5 Author: Pekka Riikonen <priikone@silcnet.org>
7 Copyright (C) 1997 - 2001 Pekka Riikonen
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
21 * Server packet routines to send packets.
25 #include "serverincludes.h"
26 #include "server_internal.h"
28 /* Routine that sends packet or marks packet to be sent. This is used
29 directly only in special cases. Normal cases should use
30 silc_server_packet_send. Returns < 0 error. */
32 int silc_server_packet_send_real(SilcServer server,
33 SilcSocketConnection sock,
38 /* If disconnecting, ignore the data */
39 if (SILC_IS_DISCONNECTING(sock))
42 /* If rekey protocol is active we must assure that all packets are
43 sent through packet queue. */
44 if (SILC_SERVER_IS_REKEY(sock))
47 /* If outbound data is already pending do not force send */
48 if (SILC_IS_OUTBUF_PENDING(sock))
52 ret = silc_packet_send(sock, force_send);
56 /* Mark that there is some outgoing data available for this connection.
57 This call sets the connection both for input and output (the input
58 is set always and this call keeps the input setting, actually).
59 Actual data sending is performed by silc_server_packet_process. */
60 SILC_SET_CONNECTION_FOR_OUTPUT(server->schedule, sock->sock);
62 /* Mark to socket that data is pending in outgoing buffer. This flag
63 is needed if new data is added to the buffer before the earlier
64 put data is sent to the network. */
65 SILC_SET_OUTBUF_PENDING(sock);
70 /* Assembles a new packet to be sent out to network. This doesn't actually
71 send the packet but creates the packet and fills the outgoing data
72 buffer and marks the packet ready to be sent to network. However, If
73 argument force_send is TRUE the packet is sent immediately and not put
74 to queue. Normal case is that the packet is not sent immediately. */
76 void silc_server_packet_send(SilcServer server,
77 SilcSocketConnection sock,
79 SilcPacketFlags flags,
85 SilcIdType dst_id_type = SILC_ID_NONE;
86 SilcIDListData idata = (SilcIDListData)sock->user_data;
91 /* If disconnecting, ignore the data */
92 if (SILC_IS_DISCONNECTING(sock))
95 /* If entry is disabled do not sent anything. */
96 if (idata && idata->status & SILC_IDLIST_STATUS_DISABLED)
99 /* Get data used in the packet sending, keys and stuff */
101 case SILC_SOCKET_TYPE_CLIENT:
102 if (sock->user_data) {
103 dst_id = ((SilcClientEntry)sock->user_data)->id;
104 dst_id_type = SILC_ID_CLIENT;
107 case SILC_SOCKET_TYPE_SERVER:
108 case SILC_SOCKET_TYPE_ROUTER:
109 if (sock->user_data) {
110 dst_id = ((SilcServerEntry)sock->user_data)->id;
111 dst_id_type = SILC_ID_SERVER;
118 silc_server_packet_send_dest(server, sock, type, flags, dst_id,
119 dst_id_type, data, data_len, force_send);
122 /* Assembles a new packet to be sent out to network. This doesn't actually
123 send the packet but creates the packet and fills the outgoing data
124 buffer and marks the packet ready to be sent to network. However, If
125 argument force_send is TRUE the packet is sent immediately and not put
126 to queue. Normal case is that the packet is not sent immediately.
127 Destination information is sent as argument for this function. */
129 void silc_server_packet_send_dest(SilcServer server,
130 SilcSocketConnection sock,
132 SilcPacketFlags flags,
134 SilcIdType dst_id_type,
139 SilcPacketContext packetdata;
140 SilcIDListData idata = (SilcIDListData)sock->user_data;
141 SilcCipher cipher = NULL;
142 SilcHmac hmac = NULL;
144 unsigned char *dst_id_data = NULL;
145 uint32 dst_id_len = 0;
148 /* If disconnecting, ignore the data */
149 if (SILC_IS_DISCONNECTING(sock))
152 /* If entry is disabled do not sent anything. */
153 if (idata && idata->status & SILC_IDLIST_STATUS_DISABLED)
156 SILC_LOG_DEBUG(("Sending packet, type %d", type));
159 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
160 dst_id_len = silc_id_get_len(dst_id, dst_id_type);
164 cipher = idata->send_key;
165 hmac = idata->hmac_send;
166 sequence = idata->psn_send++;
167 block_len = silc_cipher_get_block_len(cipher);
170 /* Set the packet context pointers */
171 packetdata.type = type;
172 packetdata.flags = flags;
173 packetdata.src_id = silc_id_id2str(server->id, server->id_type);
174 packetdata.src_id_len = silc_id_get_len(server->id, server->id_type);
175 packetdata.src_id_type = server->id_type;
176 packetdata.dst_id = dst_id_data;
177 packetdata.dst_id_len = dst_id_len;
178 packetdata.dst_id_type = dst_id_type;
179 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
180 packetdata.src_id_len + dst_id_len;
181 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen, block_len);
183 /* Prepare outgoing data buffer for packet sending */
184 silc_packet_send_prepare(sock,
185 SILC_PACKET_HEADER_LEN +
186 packetdata.src_id_len +
187 packetdata.dst_id_len,
191 SILC_LOG_DEBUG(("Putting data to outgoing buffer, len %d", data_len));
193 packetdata.buffer = sock->outbuf;
195 /* Put the data to the buffer */
196 if (data && data_len)
197 silc_buffer_put(sock->outbuf, data, data_len);
199 /* Create the outgoing packet */
200 silc_packet_assemble(&packetdata, cipher);
202 /* Encrypt the packet */
203 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf, sock->outbuf->len);
205 SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence,
207 sock->outbuf->data, sock->outbuf->len);
209 /* Now actually send the packet */
210 silc_server_packet_send_real(server, sock, force_send);
212 if (packetdata.src_id)
213 silc_free(packetdata.src_id);
214 if (packetdata.dst_id)
215 silc_free(packetdata.dst_id);
218 /* Assembles a new packet to be sent out to network. This doesn't actually
219 send the packet but creates the packet and fills the outgoing data
220 buffer and marks the packet ready to be sent to network. However, If
221 argument force_send is TRUE the packet is sent immediately and not put
222 to queue. Normal case is that the packet is not sent immediately.
223 The source and destination information is sent as argument for this
226 void silc_server_packet_send_srcdest(SilcServer server,
227 SilcSocketConnection sock,
229 SilcPacketFlags flags,
231 SilcIdType src_id_type,
233 SilcIdType dst_id_type,
238 SilcPacketContext packetdata;
239 SilcIDListData idata;
240 SilcCipher cipher = NULL;
241 SilcHmac hmac = NULL;
243 unsigned char *dst_id_data = NULL;
244 uint32 dst_id_len = 0;
245 unsigned char *src_id_data = NULL;
246 uint32 src_id_len = 0;
249 SILC_LOG_DEBUG(("Sending packet, type %d", type));
251 /* Get data used in the packet sending, keys and stuff */
252 idata = (SilcIDListData)sock->user_data;
255 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
256 dst_id_len = silc_id_get_len(dst_id, dst_id_type);
260 src_id_data = silc_id_id2str(src_id, src_id_type);
261 src_id_len = silc_id_get_len(src_id, src_id_type);
265 cipher = idata->send_key;
266 hmac = idata->hmac_send;
267 sequence = idata->psn_send++;
268 block_len = silc_cipher_get_block_len(cipher);
271 /* Set the packet context pointers */
272 packetdata.type = type;
273 packetdata.flags = flags;
274 packetdata.src_id = src_id_data;
275 packetdata.src_id_len = src_id_len;
276 packetdata.src_id_type = src_id_type;
277 packetdata.dst_id = dst_id_data;
278 packetdata.dst_id_len = dst_id_len;
279 packetdata.dst_id_type = dst_id_type;
280 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
281 packetdata.src_id_len + dst_id_len;
282 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen, block_len);
284 /* Prepare outgoing data buffer for packet sending */
285 silc_packet_send_prepare(sock,
286 SILC_PACKET_HEADER_LEN +
287 packetdata.src_id_len +
288 packetdata.dst_id_len,
292 SILC_LOG_DEBUG(("Putting data to outgoing buffer, len %d", data_len));
294 packetdata.buffer = sock->outbuf;
296 /* Put the data to the buffer */
297 if (data && data_len)
298 silc_buffer_put(sock->outbuf, data, data_len);
300 /* Create the outgoing packet */
301 silc_packet_assemble(&packetdata, cipher);
303 /* Encrypt the packet */
304 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf, sock->outbuf->len);
306 SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence,
308 sock->outbuf->data, sock->outbuf->len);
310 /* Now actually send the packet */
311 silc_server_packet_send_real(server, sock, force_send);
313 if (packetdata.src_id)
314 silc_free(packetdata.src_id);
315 if (packetdata.dst_id)
316 silc_free(packetdata.dst_id);
319 /* Broadcast received packet to our primary route. This function is used
320 by router to further route received broadcast packet. It is expected
321 that the broadcast flag from the packet is checked before calling this
322 function. This does not test or set the broadcast flag. */
324 void silc_server_packet_broadcast(SilcServer server,
325 SilcSocketConnection sock,
326 SilcPacketContext *packet)
328 SilcBuffer buffer = packet->buffer;
329 SilcIDListData idata;
332 SILC_LOG_DEBUG(("Broadcasting received broadcast packet"));
334 /* If the packet is originated from our primary route we are
335 not allowed to send the packet. */
336 id = silc_id_str2id(packet->src_id, packet->src_id_len, packet->src_id_type);
337 if (id && !SILC_ID_SERVER_COMPARE(id, server->router->id)) {
338 idata = (SilcIDListData)sock->user_data;
340 silc_buffer_push(buffer, buffer->data - buffer->head);
341 silc_packet_send_prepare(sock, 0, 0, buffer->len);
342 silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
343 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
344 sock->outbuf, sock->outbuf->len);
346 SILC_LOG_HEXDUMP(("Broadcasted packet (%d), len %d", idata->psn_send - 1,
348 sock->outbuf->data, sock->outbuf->len);
350 /* Now actually send the packet */
351 silc_server_packet_send_real(server, sock, TRUE);
356 SILC_LOG_DEBUG(("Will not broadcast to primary route since it is the "
357 "original sender of this packet"));
361 /* Routes received packet to `sock'. This is used to route the packets that
362 router receives but are not destined to it. */
364 void silc_server_packet_route(SilcServer server,
365 SilcSocketConnection sock,
366 SilcPacketContext *packet)
368 SilcBuffer buffer = packet->buffer;
369 SilcIDListData idata;
371 SILC_LOG_DEBUG(("Routing received packet"));
373 idata = (SilcIDListData)sock->user_data;
375 silc_buffer_push(buffer, buffer->data - buffer->head);
376 silc_packet_send_prepare(sock, 0, 0, buffer->len);
377 silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
378 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
379 sock->outbuf, sock->outbuf->len);
381 SILC_LOG_HEXDUMP(("Routed packet (%d), len %d", idata->psn_send - 1,
383 sock->outbuf->data, sock->outbuf->len);
385 /* Now actually send the packet */
386 silc_server_packet_send_real(server, sock, TRUE);
389 /* This routine can be used to send a packet to table of clients provided
390 in `clients'. If `route' is FALSE the packet is routed only to local
391 clients (for server locally connected, and for router local cell). */
393 void silc_server_packet_send_clients(SilcServer server,
394 SilcClientEntry *clients,
395 uint32 clients_count,
397 SilcPacketFlags flags,
403 SilcSocketConnection sock = NULL;
404 SilcClientEntry client = NULL;
405 SilcServerEntry *routed = NULL;
406 uint32 routed_count = 0;
410 SILC_LOG_DEBUG(("Sending packet to list of clients"));
412 /* Send to all clients in table */
413 for (i = 0; i < clients_count; i++) {
416 /* If client has router set it is not locally connected client and
417 we will route the message to the router set in the client. Though,
418 send locally connected server in all cases. */
419 if (server->server_type == SILC_ROUTER && client->router &&
420 ((!route && client->router->router == server->id_entry) || route)) {
422 /* Check if we have sent the packet to this route already */
423 for (k = 0; k < routed_count; k++)
424 if (routed[k] == client->router)
426 if (k < routed_count)
429 /* Route only once to router */
430 sock = (SilcSocketConnection)client->router->connection;
431 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
437 /* Send the packet */
438 silc_server_packet_send_dest(server, sock, type, flags,
439 client->router->id, SILC_ID_SERVER,
440 data, data_len, force_send);
442 /* Mark this route routed already */
443 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
444 routed[routed_count++] = client->router;
451 /* Send to locally connected client */
452 sock = (SilcSocketConnection)client->connection;
453 silc_server_packet_send_dest(server, sock, type, flags,
454 client->id, SILC_ID_CLIENT,
455 data, data_len, force_send);
461 /* Internal routine to actually create the channel packet and send it
462 to network. This is common function in channel message sending. If
463 `channel_message' is TRUE this encrypts the message as it is strictly
464 a channel message. If FALSE normal encryption process is used. */
467 silc_server_packet_send_to_channel_real(SilcServer server,
468 SilcSocketConnection sock,
469 SilcPacketContext *packet,
475 bool channel_message,
483 packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
484 packet->src_id_len + packet->dst_id_len;
486 block_len = cipher ? silc_cipher_get_block_len(cipher) : 0;
488 packet->padlen = SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
490 packet->dst_id_len), block_len);
492 packet->padlen = SILC_PACKET_PADLEN(packet->truelen, block_len);
494 /* Prepare outgoing data buffer for packet sending */
495 silc_packet_send_prepare(sock,
496 SILC_PACKET_HEADER_LEN +
502 packet->buffer = sock->outbuf;
504 /* Put the data to buffer, assemble and encrypt the packet. The packet
505 is encrypted with normal session key shared with the client, unless
506 the `channel_message' is TRUE. */
507 silc_buffer_put(sock->outbuf, data, data_len);
508 silc_packet_assemble(packet, cipher);
510 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf,
511 SILC_PACKET_HEADER_LEN + packet->src_id_len +
512 packet->dst_id_len + packet->padlen);
514 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf,
517 SILC_LOG_HEXDUMP(("Channel packet (%d), len %d", sequence,
519 sock->outbuf->data, sock->outbuf->len);
521 /* Now actually send the packet */
522 silc_server_packet_send_real(server, sock, force_send);
525 /* This routine is used by the server to send packets to channel. The
526 packet sent with this function is distributed to all clients on
527 the channel. Usually this is used to send notify messages to the
528 channel, things like notify about new user joining to the channel.
529 If `route' is FALSE then the packet is sent only locally and will not
530 be routed anywhere (for router locally means cell wide). If `sender'
531 is provided then the packet is not sent to that connection since it
532 originally came from it. If `send_to_clients' is FALSE then the
533 packet is not sent clients, only servers. */
535 void silc_server_packet_send_to_channel(SilcServer server,
536 SilcSocketConnection sender,
537 SilcChannelEntry channel,
544 SilcSocketConnection sock = NULL;
545 SilcPacketContext packetdata;
546 SilcClientEntry client = NULL;
547 SilcServerEntry *routed = NULL;
548 SilcChannelClientEntry chl;
549 SilcHashTableList htl;
550 SilcIDListData idata;
551 uint32 routed_count = 0;
555 /* This doesn't send channel message packets */
556 assert(type != SILC_PACKET_CHANNEL_MESSAGE);
558 SILC_LOG_DEBUG(("Sending packet to channel"));
560 /* Set the packet context pointers. */
561 packetdata.flags = 0;
562 packetdata.type = type;
563 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
564 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
565 packetdata.src_id_type = SILC_ID_SERVER;
566 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
567 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
568 packetdata.dst_id_type = SILC_ID_CHANNEL;
570 /* If there are global users in the channel we will send the message
571 first to our router for further routing. */
572 if (route && server->server_type != SILC_ROUTER && !server->standalone &&
573 channel->global_users) {
574 SilcServerEntry router;
576 /* Get data used in packet header encryption, keys and stuff. */
577 router = server->router;
578 sock = (SilcSocketConnection)router->connection;
579 idata = (SilcIDListData)router;
581 if (sock != sender) {
582 SILC_LOG_DEBUG(("Sending packet to router for routing"));
584 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
588 data, data_len, FALSE,
593 routed = silc_calloc(silc_hash_table_count(channel->user_list),
596 /* Send the message to clients on the channel's client list. */
597 silc_hash_table_list(channel->user_list, &htl);
598 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
599 client = chl->client;
603 /* If client has router set it is not locally connected client and
604 we will route the message to the router set in the client. Though,
605 send locally connected server in all cases. */
606 if (server->server_type == SILC_ROUTER && client->router &&
607 ((!route && client->router->router == server->id_entry) || route)) {
609 /* Check if we have sent the packet to this route already */
610 for (k = 0; k < routed_count; k++)
611 if (routed[k] == client->router)
613 if (k < routed_count)
616 /* Get data used in packet header encryption, keys and stuff. */
617 sock = (SilcSocketConnection)client->router->connection;
618 idata = (SilcIDListData)client->router;
620 if (sender && sock == sender)
623 /* Route only once to router */
624 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
630 /* Send the packet */
631 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
635 data, data_len, FALSE,
638 /* Mark this route routed already */
639 routed[routed_count++] = client->router;
646 /* Send to locally connected client */
648 /* Get data used in packet header encryption, keys and stuff. */
649 sock = (SilcSocketConnection)client->connection;
650 idata = (SilcIDListData)client;
652 if (sender && sock == sender)
655 /* Send the packet */
656 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
660 data, data_len, FALSE,
665 silc_free(packetdata.src_id);
666 silc_free(packetdata.dst_id);
669 /* This checks whether the relayed packet came from router. If it did
670 then we'll need to encrypt it with the channel key. This is called
671 from the silc_server_packet_relay_to_channel. */
674 silc_server_packet_relay_to_channel_encrypt(SilcServer server,
675 SilcSocketConnection sock,
676 SilcChannelEntry channel,
678 unsigned int data_len)
680 /* If we are router and the packet came from router and private key
681 has not been set for the channel then we must encrypt the packet
682 as it was decrypted with the session key shared between us and the
683 router which sent it. This is so, because cells does not share the
685 if (server->server_type == SILC_ROUTER &&
686 sock->type == SILC_SOCKET_TYPE_ROUTER &&
687 !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
688 channel->channel_key) {
693 iv_len = silc_cipher_get_block_len(channel->channel_key);
694 if (channel->iv[0] == '\0')
695 for (i = 0; i < iv_len; i++) channel->iv[i] =
696 silc_rng_get_byte(server->rng);
698 silc_hash_make(server->md5hash, channel->iv, iv_len, channel->iv);
700 /* Encode new payload. This encrypts it also. */
701 SILC_GET16_MSB(flags, data);
702 SILC_GET16_MSB(dlen, data + 2);
704 if (dlen > data_len) {
705 SILC_LOG_WARNING(("Corrupted channel message, cannot relay it"));
709 chp = silc_channel_message_payload_encode(flags, dlen, data + 4,
711 channel->channel_key,
713 memcpy(data, chp->data, chp->len);
714 silc_buffer_free(chp);
720 /* This routine is explicitly used to relay messages to some channel.
721 Packets sent with this function we have received earlier and are
722 totally encrypted. This just sends the packet to all clients on
723 the channel. If the sender of the packet is someone on the channel
724 the message will not be sent to that client. The SILC Packet header
725 is encrypted with the session key shared between us and the client.
726 MAC is also computed before encrypting the header. Rest of the
727 packet will be untouched. */
729 void silc_server_packet_relay_to_channel(SilcServer server,
730 SilcSocketConnection sender_sock,
731 SilcChannelEntry channel,
733 SilcIdType sender_type,
740 SilcSocketConnection sock = NULL;
741 SilcPacketContext packetdata;
742 SilcClientEntry client = NULL;
743 SilcServerEntry *routed = NULL;
744 SilcChannelClientEntry chl;
745 uint32 routed_count = 0;
746 SilcIDListData idata;
747 SilcHashTableList htl;
751 SILC_LOG_DEBUG(("Relaying packet to channel"));
753 /* This encrypts the packet, if needed. It will be encrypted if
754 it came from the router thus it needs to be encrypted with the
755 channel key. If the channel key does not exist, then we know we
756 don't have a single local user on the channel. */
757 if (!silc_server_packet_relay_to_channel_encrypt(server, sender_sock,
762 /* Set the packet context pointers. */
763 packetdata.flags = 0;
764 packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
765 packetdata.src_id = silc_id_id2str(sender, sender_type);
766 packetdata.src_id_len = silc_id_get_len(sender, sender_type);
767 packetdata.src_id_type = sender_type;
768 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
769 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
770 packetdata.dst_id_type = SILC_ID_CHANNEL;
772 /* If there are global users in the channel we will send the message
773 first to our router for further routing. */
774 if (server->server_type != SILC_ROUTER && !server->standalone &&
775 channel->global_users) {
776 SilcServerEntry router = server->router;
778 /* Check that the sender is not our router. */
779 if (sender_sock != (SilcSocketConnection)router->connection) {
781 /* Get data used in packet header encryption, keys and stuff. */
782 sock = (SilcSocketConnection)router->connection;
783 idata = (SilcIDListData)router;
785 SILC_LOG_DEBUG(("Sending channel message to router for routing"));
787 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
791 data, data_len, TRUE,
796 routed = silc_calloc(silc_hash_table_count(channel->user_list),
799 /* Mark that to the route the original sender if from is not routed */
800 if (sender_type == SILC_ID_CLIENT) {
801 client = (SilcClientEntry)sender_entry;
802 if (client->router) {
803 routed[routed_count++] = client->router;
804 SILC_LOG_DEBUG(("************* router %s",
805 silc_id_render(client->router->id, SILC_ID_SERVER)));
809 /* Send the message to clients on the channel's client list. */
810 silc_hash_table_list(channel->user_list, &htl);
811 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
812 client = chl->client;
816 /* Do not send to the sender */
817 if (!found && client == sender_entry) {
822 /* If the client has set router it means that it is not locally
823 connected client and we will route the packet further. */
824 if (server->server_type == SILC_ROUTER && client->router) {
826 /* Sender maybe server as well so we want to make sure that
827 we won't send the message to the server it came from. */
828 if (!found && SILC_ID_SERVER_COMPARE(client->router->id, sender)) {
830 routed[routed_count++] = client->router;
834 /* Check if we have sent the packet to this route already */
835 for (k = 0; k < routed_count; k++)
836 if (routed[k] == client->router)
838 if (k < routed_count)
841 /* Get data used in packet header encryption, keys and stuff. */
842 sock = (SilcSocketConnection)client->router->connection;
843 idata = (SilcIDListData)client->router;
845 /* Do not send to the sender. Check first whether the true
846 sender's router is same as this client's router. Also check
847 if the sender socket is the same as this client's router
850 ((SilcClientEntry)sender_entry)->router == client->router)
852 if (sender_sock && sock == sender_sock)
855 SILC_LOG_DEBUG(("Relaying packet to client ID(%s) %s (%s)",
856 silc_id_render(client->id, SILC_ID_CLIENT),
857 sock->hostname, sock->ip));
859 /* Mark this route routed already. */
860 routed[routed_count++] = client->router;
862 /* If the remote connection is router then we'll decrypt the
863 channel message and re-encrypt it with the session key shared
864 between us and the remote router. This is done because the
865 channel keys are cell specific and we have different channel
866 key than the remote router has. */
867 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
871 SILC_LOG_DEBUG(("Remote is router, encrypt with session key"));
874 /* If private key mode is not set then decrypt the packet
876 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
877 unsigned char *tmp = silc_calloc(data_len, sizeof(*data));
878 memcpy(tmp, 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 (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,
947 silc_free(packetdata.src_id);
948 silc_free(packetdata.dst_id);
951 /* This function is used to send packets strictly to all local clients
952 on a particular channel. This is used for example to distribute new
953 channel key to all our locally connected clients on the channel.
954 The packets are always encrypted with the session key shared between
955 the client, this means these are not _to the channel_ but _to the client_
958 void silc_server_packet_send_local_channel(SilcServer server,
959 SilcChannelEntry channel,
961 SilcPacketFlags flags,
966 SilcChannelClientEntry chl;
967 SilcHashTableList htl;
968 SilcSocketConnection sock = NULL;
970 SILC_LOG_DEBUG(("Start"));
972 /* Send the message to clients on the channel's client list. */
973 silc_hash_table_list(channel->user_list, &htl);
974 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
975 if (chl->client && !chl->client->router) {
976 sock = (SilcSocketConnection)chl->client->connection;
978 /* Send the packet to the client */
979 silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
980 SILC_ID_CLIENT, data, data_len,
986 /* Routine used to send (relay, route) private messages to some destination.
987 If the private message key does not exist then the message is re-encrypted,
988 otherwise we just pass it along. This really is not used to send new
989 private messages (as server does not send them) but to relay received
992 void silc_server_send_private_message(SilcServer server,
993 SilcSocketConnection dst_sock,
997 SilcPacketContext *packet)
999 SilcBuffer buffer = packet->buffer;
1001 /* Re-encrypt and send if private messge key does not exist */
1002 if (!(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY)) {
1004 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1005 + packet->dst_id_len + packet->padlen);
1006 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1007 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1009 /* Re-encrypt packet */
1010 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf, buffer->len);
1012 /* Send the packet */
1013 silc_server_packet_send_real(server, dst_sock, FALSE);
1016 /* Key exist so encrypt just header and send it */
1017 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1018 + packet->dst_id_len + packet->padlen);
1019 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1020 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1022 /* Encrypt header */
1023 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf,
1024 SILC_PACKET_HEADER_LEN + packet->src_id_len +
1025 packet->dst_id_len + packet->padlen);
1027 silc_server_packet_send_real(server, dst_sock, FALSE);
1031 /* Sends current motd to client */
1033 void silc_server_send_motd(SilcServer server,
1034 SilcSocketConnection sock)
1039 if (server->config && server->config->motd &&
1040 server->config->motd->motd_file) {
1042 motd = silc_file_readfile(server->config->motd->motd_file, &motd_len);
1046 silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
1052 /* Sends error message. Error messages may or may not have any
1055 void silc_server_send_error(SilcServer server,
1056 SilcSocketConnection sock,
1057 const char *fmt, ...)
1060 unsigned char buf[4096];
1062 memset(buf, 0, sizeof(buf));
1064 vsprintf(buf, fmt, ap);
1067 silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
1068 buf, strlen(buf), FALSE);
1071 /* Sends notify message. If format is TRUE the variable arguments are
1072 formatted and the formatted string is sent as argument payload. If it is
1073 FALSE then each argument is sent as separate argument and their format
1074 in the argument list must be { argument data, argument length }. */
1076 void silc_server_send_notify(SilcServer server,
1077 SilcSocketConnection sock,
1079 SilcNotifyType type,
1087 packet = silc_notify_payload_encode(type, argc, ap);
1088 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1089 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1090 packet->data, packet->len, FALSE);
1092 /* Send to backup routers if this is being broadcasted to primary
1094 if (server->router && server->router->connection &&
1095 sock == server->router->connection && broadcast)
1096 silc_server_backup_send(server, NULL, SILC_PACKET_NOTIFY, 0,
1097 packet->data, packet->len, FALSE, TRUE);
1099 silc_buffer_free(packet);
1103 /* Sends notify message and gets the arguments from the `args' Argument
1106 void silc_server_send_notify_args(SilcServer server,
1107 SilcSocketConnection sock,
1109 SilcNotifyType type,
1115 packet = silc_notify_payload_encode_args(type, argc, args);
1116 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1117 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1118 packet->data, packet->len, FALSE);
1119 silc_buffer_free(packet);
1122 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
1123 `old_id' with the `new_id'. */
1125 void silc_server_send_notify_channel_change(SilcServer server,
1126 SilcSocketConnection sock,
1128 SilcChannelID *old_id,
1129 SilcChannelID *new_id)
1131 SilcBuffer idp1, idp2;
1133 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
1134 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
1136 silc_server_send_notify(server, sock, broadcast,
1137 SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
1138 2, idp1->data, idp1->len, idp2->data, idp2->len);
1139 silc_buffer_free(idp1);
1140 silc_buffer_free(idp2);
1143 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
1144 `old_id' with the `new_id'. */
1146 void silc_server_send_notify_nick_change(SilcServer server,
1147 SilcSocketConnection sock,
1149 SilcClientID *old_id,
1150 SilcClientID *new_id)
1152 SilcBuffer idp1, idp2;
1154 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
1155 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
1157 silc_server_send_notify(server, sock, broadcast,
1158 SILC_NOTIFY_TYPE_NICK_CHANGE,
1159 2, idp1->data, idp1->len, idp2->data, idp2->len);
1160 silc_buffer_free(idp1);
1161 silc_buffer_free(idp2);
1164 /* Sends JOIN notify type. This tells that new client by `client_id' ID
1165 has joined to the `channel'. */
1167 void silc_server_send_notify_join(SilcServer server,
1168 SilcSocketConnection sock,
1170 SilcChannelEntry channel,
1171 SilcClientID *client_id)
1173 SilcBuffer idp1, idp2;
1175 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1176 idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1177 silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
1178 2, idp1->data, idp1->len,
1179 idp2->data, idp2->len);
1180 silc_buffer_free(idp1);
1181 silc_buffer_free(idp2);
1184 /* Sends LEAVE notify type. This tells that `client_id' has left the
1185 `channel'. The Notify packet is always destined to the channel. */
1187 void silc_server_send_notify_leave(SilcServer server,
1188 SilcSocketConnection sock,
1190 SilcChannelEntry channel,
1191 SilcClientID *client_id)
1195 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1196 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1197 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
1198 1, idp->data, idp->len);
1199 silc_buffer_free(idp);
1202 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
1203 `channel' mode to `mode. The Notify packet is always destined to
1206 void silc_server_send_notify_cmode(SilcServer server,
1207 SilcSocketConnection sock,
1209 SilcChannelEntry channel,
1211 void *id, SilcIdType id_type,
1212 char *cipher, char *hmac,
1216 unsigned char mode[4];
1218 idp = silc_id_payload_encode((void *)id, id_type);
1219 SILC_PUT32_MSB(mode_mask, mode);
1221 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1222 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
1223 5, idp->data, idp->len,
1225 cipher, cipher ? strlen(cipher) : 0,
1226 hmac, hmac ? strlen(hmac) : 0,
1227 passphrase, passphrase ?
1228 strlen(passphrase) : 0);
1229 silc_buffer_free(idp);
1232 /* Sends CUMODE_CHANGE notify type. This tells that `client_id' changed the
1233 `target' client's mode on `channel'. The notify packet is always
1234 destined to the channel. */
1236 void silc_server_send_notify_cumode(SilcServer server,
1237 SilcSocketConnection sock,
1239 SilcChannelEntry channel,
1241 void *id, SilcIdType id_type,
1242 SilcClientID *target)
1244 SilcBuffer idp1, idp2;
1245 unsigned char mode[4];
1247 idp1 = silc_id_payload_encode((void *)id, id_type);
1248 idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
1249 SILC_PUT32_MSB(mode_mask, mode);
1251 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1253 SILC_NOTIFY_TYPE_CUMODE_CHANGE, 3,
1254 idp1->data, idp1->len,
1256 idp2->data, idp2->len);
1257 silc_buffer_free(idp1);
1258 silc_buffer_free(idp2);
1261 /* Sends SIGNOFF notify type. This tells that `client_id' client has
1262 left SILC network. This function is used only between server and router
1263 traffic. This is not used to send the notify to the channel for
1264 client. The `message may be NULL. */
1266 void silc_server_send_notify_signoff(SilcServer server,
1267 SilcSocketConnection sock,
1269 SilcClientID *client_id,
1270 const char *message)
1274 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1275 silc_server_send_notify(server, sock, broadcast,
1276 SILC_NOTIFY_TYPE_SIGNOFF,
1277 message ? 2 : 1, idp->data, idp->len,
1278 message, message ? strlen(message): 0);
1279 silc_buffer_free(idp);
1282 /* Sends TOPIC_SET notify type. This tells that `id' changed
1283 the `channel's topic to `topic'. The Notify packet is always destined
1284 to the channel. This function is used to send the topic set notifies
1287 void silc_server_send_notify_topic_set(SilcServer server,
1288 SilcSocketConnection sock,
1290 SilcChannelEntry channel,
1291 void *id, SilcIdType id_type,
1296 idp = silc_id_payload_encode(id, id_type);
1297 silc_server_send_notify_dest(server, sock, broadcast,
1298 (void *)channel->id, SILC_ID_CHANNEL,
1299 SILC_NOTIFY_TYPE_TOPIC_SET,
1301 idp->data, idp->len,
1302 topic, topic ? strlen(topic) : 0);
1303 silc_buffer_free(idp);
1306 /* Send KICKED notify type. This tells that the `client_id' on `channel'
1307 was kicked off the channel. The `comment' may indicate the reason
1308 for the kicking. This function is used only between server and router
1311 void silc_server_send_notify_kicked(SilcServer server,
1312 SilcSocketConnection sock,
1314 SilcChannelEntry channel,
1315 SilcClientID *client_id,
1316 SilcClientID *kicker,
1322 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1323 idp2 = silc_id_payload_encode((void *)kicker, SILC_ID_CLIENT);
1324 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1325 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED, 3,
1326 idp1->data, idp1->len,
1327 comment, comment ? strlen(comment) : 0,
1328 idp2->data, idp2->len);
1329 silc_buffer_free(idp1);
1330 silc_buffer_free(idp2);
1333 /* Send KILLED notify type. This tells that the `client_id' client was
1334 killed from the network. The `comment' may indicate the reason
1337 void silc_server_send_notify_killed(SilcServer server,
1338 SilcSocketConnection sock,
1340 SilcClientID *client_id,
1345 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1346 silc_server_send_notify_dest(server, sock, broadcast, (void *)client_id,
1347 SILC_ID_CLIENT, SILC_NOTIFY_TYPE_KILLED,
1348 comment ? 2 : 1, idp->data, idp->len,
1349 comment, comment ? strlen(comment) : 0);
1350 silc_buffer_free(idp);
1353 /* Sends UMODE_CHANGE notify type. This tells that `client_id' client's
1354 user mode in the SILC Network was changed. This function is used to
1355 send the packet between routers as broadcast packet. */
1357 void silc_server_send_notify_umode(SilcServer server,
1358 SilcSocketConnection sock,
1360 SilcClientID *client_id,
1364 unsigned char mode[4];
1366 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1367 SILC_PUT32_MSB(mode_mask, mode);
1369 silc_server_send_notify(server, sock, broadcast,
1370 SILC_NOTIFY_TYPE_UMODE_CHANGE, 2,
1371 idp->data, idp->len,
1373 silc_buffer_free(idp);
1376 /* Sends BAN notify type. This tells that ban has been either `add'ed
1377 or `del'eted on the `channel. This function is used to send the packet
1378 between routers as broadcast packet. */
1380 void silc_server_send_notify_ban(SilcServer server,
1381 SilcSocketConnection sock,
1383 SilcChannelEntry channel,
1384 char *add, char *del)
1388 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1389 silc_server_send_notify(server, sock, broadcast,
1390 SILC_NOTIFY_TYPE_BAN, 3,
1391 idp->data, idp->len,
1392 add, add ? strlen(add) : 0,
1393 del, del ? strlen(del) : 0);
1394 silc_buffer_free(idp);
1397 /* Sends INVITE notify type. This tells that invite has been either `add'ed
1398 or `del'eted on the `channel. The sender of the invite is the `client_id'.
1399 This function is used to send the packet between routers as broadcast
1402 void silc_server_send_notify_invite(SilcServer server,
1403 SilcSocketConnection sock,
1405 SilcChannelEntry channel,
1406 SilcClientID *client_id,
1407 char *add, char *del)
1409 SilcBuffer idp, idp2;
1411 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1412 idp2 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1413 silc_server_send_notify(server, sock, broadcast,
1414 SILC_NOTIFY_TYPE_INVITE, 5,
1415 idp->data, idp->len,
1416 channel->channel_name, strlen(channel->channel_name),
1417 idp2->data, idp2->len,
1418 add, add ? strlen(add) : 0,
1419 del, del ? strlen(del) : 0);
1420 silc_buffer_free(idp);
1421 silc_buffer_free(idp2);
1424 /* Sends notify message destined to specific entity. */
1426 void silc_server_send_notify_dest(SilcServer server,
1427 SilcSocketConnection sock,
1430 SilcIdType dest_id_type,
1431 SilcNotifyType type,
1439 packet = silc_notify_payload_encode(type, argc, ap);
1440 silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY,
1441 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1442 dest_id, dest_id_type,
1443 packet->data, packet->len, FALSE);
1444 silc_buffer_free(packet);
1448 /* Sends notify message to a channel. The notify message sent is
1449 distributed to all clients on the channel. If `route_notify' is TRUE
1450 then the notify may be routed to primary route or to some other routers.
1451 If FALSE it is assured that the notify is sent only locally. If `sender'
1452 is provided then the packet is not sent to that connection since it
1453 originally came from it. */
1455 void silc_server_send_notify_to_channel(SilcServer server,
1456 SilcSocketConnection sender,
1457 SilcChannelEntry channel,
1459 SilcNotifyType type,
1467 packet = silc_notify_payload_encode(type, argc, ap);
1468 silc_server_packet_send_to_channel(server, sender, channel,
1469 SILC_PACKET_NOTIFY, route_notify,
1470 packet->data, packet->len, FALSE);
1471 silc_buffer_free(packet);
1475 /* Send notify message to all channels the client has joined. It is quaranteed
1476 that the message is sent only once to a client (ie. if a client is joined
1477 on two same channel it will receive only one notify message). Also, this
1478 sends only to local clients (locally connected if we are server, and to
1479 local servers if we are router). If `sender' is provided the packet is
1480 not sent to that client at all. */
1482 void silc_server_send_notify_on_channels(SilcServer server,
1483 SilcClientEntry sender,
1484 SilcClientEntry client,
1485 SilcNotifyType type,
1489 SilcSocketConnection sock = NULL;
1490 SilcPacketContext packetdata;
1492 SilcClientEntry *sent_clients = NULL;
1493 uint32 sent_clients_count = 0;
1494 SilcServerEntry *routed = NULL;
1495 uint32 routed_count = 0;
1496 SilcHashTableList htl, htl2;
1497 SilcChannelEntry channel;
1498 SilcChannelClientEntry chl, chl2;
1499 SilcIDListData idata;
1501 unsigned char *data;
1503 bool force_send = FALSE;
1506 SILC_LOG_DEBUG(("Start"));
1508 if (!silc_hash_table_count(client->channels))
1512 packet = silc_notify_payload_encode(type, argc, ap);
1513 data = packet->data;
1514 data_len = packet->len;
1516 /* Set the packet context pointers. */
1517 packetdata.flags = 0;
1518 packetdata.type = SILC_PACKET_NOTIFY;
1519 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1520 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
1521 packetdata.src_id_type = SILC_ID_SERVER;
1523 silc_hash_table_list(client->channels, &htl);
1524 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
1525 channel = chl->channel;
1527 /* Send the message to all clients on the channel's client list. */
1528 silc_hash_table_list(channel->user_list, &htl2);
1529 while (silc_hash_table_get(&htl2, NULL, (void *)&chl2)) {
1532 if (sender && c == sender)
1535 /* Check if we have sent the packet to this client already */
1536 for (k = 0; k < sent_clients_count; k++)
1537 if (sent_clients[k] == c)
1539 if (k < sent_clients_count)
1542 /* If we are router and if this client has router set it is not
1543 locally connected client and we will route the message to the
1544 router set in the client. */
1545 if (c && c->router && server->server_type == SILC_ROUTER) {
1546 /* Check if we have sent the packet to this route already */
1547 for (k = 0; k < routed_count; k++)
1548 if (routed[k] == c->router)
1550 if (k < routed_count)
1553 /* Get data used in packet header encryption, keys and stuff. */
1554 sock = (SilcSocketConnection)c->router->connection;
1555 idata = (SilcIDListData)c->router;
1558 SILC_LOG_DEBUG(("*****************"));
1559 SILC_LOG_DEBUG(("client->router->id %s",
1560 silc_id_render(c->router->id, SILC_ID_SERVER)));
1561 SILC_LOG_DEBUG(("client->router->connection->user_data->id %s",
1562 silc_id_render(((SilcServerEntry)sock->user_data)->id, SILC_ID_SERVER)));
1565 packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1566 packetdata.dst_id_len = silc_id_get_len(c->router->id, SILC_ID_SERVER);
1567 packetdata.dst_id_type = SILC_ID_SERVER;
1569 /* Send the packet */
1570 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1574 data, data_len, FALSE,
1577 silc_free(packetdata.dst_id);
1579 /* We want to make sure that the packet is routed to same router
1580 only once. Mark this route as sent route. */
1581 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
1582 routed[routed_count++] = c->router;
1589 /* Send to locally connected client */
1592 /* Get data used in packet header encryption, keys and stuff. */
1593 sock = (SilcSocketConnection)c->connection;
1594 idata = (SilcIDListData)c;
1596 packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1597 packetdata.dst_id_len = silc_id_get_len(c->id, SILC_ID_CLIENT);
1598 packetdata.dst_id_type = SILC_ID_CLIENT;
1600 /* Send the packet */
1601 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1605 data, data_len, FALSE,
1608 silc_free(packetdata.dst_id);
1610 /* Make sure that we send the notify only once per client. */
1611 sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1612 (sent_clients_count + 1));
1613 sent_clients[sent_clients_count++] = c;
1619 silc_free(sent_clients);
1620 silc_free(packetdata.src_id);
1621 silc_buffer_free(packet);
1625 /* Sends New ID Payload to remote end. The packet is used to distribute
1626 information about new registered clients, servers, channel etc. usually
1627 to routers so that they can keep these information up to date.
1628 If the argument `broadcast' is TRUE then the packet is sent as
1629 broadcast packet. */
1631 void silc_server_send_new_id(SilcServer server,
1632 SilcSocketConnection sock,
1634 void *id, SilcIdType id_type,
1639 SILC_LOG_DEBUG(("Start"));
1641 idp = silc_id_payload_encode(id, id_type);
1642 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1643 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1644 idp->data, idp->len, FALSE);
1646 /* Send to backup routers if this is being broadcasted to primary
1648 if (server->router && server->router->connection &&
1649 sock == server->router->connection && broadcast)
1650 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0,
1651 idp->data, idp->len, FALSE, TRUE);
1653 silc_buffer_free(idp);
1656 /* Send New Channel Payload to notify about newly created channel in the
1657 SILC network. Normal server nevers sends this packet. Router uses this
1658 to notify other routers in the network about new channel. This packet
1661 void silc_server_send_new_channel(SilcServer server,
1662 SilcSocketConnection sock,
1666 uint32 channel_id_len,
1671 uint32 name_len = strlen(channel_name);
1673 SILC_LOG_DEBUG(("Start"));
1675 cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1679 /* Encode the channel payload */
1680 packet = silc_channel_payload_encode(channel_name, name_len,
1681 cid, channel_id_len, mode);
1683 silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1684 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1685 packet->data, packet->len, FALSE);
1687 /* Send to backup routers if this is being broadcasted to primary
1689 if (server->router && server->router->connection &&
1690 sock == server->router->connection && broadcast)
1691 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
1692 packet->data, packet->len, FALSE, TRUE);
1695 silc_buffer_free(packet);
1698 /* Send Channel Key payload to distribute the new channel key. Normal server
1699 sends this to router when new client joins to existing channel. Router
1700 sends this to the local server who sent the join command in case where
1701 the channel did not exist yet. Both normal and router servers uses this
1702 also to send this to locally connected clients on the channel. This
1703 must not be broadcasted packet. Routers do not send this to each other.
1704 If `sender is provided then the packet is not sent to that connection since
1705 it originally came from it. */
1707 void silc_server_send_channel_key(SilcServer server,
1708 SilcSocketConnection sender,
1709 SilcChannelEntry channel,
1710 unsigned char route)
1713 unsigned char *chid;
1716 SILC_LOG_DEBUG(("Sending key to channel %s", channel->channel_name));
1718 chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1722 /* Encode channel key packet */
1723 tmp_len = strlen(channel->channel_key->cipher->name);
1724 packet = silc_channel_key_payload_encode(silc_id_get_len(channel->id,
1727 channel->channel_key->cipher->name,
1728 channel->key_len / 8, channel->key);
1729 silc_server_packet_send_to_channel(server, sender, channel,
1730 SILC_PACKET_CHANNEL_KEY,
1731 route, packet->data, packet->len,
1733 silc_buffer_free(packet);
1737 /* Generic function to send any command. The arguments must be sent already
1738 encoded into correct form in correct order. */
1740 void silc_server_send_command(SilcServer server,
1741 SilcSocketConnection sock,
1742 SilcCommand command,
1751 packet = silc_command_payload_encode_vap(command, ident, argc, ap);
1752 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1753 packet->data, packet->len, TRUE);
1754 silc_buffer_free(packet);
1758 /* Generic function to send any command reply. The arguments must be sent
1759 already encoded into correct form in correct order. */
1761 void silc_server_send_command_reply(SilcServer server,
1762 SilcSocketConnection sock,
1763 SilcCommand command,
1764 SilcCommandStatus status,
1773 packet = silc_command_reply_payload_encode_vap(command, status, ident,
1775 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1776 packet->data, packet->len, TRUE);
1777 silc_buffer_free(packet);
1781 /* Generic function to send any command reply. The arguments must be sent
1782 already encoded into correct form in correct order. */
1784 void silc_server_send_dest_command_reply(SilcServer server,
1785 SilcSocketConnection sock,
1787 SilcIdType dst_id_type,
1788 SilcCommand command,
1789 SilcCommandStatus status,
1798 packet = silc_command_reply_payload_encode_vap(command, status, ident,
1800 silc_server_packet_send_dest(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1801 dst_id, dst_id_type, packet->data,
1803 silc_buffer_free(packet);
1807 /* Send the heartbeat packet. */
1809 void silc_server_send_heartbeat(SilcServer server,
1810 SilcSocketConnection sock)
1812 silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1816 /* Generic function to relay packet we've received. This is used to relay
1817 packets to a client but generally can be used to other purposes as well. */
1819 void silc_server_relay_packet(SilcServer server,
1820 SilcSocketConnection dst_sock,
1824 SilcPacketContext *packet,
1827 silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1828 + packet->dst_id_len + packet->padlen);
1830 silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len);
1831 silc_buffer_put(dst_sock->outbuf, packet->buffer->data, packet->buffer->len);
1833 /* Re-encrypt packet */
1834 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf,
1835 packet->buffer->len);
1837 /* Send the packet */
1838 silc_server_packet_send_real(server, dst_sock, force_send);
1840 silc_buffer_pull(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1841 + packet->dst_id_len + packet->padlen);
1844 /* Routine used to send the connection authentication packet. */
1846 void silc_server_send_connection_auth_request(SilcServer server,
1847 SilcSocketConnection sock,
1849 SilcAuthMethod auth_meth)
1853 packet = silc_buffer_alloc(4);
1854 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1855 silc_buffer_format(packet,
1856 SILC_STR_UI_SHORT(conn_type),
1857 SILC_STR_UI_SHORT(auth_meth),
1860 silc_server_packet_send(server, sock, SILC_PACKET_CONNECTION_AUTH_REQUEST,
1861 0, packet->data, packet->len, FALSE);
1862 silc_buffer_free(packet);
1865 /* Purge the outgoing packet queue to the network if there is data. This
1866 function can be used to empty the packet queue. It is guaranteed that
1867 after this function returns the outgoing data queue is empty. */
1869 void silc_server_packet_queue_purge(SilcServer server,
1870 SilcSocketConnection sock)
1872 if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
1873 (SILC_IS_DISCONNECTED(sock) == FALSE)) {
1874 server->stat.packets_sent++;
1876 if (sock->outbuf->data - sock->outbuf->head)
1877 silc_buffer_push(sock->outbuf, sock->outbuf->data - sock->outbuf->head);
1879 silc_packet_send(sock, TRUE);
1881 SILC_SET_CONNECTION_FOR_INPUT(server->schedule, sock->sock);
1882 SILC_UNSET_OUTBUF_PENDING(sock);
1883 silc_buffer_clear(sock->outbuf);