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; version 2 of the License.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
20 * Server packet routines to send packets.
24 #include "serverincludes.h"
25 #include "server_internal.h"
27 /* Routine that sends packet or marks packet to be sent. This is used
28 directly only in special cases. Normal cases should use
29 silc_server_packet_send. Returns < 0 error. */
31 int silc_server_packet_send_real(SilcServer server,
32 SilcSocketConnection sock,
37 /* If disconnecting, ignore the data */
38 if (SILC_IS_DISCONNECTING(sock))
42 ret = silc_packet_send(sock, FALSE);
45 SILC_LOG_ERROR(("Error sending packet to connection "
46 "%s:%d [%s]", sock->hostname, sock->port,
47 (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
48 sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
49 sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
52 SILC_SET_DISCONNECTING(sock);
54 silc_server_free_sock_user_data(server, sock, NULL);
55 silc_server_close_connection(server, sock);
59 server->stat.packets_sent++;
63 /* Mark that there is some outgoing data available for this connection.
64 This call sets the connection both for input and output (the input
65 is set always and this call keeps the input setting, actually).
66 Actual data sending is performed by silc_server_packet_process. */
67 SILC_SET_CONNECTION_FOR_OUTPUT(server->schedule, sock->sock);
69 /* Mark to socket that data is pending in outgoing buffer. This flag
70 is needed if new data is added to the buffer before the earlier
71 put data is sent to the network. */
72 SILC_SET_OUTBUF_PENDING(sock);
77 /* Assembles a new packet to be sent out to network. This doesn't actually
78 send the packet but creates the packet and fills the outgoing data
79 buffer and marks the packet ready to be sent to network. However, If
80 argument force_send is TRUE the packet is sent immediately and not put
81 to queue. Normal case is that the packet is not sent immediately. */
83 void silc_server_packet_send(SilcServer server,
84 SilcSocketConnection sock,
86 SilcPacketFlags flags,
92 SilcIdType dst_id_type = SILC_ID_NONE;
98 idata = (SilcIDListData)sock->user_data;
100 /* If disconnecting, ignore the data */
101 if (SILC_IS_DISCONNECTING(sock))
104 /* If entry is disabled do not sent anything. Allow hearbeat and
106 if ((idata && idata->status & SILC_IDLIST_STATUS_DISABLED &&
107 type != SILC_PACKET_HEARTBEAT && type != SILC_PACKET_REKEY &&
108 type != SILC_PACKET_REKEY_DONE) ||
109 sock->user_data == server->id_entry) {
110 SILC_LOG_DEBUG(("Connection is disabled"));
114 /* Get data used in the packet sending, keys and stuff */
116 case SILC_SOCKET_TYPE_CLIENT:
117 if (sock->user_data) {
118 dst_id = ((SilcClientEntry)sock->user_data)->id;
119 dst_id_type = SILC_ID_CLIENT;
122 case SILC_SOCKET_TYPE_SERVER:
123 case SILC_SOCKET_TYPE_ROUTER:
124 if (sock->user_data) {
125 dst_id = ((SilcServerEntry)sock->user_data)->id;
126 dst_id_type = SILC_ID_SERVER;
133 silc_server_packet_send_dest(server, sock, type, flags, dst_id,
134 dst_id_type, data, data_len, force_send);
137 /* Assembles a new packet to be sent out to network. This doesn't actually
138 send the packet but creates the packet and fills the outgoing data
139 buffer and marks the packet ready to be sent to network. However, If
140 argument force_send is TRUE the packet is sent immediately and not put
141 to queue. Normal case is that the packet is not sent immediately.
142 Destination information is sent as argument for this function. */
144 void silc_server_packet_send_dest(SilcServer server,
145 SilcSocketConnection sock,
147 SilcPacketFlags flags,
149 SilcIdType dst_id_type,
154 SilcPacketContext packetdata;
155 const SilcBufferStruct packet;
156 SilcIDListData idata;
157 SilcCipher cipher = NULL;
158 SilcHmac hmac = NULL;
159 SilcUInt32 sequence = 0;
160 unsigned char *dst_id_data = NULL;
161 SilcUInt32 dst_id_len = 0;
164 /* If disconnecting, ignore the data */
165 if (!sock || SILC_IS_DISCONNECTING(sock))
168 idata = (SilcIDListData)sock->user_data;
170 /* If entry is disabled do not sent anything. */
171 if ((idata && idata->status & SILC_IDLIST_STATUS_DISABLED) ||
172 sock->user_data == server->id_entry) {
173 SILC_LOG_DEBUG(("Connection is disabled"));
177 SILC_LOG_DEBUG(("Sending %s packet (forced=%s)",
178 silc_get_packet_name(type), force_send ? "yes" : "no"));
181 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
182 dst_id_len = silc_id_get_len(dst_id, dst_id_type);
186 cipher = idata->send_key;
187 hmac = idata->hmac_send;
188 sequence = idata->psn_send++;
190 block_len = silc_cipher_get_block_len(cipher);
192 /* Check for mandatory rekey */
193 if (sequence == SILC_SERVER_REKEY_THRESHOLD)
194 silc_schedule_task_add(server->schedule, sock->sock,
195 silc_server_rekey_callback, sock, 0, 1,
196 SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
199 /* Set the packet context pointers */
200 packetdata.type = type;
201 packetdata.flags = flags;
202 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
203 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
204 packetdata.src_id_type = SILC_ID_SERVER;
205 packetdata.dst_id = dst_id_data;
206 packetdata.dst_id_len = dst_id_len;
207 packetdata.dst_id_type = dst_id_type;
208 data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
209 packetdata.src_id_len +
210 packetdata.dst_id_len));
211 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
212 packetdata.src_id_len + dst_id_len;
213 if (type == SILC_PACKET_CONNECTION_AUTH)
214 SILC_PACKET_PADLEN_MAX(packetdata.truelen, block_len, packetdata.padlen);
216 SILC_PACKET_PADLEN(packetdata.truelen, block_len, packetdata.padlen);
218 /* Create the outgoing packet */
219 if (!silc_packet_assemble(&packetdata, NULL, cipher, hmac, sock,
220 data, data_len, (const SilcBuffer)&packet)) {
221 SILC_LOG_ERROR(("Cannot assemble packet"));
225 /* Encrypt the packet */
226 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&packet, packet.len);
228 SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence, packet.len),
229 packet.data, packet.len);
231 /* Now actually send the packet */
232 silc_server_packet_send_real(server, sock, force_send);
235 silc_free(packetdata.src_id);
236 silc_free(packetdata.dst_id);
239 /* Assembles a new packet to be sent out to network. This doesn't actually
240 send the packet but creates the packet and fills the outgoing data
241 buffer and marks the packet ready to be sent to network. However, If
242 argument force_send is TRUE the packet is sent immediately and not put
243 to queue. Normal case is that the packet is not sent immediately.
244 The source and destination information is sent as argument for this
247 void silc_server_packet_send_srcdest(SilcServer server,
248 SilcSocketConnection sock,
250 SilcPacketFlags flags,
252 SilcIdType src_id_type,
254 SilcIdType dst_id_type,
259 SilcPacketContext packetdata;
260 const SilcBufferStruct packet;
261 SilcIDListData idata;
262 SilcCipher cipher = NULL;
263 SilcHmac hmac = NULL;
264 SilcUInt32 sequence = 0;
265 unsigned char *dst_id_data = NULL;
266 SilcUInt32 dst_id_len = 0;
267 unsigned char *src_id_data = NULL;
268 SilcUInt32 src_id_len = 0;
271 SILC_LOG_DEBUG(("Sending %s packet", silc_get_packet_name(type)));
276 /* Get data used in the packet sending, keys and stuff */
277 idata = (SilcIDListData)sock->user_data;
279 /* If entry is disabled do not sent anything. */
280 if ((idata && idata->status & SILC_IDLIST_STATUS_DISABLED) ||
281 sock->user_data == server->id_entry) {
282 SILC_LOG_DEBUG(("Connection is disabled"));
287 cipher = idata->send_key;
288 hmac = idata->hmac_send;
289 sequence = idata->psn_send++;
290 block_len = silc_cipher_get_block_len(cipher);
292 /* Check for mandatory rekey */
293 if (sequence == SILC_SERVER_REKEY_THRESHOLD)
294 silc_schedule_task_add(server->schedule, sock->sock,
295 silc_server_rekey_callback, sock, 0, 1,
296 SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
300 dst_id_data = silc_id_id2str(dst_id, dst_id_type);
301 dst_id_len = silc_id_get_len(dst_id, dst_id_type);
305 src_id_data = silc_id_id2str(src_id, src_id_type);
306 src_id_len = silc_id_get_len(src_id, src_id_type);
309 /* Set the packet context pointers */
310 packetdata.type = type;
311 packetdata.flags = flags;
312 packetdata.src_id = src_id_data;
313 packetdata.src_id_len = src_id_len;
314 packetdata.src_id_type = src_id_type;
315 packetdata.dst_id = dst_id_data;
316 packetdata.dst_id_len = dst_id_len;
317 packetdata.dst_id_type = dst_id_type;
318 data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
319 packetdata.src_id_len +
321 packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
322 packetdata.src_id_len + dst_id_len;
323 SILC_PACKET_PADLEN(packetdata.truelen, block_len, packetdata.padlen);
325 /* Create the outgoing packet */
326 if (!silc_packet_assemble(&packetdata, NULL, cipher, hmac, sock, data,
327 data_len, (const SilcBuffer)&packet)) {
328 SILC_LOG_ERROR(("Cannot assemble packe"));
332 /* Encrypt the packet */
333 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&packet, packet.len);
335 SILC_LOG_HEXDUMP(("Outgoing packet (%d), len %d", sequence, packet.len),
336 packet.data, packet.len);
338 /* Now actually send the packet */
339 silc_server_packet_send_real(server, sock, force_send);
342 silc_free(packetdata.src_id);
343 silc_free(packetdata.dst_id);
346 /* Broadcast received packet to our primary route. This function is used
347 by router to further route received broadcast packet. It is expected
348 that the broadcast flag from the packet is checked before calling this
349 function. This does not test or set the broadcast flag. */
351 void silc_server_packet_broadcast(SilcServer server,
352 SilcSocketConnection sock,
353 SilcPacketContext *packet)
355 SilcBuffer buffer = packet->buffer;
356 SilcIDListData idata;
362 SILC_LOG_DEBUG(("Broadcasting received broadcast packet"));
364 /* If the packet is originated from our primary route we are
365 not allowed to send the packet. */
366 id = silc_id_str2id(packet->src_id, packet->src_id_len, packet->src_id_type);
367 if (id && !SILC_ID_SERVER_COMPARE(id, server->router->id)) {
368 const SilcBufferStruct p;
370 idata = (SilcIDListData)sock->user_data;
372 silc_buffer_push(buffer, buffer->data - buffer->head);
373 if (!silc_packet_send_prepare(sock, 0, 0, buffer->len, idata->hmac_send,
374 (const SilcBuffer)&p)) {
375 SILC_LOG_ERROR(("Cannot send packet"));
379 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
380 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
381 (SilcBuffer)&p, p.len);
383 SILC_LOG_HEXDUMP(("Broadcasted packet (%d), len %d", idata->psn_send - 1,
384 p.len), p.data, p.len);
386 /* Now actually send the packet */
387 silc_server_packet_send_real(server, sock, TRUE);
390 /* Check for mandatory rekey */
391 if (idata->psn_send == SILC_SERVER_REKEY_THRESHOLD)
392 silc_schedule_task_add(server->schedule, sock->sock,
393 silc_server_rekey_callback, sock, 0, 1,
394 SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
398 SILC_LOG_DEBUG(("Will not broadcast to primary route since it is the "
399 "original sender of this packet"));
403 /* Routes received packet to `sock'. This is used to route the packets that
404 router receives but are not destined to it. */
406 void silc_server_packet_route(SilcServer server,
407 SilcSocketConnection sock,
408 SilcPacketContext *packet)
410 SilcBuffer buffer = packet->buffer;
411 const SilcBufferStruct p;
412 SilcIDListData idata;
414 SILC_LOG_DEBUG(("Routing received packet"));
416 idata = (SilcIDListData)sock->user_data;
418 silc_buffer_push(buffer, buffer->data - buffer->head);
419 if (!silc_packet_send_prepare(sock, 0, 0, buffer->len, idata->hmac_send,
420 (const SilcBuffer)&p)) {
421 SILC_LOG_ERROR(("Cannot send packet"));
424 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
425 silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
426 (SilcBuffer)&p, p.len);
428 SILC_LOG_HEXDUMP(("Routed packet (%d), len %d", idata->psn_send - 1,
429 p.len), p.data, p.len);
431 /* Now actually send the packet */
432 silc_server_packet_send_real(server, sock, TRUE);
434 /* Check for mandatory rekey */
435 if (idata->psn_send == SILC_SERVER_REKEY_THRESHOLD)
436 silc_schedule_task_add(server->schedule, sock->sock,
437 silc_server_rekey_callback, sock, 0, 1,
438 SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
441 /* This routine can be used to send a packet to table of clients provided
442 in `clients'. If `route' is FALSE the packet is routed only to local
443 clients (for server locally connected, and for router local cell). */
445 void silc_server_packet_send_clients(SilcServer server,
446 SilcHashTable clients,
448 SilcPacketFlags flags,
454 SilcSocketConnection sock = NULL;
455 SilcHashTableList htl;
456 SilcClientEntry client = NULL;
457 SilcServerEntry *routed = NULL;
458 SilcUInt32 routed_count = 0;
462 if (!silc_hash_table_count(clients))
465 SILC_LOG_DEBUG(("Sending packet to %d clients",
466 silc_hash_table_count(clients)));
468 /* Send to all clients in table */
469 silc_hash_table_list(clients, &htl);
470 while (silc_hash_table_get(&htl, NULL, (void **)&client)) {
471 /* If client has router set it is not locally connected client and
472 we will route the message to the router set in the client. Though,
473 send locally connected server in all cases. */
474 if (server->server_type == SILC_ROUTER && client->router &&
475 ((!route && client->router->router == server->id_entry) || route)) {
477 /* Check if we have sent the packet to this route already */
478 for (k = 0; k < routed_count; k++)
479 if (routed[k] == client->router)
481 if (k < routed_count)
484 /* Route only once to router */
485 sock = (SilcSocketConnection)client->router->connection;
486 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
492 /* Send the packet */
493 silc_server_packet_send_dest(server, sock, type, flags,
494 client->router->id, SILC_ID_SERVER,
495 data, data_len, force_send);
497 /* Mark this route routed already */
498 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
499 routed[routed_count++] = client->router;
506 /* Send to locally connected client */
507 sock = (SilcSocketConnection)client->connection;
511 silc_server_packet_send_dest(server, sock, type, flags,
512 client->id, SILC_ID_CLIENT,
513 data, data_len, force_send);
515 silc_hash_table_list_reset(&htl);
519 /* Internal routine to actually create the channel packet and send it
520 to network. This is common function in channel message sending. If
521 `channel_message' is TRUE this encrypts the message as it is strictly
522 a channel message. If FALSE normal encryption process is used. */
525 silc_server_packet_send_to_channel_real(SilcServer server,
526 SilcSocketConnection sock,
527 SilcPacketContext *packet,
533 bool channel_message,
537 const SilcBufferStruct p;
542 data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
544 packet->dst_id_len));
545 packet->truelen = data_len + SILC_PACKET_HEADER_LEN +
546 packet->src_id_len + packet->dst_id_len;
548 block_len = cipher ? silc_cipher_get_block_len(cipher) : 0;
550 SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN +
552 packet->dst_id_len), block_len, packet->padlen);
554 SILC_PACKET_PADLEN(packet->truelen, block_len, packet->padlen);
556 /* Put the data to buffer, assemble and encrypt the packet. The packet
557 is encrypted with normal session key shared with the client, unless
558 the `channel_message' is TRUE. */
559 if (!silc_packet_assemble(packet, NULL, cipher, hmac, sock, data,
560 data_len, (const SilcBuffer)&p)) {
561 SILC_LOG_ERROR(("Cannot assemble packet"));
566 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p,
567 SILC_PACKET_HEADER_LEN + packet->src_id_len +
568 packet->dst_id_len + packet->padlen);
570 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, p.len);
572 SILC_LOG_HEXDUMP(("Channel packet (%d), len %d", sequence, p.len),
575 /* Now actually send the packet */
576 silc_server_packet_send_real(server, sock, force_send);
579 /* This routine is used by the server to send packets to channel. The
580 packet sent with this function is distributed to all clients on
581 the channel. Usually this is used to send notify messages to the
582 channel, things like notify about new user joining to the channel.
583 If `route' is FALSE then the packet is sent only locally and will not
584 be routed anywhere (for router locally means cell wide). If `sender'
585 is provided then the packet is not sent to that connection since it
586 originally came from it. If `send_to_clients' is FALSE then the
587 packet is not sent clients, only servers. */
589 void silc_server_packet_send_to_channel(SilcServer server,
590 SilcSocketConnection sender,
591 SilcChannelEntry channel,
598 SilcSocketConnection sock = NULL;
599 SilcPacketContext packetdata;
600 SilcClientEntry client = NULL;
601 SilcServerEntry *routed = NULL;
602 SilcChannelClientEntry chl;
603 SilcHashTableList htl;
604 SilcIDListData idata;
605 SilcUInt32 routed_count = 0;
609 /* This doesn't send channel message packets */
610 assert(type != SILC_PACKET_CHANNEL_MESSAGE);
612 /* Set the packet context pointers. */
613 packetdata.flags = 0;
614 packetdata.type = type;
615 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
616 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
617 packetdata.src_id_type = SILC_ID_SERVER;
618 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
619 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
620 packetdata.dst_id_type = SILC_ID_CHANNEL;
622 /* If there are global users in the channel we will send the message
623 first to our router for further routing. */
624 if (route && server->server_type != SILC_ROUTER && !server->standalone &&
625 channel->global_users) {
626 SilcServerEntry router;
628 /* Get data used in packet header encryption, keys and stuff. */
629 router = server->router;
630 sock = (SilcSocketConnection)router->connection;
631 idata = (SilcIDListData)router;
633 if (sock != sender) {
634 SILC_LOG_DEBUG(("Sending packet to router for routing"));
635 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
639 data, data_len, FALSE,
644 if (!silc_hash_table_count(channel->user_list)) {
645 SILC_LOG_DEBUG(("Channel %s is empty", channel->channel_name));
649 SILC_LOG_DEBUG(("Sending %s to channel %s",
650 silc_get_packet_name(type), channel->channel_name));
652 routed = silc_calloc(silc_hash_table_count(channel->user_list),
655 /* Send the message to clients on the channel's client list. */
656 silc_hash_table_list(channel->user_list, &htl);
657 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
658 client = chl->client;
662 /* If client has router set it is not locally connected client and
663 we will route the message to the router set in the client. Though,
664 send locally connected server in all cases. */
665 if (server->server_type == SILC_ROUTER && client->router &&
666 ((!route && client->router->router == server->id_entry) || route)) {
668 /* Check if we have sent the packet to this route already */
669 for (k = 0; k < routed_count; k++)
670 if (routed[k] == client->router)
672 if (k < routed_count)
675 /* Get data used in packet header encryption, keys and stuff. */
676 sock = (SilcSocketConnection)client->router->connection;
677 idata = (SilcIDListData)client->router;
679 if (sender && sock == sender)
682 /* Route only once to router. Protocol prohibits sending channel
683 messages to more than one router. */
684 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
690 SILC_LOG_DEBUG(("Sending packet to client %s",
691 client->nickname ? client->nickname :
692 (unsigned char *)""));
694 /* Send the packet */
695 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
699 data, data_len, FALSE,
702 /* Mark this route routed already */
703 routed[routed_count++] = client->router;
710 /* Send to locally connected client */
712 /* Get data used in packet header encryption, keys and stuff. */
713 sock = (SilcSocketConnection)client->connection;
714 idata = (SilcIDListData)client;
716 if (!sock || (sender && sock == sender))
719 SILC_LOG_DEBUG(("Sending packet to client %s",
720 client->nickname ? client->nickname :
721 (unsigned char *)""));
723 /* Send the packet */
724 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
728 data, data_len, FALSE,
731 silc_hash_table_list_reset(&htl);
735 silc_free(packetdata.src_id);
736 silc_free(packetdata.dst_id);
739 /* This checks whether the relayed packet came from router. If it did
740 then we'll need to encrypt it with the channel key. This is called
741 from the silc_server_packet_relay_to_channel. */
744 silc_server_packet_relay_to_channel_encrypt(SilcServer server,
745 SilcSocketConnection sock,
746 SilcChannelEntry channel,
748 unsigned int data_len)
750 SilcUInt32 mac_len, iv_len;
751 unsigned char iv[SILC_CIPHER_MAX_IV_SIZE];
753 /* If we are router and the packet came from router and private key
754 has not been set for the channel then we must encrypt the packet
755 as it was decrypted with the session key shared between us and the
756 router which sent it. This is so, because cells does not share the
758 if (server->server_type == SILC_ROUTER &&
759 sock->type == SILC_SOCKET_TYPE_ROUTER &&
760 !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) && channel->key) {
762 /* If we are backup router and remote is our primary router and
763 we are currently doing backup resuming protocol we must not
764 re-encrypt message with session key. */
765 if (server->backup_router && SILC_SERVER_IS_BACKUP(sock) &&
766 SILC_PRIMARY_ROUTE(server) == sock)
769 mac_len = silc_hmac_len(channel->hmac);
770 iv_len = silc_cipher_get_block_len(channel->channel_key);
772 if (data_len <= mac_len + iv_len) {
773 SILC_LOG_WARNING(("Corrupted channel message, cannot relay it"));
777 memcpy(iv, data + (data_len - iv_len - mac_len), iv_len);
778 silc_message_payload_encrypt(data, data_len - iv_len, data_len,
779 iv, iv_len, channel->channel_key,
786 /* This routine is explicitly used to relay messages to some channel.
787 Packets sent with this function we have received earlier and are
788 totally encrypted. This just sends the packet to all clients on
789 the channel. If the sender of the packet is someone on the channel
790 the message will not be sent to that client. The SILC Packet header
791 is encrypted with the session key shared between us and the client.
792 MAC is also computed before encrypting the header. Rest of the
793 packet will be untouched. */
795 void silc_server_packet_relay_to_channel(SilcServer server,
796 SilcSocketConnection sender_sock,
797 SilcChannelEntry channel,
799 SilcIdType sender_type,
800 SilcClientEntry sender_entry,
805 SilcSocketConnection sock = NULL;
806 SilcPacketContext packetdata;
807 SilcClientEntry client = NULL;
808 SilcServerEntry *routed = NULL;
809 SilcChannelClientEntry chl, chl_sender;
810 SilcUInt32 routed_count = 0;
811 SilcIDListData idata;
812 SilcHashTableList htl;
816 if (!silc_server_client_on_channel(sender_entry, channel, &chl_sender))
819 SILC_LOG_DEBUG(("Relaying packet to channel %s", channel->channel_name));
821 /* This encrypts the packet, if needed. It will be encrypted if
822 it came from the router thus it needs to be encrypted with the
823 channel key. If the channel key does not exist, then we know we
824 don't have a single local user on the channel. */
825 if (!silc_server_packet_relay_to_channel_encrypt(server, sender_sock,
830 /* Set the packet context pointers. */
831 packetdata.flags = 0;
832 packetdata.type = SILC_PACKET_CHANNEL_MESSAGE;
833 packetdata.src_id = silc_id_id2str(sender_id, sender_type);
834 packetdata.src_id_len = silc_id_get_len(sender_id, sender_type);
835 packetdata.src_id_type = sender_type;
836 packetdata.dst_id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
837 packetdata.dst_id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
838 packetdata.dst_id_type = SILC_ID_CHANNEL;
840 /* If there are global users in the channel we will send the message
841 first to our router for further routing. */
842 if (server->server_type != SILC_ROUTER && !server->standalone &&
843 channel->global_users) {
844 SilcServerEntry router = server->router;
846 /* Check that the sender is not our router. */
847 if (sender_sock != (SilcSocketConnection)router->connection) {
849 /* Get data used in packet header encryption, keys and stuff. */
850 sock = (SilcSocketConnection)router->connection;
851 idata = (SilcIDListData)router;
853 SILC_LOG_DEBUG(("Sending message to router for routing"));
855 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
859 data, data_len, TRUE,
864 routed = silc_calloc(silc_hash_table_count(channel->user_list),
867 /* Assure we won't route the message back to the sender's way. */
868 if (sender_entry->router)
869 routed[routed_count++] = sender_entry->router;
871 /* Send the message to clients on the channel's client list. */
872 silc_hash_table_list(channel->user_list, &htl);
873 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
874 client = chl->client;
875 if (!client || client == sender_entry)
878 /* Check whether message sending is blocked */
879 if (chl->mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES)
881 if (chl->mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES_USERS &&
882 !(chl_sender->mode & SILC_CHANNEL_UMODE_CHANOP) &&
883 !(chl_sender->mode & SILC_CHANNEL_UMODE_CHANFO))
885 if (chl->mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES_ROBOTS &&
886 sender_entry->mode & SILC_UMODE_ROBOT)
889 /* If the client has set router it means that it is not locally
890 connected client and we will route the packet further. */
891 if (server->server_type == SILC_ROUTER && client->router) {
893 /* Check if we have sent the packet to this route already */
894 for (k = 0; k < routed_count; k++)
895 if (routed[k] == client->router)
897 if (k < routed_count)
900 /* Get data used in packet header encryption, keys and stuff. */
901 sock = (SilcSocketConnection)client->router->connection;
902 idata = (SilcIDListData)client->router;
904 /* Check if the sender socket is the same as this client's router
906 if (sender_sock && sock == sender_sock)
909 SILC_LOG_DEBUG(("Relaying packet to client ID(%s) %s (%s)",
910 silc_id_render(client->id, SILC_ID_CLIENT),
911 sock->hostname, sock->ip));
913 /* Mark this route routed already. */
914 routed[routed_count++] = client->router;
916 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
917 /* The remote connection is router then we'll decrypt the
918 channel message and re-encrypt it with the session key shared
919 between us and the remote router. This is done because the
920 channel keys are cell specific and we have different channel
921 key than the remote router has. */
923 /* Route only once to router. Protocol prohibits sending channel
924 messages to more than one router. */
929 /* If we are backup router and remote is our primary router and
930 we are currently doing backup resuming protocol we must not
931 re-encrypt message with session key. */
932 if (server->backup_router && SILC_SERVER_IS_BACKUP(sock) &&
933 SILC_PRIMARY_ROUTE(server) == sock) {
934 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
938 data, data_len, TRUE,
943 SILC_LOG_DEBUG(("Remote is router, encrypt with session key"));
945 /* If private key mode is not set then decrypt the packet
947 if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY) &&
948 channel->channel_key) {
949 unsigned char tmp[SILC_PACKET_MAX_LEN];
951 if (data_len > SILC_PACKET_MAX_LEN)
952 data_len = SILC_PACKET_MAX_LEN;
953 memcpy(tmp, data, data_len);
955 /* Decrypt the channel message (we don't check the MAC) */
956 silc_message_payload_decrypt(tmp, data_len, FALSE, FALSE,
957 channel->channel_key,
958 channel->hmac, FALSE);
960 /* Now re-encrypt and send it to the router */
961 silc_server_packet_send_srcdest(server, sock,
962 SILC_PACKET_CHANNEL_MESSAGE, 0,
963 sender_id, sender_type,
964 channel->id, SILC_ID_CHANNEL,
965 tmp, data_len, force_send);
967 /* Private key mode is set, we don't have the channel key, so
968 just re-encrypt the entire packet and send it to the router. */
969 silc_server_packet_send_srcdest(server, sock,
970 SILC_PACKET_CHANNEL_MESSAGE, 0,
971 sender_id, sender_type,
972 channel->id, SILC_ID_CHANNEL,
973 data, data_len, force_send);
976 /* Send the packet to normal server */
977 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
981 data, data_len, TRUE,
991 /* Get data used in packet header encryption, keys and stuff. */
992 sock = (SilcSocketConnection)client->connection;
993 idata = (SilcIDListData)client;
995 if (!sock || (sender_sock && sock == sender_sock))
998 SILC_LOG_DEBUG(("Sending packet to client ID(%s) %s (%s)",
999 silc_id_render(client->id, SILC_ID_CLIENT),
1000 sock->hostname, sock->ip));
1002 /* Send the packet */
1003 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1007 data, data_len, TRUE,
1011 silc_hash_table_list_reset(&htl);
1013 silc_free(packetdata.src_id);
1014 silc_free(packetdata.dst_id);
1017 /* This function is used to send packets strictly to all local clients
1018 on a particular channel. This is used for example to distribute new
1019 channel key to all our locally connected clients on the channel.
1020 The packets are always encrypted with the session key shared between
1021 the client, this means these are not _to the channel_ but _to the client_
1024 void silc_server_packet_send_local_channel(SilcServer server,
1025 SilcChannelEntry channel,
1026 SilcPacketType type,
1027 SilcPacketFlags flags,
1028 unsigned char *data,
1029 SilcUInt32 data_len,
1032 SilcChannelClientEntry chl;
1033 SilcHashTableList htl;
1034 SilcSocketConnection sock = NULL;
1036 SILC_LOG_DEBUG(("Send packet to local clients on channel %s",
1037 channel->channel_name));
1039 /* Send the message to clients on the channel's client list. */
1040 silc_hash_table_list(channel->user_list, &htl);
1041 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
1042 if (chl->client && SILC_IS_LOCAL(chl->client)) {
1043 sock = chl->client->connection;
1045 /* Send the packet to the client */
1046 silc_server_packet_send_dest(server, sock, type, flags, chl->client->id,
1047 SILC_ID_CLIENT, data, data_len,
1051 silc_hash_table_list_reset(&htl);
1054 /* Routine used to send (relay, route) private messages to some destination.
1055 If the private message key does not exist then the message is re-encrypted,
1056 otherwise we just pass it along. This really is not used to send new
1057 private messages (as server does not send them) but to relay received
1058 private messages. */
1060 void silc_server_send_private_message(SilcServer server,
1061 SilcSocketConnection dst_sock,
1064 SilcUInt32 sequence,
1065 SilcPacketContext *packet)
1067 SilcBuffer buffer = packet->buffer;
1068 const SilcBufferStruct p;
1070 silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1071 + packet->dst_id_len + packet->padlen);
1072 if (!silc_packet_send_prepare(dst_sock, 0, 0, buffer->len, hmac,
1073 (const SilcBuffer)&p)) {
1074 SILC_LOG_ERROR(("Cannot send packet"));
1077 silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
1079 /* Re-encrypt and send if private messge key does not exist */
1080 if (!(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY)) {
1081 /* Re-encrypt packet */
1082 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, buffer->len);
1084 /* Key exist so encrypt just header and send it */
1085 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p,
1086 SILC_PACKET_HEADER_LEN + packet->src_id_len +
1087 packet->dst_id_len + packet->padlen);
1090 /* Send the packet */
1091 silc_server_packet_send_real(server, dst_sock, FALSE);
1093 /* Check for mandatory rekey */
1094 if (sequence == SILC_SERVER_REKEY_THRESHOLD)
1095 silc_schedule_task_add(server->schedule, dst_sock->sock,
1096 silc_server_rekey_callback, dst_sock, 0, 1,
1097 SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
1100 /* Sends current motd to client */
1102 void silc_server_send_motd(SilcServer server,
1103 SilcSocketConnection sock)
1105 char *motd, *motd_file = NULL;
1106 SilcUInt32 motd_len;
1109 motd_file = server->config->server_info->motd_file;
1112 motd = silc_file_readfile(motd_file, &motd_len);
1117 silc_server_send_notify(server, sock, FALSE, SILC_NOTIFY_TYPE_MOTD, 1,
1123 /* Sends error message. Error messages may or may not have any
1126 void silc_server_send_error(SilcServer server,
1127 SilcSocketConnection sock,
1128 const char *fmt, ...)
1131 unsigned char buf[4096];
1133 memset(buf, 0, sizeof(buf));
1135 vsnprintf(buf, sizeof(buf) - 1, fmt, ap);
1138 silc_server_packet_send(server, sock, SILC_PACKET_ERROR, 0,
1139 buf, strlen(buf), FALSE);
1142 /* Sends notify message. If format is TRUE the variable arguments are
1143 formatted and the formatted string is sent as argument payload. If it is
1144 FALSE then each argument is sent as separate argument and their format
1145 in the argument list must be { argument data, argument length }. */
1147 void silc_server_send_notify(SilcServer server,
1148 SilcSocketConnection sock,
1150 SilcNotifyType type,
1151 SilcUInt32 argc, ...)
1158 packet = silc_notify_payload_encode(type, argc, ap);
1159 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1160 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1161 packet->data, packet->len, FALSE);
1163 /* Send to backup routers if this is being broadcasted to primary
1164 router. The silc_server_backup_send checks further whether to
1165 actually send it or not. */
1166 if ((broadcast && sock && sock == SILC_PRIMARY_ROUTE(server)) ||
1167 (broadcast && !sock && !SILC_PRIMARY_ROUTE(server)))
1168 silc_server_backup_send(server, NULL, SILC_PACKET_NOTIFY, 0,
1169 packet->data, packet->len, FALSE, TRUE);
1171 silc_buffer_free(packet);
1175 /* Sends notify message and gets the arguments from the `args' Argument
1178 void silc_server_send_notify_args(SilcServer server,
1179 SilcSocketConnection sock,
1181 SilcNotifyType type,
1187 packet = silc_notify_payload_encode_args(type, argc, args);
1188 silc_server_packet_send(server, sock, SILC_PACKET_NOTIFY,
1189 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1190 packet->data, packet->len, FALSE);
1191 silc_buffer_free(packet);
1194 /* Send CHANNEL_CHANGE notify type. This tells the receiver to replace the
1195 `old_id' with the `new_id'. */
1197 void silc_server_send_notify_channel_change(SilcServer server,
1198 SilcSocketConnection sock,
1200 SilcChannelID *old_id,
1201 SilcChannelID *new_id)
1203 SilcBuffer idp1, idp2;
1205 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CHANNEL);
1206 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CHANNEL);
1208 silc_server_send_notify(server, sock, broadcast,
1209 SILC_NOTIFY_TYPE_CHANNEL_CHANGE,
1210 2, idp1->data, idp1->len, idp2->data, idp2->len);
1211 silc_buffer_free(idp1);
1212 silc_buffer_free(idp2);
1215 /* Send NICK_CHANGE notify type. This tells the receiver to replace the
1216 `old_id' with the `new_id'. */
1218 void silc_server_send_notify_nick_change(SilcServer server,
1219 SilcSocketConnection sock,
1221 SilcClientID *old_id,
1222 SilcClientID *new_id,
1223 const char *nickname)
1225 SilcBuffer idp1, idp2;
1227 idp1 = silc_id_payload_encode((void *)old_id, SILC_ID_CLIENT);
1228 idp2 = silc_id_payload_encode((void *)new_id, SILC_ID_CLIENT);
1230 silc_server_send_notify(server, sock, broadcast,
1231 SILC_NOTIFY_TYPE_NICK_CHANGE,
1232 3, idp1->data, idp1->len, idp2->data, idp2->len,
1233 nickname, nickname ? strlen(nickname) : 0);
1234 silc_buffer_free(idp1);
1235 silc_buffer_free(idp2);
1238 /* Sends JOIN notify type. This tells that new client by `client_id' ID
1239 has joined to the `channel'. */
1241 void silc_server_send_notify_join(SilcServer server,
1242 SilcSocketConnection sock,
1244 SilcChannelEntry channel,
1245 SilcClientID *client_id)
1247 SilcBuffer idp1, idp2;
1249 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1250 idp2 = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1251 silc_server_send_notify(server, sock, broadcast, SILC_NOTIFY_TYPE_JOIN,
1252 2, idp1->data, idp1->len,
1253 idp2->data, idp2->len);
1254 silc_buffer_free(idp1);
1255 silc_buffer_free(idp2);
1258 /* Sends LEAVE notify type. This tells that `client_id' has left the
1259 `channel'. The Notify packet is always destined to the channel. */
1261 void silc_server_send_notify_leave(SilcServer server,
1262 SilcSocketConnection sock,
1264 SilcChannelEntry channel,
1265 SilcClientID *client_id)
1269 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1270 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1271 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_LEAVE,
1272 1, idp->data, idp->len);
1273 silc_buffer_free(idp);
1276 /* Sends CMODE_CHANGE notify type. This tells that `client_id' changed the
1277 `channel' mode to `mode. The Notify packet is always destined to
1280 void silc_server_send_notify_cmode(SilcServer server,
1281 SilcSocketConnection sock,
1283 SilcChannelEntry channel,
1284 SilcUInt32 mode_mask,
1285 void *id, SilcIdType id_type,
1286 const char *cipher, const char *hmac,
1287 const char *passphrase,
1288 SilcPublicKey founder_key)
1290 SilcBuffer idp, fkey = NULL;
1291 unsigned char mode[4];
1293 idp = silc_id_payload_encode((void *)id, id_type);
1294 SILC_PUT32_MSB(mode_mask, mode);
1296 fkey = silc_pkcs_public_key_payload_encode(founder_key);
1298 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1299 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_CMODE_CHANGE,
1300 6, idp->data, idp->len,
1302 cipher, cipher ? strlen(cipher) : 0,
1303 hmac, hmac ? strlen(hmac) : 0,
1304 passphrase, passphrase ?
1305 strlen(passphrase) : 0,
1306 fkey ? fkey->data : NULL, fkey ? fkey->len : 0);
1307 silc_buffer_free(fkey),
1308 silc_buffer_free(idp);
1311 /* Sends CUMODE_CHANGE notify type. This tells that `id' changed the
1312 `target' client's mode on `channel'. The notify packet is always
1313 destined to the channel. */
1315 void silc_server_send_notify_cumode(SilcServer server,
1316 SilcSocketConnection sock,
1318 SilcChannelEntry channel,
1319 SilcUInt32 mode_mask,
1320 void *id, SilcIdType id_type,
1321 SilcClientID *target,
1322 SilcPublicKey founder_key)
1324 SilcBuffer idp1, idp2, fkey = NULL;
1325 unsigned char mode[4];
1327 idp1 = silc_id_payload_encode((void *)id, id_type);
1328 idp2 = silc_id_payload_encode((void *)target, SILC_ID_CLIENT);
1329 SILC_PUT32_MSB(mode_mask, mode);
1331 fkey = silc_pkcs_public_key_payload_encode(founder_key);
1333 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1335 SILC_NOTIFY_TYPE_CUMODE_CHANGE, 4,
1336 idp1->data, idp1->len,
1338 idp2->data, idp2->len,
1339 fkey ? fkey->data : NULL, fkey ? fkey->len : 0);
1340 silc_buffer_free(fkey);
1341 silc_buffer_free(idp1);
1342 silc_buffer_free(idp2);
1345 /* Sends SIGNOFF notify type. This tells that `client_id' client has
1346 left SILC network. This function is used only between server and router
1347 traffic. This is not used to send the notify to the channel for
1348 client. The `message may be NULL. */
1350 void silc_server_send_notify_signoff(SilcServer server,
1351 SilcSocketConnection sock,
1353 SilcClientID *client_id,
1354 const char *message)
1358 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1359 silc_server_send_notify(server, sock, broadcast,
1360 SILC_NOTIFY_TYPE_SIGNOFF,
1361 message ? 2 : 1, idp->data, idp->len,
1362 message, message ? strlen(message): 0);
1363 silc_buffer_free(idp);
1366 /* Sends TOPIC_SET notify type. This tells that `id' changed
1367 the `channel's topic to `topic'. The Notify packet is always destined
1368 to the channel. This function is used to send the topic set notifies
1371 void silc_server_send_notify_topic_set(SilcServer server,
1372 SilcSocketConnection sock,
1374 SilcChannelEntry channel,
1375 void *id, SilcIdType id_type,
1380 idp = silc_id_payload_encode(id, id_type);
1381 silc_server_send_notify_dest(server, sock, broadcast,
1382 (void *)channel->id, SILC_ID_CHANNEL,
1383 SILC_NOTIFY_TYPE_TOPIC_SET,
1385 idp->data, idp->len,
1386 topic, topic ? strlen(topic) : 0);
1387 silc_buffer_free(idp);
1390 /* Send KICKED notify type. This tells that the `client_id' on `channel'
1391 was kicked off the channel. The `comment' may indicate the reason
1392 for the kicking. This function is used only between server and router
1395 void silc_server_send_notify_kicked(SilcServer server,
1396 SilcSocketConnection sock,
1398 SilcChannelEntry channel,
1399 SilcClientID *client_id,
1400 SilcClientID *kicker,
1406 idp1 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1407 idp2 = silc_id_payload_encode((void *)kicker, SILC_ID_CLIENT);
1408 silc_server_send_notify_dest(server, sock, broadcast, (void *)channel->id,
1409 SILC_ID_CHANNEL, SILC_NOTIFY_TYPE_KICKED, 3,
1410 idp1->data, idp1->len,
1411 comment, comment ? strlen(comment) : 0,
1412 idp2->data, idp2->len);
1413 silc_buffer_free(idp1);
1414 silc_buffer_free(idp2);
1417 /* Send KILLED notify type. This tells that the `client_id' client was
1418 killed from the network. The `comment' may indicate the reason
1421 void silc_server_send_notify_killed(SilcServer server,
1422 SilcSocketConnection sock,
1424 SilcClientID *client_id,
1425 const char *comment,
1426 void *killer, SilcIdType killer_type)
1431 idp1 = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
1432 idp2 = silc_id_payload_encode(killer, killer_type);
1433 silc_server_send_notify_dest(server, sock, broadcast, (void *)client_id,
1434 SILC_ID_CLIENT, SILC_NOTIFY_TYPE_KILLED,
1435 3, idp1->data, idp1->len,
1436 comment, comment ? strlen(comment) : 0,
1437 idp2->data, idp2->len);
1438 silc_buffer_free(idp1);
1439 silc_buffer_free(idp2);
1442 /* Sends UMODE_CHANGE notify type. This tells that `client_id' client's
1443 user mode in the SILC Network was changed. This function is used to
1444 send the packet between routers as broadcast packet. */
1446 void silc_server_send_notify_umode(SilcServer server,
1447 SilcSocketConnection sock,
1449 SilcClientID *client_id,
1450 SilcUInt32 mode_mask)
1453 unsigned char mode[4];
1455 idp = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1456 SILC_PUT32_MSB(mode_mask, mode);
1458 silc_server_send_notify(server, sock, broadcast,
1459 SILC_NOTIFY_TYPE_UMODE_CHANGE, 2,
1460 idp->data, idp->len,
1462 silc_buffer_free(idp);
1465 /* Sends BAN notify type. This tells that ban has been either `add'ed
1466 or `del'eted on the `channel. This function is used to send the packet
1467 between routers as broadcast packet. */
1469 void silc_server_send_notify_ban(SilcServer server,
1470 SilcSocketConnection sock,
1472 SilcChannelEntry channel,
1473 unsigned char *action,
1478 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1479 silc_server_send_notify(server, sock, broadcast,
1480 SILC_NOTIFY_TYPE_BAN, 3,
1481 idp->data, idp->len,
1482 action ? action : NULL, action ? 1 : 0,
1483 list ? list->data : NULL, list ? list->len : 0);
1484 silc_buffer_free(idp);
1487 /* Sends INVITE notify type. This tells that invite has been either `add'ed
1488 or `del'eted on the `channel. The sender of the invite is the `client_id'.
1489 This function is used to send the packet between routers as broadcast
1492 void silc_server_send_notify_invite(SilcServer server,
1493 SilcSocketConnection sock,
1495 SilcChannelEntry channel,
1496 SilcClientID *client_id,
1497 unsigned char *action,
1500 SilcBuffer idp, idp2;
1502 idp = silc_id_payload_encode((void *)channel->id, SILC_ID_CHANNEL);
1503 idp2 = silc_id_payload_encode((void *)client_id, SILC_ID_CLIENT);
1504 silc_server_send_notify(server, sock, broadcast,
1505 SILC_NOTIFY_TYPE_INVITE, 5,
1506 idp->data, idp->len,
1507 channel->channel_name, strlen(channel->channel_name),
1508 idp2->data, idp2->len,
1509 action ? action : NULL, action ? 1 : 0,
1510 list ? list->data : NULL, list ? list->len : 0);
1511 silc_buffer_free(idp);
1512 silc_buffer_free(idp2);
1515 /* Sends WATCH notify type. This tells that the `client' was watched and
1516 its status in the network has changed. */
1518 void silc_server_send_notify_watch(SilcServer server,
1519 SilcSocketConnection sock,
1520 SilcClientEntry watcher,
1521 SilcClientEntry client,
1522 const char *nickname,
1523 SilcNotifyType type)
1526 unsigned char mode[4], n[2];
1528 idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
1529 SILC_PUT16_MSB(type, n);
1530 SILC_PUT32_MSB(client->mode, mode);
1531 silc_server_send_notify_dest(server, sock, FALSE, watcher->id,
1532 SILC_ID_CLIENT, SILC_NOTIFY_TYPE_WATCH,
1533 4, idp->data, idp->len,
1534 nickname, nickname ? strlen(nickname) : 0,
1536 type != SILC_NOTIFY_TYPE_NONE ?
1537 n : NULL, sizeof(n));
1538 silc_buffer_free(idp);
1541 /* Sends notify message destined to specific entity. */
1543 void silc_server_send_notify_dest(SilcServer server,
1544 SilcSocketConnection sock,
1547 SilcIdType dest_id_type,
1548 SilcNotifyType type,
1549 SilcUInt32 argc, ...)
1556 packet = silc_notify_payload_encode(type, argc, ap);
1557 silc_server_packet_send_dest(server, sock, SILC_PACKET_NOTIFY,
1558 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1559 dest_id, dest_id_type,
1560 packet->data, packet->len, FALSE);
1562 /* Send to backup routers if this is being broadcasted to primary
1563 router. The silc_server_backup_send checks further whether to
1564 actually send it or not. */
1565 if ((broadcast && sock && sock == SILC_PRIMARY_ROUTE(server)) ||
1566 (broadcast && !sock && !SILC_PRIMARY_ROUTE(server)))
1567 silc_server_backup_send_dest(server, NULL, SILC_PACKET_NOTIFY, 0,
1568 dest_id, dest_id_type,
1569 packet->data, packet->len, FALSE, TRUE);
1571 silc_buffer_free(packet);
1575 /* Sends notify message to a channel. The notify message sent is
1576 distributed to all clients on the channel. If `route_notify' is TRUE
1577 then the notify may be routed to primary route or to some other routers.
1578 If FALSE it is assured that the notify is sent only locally. If `sender'
1579 is provided then the packet is not sent to that connection since it
1580 originally came from it. */
1582 void silc_server_send_notify_to_channel(SilcServer server,
1583 SilcSocketConnection sender,
1584 SilcChannelEntry channel,
1586 SilcNotifyType type,
1587 SilcUInt32 argc, ...)
1594 packet = silc_notify_payload_encode(type, argc, ap);
1595 silc_server_packet_send_to_channel(server, sender, channel,
1596 SILC_PACKET_NOTIFY, route_notify,
1597 packet->data, packet->len, FALSE);
1598 silc_buffer_free(packet);
1602 /* Send notify message to all channels the client has joined. It is quaranteed
1603 that the message is sent only once to a client (ie. if a client is joined
1604 on two same channel it will receive only one notify message). Also, this
1605 sends only to local clients (locally connected if we are server, and to
1606 local servers if we are router). If `sender' is provided the packet is
1607 not sent to that client at all. */
1609 void silc_server_send_notify_on_channels(SilcServer server,
1610 SilcClientEntry sender,
1611 SilcClientEntry client,
1612 SilcNotifyType type,
1613 SilcUInt32 argc, ...)
1616 SilcSocketConnection sock = NULL;
1617 SilcPacketContext packetdata;
1619 SilcClientEntry *sent_clients = NULL;
1620 SilcUInt32 sent_clients_count = 0;
1621 SilcServerEntry *routed = NULL;
1622 SilcUInt32 routed_count = 0;
1623 SilcHashTableList htl, htl2;
1624 SilcChannelEntry channel;
1625 SilcChannelClientEntry chl, chl2;
1626 SilcIDListData idata;
1628 unsigned char *data;
1629 SilcUInt32 data_len;
1630 bool force_send = FALSE;
1633 if (!silc_hash_table_count(client->channels)) {
1634 SILC_LOG_DEBUG(("Client is not joined to any channels"));
1638 SILC_LOG_DEBUG(("Sending notify to joined channels"));
1641 packet = silc_notify_payload_encode(type, argc, ap);
1642 data = packet->data;
1643 data_len = packet->len;
1645 /* Set the packet context pointers. */
1646 packetdata.flags = 0;
1647 packetdata.type = SILC_PACKET_NOTIFY;
1648 packetdata.src_id = silc_id_id2str(server->id, SILC_ID_SERVER);
1649 packetdata.src_id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
1650 packetdata.src_id_type = SILC_ID_SERVER;
1652 silc_hash_table_list(client->channels, &htl);
1653 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
1654 channel = chl->channel;
1656 /* Send the message to all clients on the channel's client list. */
1657 silc_hash_table_list(channel->user_list, &htl2);
1658 while (silc_hash_table_get(&htl2, NULL, (void **)&chl2)) {
1661 if (sender && c == sender)
1664 /* Check if we have sent the packet to this client already */
1665 for (k = 0; k < sent_clients_count; k++)
1666 if (sent_clients[k] == c)
1668 if (k < sent_clients_count)
1671 /* If we are router and if this client has router set it is not
1672 locally connected client and we will route the message to the
1673 router set in the client. */
1674 if (c && c->router && server->server_type == SILC_ROUTER) {
1675 /* Check if we have sent the packet to this route already */
1676 for (k = 0; k < routed_count; k++)
1677 if (routed[k] == c->router)
1679 if (k < routed_count)
1682 /* Get data used in packet header encryption, keys and stuff. */
1683 sock = (SilcSocketConnection)c->router->connection;
1684 idata = (SilcIDListData)c->router;
1687 SILC_LOG_DEBUG(("*****************"));
1688 SILC_LOG_DEBUG(("client->router->id %s",
1689 silc_id_render(c->router->id, SILC_ID_SERVER)));
1690 SILC_LOG_DEBUG(("client->router->connection->user_data->id %s",
1691 silc_id_render(((SilcServerEntry)sock->user_data)->id, SILC_ID_SERVER)));
1694 packetdata.dst_id = silc_id_id2str(c->router->id, SILC_ID_SERVER);
1695 packetdata.dst_id_len = silc_id_get_len(c->router->id, SILC_ID_SERVER);
1696 packetdata.dst_id_type = SILC_ID_SERVER;
1698 /* Send the packet */
1699 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1703 data, data_len, FALSE,
1706 silc_free(packetdata.dst_id);
1708 /* We want to make sure that the packet is routed to same router
1709 only once. Mark this route as sent route. */
1710 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
1711 routed[routed_count++] = c->router;
1718 /* Send to locally connected client */
1721 /* Get data used in packet header encryption, keys and stuff. */
1722 sock = (SilcSocketConnection)c->connection;
1723 idata = (SilcIDListData)c;
1728 packetdata.dst_id = silc_id_id2str(c->id, SILC_ID_CLIENT);
1729 packetdata.dst_id_len = silc_id_get_len(c->id, SILC_ID_CLIENT);
1730 packetdata.dst_id_type = SILC_ID_CLIENT;
1732 /* Send the packet */
1733 silc_server_packet_send_to_channel_real(server, sock, &packetdata,
1737 data, data_len, FALSE,
1740 silc_free(packetdata.dst_id);
1742 /* Make sure that we send the notify only once per client. */
1743 sent_clients = silc_realloc(sent_clients, sizeof(*sent_clients) *
1744 (sent_clients_count + 1));
1745 sent_clients[sent_clients_count++] = c;
1748 silc_hash_table_list_reset(&htl2);
1751 silc_hash_table_list_reset(&htl);
1753 silc_free(sent_clients);
1754 silc_free(packetdata.src_id);
1755 silc_buffer_free(packet);
1759 /* Sends New ID Payload to remote end. The packet is used to distribute
1760 information about new registered clients, servers, channel etc. usually
1761 to routers so that they can keep these information up to date.
1762 If the argument `broadcast' is TRUE then the packet is sent as
1763 broadcast packet. */
1765 void silc_server_send_new_id(SilcServer server,
1766 SilcSocketConnection sock,
1768 void *id, SilcIdType id_type,
1773 SILC_LOG_DEBUG(("Sending new ID"));
1775 idp = silc_id_payload_encode(id, id_type);
1776 silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID,
1777 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1778 idp->data, idp->len, FALSE);
1779 silc_buffer_free(idp);
1782 /* Send New Channel Payload to notify about newly created channel in the
1783 SILC network. Router uses this to notify other routers in the network
1784 about new channel. This packet is broadcasted by router. */
1786 void silc_server_send_new_channel(SilcServer server,
1787 SilcSocketConnection sock,
1791 SilcUInt32 channel_id_len,
1796 SilcUInt32 name_len = strlen(channel_name);
1798 SILC_LOG_DEBUG(("Sending new channel"));
1800 cid = silc_id_id2str(channel_id, SILC_ID_CHANNEL);
1804 /* Encode the channel payload */
1805 packet = silc_channel_payload_encode(channel_name, name_len,
1806 cid, channel_id_len, mode);
1808 silc_server_packet_send(server, sock, SILC_PACKET_NEW_CHANNEL,
1809 broadcast ? SILC_PACKET_FLAG_BROADCAST : 0,
1810 packet->data, packet->len, FALSE);
1813 silc_buffer_free(packet);
1816 /* Send Channel Key payload to distribute the new channel key. Normal server
1817 sends this to router when new client joins to existing channel. Router
1818 sends this to the local server who sent the join command in case where
1819 the channel did not exist yet. Both normal and router servers uses this
1820 also to send this to locally connected clients on the channel. This
1821 must not be broadcasted packet. Routers do not send this to each other.
1822 If `sender is provided then the packet is not sent to that connection since
1823 it originally came from it. */
1825 void silc_server_send_channel_key(SilcServer server,
1826 SilcSocketConnection sender,
1827 SilcChannelEntry channel,
1828 unsigned char route)
1831 unsigned char *chid;
1835 SILC_LOG_DEBUG(("Sending key to channel %s", channel->channel_name));
1837 chid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
1841 if (!channel->channel_key)
1844 /* Encode channel key packet */
1845 cipher = silc_cipher_get_name(channel->channel_key);
1846 tmp_len = strlen(cipher);
1847 packet = silc_channel_key_payload_encode(silc_id_get_len(channel->id,
1849 chid, tmp_len, cipher,
1850 channel->key_len / 8, channel->key);
1851 silc_server_packet_send_to_channel(server, sender, channel,
1852 SILC_PACKET_CHANNEL_KEY,
1853 route, packet->data, packet->len,
1855 silc_buffer_free(packet);
1859 /* Generic function to send any command. The arguments must be sent already
1860 encoded into correct form in correct order. */
1862 void silc_server_send_command(SilcServer server,
1863 SilcSocketConnection sock,
1864 SilcCommand command,
1866 SilcUInt32 argc, ...)
1873 packet = silc_command_payload_encode_vap(command, ident, argc, ap);
1874 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND, 0,
1875 packet->data, packet->len, FALSE);
1876 silc_buffer_free(packet);
1880 /* Generic function to send any command reply. The arguments must be sent
1881 already encoded into correct form in correct order. */
1883 void silc_server_send_command_reply(SilcServer server,
1884 SilcSocketConnection sock,
1885 SilcCommand command,
1889 SilcUInt32 argc, ...)
1896 packet = silc_command_reply_payload_encode_vap(command, status, error,
1898 silc_server_packet_send(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1899 packet->data, packet->len, TRUE);
1900 silc_buffer_free(packet);
1904 /* Generic function to send any command reply. The arguments must be sent
1905 already encoded into correct form in correct order. */
1907 void silc_server_send_dest_command_reply(SilcServer server,
1908 SilcSocketConnection sock,
1910 SilcIdType dst_id_type,
1911 SilcCommand command,
1915 SilcUInt32 argc, ...)
1922 packet = silc_command_reply_payload_encode_vap(command, status, error,
1924 silc_server_packet_send_dest(server, sock, SILC_PACKET_COMMAND_REPLY, 0,
1925 dst_id, dst_id_type, packet->data,
1926 packet->len, FALSE);
1927 silc_buffer_free(packet);
1931 /* Send the heartbeat packet. */
1933 void silc_server_send_heartbeat(SilcServer server,
1934 SilcSocketConnection sock)
1936 silc_server_packet_send(server, sock, SILC_PACKET_HEARTBEAT, 0,
1940 /* Generic function to relay packet we've received. This is used to relay
1941 packets to a client but generally can be used to other purposes as well. */
1943 void silc_server_relay_packet(SilcServer server,
1944 SilcSocketConnection dst_sock,
1947 SilcUInt32 sequence,
1948 SilcPacketContext *packet,
1951 const SilcBufferStruct p;
1953 silc_buffer_push(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1954 + packet->dst_id_len + packet->padlen);
1955 if (!silc_packet_send_prepare(dst_sock, 0, 0, packet->buffer->len, hmac,
1956 (const SilcBuffer)&p)) {
1957 SILC_LOG_ERROR(("Cannot send packet"));
1960 silc_buffer_put((SilcBuffer)&p, packet->buffer->data, packet->buffer->len);
1962 /* Re-encrypt packet */
1963 silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&p, p.len);
1965 /* Send the packet */
1966 silc_server_packet_send_real(server, dst_sock, force_send);
1968 silc_buffer_pull(packet->buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1969 + packet->dst_id_len + packet->padlen);
1971 /* Check for mandatory rekey */
1972 if (sequence == SILC_SERVER_REKEY_THRESHOLD)
1973 silc_schedule_task_add(server->schedule, dst_sock->sock,
1974 silc_server_rekey_callback, dst_sock, 0, 1,
1975 SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
1978 /* Routine used to send the connection authentication packet. */
1980 void silc_server_send_connection_auth_request(SilcServer server,
1981 SilcSocketConnection sock,
1982 SilcUInt16 conn_type,
1983 SilcAuthMethod auth_meth)
1987 packet = silc_buffer_alloc(4);
1988 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1989 silc_buffer_format(packet,
1990 SILC_STR_UI_SHORT(conn_type),
1991 SILC_STR_UI_SHORT(auth_meth),
1994 silc_server_packet_send(server, sock, SILC_PACKET_CONNECTION_AUTH_REQUEST,
1995 0, packet->data, packet->len, FALSE);
1996 silc_buffer_free(packet);
1999 /* Purge the outgoing packet queue to the network if there is data. This
2000 function can be used to empty the packet queue. It is guaranteed that
2001 after this function returns the outgoing data queue is empty. */
2003 void silc_server_packet_queue_purge(SilcServer server,
2004 SilcSocketConnection sock)
2006 if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
2007 (SILC_IS_DISCONNECTED(sock) == FALSE)) {
2008 SILC_LOG_DEBUG(("Purging ourgoing queue"));
2009 server->stat.packets_sent++;
2010 silc_packet_send(sock, TRUE);
2011 SILC_UNSET_OUTBUF_PENDING(sock);
2012 silc_buffer_clear(sock->outbuf);
2016 /* Send packet to clients that are known to be operators. If server
2017 is router and `route' is TRUE then the packet would go to all operators
2018 in the SILC network. If `route' is FALSE then only local operators
2019 (local for server and cell wide for router). If `local' is TRUE then
2020 only locally connected operators receive the packet. If `local' is
2021 TRUE then `route' is ignored. If server is normal server and `route'
2022 is FALSE it is equivalent to `local' being TRUE. */
2024 void silc_server_send_opers(SilcServer server,
2025 SilcPacketType type,
2026 SilcPacketFlags flags,
2027 bool route, bool local,
2028 unsigned char *data,
2029 SilcUInt32 data_len,
2032 SilcIDCacheList list = NULL;
2033 SilcIDCacheEntry id_cache = NULL;
2034 SilcClientEntry client = NULL;
2035 SilcSocketConnection sock;
2036 SilcServerEntry *routed = NULL;
2037 SilcUInt32 routed_count = 0;
2041 SILC_LOG_DEBUG(("Sending %s packet to operators",
2042 silc_get_packet_name(type)));
2044 /* If local was requested send only locally connected operators. */
2045 if (local || (server->server_type == SILC_SERVER && !route)) {
2046 if (!silc_idcache_get_all(server->local_list->clients, &list) ||
2047 !silc_idcache_list_first(list, &id_cache))
2050 client = (SilcClientEntry)id_cache->context;
2051 if (!client->router && SILC_IS_LOCAL(client) &&
2052 (client->mode & SILC_UMODE_SERVER_OPERATOR ||
2053 client->mode & SILC_UMODE_ROUTER_OPERATOR)) {
2055 /* Send the packet to locally connected operator */
2056 silc_server_packet_send_dest(server, client->connection, type, flags,
2057 client->id, SILC_ID_CLIENT,
2058 data, data_len, force_send);
2061 if (!silc_idcache_list_next(list, &id_cache))
2064 silc_idcache_list_free(list);
2068 if (!silc_idcache_get_all(server->local_list->clients, &list) ||
2069 !silc_idcache_list_first(list, &id_cache))
2072 client = (SilcClientEntry)id_cache->context;
2073 if (!(client->mode & SILC_UMODE_SERVER_OPERATOR) &&
2074 !(client->mode & SILC_UMODE_ROUTER_OPERATOR))
2077 if (server->server_type != SILC_SERVER && client->router &&
2078 ((!route && client->router->router == server->id_entry) || route)) {
2080 /* Check if we have sent the packet to this route already */
2081 for (k = 0; k < routed_count; k++)
2082 if (routed[k] == client->router)
2084 if (k < routed_count)
2087 /* Route only once to router */
2088 sock = (SilcSocketConnection)client->router->connection;
2089 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2095 /* Send the packet */
2096 silc_server_packet_send_dest(server, sock, type, flags,
2097 client->id, SILC_ID_CLIENT,
2098 data, data_len, force_send);
2100 /* Mark this route routed already */
2101 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
2102 routed[routed_count++] = client->router;
2106 if (client->router || !client->connection)
2109 /* Send to locally connected client */
2110 sock = (SilcSocketConnection)client->connection;
2111 silc_server_packet_send_dest(server, sock, type, flags,
2112 client->id, SILC_ID_CLIENT,
2113 data, data_len, force_send);
2116 if (!silc_idcache_list_next(list, &id_cache))
2119 silc_idcache_list_free(list);
2121 if (!silc_idcache_get_all(server->global_list->clients, &list) ||
2122 !silc_idcache_list_first(list, &id_cache))
2125 client = (SilcClientEntry)id_cache->context;
2126 if (!(client->mode & SILC_UMODE_SERVER_OPERATOR) &&
2127 !(client->mode & SILC_UMODE_ROUTER_OPERATOR))
2130 if (server->server_type != SILC_SERVER && client->router &&
2131 ((!route && client->router->router == server->id_entry) || route)) {
2133 /* Check if we have sent the packet to this route already */
2134 for (k = 0; k < routed_count; k++)
2135 if (routed[k] == client->router)
2137 if (k < routed_count)
2140 /* Route only once to router */
2141 sock = (SilcSocketConnection)client->router->connection;
2142 if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2148 /* Send the packet */
2149 silc_server_packet_send_dest(server, sock, type, flags,
2150 client->id, SILC_ID_CLIENT,
2151 data, data_len, force_send);
2153 /* Mark this route routed already */
2154 routed = silc_realloc(routed, sizeof(*routed) * (routed_count + 1));
2155 routed[routed_count++] = client->router;
2159 if (client->router || !client->connection)
2162 /* Send to locally connected client */
2163 sock = (SilcSocketConnection)client->connection;
2164 silc_server_packet_send_dest(server, sock, type, flags,
2165 client->id, SILC_ID_CLIENT,
2166 data, data_len, force_send);
2169 if (!silc_idcache_list_next(list, &id_cache))
2172 silc_idcache_list_free(list);
2176 /* Send a notify packet to operators */
2178 void silc_server_send_opers_notify(SilcServer server,
2181 SilcNotifyType type,
2182 SilcUInt32 argc, ...)
2188 packet = silc_notify_payload_encode(type, argc, ap);
2189 silc_server_send_opers(server, SILC_PACKET_NOTIFY, 0,
2190 route, local, packet->data, packet->len,
2192 silc_buffer_free(packet);