5 Author: Pekka Riikonen <priikone@silcnet.org>
7 Copyright (C) 1997 - 2002 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 const SilcBufferStruct packet;
141 SilcIDListData idata = (SilcIDListData)sock->user_data;
142 SilcCipher cipher = NULL;
143 SilcHmac hmac = NULL;
144 SilcUInt32 sequence = 0;
145 unsigned char *dst_id_data = NULL;
146 SilcUInt32 dst_id_len = 0;
149 /* If disconnecting, ignore the data */
150 if (SILC_IS_DISCONNECTING(sock))
153 /* If entry is disabled do not sent anything. */
154 if (idata && idata->status & SILC_IDLIST_STATUS_DISABLED)
157 SILC_LOG_DEBUG(("Sending packet, type %d", type));
160 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
161 dst_id_len = silc_id_get_len(dst_id, dst_id_type);
165 cipher = idata->send_key;
166 hmac = idata->hmac_send;
167 sequence = idata->psn_send++;
168 block_len = silc_cipher_get_block_len(cipher);
171 /* Set the packet context pointers */
172 packetdata.type = type;
173 packetdata.flags = flags;
174 packetdata.src_id = silc_id_id2str(server->id, server->id_type);
175 packetdata.src_id_len = silc_id_get_len(server->id, server->id_type);
176 packetdata.src_id_type = server->id_type;
177 packetdata.dst_id = dst_id_data;
178 packetdata.dst_id_len = dst_id_len;
179 packetdata.dst_id_type = dst_id_type;
180 data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
181 packetdata.src_id_len +
182 packetdata.dst_id_len));
183 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
184 packetdata.src_id_len + dst_id_len;
185 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen, block_len);
187 /* Create the outgoing packet */
188 if (!silc_packet_assemble(&packetdata, NULL, cipher, hmac, sock,
189 data, data_len, (const SilcBuffer)&packet)) {
190 SILC_LOG_ERROR(("Cannot assemble packet"));
194 /* Encrypt the packet */
195 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&packet, packet.len);
197 SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence, packet.len),
198 packet.data, packet.len);
200 /* Now actually send the packet */
201 silc_server_packet_send_real(server, sock, force_send);
204 if (packetdata.src_id)
205 silc_free(packetdata.src_id);
206 if (packetdata.dst_id)
207 silc_free(packetdata.dst_id);
210 /* Assembles a new packet to be sent out to network. This doesn't actually
211 send the packet but creates the packet and fills the outgoing data
212 buffer and marks the packet ready to be sent to network. However, If
213 argument force_send is TRUE the packet is sent immediately and not put
214 to queue. Normal case is that the packet is not sent immediately.
215 The source and destination information is sent as argument for this
218 void silc_server_packet_send_srcdest(SilcServer server,
219 SilcSocketConnection sock,
221 SilcPacketFlags flags,
223 SilcIdType src_id_type,
225 SilcIdType dst_id_type,
230 SilcPacketContext packetdata;
231 const SilcBufferStruct packet;
232 SilcIDListData idata;
233 SilcCipher cipher = NULL;
234 SilcHmac hmac = NULL;
235 SilcUInt32 sequence = 0;
236 unsigned char *dst_id_data = NULL;
237 SilcUInt32 dst_id_len = 0;
238 unsigned char *src_id_data = NULL;
239 SilcUInt32 src_id_len = 0;
242 SILC_LOG_DEBUG(("Sending packet, type %d", type));
244 /* Get data used in the packet sending, keys and stuff */
245 idata = (SilcIDListData)sock->user_data;
248 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
249 dst_id_len = silc_id_get_len(dst_id, dst_id_type);
253 src_id_data = silc_id_id2str(src_id, src_id_type);
254 src_id_len = silc_id_get_len(src_id, src_id_type);
258 cipher = idata->send_key;
259 hmac = idata->hmac_send;
260 sequence = idata->psn_send++;
261 block_len = silc_cipher_get_block_len(cipher);
264 /* Set the packet context pointers */
265 packetdata.type = type;
266 packetdata.flags = flags;
267 packetdata.src_id = src_id_data;
268 packetdata.src_id_len = src_id_len;
269 packetdata.src_id_type = src_id_type;
270 packetdata.dst_id = dst_id_data;
271 packetdata.dst_id_len = dst_id_len;
272 packetdata.dst_id_type = dst_id_type;
273 data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
274 packetdata.src_id_len +
276 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
277 packetdata.src_id_len + dst_id_len;
278 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen, block_len);
280 /* Create the outgoing packet */
281 if (!silc_packet_assemble(&packetdata, NULL, cipher, hmac, sock, data,
282 data_len, (const SilcBuffer)&packet)) {
283 SILC_LOG_ERROR(("Cannot assemble packe"));
287 /* Encrypt the packet */
288 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&packet, packet.len);
290 SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence, packet.len),
291 packet.data, packet.len);
293 /* Now actually send the packet */
294 silc_server_packet_send_real(server, sock, force_send);
297 if (packetdata.src_id)
298 silc_free(packetdata.src_id);
299 if (packetdata.dst_id)
300 silc_free(packetdata.dst_id);
303 /* Broadcast received packet to our primary route. This function is used
304 by router to further route received broadcast packet. It is expected
305 that the broadcast flag from the packet is checked before calling this
306 function. This does not test or set the broadcast flag. */
308 void silc_server_packet_broadcast(SilcServer server,
309 SilcSocketConnection sock,
310 SilcPacketContext *packet)
312 SilcBuffer buffer = packet->buffer;
313 SilcIDListData idata;
316 SILC_LOG_DEBUG(("Broadcasting received broadcast packet"));
318 /* If the packet is originated from our primary route we are
319 not allowed to send the packet. */
320 id = silc_id_str2id(packet->src_id, packet->src_id_len, packet->src_id_type);
321 if (id && !SILC_ID_SERVER_COMPARE(id, server->router->id)) {
322 const SilcBufferStruct p;
324 idata = (SilcIDListData)sock->user_data;
326 silc_buffer_push(buffer, buffer->data - buffer->head);
327 if (!silc_packet_send_prepare(sock, 0, 0, buffer->len, idata->hmac_send,
328 (const SilcBuffer)&p)) {
329 SILC_LOG_ERROR(("Cannot send packet"));
333 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
334 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
335 (SilcBuffer)&p, p.len);
337 SILC_LOG_HEXDUMP(("Broadcasted packet (%d), len %d", idata->psn_send - 1,
338 p.len), p.data, p.len);
340 /* Now actually send the packet */
341 silc_server_packet_send_real(server, sock, TRUE);
346 SILC_LOG_DEBUG(("Will not broadcast to primary route since it is the "
347 "original sender of this packet"));
351 /* Routes received packet to `sock'. This is used to route the packets that
352 router receives but are not destined to it. */
354 void silc_server_packet_route(SilcServer server,
355 SilcSocketConnection sock,
356 SilcPacketContext *packet)
358 SilcBuffer buffer = packet->buffer;
359 const SilcBufferStruct p;
360 SilcIDListData idata;
362 SILC_LOG_DEBUG(("Routing received packet"));
364 idata = (SilcIDListData)sock->user_data;
366 silc_buffer_push(buffer, buffer->data - buffer->head);
367 if (!silc_packet_send_prepare(sock, 0, 0, buffer->len, idata->hmac_send,
368 (const SilcBuffer)&p)) {
369 SILC_LOG_ERROR(("Cannot send packet"));
372 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
373 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
374 (SilcBuffer)&p, p.len);
376 SILC_LOG_HEXDUMP(("Routed packet (%d), len %d", idata->psn_send - 1,
377 p.len), p.data, p.len);
379 /* Now actually send the packet */
380 silc_server_packet_send_real(server, sock, TRUE);
383 /* This routine can be used to send a packet to table of clients provided
384 in `clients'. If `route' is FALSE the packet is routed only to local
385 clients (for server locally connected, and for router local cell). */
387 void silc_server_packet_send_clients(SilcServer server,
388 SilcClientEntry *clients,
389 SilcUInt32 clients_count,
391 SilcPacketFlags flags,
397 SilcSocketConnection sock = NULL;
398 SilcClientEntry client = NULL;
399 SilcServerEntry *routed = NULL;
400 SilcUInt32 routed_count = 0;
404 SILC_LOG_DEBUG(("Sending packet to list of clients"));
406 /* Send to all clients in table */
407 for (i = 0; i < clients_count; i++) {
410 /* If client has router set it is not locally connected client and
411 we will route the message to the router set in the client. Though,
412 send locally connected server in all cases. */
413 if (server->server_type == SILC_ROUTER && client->router &&
414 ((!route && client->router->router == server->id_entry) || route)) {
416 /* Check if we have sent the packet to this route already */
417 for (k = 0; k < routed_count; k++)
418 if (routed[k] == client->router)
420 if (k < routed_count)
423 /* Route only once to router */
424 sock = (SilcSocketConnection)client->router->connection;
425 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
431 /* Send the packet */
432 silc_server_packet_send_dest(server, sock, type, flags,
433 client->router->id, SILC_ID_SERVER,
434 data, data_len, force_send);
436 /* Mark this route routed already */
437 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
438 routed[routed_count++] = client->router;
445 /* Send to locally connected client */
446 sock = (SilcSocketConnection)client->connection;
447 silc_server_packet_send_dest(server, sock, type, flags,
448 client->id, SILC_ID_CLIENT,
449 data, data_len, force_send);
455 /* Internal routine to actually create the channel packet and send it
456 to network. This is common function in channel message sending. If
457 `channel_message' is TRUE this encrypts the message as it is strictly
458 a channel message. If FALSE normal encryption process is used. */
461 silc_server_packet_send_to_channel_real(SilcServer server,
462 SilcSocketConnection sock,
463 SilcPacketContext *packet,
469 bool channel_message,
473 const SilcBufferStruct p;
478 data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
480 packet->dst_id_len));
481 packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
482 packet->src_id_len + packet->dst_id_len;
484 block_len = cipher ? silc_cipher_get_block_len(cipher) : 0;
486 packet->padlen = SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
488 packet->dst_id_len), block_len);
490 packet->padlen = SILC_PACKET_PADLEN(packet->truelen, block_len);
492 /* Put the data to buffer, assemble and encrypt the packet. The packet
493 is encrypted with normal session key shared with the client, unless
494 the `channel_message' is TRUE. */
495 if (!silc_packet_assemble(packet, NULL, cipher, hmac, sock, data,
496 data_len, (const SilcBuffer)&p)) {
497 SILC_LOG_ERROR(("Cannot assemble packet"));
502 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p,
503 SILC_PACKET_HEADER_LEN + packet->src_id_len +
504 packet->dst_id_len + packet->padlen);
506 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, p.len);
508 SILC_LOG_HEXDUMP(("Channel packet (%d), len %d", sequence, p.len),
511 /* Now actually send the packet */
512 silc_server_packet_send_real(server, sock, force_send);
515 /* This routine is used by the server to send packets to channel. The
516 packet sent with this function is distributed to all clients on
517 the channel. Usually this is used to send notify messages to the
518 channel, things like notify about new user joining to the channel.
519 If `route' is FALSE then the packet is sent only locally and will not
520 be routed anywhere (for router locally means cell wide). If `sender'
521 is provided then the packet is not sent to that connection since it
522 originally came from it. If `send_to_clients' is FALSE then the
523 packet is not sent clients, only servers. */
525 void silc_server_packet_send_to_channel(SilcServer server,
526 SilcSocketConnection sender,
527 SilcChannelEntry channel,
534 SilcSocketConnection sock = NULL;
535 SilcPacketContext packetdata;
536 SilcClientEntry client = NULL;
537 SilcServerEntry *routed = NULL;
538 SilcChannelClientEntry chl;
539 SilcHashTableList htl;
540 SilcIDListData idata;
541 SilcUInt32 routed_count = 0;
545 /* This doesn't send channel message packets */
546 assert(type != SILC_PACKET_CHANNEL_MESSAGE);
548 SILC_LOG_DEBUG(("Sending packet to channel"));
550 /* Set the packet context pointers. */
551 packetdata.flags = 0;
552 packetdata.type = type;
553 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
554 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
555 packetdata.src_id_type = SILC_ID_SERVER;
556 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
557 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
558 packetdata.dst_id_type = SILC_ID_CHANNEL;
560 /* If there are global users in the channel we will send the message
561 first to our router for further routing. */
562 if (route && server->server_type != SILC_ROUTER && !server->standalone &&
563 channel->global_users) {
564 SilcServerEntry router;
566 /* Get data used in packet header encryption, keys and stuff. */
567 router = server->router;
568 sock = (SilcSocketConnection)router->connection;
569 idata = (SilcIDListData)router;
571 if (sock != sender) {
572 SILC_LOG_DEBUG(("Sending packet to router for routing"));
574 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
578 data, data_len, FALSE,
583 routed = silc_calloc(silc_hash_table_count(channel->user_list),
586 /* Send the message to clients on the channel's client list. */
587 silc_hash_table_list(channel->user_list, &htl);
588 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
589 client = chl->client;
593 /* If client has router set it is not locally connected client and
594 we will route the message to the router set in the client. Though,
595 send locally connected server in all cases. */
596 if (server->server_type == SILC_ROUTER && client->router &&
597 ((!route && client->router->router == server->id_entry) || route)) {
599 /* Check if we have sent the packet to this route already */
600 for (k = 0; k < routed_count; k++)
601 if (routed[k] == client->router)
603 if (k < routed_count)
606 /* Get data used in packet header encryption, keys and stuff. */
607 sock = (SilcSocketConnection)client->router->connection;
608 idata = (SilcIDListData)client->router;
610 if (sender && sock == sender)
613 /* Route only once to router. Protocol prohibits sending channel
614 messages to more than one router. */
615 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
621 /* Send the packet */
622 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
626 data, data_len, FALSE,
629 /* Mark this route routed already */
630 routed[routed_count++] = client->router;
637 /* Send to locally connected client */
639 /* Get data used in packet header encryption, keys and stuff. */
640 sock = (SilcSocketConnection)client->connection;
641 idata = (SilcIDListData)client;
643 if (!sock || (sender && sock == sender))
646 /* Send the packet */
647 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
651 data, data_len, FALSE,
655 silc_hash_table_list_reset(&htl);
657 silc_free(packetdata.src_id);
658 silc_free(packetdata.dst_id);
661 /* This checks whether the relayed packet came from router. If it did
662 then we'll need to encrypt it with the channel key. This is called
663 from the silc_server_packet_relay_to_channel. */
666 silc_server_packet_relay_to_channel_encrypt(SilcServer server,
667 SilcSocketConnection sock,
668 SilcChannelEntry channel,
670 unsigned int data_len)
672 /* If we are router and the packet came from router and private key
673 has not been set for the channel then we must encrypt the packet
674 as it was decrypted with the session key shared between us and the
675 router which sent it. This is so, because cells does not share the
677 if (server->server_type == SILC_ROUTER &&
678 sock->type == SILC_SOCKET_TYPE_ROUTER &&
679 !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
680 channel->channel_key) {
681 SilcUInt32 mac_len = silc_hmac_len(channel->hmac);
682 SilcUInt32 iv_len = silc_cipher_get_block_len(channel->channel_key);
684 if (data_len <= mac_len + iv_len) {
685 SILC_LOG_WARNING(("Corrupted channel message, cannot relay it"));
689 memcpy(channel->iv, data + (data_len - iv_len), iv_len);
690 silc_channel_message_payload_encrypt(data, data_len - iv_len - mac_len,
691 data_len, channel->iv, iv_len,
692 channel->channel_key, channel->hmac);
698 /* This routine is explicitly used to relay messages to some channel.
699 Packets sent with this function we have received earlier and are
700 totally encrypted. This just sends the packet to all clients on
701 the channel. If the sender of the packet is someone on the channel
702 the message will not be sent to that client. The SILC Packet header
703 is encrypted with the session key shared between us and the client.
704 MAC is also computed before encrypting the header. Rest of the
705 packet will be untouched. */
707 void silc_server_packet_relay_to_channel(SilcServer server,
708 SilcSocketConnection sender_sock,
709 SilcChannelEntry channel,
711 SilcIdType sender_type,
712 SilcClientEntry sender_entry,
717 SilcSocketConnection sock = NULL;
718 SilcPacketContext packetdata;
719 SilcClientEntry client = NULL;
720 SilcServerEntry *routed = NULL;
721 SilcChannelClientEntry chl;
722 SilcUInt32 routed_count = 0;
723 SilcIDListData idata;
724 SilcHashTableList htl;
728 SILC_LOG_DEBUG(("Relaying packet to channel"));
730 /* This encrypts the packet, if needed. It will be encrypted if
731 it came from the router thus it needs to be encrypted with the
732 channel key. If the channel key does not exist, then we know we
733 don't have a single local user on the channel. */
734 if (!silc_server_packet_relay_to_channel_encrypt(server, sender_sock,
739 /* Set the packet context pointers. */
740 packetdata.flags = 0;
741 packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
742 packetdata.src_id = silc_id_id2str(sender_id, sender_type);
743 packetdata.src_id_len = silc_id_get_len(sender_id, sender_type);
744 packetdata.src_id_type = sender_type;
745 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
746 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
747 packetdata.dst_id_type = SILC_ID_CHANNEL;
749 /* If there are global users in the channel we will send the message
750 first to our router for further routing. */
751 if (server->server_type != SILC_ROUTER && !server->standalone &&
752 channel->global_users) {
753 SilcServerEntry router = server->router;
755 /* Check that the sender is not our router. */
756 if (sender_sock != (SilcSocketConnection)router->connection) {
758 /* Get data used in packet header encryption, keys and stuff. */
759 sock = (SilcSocketConnection)router->connection;
760 idata = (SilcIDListData)router;
762 SILC_LOG_DEBUG(("Sending channel message to router for routing"));
764 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
768 data, data_len, TRUE,
773 routed = silc_calloc(silc_hash_table_count(channel->user_list),
776 /* Assure we won't route the message back to the sender's way. */
777 if (sender_entry->router)
778 routed[routed_count++] = sender_entry->router;
780 /* Send the message to clients on the channel's client list. */
781 silc_hash_table_list(channel->user_list, &htl);
782 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
783 client = chl->client;
784 if (!client || client == sender_entry ||
785 chl->mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES)
788 /* If the client has set router it means that it is not locally
789 connected client and we will route the packet further. */
790 if (server->server_type == SILC_ROUTER && client->router) {
792 /* Check if we have sent the packet to this route already */
793 for (k = 0; k < routed_count; k++)
794 if (routed[k] == client->router)
796 if (k < routed_count)
799 /* Get data used in packet header encryption, keys and stuff. */
800 sock = (SilcSocketConnection)client->router->connection;
801 idata = (SilcIDListData)client->router;
803 /* Check if the sender socket is the same as this client's router
805 if (sender_sock && sock == sender_sock)
808 SILC_LOG_DEBUG(("Relaying packet to client ID(%s) %s (%s)",
809 silc_id_render(client->id, SILC_ID_CLIENT),
810 sock->hostname, sock->ip));
812 /* Mark this route routed already. */
813 routed[routed_count++] = client->router;
815 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
816 /* The remote connection is router then we'll decrypt the
817 channel message and re-encrypt it with the session key shared
818 between us and the remote router. This is done because the
819 channel keys are cell specific and we have different channel
820 key than the remote router has. */
822 /* Route only once to router. Protocol prohibits sending channel
823 messages to more than one router. */
828 SILC_LOG_DEBUG(("Remote is router, encrypt with session key"));
830 /* If private key mode is not set then decrypt the packet
832 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
833 channel->channel_key) {
834 unsigned char tmp[SILC_PACKET_MAX_LEN];
836 if (data_len > SILC_PACKET_MAX_LEN)
837 data_len = SILC_PACKET_MAX_LEN;
838 memcpy(tmp, data, data_len);
840 /* Decrypt the channel message (we don't check the MAC) */
841 silc_channel_message_payload_decrypt(tmp, data_len,
842 channel->channel_key, NULL);
844 /* Now re-encrypt and send it to the router */
845 silc_server_packet_send_srcdest(server, sock,
846 SILC_PACKET_CHANNEL_MESSAGE, 0,
847 sender_id, sender_type,
848 channel->id, SILC_ID_CHANNEL,
849 tmp, data_len, force_send);
851 /* Private key mode is set, we don't have the channel key, so
852 just re-encrypt the entire packet and send it to the router. */
853 silc_server_packet_send_srcdest(server, sock,
854 SILC_PACKET_CHANNEL_MESSAGE, 0,
855 sender_id, sender_type,
856 channel->id, SILC_ID_CHANNEL,
857 data, data_len, force_send);
860 /* Send the packet to normal server */
861 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
865 data, data_len, TRUE,
875 /* Get data used in packet header encryption, keys and stuff. */
876 sock = (SilcSocketConnection)client->connection;
877 idata = (SilcIDListData)client;
879 if (!sock || (sender_sock && sock == sender_sock))
882 SILC_LOG_DEBUG(("Sending packet to client ID(%s) %s (%s)",
883 silc_id_render(client->id, SILC_ID_CLIENT),
884 sock->hostname, sock->ip));
886 /* Send the packet */
887 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
891 data, data_len, TRUE,
895 silc_hash_table_list_reset(&htl);
897 silc_free(packetdata.src_id);
898 silc_free(packetdata.dst_id);
901 /* This function is used to send packets strictly to all local clients
902 on a particular channel. This is used for example to distribute new
903 channel key to all our locally connected clients on the channel.
904 The packets are always encrypted with the session key shared between
905 the client, this means these are not _to the channel_ but _to the client_
908 void silc_server_packet_send_local_channel(SilcServer server,
909 SilcChannelEntry channel,
911 SilcPacketFlags flags,
916 SilcChannelClientEntry chl;
917 SilcHashTableList htl;
918 SilcSocketConnection sock = NULL;
920 SILC_LOG_DEBUG(("Start"));
922 /* Send the message to clients on the channel's client list. */
923 silc_hash_table_list(channel->user_list, &htl);
924 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
925 if (chl->client && !chl->client->router) {
926 sock = (SilcSocketConnection)chl->client->connection;
928 /* Send the packet to the client */
929 silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
930 SILC_ID_CLIENT, data, data_len,
934 silc_hash_table_list_reset(&htl);
937 /* Routine used to send (relay, route) private messages to some destination.
938 If the private message key does not exist then the message is re-encrypted,
939 otherwise we just pass it along. This really is not used to send new
940 private messages (as server does not send them) but to relay received
943 void silc_server_send_private_message(SilcServer server,
944 SilcSocketConnection dst_sock,
948 SilcPacketContext *packet)
950 SilcBuffer buffer = packet->buffer;
951 const SilcBufferStruct p;
953 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
954 + packet->dst_id_len + packet->padlen);
955 if (!silc_packet_send_prepare(dst_sock, 0, 0, buffer->len, hmac,
956 (const SilcBuffer)&p)) {
957 SILC_LOG_ERROR(("Cannot send packet"));
960 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
962 /* Re-encrypt and send if private messge key does not exist */
963 if (!(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY)) {
964 /* Re-encrypt packet */
965 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, buffer->len);
967 /* Key exist so encrypt just header and send it */
968 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p,
969 SILC_PACKET_HEADER_LEN + packet->src_id_len +
970 packet->dst_id_len + packet->padlen);
973 /* Send the packet */
974 silc_server_packet_send_real(server, dst_sock, FALSE);
977 /* Sends current motd to client */
979 void silc_server_send_motd(SilcServer server,
980 SilcSocketConnection sock)
982 char *motd, *motd_file = NULL;
986 motd_file = server->config->server_info->motd_file;
989 motd = silc_file_readfile(motd_file, &motd_len);
993 silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
999 /* Sends error message. Error messages may or may not have any
1002 void silc_server_send_error(SilcServer server,
1003 SilcSocketConnection sock,
1004 const char *fmt, ...)
1007 unsigned char buf[4096];
1009 memset(buf, 0, sizeof(buf));
1011 vsprintf(buf, fmt, ap);
1014 silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
1015 buf, strlen(buf), FALSE);
1018 /* Sends notify message. If format is TRUE the variable arguments are
1019 formatted and the formatted string is sent as argument payload. If it is
1020 FALSE then each argument is sent as separate argument and their format
1021 in the argument list must be { argument data, argument length }. */
1023 void silc_server_send_notify(SilcServer server,
1024 SilcSocketConnection sock,
1026 SilcNotifyType type,
1027 SilcUInt32 argc, ...)
1034 packet = silc_notify_payload_encode(type, argc, ap);
1035 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1036 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1037 packet->data, packet->len, FALSE);
1039 /* Send to backup routers if this is being broadcasted to primary
1041 if (server->router && server->router->connection &&
1042 sock == server->router->connection && broadcast)
1043 silc_server_backup_send(server, NULL, SILC_PACKET_NOTIFY, 0,
1044 packet->data, packet->len, FALSE, TRUE);
1046 silc_buffer_free(packet);
1050 /* Sends notify message and gets the arguments from the `args' Argument
1053 void silc_server_send_notify_args(SilcServer server,
1054 SilcSocketConnection sock,
1056 SilcNotifyType type,
1062 packet = silc_notify_payload_encode_args(type, argc, args);
1063 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1064 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1065 packet->data, packet->len, FALSE);
1066 silc_buffer_free(packet);
1069 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
1070 `old_id' with the `new_id'. */
1072 void silc_server_send_notify_channel_change(SilcServer server,
1073 SilcSocketConnection sock,
1075 SilcChannelID *old_id,
1076 SilcChannelID *new_id)
1078 SilcBuffer idp1, idp2;
1080 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
1081 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
1083 silc_server_send_notify(server, sock, broadcast,
1084 SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
1085 2, idp1->data, idp1->len, idp2->data, idp2->len);
1086 silc_buffer_free(idp1);
1087 silc_buffer_free(idp2);
1090 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
1091 `old_id' with the `new_id'. */
1093 void silc_server_send_notify_nick_change(SilcServer server,
1094 SilcSocketConnection sock,
1096 SilcClientID *old_id,
1097 SilcClientID *new_id,
1098 const char *nickname)
1100 SilcBuffer idp1, idp2;
1102 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
1103 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
1105 silc_server_send_notify(server, sock, broadcast,
1106 SILC_NOTIFY_TYPE_NICK_CHANGE,
1107 3, idp1->data, idp1->len, idp2->data, idp2->len,
1108 nickname, nickname ? strlen(nickname) : 0);
1109 silc_buffer_free(idp1);
1110 silc_buffer_free(idp2);
1113 /* Sends JOIN notify type. This tells that new client by `client_id' ID
1114 has joined to the `channel'. */
1116 void silc_server_send_notify_join(SilcServer server,
1117 SilcSocketConnection sock,
1119 SilcChannelEntry channel,
1120 SilcClientID *client_id)
1122 SilcBuffer idp1, idp2;
1124 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1125 idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1126 silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
1127 2, idp1->data, idp1->len,
1128 idp2->data, idp2->len);
1129 silc_buffer_free(idp1);
1130 silc_buffer_free(idp2);
1133 /* Sends LEAVE notify type. This tells that `client_id' has left the
1134 `channel'. The Notify packet is always destined to the channel. */
1136 void silc_server_send_notify_leave(SilcServer server,
1137 SilcSocketConnection sock,
1139 SilcChannelEntry channel,
1140 SilcClientID *client_id)
1144 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1145 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1146 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
1147 1, idp->data, idp->len);
1148 silc_buffer_free(idp);
1151 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
1152 `channel' mode to `mode. The Notify packet is always destined to
1155 void silc_server_send_notify_cmode(SilcServer server,
1156 SilcSocketConnection sock,
1158 SilcChannelEntry channel,
1159 SilcUInt32 mode_mask,
1160 void *id, SilcIdType id_type,
1161 char *cipher, char *hmac,
1165 unsigned char mode[4];
1167 idp = silc_id_payload_encode((void *)id, id_type);
1168 SILC_PUT32_MSB(mode_mask, mode);
1170 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1171 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
1172 5, idp->data, idp->len,
1174 cipher, cipher ? strlen(cipher) : 0,
1175 hmac, hmac ? strlen(hmac) : 0,
1176 passphrase, passphrase ?
1177 strlen(passphrase) : 0);
1178 silc_buffer_free(idp);
1181 /* Sends CUMODE_CHANGE notify type. This tells that `client_id' changed the
1182 `target' client's mode on `channel'. The notify packet is always
1183 destined to the channel. */
1185 void silc_server_send_notify_cumode(SilcServer server,
1186 SilcSocketConnection sock,
1188 SilcChannelEntry channel,
1189 SilcUInt32 mode_mask,
1190 void *id, SilcIdType id_type,
1191 SilcClientID *target)
1193 SilcBuffer idp1, idp2;
1194 unsigned char mode[4];
1196 idp1 = silc_id_payload_encode((void *)id, id_type);
1197 idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
1198 SILC_PUT32_MSB(mode_mask, mode);
1200 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1202 SILC_NOTIFY_TYPE_CUMODE_CHANGE, 3,
1203 idp1->data, idp1->len,
1205 idp2->data, idp2->len);
1206 silc_buffer_free(idp1);
1207 silc_buffer_free(idp2);
1210 /* Sends SIGNOFF notify type. This tells that `client_id' client has
1211 left SILC network. This function is used only between server and router
1212 traffic. This is not used to send the notify to the channel for
1213 client. The `message may be NULL. */
1215 void silc_server_send_notify_signoff(SilcServer server,
1216 SilcSocketConnection sock,
1218 SilcClientID *client_id,
1219 const char *message)
1223 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1224 silc_server_send_notify(server, sock, broadcast,
1225 SILC_NOTIFY_TYPE_SIGNOFF,
1226 message ? 2 : 1, idp->data, idp->len,
1227 message, message ? strlen(message): 0);
1228 silc_buffer_free(idp);
1231 /* Sends TOPIC_SET notify type. This tells that `id' changed
1232 the `channel's topic to `topic'. The Notify packet is always destined
1233 to the channel. This function is used to send the topic set notifies
1236 void silc_server_send_notify_topic_set(SilcServer server,
1237 SilcSocketConnection sock,
1239 SilcChannelEntry channel,
1240 void *id, SilcIdType id_type,
1245 idp = silc_id_payload_encode(id, id_type);
1246 silc_server_send_notify_dest(server, sock, broadcast,
1247 (void *)channel->id, SILC_ID_CHANNEL,
1248 SILC_NOTIFY_TYPE_TOPIC_SET,
1250 idp->data, idp->len,
1251 topic, topic ? strlen(topic) : 0);
1252 silc_buffer_free(idp);
1255 /* Send KICKED notify type. This tells that the `client_id' on `channel'
1256 was kicked off the channel. The `comment' may indicate the reason
1257 for the kicking. This function is used only between server and router
1260 void silc_server_send_notify_kicked(SilcServer server,
1261 SilcSocketConnection sock,
1263 SilcChannelEntry channel,
1264 SilcClientID *client_id,
1265 SilcClientID *kicker,
1271 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1272 idp2 = silc_id_payload_encode((void *)kicker, SILC_ID_CLIENT);
1273 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1274 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED, 3,
1275 idp1->data, idp1->len,
1276 comment, comment ? strlen(comment) : 0,
1277 idp2->data, idp2->len);
1278 silc_buffer_free(idp1);
1279 silc_buffer_free(idp2);
1282 /* Send KILLED notify type. This tells that the `client_id' client was
1283 killed from the network. The `comment' may indicate the reason
1286 void silc_server_send_notify_killed(SilcServer server,
1287 SilcSocketConnection sock,
1289 SilcClientID *client_id,
1291 SilcClientID *killer)
1296 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1297 idp2 = silc_id_payload_encode((void *)killer, SILC_ID_CLIENT);
1298 silc_server_send_notify_dest(server, sock, broadcast, (void *)client_id,
1299 SILC_ID_CLIENT, SILC_NOTIFY_TYPE_KILLED,
1300 3, idp1->data, idp1->len,
1301 comment, comment ? strlen(comment) : 0,
1302 idp2->data, idp2->len);
1303 silc_buffer_free(idp1);
1304 silc_buffer_free(idp2);
1307 /* Sends UMODE_CHANGE notify type. This tells that `client_id' client's
1308 user mode in the SILC Network was changed. This function is used to
1309 send the packet between routers as broadcast packet. */
1311 void silc_server_send_notify_umode(SilcServer server,
1312 SilcSocketConnection sock,
1314 SilcClientID *client_id,
1315 SilcUInt32 mode_mask)
1318 unsigned char mode[4];
1320 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1321 SILC_PUT32_MSB(mode_mask, mode);
1323 silc_server_send_notify(server, sock, broadcast,
1324 SILC_NOTIFY_TYPE_UMODE_CHANGE, 2,
1325 idp->data, idp->len,
1327 silc_buffer_free(idp);
1330 /* Sends BAN notify type. This tells that ban has been either `add'ed
1331 or `del'eted on the `channel. This function is used to send the packet
1332 between routers as broadcast packet. */
1334 void silc_server_send_notify_ban(SilcServer server,
1335 SilcSocketConnection sock,
1337 SilcChannelEntry channel,
1338 char *add, char *del)
1342 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1343 silc_server_send_notify(server, sock, broadcast,
1344 SILC_NOTIFY_TYPE_BAN, 3,
1345 idp->data, idp->len,
1346 add, add ? strlen(add) : 0,
1347 del, del ? strlen(del) : 0);
1348 silc_buffer_free(idp);
1351 /* Sends INVITE notify type. This tells that invite has been either `add'ed
1352 or `del'eted on the `channel. The sender of the invite is the `client_id'.
1353 This function is used to send the packet between routers as broadcast
1356 void silc_server_send_notify_invite(SilcServer server,
1357 SilcSocketConnection sock,
1359 SilcChannelEntry channel,
1360 SilcClientID *client_id,
1361 char *add, char *del)
1363 SilcBuffer idp, idp2;
1365 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1366 idp2 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1367 silc_server_send_notify(server, sock, broadcast,
1368 SILC_NOTIFY_TYPE_INVITE, 5,
1369 idp->data, idp->len,
1370 channel->channel_name, strlen(channel->channel_name),
1371 idp2->data, idp2->len,
1372 add, add ? strlen(add) : 0,
1373 del, del ? strlen(del) : 0);
1374 silc_buffer_free(idp);
1375 silc_buffer_free(idp2);
1378 /* Sends notify message destined to specific entity. */
1380 void silc_server_send_notify_dest(SilcServer server,
1381 SilcSocketConnection sock,
1384 SilcIdType dest_id_type,
1385 SilcNotifyType type,
1386 SilcUInt32 argc, ...)
1393 packet = silc_notify_payload_encode(type, argc, ap);
1394 silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY,
1395 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1396 dest_id, dest_id_type,
1397 packet->data, packet->len, FALSE);
1398 silc_buffer_free(packet);
1402 /* Sends notify message to a channel. The notify message sent is
1403 distributed to all clients on the channel. If `route_notify' is TRUE
1404 then the notify may be routed to primary route or to some other routers.
1405 If FALSE it is assured that the notify is sent only locally. If `sender'
1406 is provided then the packet is not sent to that connection since it
1407 originally came from it. */
1409 void silc_server_send_notify_to_channel(SilcServer server,
1410 SilcSocketConnection sender,
1411 SilcChannelEntry channel,
1413 SilcNotifyType type,
1414 SilcUInt32 argc, ...)
1421 packet = silc_notify_payload_encode(type, argc, ap);
1422 silc_server_packet_send_to_channel(server, sender, channel,
1423 SILC_PACKET_NOTIFY, route_notify,
1424 packet->data, packet->len, FALSE);
1425 silc_buffer_free(packet);
1429 /* Send notify message to all channels the client has joined. It is quaranteed
1430 that the message is sent only once to a client (ie. if a client is joined
1431 on two same channel it will receive only one notify message). Also, this
1432 sends only to local clients (locally connected if we are server, and to
1433 local servers if we are router). If `sender' is provided the packet is
1434 not sent to that client at all. */
1436 void silc_server_send_notify_on_channels(SilcServer server,
1437 SilcClientEntry sender,
1438 SilcClientEntry client,
1439 SilcNotifyType type,
1440 SilcUInt32 argc, ...)
1443 SilcSocketConnection sock = NULL;
1444 SilcPacketContext packetdata;
1446 SilcClientEntry *sent_clients = NULL;
1447 SilcUInt32 sent_clients_count = 0;
1448 SilcServerEntry *routed = NULL;
1449 SilcUInt32 routed_count = 0;
1450 SilcHashTableList htl, htl2;
1451 SilcChannelEntry channel;
1452 SilcChannelClientEntry chl, chl2;
1453 SilcIDListData idata;
1455 unsigned char *data;
1456 SilcUInt32 data_len;
1457 bool force_send = FALSE;
1460 SILC_LOG_DEBUG(("Start"));
1462 if (!silc_hash_table_count(client->channels))
1466 packet = silc_notify_payload_encode(type, argc, ap);
1467 data = packet->data;
1468 data_len = packet->len;
1470 /* Set the packet context pointers. */
1471 packetdata.flags = 0;
1472 packetdata.type = SILC_PACKET_NOTIFY;
1473 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1474 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
1475 packetdata.src_id_type = SILC_ID_SERVER;
1477 silc_hash_table_list(client->channels, &htl);
1478 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
1479 channel = chl->channel;
1481 /* Send the message to all clients on the channel's client list. */
1482 silc_hash_table_list(channel->user_list, &htl2);
1483 while (silc_hash_table_get(&htl2, NULL, (void *)&chl2)) {
1486 if (sender && c == sender)
1489 /* Check if we have sent the packet to this client already */
1490 for (k = 0; k < sent_clients_count; k++)
1491 if (sent_clients[k] == c)
1493 if (k < sent_clients_count)
1496 /* If we are router and if this client has router set it is not
1497 locally connected client and we will route the message to the
1498 router set in the client. */
1499 if (c && c->router && server->server_type == SILC_ROUTER) {
1500 /* Check if we have sent the packet to this route already */
1501 for (k = 0; k < routed_count; k++)
1502 if (routed[k] == c->router)
1504 if (k < routed_count)
1507 /* Get data used in packet header encryption, keys and stuff. */
1508 sock = (SilcSocketConnection)c->router->connection;
1509 idata = (SilcIDListData)c->router;
1512 SILC_LOG_DEBUG(("*****************"));
1513 SILC_LOG_DEBUG(("client->router->id %s",
1514 silc_id_render(c->router->id, SILC_ID_SERVER)));
1515 SILC_LOG_DEBUG(("client->router->connection->user_data->id %s",
1516 silc_id_render(((SilcServerEntry)sock->user_data)->id, SILC_ID_SERVER)));
1519 packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1520 packetdata.dst_id_len = silc_id_get_len(c->router->id, SILC_ID_SERVER);
1521 packetdata.dst_id_type = SILC_ID_SERVER;
1523 /* Send the packet */
1524 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1528 data, data_len, FALSE,
1531 silc_free(packetdata.dst_id);
1533 /* We want to make sure that the packet is routed to same router
1534 only once. Mark this route as sent route. */
1535 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
1536 routed[routed_count++] = c->router;
1543 /* Send to locally connected client */
1546 /* Get data used in packet header encryption, keys and stuff. */
1547 sock = (SilcSocketConnection)c->connection;
1548 idata = (SilcIDListData)c;
1553 packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1554 packetdata.dst_id_len = silc_id_get_len(c->id, SILC_ID_CLIENT);
1555 packetdata.dst_id_type = SILC_ID_CLIENT;
1557 /* Send the packet */
1558 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1562 data, data_len, FALSE,
1565 silc_free(packetdata.dst_id);
1567 /* Make sure that we send the notify only once per client. */
1568 sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1569 (sent_clients_count + 1));
1570 sent_clients[sent_clients_count++] = c;
1573 silc_hash_table_list_reset(&htl2);
1576 silc_hash_table_list_reset(&htl);
1578 silc_free(sent_clients);
1579 silc_free(packetdata.src_id);
1580 silc_buffer_free(packet);
1584 /* Sends New ID Payload to remote end. The packet is used to distribute
1585 information about new registered clients, servers, channel etc. usually
1586 to routers so that they can keep these information up to date.
1587 If the argument `broadcast' is TRUE then the packet is sent as
1588 broadcast packet. */
1590 void silc_server_send_new_id(SilcServer server,
1591 SilcSocketConnection sock,
1593 void *id, SilcIdType id_type,
1598 SILC_LOG_DEBUG(("Start"));
1600 idp = silc_id_payload_encode(id, id_type);
1601 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1602 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1603 idp->data, idp->len, FALSE);
1605 /* Send to backup routers if this is being broadcasted to primary
1607 if (server->router && server->router->connection &&
1608 sock == server->router->connection && broadcast)
1609 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0,
1610 idp->data, idp->len, FALSE, TRUE);
1612 silc_buffer_free(idp);
1615 /* Send New Channel Payload to notify about newly created channel in the
1616 SILC network. Router uses this to notify other routers in the network
1617 about new channel. This packet is broadcasted by router. */
1619 void silc_server_send_new_channel(SilcServer server,
1620 SilcSocketConnection sock,
1624 SilcUInt32 channel_id_len,
1629 SilcUInt32 name_len = strlen(channel_name);
1631 SILC_LOG_DEBUG(("Start"));
1633 cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1637 /* Encode the channel payload */
1638 packet = silc_channel_payload_encode(channel_name, name_len,
1639 cid, channel_id_len, mode);
1641 silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1642 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1643 packet->data, packet->len, FALSE);
1645 /* Send to backup routers if this is being broadcasted to primary
1647 if (server->server_type == SILC_ROUTER &&
1648 server->router && server->router->connection &&
1649 sock == server->router->connection && broadcast)
1650 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
1651 packet->data, packet->len, FALSE, TRUE);
1654 silc_buffer_free(packet);
1657 /* Send Channel Key payload to distribute the new channel key. Normal server
1658 sends this to router when new client joins to existing channel. Router
1659 sends this to the local server who sent the join command in case where
1660 the channel did not exist yet. Both normal and router servers uses this
1661 also to send this to locally connected clients on the channel. This
1662 must not be broadcasted packet. Routers do not send this to each other.
1663 If `sender is provided then the packet is not sent to that connection since
1664 it originally came from it. */
1666 void silc_server_send_channel_key(SilcServer server,
1667 SilcSocketConnection sender,
1668 SilcChannelEntry channel,
1669 unsigned char route)
1672 unsigned char *chid;
1675 SILC_LOG_DEBUG(("Sending key to channel %s", channel->channel_name));
1677 chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1681 /* Encode channel key packet */
1682 tmp_len = strlen(channel->channel_key->cipher->name);
1683 packet = silc_channel_key_payload_encode(silc_id_get_len(channel->id,
1686 channel->channel_key->cipher->name,
1687 channel->key_len / 8, channel->key);
1688 silc_server_packet_send_to_channel(server, sender, channel,
1689 SILC_PACKET_CHANNEL_KEY,
1690 route, packet->data, packet->len,
1692 silc_buffer_free(packet);
1696 /* Generic function to send any command. The arguments must be sent already
1697 encoded into correct form in correct order. */
1699 void silc_server_send_command(SilcServer server,
1700 SilcSocketConnection sock,
1701 SilcCommand command,
1703 SilcUInt32 argc, ...)
1710 packet = silc_command_payload_encode_vap(command, ident, argc, ap);
1711 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1712 packet->data, packet->len, TRUE);
1713 silc_buffer_free(packet);
1717 /* Generic function to send any command reply. The arguments must be sent
1718 already encoded into correct form in correct order. */
1720 void silc_server_send_command_reply(SilcServer server,
1721 SilcSocketConnection sock,
1722 SilcCommand command,
1723 SilcCommandStatus status,
1724 SilcCommandStatus error,
1726 SilcUInt32 argc, ...)
1733 packet = silc_command_reply_payload_encode_vap(command, status, error,
1735 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1736 packet->data, packet->len, TRUE);
1737 silc_buffer_free(packet);
1741 /* Generic function to send any command reply. The arguments must be sent
1742 already encoded into correct form in correct order. */
1744 void silc_server_send_dest_command_reply(SilcServer server,
1745 SilcSocketConnection sock,
1747 SilcIdType dst_id_type,
1748 SilcCommand command,
1749 SilcCommandStatus status,
1750 SilcCommandStatus error,
1752 SilcUInt32 argc, ...)
1759 packet = silc_command_reply_payload_encode_vap(command, status, error,
1761 silc_server_packet_send_dest(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1762 dst_id, dst_id_type, packet->data,
1764 silc_buffer_free(packet);
1768 /* Send the heartbeat packet. */
1770 void silc_server_send_heartbeat(SilcServer server,
1771 SilcSocketConnection sock)
1773 silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1777 /* Generic function to relay packet we've received. This is used to relay
1778 packets to a client but generally can be used to other purposes as well. */
1780 void silc_server_relay_packet(SilcServer server,
1781 SilcSocketConnection dst_sock,
1784 SilcUInt32 sequence,
1785 SilcPacketContext *packet,
1788 const SilcBufferStruct p;
1790 silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1791 + packet->dst_id_len + packet->padlen);
1792 if (!silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len, hmac,
1793 (const SilcBuffer)&p)) {
1794 SILC_LOG_ERROR(("Cannot send packet"));
1797 silc_buffer_put((SilcBuffer)&p, packet->buffer->data, packet->buffer->len);
1799 /* Re-encrypt packet */
1800 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, p.len);
1802 /* Send the packet */
1803 silc_server_packet_send_real(server, dst_sock, force_send);
1805 silc_buffer_pull(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1806 + packet->dst_id_len + packet->padlen);
1809 /* Routine used to send the connection authentication packet. */
1811 void silc_server_send_connection_auth_request(SilcServer server,
1812 SilcSocketConnection sock,
1813 SilcUInt16 conn_type,
1814 SilcAuthMethod auth_meth)
1818 packet = silc_buffer_alloc(4);
1819 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1820 silc_buffer_format(packet,
1821 SILC_STR_UI_SHORT(conn_type),
1822 SILC_STR_UI_SHORT(auth_meth),
1825 silc_server_packet_send(server, sock, SILC_PACKET_CONNECTION_AUTH_REQUEST,
1826 0, packet->data, packet->len, FALSE);
1827 silc_buffer_free(packet);
1830 /* Purge the outgoing packet queue to the network if there is data. This
1831 function can be used to empty the packet queue. It is guaranteed that
1832 after this function returns the outgoing data queue is empty. */
1834 void silc_server_packet_queue_purge(SilcServer server,
1835 SilcSocketConnection sock)
1837 if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
1838 (SILC_IS_DISCONNECTED(sock) == FALSE)) {
1839 server->stat.packets_sent++;
1840 silc_packet_send(sock, TRUE);
1841 SILC_SET_CONNECTION_FOR_INPUT(server->schedule, sock->sock);
1842 SILC_UNSET_OUTBUF_PENDING(sock);
1843 silc_buffer_clear(sock->outbuf);