1 /* Copyright (C) 2009-2012, Martin Johansson <martin@fatbob.nu>
2 Copyright (C) 2005-2012, 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"
50 extern char system_string[], version_string[];
52 static int Client_read(client_t *client);
53 static int Client_write(client_t *client);
54 static int Client_send_udp(client_t *client, uint8_t *data, int len);
55 void Client_free(client_t *client);
57 declare_list(clients);
58 static int clientcount; /* = 0 */
59 static int maxBandwidth;
62 int iCodecAlpha, iCodecBeta;
69 maxBandwidth = getIntConf(MAX_BANDWIDTH) / 8; /* From bits/s -> bytes/s */
77 int Client_getfds(struct pollfd *pollfds)
81 list_iterate(itr, &clients) {
83 c = list_get_entry(itr, client_t, node);
84 pollfds[i].fd = c->tcpfd;
85 pollfds[i].events = POLLIN | POLLHUP | POLLERR;
86 if (c->txsize > 0 || c->readBlockedOnWrite) /* Data waiting to be sent? */
87 pollfds[i].events |= POLLOUT;
95 struct dlist *itr, *save;
96 int bwTop = maxBandwidth + maxBandwidth / 4;
97 list_iterate_safe(itr, save, &clients) {
99 c = list_get_entry(itr, client_t, node);
100 Log_debug("Client %s BW available %d", c->username, c->availableBandwidth);
101 c->availableBandwidth += maxBandwidth;
102 if (c->availableBandwidth > bwTop)
103 c->availableBandwidth = bwTop;
105 if (Timer_isElapsed(&c->lastActivity, 1000000LL * INACTIVITY_TIMEOUT)) {
106 /* No activity from client - assume it is lost and close. */
107 Log_info_client(c, "Timeout, closing.");
114 void Client_codec_add(client_t *client, int codec)
116 codec_t *cd = malloc(sizeof(codec_t));
118 Log_fatal("Out of memory");
119 init_list_entry(&cd->node);
121 list_add_tail(&cd->node, &client->codecs);
124 void Client_codec_free(client_t *client)
126 struct dlist *itr, *save;
127 list_iterate_safe(itr, save, &client->codecs) {
128 list_del(&list_get_entry(itr, codec_t, node)->node);
129 free(list_get_entry(itr, codec_t, node));
133 codec_t *Client_codec_iterate(client_t *client, codec_t **codec_itr)
135 codec_t *cd = *codec_itr;
137 if (list_empty(&client->codecs))
141 cd = list_get_entry(list_get_first(&client->codecs), codec_t, node);
143 if (list_get_next(&cd->node) == &client->codecs)
146 cd = list_get_entry(list_get_next(&cd->node), codec_t, node);
152 void Client_token_add(client_t *client, char *token_string)
156 if (client->tokencount >= MAX_TOKENS)
158 token = malloc(sizeof(token_t));
160 Log_fatal("Out of memory");
161 init_list_entry(&token->node);
162 token->token = strdup(token_string);
163 if (token->token == NULL)
164 Log_fatal("Out of memory");
165 list_add_tail(&token->node, &client->tokens);
166 client->tokencount++;
169 bool_t Client_token_match(client_t *client, char *str)
174 if (list_empty(&client->tokens))
176 list_iterate(itr, &client->tokens) {
177 token = list_get_entry(itr, token_t, node);
178 if (strncasecmp(token->token, str, MAX_TOKENSIZE) == 0)
184 void Client_token_free(client_t *client)
186 struct dlist *itr, *save;
189 list_iterate_safe(itr, save, &client->tokens) {
190 token = list_get_entry(itr, token_t, node);
191 list_del(&token->node);
195 client->tokencount = 0;
199 #define OPUS_WARN_USING "<strong>WARNING:</strong> Your client doesn't support the Opus codec the server is using, you won't be able to talk or hear anyone. Please upgrade your Mumble client."
200 #define OPUS_WARN_SWITCHING "<strong>WARNING:</strong> Your client doesn't support the Opus codec the server is switching to, you won't be able to talk or hear anyone. Please upgrade your Mumble client."
201 void recheckCodecVersions(client_t *connectingClient)
203 client_t *client_itr = NULL;
204 int max = 0, version, current_version;
205 int users = 0, opus = 0;
207 struct dlist codec_list, *itr, *save;
208 codec_t *codec_itr, *cd;
212 init_list_entry(&codec_list);
214 while (Client_iterate(&client_itr) != NULL) {
216 if (client_itr->codec_count == 0 && !client_itr->bOpus)
218 while (Client_codec_iterate(client_itr, &codec_itr) != NULL) {
220 list_iterate(itr, &codec_list) {
221 cd = list_get_entry(itr, codec_t, node);
222 if (cd->codec == codec_itr->codec) {
228 cd = malloc(sizeof(codec_t));
230 Log_fatal("Out of memory");
231 memset(cd, 0, sizeof(codec_t));
232 init_list_entry(&cd->node);
233 cd->codec = codec_itr->codec;
235 list_add_tail(&cd->node, &codec_list);
239 if (client_itr->bOpus)
245 enableOpus = ((opus * 100 / users) >= getIntConf(OPUS_THRESHOLD));
247 list_iterate(itr, &codec_list) {
248 cd = list_get_entry(itr, codec_t, node);
249 if (cd->count > max) {
254 list_iterate_safe(itr, save, &codec_list) {
255 list_del(&list_get_entry(itr, codec_t, node)->node);
256 free(list_get_entry(itr, codec_t, node));
259 current_version = bPreferAlpha ? iCodecAlpha : iCodecBeta;
260 if (current_version != version) {
261 // If we don't already use the compat bitstream version set
262 // it as alpha and announce it. If another codec now got the
263 // majority set it as the opposite of the currently valid bPreferAlpha
265 if (version == (uint32_t)0x8000000b)
268 bPreferAlpha = !bPreferAlpha;
271 iCodecAlpha = version;
273 iCodecBeta = version;
274 } else if (bOpus && enableOpus) {
275 if (connectingClient && !connectingClient->bOpus)
276 Client_textmessage(connectingClient, OPUS_WARN_USING);
280 sendmsg = Msg_create(CodecVersion);
281 sendmsg->payload.codecVersion->alpha = iCodecAlpha;
282 sendmsg->payload.codecVersion->beta = iCodecBeta;
283 sendmsg->payload.codecVersion->prefer_alpha = bPreferAlpha;
284 sendmsg->payload.codecVersion->has_opus = true;
285 sendmsg->payload.codecVersion->opus = enableOpus;
287 Client_send_message_except(NULL, sendmsg);
289 Log_info("CELT codec switch 0x%x 0x%x (prefer 0x%x)", iCodecAlpha, iCodecBeta,
290 bPreferAlpha ? iCodecAlpha : iCodecBeta);
292 if (enableOpus && !bOpus) {
294 while (Client_iterate(&client_itr) != NULL) {
295 if ((client_itr->authenticated || client_itr == connectingClient) &&
296 !client_itr->bOpus) {
297 Client_textmessage(client_itr, OPUS_WARN_SWITCHING);
303 Log_info("OPUS codec is %s", bOpus ? "enabled" : "disabled");
306 static int findFreeSessionId()
309 client_t *itr = NULL;
311 for (id = 1; id < INT_MAX; id++) {
313 while ((itr = Client_iterate(&itr)) != NULL) {
314 if (itr->sessionId == id)
317 if (itr == NULL) /* Found free id */
323 int Client_add(int fd, struct sockaddr_in *remote)
328 if (Ban_isBannedAddr((in_addr_t *)&remote->sin_addr)) {
329 Log_info("Address %s banned. Disconnecting", inet_ntoa(remote->sin_addr));
332 newclient = malloc(sizeof(client_t));
333 if (newclient == NULL)
334 Log_fatal("Out of memory");
335 memset(newclient, 0, sizeof(client_t));
337 newclient->tcpfd = fd;
338 memcpy(&newclient->remote_tcp, remote, sizeof(struct sockaddr_in));
339 newclient->ssl = SSLi_newconnection(&newclient->tcpfd, &newclient->SSLready);
340 if (newclient->ssl == NULL) {
341 Log_warn("SSL negotiation failed with %s:%d", inet_ntoa(remote->sin_addr),
342 ntohs(remote->sin_port));
346 newclient->availableBandwidth = maxBandwidth;
347 Timer_init(&newclient->lastActivity);
348 Timer_init(&newclient->connectTime);
349 Timer_init(&newclient->idleTime);
350 newclient->sessionId = findFreeSessionId();
351 if (newclient->sessionId < 0)
352 Log_fatal("Could not find a free session ID");
354 init_list_entry(&newclient->txMsgQueue);
355 init_list_entry(&newclient->chan_node);
356 init_list_entry(&newclient->node);
357 init_list_entry(&newclient->voicetargets);
358 init_list_entry(&newclient->codecs);
359 init_list_entry(&newclient->tokens);
361 list_add_tail(&newclient->node, &clients);
364 /* Send version message to client */
365 sendmsg = Msg_create(Version);
366 sendmsg->payload.version->has_version = true;
367 sendmsg->payload.version->version = PROTOCOL_VERSION;
368 sendmsg->payload.version->release = strdup(UMURMUR_VERSION);
369 sendmsg->payload.version->os = strdup(system_string);
370 sendmsg->payload.version->os_version = strdup(version_string);
371 Client_send_message(newclient, sendmsg);
376 void Client_free(client_t *client)
378 struct dlist *itr, *save;
380 bool_t authenticatedLeft = client->authenticated;
382 if (client->authenticated) {
384 leave_id = Chan_userLeave(client);
385 if (leave_id > 0) { /* Remove temp channel */
386 sendmsg = Msg_create(ChannelRemove);
387 sendmsg->payload.channelRemove->channel_id = leave_id;
388 Client_send_message_except(client, sendmsg);
390 sendmsg = Msg_create(UserRemove);
391 sendmsg->payload.userRemove->session = client->sessionId;
392 Client_send_message_except(client, sendmsg);
394 list_iterate_safe(itr, save, &client->txMsgQueue) {
395 list_del(&list_get_entry(itr, message_t, node)->node);
396 Msg_free(list_get_entry(itr, message_t, node));
398 Client_codec_free(client);
399 Voicetarget_free_all(client);
400 Client_token_free(client);
402 list_del(&client->node);
404 SSLi_free(client->ssl);
405 close(client->tcpfd);
408 free(client->release);
411 if (client->os_version)
412 free(client->os_version);
413 if (client->username)
414 free(client->username);
416 free(client->context);
419 if (authenticatedLeft)
420 recheckCodecVersions(NULL); /* Can use better codec now? */
423 void Client_close(client_t *client)
425 SSLi_shutdown(client->ssl);
426 client->shutdown_wait = true;
429 void Client_disconnect_all()
431 struct dlist *itr, *save;
433 list_iterate_safe(itr, save, &clients) {
434 Client_free(list_get_entry(itr, client_t, node));
438 int Client_read_fd(int fd)
441 client_t *client = NULL;
443 list_iterate(itr, &clients) {
444 if (fd == list_get_entry(itr, client_t, node)->tcpfd) {
445 client = list_get_entry(itr, client_t, node);
450 return Client_read(client);
455 int Client_read(client_t *client)
459 Timer_restart(&client->lastActivity);
461 if (client->writeBlockedOnRead) {
462 client->writeBlockedOnRead = false;
463 Log_debug("Client_read: writeBlockedOnRead == true");
464 return Client_write(client);
467 if (client->shutdown_wait) {
471 if (!client->SSLready) {
473 rc = SSLi_nonblockaccept(client->ssl, &client->SSLready);
482 if (!client->msgsize)
483 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
485 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
488 client->rxcount += rc;
489 if (!client->msgsize && client->rxcount >= 6) {
491 memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
492 client->msgsize = ntohl(msgLen);
494 if (client->msgsize > BUFSIZE - 6) {
495 /* XXX - figure out how to handle this. A large size here can represent two cases:
496 * 1. A valid size. The only message that is this big is UserState message with a big texture
497 * 2. An invalid size = protocol error, e.g. connecting with a 1.1.x client
499 Log_warn("Too big message received (%d bytes). Playing safe and disconnecting client %s:%d",
500 client->msgsize, inet_ntoa(client->remote_tcp.sin_addr), ntohs(client->remote_tcp.sin_port));
503 /* client->rxcount = client->msgsize = 0; */
505 else if (client->rxcount == client->msgsize + 6) { /* Got all of the message */
506 msg = Msg_networkToMessage(client->rxbuf, client->msgsize + 6);
507 /* pass messsage to handler */
509 Mh_handle_message(client, msg);
510 client->rxcount = client->msgsize = 0;
512 } else /* rc <= 0 */ {
513 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
516 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
517 client->readBlockedOnWrite = true;
520 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_ZERO_RETURN ||
521 SSLi_get_error(client->ssl, rc) == 0) {
522 Log_info_client(client, "Connection closed by peer");
523 Client_close(client);
526 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
528 Log_info_client(client, "Connection closed by peer");
530 Log_info_client(client,"Error: %s - Closing connection (code %d)",
533 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
534 Log_info_client(client, "Connection reset by peer");
537 Log_info_client(client, "SSL error: %d - Closing connection", SSLi_get_error(client->ssl, rc));
543 } while (SSLi_data_pending(client->ssl));
548 int Client_write_fd(int fd)
551 client_t *client = NULL;
553 list_iterate(itr, &clients) {
554 if(fd == list_get_entry(itr, client_t, node)->tcpfd) {
555 client = list_get_entry(itr, client_t, node);
560 return Client_write(client);
565 int Client_write(client_t *client)
569 if (client->readBlockedOnWrite) {
570 client->readBlockedOnWrite = false;
571 Log_debug("Client_write: readBlockedOnWrite == true");
572 return Client_read(client);
574 rc = SSLi_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
576 client->txcount += rc;
577 if (client->txcount == client->txsize)
578 client->txsize = client->txcount = 0;
581 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
582 client->writeBlockedOnRead = true;
585 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
589 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
590 Log_info_client(client, "Error: %s - Closing connection", strerror(errno));
592 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
593 Log_info_client(client, "Connection reset by peer");
596 Log_info_client(client, "SSL error: %d - Closing connection.", SSLi_get_error(client->ssl, rc));
602 if (client->txsize == 0 && !list_empty(&client->txMsgQueue)) {
604 msg = list_get_entry(list_get_first(&client->txMsgQueue), message_t, node);
605 list_del(list_get_first(&client->txMsgQueue));
606 client->txQueueCount--;
607 Client_send_message(client, msg);
612 int Client_send_message_ver(client_t *client, message_t *msg, uint32_t version)
614 if ((version == 0) || (client->version >= version) ||
615 ((version & 0x80000000) && (client->version < (~version))))
616 return Client_send_message(client, msg);
621 int Client_send_message(client_t *client, message_t *msg)
623 if (!client->authenticated && msg->messageType != Version) {
627 if (client->txsize != 0 || !client->SSLready) {
629 if ((client->txQueueCount > 5 && msg->messageType == UDPTunnel) ||
630 client->txQueueCount > 30) {
634 client->txQueueCount++;
635 list_add_tail(&msg->node, &client->txMsgQueue);
636 Log_debug("Queueing message");
639 len = Msg_messageToNetwork(msg, client->txbuf);
640 doAssert(len < BUFSIZE);
642 client->txsize = len;
644 Client_write(client);
650 client_t *Client_iterate(client_t **client_itr)
652 client_t *c = *client_itr;
654 if (list_empty(&clients))
658 c = list_get_entry(list_get_first(&clients), client_t, node);
660 if (list_get_next(&c->node) == &clients)
663 c = list_get_entry(list_get_next(&c->node), client_t, node);
669 void Client_textmessage(client_t *client, char *text)
673 message_t *sendmsg = NULL;
675 message = malloc(strlen(text) + 1);
677 Log_fatal("Out of memory");
678 tree_id = malloc(sizeof(uint32_t));
680 Log_fatal("Out of memory");
682 sendmsg = Msg_create(TextMessage);
683 sendmsg->payload.textMessage->message = message;
684 sendmsg->payload.textMessage->n_tree_id = 1;
685 sendmsg->payload.textMessage->tree_id = tree_id;
686 strcpy(message, text);
687 Client_send_message(client, sendmsg);
691 int Client_send_message_except(client_t *client, message_t *msg)
693 client_t *itr = NULL;
696 Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
697 while (Client_iterate(&itr) != NULL) {
700 Msg_inc_ref(msg); /* One extra reference for each new copy */
701 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
702 Client_send_message(itr, msg);
705 Msg_free(msg); /* Free our reference to the message */
708 Msg_free(msg); /* If only 1 client is connected then no message is passed
709 * to Client_send_message(). Free it here. */
714 int Client_send_message_except_ver(client_t *client, message_t *msg, uint32_t version)
716 client_t *itr = NULL;
719 Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
720 while (Client_iterate(&itr) != NULL) {
723 Msg_inc_ref(msg); /* One extra reference for each new copy */
724 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
725 Client_send_message_ver(itr, msg, version);
728 Msg_free(msg); /* Free our reference to the message */
731 Msg_free(msg); /* If only 1 client is connected then no message is passed
732 * to Client_send_message(). Free it here. */
737 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
739 if (CryptState_isValid(&client->cryptState) &&
740 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
743 if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
744 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
746 Timer_restart(&client->cryptState.tLastRequest);
748 sendmsg = Msg_create(CryptSetup);
749 Log_info_client(client, "Requesting voice channel crypt resync");
750 Client_send_message(client, sendmsg);
756 #define UDP_PACKET_SIZE 1024
757 int Client_read_udp()
760 struct sockaddr_in from;
761 socklen_t fromlen = sizeof(struct sockaddr_in);
764 UDPMessageType_t msgType;
766 #if defined(__LP64__)
767 uint8_t encbuff[UDP_PACKET_SIZE + 8];
768 uint8_t *encrypted = encbuff + 4;
770 uint8_t encrypted[UDP_PACKET_SIZE];
772 uint8_t buffer[UDP_PACKET_SIZE];
774 len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
777 } else if (len < 0) {
779 } else if (len < 5) {
780 // 4 bytes crypt header + type + session
782 } else if (len > UDP_PACKET_SIZE) {
787 if (len == 12 && *encrypted == 0) {
788 uint32_t *ping = (uint32_t *)encrypted;
789 ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
790 // 1 and 2 will be the timestamp, which we return unmodified.
791 ping[3] = htonl((uint32_t)clientcount);
792 ping[4] = htonl((uint32_t)getIntConf(MAX_CLIENTS));
793 ping[5] = htonl((uint32_t)getIntConf(MAX_BANDWIDTH));
795 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
799 key = (((uint64_t)from.sin_addr.s_addr) << 16) ^ from.sin_port;
802 while (Client_iterate(&itr) != NULL) {
803 if (itr->key == key) {
804 if (!checkDecrypt(itr, encrypted, buffer, len))
809 if (itr == NULL) { /* Unknown peer */
810 while (Client_iterate(&itr) != NULL) {
811 if (itr->remote_tcp.sin_addr.s_addr == from.sin_addr.s_addr) {
812 if (checkDecrypt(itr, encrypted, buffer, len)) {
814 Log_info_client(itr, "New UDP connection port %d", ntohs(from.sin_port));
815 memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_in));
821 if (itr == NULL) { /* Couldn't find this peer among connected clients */
826 len -= 4; /* Adjust for crypt header */
827 msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
830 case UDPVoiceCELTAlpha:
831 case UDPVoiceCELTBeta:
835 Client_voiceMsg(itr, buffer, len);
838 Log_debug("UDP Ping reply len %d", len);
839 Client_send_udp(itr, buffer, len);
842 Log_debug("Unknown UDP message type from %s port %d", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
850 static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
852 if (IS_AUTH(dst) && dst != src && !dst->deaf && !dst->self_deaf) {
853 if (poslen > 0 && /* Has positional data */
854 src->context != NULL && dst->context != NULL && /* ...both source and destination has context */
855 strcmp(src->context, dst->context) == 0) /* ...and the contexts match */
856 Client_send_udp(dst, data, len);
858 Client_send_udp(dst, data, len - poslen);
862 /* Handle decrypted voice message */
863 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
865 uint8_t buffer[UDP_PACKET_SIZE];
866 pds_t *pdi = Pds_create(data + 1, len - 1);
867 pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
868 unsigned int type = data[0] & 0xe0;
869 unsigned int target = data[0] & 0x1f;
870 unsigned int poslen, counter, size;
871 int offset, packetsize;
874 channel_t *ch = (channel_t *)client->channel;
877 if (!client->authenticated || client->mute || client->self_mute)
880 packetsize = 20 + 8 + 4 + len;
881 if (client->availableBandwidth - packetsize < 0)
882 goto out; /* Discard */
883 client->availableBandwidth -= packetsize;
885 Timer_restart(&client->idleTime);
886 Timer_restart(&client->lastActivity);
888 if ((type >> 5) != UDPVoiceOpus) {
889 counter = Pds_get_numval(pdi); /* step past session id */
891 counter = Pds_next8(pdi);
892 offset = Pds_skip(pdi, counter & 0x7f);
893 } while ((counter & 0x80) && offset > 0);
895 size = Pds_get_numval(pdi);
896 Pds_skip(pdi, size & 0x1fff);
899 poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
901 Pds_add_numval(pds, client->sessionId);
902 Pds_append_data_nosize(pds, data + 1, len - 1);
904 if (target == 0x1f) { /* Loopback */
905 buffer[0] = (uint8_t) type;
906 Client_send_udp(client, buffer, pds->offset + 1);
908 else if (target == 0) { /* regular channel speech */
909 buffer[0] = (uint8_t) type;
914 list_iterate(itr, &ch->clients) {
916 c = list_get_entry(itr, client_t, chan_node);
917 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
919 } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
923 for (i = 0; i < TARGET_MAX_CHANNELS && vt->channels[i].channel != -1; i++) {
924 buffer[0] = (uint8_t) (type | 1);
925 Log_debug("Whisper channel %d", vt->channels[i]);
926 ch = Chan_fromId(vt->channels[i].channel);
929 list_iterate(itr, &ch->clients) {
931 c = list_get_entry(itr, client_t, chan_node);
932 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
935 if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
936 struct dlist *ch_itr;
937 list_iterate(ch_itr, &ch->channel_links) {
939 ch_link = list_get_entry(ch_itr, channel_t, link_node);
940 list_iterate(itr, &ch_link->clients) {
942 c = list_get_entry(itr, client_t, chan_node);
943 Log_debug("Linked voice from %s -> %s", ch->name, ch_link->name);
944 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
949 if (vt->channels[i].children) {
950 struct dlist chanlist, *ch_itr;
951 init_list_entry(&chanlist);
952 Chan_buildTreeList(ch, &chanlist);
953 list_iterate(ch_itr, &chanlist) {
955 sub = list_get_entry(ch_itr, channellist_t, node)->chan;
956 list_iterate(itr, &sub->clients) {
958 c = list_get_entry(itr, client_t, chan_node);
959 Log_debug("Child voice from %s -> %s", ch->name, sub->name);
960 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
963 Chan_freeTreeList(&chanlist);
967 for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
969 buffer[0] = (uint8_t) (type | 2);
970 Log_debug("Whisper session %d", vt->sessions[i]);
971 while (Client_iterate(&c) != NULL) {
972 if (c->sessionId == vt->sessions[i]) {
973 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
987 static int Client_send_udp(client_t *client, uint8_t *data, int len)
991 if (client->remote_udp.sin_port != 0 && CryptState_isValid(&client->cryptState) &&
993 #if defined(__LP64__)
994 buf = mbuf = malloc(len + 4 + 16);
997 mbuf = buf = malloc(len + 4);
1000 Log_fatal("Out of memory");
1002 CryptState_encrypt(&client->cryptState, data, buf, len);
1004 sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, sizeof(struct sockaddr_in));
1009 msg = Msg_CreateVoiceMsg(data, len);
1010 Client_send_message(client, msg);