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;
143 SilcUInt32 sequence = 0;
144 unsigned char *dst_id_data = NULL;
145 SilcUInt32 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;
242 SilcUInt32 sequence = 0;
243 unsigned char *dst_id_data = NULL;
244 SilcUInt32 dst_id_len = 0;
245 unsigned char *src_id_data = NULL;
246 SilcUInt32 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 SilcUInt32 clients_count,
397 SilcPacketFlags flags,
403 SilcSocketConnection sock = NULL;
404 SilcClientEntry client = NULL;
405 SilcServerEntry *routed = NULL;
406 SilcUInt32 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 SilcUInt32 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 (!sock || (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) {
691 SilcUInt32 iv_len, i;
692 SilcUInt16 dlen, flags;
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 SilcUInt32 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_memdup(data, data_len);
880 /* Decrypt the channel message (we don't check the MAC) */
881 if (channel->channel_key &&
882 !silc_channel_message_payload_decrypt(tmp, data_len,
883 channel->channel_key,
885 memset(tmp, 0, data_len);
890 /* Now re-encrypt and send it to the router */
891 silc_server_packet_send_srcdest(server, sock,
892 SILC_PACKET_CHANNEL_MESSAGE, 0,
894 channel->id, SILC_ID_CHANNEL,
895 tmp, data_len, force_send);
897 /* Free the copy of the channel message */
898 memset(tmp, 0, data_len);
901 /* Private key mode is set, we don't have the channel key, so
902 just re-encrypt the entire packet and send it to the router. */
903 silc_server_packet_send_srcdest(server, sock,
904 SILC_PACKET_CHANNEL_MESSAGE, 0,
906 channel->id, SILC_ID_CHANNEL,
907 data, data_len, force_send);
912 /* Send the packet (to normal server) */
913 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
917 data, data_len, TRUE,
926 /* Get data used in packet header encryption, keys and stuff. */
927 sock = (SilcSocketConnection)client->connection;
928 idata = (SilcIDListData)client;
930 if (!sock || (sender_sock && sock == sender_sock))
933 SILC_LOG_DEBUG(("Sending packet to client ID(%s) %s (%s)",
934 silc_id_render(client->id, SILC_ID_CLIENT),
935 sock->hostname, sock->ip));
937 /* Send the packet */
938 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
942 data, data_len, TRUE,
946 silc_hash_table_list_reset(&htl);
948 silc_free(packetdata.src_id);
949 silc_free(packetdata.dst_id);
952 /* This function is used to send packets strictly to all local clients
953 on a particular channel. This is used for example to distribute new
954 channel key to all our locally connected clients on the channel.
955 The packets are always encrypted with the session key shared between
956 the client, this means these are not _to the channel_ but _to the client_
959 void silc_server_packet_send_local_channel(SilcServer server,
960 SilcChannelEntry channel,
962 SilcPacketFlags flags,
967 SilcChannelClientEntry chl;
968 SilcHashTableList htl;
969 SilcSocketConnection sock = NULL;
971 SILC_LOG_DEBUG(("Start"));
973 /* Send the message to clients on the channel's client list. */
974 silc_hash_table_list(channel->user_list, &htl);
975 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
976 if (chl->client && !chl->client->router) {
977 sock = (SilcSocketConnection)chl->client->connection;
979 /* Send the packet to the client */
980 silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
981 SILC_ID_CLIENT, data, data_len,
985 silc_hash_table_list_reset(&htl);
988 /* Routine used to send (relay, route) private messages to some destination.
989 If the private message key does not exist then the message is re-encrypted,
990 otherwise we just pass it along. This really is not used to send new
991 private messages (as server does not send them) but to relay received
994 void silc_server_send_private_message(SilcServer server,
995 SilcSocketConnection dst_sock,
999 SilcPacketContext *packet)
1001 SilcBuffer buffer = packet->buffer;
1003 /* Re-encrypt and send if private messge key does not exist */
1004 if (!(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY)) {
1006 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1007 + packet->dst_id_len + packet->padlen);
1008 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1009 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1011 /* Re-encrypt packet */
1012 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf, buffer->len);
1014 /* Send the packet */
1015 silc_server_packet_send_real(server, dst_sock, FALSE);
1018 /* Key exist so encrypt just header and send it */
1019 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1020 + packet->dst_id_len + packet->padlen);
1021 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1022 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1024 /* Encrypt header */
1025 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf,
1026 SILC_PACKET_HEADER_LEN + packet->src_id_len +
1027 packet->dst_id_len + packet->padlen);
1029 silc_server_packet_send_real(server, dst_sock, FALSE);
1033 /* Sends current motd to client */
1035 void silc_server_send_motd(SilcServer server,
1036 SilcSocketConnection sock)
1038 char *motd, *motd_file = NULL;
1039 SilcUInt32 motd_len;
1042 motd_file = server->config->server_info->motd_file;
1045 motd = silc_file_readfile(motd_file, &motd_len);
1049 silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
1055 /* Sends error message. Error messages may or may not have any
1058 void silc_server_send_error(SilcServer server,
1059 SilcSocketConnection sock,
1060 const char *fmt, ...)
1063 unsigned char buf[4096];
1065 memset(buf, 0, sizeof(buf));
1067 vsprintf(buf, fmt, ap);
1070 silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
1071 buf, strlen(buf), FALSE);
1074 /* Sends notify message. If format is TRUE the variable arguments are
1075 formatted and the formatted string is sent as argument payload. If it is
1076 FALSE then each argument is sent as separate argument and their format
1077 in the argument list must be { argument data, argument length }. */
1079 void silc_server_send_notify(SilcServer server,
1080 SilcSocketConnection sock,
1082 SilcNotifyType type,
1083 SilcUInt32 argc, ...)
1090 packet = silc_notify_payload_encode(type, argc, ap);
1091 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1092 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1093 packet->data, packet->len, FALSE);
1095 /* Send to backup routers if this is being broadcasted to primary
1097 if (server->router && server->router->connection &&
1098 sock == server->router->connection && broadcast)
1099 silc_server_backup_send(server, NULL, SILC_PACKET_NOTIFY, 0,
1100 packet->data, packet->len, FALSE, TRUE);
1102 silc_buffer_free(packet);
1106 /* Sends notify message and gets the arguments from the `args' Argument
1109 void silc_server_send_notify_args(SilcServer server,
1110 SilcSocketConnection sock,
1112 SilcNotifyType type,
1118 packet = silc_notify_payload_encode_args(type, argc, args);
1119 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1120 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1121 packet->data, packet->len, FALSE);
1122 silc_buffer_free(packet);
1125 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
1126 `old_id' with the `new_id'. */
1128 void silc_server_send_notify_channel_change(SilcServer server,
1129 SilcSocketConnection sock,
1131 SilcChannelID *old_id,
1132 SilcChannelID *new_id)
1134 SilcBuffer idp1, idp2;
1136 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
1137 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
1139 silc_server_send_notify(server, sock, broadcast,
1140 SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
1141 2, idp1->data, idp1->len, idp2->data, idp2->len);
1142 silc_buffer_free(idp1);
1143 silc_buffer_free(idp2);
1146 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
1147 `old_id' with the `new_id'. */
1149 void silc_server_send_notify_nick_change(SilcServer server,
1150 SilcSocketConnection sock,
1152 SilcClientID *old_id,
1153 SilcClientID *new_id)
1155 SilcBuffer idp1, idp2;
1157 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
1158 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
1160 silc_server_send_notify(server, sock, broadcast,
1161 SILC_NOTIFY_TYPE_NICK_CHANGE,
1162 2, idp1->data, idp1->len, idp2->data, idp2->len);
1163 silc_buffer_free(idp1);
1164 silc_buffer_free(idp2);
1167 /* Sends JOIN notify type. This tells that new client by `client_id' ID
1168 has joined to the `channel'. */
1170 void silc_server_send_notify_join(SilcServer server,
1171 SilcSocketConnection sock,
1173 SilcChannelEntry channel,
1174 SilcClientID *client_id)
1176 SilcBuffer idp1, idp2;
1178 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1179 idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1180 silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
1181 2, idp1->data, idp1->len,
1182 idp2->data, idp2->len);
1183 silc_buffer_free(idp1);
1184 silc_buffer_free(idp2);
1187 /* Sends LEAVE notify type. This tells that `client_id' has left the
1188 `channel'. The Notify packet is always destined to the channel. */
1190 void silc_server_send_notify_leave(SilcServer server,
1191 SilcSocketConnection sock,
1193 SilcChannelEntry channel,
1194 SilcClientID *client_id)
1198 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1199 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1200 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
1201 1, idp->data, idp->len);
1202 silc_buffer_free(idp);
1205 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
1206 `channel' mode to `mode. The Notify packet is always destined to
1209 void silc_server_send_notify_cmode(SilcServer server,
1210 SilcSocketConnection sock,
1212 SilcChannelEntry channel,
1213 SilcUInt32 mode_mask,
1214 void *id, SilcIdType id_type,
1215 char *cipher, char *hmac,
1219 unsigned char mode[4];
1221 idp = silc_id_payload_encode((void *)id, id_type);
1222 SILC_PUT32_MSB(mode_mask, mode);
1224 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1225 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
1226 5, idp->data, idp->len,
1228 cipher, cipher ? strlen(cipher) : 0,
1229 hmac, hmac ? strlen(hmac) : 0,
1230 passphrase, passphrase ?
1231 strlen(passphrase) : 0);
1232 silc_buffer_free(idp);
1235 /* Sends CUMODE_CHANGE notify type. This tells that `client_id' changed the
1236 `target' client's mode on `channel'. The notify packet is always
1237 destined to the channel. */
1239 void silc_server_send_notify_cumode(SilcServer server,
1240 SilcSocketConnection sock,
1242 SilcChannelEntry channel,
1243 SilcUInt32 mode_mask,
1244 void *id, SilcIdType id_type,
1245 SilcClientID *target)
1247 SilcBuffer idp1, idp2;
1248 unsigned char mode[4];
1250 idp1 = silc_id_payload_encode((void *)id, id_type);
1251 idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
1252 SILC_PUT32_MSB(mode_mask, mode);
1254 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1256 SILC_NOTIFY_TYPE_CUMODE_CHANGE, 3,
1257 idp1->data, idp1->len,
1259 idp2->data, idp2->len);
1260 silc_buffer_free(idp1);
1261 silc_buffer_free(idp2);
1264 /* Sends SIGNOFF notify type. This tells that `client_id' client has
1265 left SILC network. This function is used only between server and router
1266 traffic. This is not used to send the notify to the channel for
1267 client. The `message may be NULL. */
1269 void silc_server_send_notify_signoff(SilcServer server,
1270 SilcSocketConnection sock,
1272 SilcClientID *client_id,
1273 const char *message)
1277 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1278 silc_server_send_notify(server, sock, broadcast,
1279 SILC_NOTIFY_TYPE_SIGNOFF,
1280 message ? 2 : 1, idp->data, idp->len,
1281 message, message ? strlen(message): 0);
1282 silc_buffer_free(idp);
1285 /* Sends TOPIC_SET notify type. This tells that `id' changed
1286 the `channel's topic to `topic'. The Notify packet is always destined
1287 to the channel. This function is used to send the topic set notifies
1290 void silc_server_send_notify_topic_set(SilcServer server,
1291 SilcSocketConnection sock,
1293 SilcChannelEntry channel,
1294 void *id, SilcIdType id_type,
1299 idp = silc_id_payload_encode(id, id_type);
1300 silc_server_send_notify_dest(server, sock, broadcast,
1301 (void *)channel->id, SILC_ID_CHANNEL,
1302 SILC_NOTIFY_TYPE_TOPIC_SET,
1304 idp->data, idp->len,
1305 topic, topic ? strlen(topic) : 0);
1306 silc_buffer_free(idp);
1309 /* Send KICKED notify type. This tells that the `client_id' on `channel'
1310 was kicked off the channel. The `comment' may indicate the reason
1311 for the kicking. This function is used only between server and router
1314 void silc_server_send_notify_kicked(SilcServer server,
1315 SilcSocketConnection sock,
1317 SilcChannelEntry channel,
1318 SilcClientID *client_id,
1319 SilcClientID *kicker,
1325 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1326 idp2 = silc_id_payload_encode((void *)kicker, SILC_ID_CLIENT);
1327 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1328 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED, 3,
1329 idp1->data, idp1->len,
1330 comment, comment ? strlen(comment) : 0,
1331 idp2->data, idp2->len);
1332 silc_buffer_free(idp1);
1333 silc_buffer_free(idp2);
1336 /* Send KILLED notify type. This tells that the `client_id' client was
1337 killed from the network. The `comment' may indicate the reason
1340 void silc_server_send_notify_killed(SilcServer server,
1341 SilcSocketConnection sock,
1343 SilcClientID *client_id,
1348 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1349 silc_server_send_notify_dest(server, sock, broadcast, (void *)client_id,
1350 SILC_ID_CLIENT, SILC_NOTIFY_TYPE_KILLED,
1351 comment ? 2 : 1, idp->data, idp->len,
1352 comment, comment ? strlen(comment) : 0);
1353 silc_buffer_free(idp);
1356 /* Sends UMODE_CHANGE notify type. This tells that `client_id' client's
1357 user mode in the SILC Network was changed. This function is used to
1358 send the packet between routers as broadcast packet. */
1360 void silc_server_send_notify_umode(SilcServer server,
1361 SilcSocketConnection sock,
1363 SilcClientID *client_id,
1364 SilcUInt32 mode_mask)
1367 unsigned char mode[4];
1369 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1370 SILC_PUT32_MSB(mode_mask, mode);
1372 silc_server_send_notify(server, sock, broadcast,
1373 SILC_NOTIFY_TYPE_UMODE_CHANGE, 2,
1374 idp->data, idp->len,
1376 silc_buffer_free(idp);
1379 /* Sends BAN notify type. This tells that ban has been either `add'ed
1380 or `del'eted on the `channel. This function is used to send the packet
1381 between routers as broadcast packet. */
1383 void silc_server_send_notify_ban(SilcServer server,
1384 SilcSocketConnection sock,
1386 SilcChannelEntry channel,
1387 char *add, char *del)
1391 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1392 silc_server_send_notify(server, sock, broadcast,
1393 SILC_NOTIFY_TYPE_BAN, 3,
1394 idp->data, idp->len,
1395 add, add ? strlen(add) : 0,
1396 del, del ? strlen(del) : 0);
1397 silc_buffer_free(idp);
1400 /* Sends INVITE notify type. This tells that invite has been either `add'ed
1401 or `del'eted on the `channel. The sender of the invite is the `client_id'.
1402 This function is used to send the packet between routers as broadcast
1405 void silc_server_send_notify_invite(SilcServer server,
1406 SilcSocketConnection sock,
1408 SilcChannelEntry channel,
1409 SilcClientID *client_id,
1410 char *add, char *del)
1412 SilcBuffer idp, idp2;
1414 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1415 idp2 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1416 silc_server_send_notify(server, sock, broadcast,
1417 SILC_NOTIFY_TYPE_INVITE, 5,
1418 idp->data, idp->len,
1419 channel->channel_name, strlen(channel->channel_name),
1420 idp2->data, idp2->len,
1421 add, add ? strlen(add) : 0,
1422 del, del ? strlen(del) : 0);
1423 silc_buffer_free(idp);
1424 silc_buffer_free(idp2);
1427 /* Sends notify message destined to specific entity. */
1429 void silc_server_send_notify_dest(SilcServer server,
1430 SilcSocketConnection sock,
1433 SilcIdType dest_id_type,
1434 SilcNotifyType type,
1435 SilcUInt32 argc, ...)
1442 packet = silc_notify_payload_encode(type, argc, ap);
1443 silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY,
1444 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1445 dest_id, dest_id_type,
1446 packet->data, packet->len, FALSE);
1447 silc_buffer_free(packet);
1451 /* Sends notify message to a channel. The notify message sent is
1452 distributed to all clients on the channel. If `route_notify' is TRUE
1453 then the notify may be routed to primary route or to some other routers.
1454 If FALSE it is assured that the notify is sent only locally. If `sender'
1455 is provided then the packet is not sent to that connection since it
1456 originally came from it. */
1458 void silc_server_send_notify_to_channel(SilcServer server,
1459 SilcSocketConnection sender,
1460 SilcChannelEntry channel,
1462 SilcNotifyType type,
1463 SilcUInt32 argc, ...)
1470 packet = silc_notify_payload_encode(type, argc, ap);
1471 silc_server_packet_send_to_channel(server, sender, channel,
1472 SILC_PACKET_NOTIFY, route_notify,
1473 packet->data, packet->len, FALSE);
1474 silc_buffer_free(packet);
1478 /* Send notify message to all channels the client has joined. It is quaranteed
1479 that the message is sent only once to a client (ie. if a client is joined
1480 on two same channel it will receive only one notify message). Also, this
1481 sends only to local clients (locally connected if we are server, and to
1482 local servers if we are router). If `sender' is provided the packet is
1483 not sent to that client at all. */
1485 void silc_server_send_notify_on_channels(SilcServer server,
1486 SilcClientEntry sender,
1487 SilcClientEntry client,
1488 SilcNotifyType type,
1489 SilcUInt32 argc, ...)
1492 SilcSocketConnection sock = NULL;
1493 SilcPacketContext packetdata;
1495 SilcClientEntry *sent_clients = NULL;
1496 SilcUInt32 sent_clients_count = 0;
1497 SilcServerEntry *routed = NULL;
1498 SilcUInt32 routed_count = 0;
1499 SilcHashTableList htl, htl2;
1500 SilcChannelEntry channel;
1501 SilcChannelClientEntry chl, chl2;
1502 SilcIDListData idata;
1504 unsigned char *data;
1505 SilcUInt32 data_len;
1506 bool force_send = FALSE;
1509 SILC_LOG_DEBUG(("Start"));
1511 if (!silc_hash_table_count(client->channels))
1515 packet = silc_notify_payload_encode(type, argc, ap);
1516 data = packet->data;
1517 data_len = packet->len;
1519 /* Set the packet context pointers. */
1520 packetdata.flags = 0;
1521 packetdata.type = SILC_PACKET_NOTIFY;
1522 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1523 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
1524 packetdata.src_id_type = SILC_ID_SERVER;
1526 silc_hash_table_list(client->channels, &htl);
1527 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
1528 channel = chl->channel;
1530 /* Send the message to all clients on the channel's client list. */
1531 silc_hash_table_list(channel->user_list, &htl2);
1532 while (silc_hash_table_get(&htl2, NULL, (void *)&chl2)) {
1535 if (sender && c == sender)
1538 /* Check if we have sent the packet to this client already */
1539 for (k = 0; k < sent_clients_count; k++)
1540 if (sent_clients[k] == c)
1542 if (k < sent_clients_count)
1545 /* If we are router and if this client has router set it is not
1546 locally connected client and we will route the message to the
1547 router set in the client. */
1548 if (c && c->router && server->server_type == SILC_ROUTER) {
1549 /* Check if we have sent the packet to this route already */
1550 for (k = 0; k < routed_count; k++)
1551 if (routed[k] == c->router)
1553 if (k < routed_count)
1556 /* Get data used in packet header encryption, keys and stuff. */
1557 sock = (SilcSocketConnection)c->router->connection;
1558 idata = (SilcIDListData)c->router;
1561 SILC_LOG_DEBUG(("*****************"));
1562 SILC_LOG_DEBUG(("client->router->id %s",
1563 silc_id_render(c->router->id, SILC_ID_SERVER)));
1564 SILC_LOG_DEBUG(("client->router->connection->user_data->id %s",
1565 silc_id_render(((SilcServerEntry)sock->user_data)->id, SILC_ID_SERVER)));
1568 packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1569 packetdata.dst_id_len = silc_id_get_len(c->router->id, SILC_ID_SERVER);
1570 packetdata.dst_id_type = SILC_ID_SERVER;
1572 /* Send the packet */
1573 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1577 data, data_len, FALSE,
1580 silc_free(packetdata.dst_id);
1582 /* We want to make sure that the packet is routed to same router
1583 only once. Mark this route as sent route. */
1584 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
1585 routed[routed_count++] = c->router;
1592 /* Send to locally connected client */
1595 /* Get data used in packet header encryption, keys and stuff. */
1596 sock = (SilcSocketConnection)c->connection;
1597 idata = (SilcIDListData)c;
1602 packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1603 packetdata.dst_id_len = silc_id_get_len(c->id, SILC_ID_CLIENT);
1604 packetdata.dst_id_type = SILC_ID_CLIENT;
1606 /* Send the packet */
1607 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1611 data, data_len, FALSE,
1614 silc_free(packetdata.dst_id);
1616 /* Make sure that we send the notify only once per client. */
1617 sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1618 (sent_clients_count + 1));
1619 sent_clients[sent_clients_count++] = c;
1622 silc_hash_table_list_reset(&htl2);
1625 silc_hash_table_list_reset(&htl);
1627 silc_free(sent_clients);
1628 silc_free(packetdata.src_id);
1629 silc_buffer_free(packet);
1633 /* Sends New ID Payload to remote end. The packet is used to distribute
1634 information about new registered clients, servers, channel etc. usually
1635 to routers so that they can keep these information up to date.
1636 If the argument `broadcast' is TRUE then the packet is sent as
1637 broadcast packet. */
1639 void silc_server_send_new_id(SilcServer server,
1640 SilcSocketConnection sock,
1642 void *id, SilcIdType id_type,
1647 SILC_LOG_DEBUG(("Start"));
1649 idp = silc_id_payload_encode(id, id_type);
1650 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1651 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1652 idp->data, idp->len, FALSE);
1654 /* Send to backup routers if this is being broadcasted to primary
1656 if (server->router && server->router->connection &&
1657 sock == server->router->connection && broadcast)
1658 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0,
1659 idp->data, idp->len, FALSE, TRUE);
1661 silc_buffer_free(idp);
1664 /* Send New Channel Payload to notify about newly created channel in the
1665 SILC network. Router uses this to notify other routers in the network
1666 about new channel. This packet is broadcasted by router. */
1668 void silc_server_send_new_channel(SilcServer server,
1669 SilcSocketConnection sock,
1673 SilcUInt32 channel_id_len,
1678 SilcUInt32 name_len = strlen(channel_name);
1680 SILC_LOG_DEBUG(("Start"));
1682 cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1686 /* Encode the channel payload */
1687 packet = silc_channel_payload_encode(channel_name, name_len,
1688 cid, channel_id_len, mode);
1690 silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1691 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1692 packet->data, packet->len, FALSE);
1694 /* Send to backup routers if this is being broadcasted to primary
1696 if (server->server_type == SILC_ROUTER &&
1697 server->router && server->router->connection &&
1698 sock == server->router->connection && broadcast)
1699 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
1700 packet->data, packet->len, FALSE, TRUE);
1703 silc_buffer_free(packet);
1706 /* Send Channel Key payload to distribute the new channel key. Normal server
1707 sends this to router when new client joins to existing channel. Router
1708 sends this to the local server who sent the join command in case where
1709 the channel did not exist yet. Both normal and router servers uses this
1710 also to send this to locally connected clients on the channel. This
1711 must not be broadcasted packet. Routers do not send this to each other.
1712 If `sender is provided then the packet is not sent to that connection since
1713 it originally came from it. */
1715 void silc_server_send_channel_key(SilcServer server,
1716 SilcSocketConnection sender,
1717 SilcChannelEntry channel,
1718 unsigned char route)
1721 unsigned char *chid;
1724 SILC_LOG_DEBUG(("Sending key to channel %s", channel->channel_name));
1726 chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1730 /* Encode channel key packet */
1731 tmp_len = strlen(channel->channel_key->cipher->name);
1732 packet = silc_channel_key_payload_encode(silc_id_get_len(channel->id,
1735 channel->channel_key->cipher->name,
1736 channel->key_len / 8, channel->key);
1737 silc_server_packet_send_to_channel(server, sender, channel,
1738 SILC_PACKET_CHANNEL_KEY,
1739 route, packet->data, packet->len,
1741 silc_buffer_free(packet);
1745 /* Generic function to send any command. The arguments must be sent already
1746 encoded into correct form in correct order. */
1748 void silc_server_send_command(SilcServer server,
1749 SilcSocketConnection sock,
1750 SilcCommand command,
1752 SilcUInt32 argc, ...)
1759 packet = silc_command_payload_encode_vap(command, ident, argc, ap);
1760 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1761 packet->data, packet->len, TRUE);
1762 silc_buffer_free(packet);
1766 /* Generic function to send any command reply. The arguments must be sent
1767 already encoded into correct form in correct order. */
1769 void silc_server_send_command_reply(SilcServer server,
1770 SilcSocketConnection sock,
1771 SilcCommand command,
1772 SilcCommandStatus status,
1774 SilcUInt32 argc, ...)
1781 packet = silc_command_reply_payload_encode_vap(command, status, ident,
1783 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1784 packet->data, packet->len, TRUE);
1785 silc_buffer_free(packet);
1789 /* Generic function to send any command reply. The arguments must be sent
1790 already encoded into correct form in correct order. */
1792 void silc_server_send_dest_command_reply(SilcServer server,
1793 SilcSocketConnection sock,
1795 SilcIdType dst_id_type,
1796 SilcCommand command,
1797 SilcCommandStatus status,
1799 SilcUInt32 argc, ...)
1806 packet = silc_command_reply_payload_encode_vap(command, status, ident,
1808 silc_server_packet_send_dest(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1809 dst_id, dst_id_type, packet->data,
1811 silc_buffer_free(packet);
1815 /* Send the heartbeat packet. */
1817 void silc_server_send_heartbeat(SilcServer server,
1818 SilcSocketConnection sock)
1820 silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1824 /* Generic function to relay packet we've received. This is used to relay
1825 packets to a client but generally can be used to other purposes as well. */
1827 void silc_server_relay_packet(SilcServer server,
1828 SilcSocketConnection dst_sock,
1831 SilcUInt32 sequence,
1832 SilcPacketContext *packet,
1835 silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1836 + packet->dst_id_len + packet->padlen);
1838 silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len);
1839 silc_buffer_put(dst_sock->outbuf, packet->buffer->data, packet->buffer->len);
1841 /* Re-encrypt packet */
1842 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf,
1843 packet->buffer->len);
1845 /* Send the packet */
1846 silc_server_packet_send_real(server, dst_sock, force_send);
1848 silc_buffer_pull(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1849 + packet->dst_id_len + packet->padlen);
1852 /* Routine used to send the connection authentication packet. */
1854 void silc_server_send_connection_auth_request(SilcServer server,
1855 SilcSocketConnection sock,
1856 SilcUInt16 conn_type,
1857 SilcAuthMethod auth_meth)
1861 packet = silc_buffer_alloc(4);
1862 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1863 silc_buffer_format(packet,
1864 SILC_STR_UI_SHORT(conn_type),
1865 SILC_STR_UI_SHORT(auth_meth),
1868 silc_server_packet_send(server, sock, SILC_PACKET_CONNECTION_AUTH_REQUEST,
1869 0, packet->data, packet->len, FALSE);
1870 silc_buffer_free(packet);
1873 /* Purge the outgoing packet queue to the network if there is data. This
1874 function can be used to empty the packet queue. It is guaranteed that
1875 after this function returns the outgoing data queue is empty. */
1877 void silc_server_packet_queue_purge(SilcServer server,
1878 SilcSocketConnection sock)
1880 if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
1881 (SILC_IS_DISCONNECTED(sock) == FALSE)) {
1882 server->stat.packets_sent++;
1884 if (sock->outbuf->data - sock->outbuf->head)
1885 silc_buffer_push(sock->outbuf, sock->outbuf->data - sock->outbuf->head);
1887 silc_packet_send(sock, TRUE);
1889 SILC_SET_CONNECTION_FOR_INPUT(server->schedule, sock->sock);
1890 SILC_UNSET_OUTBUF_PENDING(sock);
1891 silc_buffer_clear(sock->outbuf);