5 Author: Pekka Riikonen <priikone@silcnet.org>
7 Copyright (C) 1997 - 2001 Pekka Riikonen
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
21 * Server packet routines to send packets.
25 #include "serverincludes.h"
26 #include "server_internal.h"
28 /* Routine that sends packet or marks packet to be sent. This is used
29 directly only in special cases. Normal cases should use
30 silc_server_packet_send. Returns < 0 error. */
32 int silc_server_packet_send_real(SilcServer server,
33 SilcSocketConnection sock,
38 /* If disconnecting, ignore the data */
39 if (SILC_IS_DISCONNECTING(sock))
42 /* If rekey protocol is active we must assure that all packets are
43 sent through packet queue. */
44 if (SILC_SERVER_IS_REKEY(sock))
47 /* If outbound data is already pending do not force send */
48 if (SILC_IS_OUTBUF_PENDING(sock))
52 ret = silc_packet_send(sock, force_send);
56 /* Mark that there is some outgoing data available for this connection.
57 This call sets the connection both for input and output (the input
58 is set always and this call keeps the input setting, actually).
59 Actual data sending is performed by silc_server_packet_process. */
60 SILC_SET_CONNECTION_FOR_OUTPUT(server->schedule, sock->sock);
62 /* Mark to socket that data is pending in outgoing buffer. This flag
63 is needed if new data is added to the buffer before the earlier
64 put data is sent to the network. */
65 SILC_SET_OUTBUF_PENDING(sock);
70 /* Assembles a new packet to be sent out to network. This doesn't actually
71 send the packet but creates the packet and fills the outgoing data
72 buffer and marks the packet ready to be sent to network. However, If
73 argument force_send is TRUE the packet is sent immediately and not put
74 to queue. Normal case is that the packet is not sent immediately. */
76 void silc_server_packet_send(SilcServer server,
77 SilcSocketConnection sock,
79 SilcPacketFlags flags,
85 SilcIdType dst_id_type = SILC_ID_NONE;
86 SilcIDListData idata = (SilcIDListData)sock->user_data;
91 /* If disconnecting, ignore the data */
92 if (SILC_IS_DISCONNECTING(sock))
95 /* If entry is disabled do not sent anything. */
96 if (idata && idata->status & SILC_IDLIST_STATUS_DISABLED)
99 /* Get data used in the packet sending, keys and stuff */
101 case SILC_SOCKET_TYPE_CLIENT:
102 if (sock->user_data) {
103 dst_id = ((SilcClientEntry)sock->user_data)->id;
104 dst_id_type = SILC_ID_CLIENT;
107 case SILC_SOCKET_TYPE_SERVER:
108 case SILC_SOCKET_TYPE_ROUTER:
109 if (sock->user_data) {
110 dst_id = ((SilcServerEntry)sock->user_data)->id;
111 dst_id_type = SILC_ID_SERVER;
118 silc_server_packet_send_dest(server, sock, type, flags, dst_id,
119 dst_id_type, data, data_len, force_send);
122 /* Assembles a new packet to be sent out to network. This doesn't actually
123 send the packet but creates the packet and fills the outgoing data
124 buffer and marks the packet ready to be sent to network. However, If
125 argument force_send is TRUE the packet is sent immediately and not put
126 to queue. Normal case is that the packet is not sent immediately.
127 Destination information is sent as argument for this function. */
129 void silc_server_packet_send_dest(SilcServer server,
130 SilcSocketConnection sock,
132 SilcPacketFlags flags,
134 SilcIdType dst_id_type,
139 SilcPacketContext packetdata;
140 SilcIDListData idata = (SilcIDListData)sock->user_data;
141 SilcCipher cipher = NULL;
142 SilcHmac hmac = NULL;
144 unsigned char *dst_id_data = NULL;
145 uint32 dst_id_len = 0;
148 /* If disconnecting, ignore the data */
149 if (SILC_IS_DISCONNECTING(sock))
152 /* If entry is disabled do not sent anything. */
153 if (idata && idata->status & SILC_IDLIST_STATUS_DISABLED)
156 SILC_LOG_DEBUG(("Sending packet, type %d", type));
159 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
160 dst_id_len = silc_id_get_len(dst_id, dst_id_type);
164 cipher = idata->send_key;
165 hmac = idata->hmac_send;
166 sequence = idata->psn_send++;
167 block_len = silc_cipher_get_block_len(cipher);
170 /* Set the packet context pointers */
171 packetdata.type = type;
172 packetdata.flags = flags;
173 packetdata.src_id = silc_id_id2str(server->id, server->id_type);
174 packetdata.src_id_len = silc_id_get_len(server->id, server->id_type);
175 packetdata.src_id_type = server->id_type;
176 packetdata.dst_id = dst_id_data;
177 packetdata.dst_id_len = dst_id_len;
178 packetdata.dst_id_type = dst_id_type;
179 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
180 packetdata.src_id_len + dst_id_len;
181 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen, block_len);
183 /* Prepare outgoing data buffer for packet sending */
184 silc_packet_send_prepare(sock,
185 SILC_PACKET_HEADER_LEN +
186 packetdata.src_id_len +
187 packetdata.dst_id_len,
191 SILC_LOG_DEBUG(("Putting data to outgoing buffer, len %d", data_len));
193 packetdata.buffer = sock->outbuf;
195 /* Put the data to the buffer */
196 if (data && data_len)
197 silc_buffer_put(sock->outbuf, data, data_len);
199 /* Create the outgoing packet */
200 silc_packet_assemble(&packetdata, cipher);
202 /* Encrypt the packet */
203 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf, sock->outbuf->len);
205 SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence,
207 sock->outbuf->data, sock->outbuf->len);
209 /* Now actually send the packet */
210 silc_server_packet_send_real(server, sock, force_send);
212 if (packetdata.src_id)
213 silc_free(packetdata.src_id);
214 if (packetdata.dst_id)
215 silc_free(packetdata.dst_id);
218 /* Assembles a new packet to be sent out to network. This doesn't actually
219 send the packet but creates the packet and fills the outgoing data
220 buffer and marks the packet ready to be sent to network. However, If
221 argument force_send is TRUE the packet is sent immediately and not put
222 to queue. Normal case is that the packet is not sent immediately.
223 The source and destination information is sent as argument for this
226 void silc_server_packet_send_srcdest(SilcServer server,
227 SilcSocketConnection sock,
229 SilcPacketFlags flags,
231 SilcIdType src_id_type,
233 SilcIdType dst_id_type,
238 SilcPacketContext packetdata;
239 SilcIDListData idata;
240 SilcCipher cipher = NULL;
241 SilcHmac hmac = NULL;
243 unsigned char *dst_id_data = NULL;
244 uint32 dst_id_len = 0;
245 unsigned char *src_id_data = NULL;
246 uint32 src_id_len = 0;
249 SILC_LOG_DEBUG(("Sending packet, type %d", type));
251 /* Get data used in the packet sending, keys and stuff */
252 idata = (SilcIDListData)sock->user_data;
255 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
256 dst_id_len = silc_id_get_len(dst_id, dst_id_type);
260 src_id_data = silc_id_id2str(src_id, src_id_type);
261 src_id_len = silc_id_get_len(src_id, src_id_type);
265 cipher = idata->send_key;
266 hmac = idata->hmac_send;
267 sequence = idata->psn_send++;
268 block_len = silc_cipher_get_block_len(cipher);
271 /* Set the packet context pointers */
272 packetdata.type = type;
273 packetdata.flags = flags;
274 packetdata.src_id = src_id_data;
275 packetdata.src_id_len = src_id_len;
276 packetdata.src_id_type = src_id_type;
277 packetdata.dst_id = dst_id_data;
278 packetdata.dst_id_len = dst_id_len;
279 packetdata.dst_id_type = dst_id_type;
280 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
281 packetdata.src_id_len + dst_id_len;
282 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen, block_len);
284 /* Prepare outgoing data buffer for packet sending */
285 silc_packet_send_prepare(sock,
286 SILC_PACKET_HEADER_LEN +
287 packetdata.src_id_len +
288 packetdata.dst_id_len,
292 SILC_LOG_DEBUG(("Putting data to outgoing buffer, len %d", data_len));
294 packetdata.buffer = sock->outbuf;
296 /* Put the data to the buffer */
297 if (data && data_len)
298 silc_buffer_put(sock->outbuf, data, data_len);
300 /* Create the outgoing packet */
301 silc_packet_assemble(&packetdata, cipher);
303 /* Encrypt the packet */
304 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf, sock->outbuf->len);
306 SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence,
308 sock->outbuf->data, sock->outbuf->len);
310 /* Now actually send the packet */
311 silc_server_packet_send_real(server, sock, force_send);
313 if (packetdata.src_id)
314 silc_free(packetdata.src_id);
315 if (packetdata.dst_id)
316 silc_free(packetdata.dst_id);
319 /* Broadcast received packet to our primary route. This function is used
320 by router to further route received broadcast packet. It is expected
321 that the broadcast flag from the packet is checked before calling this
322 function. This does not test or set the broadcast flag. */
324 void silc_server_packet_broadcast(SilcServer server,
325 SilcSocketConnection sock,
326 SilcPacketContext *packet)
328 SilcBuffer buffer = packet->buffer;
329 SilcIDListData idata;
332 SILC_LOG_DEBUG(("Broadcasting received broadcast packet"));
334 /* If the packet is originated from our primary route we are
335 not allowed to send the packet. */
336 id = silc_id_str2id(packet->src_id, packet->src_id_len, packet->src_id_type);
337 if (id && !SILC_ID_SERVER_COMPARE(id, server->router->id)) {
338 idata = (SilcIDListData)sock->user_data;
340 silc_buffer_push(buffer, buffer->data - buffer->head);
341 silc_packet_send_prepare(sock, 0, 0, buffer->len);
342 silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
343 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
344 sock->outbuf, sock->outbuf->len);
346 SILC_LOG_HEXDUMP(("Broadcasted packet (%d), len %d", idata->psn_send - 1,
348 sock->outbuf->data, sock->outbuf->len);
350 /* Now actually send the packet */
351 silc_server_packet_send_real(server, sock, TRUE);
356 SILC_LOG_DEBUG(("Will not broadcast to primary route since it is the "
357 "original sender of this packet"));
361 /* Routes received packet to `sock'. This is used to route the packets that
362 router receives but are not destined to it. */
364 void silc_server_packet_route(SilcServer server,
365 SilcSocketConnection sock,
366 SilcPacketContext *packet)
368 SilcBuffer buffer = packet->buffer;
369 SilcIDListData idata;
371 SILC_LOG_DEBUG(("Routing received packet"));
373 idata = (SilcIDListData)sock->user_data;
375 silc_buffer_push(buffer, buffer->data - buffer->head);
376 silc_packet_send_prepare(sock, 0, 0, buffer->len);
377 silc_buffer_put(sock->outbuf, buffer->data, buffer->len);
378 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
379 sock->outbuf, sock->outbuf->len);
381 SILC_LOG_HEXDUMP(("Routed packet (%d), len %d", idata->psn_send - 1,
383 sock->outbuf->data, sock->outbuf->len);
385 /* Now actually send the packet */
386 silc_server_packet_send_real(server, sock, TRUE);
389 /* This routine can be used to send a packet to table of clients provided
390 in `clients'. If `route' is FALSE the packet is routed only to local
391 clients (for server locally connected, and for router local cell). */
393 void silc_server_packet_send_clients(SilcServer server,
394 SilcClientEntry *clients,
395 uint32 clients_count,
397 SilcPacketFlags flags,
403 SilcSocketConnection sock = NULL;
404 SilcClientEntry client = NULL;
405 SilcServerEntry *routed = NULL;
406 uint32 routed_count = 0;
410 SILC_LOG_DEBUG(("Sending packet to list of clients"));
412 /* Send to all clients in table */
413 for (i = 0; i < clients_count; i++) {
416 /* If client has router set it is not locally connected client and
417 we will route the message to the router set in the client. Though,
418 send locally connected server in all cases. */
419 if (server->server_type == SILC_ROUTER && client->router &&
420 ((!route && client->router->router == server->id_entry) || route)) {
422 /* Check if we have sent the packet to this route already */
423 for (k = 0; k < routed_count; k++)
424 if (routed[k] == client->router)
426 if (k < routed_count)
429 /* Route only once to router */
430 sock = (SilcSocketConnection)client->router->connection;
431 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
437 /* Send the packet */
438 silc_server_packet_send_dest(server, sock, type, flags,
439 client->router->id, SILC_ID_SERVER,
440 data, data_len, force_send);
442 /* Mark this route routed already */
443 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
444 routed[routed_count++] = client->router;
451 /* Send to locally connected client */
452 sock = (SilcSocketConnection)client->connection;
453 silc_server_packet_send_dest(server, sock, type, flags,
454 client->id, SILC_ID_CLIENT,
455 data, data_len, force_send);
461 /* Internal routine to actually create the channel packet and send it
462 to network. This is common function in channel message sending. If
463 `channel_message' is TRUE this encrypts the message as it is strictly
464 a channel message. If FALSE normal encryption process is used. */
467 silc_server_packet_send_to_channel_real(SilcServer server,
468 SilcSocketConnection sock,
469 SilcPacketContext *packet,
475 bool channel_message,
479 packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
480 packet->src_id_len + packet->dst_id_len;
482 block_len = cipher ? silc_cipher_get_block_len(cipher) : 0;
484 packet->padlen = SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
486 packet->dst_id_len), block_len);
488 packet->padlen = SILC_PACKET_PADLEN(packet->truelen, block_len);
490 /* Prepare outgoing data buffer for packet sending */
491 silc_packet_send_prepare(sock,
492 SILC_PACKET_HEADER_LEN +
498 packet->buffer = sock->outbuf;
500 /* Put the data to buffer, assemble and encrypt the packet. The packet
501 is encrypted with normal session key shared with the client, unless
502 the `channel_message' is TRUE. */
503 silc_buffer_put(sock->outbuf, data, data_len);
504 silc_packet_assemble(packet, cipher);
506 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf,
507 SILC_PACKET_HEADER_LEN + packet->src_id_len +
508 packet->dst_id_len + packet->padlen);
510 silc_packet_encrypt(cipher, hmac, sequence, sock->outbuf,
513 SILC_LOG_HEXDUMP(("Channel packet (%d), len %d", sequence,
515 sock->outbuf->data, sock->outbuf->len);
517 /* Now actually send the packet */
518 silc_server_packet_send_real(server, sock, force_send);
521 /* This routine is used by the server to send packets to channel. The
522 packet sent with this function is distributed to all clients on
523 the channel. Usually this is used to send notify messages to the
524 channel, things like notify about new user joining to the channel.
525 If `route' is FALSE then the packet is sent only locally and will not
526 be routed anywhere (for router locally means cell wide). If `sender'
527 is provided then the packet is not sent to that connection since it
528 originally came from it. */
530 void silc_server_packet_send_to_channel(SilcServer server,
531 SilcSocketConnection sender,
532 SilcChannelEntry channel,
539 SilcSocketConnection sock = NULL;
540 SilcPacketContext packetdata;
541 SilcClientEntry client = NULL;
542 SilcServerEntry *routed = NULL;
543 SilcChannelClientEntry chl;
544 SilcHashTableList htl;
545 SilcIDListData idata;
546 uint32 routed_count = 0;
550 /* This doesn't send channel message packets */
551 assert(type != SILC_PACKET_CHANNEL_MESSAGE);
553 SILC_LOG_DEBUG(("Sending packet to channel"));
555 /* Set the packet context pointers. */
556 packetdata.flags = 0;
557 packetdata.type = type;
558 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
559 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
560 packetdata.src_id_type = SILC_ID_SERVER;
561 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
562 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
563 packetdata.dst_id_type = SILC_ID_CHANNEL;
565 /* If there are global users in the channel we will send the message
566 first to our router for further routing. */
567 if (route && server->server_type != SILC_ROUTER && !server->standalone &&
568 channel->global_users) {
569 SilcServerEntry router;
571 /* Get data used in packet header encryption, keys and stuff. */
572 router = server->router;
573 sock = (SilcSocketConnection)router->connection;
574 idata = (SilcIDListData)router;
576 if (sock != sender) {
577 SILC_LOG_DEBUG(("Sending channel message to router for routing"));
579 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
583 data, data_len, FALSE,
588 routed = silc_calloc(silc_hash_table_count(channel->user_list),
591 /* Send the message to clients on the channel's client list. */
592 silc_hash_table_list(channel->user_list, &htl);
593 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
594 client = chl->client;
598 /* If client has router set it is not locally connected client and
599 we will route the message to the router set in the client. Though,
600 send locally connected server in all cases. */
601 if (server->server_type == SILC_ROUTER && client->router &&
602 ((!route && client->router->router == server->id_entry) || route)) {
604 /* Check if we have sent the packet to this route already */
605 for (k = 0; k < routed_count; k++)
606 if (routed[k] == client->router)
608 if (k < routed_count)
611 /* Get data used in packet header encryption, keys and stuff. */
612 sock = (SilcSocketConnection)client->router->connection;
613 idata = (SilcIDListData)client->router;
615 if (sender && sock == sender)
618 /* Route only once to router */
619 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
625 /* Send the packet */
626 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
630 data, data_len, FALSE,
633 /* Mark this route routed already */
634 routed[routed_count++] = client->router;
641 /* Send to locally connected client */
643 /* Get data used in packet header encryption, keys and stuff. */
644 sock = (SilcSocketConnection)client->connection;
645 idata = (SilcIDListData)client;
647 if (sender && sock == sender)
650 /* Send the packet */
651 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
655 data, data_len, FALSE,
660 silc_free(packetdata.src_id);
661 silc_free(packetdata.dst_id);
664 /* This checks whether the relayed packet came from router. If it did
665 then we'll need to encrypt it with the channel key. This is called
666 from the silc_server_packet_relay_to_channel. */
669 silc_server_packet_relay_to_channel_encrypt(SilcServer server,
670 SilcSocketConnection sock,
671 SilcChannelEntry channel,
673 unsigned int data_len)
675 /* If we are router and the packet came from router and private key
676 has not been set for the channel then we must encrypt the packet
677 as it was decrypted with the session key shared between us and the
678 router which sent it. This is so, because cells does not share the
680 if (server->server_type == SILC_ROUTER &&
681 sock->type == SILC_SOCKET_TYPE_ROUTER &&
682 !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
683 channel->channel_key) {
688 iv_len = silc_cipher_get_block_len(channel->channel_key);
689 if (channel->iv[0] == '\0')
690 for (i = 0; i < iv_len; i++) channel->iv[i] =
691 silc_rng_get_byte(server->rng);
693 silc_hash_make(server->md5hash, channel->iv, iv_len, channel->iv);
695 /* Encode new payload. This encrypts it also. */
696 SILC_GET16_MSB(flags, data);
697 SILC_GET16_MSB(dlen, data + 2);
699 if (dlen > data_len) {
700 SILC_LOG_WARNING(("Corrupted channel message, cannot relay it"));
704 chp = silc_channel_message_payload_encode(flags, dlen, data + 4,
706 channel->channel_key,
708 memcpy(data, chp->data, chp->len);
709 silc_buffer_free(chp);
715 /* This routine is explicitly used to relay messages to some channel.
716 Packets sent with this function we have received earlier and are
717 totally encrypted. This just sends the packet to all clients on
718 the channel. If the sender of the packet is someone on the channel
719 the message will not be sent to that client. The SILC Packet header
720 is encrypted with the session key shared between us and the client.
721 MAC is also computed before encrypting the header. Rest of the
722 packet will be untouched. */
724 void silc_server_packet_relay_to_channel(SilcServer server,
725 SilcSocketConnection sender_sock,
726 SilcChannelEntry channel,
728 SilcIdType sender_type,
735 SilcSocketConnection sock = NULL;
736 SilcPacketContext packetdata;
737 SilcClientEntry client = NULL;
738 SilcServerEntry *routed = NULL;
739 SilcChannelClientEntry chl;
740 uint32 routed_count = 0;
741 SilcIDListData idata;
742 SilcHashTableList htl;
746 SILC_LOG_DEBUG(("Relaying packet to channel"));
748 /* This encrypts the packet, if needed. It will be encrypted if
749 it came from the router thus it needs to be encrypted with the
750 channel key. If the channel key does not exist, then we know we
751 don't have a single local user on the channel. */
752 if (!silc_server_packet_relay_to_channel_encrypt(server, sender_sock,
757 /* Set the packet context pointers. */
758 packetdata.flags = 0;
759 packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
760 packetdata.src_id = silc_id_id2str(sender, sender_type);
761 packetdata.src_id_len = silc_id_get_len(sender, sender_type);
762 packetdata.src_id_type = sender_type;
763 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
764 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
765 packetdata.dst_id_type = SILC_ID_CHANNEL;
767 /* If there are global users in the channel we will send the message
768 first to our router for further routing. */
769 if (server->server_type != SILC_ROUTER && !server->standalone &&
770 channel->global_users) {
771 SilcServerEntry router = server->router;
773 /* Check that the sender is not our router. */
774 if (sender_sock != (SilcSocketConnection)router->connection) {
776 /* Get data used in packet header encryption, keys and stuff. */
777 sock = (SilcSocketConnection)router->connection;
778 idata = (SilcIDListData)router;
780 SILC_LOG_DEBUG(("Sending channel message to router for routing"));
782 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
786 data, data_len, TRUE,
791 routed = silc_calloc(silc_hash_table_count(channel->user_list),
794 /* Mark that to the route the original sender if from is not routed */
795 if (sender_type == SILC_ID_CLIENT) {
796 client = (SilcClientEntry)sender_entry;
797 if (client->router) {
798 routed[routed_count++] = client->router;
799 SILC_LOG_DEBUG(("************* router %s",
800 silc_id_render(client->router->id, SILC_ID_SERVER)));
804 /* Send the message to clients on the channel's client list. */
805 silc_hash_table_list(channel->user_list, &htl);
806 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
807 client = chl->client;
811 /* Do not send to the sender */
812 if (!found && client == sender_entry) {
817 /* If the client has set router it means that it is not locally
818 connected client and we will route the packet further. */
819 if (server->server_type == SILC_ROUTER && client->router) {
821 /* Sender maybe server as well so we want to make sure that
822 we won't send the message to the server it came from. */
823 if (!found && SILC_ID_SERVER_COMPARE(client->router->id, sender)) {
825 routed[routed_count++] = client->router;
829 /* Check if we have sent the packet to this route already */
830 for (k = 0; k < routed_count; k++)
831 if (routed[k] == client->router)
833 if (k < routed_count)
836 /* Get data used in packet header encryption, keys and stuff. */
837 sock = (SilcSocketConnection)client->router->connection;
838 idata = (SilcIDListData)client->router;
840 /* Do not send to the sender. Check first whether the true
841 sender's router is same as this client's router. Also check
842 if the sender socket is the same as this client's router
845 ((SilcClientEntry)sender_entry)->router == client->router)
847 if (sender_sock && sock == sender_sock)
850 SILC_LOG_DEBUG(("Relaying packet to client ID(%s) %s (%s)",
851 silc_id_render(client->id, SILC_ID_CLIENT),
852 sock->hostname, sock->ip));
854 /* Mark this route routed already. */
855 routed[routed_count++] = client->router;
857 /* If the remote connection is router then we'll decrypt the
858 channel message and re-encrypt it with the session key shared
859 between us and the remote router. This is done because the
860 channel keys are cell specific and we have different channel
861 key than the remote router has. */
862 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
866 SILC_LOG_DEBUG(("Remote is router, encrypt with session key"));
869 /* If private key mode is not set then decrypt the packet
871 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
872 unsigned char *tmp = silc_calloc(data_len, sizeof(*data));
873 memcpy(tmp, data, data_len);
875 /* Decrypt the channel message (we don't check the MAC) */
876 if (channel->channel_key &&
877 !silc_channel_message_payload_decrypt(tmp, data_len,
878 channel->channel_key,
880 memset(tmp, 0, data_len);
885 /* Now re-encrypt and send it to the router */
886 silc_server_packet_send_srcdest(server, sock,
887 SILC_PACKET_CHANNEL_MESSAGE, 0,
889 channel->id, SILC_ID_CHANNEL,
890 tmp, data_len, force_send);
892 /* Free the copy of the channel message */
893 memset(tmp, 0, data_len);
896 /* Private key mode is set, we don't have the channel key, so
897 just re-encrypt the entire packet and send it to the router. */
898 silc_server_packet_send_srcdest(server, sock,
899 SILC_PACKET_CHANNEL_MESSAGE, 0,
901 channel->id, SILC_ID_CHANNEL,
902 data, data_len, force_send);
907 /* Send the packet (to normal server) */
908 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
912 data, data_len, TRUE,
921 /* Get data used in packet header encryption, keys and stuff. */
922 sock = (SilcSocketConnection)client->connection;
923 idata = (SilcIDListData)client;
925 if (sender_sock && sock == sender_sock)
928 SILC_LOG_DEBUG(("Sending packet to client ID(%s) %s (%s)",
929 silc_id_render(client->id, SILC_ID_CLIENT),
930 sock->hostname, sock->ip));
932 /* Send the packet */
933 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
937 data, data_len, TRUE,
942 silc_free(packetdata.src_id);
943 silc_free(packetdata.dst_id);
946 /* This function is used to send packets strictly to all local clients
947 on a particular channel. This is used for example to distribute new
948 channel key to all our locally connected clients on the channel.
949 The packets are always encrypted with the session key shared between
950 the client, this means these are not _to the channel_ but _to the client_
953 void silc_server_packet_send_local_channel(SilcServer server,
954 SilcChannelEntry channel,
956 SilcPacketFlags flags,
961 SilcChannelClientEntry chl;
962 SilcHashTableList htl;
963 SilcSocketConnection sock = NULL;
965 SILC_LOG_DEBUG(("Start"));
967 /* Send the message to clients on the channel's client list. */
968 silc_hash_table_list(channel->user_list, &htl);
969 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
970 if (chl->client && !chl->client->router) {
971 sock = (SilcSocketConnection)chl->client->connection;
973 /* Send the packet to the client */
974 silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
975 SILC_ID_CLIENT, data, data_len,
981 /* Routine used to send (relay, route) private messages to some destination.
982 If the private message key does not exist then the message is re-encrypted,
983 otherwise we just pass it along. This really is not used to send new
984 private messages (as server does not send them) but to relay received
987 void silc_server_send_private_message(SilcServer server,
988 SilcSocketConnection dst_sock,
992 SilcPacketContext *packet)
994 SilcBuffer buffer = packet->buffer;
996 /* Re-encrypt and send if private messge key does not exist */
997 if (!(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY)) {
999 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1000 + packet->dst_id_len + packet->padlen);
1001 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1002 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1004 /* Re-encrypt packet */
1005 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf, buffer->len);
1007 /* Send the packet */
1008 silc_server_packet_send_real(server, dst_sock, FALSE);
1011 /* Key exist so encrypt just header and send it */
1012 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1013 + packet->dst_id_len + packet->padlen);
1014 silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1015 silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1017 /* Encrypt header */
1018 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf,
1019 SILC_PACKET_HEADER_LEN + packet->src_id_len +
1020 packet->dst_id_len + packet->padlen);
1022 silc_server_packet_send_real(server, dst_sock, FALSE);
1026 /* Sends current motd to client */
1028 void silc_server_send_motd(SilcServer server,
1029 SilcSocketConnection sock)
1034 if (server->config && server->config->motd &&
1035 server->config->motd->motd_file) {
1037 motd = silc_file_readfile(server->config->motd->motd_file, &motd_len);
1041 silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
1047 /* Sends error message. Error messages may or may not have any
1050 void silc_server_send_error(SilcServer server,
1051 SilcSocketConnection sock,
1052 const char *fmt, ...)
1055 unsigned char buf[4096];
1057 memset(buf, 0, sizeof(buf));
1059 vsprintf(buf, fmt, ap);
1062 silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
1063 buf, strlen(buf), FALSE);
1066 /* Sends notify message. If format is TRUE the variable arguments are
1067 formatted and the formatted string is sent as argument payload. If it is
1068 FALSE then each argument is sent as separate argument and their format
1069 in the argument list must be { argument data, argument length }. */
1071 void silc_server_send_notify(SilcServer server,
1072 SilcSocketConnection sock,
1074 SilcNotifyType type,
1082 packet = silc_notify_payload_encode(type, argc, ap);
1083 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1084 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1085 packet->data, packet->len, FALSE);
1087 /* Send to backup routers if this is being broadcasted to primary
1089 if (server->router && server->router->connection &&
1090 sock == server->router->connection && broadcast)
1091 silc_server_backup_send(server, NULL, SILC_PACKET_NOTIFY, 0,
1092 packet->data, packet->len, FALSE, TRUE);
1094 silc_buffer_free(packet);
1098 /* Sends notify message and gets the arguments from the `args' Argument
1101 void silc_server_send_notify_args(SilcServer server,
1102 SilcSocketConnection sock,
1104 SilcNotifyType type,
1110 packet = silc_notify_payload_encode_args(type, argc, args);
1111 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1112 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1113 packet->data, packet->len, FALSE);
1114 silc_buffer_free(packet);
1117 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
1118 `old_id' with the `new_id'. */
1120 void silc_server_send_notify_channel_change(SilcServer server,
1121 SilcSocketConnection sock,
1123 SilcChannelID *old_id,
1124 SilcChannelID *new_id)
1126 SilcBuffer idp1, idp2;
1128 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
1129 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
1131 silc_server_send_notify(server, sock, broadcast,
1132 SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
1133 2, idp1->data, idp1->len, idp2->data, idp2->len);
1134 silc_buffer_free(idp1);
1135 silc_buffer_free(idp2);
1138 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
1139 `old_id' with the `new_id'. */
1141 void silc_server_send_notify_nick_change(SilcServer server,
1142 SilcSocketConnection sock,
1144 SilcClientID *old_id,
1145 SilcClientID *new_id)
1147 SilcBuffer idp1, idp2;
1149 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
1150 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
1152 silc_server_send_notify(server, sock, broadcast,
1153 SILC_NOTIFY_TYPE_NICK_CHANGE,
1154 2, idp1->data, idp1->len, idp2->data, idp2->len);
1155 silc_buffer_free(idp1);
1156 silc_buffer_free(idp2);
1159 /* Sends JOIN notify type. This tells that new client by `client_id' ID
1160 has joined to the `channel'. */
1162 void silc_server_send_notify_join(SilcServer server,
1163 SilcSocketConnection sock,
1165 SilcChannelEntry channel,
1166 SilcClientID *client_id)
1168 SilcBuffer idp1, idp2;
1170 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1171 idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1172 silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
1173 2, idp1->data, idp1->len,
1174 idp2->data, idp2->len);
1175 silc_buffer_free(idp1);
1176 silc_buffer_free(idp2);
1179 /* Sends LEAVE notify type. This tells that `client_id' has left the
1180 `channel'. The Notify packet is always destined to the channel. */
1182 void silc_server_send_notify_leave(SilcServer server,
1183 SilcSocketConnection sock,
1185 SilcChannelEntry channel,
1186 SilcClientID *client_id)
1190 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1191 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1192 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
1193 1, idp->data, idp->len);
1194 silc_buffer_free(idp);
1197 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
1198 `channel' mode to `mode. The Notify packet is always destined to
1201 void silc_server_send_notify_cmode(SilcServer server,
1202 SilcSocketConnection sock,
1204 SilcChannelEntry channel,
1206 void *id, SilcIdType id_type,
1207 char *cipher, char *hmac)
1210 unsigned char mode[4];
1212 idp = silc_id_payload_encode((void *)id, id_type);
1213 SILC_PUT32_MSB(mode_mask, mode);
1215 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1216 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
1217 4, idp->data, idp->len,
1219 cipher, cipher ? strlen(cipher) : 0,
1220 hmac, hmac ? strlen(hmac) : 0);
1221 silc_buffer_free(idp);
1224 /* Sends CUMODE_CHANGE notify type. This tells that `client_id' changed the
1225 `target' client's mode on `channel'. The Notify packet is always
1226 destined to the channel. */
1228 void silc_server_send_notify_cumode(SilcServer server,
1229 SilcSocketConnection sock,
1231 SilcChannelEntry channel,
1233 void *id, SilcIdType id_type,
1234 SilcClientID *target)
1236 SilcBuffer idp1, idp2;
1237 unsigned char mode[4];
1239 idp1 = silc_id_payload_encode((void *)id, id_type);
1240 idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
1241 SILC_PUT32_MSB(mode_mask, mode);
1243 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1245 SILC_NOTIFY_TYPE_CUMODE_CHANGE, 3,
1246 idp1->data, idp1->len,
1248 idp2->data, idp2->len);
1249 silc_buffer_free(idp1);
1250 silc_buffer_free(idp2);
1253 /* Sends SIGNOFF notify type. This tells that `client_id' client has
1254 left SILC network. This function is used only between server and router
1255 traffic. This is not used to send the notify to the channel for
1256 client. The `message may be NULL. */
1258 void silc_server_send_notify_signoff(SilcServer server,
1259 SilcSocketConnection sock,
1261 SilcClientID *client_id,
1266 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1267 silc_server_send_notify(server, sock, broadcast,
1268 SILC_NOTIFY_TYPE_SIGNOFF,
1269 message ? 2 : 1, idp->data, idp->len,
1270 message, message ? strlen(message): 0);
1271 silc_buffer_free(idp);
1274 /* Sends TOPIC_SET notify type. This tells that `client_id' changed
1275 the `channel's topic to `topic'. The Notify packet is always destined
1276 to the channel. This function is used to send the topic set notifies
1279 void silc_server_send_notify_topic_set(SilcServer server,
1280 SilcSocketConnection sock,
1282 SilcChannelEntry channel,
1283 SilcClientID *client_id,
1288 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1289 silc_server_send_notify(server, sock, broadcast,
1290 SILC_NOTIFY_TYPE_TOPIC_SET,
1292 idp->data, idp->len,
1293 topic, topic ? strlen(topic) : 0);
1294 silc_buffer_free(idp);
1297 /* Send KICKED notify type. This tells that the `client_id' on `channel'
1298 was kicked off the channel. The `comment' may indicate the reason
1299 for the kicking. This function is used only between server and router
1302 void silc_server_send_notify_kicked(SilcServer server,
1303 SilcSocketConnection sock,
1305 SilcChannelEntry channel,
1306 SilcClientID *client_id,
1311 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1312 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1313 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED,
1314 comment ? 2 : 1, idp->data, idp->len,
1315 comment, comment ? strlen(comment) : 0);
1316 silc_buffer_free(idp);
1319 /* Send KILLED notify type. This tells that the `client_id' client was
1320 killed from the network. The `comment' may indicate the reason
1323 void silc_server_send_notify_killed(SilcServer server,
1324 SilcSocketConnection sock,
1326 SilcClientID *client_id,
1331 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1332 silc_server_send_notify_dest(server, sock, broadcast, (void *)client_id,
1333 SILC_ID_CLIENT, SILC_NOTIFY_TYPE_KILLED,
1334 comment ? 2 : 1, idp->data, idp->len,
1335 comment, comment ? strlen(comment) : 0);
1336 silc_buffer_free(idp);
1339 /* Sends UMODE_CHANGE notify type. This tells that `client_id' client's
1340 user mode in the SILC Network was changed. This function is used to
1341 send the packet between routers as broadcast packet. */
1343 void silc_server_send_notify_umode(SilcServer server,
1344 SilcSocketConnection sock,
1346 SilcClientID *client_id,
1350 unsigned char mode[4];
1352 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1353 SILC_PUT32_MSB(mode_mask, mode);
1355 silc_server_send_notify(server, sock, broadcast,
1356 SILC_NOTIFY_TYPE_UMODE_CHANGE, 2,
1357 idp->data, idp->len,
1359 silc_buffer_free(idp);
1362 /* Sends BAN notify type. This tells that ban has been either `add'ed
1363 or `del'eted on the `channel. This function is used to send the packet
1364 between routers as broadcast packet. */
1366 void silc_server_send_notify_ban(SilcServer server,
1367 SilcSocketConnection sock,
1369 SilcChannelEntry channel,
1370 char *add, char *del)
1374 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1375 silc_server_send_notify(server, sock, broadcast,
1376 SILC_NOTIFY_TYPE_BAN, 3,
1377 idp->data, idp->len,
1378 add, add ? strlen(add) : 0,
1379 del, del ? strlen(del) : 0);
1380 silc_buffer_free(idp);
1383 /* Sends INVITE notify type. This tells that invite has been either `add'ed
1384 or `del'eted on the `channel. The sender of the invite is the `client_id'.
1385 This function is used to send the packet between routers as broadcast
1388 void silc_server_send_notify_invite(SilcServer server,
1389 SilcSocketConnection sock,
1391 SilcChannelEntry channel,
1392 SilcClientID *client_id,
1393 char *add, char *del)
1395 SilcBuffer idp, idp2;
1397 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1398 idp2 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1399 silc_server_send_notify(server, sock, broadcast,
1400 SILC_NOTIFY_TYPE_INVITE, 5,
1401 idp->data, idp->len,
1402 channel->channel_name, strlen(channel->channel_name),
1403 idp2->data, idp2->len,
1404 add, add ? strlen(add) : 0,
1405 del, del ? strlen(del) : 0);
1406 silc_buffer_free(idp);
1407 silc_buffer_free(idp2);
1410 /* Sends notify message destined to specific entity. */
1412 void silc_server_send_notify_dest(SilcServer server,
1413 SilcSocketConnection sock,
1416 SilcIdType dest_id_type,
1417 SilcNotifyType type,
1425 packet = silc_notify_payload_encode(type, argc, ap);
1426 silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY,
1427 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1428 dest_id, dest_id_type,
1429 packet->data, packet->len, FALSE);
1430 silc_buffer_free(packet);
1434 /* Sends notify message to a channel. The notify message sent is
1435 distributed to all clients on the channel. If `route_notify' is TRUE
1436 then the notify may be routed to primary route or to some other routers.
1437 If FALSE it is assured that the notify is sent only locally. If `sender'
1438 is provided then the packet is not sent to that connection since it
1439 originally came from it. */
1441 void silc_server_send_notify_to_channel(SilcServer server,
1442 SilcSocketConnection sender,
1443 SilcChannelEntry channel,
1444 unsigned char route_notify,
1445 SilcNotifyType type,
1453 packet = silc_notify_payload_encode(type, argc, ap);
1454 silc_server_packet_send_to_channel(server, sender, channel,
1455 SILC_PACKET_NOTIFY, route_notify,
1456 packet->data, packet->len, FALSE);
1457 silc_buffer_free(packet);
1461 /* Send notify message to all channels the client has joined. It is quaranteed
1462 that the message is sent only once to a client (ie. if a client is joined
1463 on two same channel it will receive only one notify message). Also, this
1464 sends only to local clients (locally connected if we are server, and to
1465 local servers if we are router). If `sender' is provided the packet is
1466 not sent to that client at all. */
1468 void silc_server_send_notify_on_channels(SilcServer server,
1469 SilcClientEntry sender,
1470 SilcClientEntry client,
1471 SilcNotifyType type,
1475 SilcSocketConnection sock = NULL;
1476 SilcPacketContext packetdata;
1478 SilcClientEntry *sent_clients = NULL;
1479 uint32 sent_clients_count = 0;
1480 SilcServerEntry *routed = NULL;
1481 uint32 routed_count = 0;
1482 SilcHashTableList htl, htl2;
1483 SilcChannelEntry channel;
1484 SilcChannelClientEntry chl, chl2;
1485 SilcIDListData idata;
1487 unsigned char *data;
1489 bool force_send = FALSE;
1492 SILC_LOG_DEBUG(("Start"));
1494 if (!silc_hash_table_count(client->channels))
1498 packet = silc_notify_payload_encode(type, argc, ap);
1499 data = packet->data;
1500 data_len = packet->len;
1502 /* Set the packet context pointers. */
1503 packetdata.flags = 0;
1504 packetdata.type = SILC_PACKET_NOTIFY;
1505 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1506 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
1507 packetdata.src_id_type = SILC_ID_SERVER;
1509 silc_hash_table_list(client->channels, &htl);
1510 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
1511 channel = chl->channel;
1513 /* Send the message to all clients on the channel's client list. */
1514 silc_hash_table_list(channel->user_list, &htl2);
1515 while (silc_hash_table_get(&htl2, NULL, (void *)&chl2)) {
1518 if (sender && c == sender)
1521 /* Check if we have sent the packet to this client already */
1522 for (k = 0; k < sent_clients_count; k++)
1523 if (sent_clients[k] == c)
1525 if (k < sent_clients_count)
1528 /* If we are router and if this client has router set it is not
1529 locally connected client and we will route the message to the
1530 router set in the client. */
1531 if (c && c->router && server->server_type == SILC_ROUTER) {
1532 /* Check if we have sent the packet to this route already */
1533 for (k = 0; k < routed_count; k++)
1534 if (routed[k] == c->router)
1536 if (k < routed_count)
1539 /* Get data used in packet header encryption, keys and stuff. */
1540 sock = (SilcSocketConnection)c->router->connection;
1541 idata = (SilcIDListData)c->router;
1544 SILC_LOG_DEBUG(("*****************"));
1545 SILC_LOG_DEBUG(("client->router->id %s",
1546 silc_id_render(c->router->id, SILC_ID_SERVER)));
1547 SILC_LOG_DEBUG(("client->router->connection->user_data->id %s",
1548 silc_id_render(((SilcServerEntry)sock->user_data)->id, SILC_ID_SERVER)));
1551 packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1552 packetdata.dst_id_len = silc_id_get_len(c->router->id, SILC_ID_SERVER);
1553 packetdata.dst_id_type = SILC_ID_SERVER;
1555 /* Send the packet */
1556 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1560 data, data_len, FALSE,
1563 silc_free(packetdata.dst_id);
1565 /* We want to make sure that the packet is routed to same router
1566 only once. Mark this route as sent route. */
1567 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
1568 routed[routed_count++] = c->router;
1575 /* Send to locally connected client */
1578 /* Get data used in packet header encryption, keys and stuff. */
1579 sock = (SilcSocketConnection)c->connection;
1580 idata = (SilcIDListData)c;
1582 packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1583 packetdata.dst_id_len = silc_id_get_len(c->id, SILC_ID_CLIENT);
1584 packetdata.dst_id_type = SILC_ID_CLIENT;
1586 /* Send the packet */
1587 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1591 data, data_len, FALSE,
1594 silc_free(packetdata.dst_id);
1596 /* Make sure that we send the notify only once per client. */
1597 sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1598 (sent_clients_count + 1));
1599 sent_clients[sent_clients_count++] = c;
1605 silc_free(sent_clients);
1606 silc_free(packetdata.src_id);
1610 /* Sends New ID Payload to remote end. The packet is used to distribute
1611 information about new registered clients, servers, channel etc. usually
1612 to routers so that they can keep these information up to date.
1613 If the argument `broadcast' is TRUE then the packet is sent as
1614 broadcast packet. */
1616 void silc_server_send_new_id(SilcServer server,
1617 SilcSocketConnection sock,
1619 void *id, SilcIdType id_type,
1624 SILC_LOG_DEBUG(("Start"));
1626 idp = silc_id_payload_encode(id, id_type);
1627 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1628 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1629 idp->data, idp->len, FALSE);
1631 /* Send to backup routers if this is being broadcasted to primary
1633 if (server->router && server->router->connection &&
1634 sock == server->router->connection && broadcast)
1635 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0,
1636 idp->data, idp->len, FALSE, TRUE);
1638 silc_buffer_free(idp);
1641 /* Send New Channel Payload to notify about newly created channel in the
1642 SILC network. Normal server nevers sends this packet. Router uses this
1643 to notify other routers in the network about new channel. This packet
1646 void silc_server_send_new_channel(SilcServer server,
1647 SilcSocketConnection sock,
1651 uint32 channel_id_len,
1656 uint32 name_len = strlen(channel_name);
1658 SILC_LOG_DEBUG(("Start"));
1660 cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1664 /* Encode the channel payload */
1665 packet = silc_channel_payload_encode(channel_name, name_len,
1666 cid, channel_id_len, mode);
1668 silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1669 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1670 packet->data, packet->len, FALSE);
1672 /* Send to backup routers if this is being broadcasted to primary
1674 if (server->router && server->router->connection &&
1675 sock == server->router->connection && broadcast)
1676 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
1677 packet->data, packet->len, FALSE, TRUE);
1680 silc_buffer_free(packet);
1683 /* Send Channel Key payload to distribute the new channel key. Normal server
1684 sends this to router when new client joins to existing channel. Router
1685 sends this to the local server who sent the join command in case where
1686 the channel did not exist yet. Both normal and router servers uses this
1687 also to send this to locally connected clients on the channel. This
1688 must not be broadcasted packet. Routers do not send this to each other.
1689 If `sender is provided then the packet is not sent to that connection since
1690 it originally came from it. */
1692 void silc_server_send_channel_key(SilcServer server,
1693 SilcSocketConnection sender,
1694 SilcChannelEntry channel,
1695 unsigned char route)
1698 unsigned char *chid;
1701 SILC_LOG_DEBUG(("Start"));
1703 chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1707 /* Encode channel key packet */
1708 tmp_len = strlen(channel->channel_key->cipher->name);
1709 packet = silc_channel_key_payload_encode(silc_id_get_len(channel->id,
1712 channel->channel_key->cipher->name,
1713 channel->key_len / 8, channel->key);
1714 silc_server_packet_send_to_channel(server, sender, channel,
1715 SILC_PACKET_CHANNEL_KEY,
1716 route, packet->data, packet->len, FALSE);
1717 silc_buffer_free(packet);
1721 /* Generic function to send any command. The arguments must be sent already
1722 encoded into correct form in correct order. */
1724 void silc_server_send_command(SilcServer server,
1725 SilcSocketConnection sock,
1726 SilcCommand command,
1735 packet = silc_command_payload_encode_vap(command, ident, argc, ap);
1736 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1737 packet->data, packet->len, TRUE);
1738 silc_buffer_free(packet);
1742 /* Send the heartbeat packet. */
1744 void silc_server_send_heartbeat(SilcServer server,
1745 SilcSocketConnection sock)
1747 silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1751 /* Generic function to relay packet we've received. This is used to relay
1752 packets to a client but generally can be used to other purposes as well. */
1754 void silc_server_relay_packet(SilcServer server,
1755 SilcSocketConnection dst_sock,
1759 SilcPacketContext *packet,
1762 silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1763 + packet->dst_id_len + packet->padlen);
1765 silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len);
1766 silc_buffer_put(dst_sock->outbuf, packet->buffer->data, packet->buffer->len);
1768 /* Re-encrypt packet */
1769 silc_packet_encrypt(cipher, hmac, sequence, dst_sock->outbuf,
1770 packet->buffer->len);
1772 /* Send the packet */
1773 silc_server_packet_send_real(server, dst_sock, force_send);
1775 silc_buffer_pull(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1776 + packet->dst_id_len + packet->padlen);
1779 /* Routine used to send the connection authentication packet. */
1781 void silc_server_send_connection_auth_request(SilcServer server,
1782 SilcSocketConnection sock,
1784 SilcAuthMethod auth_meth)
1788 packet = silc_buffer_alloc(4);
1789 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1790 silc_buffer_format(packet,
1791 SILC_STR_UI_SHORT(conn_type),
1792 SILC_STR_UI_SHORT(auth_meth),
1795 silc_server_packet_send(server, sock, SILC_PACKET_CONNECTION_AUTH_REQUEST,
1796 0, packet->data, packet->len, FALSE);
1797 silc_buffer_free(packet);
1800 /* Purge the outgoing packet queue to the network if there is data. This
1801 function can be used to empty the packet queue. It is guaranteed that
1802 after this function returns the outgoing data queue is empty. */
1804 void silc_server_packet_queue_purge(SilcServer server,
1805 SilcSocketConnection sock)
1807 if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
1808 (SILC_IS_DISCONNECTED(sock) == FALSE)) {
1809 server->stat.packets_sent++;
1811 if (sock->outbuf->data - sock->outbuf->head)
1812 silc_buffer_push(sock->outbuf, sock->outbuf->data - sock->outbuf->head);
1814 silc_packet_send(sock, TRUE);
1816 SILC_SET_CONNECTION_FOR_INPUT(server->schedule, sock->sock);
1817 SILC_UNSET_OUTBUF_PENDING(sock);
1818 silc_buffer_clear(sock->outbuf);