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);
406 if (client->os_version)
407 free(client->os_version);
408 if (client->username)
409 free(client->username);
411 free(client->context);
414 if (authenticatedLeft)
415 recheckCodecVersions(NULL); /* Can use better codec now? */
418 void Client_close(client_t *client)
420 SSLi_shutdown(client->ssl);
421 client->shutdown_wait = true;
424 void Client_disconnect_all()
426 struct dlist *itr, *save;
428 list_iterate_safe(itr, save, &clients) {
429 Client_free(list_get_entry(itr, client_t, node));
433 int Client_read_fd(int fd)
436 client_t *client = NULL;
438 list_iterate(itr, &clients) {
439 if (fd == list_get_entry(itr, client_t, node)->tcpfd) {
440 client = list_get_entry(itr, client_t, node);
445 return Client_read(client);
450 int Client_read(client_t *client)
454 Timer_restart(&client->lastActivity);
456 if (client->writeBlockedOnRead) {
457 client->writeBlockedOnRead = false;
458 Log_debug("Client_read: writeBlockedOnRead == true");
459 return Client_write(client);
462 if (client->shutdown_wait) {
466 if (!client->SSLready) {
468 rc = SSLi_nonblockaccept(client->ssl, &client->SSLready);
477 if (!client->msgsize)
478 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
480 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
483 client->rxcount += rc;
484 if (!client->msgsize && client->rxcount >= 6) {
486 memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
487 client->msgsize = ntohl(msgLen);
489 if (client->msgsize > BUFSIZE - 6) {
490 /* XXX - figure out how to handle this. A large size here can represent two cases:
491 * 1. A valid size. The only message that is this big is UserState message with a big texture
492 * 2. An invalid size = protocol error, e.g. connecting with a 1.1.x client
494 // Log_warn("Too big message received (%d bytes). Playing safe and disconnecting client %s:%d",
495 // client->msgsize, inet_ntoa(client->remote_tcp.sin_addr), ntohs(client->remote_tcp.sin_port));
498 /* client->rxcount = client->msgsize = 0; */
500 else if (client->rxcount == client->msgsize + 6) { /* Got all of the message */
501 msg = Msg_networkToMessage(client->rxbuf, client->msgsize + 6);
502 /* pass messsage to handler */
504 Mh_handle_message(client, msg);
505 client->rxcount = client->msgsize = 0;
507 } else /* rc <= 0 */ {
508 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
511 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
512 client->readBlockedOnWrite = true;
515 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_ZERO_RETURN ||
516 SSLi_get_error(client->ssl, rc) == 0) {
517 Log_info_client(client, "Connection closed by peer");
518 Client_close(client);
521 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
523 Log_info_client(client, "Connection closed by peer");
525 Log_info_client(client,"Error: %s - Closing connection (code %d)",
528 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
529 Log_info_client(client, "Connection reset by peer");
532 Log_info_client(client, "SSL error: %d - Closing connection", SSLi_get_error(client->ssl, rc));
538 } while (SSLi_data_pending(client->ssl));
543 int Client_write_fd(int fd)
546 client_t *client = NULL;
548 list_iterate(itr, &clients) {
549 if(fd == list_get_entry(itr, client_t, node)->tcpfd) {
550 client = list_get_entry(itr, client_t, node);
555 return Client_write(client);
560 int Client_write(client_t *client)
564 if (client->readBlockedOnWrite) {
565 client->readBlockedOnWrite = false;
566 Log_debug("Client_write: readBlockedOnWrite == true");
567 return Client_read(client);
569 rc = SSLi_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
571 client->txcount += rc;
572 if (client->txcount == client->txsize)
573 client->txsize = client->txcount = 0;
576 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
577 client->writeBlockedOnRead = true;
580 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
584 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
585 Log_info_client(client, "Error: %s - Closing connection", strerror(errno));
587 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
588 Log_info_client(client, "Connection reset by peer");
591 Log_info_client(client, "SSL error: %d - Closing connection.", SSLi_get_error(client->ssl, rc));
597 if (client->txsize == 0 && !list_empty(&client->txMsgQueue)) {
599 msg = list_get_entry(list_get_first(&client->txMsgQueue), message_t, node);
600 list_del(list_get_first(&client->txMsgQueue));
601 client->txQueueCount--;
602 Client_send_message(client, msg);
607 int Client_send_message_ver(client_t *client, message_t *msg, uint32_t version)
609 if ((version == 0) || (client->version >= version) ||
610 ((version & 0x80000000) && (client->version < (~version))))
611 return Client_send_message(client, msg);
617 int Client_send_message(client_t *client, message_t *msg)
619 if (!client->authenticated && msg->messageType != Version) {
623 if (client->txsize != 0 || !client->SSLready) {
625 if ((client->txQueueCount > 5 && msg->messageType == UDPTunnel) ||
626 client->txQueueCount > 30) {
630 client->txQueueCount++;
631 list_add_tail(&msg->node, &client->txMsgQueue);
632 Log_debug("Queueing message");
635 len = Msg_messageToNetwork(msg, client->txbuf);
636 doAssert(len < BUFSIZE);
638 client->txsize = len;
640 Client_write(client);
646 client_t *Client_iterate(client_t **client_itr)
648 client_t *c = *client_itr;
650 if (list_empty(&clients))
654 c = list_get_entry(list_get_first(&clients), client_t, node);
656 if (list_get_next(&c->node) == &clients)
659 c = list_get_entry(list_get_next(&c->node), client_t, node);
665 void Client_textmessage(client_t *client, char *text)
669 message_t *sendmsg = NULL;
671 message = Memory_safeMalloc(1, strlen(text) + 1);
672 tree_id = Memory_safeMalloc(1, sizeof(uint32_t));
674 sendmsg = Msg_create(TextMessage);
675 sendmsg->payload.textMessage->message = message;
676 sendmsg->payload.textMessage->n_tree_id = 1;
677 sendmsg->payload.textMessage->tree_id = tree_id;
678 strcpy(message, text);
679 Client_send_message(client, sendmsg);
683 int Client_send_message_except(client_t *client, message_t *msg)
685 client_t *itr = NULL;
688 Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
689 while (Client_iterate(&itr) != NULL) {
692 Msg_inc_ref(msg); /* One extra reference for each new copy */
693 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
694 Client_send_message(itr, msg);
697 Msg_free(msg); /* Free our reference to the message */
700 Msg_free(msg); /* If only 1 client is connected then no message is passed
701 * to Client_send_message(). Free it here. */
706 int Client_send_message_except_ver(client_t *client, message_t *msg, uint32_t version)
708 client_t *itr = NULL;
711 Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
712 while (Client_iterate(&itr) != NULL) {
715 Msg_inc_ref(msg); /* One extra reference for each new copy */
716 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
717 Client_send_message_ver(itr, msg, version);
720 Msg_free(msg); /* Free our reference to the message */
723 Msg_free(msg); /* If only 1 client is connected then no message is passed
724 * to Client_send_message(). Free it here. */
729 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
731 if (CryptState_isValid(&client->cryptState) &&
732 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
735 if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
736 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
738 Timer_restart(&client->cryptState.tLastRequest);
740 sendmsg = Msg_create(CryptSetup);
741 Log_info_client(client, "Requesting voice channel crypt resync");
742 Client_send_message(client, sendmsg);
748 #define UDP_PACKET_SIZE 1024
749 int Client_read_udp(int udpsock)
752 struct sockaddr_storage from;
753 socklen_t fromlen = sizeof(struct sockaddr_storage);
754 uint8_t key[KEY_LENGTH];
756 UDPMessageType_t msgType;
757 uint8_t fromaddress[4 * sizeof(in_addr_t)];
760 #if defined(__LP64__)
761 uint8_t encbuff[UDP_PACKET_SIZE + 8];
762 uint8_t *encrypted = encbuff + 4;
764 uint8_t encrypted[UDP_PACKET_SIZE];
766 uint8_t buffer[UDP_PACKET_SIZE];
768 len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
770 memset(key, 0, KEY_LENGTH);
772 fromport = Util_addressToPort(&from);
774 if(from.ss_family == AF_INET) {
775 memcpy(fromaddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
776 memcpy(&key[0], &fromport, 2);
777 memcpy(&key[2], fromaddress, sizeof(in_addr_t));
779 memcpy(fromaddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
780 memcpy(&key[0], &fromport, 2);
781 memcpy(&key[2], fromaddress, 4 * sizeof(in_addr_t));
786 else if (len < 5 || len > UDP_PACKET_SIZE) /* 4 bytes crypt header + type + session */
790 * Reply to ping packet
791 * The second and third uint32_t are the timestamp, which will be returned unmodified
793 if (len == 12 && *encrypted == 0) {
794 uint32_t *ping = (uint32_t *)encrypted;
795 ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
796 ping[3] = htonl((uint32_t)clientcount);
797 ping[4] = htonl((uint32_t)getIntConf(MAX_CLIENTS));
798 ping[5] = htonl((uint32_t)getIntConf(MAX_BANDWIDTH));
800 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
806 while (Client_iterate(&itr) != NULL) {
807 if (memcmp(itr->key, key, KEY_LENGTH) == 0) {
808 if (!checkDecrypt(itr, encrypted, buffer, len))
813 if (itr == NULL) { /* Unknown peer */
814 struct sockaddr_storage itraddressstorage;
815 uint8_t itraddress[4 * sizeof(in_addr_t)];
818 while (Client_iterate(&itr) != NULL) {
819 itraddressstorage = itr->remote_tcp;
820 if(itraddressstorage.ss_family == AF_INET) {
821 memcpy(itraddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
822 addresslength = sizeof(in_addr_t);
824 memcpy(itraddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
825 addresslength = 4 * sizeof(in_addr_t);
828 if (memcmp(itraddress, fromaddress, addresslength) == 0) {
829 if (checkDecrypt(itr, encrypted, buffer, len)) {
830 memcpy(itr->key, key, KEY_LENGTH);
831 char* clientAddressString = Util_clientAddressToString(itr);
832 Log_info_client(itr, "New UDP connection from %s on port %d", clientAddressString, fromport);
833 free(clientAddressString);
834 memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_storage));
840 if (itr == NULL) { /* Couldn't find this peer among connected clients */
845 len -= 4; /* Adjust for crypt header */
846 msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
848 char *clientAddressString = NULL;
852 case UDPVoiceCELTAlpha:
853 case UDPVoiceCELTBeta:
857 Client_voiceMsg(itr, buffer, len);
860 Log_debug("UDP Ping reply len %d", len);
861 Client_send_udp(itr, buffer, len);
864 clientAddressString = Util_clientAddressToString(itr);
865 Log_debug("Unknown UDP message type from %s port %d", clientAddressString, fromport);
866 free(clientAddressString);
874 static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
876 if (IS_AUTH(dst) && dst != src && !dst->deaf && !dst->self_deaf) {
877 if (poslen > 0 && /* Has positional data */
878 src->context != NULL && dst->context != NULL && /* ...both source and destination has context */
879 strcmp(src->context, dst->context) == 0) /* ...and the contexts match */
880 Client_send_udp(dst, data, len);
882 Client_send_udp(dst, data, len - poslen);
886 /* Handle decrypted voice message */
887 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
889 uint8_t buffer[UDP_PACKET_SIZE];
890 pds_t *pdi = Pds_create(data + 1, len - 1);
891 pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
892 unsigned int type = data[0] & 0xe0;
893 unsigned int target = data[0] & 0x1f;
894 unsigned int poslen, counter, size;
895 int offset, packetsize;
898 channel_t *ch = (channel_t *)client->channel;
901 if (!client->authenticated || client->mute || client->self_mute || ch->silent)
904 packetsize = 20 + 8 + 4 + len;
905 if (client->availableBandwidth - packetsize < 0)
906 goto out; /* Discard */
907 client->availableBandwidth -= packetsize;
909 Timer_restart(&client->idleTime);
910 Timer_restart(&client->lastActivity);
912 counter = Pds_get_numval(pdi); /* step past session id */
913 if ((type >> 5) != UDPVoiceOpus) {
915 counter = Pds_next8(pdi);
916 offset = Pds_skip(pdi, counter & 0x7f);
917 } while ((counter & 0x80) && offset > 0);
919 size = Pds_get_numval(pdi);
920 Pds_skip(pdi, size & 0x1fff);
923 poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
925 Pds_add_numval(pds, client->sessionId);
926 Pds_append_data_nosize(pds, data + 1, len - 1);
928 if (target == 0x1f) { /* Loopback */
929 buffer[0] = (uint8_t) type;
930 Client_send_udp(client, buffer, pds->offset + 1);
932 else if (target == 0) { /* regular channel speech */
933 buffer[0] = (uint8_t) type;
938 list_iterate(itr, &ch->clients) {
940 c = list_get_entry(itr, client_t, chan_node);
941 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
943 } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
947 for (i = 0; i < TARGET_MAX_CHANNELS && vt->channels[i].channel != -1; i++) {
948 buffer[0] = (uint8_t) (type | 1);
949 Log_debug("Whisper channel %d", vt->channels[i]);
950 ch = Chan_fromId(vt->channels[i].channel);
953 list_iterate(itr, &ch->clients) {
955 c = list_get_entry(itr, client_t, chan_node);
956 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
959 if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
960 struct dlist *ch_itr;
961 list_iterate(ch_itr, &ch->channel_links) {
964 chl = list_get_entry(ch_itr, channellist_t, node);
966 list_iterate(itr, &ch_link->clients) {
968 c = list_get_entry(itr, client_t, chan_node);
969 Log_debug("Linked voice from %s -> %s", ch->name, ch_link->name);
970 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
975 if (vt->channels[i].children) {
976 struct dlist chanlist, *ch_itr;
977 init_list_entry(&chanlist);
978 Chan_buildTreeList(ch, &chanlist);
979 list_iterate(ch_itr, &chanlist) {
981 sub = list_get_entry(ch_itr, channellist_t, node)->chan;
982 list_iterate(itr, &sub->clients) {
984 c = list_get_entry(itr, client_t, chan_node);
985 Log_debug("Child voice from %s -> %s", ch->name, sub->name);
986 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
989 Chan_freeTreeList(&chanlist);
993 for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
995 buffer[0] = (uint8_t) (type | 2);
996 Log_debug("Whisper session %d", vt->sessions[i]);
997 while (Client_iterate(&c) != NULL) {
998 if (c->sessionId == vt->sessions[i]) {
999 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
1012 static int Client_send_udp(client_t *client, uint8_t *data, int len)
1014 uint8_t *buf, *mbuf;
1016 int udpsock = (client->remote_udp.ss_family == AF_INET) ? udpsocks[0] : udpsocks[(hasv4) ? 1 : 0];
1018 if (Util_clientAddressToPortUDP(client) != 0 && CryptState_isValid(&client->cryptState) &&
1020 #if defined(__LP64__)
1021 buf = mbuf = Memory_safeMalloc(1, len + 4 + 16);
1024 mbuf = buf = Memory_safeMalloc(1, len + 4);
1026 CryptState_encrypt(&client->cryptState, data, buf, len);
1028 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
1029 sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, client->remote_tcp.ss_len);
1031 sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, sizeof(struct sockaddr_storage));
1037 msg = Msg_CreateVoiceMsg(data, len);
1038 Client_send_message(client, msg);