1 /* Copyright (C) 2009-2014, Martin Johansson <martin@fatbob.nu>
2 Copyright (C) 2005-2014, 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>
44 #include "messagehandler.h"
48 #include "voicetarget.h"
52 extern char system_string[], version_string[];
54 static int Client_read(client_t *client);
55 static int Client_write(client_t *client);
56 static int Client_send_udp(client_t *client, uint8_t *data, int len);
57 void Client_free(client_t *client);
59 declare_list(clients);
60 static int clientcount; /* = 0 */
61 static int maxBandwidth;
64 int iCodecAlpha, iCodecBeta;
72 maxBandwidth = getIntConf(MAX_BANDWIDTH) / 8; /* From bits/s -> bytes/s */
80 int Client_getfds(struct pollfd *pollfds)
84 list_iterate(itr, &clients) {
86 c = list_get_entry(itr, client_t, node);
87 pollfds[i].fd = c->tcpfd;
88 pollfds[i].events = POLLIN | POLLHUP | POLLERR;
89 if (c->txsize > 0 || c->readBlockedOnWrite) /* Data waiting to be sent? */
90 pollfds[i].events |= POLLOUT;
98 struct dlist *itr, *save;
99 int bwTop = maxBandwidth + maxBandwidth / 4;
100 list_iterate_safe(itr, save, &clients) {
102 c = list_get_entry(itr, client_t, node);
103 Log_debug("Client %s BW available %d", c->username, c->availableBandwidth);
104 c->availableBandwidth += maxBandwidth;
105 if (c->availableBandwidth > bwTop)
106 c->availableBandwidth = bwTop;
108 if (Timer_isElapsed(&c->lastActivity, 1000000LL * INACTIVITY_TIMEOUT)) {
109 /* No activity from client - assume it is lost and close. */
110 Log_info_client(c, "Timeout, closing.");
117 void Client_codec_add(client_t *client, int codec)
119 codec_t *cd = Memory_safeMalloc(1, sizeof(codec_t));
120 init_list_entry(&cd->node);
122 list_add_tail(&cd->node, &client->codecs);
125 void Client_codec_free(client_t *client)
127 struct dlist *itr, *save;
128 list_iterate_safe(itr, save, &client->codecs) {
129 list_del(&list_get_entry(itr, codec_t, node)->node);
130 free(list_get_entry(itr, codec_t, node));
134 codec_t *Client_codec_iterate(client_t *client, codec_t **codec_itr)
136 codec_t *cd = *codec_itr;
138 if (list_empty(&client->codecs))
142 cd = list_get_entry(list_get_first(&client->codecs), codec_t, node);
144 if (list_get_next(&cd->node) == &client->codecs)
147 cd = list_get_entry(list_get_next(&cd->node), codec_t, node);
153 void Client_token_add(client_t *client, char *token_string)
157 if (client->tokencount >= MAX_TOKENS)
159 token = Memory_safeMalloc(1, sizeof(token_t));
160 init_list_entry(&token->node);
161 token->token = strdup(token_string);
162 if (token->token == NULL)
163 Log_fatal("Out of memory");
164 list_add_tail(&token->node, &client->tokens);
165 client->tokencount++;
168 bool_t Client_token_match(client_t *client, char const *str)
173 if (list_empty(&client->tokens))
175 list_iterate(itr, &client->tokens) {
176 token = list_get_entry(itr, token_t, node);
177 if (strncasecmp(token->token, str, MAX_TOKENSIZE) == 0)
183 void Client_token_free(client_t *client)
185 struct dlist *itr, *save;
188 list_iterate_safe(itr, save, &client->tokens) {
189 token = list_get_entry(itr, token_t, node);
190 list_del(&token->node);
194 client->tokencount = 0;
198 #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."
199 #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."
200 void recheckCodecVersions(client_t *connectingClient)
202 client_t *client_itr = NULL;
203 int max = 0, version, current_version;
204 int users = 0, opus = 0;
206 struct dlist codec_list, *itr, *save;
207 codec_t *codec_itr, *cd;
211 init_list_entry(&codec_list);
213 while (Client_iterate(&client_itr) != NULL) {
215 if (client_itr->codec_count == 0 && !client_itr->bOpus)
217 while (Client_codec_iterate(client_itr, &codec_itr) != NULL) {
219 list_iterate(itr, &codec_list) {
220 cd = list_get_entry(itr, codec_t, node);
221 if (cd->codec == codec_itr->codec) {
227 cd = Memory_safeCalloc(1, sizeof(codec_t));
228 init_list_entry(&cd->node);
229 cd->codec = codec_itr->codec;
231 list_add_tail(&cd->node, &codec_list);
235 if (client_itr->bOpus)
241 enableOpus = ((opus * 100 / users) >= getIntConf(OPUS_THRESHOLD));
243 list_iterate(itr, &codec_list) {
244 cd = list_get_entry(itr, codec_t, node);
245 if (cd->count > max) {
250 list_iterate_safe(itr, save, &codec_list) {
251 list_del(&list_get_entry(itr, codec_t, node)->node);
252 free(list_get_entry(itr, codec_t, node));
255 current_version = bPreferAlpha ? iCodecAlpha : iCodecBeta;
256 if (current_version != version) {
257 // If we don't already use the compat bitstream version set
258 // it as alpha and announce it. If another codec now got the
259 // majority set it as the opposite of the currently valid bPreferAlpha
261 if (version == (uint32_t)0x8000000b)
264 bPreferAlpha = !bPreferAlpha;
267 iCodecAlpha = version;
269 iCodecBeta = version;
270 } else if (bOpus && enableOpus) {
271 if (connectingClient && !connectingClient->bOpus)
272 Client_textmessage(connectingClient, OPUS_WARN_USING);
276 sendmsg = Msg_create(CodecVersion);
277 sendmsg->payload.codecVersion->alpha = iCodecAlpha;
278 sendmsg->payload.codecVersion->beta = iCodecBeta;
279 sendmsg->payload.codecVersion->prefer_alpha = bPreferAlpha;
280 sendmsg->payload.codecVersion->has_opus = true;
281 sendmsg->payload.codecVersion->opus = enableOpus;
283 Client_send_message_except(NULL, sendmsg);
285 if (enableOpus && !bOpus) {
287 while (Client_iterate(&client_itr) != NULL) {
288 if ((client_itr->authenticated || client_itr == connectingClient) &&
289 !client_itr->bOpus) {
290 Client_textmessage(client_itr, OPUS_WARN_SWITCHING);
293 Log_info("OPUS codec %s", bOpus ? "enabled" : "disabled");
299 static int findFreeSessionId()
302 client_t *itr = NULL;
304 for (id = 1; id < INT_MAX; id++) {
306 while ((itr = Client_iterate(&itr)) != NULL) {
307 if (itr->sessionId == id)
310 if (itr == NULL) /* Found free id */
316 int Client_add(int fd, struct sockaddr_storage *remote)
320 char* addressString = NULL;
322 if (Ban_isBannedAddr(remote)) {
323 addressString = Util_addressToString(remote);
324 Log_info("Address %s banned. Disconnecting", addressString);
329 newclient = Memory_safeCalloc(1, sizeof(client_t));
331 newclient->tcpfd = fd;
332 memcpy(&newclient->remote_tcp, remote, sizeof(struct sockaddr_storage));
333 newclient->ssl = SSLi_newconnection(&newclient->tcpfd, &newclient->SSLready);
334 if (newclient->ssl == NULL) {
335 addressString = Util_addressToString(remote);
336 Log_warn("SSL negotiation failed with %s on port %d", addressString, Util_addressToPort(remote));
341 newclient->availableBandwidth = maxBandwidth;
342 Timer_init(&newclient->lastActivity);
343 Timer_init(&newclient->connectTime);
344 Timer_init(&newclient->idleTime);
345 newclient->sessionId = findFreeSessionId();
346 if (newclient->sessionId < 0)
347 Log_fatal("Could not find a free session ID");
349 init_list_entry(&newclient->txMsgQueue);
350 init_list_entry(&newclient->chan_node);
351 init_list_entry(&newclient->node);
352 init_list_entry(&newclient->voicetargets);
353 init_list_entry(&newclient->codecs);
354 init_list_entry(&newclient->tokens);
356 list_add_tail(&newclient->node, &clients);
359 /* Send version message to client */
360 sendmsg = Msg_create(Version);
361 sendmsg->payload.version->has_version = true;
362 sendmsg->payload.version->version = PROTOCOL_VERSION;
363 sendmsg->payload.version->release = strdup(UMURMUR_VERSION);
364 sendmsg->payload.version->os = strdup(system_string);
365 sendmsg->payload.version->os_version = strdup(version_string);
366 Client_send_message(newclient, sendmsg);
371 void Client_free(client_t *client)
373 struct dlist *itr, *save;
375 bool_t authenticatedLeft = client->authenticated;
377 if (client->authenticated) {
379 leave_id = Chan_userLeave(client);
380 if (leave_id > 0) { /* Remove temp channel */
381 sendmsg = Msg_create(ChannelRemove);
382 sendmsg->payload.channelRemove->channel_id = leave_id;
383 Client_send_message_except(client, sendmsg);
385 sendmsg = Msg_create(UserRemove);
386 sendmsg->payload.userRemove->session = client->sessionId;
387 Client_send_message_except(client, sendmsg);
389 list_iterate_safe(itr, save, &client->txMsgQueue) {
390 list_del(&list_get_entry(itr, message_t, node)->node);
391 Msg_free(list_get_entry(itr, message_t, node));
393 Client_codec_free(client);
394 Voicetarget_free_all(client);
395 Client_token_free(client);
397 list_del(&client->node);
399 SSLi_free(client->ssl);
400 close(client->tcpfd);
403 free(client->release);
405 free(client->os_version);
406 free(client->username);
407 free(client->context);
410 if (authenticatedLeft)
411 recheckCodecVersions(NULL); /* Can use better codec now? */
414 void Client_close(client_t *client)
416 SSLi_shutdown(client->ssl);
417 client->shutdown_wait = true;
420 void Client_disconnect_all()
422 struct dlist *itr, *save;
424 list_iterate_safe(itr, save, &clients) {
425 Client_free(list_get_entry(itr, client_t, node));
429 int Client_read_fd(int fd)
432 client_t *client = NULL;
434 list_iterate(itr, &clients) {
435 if (fd == list_get_entry(itr, client_t, node)->tcpfd) {
436 client = list_get_entry(itr, client_t, node);
441 return Client_read(client);
446 int Client_read(client_t *client)
450 Timer_restart(&client->lastActivity);
452 if (client->writeBlockedOnRead) {
453 client->writeBlockedOnRead = false;
454 Log_debug("Client_read: writeBlockedOnRead == true");
455 return Client_write(client);
458 if (client->shutdown_wait) {
462 if (!client->SSLready) {
464 rc = SSLi_nonblockaccept(client->ssl, &client->SSLready);
473 if (!client->msgsize)
474 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
476 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
479 client->rxcount += rc;
480 if (!client->msgsize && client->rxcount >= 6) {
482 memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
483 client->msgsize = ntohl(msgLen);
485 if (client->msgsize > BUFSIZE - 6) {
486 /* XXX - figure out how to handle this. A large size here can represent two cases:
487 * 1. A valid size. The only message that is this big is UserState message with a big texture
488 * 2. An invalid size = protocol error, e.g. connecting with a 1.1.x client
490 // Log_warn("Too big message received (%d bytes). Playing safe and disconnecting client %s:%d",
491 // client->msgsize, inet_ntoa(client->remote_tcp.sin_addr), ntohs(client->remote_tcp.sin_port));
494 /* client->rxcount = client->msgsize = 0; */
496 else if (client->rxcount == client->msgsize + 6) { /* Got all of the message */
497 msg = Msg_networkToMessage(client->rxbuf, client->msgsize + 6);
498 /* pass messsage to handler */
500 Mh_handle_message(client, msg);
501 client->rxcount = client->msgsize = 0;
503 } else /* rc <= 0 */ {
504 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
507 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
508 client->readBlockedOnWrite = true;
511 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_ZERO_RETURN ||
512 SSLi_get_error(client->ssl, rc) == 0) {
513 Log_info_client(client, "Connection closed by peer");
514 Client_close(client);
517 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
519 Log_info_client(client, "Connection closed by peer");
521 Log_info_client(client,"Error: %s - Closing connection (code %d)",
524 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
525 Log_info_client(client, "Connection reset by peer");
528 Log_info_client(client, "SSL error: %d - Closing connection", SSLi_get_error(client->ssl, rc));
534 } while (SSLi_data_pending(client->ssl));
539 int Client_write_fd(int fd)
542 client_t *client = NULL;
544 list_iterate(itr, &clients) {
545 if(fd == list_get_entry(itr, client_t, node)->tcpfd) {
546 client = list_get_entry(itr, client_t, node);
551 return Client_write(client);
556 int Client_write(client_t *client)
560 if (client->readBlockedOnWrite) {
561 client->readBlockedOnWrite = false;
562 Log_debug("Client_write: readBlockedOnWrite == true");
563 return Client_read(client);
565 rc = SSLi_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
567 client->txcount += rc;
568 if (client->txcount == client->txsize)
569 client->txsize = client->txcount = 0;
572 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
573 client->writeBlockedOnRead = true;
576 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
580 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
581 Log_info_client(client, "Error: %s - Closing connection", strerror(errno));
583 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
584 Log_info_client(client, "Connection reset by peer");
587 Log_info_client(client, "SSL error: %d - Closing connection.", SSLi_get_error(client->ssl, rc));
593 if (client->txsize == 0 && !list_empty(&client->txMsgQueue)) {
595 msg = list_get_entry(list_get_first(&client->txMsgQueue), message_t, node);
596 list_del(list_get_first(&client->txMsgQueue));
597 client->txQueueCount--;
598 Client_send_message(client, msg);
603 int Client_send_message_ver(client_t *client, message_t *msg, uint32_t version)
605 if ((version == 0) || (client->version >= version) ||
606 ((version & 0x80000000) && (client->version < (~version))))
607 return Client_send_message(client, msg);
613 int Client_send_message(client_t *client, message_t *msg)
615 if (!client->authenticated && msg->messageType != Version) {
619 if (client->txsize != 0 || !client->SSLready) {
621 if ((client->txQueueCount > 5 && msg->messageType == UDPTunnel) ||
622 client->txQueueCount > 30) {
626 client->txQueueCount++;
627 list_add_tail(&msg->node, &client->txMsgQueue);
628 Log_debug("Queueing message");
631 len = Msg_messageToNetwork(msg, client->txbuf);
632 doAssert(len < BUFSIZE);
634 client->txsize = len;
636 Client_write(client);
642 client_t *Client_iterate(client_t **client_itr)
644 client_t *c = *client_itr;
646 if (list_empty(&clients))
650 c = list_get_entry(list_get_first(&clients), client_t, node);
652 if (list_get_next(&c->node) == &clients)
655 c = list_get_entry(list_get_next(&c->node), client_t, node);
661 void Client_textmessage(client_t *client, char *text)
665 message_t *sendmsg = NULL;
667 message = Memory_safeMalloc(1, strlen(text) + 1);
668 tree_id = Memory_safeMalloc(1, sizeof(uint32_t));
670 sendmsg = Msg_create(TextMessage);
671 sendmsg->payload.textMessage->message = message;
672 sendmsg->payload.textMessage->n_tree_id = 1;
673 sendmsg->payload.textMessage->tree_id = tree_id;
674 strcpy(message, text);
675 Client_send_message(client, sendmsg);
679 int Client_send_message_except(client_t *client, message_t *msg)
681 client_t *itr = NULL;
683 while (Client_iterate(&itr) != NULL) {
685 Msg_inc_ref(msg); /* One extra reference for each new copy */
686 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
687 Client_send_message(itr, msg);
690 Msg_free(msg); /* Consume caller's reference. */
695 int Client_send_message_except_ver(client_t *client, message_t *msg, uint32_t version)
697 client_t *itr = NULL;
699 while (Client_iterate(&itr) != NULL) {
701 Msg_inc_ref(msg); /* One extra reference for each new copy */
702 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
703 Client_send_message_ver(itr, msg, version);
706 Msg_free(msg); /* Consume caller's reference. */
711 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
713 if (CryptState_isValid(&client->cryptState) &&
714 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
717 if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
718 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
720 Timer_restart(&client->cryptState.tLastRequest);
722 sendmsg = Msg_create(CryptSetup);
723 Log_info_client(client, "Requesting voice channel crypt resync");
724 Client_send_message(client, sendmsg);
730 #define UDP_PACKET_SIZE 1024
731 int Client_read_udp(int udpsock)
734 struct sockaddr_storage from;
735 socklen_t fromlen = sizeof(struct sockaddr_storage);
736 uint8_t key[KEY_LENGTH];
738 UDPMessageType_t msgType;
739 uint8_t fromaddress[4 * sizeof(in_addr_t)];
742 #if defined(__LP64__)
743 uint8_t encbuff[UDP_PACKET_SIZE + 8];
744 uint8_t *encrypted = encbuff + 4;
746 uint8_t encrypted[UDP_PACKET_SIZE];
748 uint8_t buffer[UDP_PACKET_SIZE];
750 len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
752 memset(key, 0, KEY_LENGTH);
754 fromport = Util_addressToPort(&from);
756 if(from.ss_family == AF_INET) {
757 memcpy(fromaddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
758 memcpy(&key[0], &fromport, 2);
759 memcpy(&key[2], fromaddress, sizeof(in_addr_t));
761 memcpy(fromaddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
762 memcpy(&key[0], &fromport, 2);
763 memcpy(&key[2], fromaddress, 4 * sizeof(in_addr_t));
768 else if (len < 5 || len > UDP_PACKET_SIZE) /* 4 bytes crypt header + type + session */
772 * Reply to ping packet
773 * The second and third uint32_t are the timestamp, which will be returned unmodified
775 if (len == 12 && *encrypted == 0) {
776 uint32_t *ping = (uint32_t *)encrypted;
777 ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
778 ping[3] = htonl((uint32_t)clientcount);
779 ping[4] = htonl((uint32_t)getIntConf(MAX_CLIENTS));
780 ping[5] = htonl((uint32_t)getIntConf(MAX_BANDWIDTH));
782 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
788 while (Client_iterate(&itr) != NULL) {
789 if (memcmp(itr->key, key, KEY_LENGTH) == 0) {
790 if (!checkDecrypt(itr, encrypted, buffer, len))
795 if (itr == NULL) { /* Unknown peer */
796 struct sockaddr_storage itraddressstorage;
797 uint8_t itraddress[4 * sizeof(in_addr_t)];
800 while (Client_iterate(&itr) != NULL) {
801 itraddressstorage = itr->remote_tcp;
802 if(itraddressstorage.ss_family == AF_INET) {
803 memcpy(itraddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
804 addresslength = sizeof(in_addr_t);
806 memcpy(itraddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
807 addresslength = 4 * sizeof(in_addr_t);
810 if (memcmp(itraddress, fromaddress, addresslength) == 0) {
811 if (checkDecrypt(itr, encrypted, buffer, len)) {
812 memcpy(itr->key, key, KEY_LENGTH);
813 char* clientAddressString = Util_clientAddressToString(itr);
814 Log_info_client(itr, "New UDP connection from %s on port %d", clientAddressString, fromport);
815 free(clientAddressString);
816 memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_storage));
822 if (itr == NULL) { /* Couldn't find this peer among connected clients */
827 len -= 4; /* Adjust for crypt header */
828 msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
830 char *clientAddressString = NULL;
834 case UDPVoiceCELTAlpha:
835 case UDPVoiceCELTBeta:
839 Client_voiceMsg(itr, buffer, len);
842 Log_debug("UDP Ping reply len %d", len);
843 Client_send_udp(itr, buffer, len);
846 clientAddressString = Util_clientAddressToString(itr);
847 Log_debug("Unknown UDP message type from %s port %d", clientAddressString, fromport);
848 free(clientAddressString);
856 static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
858 if (IS_AUTH(dst) && dst != src && !dst->deaf && !dst->self_deaf) {
859 if (poslen > 0 && /* Has positional data */
860 src->context != NULL && dst->context != NULL && /* ...both source and destination has context */
861 strcmp(src->context, dst->context) == 0) /* ...and the contexts match */
862 Client_send_udp(dst, data, len);
864 Client_send_udp(dst, data, len - poslen);
868 /* Handle decrypted voice message */
869 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
871 uint8_t buffer[UDP_PACKET_SIZE];
872 pds_t *pdi = Pds_create(data + 1, len - 1);
873 pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
874 unsigned int type = data[0] & 0xe0;
875 unsigned int target = data[0] & 0x1f;
876 unsigned int poslen, counter, size;
877 int offset, packetsize;
880 channel_t *ch = client->channel;
883 if (!client->authenticated || client->mute || client->self_mute || ch->silent)
886 packetsize = 20 + 8 + 4 + len;
887 if (client->availableBandwidth - packetsize < 0)
888 goto out; /* Discard */
889 client->availableBandwidth -= packetsize;
891 Timer_restart(&client->idleTime);
892 Timer_restart(&client->lastActivity);
894 counter = Pds_get_numval(pdi); /* step past session id */
895 if ((type >> 5) != UDPVoiceOpus) {
897 counter = Pds_next8(pdi);
898 offset = Pds_skip(pdi, counter & 0x7f);
899 } while ((counter & 0x80) && offset > 0);
901 size = Pds_get_numval(pdi);
902 Pds_skip(pdi, size & 0x1fff);
905 poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
907 Pds_add_numval(pds, client->sessionId);
908 Pds_append_data_nosize(pds, data + 1, len - 1);
910 if (target == 0x1f) { /* Loopback */
911 buffer[0] = (uint8_t) type;
912 Client_send_udp(client, buffer, pds->offset + 1);
914 else if (target == 0) { /* regular channel speech */
915 buffer[0] = (uint8_t) type;
920 list_iterate(itr, &ch->clients) {
922 c = list_get_entry(itr, client_t, chan_node);
923 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
925 } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
929 for (i = 0; i < TARGET_MAX_CHANNELS && vt->channels[i].channel != -1; i++) {
930 buffer[0] = (uint8_t) (type | 1);
931 Log_debug("Whisper channel %d", vt->channels[i]);
932 ch = Chan_fromId(vt->channels[i].channel);
935 list_iterate(itr, &ch->clients) {
937 c = list_get_entry(itr, client_t, chan_node);
938 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
941 if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
942 struct dlist *ch_itr;
943 list_iterate(ch_itr, &ch->channel_links) {
946 chl = list_get_entry(ch_itr, channellist_t, node);
948 list_iterate(itr, &ch_link->clients) {
950 c = list_get_entry(itr, client_t, chan_node);
951 Log_debug("Linked voice from %s -> %s", ch->name, ch_link->name);
952 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
957 if (vt->channels[i].children) {
958 struct dlist chanlist, *ch_itr;
959 init_list_entry(&chanlist);
960 Chan_buildTreeList(ch, &chanlist);
961 list_iterate(ch_itr, &chanlist) {
963 sub = list_get_entry(ch_itr, channellist_t, node)->chan;
964 list_iterate(itr, &sub->clients) {
966 c = list_get_entry(itr, client_t, chan_node);
967 Log_debug("Child voice from %s -> %s", ch->name, sub->name);
968 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
971 Chan_freeTreeList(&chanlist);
975 for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
977 buffer[0] = (uint8_t) (type | 2);
978 Log_debug("Whisper session %d", vt->sessions[i]);
979 while (Client_iterate(&c) != NULL) {
980 if (c->sessionId == vt->sessions[i]) {
981 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
994 static int Client_send_udp(client_t *client, uint8_t *data, int len)
998 int udpsock = (client->remote_udp.ss_family == AF_INET) ? udpsocks[0] : udpsocks[(hasv4) ? 1 : 0];
1000 if (Util_clientAddressToPortUDP(client) != 0 && CryptState_isValid(&client->cryptState) &&
1002 #if defined(__LP64__)
1003 buf = mbuf = Memory_safeMalloc(1, len + 4 + 16);
1006 mbuf = buf = Memory_safeMalloc(1, len + 4);
1008 CryptState_encrypt(&client->cryptState, data, buf, len);
1010 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
1011 sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, client->remote_tcp.ss_len);
1013 sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, sizeof(struct sockaddr_storage));
1019 msg = Msg_CreateVoiceMsg(data, len);
1020 Client_send_message(client, msg);