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>
43 #include "messagehandler.h"
47 #include "voicetarget.h"
51 extern char system_string[], version_string[];
53 static int Client_read(client_t *client);
54 static int Client_write(client_t *client);
55 static int Client_send_udp(client_t *client, uint8_t *data, int len);
56 void Client_free(client_t *client);
58 declare_list(clients);
59 static int clientcount; /* = 0 */
60 static int maxBandwidth;
63 int iCodecAlpha, iCodecBeta;
71 maxBandwidth = getIntConf(MAX_BANDWIDTH) / 8; /* From bits/s -> bytes/s */
79 int Client_getfds(struct pollfd *pollfds)
83 list_iterate(itr, &clients) {
85 c = list_get_entry(itr, client_t, node);
86 pollfds[i].fd = c->tcpfd;
87 pollfds[i].events = POLLIN | POLLHUP | POLLERR;
88 if (c->txsize > 0 || c->readBlockedOnWrite) /* Data waiting to be sent? */
89 pollfds[i].events |= POLLOUT;
97 struct dlist *itr, *save;
98 int bwTop = maxBandwidth + maxBandwidth / 4;
99 list_iterate_safe(itr, save, &clients) {
101 c = list_get_entry(itr, client_t, node);
102 Log_debug("Client %s BW available %d", c->username, c->availableBandwidth);
103 c->availableBandwidth += maxBandwidth;
104 if (c->availableBandwidth > bwTop)
105 c->availableBandwidth = bwTop;
107 if (Timer_isElapsed(&c->lastActivity, 1000000LL * INACTIVITY_TIMEOUT)) {
108 /* No activity from client - assume it is lost and close. */
109 Log_info_client(c, "Timeout, closing.");
116 void Client_codec_add(client_t *client, int codec)
118 codec_t *cd = malloc(sizeof(codec_t));
120 Log_fatal("Out of memory");
121 init_list_entry(&cd->node);
123 list_add_tail(&cd->node, &client->codecs);
126 void Client_codec_free(client_t *client)
128 struct dlist *itr, *save;
129 list_iterate_safe(itr, save, &client->codecs) {
130 list_del(&list_get_entry(itr, codec_t, node)->node);
131 free(list_get_entry(itr, codec_t, node));
135 codec_t *Client_codec_iterate(client_t *client, codec_t **codec_itr)
137 codec_t *cd = *codec_itr;
139 if (list_empty(&client->codecs))
143 cd = list_get_entry(list_get_first(&client->codecs), codec_t, node);
145 if (list_get_next(&cd->node) == &client->codecs)
148 cd = list_get_entry(list_get_next(&cd->node), codec_t, node);
154 void Client_token_add(client_t *client, char *token_string)
158 if (client->tokencount >= MAX_TOKENS)
160 token = malloc(sizeof(token_t));
162 Log_fatal("Out of memory");
163 init_list_entry(&token->node);
164 token->token = strdup(token_string);
165 if (token->token == NULL)
166 Log_fatal("Out of memory");
167 list_add_tail(&token->node, &client->tokens);
168 client->tokencount++;
171 bool_t Client_token_match(client_t *client, char *str)
176 if (list_empty(&client->tokens))
178 list_iterate(itr, &client->tokens) {
179 token = list_get_entry(itr, token_t, node);
180 if (strncasecmp(token->token, str, MAX_TOKENSIZE) == 0)
186 void Client_token_free(client_t *client)
188 struct dlist *itr, *save;
191 list_iterate_safe(itr, save, &client->tokens) {
192 token = list_get_entry(itr, token_t, node);
193 list_del(&token->node);
197 client->tokencount = 0;
201 #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."
202 #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."
203 void recheckCodecVersions(client_t *connectingClient)
205 client_t *client_itr = NULL;
206 int max = 0, version, current_version;
207 int users = 0, opus = 0;
209 struct dlist codec_list, *itr, *save;
210 codec_t *codec_itr, *cd;
214 init_list_entry(&codec_list);
216 while (Client_iterate(&client_itr) != NULL) {
218 if (client_itr->codec_count == 0 && !client_itr->bOpus)
220 while (Client_codec_iterate(client_itr, &codec_itr) != NULL) {
222 list_iterate(itr, &codec_list) {
223 cd = list_get_entry(itr, codec_t, node);
224 if (cd->codec == codec_itr->codec) {
230 cd = malloc(sizeof(codec_t));
232 Log_fatal("Out of memory");
233 memset(cd, 0, sizeof(codec_t));
234 init_list_entry(&cd->node);
235 cd->codec = codec_itr->codec;
237 list_add_tail(&cd->node, &codec_list);
241 if (client_itr->bOpus)
247 enableOpus = ((opus * 100 / users) >= getIntConf(OPUS_THRESHOLD));
249 list_iterate(itr, &codec_list) {
250 cd = list_get_entry(itr, codec_t, node);
251 if (cd->count > max) {
256 list_iterate_safe(itr, save, &codec_list) {
257 list_del(&list_get_entry(itr, codec_t, node)->node);
258 free(list_get_entry(itr, codec_t, node));
261 current_version = bPreferAlpha ? iCodecAlpha : iCodecBeta;
262 if (current_version != version) {
263 // If we don't already use the compat bitstream version set
264 // it as alpha and announce it. If another codec now got the
265 // majority set it as the opposite of the currently valid bPreferAlpha
267 if (version == (uint32_t)0x8000000b)
270 bPreferAlpha = !bPreferAlpha;
273 iCodecAlpha = version;
275 iCodecBeta = version;
276 } else if (bOpus && enableOpus) {
277 if (connectingClient && !connectingClient->bOpus)
278 Client_textmessage(connectingClient, OPUS_WARN_USING);
282 sendmsg = Msg_create(CodecVersion);
283 sendmsg->payload.codecVersion->alpha = iCodecAlpha;
284 sendmsg->payload.codecVersion->beta = iCodecBeta;
285 sendmsg->payload.codecVersion->prefer_alpha = bPreferAlpha;
286 sendmsg->payload.codecVersion->has_opus = true;
287 sendmsg->payload.codecVersion->opus = enableOpus;
289 Client_send_message_except(NULL, sendmsg);
291 if (enableOpus && !bOpus) {
293 while (Client_iterate(&client_itr) != NULL) {
294 if ((client_itr->authenticated || client_itr == connectingClient) &&
295 !client_itr->bOpus) {
296 Client_textmessage(client_itr, OPUS_WARN_SWITCHING);
299 Log_info("OPUS codec %s", bOpus ? "enabled" : "disabled");
305 static int findFreeSessionId()
308 client_t *itr = NULL;
310 for (id = 1; id < INT_MAX; id++) {
312 while ((itr = Client_iterate(&itr)) != NULL) {
313 if (itr->sessionId == id)
316 if (itr == NULL) /* Found free id */
322 int Client_add(int fd, struct sockaddr_storage *remote)
327 if (Ban_isBannedAddr(remote)) {
328 Log_info("Address %s banned. Disconnecting", Util_addressToString(remote));
332 if ((newclient = calloc(1, sizeof(client_t))) == NULL)
333 Log_fatal("(%s:%s): Out of memory while allocating %d bytes.", __FILE__, __LINE__, sizeof(client_t));
335 newclient->tcpfd = fd;
336 memcpy(&newclient->remote_tcp, remote, sizeof(struct sockaddr_storage));
337 newclient->ssl = SSLi_newconnection(&newclient->tcpfd, &newclient->SSLready);
338 if (newclient->ssl == NULL) {
339 Log_warn("SSL negotiation failed with %s on port %d", Util_addressToString(remote), Util_addressToPort(remote));
343 newclient->availableBandwidth = maxBandwidth;
344 Timer_init(&newclient->lastActivity);
345 Timer_init(&newclient->connectTime);
346 Timer_init(&newclient->idleTime);
347 newclient->sessionId = findFreeSessionId();
348 if (newclient->sessionId < 0)
349 Log_fatal("Could not find a free session ID");
351 init_list_entry(&newclient->txMsgQueue);
352 init_list_entry(&newclient->chan_node);
353 init_list_entry(&newclient->node);
354 init_list_entry(&newclient->voicetargets);
355 init_list_entry(&newclient->codecs);
356 init_list_entry(&newclient->tokens);
358 list_add_tail(&newclient->node, &clients);
361 /* Send version message to client */
362 sendmsg = Msg_create(Version);
363 sendmsg->payload.version->has_version = true;
364 sendmsg->payload.version->version = PROTOCOL_VERSION;
365 sendmsg->payload.version->release = strdup(UMURMUR_VERSION);
366 sendmsg->payload.version->os = strdup(system_string);
367 sendmsg->payload.version->os_version = strdup(version_string);
368 Client_send_message(newclient, sendmsg);
373 void Client_free(client_t *client)
375 struct dlist *itr, *save;
377 bool_t authenticatedLeft = client->authenticated;
379 if (client->authenticated) {
381 leave_id = Chan_userLeave(client);
382 if (leave_id > 0) { /* Remove temp channel */
383 sendmsg = Msg_create(ChannelRemove);
384 sendmsg->payload.channelRemove->channel_id = leave_id;
385 Client_send_message_except(client, sendmsg);
387 sendmsg = Msg_create(UserRemove);
388 sendmsg->payload.userRemove->session = client->sessionId;
389 Client_send_message_except(client, sendmsg);
391 list_iterate_safe(itr, save, &client->txMsgQueue) {
392 list_del(&list_get_entry(itr, message_t, node)->node);
393 Msg_free(list_get_entry(itr, message_t, node));
395 Client_codec_free(client);
396 Voicetarget_free_all(client);
397 Client_token_free(client);
399 list_del(&client->node);
401 SSLi_free(client->ssl);
402 close(client->tcpfd);
405 free(client->release);
408 if (client->os_version)
409 free(client->os_version);
410 if (client->username)
411 free(client->username);
413 free(client->context);
416 if (authenticatedLeft)
417 recheckCodecVersions(NULL); /* Can use better codec now? */
420 void Client_close(client_t *client)
422 SSLi_shutdown(client->ssl);
423 client->shutdown_wait = true;
426 void Client_disconnect_all()
428 struct dlist *itr, *save;
430 list_iterate_safe(itr, save, &clients) {
431 Client_free(list_get_entry(itr, client_t, node));
435 int Client_read_fd(int fd)
438 client_t *client = NULL;
440 list_iterate(itr, &clients) {
441 if (fd == list_get_entry(itr, client_t, node)->tcpfd) {
442 client = list_get_entry(itr, client_t, node);
447 return Client_read(client);
452 int Client_read(client_t *client)
456 Timer_restart(&client->lastActivity);
458 if (client->writeBlockedOnRead) {
459 client->writeBlockedOnRead = false;
460 Log_debug("Client_read: writeBlockedOnRead == true");
461 return Client_write(client);
464 if (client->shutdown_wait) {
468 if (!client->SSLready) {
470 rc = SSLi_nonblockaccept(client->ssl, &client->SSLready);
479 if (!client->msgsize)
480 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
482 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
485 client->rxcount += rc;
486 if (!client->msgsize && client->rxcount >= 6) {
488 memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
489 client->msgsize = ntohl(msgLen);
491 if (client->msgsize > BUFSIZE - 6) {
492 /* XXX - figure out how to handle this. A large size here can represent two cases:
493 * 1. A valid size. The only message that is this big is UserState message with a big texture
494 * 2. An invalid size = protocol error, e.g. connecting with a 1.1.x client
496 // Log_warn("Too big message received (%d bytes). Playing safe and disconnecting client %s:%d",
497 // client->msgsize, inet_ntoa(client->remote_tcp.sin_addr), ntohs(client->remote_tcp.sin_port));
500 /* client->rxcount = client->msgsize = 0; */
502 else if (client->rxcount == client->msgsize + 6) { /* Got all of the message */
503 msg = Msg_networkToMessage(client->rxbuf, client->msgsize + 6);
504 /* pass messsage to handler */
506 Mh_handle_message(client, msg);
507 client->rxcount = client->msgsize = 0;
509 } else /* rc <= 0 */ {
510 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
513 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
514 client->readBlockedOnWrite = true;
517 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_ZERO_RETURN ||
518 SSLi_get_error(client->ssl, rc) == 0) {
519 Log_info_client(client, "Connection closed by peer");
520 Client_close(client);
523 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
525 Log_info_client(client, "Connection closed by peer");
527 Log_info_client(client,"Error: %s - Closing connection (code %d)",
530 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
531 Log_info_client(client, "Connection reset by peer");
534 Log_info_client(client, "SSL error: %d - Closing connection", SSLi_get_error(client->ssl, rc));
540 } while (SSLi_data_pending(client->ssl));
545 int Client_write_fd(int fd)
548 client_t *client = NULL;
550 list_iterate(itr, &clients) {
551 if(fd == list_get_entry(itr, client_t, node)->tcpfd) {
552 client = list_get_entry(itr, client_t, node);
557 return Client_write(client);
562 int Client_write(client_t *client)
566 if (client->readBlockedOnWrite) {
567 client->readBlockedOnWrite = false;
568 Log_debug("Client_write: readBlockedOnWrite == true");
569 return Client_read(client);
571 rc = SSLi_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
573 client->txcount += rc;
574 if (client->txcount == client->txsize)
575 client->txsize = client->txcount = 0;
578 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
579 client->writeBlockedOnRead = true;
582 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
586 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
587 Log_info_client(client, "Error: %s - Closing connection", strerror(errno));
589 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
590 Log_info_client(client, "Connection reset by peer");
593 Log_info_client(client, "SSL error: %d - Closing connection.", SSLi_get_error(client->ssl, rc));
599 if (client->txsize == 0 && !list_empty(&client->txMsgQueue)) {
601 msg = list_get_entry(list_get_first(&client->txMsgQueue), message_t, node);
602 list_del(list_get_first(&client->txMsgQueue));
603 client->txQueueCount--;
604 Client_send_message(client, msg);
609 int Client_send_message_ver(client_t *client, message_t *msg, uint32_t version)
611 if ((version == 0) || (client->version >= version) ||
612 ((version & 0x80000000) && (client->version < (~version))))
613 return Client_send_message(client, msg);
619 int Client_send_message(client_t *client, message_t *msg)
621 if (!client->authenticated && msg->messageType != Version) {
625 if (client->txsize != 0 || !client->SSLready) {
627 if ((client->txQueueCount > 5 && msg->messageType == UDPTunnel) ||
628 client->txQueueCount > 30) {
632 client->txQueueCount++;
633 list_add_tail(&msg->node, &client->txMsgQueue);
634 Log_debug("Queueing message");
637 len = Msg_messageToNetwork(msg, client->txbuf);
638 doAssert(len < BUFSIZE);
640 client->txsize = len;
642 Client_write(client);
648 client_t *Client_iterate(client_t **client_itr)
650 client_t *c = *client_itr;
652 if (list_empty(&clients))
656 c = list_get_entry(list_get_first(&clients), client_t, node);
658 if (list_get_next(&c->node) == &clients)
661 c = list_get_entry(list_get_next(&c->node), client_t, node);
667 void Client_textmessage(client_t *client, char *text)
671 message_t *sendmsg = NULL;
673 message = malloc(strlen(text) + 1);
675 Log_fatal("Out of memory");
676 tree_id = malloc(sizeof(uint32_t));
678 Log_fatal("Out of memory");
680 sendmsg = Msg_create(TextMessage);
681 sendmsg->payload.textMessage->message = message;
682 sendmsg->payload.textMessage->n_tree_id = 1;
683 sendmsg->payload.textMessage->tree_id = tree_id;
684 strcpy(message, text);
685 Client_send_message(client, sendmsg);
689 int Client_send_message_except(client_t *client, message_t *msg)
691 client_t *itr = NULL;
694 Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
695 while (Client_iterate(&itr) != NULL) {
698 Msg_inc_ref(msg); /* One extra reference for each new copy */
699 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
700 Client_send_message(itr, msg);
703 Msg_free(msg); /* Free our reference to the message */
706 Msg_free(msg); /* If only 1 client is connected then no message is passed
707 * to Client_send_message(). Free it here. */
712 int Client_send_message_except_ver(client_t *client, message_t *msg, uint32_t version)
714 client_t *itr = NULL;
717 Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
718 while (Client_iterate(&itr) != NULL) {
721 Msg_inc_ref(msg); /* One extra reference for each new copy */
722 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
723 Client_send_message_ver(itr, msg, version);
726 Msg_free(msg); /* Free our reference to the message */
729 Msg_free(msg); /* If only 1 client is connected then no message is passed
730 * to Client_send_message(). Free it here. */
735 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
737 if (CryptState_isValid(&client->cryptState) &&
738 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
741 if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
742 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
744 Timer_restart(&client->cryptState.tLastRequest);
746 sendmsg = Msg_create(CryptSetup);
747 Log_info_client(client, "Requesting voice channel crypt resync");
748 Client_send_message(client, sendmsg);
754 #define UDP_PACKET_SIZE 1024
755 int Client_read_udp(int udpsock)
758 struct sockaddr_storage from;
759 socklen_t fromlen = sizeof(struct sockaddr_storage);
760 uint8_t key[KEY_LENGTH];
762 UDPMessageType_t msgType;
763 uint8_t fromaddress[4 * sizeof(in_addr_t)];
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);
776 memset(key, 0, KEY_LENGTH);
778 fromport = Util_addressToPort(&from);
780 if(from.ss_family == AF_INET) {
781 memcpy(fromaddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
782 memcpy(&key[0], &fromport, 2);
783 memcpy(&key[2], fromaddress, sizeof(in_addr_t));
785 memcpy(fromaddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
786 memcpy(&key[0], &fromport, 2);
787 memcpy(&key[2], fromaddress, 4 * sizeof(in_addr_t));
792 else if (len < 5 || len > UDP_PACKET_SIZE) /* 4 bytes crypt header + type + session */
796 * Reply to ping packet
797 * The second and third uint32_t are the timestamp, which will be returned unmodified
799 if (len == 12 && *encrypted == 0) {
800 uint32_t *ping = (uint32_t *)encrypted;
801 ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
802 ping[3] = htonl((uint32_t)clientcount);
803 ping[4] = htonl((uint32_t)getIntConf(MAX_CLIENTS));
804 ping[5] = htonl((uint32_t)getIntConf(MAX_BANDWIDTH));
806 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
812 while (Client_iterate(&itr) != NULL) {
813 if (memcmp(itr->key, key, KEY_LENGTH) == 0) {
814 if (!checkDecrypt(itr, encrypted, buffer, len))
819 if (itr == NULL) { /* Unknown peer */
820 struct sockaddr_storage itraddressstorage;
821 uint8_t itraddress[4 * sizeof(in_addr_t)];
824 while (Client_iterate(&itr) != NULL) {
825 itraddressstorage = itr->remote_tcp;
826 if(itraddressstorage.ss_family == AF_INET) {
827 memcpy(itraddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
828 addresslength = sizeof(in_addr_t);
830 memcpy(itraddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
831 addresslength = 4 * sizeof(in_addr_t);
834 if (memcmp(itraddress, fromaddress, addresslength) == 0) {
835 if (checkDecrypt(itr, encrypted, buffer, len)) {
836 memcpy(itr->key, key, KEY_LENGTH);
837 Log_info_client(itr, "New UDP connection from %s on port %d", Util_clientAddressToString(itr), fromport);
838 memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_storage));
844 if (itr == NULL) { /* Couldn't find this peer among connected clients */
849 len -= 4; /* Adjust for crypt header */
850 msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
853 case UDPVoiceCELTAlpha:
854 case UDPVoiceCELTBeta:
858 Client_voiceMsg(itr, buffer, len);
861 Log_debug("UDP Ping reply len %d", len);
862 Client_send_udp(itr, buffer, len);
865 Log_debug("Unknown UDP message type from %s port %d", Util_clientAddressToString(itr), fromport);
873 static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
875 if (IS_AUTH(dst) && dst != src && !dst->deaf && !dst->self_deaf) {
876 if (poslen > 0 && /* Has positional data */
877 src->context != NULL && dst->context != NULL && /* ...both source and destination has context */
878 strcmp(src->context, dst->context) == 0) /* ...and the contexts match */
879 Client_send_udp(dst, data, len);
881 Client_send_udp(dst, data, len - poslen);
885 /* Handle decrypted voice message */
886 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
888 uint8_t buffer[UDP_PACKET_SIZE];
889 pds_t *pdi = Pds_create(data + 1, len - 1);
890 pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
891 unsigned int type = data[0] & 0xe0;
892 unsigned int target = data[0] & 0x1f;
893 unsigned int poslen, counter, size;
894 int offset, packetsize;
897 channel_t *ch = (channel_t *)client->channel;
900 if (!client->authenticated || client->mute || client->self_mute || ch->silent)
903 packetsize = 20 + 8 + 4 + len;
904 if (client->availableBandwidth - packetsize < 0)
905 goto out; /* Discard */
906 client->availableBandwidth -= packetsize;
908 Timer_restart(&client->idleTime);
909 Timer_restart(&client->lastActivity);
911 counter = Pds_get_numval(pdi); /* step past session id */
912 if ((type >> 5) != UDPVoiceOpus) {
914 counter = Pds_next8(pdi);
915 offset = Pds_skip(pdi, counter & 0x7f);
916 } while ((counter & 0x80) && offset > 0);
918 size = Pds_get_numval(pdi);
919 Pds_skip(pdi, size & 0x1fff);
922 poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
924 Pds_add_numval(pds, client->sessionId);
925 Pds_append_data_nosize(pds, data + 1, len - 1);
927 if (target == 0x1f) { /* Loopback */
928 buffer[0] = (uint8_t) type;
929 Client_send_udp(client, buffer, pds->offset + 1);
931 else if (target == 0) { /* regular channel speech */
932 buffer[0] = (uint8_t) type;
937 list_iterate(itr, &ch->clients) {
939 c = list_get_entry(itr, client_t, chan_node);
940 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
942 } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
946 for (i = 0; i < TARGET_MAX_CHANNELS && vt->channels[i].channel != -1; i++) {
947 buffer[0] = (uint8_t) (type | 1);
948 Log_debug("Whisper channel %d", vt->channels[i]);
949 ch = Chan_fromId(vt->channels[i].channel);
952 list_iterate(itr, &ch->clients) {
954 c = list_get_entry(itr, client_t, chan_node);
955 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
958 if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
959 struct dlist *ch_itr;
960 list_iterate(ch_itr, &ch->channel_links) {
962 ch_link = list_get_entry(ch_itr, channel_t, link_node);
963 list_iterate(itr, &ch_link->clients) {
965 c = list_get_entry(itr, client_t, chan_node);
966 Log_debug("Linked voice from %s -> %s", ch->name, ch_link->name);
967 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
972 if (vt->channels[i].children) {
973 struct dlist chanlist, *ch_itr;
974 init_list_entry(&chanlist);
975 Chan_buildTreeList(ch, &chanlist);
976 list_iterate(ch_itr, &chanlist) {
978 sub = list_get_entry(ch_itr, channellist_t, node)->chan;
979 list_iterate(itr, &sub->clients) {
981 c = list_get_entry(itr, client_t, chan_node);
982 Log_debug("Child voice from %s -> %s", ch->name, sub->name);
983 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
986 Chan_freeTreeList(&chanlist);
990 for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
992 buffer[0] = (uint8_t) (type | 2);
993 Log_debug("Whisper session %d", vt->sessions[i]);
994 while (Client_iterate(&c) != NULL) {
995 if (c->sessionId == vt->sessions[i]) {
996 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
1009 static int Client_send_udp(client_t *client, uint8_t *data, int len)
1011 uint8_t *buf, *mbuf;
1013 int udpsock = (client->remote_udp.ss_family == AF_INET) ? udpsocks[0] : udpsocks[(hasv4) ? 1 : 0];
1015 if (Util_clientAddressToPortUDP(client) != 0 && CryptState_isValid(&client->cryptState) &&
1017 #if defined(__LP64__)
1018 buf = mbuf = malloc(len + 4 + 16);
1021 mbuf = buf = malloc(len + 4);
1024 Log_fatal("Out of memory");
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);