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);
54 server->stat.packets_sent++;
58 /* Mark that there is some outgoing data available for this connection.
59 This call sets the connection both for input and output (the input
60 is set always and this call keeps the input setting, actually).
61 Actual data sending is performed by silc_server_packet_process. */
62 SILC_SET_CONNECTION_FOR_OUTPUT(server->schedule, sock->sock);
64 /* Mark to socket that data is pending in outgoing buffer. This flag
65 is needed if new data is added to the buffer before the earlier
66 put data is sent to the network. */
67 SILC_SET_OUTBUF_PENDING(sock);
72 /* Assembles a new packet to be sent out to network. This doesn't actually
73 send the packet but creates the packet and fills the outgoing data
74 buffer and marks the packet ready to be sent to network. However, If
75 argument force_send is TRUE the packet is sent immediately and not put
76 to queue. Normal case is that the packet is not sent immediately. */
78 void silc_server_packet_send(SilcServer server,
79 SilcSocketConnection sock,
81 SilcPacketFlags flags,
87 SilcIdType dst_id_type = SILC_ID_NONE;
93 idata = (SilcIDListData)sock->user_data;
95 /* If disconnecting, ignore the data */
96 if (SILC_IS_DISCONNECTING(sock))
99 /* If entry is disabled do not sent anything. */
100 if (idata && idata->status & SILC_IDLIST_STATUS_DISABLED)
103 /* Get data used in the packet sending, keys and stuff */
105 case SILC_SOCKET_TYPE_CLIENT:
106 if (sock->user_data) {
107 dst_id = ((SilcClientEntry)sock->user_data)->id;
108 dst_id_type = SILC_ID_CLIENT;
111 case SILC_SOCKET_TYPE_SERVER:
112 case SILC_SOCKET_TYPE_ROUTER:
113 if (sock->user_data) {
114 dst_id = ((SilcServerEntry)sock->user_data)->id;
115 dst_id_type = SILC_ID_SERVER;
122 silc_server_packet_send_dest(server, sock, type, flags, dst_id,
123 dst_id_type, data, data_len, force_send);
126 /* Assembles a new packet to be sent out to network. This doesn't actually
127 send the packet but creates the packet and fills the outgoing data
128 buffer and marks the packet ready to be sent to network. However, If
129 argument force_send is TRUE the packet is sent immediately and not put
130 to queue. Normal case is that the packet is not sent immediately.
131 Destination information is sent as argument for this function. */
133 void silc_server_packet_send_dest(SilcServer server,
134 SilcSocketConnection sock,
136 SilcPacketFlags flags,
138 SilcIdType dst_id_type,
143 SilcPacketContext packetdata;
144 const SilcBufferStruct packet;
145 SilcIDListData idata;
146 SilcCipher cipher = NULL;
147 SilcHmac hmac = NULL;
148 SilcUInt32 sequence = 0;
149 unsigned char *dst_id_data = NULL;
150 SilcUInt32 dst_id_len = 0;
153 /* If disconnecting, ignore the data */
154 if (!sock || SILC_IS_DISCONNECTING(sock))
157 idata = (SilcIDListData)sock->user_data;
159 /* If entry is disabled do not sent anything. */
160 if (idata && idata->status & SILC_IDLIST_STATUS_DISABLED)
163 SILC_LOG_DEBUG(("Sending %s packet", silc_get_packet_name(type)));
166 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
167 dst_id_len = silc_id_get_len(dst_id, dst_id_type);
171 cipher = idata->send_key;
172 hmac = idata->hmac_send;
173 sequence = idata->psn_send++;
174 block_len = silc_cipher_get_block_len(cipher);
177 /* Set the packet context pointers */
178 packetdata.type = type;
179 packetdata.flags = flags;
180 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
181 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
182 packetdata.src_id_type = SILC_ID_SERVER;
183 packetdata.dst_id = dst_id_data;
184 packetdata.dst_id_len = dst_id_len;
185 packetdata.dst_id_type = dst_id_type;
186 data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
187 packetdata.src_id_len +
188 packetdata.dst_id_len));
189 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
190 packetdata.src_id_len + dst_id_len;
191 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen, block_len);
193 /* Create the outgoing packet */
194 if (!silc_packet_assemble(&packetdata, NULL, cipher, hmac, sock,
195 data, data_len, (const SilcBuffer)&packet)) {
196 SILC_LOG_ERROR(("Cannot assemble packet"));
200 /* Encrypt the packet */
201 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&packet, packet.len);
203 SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence, packet.len),
204 packet.data, packet.len);
206 /* Now actually send the packet */
207 silc_server_packet_send_real(server, sock, force_send);
210 if (packetdata.src_id)
211 silc_free(packetdata.src_id);
212 if (packetdata.dst_id)
213 silc_free(packetdata.dst_id);
216 /* Assembles a new packet to be sent out to network. This doesn't actually
217 send the packet but creates the packet and fills the outgoing data
218 buffer and marks the packet ready to be sent to network. However, If
219 argument force_send is TRUE the packet is sent immediately and not put
220 to queue. Normal case is that the packet is not sent immediately.
221 The source and destination information is sent as argument for this
224 void silc_server_packet_send_srcdest(SilcServer server,
225 SilcSocketConnection sock,
227 SilcPacketFlags flags,
229 SilcIdType src_id_type,
231 SilcIdType dst_id_type,
236 SilcPacketContext packetdata;
237 const SilcBufferStruct packet;
238 SilcIDListData idata;
239 SilcCipher cipher = NULL;
240 SilcHmac hmac = NULL;
241 SilcUInt32 sequence = 0;
242 unsigned char *dst_id_data = NULL;
243 SilcUInt32 dst_id_len = 0;
244 unsigned char *src_id_data = NULL;
245 SilcUInt32 src_id_len = 0;
248 SILC_LOG_DEBUG(("Sending %s packet", silc_get_packet_name(type)));
253 /* Get data used in the packet sending, keys and stuff */
254 idata = (SilcIDListData)sock->user_data;
257 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
258 dst_id_len = silc_id_get_len(dst_id, dst_id_type);
262 src_id_data = silc_id_id2str(src_id, src_id_type);
263 src_id_len = silc_id_get_len(src_id, src_id_type);
267 cipher = idata->send_key;
268 hmac = idata->hmac_send;
269 sequence = idata->psn_send++;
270 block_len = silc_cipher_get_block_len(cipher);
273 /* Set the packet context pointers */
274 packetdata.type = type;
275 packetdata.flags = flags;
276 packetdata.src_id = src_id_data;
277 packetdata.src_id_len = src_id_len;
278 packetdata.src_id_type = src_id_type;
279 packetdata.dst_id = dst_id_data;
280 packetdata.dst_id_len = dst_id_len;
281 packetdata.dst_id_type = dst_id_type;
282 data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
283 packetdata.src_id_len +
285 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
286 packetdata.src_id_len + dst_id_len;
287 packetdata.padlen = SILC_PACKET_PADLEN(packetdata.truelen, block_len);
289 /* Create the outgoing packet */
290 if (!silc_packet_assemble(&packetdata, NULL, cipher, hmac, sock, data,
291 data_len, (const SilcBuffer)&packet)) {
292 SILC_LOG_ERROR(("Cannot assemble packe"));
296 /* Encrypt the packet */
297 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&packet, packet.len);
299 SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence, packet.len),
300 packet.data, packet.len);
302 /* Now actually send the packet */
303 silc_server_packet_send_real(server, sock, force_send);
306 if (packetdata.src_id)
307 silc_free(packetdata.src_id);
308 if (packetdata.dst_id)
309 silc_free(packetdata.dst_id);
312 /* Broadcast received packet to our primary route. This function is used
313 by router to further route received broadcast packet. It is expected
314 that the broadcast flag from the packet is checked before calling this
315 function. This does not test or set the broadcast flag. */
317 void silc_server_packet_broadcast(SilcServer server,
318 SilcSocketConnection sock,
319 SilcPacketContext *packet)
321 SilcBuffer buffer = packet->buffer;
322 SilcIDListData idata;
328 SILC_LOG_DEBUG(("Broadcasting received broadcast packet"));
330 /* If the packet is originated from our primary route we are
331 not allowed to send the packet. */
332 id = silc_id_str2id(packet->src_id, packet->src_id_len, packet->src_id_type);
333 if (id && !SILC_ID_SERVER_COMPARE(id, server->router->id)) {
334 const SilcBufferStruct p;
336 idata = (SilcIDListData)sock->user_data;
338 silc_buffer_push(buffer, buffer->data - buffer->head);
339 if (!silc_packet_send_prepare(sock, 0, 0, buffer->len, idata->hmac_send,
340 (const SilcBuffer)&p)) {
341 SILC_LOG_ERROR(("Cannot send packet"));
345 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
346 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
347 (SilcBuffer)&p, p.len);
349 SILC_LOG_HEXDUMP(("Broadcasted packet (%d), len %d", idata->psn_send - 1,
350 p.len), p.data, p.len);
352 /* Now actually send the packet */
353 silc_server_packet_send_real(server, sock, TRUE);
358 SILC_LOG_DEBUG(("Will not broadcast to primary route since it is the "
359 "original sender of this packet"));
363 /* Routes received packet to `sock'. This is used to route the packets that
364 router receives but are not destined to it. */
366 void silc_server_packet_route(SilcServer server,
367 SilcSocketConnection sock,
368 SilcPacketContext *packet)
370 SilcBuffer buffer = packet->buffer;
371 const SilcBufferStruct p;
372 SilcIDListData idata;
374 SILC_LOG_DEBUG(("Routing received packet"));
376 idata = (SilcIDListData)sock->user_data;
378 silc_buffer_push(buffer, buffer->data - buffer->head);
379 if (!silc_packet_send_prepare(sock, 0, 0, buffer->len, idata->hmac_send,
380 (const SilcBuffer)&p)) {
381 SILC_LOG_ERROR(("Cannot send packet"));
384 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
385 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
386 (SilcBuffer)&p, p.len);
388 SILC_LOG_HEXDUMP(("Routed packet (%d), len %d", idata->psn_send - 1,
389 p.len), p.data, p.len);
391 /* Now actually send the packet */
392 silc_server_packet_send_real(server, sock, TRUE);
395 /* This routine can be used to send a packet to table of clients provided
396 in `clients'. If `route' is FALSE the packet is routed only to local
397 clients (for server locally connected, and for router local cell). */
399 void silc_server_packet_send_clients(SilcServer server,
400 SilcHashTable clients,
402 SilcPacketFlags flags,
408 SilcSocketConnection sock = NULL;
409 SilcHashTableList htl;
410 SilcClientEntry client = NULL;
411 SilcServerEntry *routed = NULL;
412 SilcUInt32 routed_count = 0;
416 SILC_LOG_DEBUG(("Sending packet to list of clients"));
418 /* Send to all clients in table */
419 silc_hash_table_list(clients, &htl);
420 while (silc_hash_table_get(&htl, NULL, (void **)&client)) {
421 /* If client has router set it is not locally connected client and
422 we will route the message to the router set in the client. Though,
423 send locally connected server in all cases. */
424 if (server->server_type == SILC_ROUTER && client->router &&
425 ((!route && client->router->router == server->id_entry) || route)) {
427 /* Check if we have sent the packet to this route already */
428 for (k = 0; k < routed_count; k++)
429 if (routed[k] == client->router)
431 if (k < routed_count)
434 /* Route only once to router */
435 sock = (SilcSocketConnection)client->router->connection;
436 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
442 /* Send the packet */
443 silc_server_packet_send_dest(server, sock, type, flags,
444 client->router->id, SILC_ID_SERVER,
445 data, data_len, force_send);
447 /* Mark this route routed already */
448 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
449 routed[routed_count++] = client->router;
456 /* Send to locally connected client */
457 sock = (SilcSocketConnection)client->connection;
461 silc_server_packet_send_dest(server, sock, type, flags,
462 client->id, SILC_ID_CLIENT,
463 data, data_len, force_send);
465 silc_hash_table_list_reset(&htl);
469 /* Internal routine to actually create the channel packet and send it
470 to network. This is common function in channel message sending. If
471 `channel_message' is TRUE this encrypts the message as it is strictly
472 a channel message. If FALSE normal encryption process is used. */
475 silc_server_packet_send_to_channel_real(SilcServer server,
476 SilcSocketConnection sock,
477 SilcPacketContext *packet,
483 bool channel_message,
487 const SilcBufferStruct p;
492 data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
494 packet->dst_id_len));
495 packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
496 packet->src_id_len + packet->dst_id_len;
498 block_len = cipher ? silc_cipher_get_block_len(cipher) : 0;
500 packet->padlen = SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
502 packet->dst_id_len), block_len);
504 packet->padlen = SILC_PACKET_PADLEN(packet->truelen, block_len);
506 /* Put the data to buffer, assemble and encrypt the packet. The packet
507 is encrypted with normal session key shared with the client, unless
508 the `channel_message' is TRUE. */
509 if (!silc_packet_assemble(packet, NULL, cipher, hmac, sock, data,
510 data_len, (const SilcBuffer)&p)) {
511 SILC_LOG_ERROR(("Cannot assemble packet"));
516 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p,
517 SILC_PACKET_HEADER_LEN + packet->src_id_len +
518 packet->dst_id_len + packet->padlen);
520 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, p.len);
522 SILC_LOG_HEXDUMP(("Channel packet (%d), len %d", sequence, p.len),
525 /* Now actually send the packet */
526 silc_server_packet_send_real(server, sock, force_send);
529 /* This routine is used by the server to send packets to channel. The
530 packet sent with this function is distributed to all clients on
531 the channel. Usually this is used to send notify messages to the
532 channel, things like notify about new user joining to the channel.
533 If `route' is FALSE then the packet is sent only locally and will not
534 be routed anywhere (for router locally means cell wide). If `sender'
535 is provided then the packet is not sent to that connection since it
536 originally came from it. If `send_to_clients' is FALSE then the
537 packet is not sent clients, only servers. */
539 void silc_server_packet_send_to_channel(SilcServer server,
540 SilcSocketConnection sender,
541 SilcChannelEntry channel,
548 SilcSocketConnection sock = NULL;
549 SilcPacketContext packetdata;
550 SilcClientEntry client = NULL;
551 SilcServerEntry *routed = NULL;
552 SilcChannelClientEntry chl;
553 SilcHashTableList htl;
554 SilcIDListData idata;
555 SilcUInt32 routed_count = 0;
559 /* This doesn't send channel message packets */
560 assert(type != SILC_PACKET_CHANNEL_MESSAGE);
562 /* Set the packet context pointers. */
563 packetdata.flags = 0;
564 packetdata.type = type;
565 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
566 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
567 packetdata.src_id_type = SILC_ID_SERVER;
568 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
569 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
570 packetdata.dst_id_type = SILC_ID_CHANNEL;
572 /* If there are global users in the channel we will send the message
573 first to our router for further routing. */
574 if (route && server->server_type != SILC_ROUTER && !server->standalone &&
575 channel->global_users) {
576 SilcServerEntry router;
578 /* Get data used in packet header encryption, keys and stuff. */
579 router = server->router;
580 sock = (SilcSocketConnection)router->connection;
581 idata = (SilcIDListData)router;
583 if (sock != sender) {
584 SILC_LOG_DEBUG(("Sending packet to router for routing"));
585 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
589 data, data_len, FALSE,
594 if (!silc_hash_table_count(channel->user_list)) {
595 SILC_LOG_DEBUG(("Channel %s is empty", channel->channel_name));
599 SILC_LOG_DEBUG(("Sending %s packet to channel %s",
600 silc_get_packet_name(type), channel->channel_name));
602 routed = silc_calloc(silc_hash_table_count(channel->user_list),
605 /* Send the message to clients on the channel's client list. */
606 silc_hash_table_list(channel->user_list, &htl);
607 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
608 client = chl->client;
612 /* If client has router set it is not locally connected client and
613 we will route the message to the router set in the client. Though,
614 send locally connected server in all cases. */
615 if (server->server_type == SILC_ROUTER && client->router &&
616 ((!route && client->router->router == server->id_entry) || route)) {
618 /* Check if we have sent the packet to this route already */
619 for (k = 0; k < routed_count; k++)
620 if (routed[k] == client->router)
622 if (k < routed_count)
625 /* Get data used in packet header encryption, keys and stuff. */
626 sock = (SilcSocketConnection)client->router->connection;
627 idata = (SilcIDListData)client->router;
629 if (sender && sock == sender)
632 /* Route only once to router. Protocol prohibits sending channel
633 messages to more than one router. */
634 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
640 SILC_LOG_DEBUG(("Sending packet to client %s",
641 client->nickname ? client->nickname :
642 (unsigned char *)""));
644 /* Send the packet */
645 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
649 data, data_len, FALSE,
652 /* Mark this route routed already */
653 routed[routed_count++] = client->router;
660 /* Send to locally connected client */
662 /* Get data used in packet header encryption, keys and stuff. */
663 sock = (SilcSocketConnection)client->connection;
664 idata = (SilcIDListData)client;
666 if (!sock || (sender && sock == sender))
669 SILC_LOG_DEBUG(("Sending packet to client %s",
670 client->nickname ? client->nickname :
671 (unsigned char *)""));
673 /* Send the packet */
674 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
678 data, data_len, FALSE,
681 silc_hash_table_list_reset(&htl);
685 silc_free(packetdata.src_id);
686 silc_free(packetdata.dst_id);
689 /* This checks whether the relayed packet came from router. If it did
690 then we'll need to encrypt it with the channel key. This is called
691 from the silc_server_packet_relay_to_channel. */
694 silc_server_packet_relay_to_channel_encrypt(SilcServer server,
695 SilcSocketConnection sock,
696 SilcChannelEntry channel,
698 unsigned int data_len)
700 /* If we are router and the packet came from router and private key
701 has not been set for the channel then we must encrypt the packet
702 as it was decrypted with the session key shared between us and the
703 router which sent it. This is so, because cells does not share the
705 if (server->server_type == SILC_ROUTER &&
706 sock->type == SILC_SOCKET_TYPE_ROUTER &&
707 !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
708 channel->channel_key) {
709 SilcUInt32 mac_len = silc_hmac_len(channel->hmac);
710 SilcUInt32 iv_len = silc_cipher_get_block_len(channel->channel_key);
711 unsigned char iv[SILC_CIPHER_MAX_IV_SIZE];
713 if (data_len <= mac_len + iv_len) {
714 SILC_LOG_WARNING(("Corrupted channel message, cannot relay it"));
718 memcpy(iv, data + (data_len - iv_len), iv_len);
719 silc_channel_message_payload_encrypt(data, data_len - iv_len - mac_len,
720 data_len, iv, iv_len,
721 channel->channel_key, channel->hmac);
727 /* This routine is explicitly used to relay messages to some channel.
728 Packets sent with this function we have received earlier and are
729 totally encrypted. This just sends the packet to all clients on
730 the channel. If the sender of the packet is someone on the channel
731 the message will not be sent to that client. The SILC Packet header
732 is encrypted with the session key shared between us and the client.
733 MAC is also computed before encrypting the header. Rest of the
734 packet will be untouched. */
736 void silc_server_packet_relay_to_channel(SilcServer server,
737 SilcSocketConnection sender_sock,
738 SilcChannelEntry channel,
740 SilcIdType sender_type,
741 SilcClientEntry sender_entry,
746 SilcSocketConnection sock = NULL;
747 SilcPacketContext packetdata;
748 SilcClientEntry client = NULL;
749 SilcServerEntry *routed = NULL;
750 SilcChannelClientEntry chl, chl_sender;
751 SilcUInt32 routed_count = 0;
752 SilcIDListData idata;
753 SilcHashTableList htl;
757 if (!silc_server_client_on_channel(sender_entry, channel, &chl_sender))
760 SILC_LOG_DEBUG(("Relaying packet to channel %s", channel->channel_name));
762 /* This encrypts the packet, if needed. It will be encrypted if
763 it came from the router thus it needs to be encrypted with the
764 channel key. If the channel key does not exist, then we know we
765 don't have a single local user on the channel. */
766 if (!silc_server_packet_relay_to_channel_encrypt(server, sender_sock,
771 /* Set the packet context pointers. */
772 packetdata.flags = 0;
773 packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
774 packetdata.src_id = silc_id_id2str(sender_id, sender_type);
775 packetdata.src_id_len = silc_id_get_len(sender_id, sender_type);
776 packetdata.src_id_type = sender_type;
777 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
778 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
779 packetdata.dst_id_type = SILC_ID_CHANNEL;
781 /* If there are global users in the channel we will send the message
782 first to our router for further routing. */
783 if (server->server_type != SILC_ROUTER && !server->standalone &&
784 channel->global_users) {
785 SilcServerEntry router = server->router;
787 /* Check that the sender is not our router. */
788 if (sender_sock != (SilcSocketConnection)router->connection) {
790 /* Get data used in packet header encryption, keys and stuff. */
791 sock = (SilcSocketConnection)router->connection;
792 idata = (SilcIDListData)router;
794 SILC_LOG_DEBUG(("Sending channel message to router for routing"));
796 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
800 data, data_len, TRUE,
805 routed = silc_calloc(silc_hash_table_count(channel->user_list),
808 /* Assure we won't route the message back to the sender's way. */
809 if (sender_entry->router)
810 routed[routed_count++] = sender_entry->router;
812 /* Send the message to clients on the channel's client list. */
813 silc_hash_table_list(channel->user_list, &htl);
814 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
815 client = chl->client;
816 if (!client || client == sender_entry)
819 /* Check whether message sending is blocked */
820 if (chl->mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES)
822 if (chl->mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES_USERS &&
823 !(chl_sender->mode & SILC_CHANNEL_UMODE_CHANOP) &&
824 !(chl_sender->mode & SILC_CHANNEL_UMODE_CHANFO))
826 if (chl->mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES_ROBOTS &&
827 sender_entry->mode & SILC_UMODE_ROBOT)
830 /* If the client has set router it means that it is not locally
831 connected client and we will route the packet further. */
832 if (server->server_type == SILC_ROUTER && client->router) {
834 /* Check if we have sent the packet to this route already */
835 for (k = 0; k < routed_count; k++)
836 if (routed[k] == client->router)
838 if (k < routed_count)
841 /* Get data used in packet header encryption, keys and stuff. */
842 sock = (SilcSocketConnection)client->router->connection;
843 idata = (SilcIDListData)client->router;
845 /* Check if the sender socket is the same as this client's 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 (sock->type == SILC_SOCKET_TYPE_ROUTER) {
858 /* The remote connection is router then we'll decrypt the
859 channel message and re-encrypt it with the session key shared
860 between us and the remote router. This is done because the
861 channel keys are cell specific and we have different channel
862 key than the remote router has. */
864 /* Route only once to router. Protocol prohibits sending channel
865 messages to more than one router. */
870 SILC_LOG_DEBUG(("Remote is router, encrypt with session key"));
872 /* If private key mode is not set then decrypt the packet
874 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
875 channel->channel_key) {
876 unsigned char tmp[SILC_PACKET_MAX_LEN];
878 if (data_len > SILC_PACKET_MAX_LEN)
879 data_len = SILC_PACKET_MAX_LEN;
880 memcpy(tmp, data, data_len);
882 /* Decrypt the channel message (we don't check the MAC) */
883 silc_channel_message_payload_decrypt(tmp, data_len,
884 channel->channel_key, NULL);
886 /* Now re-encrypt and send it to the router */
887 silc_server_packet_send_srcdest(server, sock,
888 SILC_PACKET_CHANNEL_MESSAGE, 0,
889 sender_id, sender_type,
890 channel->id, SILC_ID_CHANNEL,
891 tmp, data_len, force_send);
893 /* Private key mode is set, we don't have the channel key, so
894 just re-encrypt the entire packet and send it to the router. */
895 silc_server_packet_send_srcdest(server, sock,
896 SILC_PACKET_CHANNEL_MESSAGE, 0,
897 sender_id, sender_type,
898 channel->id, SILC_ID_CHANNEL,
899 data, data_len, force_send);
902 /* Send the packet to normal server */
903 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
907 data, data_len, TRUE,
917 /* Get data used in packet header encryption, keys and stuff. */
918 sock = (SilcSocketConnection)client->connection;
919 idata = (SilcIDListData)client;
921 if (!sock || (sender_sock && sock == sender_sock))
924 SILC_LOG_DEBUG(("Sending packet to client ID(%s) %s (%s)",
925 silc_id_render(client->id, SILC_ID_CLIENT),
926 sock->hostname, sock->ip));
928 /* Send the packet */
929 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
933 data, data_len, TRUE,
937 silc_hash_table_list_reset(&htl);
939 silc_free(packetdata.src_id);
940 silc_free(packetdata.dst_id);
943 /* This function is used to send packets strictly to all local clients
944 on a particular channel. This is used for example to distribute new
945 channel key to all our locally connected clients on the channel.
946 The packets are always encrypted with the session key shared between
947 the client, this means these are not _to the channel_ but _to the client_
950 void silc_server_packet_send_local_channel(SilcServer server,
951 SilcChannelEntry channel,
953 SilcPacketFlags flags,
958 SilcChannelClientEntry chl;
959 SilcHashTableList htl;
960 SilcSocketConnection sock = NULL;
962 SILC_LOG_DEBUG(("Send packet to local clients on channel %s",
963 channel->channel_name));
965 /* Send the message to clients on the channel's client list. */
966 silc_hash_table_list(channel->user_list, &htl);
967 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
968 if (chl->client && !chl->client->router) {
969 sock = (SilcSocketConnection)chl->client->connection;
971 /* Send the packet to the client */
972 silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
973 SILC_ID_CLIENT, data, data_len,
977 silc_hash_table_list_reset(&htl);
980 /* Routine used to send (relay, route) private messages to some destination.
981 If the private message key does not exist then the message is re-encrypted,
982 otherwise we just pass it along. This really is not used to send new
983 private messages (as server does not send them) but to relay received
986 void silc_server_send_private_message(SilcServer server,
987 SilcSocketConnection dst_sock,
991 SilcPacketContext *packet)
993 SilcBuffer buffer = packet->buffer;
994 const SilcBufferStruct p;
996 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
997 + packet->dst_id_len + packet->padlen);
998 if (!silc_packet_send_prepare(dst_sock, 0, 0, buffer->len, hmac,
999 (const SilcBuffer)&p)) {
1000 SILC_LOG_ERROR(("Cannot send packet"));
1003 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
1005 /* Re-encrypt and send if private messge key does not exist */
1006 if (!(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY)) {
1007 /* Re-encrypt packet */
1008 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, buffer->len);
1010 /* Key exist so encrypt just header and send it */
1011 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p,
1012 SILC_PACKET_HEADER_LEN + packet->src_id_len +
1013 packet->dst_id_len + packet->padlen);
1016 /* Send the packet */
1017 silc_server_packet_send_real(server, dst_sock, FALSE);
1020 /* Sends current motd to client */
1022 void silc_server_send_motd(SilcServer server,
1023 SilcSocketConnection sock)
1025 char *motd, *motd_file = NULL;
1026 SilcUInt32 motd_len;
1029 motd_file = server->config->server_info->motd_file;
1032 motd = silc_file_readfile(motd_file, &motd_len);
1036 silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
1042 /* Sends error message. Error messages may or may not have any
1045 void silc_server_send_error(SilcServer server,
1046 SilcSocketConnection sock,
1047 const char *fmt, ...)
1050 unsigned char buf[4096];
1052 memset(buf, 0, sizeof(buf));
1054 vsprintf(buf, fmt, ap);
1057 silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
1058 buf, strlen(buf), FALSE);
1061 /* Sends notify message. If format is TRUE the variable arguments are
1062 formatted and the formatted string is sent as argument payload. If it is
1063 FALSE then each argument is sent as separate argument and their format
1064 in the argument list must be { argument data, argument length }. */
1066 void silc_server_send_notify(SilcServer server,
1067 SilcSocketConnection sock,
1069 SilcNotifyType type,
1070 SilcUInt32 argc, ...)
1077 packet = silc_notify_payload_encode(type, argc, ap);
1078 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1079 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1080 packet->data, packet->len, FALSE);
1082 /* Send to backup routers if this is being broadcasted to primary
1083 router. The silc_server_backup_send checks further whether to
1084 actually send it or not. */
1085 if ((broadcast && sock && sock == SILC_PRIMARY_ROUTE(server)) ||
1086 (broadcast && !sock && !SILC_PRIMARY_ROUTE(server)))
1087 silc_server_backup_send(server, NULL, SILC_PACKET_NOTIFY, 0,
1088 packet->data, packet->len, FALSE, TRUE);
1090 silc_buffer_free(packet);
1094 /* Sends notify message and gets the arguments from the `args' Argument
1097 void silc_server_send_notify_args(SilcServer server,
1098 SilcSocketConnection sock,
1100 SilcNotifyType type,
1106 packet = silc_notify_payload_encode_args(type, argc, args);
1107 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1108 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1109 packet->data, packet->len, FALSE);
1110 silc_buffer_free(packet);
1113 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
1114 `old_id' with the `new_id'. */
1116 void silc_server_send_notify_channel_change(SilcServer server,
1117 SilcSocketConnection sock,
1119 SilcChannelID *old_id,
1120 SilcChannelID *new_id)
1122 SilcBuffer idp1, idp2;
1124 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
1125 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
1127 silc_server_send_notify(server, sock, broadcast,
1128 SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
1129 2, idp1->data, idp1->len, idp2->data, idp2->len);
1130 silc_buffer_free(idp1);
1131 silc_buffer_free(idp2);
1134 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
1135 `old_id' with the `new_id'. */
1137 void silc_server_send_notify_nick_change(SilcServer server,
1138 SilcSocketConnection sock,
1140 SilcClientID *old_id,
1141 SilcClientID *new_id,
1142 const char *nickname)
1144 SilcBuffer idp1, idp2;
1146 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
1147 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
1149 silc_server_send_notify(server, sock, broadcast,
1150 SILC_NOTIFY_TYPE_NICK_CHANGE,
1151 3, idp1->data, idp1->len, idp2->data, idp2->len,
1152 nickname, nickname ? strlen(nickname) : 0);
1153 silc_buffer_free(idp1);
1154 silc_buffer_free(idp2);
1157 /* Sends JOIN notify type. This tells that new client by `client_id' ID
1158 has joined to the `channel'. */
1160 void silc_server_send_notify_join(SilcServer server,
1161 SilcSocketConnection sock,
1163 SilcChannelEntry channel,
1164 SilcClientID *client_id)
1166 SilcBuffer idp1, idp2;
1168 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1169 idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1170 silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
1171 2, idp1->data, idp1->len,
1172 idp2->data, idp2->len);
1173 silc_buffer_free(idp1);
1174 silc_buffer_free(idp2);
1177 /* Sends LEAVE notify type. This tells that `client_id' has left the
1178 `channel'. The Notify packet is always destined to the channel. */
1180 void silc_server_send_notify_leave(SilcServer server,
1181 SilcSocketConnection sock,
1183 SilcChannelEntry channel,
1184 SilcClientID *client_id)
1188 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1189 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1190 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
1191 1, idp->data, idp->len);
1192 silc_buffer_free(idp);
1195 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
1196 `channel' mode to `mode. The Notify packet is always destined to
1199 void silc_server_send_notify_cmode(SilcServer server,
1200 SilcSocketConnection sock,
1202 SilcChannelEntry channel,
1203 SilcUInt32 mode_mask,
1204 void *id, SilcIdType id_type,
1205 const char *cipher, const char *hmac,
1206 const char *passphrase,
1207 SilcPublicKey founder_key)
1210 unsigned char mode[4], *key = NULL;
1211 SilcUInt32 key_len = 0;
1213 idp = silc_id_payload_encode((void *)id, id_type);
1214 SILC_PUT32_MSB(mode_mask, mode);
1216 key = silc_pkcs_public_key_encode(founder_key, &key_len);
1218 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1219 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
1220 6, idp->data, idp->len,
1222 cipher, cipher ? strlen(cipher) : 0,
1223 hmac, hmac ? strlen(hmac) : 0,
1224 passphrase, passphrase ?
1225 strlen(passphrase) : 0,
1228 silc_buffer_free(idp);
1231 /* Sends CUMODE_CHANGE notify type. This tells that `id' changed the
1232 `target' client's mode on `channel'. The notify packet is always
1233 destined to the channel. */
1235 void silc_server_send_notify_cumode(SilcServer server,
1236 SilcSocketConnection sock,
1238 SilcChannelEntry channel,
1239 SilcUInt32 mode_mask,
1240 void *id, SilcIdType id_type,
1241 SilcClientID *target,
1242 SilcPublicKey founder_key)
1244 SilcBuffer idp1, idp2;
1245 unsigned char mode[4], *key = NULL;
1246 SilcUInt32 key_len = 0;
1248 idp1 = silc_id_payload_encode((void *)id, id_type);
1249 idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
1250 SILC_PUT32_MSB(mode_mask, mode);
1252 key = silc_pkcs_public_key_encode(founder_key, &key_len);
1254 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1256 SILC_NOTIFY_TYPE_CUMODE_CHANGE, 4,
1257 idp1->data, idp1->len,
1259 idp2->data, idp2->len,
1262 silc_buffer_free(idp1);
1263 silc_buffer_free(idp2);
1266 /* Sends SIGNOFF notify type. This tells that `client_id' client has
1267 left SILC network. This function is used only between server and router
1268 traffic. This is not used to send the notify to the channel for
1269 client. The `message may be NULL. */
1271 void silc_server_send_notify_signoff(SilcServer server,
1272 SilcSocketConnection sock,
1274 SilcClientID *client_id,
1275 const char *message)
1279 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1280 silc_server_send_notify(server, sock, broadcast,
1281 SILC_NOTIFY_TYPE_SIGNOFF,
1282 message ? 2 : 1, idp->data, idp->len,
1283 message, message ? strlen(message): 0);
1284 silc_buffer_free(idp);
1287 /* Sends TOPIC_SET notify type. This tells that `id' changed
1288 the `channel's topic to `topic'. The Notify packet is always destined
1289 to the channel. This function is used to send the topic set notifies
1292 void silc_server_send_notify_topic_set(SilcServer server,
1293 SilcSocketConnection sock,
1295 SilcChannelEntry channel,
1296 void *id, SilcIdType id_type,
1301 idp = silc_id_payload_encode(id, id_type);
1302 silc_server_send_notify_dest(server, sock, broadcast,
1303 (void *)channel->id, SILC_ID_CHANNEL,
1304 SILC_NOTIFY_TYPE_TOPIC_SET,
1306 idp->data, idp->len,
1307 topic, topic ? strlen(topic) : 0);
1308 silc_buffer_free(idp);
1311 /* Send KICKED notify type. This tells that the `client_id' on `channel'
1312 was kicked off the channel. The `comment' may indicate the reason
1313 for the kicking. This function is used only between server and router
1316 void silc_server_send_notify_kicked(SilcServer server,
1317 SilcSocketConnection sock,
1319 SilcChannelEntry channel,
1320 SilcClientID *client_id,
1321 SilcClientID *kicker,
1327 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1328 idp2 = silc_id_payload_encode((void *)kicker, SILC_ID_CLIENT);
1329 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1330 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED, 3,
1331 idp1->data, idp1->len,
1332 comment, comment ? strlen(comment) : 0,
1333 idp2->data, idp2->len);
1334 silc_buffer_free(idp1);
1335 silc_buffer_free(idp2);
1338 /* Send KILLED notify type. This tells that the `client_id' client was
1339 killed from the network. The `comment' may indicate the reason
1342 void silc_server_send_notify_killed(SilcServer server,
1343 SilcSocketConnection sock,
1345 SilcClientID *client_id,
1346 const char *comment,
1347 void *killer, SilcIdType killer_type)
1352 idp1 = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
1353 idp2 = silc_id_payload_encode(killer, killer_type);
1354 silc_server_send_notify_dest(server, sock, broadcast, (void *)client_id,
1355 SILC_ID_CLIENT, SILC_NOTIFY_TYPE_KILLED,
1356 3, idp1->data, idp1->len,
1357 comment, comment ? strlen(comment) : 0,
1358 idp2->data, idp2->len);
1359 silc_buffer_free(idp1);
1360 silc_buffer_free(idp2);
1363 /* Sends UMODE_CHANGE notify type. This tells that `client_id' client's
1364 user mode in the SILC Network was changed. This function is used to
1365 send the packet between routers as broadcast packet. */
1367 void silc_server_send_notify_umode(SilcServer server,
1368 SilcSocketConnection sock,
1370 SilcClientID *client_id,
1371 SilcUInt32 mode_mask)
1374 unsigned char mode[4];
1376 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1377 SILC_PUT32_MSB(mode_mask, mode);
1379 silc_server_send_notify(server, sock, broadcast,
1380 SILC_NOTIFY_TYPE_UMODE_CHANGE, 2,
1381 idp->data, idp->len,
1383 silc_buffer_free(idp);
1386 /* Sends BAN notify type. This tells that ban has been either `add'ed
1387 or `del'eted on the `channel. This function is used to send the packet
1388 between routers as broadcast packet. */
1390 void silc_server_send_notify_ban(SilcServer server,
1391 SilcSocketConnection sock,
1393 SilcChannelEntry channel,
1394 char *add, char *del)
1398 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1399 silc_server_send_notify(server, sock, broadcast,
1400 SILC_NOTIFY_TYPE_BAN, 3,
1401 idp->data, idp->len,
1402 add, add ? strlen(add) : 0,
1403 del, del ? strlen(del) : 0);
1404 silc_buffer_free(idp);
1407 /* Sends INVITE notify type. This tells that invite has been either `add'ed
1408 or `del'eted on the `channel. The sender of the invite is the `client_id'.
1409 This function is used to send the packet between routers as broadcast
1412 void silc_server_send_notify_invite(SilcServer server,
1413 SilcSocketConnection sock,
1415 SilcChannelEntry channel,
1416 SilcClientID *client_id,
1417 char *add, char *del)
1419 SilcBuffer idp, idp2;
1421 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1422 idp2 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1423 silc_server_send_notify(server, sock, broadcast,
1424 SILC_NOTIFY_TYPE_INVITE, 5,
1425 idp->data, idp->len,
1426 channel->channel_name, strlen(channel->channel_name),
1427 idp2->data, idp2->len,
1428 add, add ? strlen(add) : 0,
1429 del, del ? strlen(del) : 0);
1430 silc_buffer_free(idp);
1431 silc_buffer_free(idp2);
1434 /* Sends WATCH notify type. This tells that the `client' was watched and
1435 its status in the network has changed. */
1437 void silc_server_send_notify_watch(SilcServer server,
1438 SilcSocketConnection sock,
1439 SilcClientEntry watcher,
1440 SilcClientEntry client,
1441 const char *nickname,
1442 SilcNotifyType type)
1445 unsigned char mode[4], n[2];
1447 idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
1448 SILC_PUT16_MSB(type, n);
1449 SILC_PUT32_MSB(client->mode, mode);
1450 silc_server_send_notify_dest(server, sock, FALSE, watcher->id,
1451 SILC_ID_CLIENT, SILC_NOTIFY_TYPE_WATCH,
1452 4, idp->data, idp->len,
1453 nickname, nickname ? strlen(nickname) : 0,
1455 type != SILC_NOTIFY_TYPE_NONE ?
1456 n : NULL, sizeof(n));
1457 silc_buffer_free(idp);
1460 /* Sends notify message destined to specific entity. */
1462 void silc_server_send_notify_dest(SilcServer server,
1463 SilcSocketConnection sock,
1466 SilcIdType dest_id_type,
1467 SilcNotifyType type,
1468 SilcUInt32 argc, ...)
1475 packet = silc_notify_payload_encode(type, argc, ap);
1476 silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY,
1477 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1478 dest_id, dest_id_type,
1479 packet->data, packet->len, FALSE);
1480 silc_buffer_free(packet);
1484 /* Sends notify message to a channel. The notify message sent is
1485 distributed to all clients on the channel. If `route_notify' is TRUE
1486 then the notify may be routed to primary route or to some other routers.
1487 If FALSE it is assured that the notify is sent only locally. If `sender'
1488 is provided then the packet is not sent to that connection since it
1489 originally came from it. */
1491 void silc_server_send_notify_to_channel(SilcServer server,
1492 SilcSocketConnection sender,
1493 SilcChannelEntry channel,
1495 SilcNotifyType type,
1496 SilcUInt32 argc, ...)
1503 packet = silc_notify_payload_encode(type, argc, ap);
1504 silc_server_packet_send_to_channel(server, sender, channel,
1505 SILC_PACKET_NOTIFY, route_notify,
1506 packet->data, packet->len, FALSE);
1507 silc_buffer_free(packet);
1511 /* Send notify message to all channels the client has joined. It is quaranteed
1512 that the message is sent only once to a client (ie. if a client is joined
1513 on two same channel it will receive only one notify message). Also, this
1514 sends only to local clients (locally connected if we are server, and to
1515 local servers if we are router). If `sender' is provided the packet is
1516 not sent to that client at all. */
1518 void silc_server_send_notify_on_channels(SilcServer server,
1519 SilcClientEntry sender,
1520 SilcClientEntry client,
1521 SilcNotifyType type,
1522 SilcUInt32 argc, ...)
1525 SilcSocketConnection sock = NULL;
1526 SilcPacketContext packetdata;
1528 SilcClientEntry *sent_clients = NULL;
1529 SilcUInt32 sent_clients_count = 0;
1530 SilcServerEntry *routed = NULL;
1531 SilcUInt32 routed_count = 0;
1532 SilcHashTableList htl, htl2;
1533 SilcChannelEntry channel;
1534 SilcChannelClientEntry chl, chl2;
1535 SilcIDListData idata;
1537 unsigned char *data;
1538 SilcUInt32 data_len;
1539 bool force_send = FALSE;
1542 if (!silc_hash_table_count(client->channels)) {
1543 SILC_LOG_DEBUG(("Client is not joined to any channels"));
1547 SILC_LOG_DEBUG(("Sending notify to joined channels"));
1550 packet = silc_notify_payload_encode(type, argc, ap);
1551 data = packet->data;
1552 data_len = packet->len;
1554 /* Set the packet context pointers. */
1555 packetdata.flags = 0;
1556 packetdata.type = SILC_PACKET_NOTIFY;
1557 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1558 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
1559 packetdata.src_id_type = SILC_ID_SERVER;
1561 silc_hash_table_list(client->channels, &htl);
1562 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
1563 channel = chl->channel;
1565 /* Send the message to all clients on the channel's client list. */
1566 silc_hash_table_list(channel->user_list, &htl2);
1567 while (silc_hash_table_get(&htl2, NULL, (void **)&chl2)) {
1570 if (sender && c == sender)
1573 /* Check if we have sent the packet to this client already */
1574 for (k = 0; k < sent_clients_count; k++)
1575 if (sent_clients[k] == c)
1577 if (k < sent_clients_count)
1580 /* If we are router and if this client has router set it is not
1581 locally connected client and we will route the message to the
1582 router set in the client. */
1583 if (c && c->router && server->server_type == SILC_ROUTER) {
1584 /* Check if we have sent the packet to this route already */
1585 for (k = 0; k < routed_count; k++)
1586 if (routed[k] == c->router)
1588 if (k < routed_count)
1591 /* Get data used in packet header encryption, keys and stuff. */
1592 sock = (SilcSocketConnection)c->router->connection;
1593 idata = (SilcIDListData)c->router;
1596 SILC_LOG_DEBUG(("*****************"));
1597 SILC_LOG_DEBUG(("client->router->id %s",
1598 silc_id_render(c->router->id, SILC_ID_SERVER)));
1599 SILC_LOG_DEBUG(("client->router->connection->user_data->id %s",
1600 silc_id_render(((SilcServerEntry)sock->user_data)->id, SILC_ID_SERVER)));
1603 packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1604 packetdata.dst_id_len = silc_id_get_len(c->router->id, SILC_ID_SERVER);
1605 packetdata.dst_id_type = SILC_ID_SERVER;
1607 /* Send the packet */
1608 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1612 data, data_len, FALSE,
1615 silc_free(packetdata.dst_id);
1617 /* We want to make sure that the packet is routed to same router
1618 only once. Mark this route as sent route. */
1619 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
1620 routed[routed_count++] = c->router;
1627 /* Send to locally connected client */
1630 /* Get data used in packet header encryption, keys and stuff. */
1631 sock = (SilcSocketConnection)c->connection;
1632 idata = (SilcIDListData)c;
1637 packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1638 packetdata.dst_id_len = silc_id_get_len(c->id, SILC_ID_CLIENT);
1639 packetdata.dst_id_type = SILC_ID_CLIENT;
1641 /* Send the packet */
1642 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1646 data, data_len, FALSE,
1649 silc_free(packetdata.dst_id);
1651 /* Make sure that we send the notify only once per client. */
1652 sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1653 (sent_clients_count + 1));
1654 sent_clients[sent_clients_count++] = c;
1657 silc_hash_table_list_reset(&htl2);
1660 silc_hash_table_list_reset(&htl);
1662 silc_free(sent_clients);
1663 silc_free(packetdata.src_id);
1664 silc_buffer_free(packet);
1668 /* Sends New ID Payload to remote end. The packet is used to distribute
1669 information about new registered clients, servers, channel etc. usually
1670 to routers so that they can keep these information up to date.
1671 If the argument `broadcast' is TRUE then the packet is sent as
1672 broadcast packet. */
1674 void silc_server_send_new_id(SilcServer server,
1675 SilcSocketConnection sock,
1677 void *id, SilcIdType id_type,
1682 SILC_LOG_DEBUG(("Sending new ID"));
1684 idp = silc_id_payload_encode(id, id_type);
1685 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1686 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1687 idp->data, idp->len, FALSE);
1688 silc_buffer_free(idp);
1691 /* Send New Channel Payload to notify about newly created channel in the
1692 SILC network. Router uses this to notify other routers in the network
1693 about new channel. This packet is broadcasted by router. */
1695 void silc_server_send_new_channel(SilcServer server,
1696 SilcSocketConnection sock,
1700 SilcUInt32 channel_id_len,
1705 SilcUInt32 name_len = strlen(channel_name);
1707 SILC_LOG_DEBUG(("Sending new channel"));
1709 cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1713 /* Encode the channel payload */
1714 packet = silc_channel_payload_encode(channel_name, name_len,
1715 cid, channel_id_len, mode);
1717 silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1718 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1719 packet->data, packet->len, FALSE);
1722 silc_buffer_free(packet);
1725 /* Send Channel Key payload to distribute the new channel key. Normal server
1726 sends this to router when new client joins to existing channel. Router
1727 sends this to the local server who sent the join command in case where
1728 the channel did not exist yet. Both normal and router servers uses this
1729 also to send this to locally connected clients on the channel. This
1730 must not be broadcasted packet. Routers do not send this to each other.
1731 If `sender is provided then the packet is not sent to that connection since
1732 it originally came from it. */
1734 void silc_server_send_channel_key(SilcServer server,
1735 SilcSocketConnection sender,
1736 SilcChannelEntry channel,
1737 unsigned char route)
1740 unsigned char *chid;
1743 SILC_LOG_DEBUG(("Sending key to channel %s", channel->channel_name));
1745 chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1749 /* Encode channel key packet */
1750 tmp_len = strlen(channel->channel_key->cipher->name);
1751 packet = silc_channel_key_payload_encode(silc_id_get_len(channel->id,
1754 channel->channel_key->cipher->name,
1755 channel->key_len / 8, channel->key);
1756 silc_server_packet_send_to_channel(server, sender, channel,
1757 SILC_PACKET_CHANNEL_KEY,
1758 route, packet->data, packet->len,
1760 silc_buffer_free(packet);
1764 /* Generic function to send any command. The arguments must be sent already
1765 encoded into correct form in correct order. */
1767 void silc_server_send_command(SilcServer server,
1768 SilcSocketConnection sock,
1769 SilcCommand command,
1771 SilcUInt32 argc, ...)
1778 packet = silc_command_payload_encode_vap(command, ident, argc, ap);
1779 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1780 packet->data, packet->len, TRUE);
1781 silc_buffer_free(packet);
1785 /* Generic function to send any command reply. The arguments must be sent
1786 already encoded into correct form in correct order. */
1788 void silc_server_send_command_reply(SilcServer server,
1789 SilcSocketConnection sock,
1790 SilcCommand command,
1794 SilcUInt32 argc, ...)
1801 packet = silc_command_reply_payload_encode_vap(command, status, error,
1803 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1804 packet->data, packet->len, TRUE);
1805 silc_buffer_free(packet);
1809 /* Generic function to send any command reply. The arguments must be sent
1810 already encoded into correct form in correct order. */
1812 void silc_server_send_dest_command_reply(SilcServer server,
1813 SilcSocketConnection sock,
1815 SilcIdType dst_id_type,
1816 SilcCommand command,
1820 SilcUInt32 argc, ...)
1827 packet = silc_command_reply_payload_encode_vap(command, status, error,
1829 silc_server_packet_send_dest(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1830 dst_id, dst_id_type, packet->data,
1832 silc_buffer_free(packet);
1836 /* Send the heartbeat packet. */
1838 void silc_server_send_heartbeat(SilcServer server,
1839 SilcSocketConnection sock)
1841 silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1845 /* Generic function to relay packet we've received. This is used to relay
1846 packets to a client but generally can be used to other purposes as well. */
1848 void silc_server_relay_packet(SilcServer server,
1849 SilcSocketConnection dst_sock,
1852 SilcUInt32 sequence,
1853 SilcPacketContext *packet,
1856 const SilcBufferStruct p;
1858 silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1859 + packet->dst_id_len + packet->padlen);
1860 if (!silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len, hmac,
1861 (const SilcBuffer)&p)) {
1862 SILC_LOG_ERROR(("Cannot send packet"));
1865 silc_buffer_put((SilcBuffer)&p, packet->buffer->data, packet->buffer->len);
1867 /* Re-encrypt packet */
1868 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, p.len);
1870 /* Send the packet */
1871 silc_server_packet_send_real(server, dst_sock, force_send);
1873 silc_buffer_pull(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1874 + packet->dst_id_len + packet->padlen);
1877 /* Routine used to send the connection authentication packet. */
1879 void silc_server_send_connection_auth_request(SilcServer server,
1880 SilcSocketConnection sock,
1881 SilcUInt16 conn_type,
1882 SilcAuthMethod auth_meth)
1886 packet = silc_buffer_alloc(4);
1887 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1888 silc_buffer_format(packet,
1889 SILC_STR_UI_SHORT(conn_type),
1890 SILC_STR_UI_SHORT(auth_meth),
1893 silc_server_packet_send(server, sock, SILC_PACKET_CONNECTION_AUTH_REQUEST,
1894 0, packet->data, packet->len, FALSE);
1895 silc_buffer_free(packet);
1898 /* Purge the outgoing packet queue to the network if there is data. This
1899 function can be used to empty the packet queue. It is guaranteed that
1900 after this function returns the outgoing data queue is empty. */
1902 void silc_server_packet_queue_purge(SilcServer server,
1903 SilcSocketConnection sock)
1905 if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
1906 (SILC_IS_DISCONNECTED(sock) == FALSE)) {
1907 server->stat.packets_sent++;
1908 silc_packet_send(sock, TRUE);
1909 SILC_SET_CONNECTION_FOR_INPUT(server->schedule, sock->sock);
1910 SILC_UNSET_OUTBUF_PENDING(sock);
1911 silc_buffer_clear(sock->outbuf);
1915 /* Send packet to clients that are known to be operators. If server
1916 is router and `route' is TRUE then the packet would go to all operators
1917 in the SILC network. If `route' is FALSE then only local operators
1918 (local for server and cell wide for router). If `local' is TRUE then
1919 only locally connected operators receive the packet. If `local' is
1920 TRUE then `route' is ignored. If server is normal server and `route'
1921 is FALSE it is equivalent to `local' being TRUE. */
1923 void silc_server_send_opers(SilcServer server,
1924 SilcPacketType type,
1925 SilcPacketFlags flags,
1926 bool route, bool local,
1927 unsigned char *data,
1928 SilcUInt32 data_len,
1931 SilcIDCacheList list = NULL;
1932 SilcIDCacheEntry id_cache = NULL;
1933 SilcClientEntry client = NULL;
1934 SilcSocketConnection sock;
1935 SilcServerEntry *routed = NULL;
1936 SilcUInt32 routed_count = 0;
1940 SILC_LOG_DEBUG(("Sending %s packet to operators",
1941 silc_get_packet_name(type)));
1943 /* If local was requested send only locally connected operators. */
1944 if (local || (server->server_type == SILC_SERVER && !route)) {
1945 if (!silc_idcache_get_all(server->local_list->clients, &list) ||
1946 !silc_idcache_list_first(list, &id_cache))
1949 client = (SilcClientEntry)id_cache->context;
1950 if (!client->router && SILC_IS_LOCAL(client) &&
1951 (client->mode & SILC_UMODE_SERVER_OPERATOR ||
1952 client->mode & SILC_UMODE_ROUTER_OPERATOR)) {
1954 /* Send the packet to locally connected operator */
1955 silc_server_packet_send_dest(server, client->connection, type, flags,
1956 client->id, SILC_ID_CLIENT,
1957 data, data_len, force_send);
1960 if (!silc_idcache_list_next(list, &id_cache))
1963 silc_idcache_list_free(list);
1967 if (!silc_idcache_get_all(server->local_list->clients, &list) ||
1968 !silc_idcache_list_first(list, &id_cache))
1971 client = (SilcClientEntry)id_cache->context;
1972 if (!(client->mode & SILC_UMODE_SERVER_OPERATOR) &&
1973 !(client->mode & SILC_UMODE_ROUTER_OPERATOR))
1976 if (server->server_type != SILC_SERVER && client->router &&
1977 ((!route && client->router->router == server->id_entry) || route)) {
1979 /* Check if we have sent the packet to this route already */
1980 for (k = 0; k < routed_count; k++)
1981 if (routed[k] == client->router)
1983 if (k < routed_count)
1986 /* Route only once to router */
1987 sock = (SilcSocketConnection)client->router->connection;
1988 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
1994 /* Send the packet */
1995 silc_server_packet_send_dest(server, sock, type, flags,
1996 client->id, SILC_ID_CLIENT,
1997 data, data_len, force_send);
1999 /* Mark this route routed already */
2000 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
2001 routed[routed_count++] = client->router;
2005 if (client->router || !client->connection)
2008 /* Send to locally connected client */
2009 sock = (SilcSocketConnection)client->connection;
2010 silc_server_packet_send_dest(server, sock, type, flags,
2011 client->id, SILC_ID_CLIENT,
2012 data, data_len, force_send);
2015 if (!silc_idcache_list_next(list, &id_cache))
2018 silc_idcache_list_free(list);
2020 if (!silc_idcache_get_all(server->global_list->clients, &list) ||
2021 !silc_idcache_list_first(list, &id_cache))
2024 client = (SilcClientEntry)id_cache->context;
2025 if (!(client->mode & SILC_UMODE_SERVER_OPERATOR) &&
2026 !(client->mode & SILC_UMODE_ROUTER_OPERATOR))
2029 if (server->server_type != SILC_SERVER && client->router &&
2030 ((!route && client->router->router == server->id_entry) || route)) {
2032 /* Check if we have sent the packet to this route already */
2033 for (k = 0; k < routed_count; k++)
2034 if (routed[k] == client->router)
2036 if (k < routed_count)
2039 /* Route only once to router */
2040 sock = (SilcSocketConnection)client->router->connection;
2041 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2047 /* Send the packet */
2048 silc_server_packet_send_dest(server, sock, type, flags,
2049 client->id, SILC_ID_CLIENT,
2050 data, data_len, force_send);
2052 /* Mark this route routed already */
2053 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
2054 routed[routed_count++] = client->router;
2058 if (client->router || !client->connection)
2061 /* Send to locally connected client */
2062 sock = (SilcSocketConnection)client->connection;
2063 silc_server_packet_send_dest(server, sock, type, flags,
2064 client->id, SILC_ID_CLIENT,
2065 data, data_len, force_send);
2068 if (!silc_idcache_list_next(list, &id_cache))
2071 silc_idcache_list_free(list);
2075 /* Send a notify packet to operators */
2077 void silc_server_send_opers_notify(SilcServer server,
2080 SilcNotifyType type,
2081 SilcUInt32 argc, ...)
2087 packet = silc_notify_payload_encode(type, argc, ap);
2088 silc_server_send_opers(server, SILC_PACKET_NOTIFY, 0,
2089 route, local, packet->data, packet->len,
2091 silc_buffer_free(packet);