1 /* Copyright (C) 2009-2011, Martin Johansson <martin@fatbob.nu>
2 Copyright (C) 2005-2011, Thorvald Natvig <thorvald@natvig.com>
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions
10 - Redistributions of source code must retain the above copyright notice,
11 this list of conditions and the following disclaimer.
12 - Redistributions in binary form must reproduce the above copyright notice,
13 this list of conditions and the following disclaimer in the documentation
14 and/or other materials provided with the distribution.
15 - Neither the name of the Developers nor the names of its contributors may
16 be used to endorse or promote products derived from this software without
17 specific prior written permission.
19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
23 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 #include <sys/socket.h>
43 #include "messagehandler.h"
47 #include "voicetarget.h"
49 extern char system_string[], version_string[];
51 static int Client_read(client_t *client);
52 static int Client_write(client_t *client);
53 static int Client_send_udp(client_t *client, uint8_t *data, int len);
54 void Client_free(client_t *client);
56 declare_list(clients);
57 static int clientcount; /* = 0 */
58 static int maxBandwidth;
60 int iCodecAlpha, iCodecBeta;
67 maxBandwidth = getIntConf(MAX_BANDWIDTH) / 8; /* From bits/s -> bytes/s */
75 int Client_getfds(struct pollfd *pollfds)
79 list_iterate(itr, &clients) {
81 c = list_get_entry(itr, client_t, node);
82 pollfds[i].fd = c->tcpfd;
83 pollfds[i].events = POLLIN | POLLHUP | POLLERR;
84 if (c->txsize > 0 || c->readBlockedOnWrite) /* Data waiting to be sent? */
85 pollfds[i].events |= POLLOUT;
94 int bwTop = maxBandwidth + maxBandwidth / 4;
95 list_iterate(itr, &clients) {
97 c = list_get_entry(itr, client_t, node);
98 Log_debug("Client %s BW available %d", c->username, c->availableBandwidth);
99 c->availableBandwidth += maxBandwidth;
100 if (c->availableBandwidth > bwTop)
101 c->availableBandwidth = bwTop;
103 if (Timer_isElapsed(&c->lastActivity, 1000000LL * INACTICITY_TIMEOUT)) {
104 /* No activity from client - assume it is lost and close. */
105 Log_info_client(c, "Timeout, closing.");
111 void Client_codec_add(client_t *client, int codec)
113 codec_t *cd = malloc(sizeof(codec_t));
115 Log_fatal("Out of memory");
116 init_list_entry(&cd->node);
118 list_add_tail(&cd->node, &client->codecs);
121 void Client_codec_free(client_t *client)
123 struct dlist *itr, *save;
124 list_iterate_safe(itr, save, &client->codecs) {
125 list_del(&list_get_entry(itr, codec_t, node)->node);
126 free(list_get_entry(itr, codec_t, node));
130 codec_t *Client_codec_iterate(client_t *client, codec_t **codec_itr)
132 codec_t *cd = *codec_itr;
134 if (list_empty(&client->codecs))
138 cd = list_get_entry(list_get_first(&client->codecs), codec_t, node);
140 if (list_get_next(&cd->node) == &client->codecs)
143 cd = list_get_entry(list_get_next(&cd->node), codec_t, node);
149 void Client_token_add(client_t *client, char *token_string)
153 if (client->tokencount >= MAX_TOKENS)
155 token = malloc(sizeof(token_t));
157 Log_fatal("Out of memory");
158 init_list_entry(&token->node);
159 token->token = strdup(token_string);
160 if (token->token == NULL)
161 Log_fatal("Out of memory");
162 list_add_tail(&token->node, &client->tokens);
163 client->tokencount++;
166 bool_t Client_token_match(client_t *client, char *str)
171 if (list_empty(&client->tokens))
173 list_iterate(itr, &client->tokens) {
174 token = list_get_entry(itr, token_t, node);
175 if (strncasecmp(token->token, str, MAX_TOKENSIZE) == 0)
181 void Client_token_free(client_t *client)
183 struct dlist *itr, *save;
186 list_iterate_safe(itr, save, &client->tokens) {
187 token = list_get_entry(itr, token_t, node);
188 list_del(&token->node);
192 client->tokencount = 0;
195 void recheckCodecVersions()
197 client_t *client_itr = NULL;
198 int max = 0, version, current_version;
200 struct dlist codec_list, *itr, *save;
201 codec_t *codec_itr, *cd;
204 init_list_entry(&codec_list);
206 while (Client_iterate(&client_itr) != NULL) {
208 while (Client_codec_iterate(client_itr, &codec_itr) != NULL) {
210 list_iterate(itr, &codec_list) {
211 cd = list_get_entry(itr, codec_t, node);
212 if (cd->codec == codec_itr->codec) {
218 cd = malloc(sizeof(codec_t));
220 Log_fatal("Out of memory");
221 memset(cd, 0, sizeof(codec_t));
222 init_list_entry(&cd->node);
223 cd->codec = codec_itr->codec;
225 list_add_tail(&cd->node, &codec_list);
230 list_iterate(itr, &codec_list) {
231 cd = list_get_entry(itr, codec_t, node);
232 if (cd->count > max) {
237 list_iterate_safe(itr, save, &codec_list) {
238 list_del(&list_get_entry(itr, codec_t, node)->node);
239 free(list_get_entry(itr, codec_t, node));
242 current_version = bPreferAlpha ? iCodecAlpha : iCodecBeta;
243 if (current_version == version)
245 // If we don't already use the compat bitstream version set
246 // it as alpha and announce it. If another codec now got the
247 // majority set it as the opposite of the currently valid bPreferAlpha
249 if (version == (uint32_t)0x8000000b)
252 bPreferAlpha = ! bPreferAlpha;
255 iCodecAlpha = version;
257 iCodecBeta = version;
259 sendmsg = Msg_create(CodecVersion);
260 sendmsg->payload.codecVersion->alpha = iCodecAlpha;
261 sendmsg->payload.codecVersion->beta = iCodecBeta;
262 sendmsg->payload.codecVersion->prefer_alpha = bPreferAlpha;
263 Client_send_message_except(NULL, sendmsg);
265 Log_info("CELT codec switch 0x%x 0x%x (prefer 0x%x)", iCodecAlpha, iCodecBeta,
266 bPreferAlpha ? iCodecAlpha : iCodecBeta);
270 static int findFreeSessionId()
273 client_t *itr = NULL;
275 for (id = 1; id < INT_MAX; id++) {
277 while ((itr = Client_iterate(&itr)) != NULL) {
278 if (itr->sessionId == id)
281 if (itr == NULL) /* Found free id */
287 int Client_add(int fd, struct sockaddr_in *remote)
292 newclient = malloc(sizeof(client_t));
293 if (newclient == NULL)
294 Log_fatal("Out of memory");
295 memset(newclient, 0, sizeof(client_t));
297 newclient->tcpfd = fd;
298 memcpy(&newclient->remote_tcp, remote, sizeof(struct sockaddr_in));
299 newclient->ssl = SSLi_newconnection(&newclient->tcpfd, &newclient->SSLready);
300 if (newclient->ssl == NULL) {
301 Log_warn("SSL negotiation failed with %s:%d", inet_ntoa(remote->sin_addr),
302 ntohs(remote->sin_port));
306 newclient->availableBandwidth = maxBandwidth;
307 Timer_init(&newclient->lastActivity);
308 Timer_init(&newclient->connectTime);
309 Timer_init(&newclient->idleTime);
310 newclient->sessionId = findFreeSessionId();
311 if (newclient->sessionId < 0)
312 Log_fatal("Could not find a free session ID");
314 init_list_entry(&newclient->txMsgQueue);
315 init_list_entry(&newclient->chan_node);
316 init_list_entry(&newclient->node);
317 init_list_entry(&newclient->voicetargets);
318 init_list_entry(&newclient->codecs);
319 init_list_entry(&newclient->tokens);
321 list_add_tail(&newclient->node, &clients);
324 /* Send version message to client */
325 sendmsg = Msg_create(Version);
326 sendmsg->payload.version->has_version = true;
327 sendmsg->payload.version->version = PROTOCOL_VERSION;
328 sendmsg->payload.version->release = strdup(UMURMUR_VERSION);
329 sendmsg->payload.version->os = strdup(system_string);
330 sendmsg->payload.version->os_version = strdup(version_string);
331 Client_send_message(newclient, sendmsg);
336 void Client_free(client_t *client)
338 struct dlist *itr, *save;
341 if (client->authenticated) {
343 leave_id = Chan_userLeave(client);
344 if (leave_id > 0) { /* Remove temp channel */
345 sendmsg = Msg_create(ChannelRemove);
346 sendmsg->payload.channelRemove->channel_id = leave_id;
347 Client_send_message_except(client, sendmsg);
349 sendmsg = Msg_create(UserRemove);
350 sendmsg->payload.userRemove->session = client->sessionId;
351 Client_send_message_except(client, sendmsg);
353 list_iterate_safe(itr, save, &client->txMsgQueue) {
354 list_del(&list_get_entry(itr, message_t, node)->node);
355 Msg_free(list_get_entry(itr, message_t, node));
357 Client_codec_free(client);
358 Voicetarget_free_all(client);
359 Client_token_free(client);
361 list_del(&client->node);
363 SSLi_free(client->ssl);
364 close(client->tcpfd);
367 free(client->release);
370 if (client->os_version)
371 free(client->os_version);
372 if (client->username)
373 free(client->username);
375 free(client->context);
379 void Client_close(client_t *client)
381 SSLi_shutdown(client->ssl);
382 client->shutdown_wait = true;
385 void Client_disconnect_all()
387 struct dlist *itr, *save;
389 list_iterate_safe(itr, save, &clients) {
390 Client_free(list_get_entry(itr, client_t, node));
394 int Client_read_fd(int fd)
397 client_t *client = NULL;
399 list_iterate(itr, &clients) {
400 if (fd == list_get_entry(itr, client_t, node)->tcpfd) {
401 client = list_get_entry(itr, client_t, node);
406 return Client_read(client);
411 int Client_read(client_t *client)
415 Timer_restart(&client->lastActivity);
417 if (client->writeBlockedOnRead) {
418 client->writeBlockedOnRead = false;
419 Log_debug("Client_read: writeBlockedOnRead == true");
420 return Client_write(client);
423 if (client->shutdown_wait) {
427 if (!client->SSLready) {
429 rc = SSLi_nonblockaccept(client->ssl, &client->SSLready);
438 if (!client->msgsize)
439 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
441 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
444 client->rxcount += rc;
445 if (!client->msgsize && client->rxcount >= 6) {
447 memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
448 client->msgsize = ntohl(msgLen);
450 if (client->msgsize > BUFSIZE - 6) {
451 /* XXX - figure out how to handle this. A large size here can represent two cases:
452 * 1. A valid size. The only message that is this big is UserState message with a big texture
453 * 2. An invalid size = protocol error, e.g. connecting with a 1.1.x client
455 Log_warn("Too big message received (%d bytes). Playing safe and disconnecting client %s:%d",
456 client->msgsize, inet_ntoa(client->remote_tcp.sin_addr), ntohs(client->remote_tcp.sin_port));
459 /* client->rxcount = client->msgsize = 0; */
461 else if (client->rxcount == client->msgsize + 6) { /* Got all of the message */
462 msg = Msg_networkToMessage(client->rxbuf, client->msgsize + 6);
463 /* pass messsage to handler */
465 Mh_handle_message(client, msg);
466 client->rxcount = client->msgsize = 0;
468 } else /* rc <= 0 */ {
469 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
472 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
473 client->readBlockedOnWrite = true;
476 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_ZERO_RETURN) {
477 Log_info_client(client, "Connection closed by peer");
478 if (!client->shutdown_wait)
479 Client_close(client);
482 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
483 Log_info_client(client, "Connection closed by peer");
486 Log_info_client(client, "SSL error: %d - Closing connection", SSLi_get_error(client->ssl, rc));
492 } while (SSLi_data_pending(client->ssl));
497 int Client_write_fd(int fd)
500 client_t *client = NULL;
502 list_iterate(itr, &clients) {
503 if(fd == list_get_entry(itr, client_t, node)->tcpfd) {
504 client = list_get_entry(itr, client_t, node);
509 return Client_write(client);
514 int Client_write(client_t *client)
518 if (client->readBlockedOnWrite) {
519 client->readBlockedOnWrite = false;
520 Log_debug("Client_write: readBlockedOnWrite == true");
521 return Client_read(client);
523 rc = SSLi_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
525 client->txcount += rc;
526 if (client->txcount == client->txsize)
527 client->txsize = client->txcount = 0;
530 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
531 client->writeBlockedOnRead = true;
534 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
538 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL)
539 Log_warn("Client_write: Error: %s - Closing connection", strerror(errno));
541 Log_warn("Client_write: SSL error: %d - Closing connection.", SSLi_get_error(client->ssl, rc));
546 if (client->txsize == 0 && !list_empty(&client->txMsgQueue)) {
548 msg = list_get_entry(list_get_first(&client->txMsgQueue), message_t, node);
549 list_del(list_get_first(&client->txMsgQueue));
550 client->txQueueCount--;
551 Client_send_message(client, msg);
556 int Client_send_message_ver(client_t *client, message_t *msg, uint32_t version)
558 if ((version == 0) || (client->version >= version) ||
559 ((version & 0x80000000) && (client->version < (~version))))
560 return Client_send_message(client, msg);
565 int Client_send_message(client_t *client, message_t *msg)
567 if (!client->authenticated && msg->messageType != Version) {
571 if (client->txsize != 0 || !client->SSLready) {
573 if ((client->txQueueCount > 5 && msg->messageType == UDPTunnel) ||
574 client->txQueueCount > 30) {
578 client->txQueueCount++;
579 list_add_tail(&msg->node, &client->txMsgQueue);
580 Log_debug("Queueing message");
583 len = Msg_messageToNetwork(msg, client->txbuf);
584 doAssert(len < BUFSIZE);
586 client->txsize = len;
588 Client_write(client);
594 client_t *Client_iterate(client_t **client_itr)
596 client_t *c = *client_itr;
598 if (list_empty(&clients))
602 c = list_get_entry(list_get_first(&clients), client_t, node);
604 if (list_get_next(&c->node) == &clients)
607 c = list_get_entry(list_get_next(&c->node), client_t, node);
614 int Client_send_message_except(client_t *client, message_t *msg)
616 client_t *itr = NULL;
619 Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
620 while (Client_iterate(&itr) != NULL) {
623 Msg_inc_ref(msg); /* One extra reference for each new copy */
624 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
625 Client_send_message(itr, msg);
628 Msg_free(msg); /* Free our reference to the message */
631 Msg_free(msg); /* If only 1 client is connected then no message is passed
632 * to Client_send_message(). Free it here. */
637 int Client_send_message_except_ver(client_t *client, message_t *msg, uint32_t version)
639 client_t *itr = NULL;
642 Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
643 while (Client_iterate(&itr) != NULL) {
646 Msg_inc_ref(msg); /* One extra reference for each new copy */
647 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
648 Client_send_message_ver(itr, msg, version);
651 Msg_free(msg); /* Free our reference to the message */
654 Msg_free(msg); /* If only 1 client is connected then no message is passed
655 * to Client_send_message(). Free it here. */
660 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
662 if (CryptState_isValid(&client->cryptState) &&
663 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
666 if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
667 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
669 Timer_restart(&client->cryptState.tLastRequest);
671 sendmsg = Msg_create(CryptSetup);
672 Log_info_client(client, "Requesting voice channel crypt resync");
673 Client_send_message(client, sendmsg);
679 #define UDP_PACKET_SIZE 1024
680 int Client_read_udp()
683 struct sockaddr_in from;
684 socklen_t fromlen = sizeof(struct sockaddr_in);
687 UDPMessageType_t msgType;
689 #if defined(__LP64__)
690 uint8_t encbuff[UDP_PACKET_SIZE + 8];
691 uint8_t *encrypted = encbuff + 4;
693 uint8_t encrypted[UDP_PACKET_SIZE];
695 uint8_t buffer[UDP_PACKET_SIZE];
697 len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
700 } else if (len < 0) {
702 } else if (len < 5) {
703 // 4 bytes crypt header + type + session
705 } else if (len > UDP_PACKET_SIZE) {
710 if (len == 12 && *encrypted == 0) {
711 uint32_t *ping = (uint32_t *)encrypted;
712 ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
713 // 1 and 2 will be the timestamp, which we return unmodified.
714 ping[3] = htonl((uint32_t)clientcount);
715 ping[4] = htonl((uint32_t)getIntConf(MAX_CLIENTS));
716 ping[5] = htonl((uint32_t)getIntConf(MAX_BANDWIDTH));
718 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
722 key = (((uint64_t)from.sin_addr.s_addr) << 16) ^ from.sin_port;
725 while (Client_iterate(&itr) != NULL) {
726 if (itr->key == key) {
727 if (!checkDecrypt(itr, encrypted, buffer, len))
732 if (itr == NULL) { /* Unknown peer */
733 while (Client_iterate(&itr) != NULL) {
734 if (itr->remote_tcp.sin_addr.s_addr == from.sin_addr.s_addr) {
735 if (checkDecrypt(itr, encrypted, buffer, len)) {
737 Log_info_client(itr, "New UDP connection port %d", ntohs(from.sin_port));
738 memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_in));
744 if (itr == NULL) { /* Couldn't find this peer among connected clients */
749 len -= 4; /* Adjust for crypt header */
750 msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
753 case UDPVoiceCELTAlpha:
754 case UDPVoiceCELTBeta:
755 Client_voiceMsg(itr, buffer, len);
758 Log_debug("UDP Ping reply len %d", len);
759 Client_send_udp(itr, buffer, len);
762 Log_debug("Unknown UDP message type from %s port %d", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
770 static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
772 if (IS_AUTH(dst) && dst != src && !dst->deaf) {
773 if (poslen > 0 && /* Has positional data */
774 src->context != NULL && dst->context != NULL && /* ...both source and destination has context */
775 strcmp(src->context, dst->context) == 0) /* ...and the contexts match */
776 Client_send_udp(dst, data, len);
778 Client_send_udp(dst, data, len - poslen);
782 /* Handle decrypted voice message */
783 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
785 uint8_t buffer[UDP_PACKET_SIZE];
786 pds_t *pdi = Pds_create(data + 1, len - 1);
787 pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
788 unsigned int type = data[0] & 0xe0;
789 unsigned int target = data[0] & 0x1f;
790 unsigned int poslen, counter;
791 int offset, packetsize;
794 channel_t *ch = (channel_t *)client->channel;
797 if (!client->authenticated || client->mute)
800 packetsize = 20 + 8 + 4 + len;
801 if (client->availableBandwidth - packetsize < 0)
802 goto out; /* Discard */
803 client->availableBandwidth -= packetsize;
805 Timer_restart(&client->idleTime);
807 counter = Pds_get_numval(pdi); /* step past session id */
809 counter = Pds_next8(pdi);
810 offset = Pds_skip(pdi, counter & 0x7f);
811 } while ((counter & 0x80) && offset > 0);
813 poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
815 Pds_add_numval(pds, client->sessionId);
816 Pds_append_data_nosize(pds, data + 1, len - 1);
818 if (target == 0x1f) { /* Loopback */
819 buffer[0] = (uint8_t) type;
820 Client_send_udp(client, buffer, pds->offset + 1);
822 else if (target == 0) { /* regular channel speech */
823 buffer[0] = (uint8_t) type;
828 list_iterate(itr, &ch->clients) {
830 c = list_get_entry(itr, client_t, chan_node);
831 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
833 } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
837 for (i = 0; i < TARGET_MAX_CHANNELS && vt->channels[i].channel != -1; i++) {
838 buffer[0] = (uint8_t) (type | 1);
839 Log_debug("Whisper channel %d", vt->channels[i]);
840 ch = Chan_fromId(vt->channels[i].channel);
843 list_iterate(itr, &ch->clients) {
845 c = list_get_entry(itr, client_t, chan_node);
846 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
849 if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
850 struct dlist *ch_itr;
851 list_iterate(ch_itr, &ch->channel_links) {
853 ch_link = list_get_entry(ch_itr, channel_t, link_node);
854 list_iterate(itr, &ch_link->clients) {
856 c = list_get_entry(itr, client_t, chan_node);
857 Log_debug("Linked voice from %s -> %s", ch->name, ch_link->name);
858 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
863 if (vt->channels[i].children) {
864 struct dlist chanlist, *ch_itr;
865 init_list_entry(&chanlist);
866 Chan_buildTreeList(ch, &chanlist);
867 list_iterate(ch_itr, &chanlist) {
869 sub = list_get_entry(ch_itr, channellist_t, node)->chan;
870 list_iterate(itr, &sub->clients) {
872 c = list_get_entry(itr, client_t, chan_node);
873 Log_debug("Child voice from %s -> %s", ch->name, sub->name);
874 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
877 Chan_freeTreeList(&chanlist);
881 for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
883 buffer[0] = (uint8_t) (type | 2);
884 Log_debug("Whisper session %d", vt->sessions[i]);
885 while (Client_iterate(&c) != NULL) {
886 if (c->sessionId == vt->sessions[i]) {
887 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
901 static int Client_send_udp(client_t *client, uint8_t *data, int len)
905 if (client->remote_udp.sin_port != 0 && CryptState_isValid(&client->cryptState) &&
907 #if defined(__LP64__)
908 buf = mbuf = malloc(len + 4 + 16);
911 mbuf = buf = malloc(len + 4);
914 Log_fatal("Out of memory");
916 CryptState_encrypt(&client->cryptState, data, buf, len);
918 sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, sizeof(struct sockaddr_in));
923 msg = Msg_CreateVoiceMsg(data, len);
924 Client_send_message(client, msg);