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_safeMalloc(1, sizeof(codec_t));
228 memset(cd, 0, sizeof(codec_t));
229 init_list_entry(&cd->node);
230 cd->codec = codec_itr->codec;
232 list_add_tail(&cd->node, &codec_list);
236 if (client_itr->bOpus)
242 enableOpus = ((opus * 100 / users) >= getIntConf(OPUS_THRESHOLD));
244 list_iterate(itr, &codec_list) {
245 cd = list_get_entry(itr, codec_t, node);
246 if (cd->count > max) {
251 list_iterate_safe(itr, save, &codec_list) {
252 list_del(&list_get_entry(itr, codec_t, node)->node);
253 free(list_get_entry(itr, codec_t, node));
256 current_version = bPreferAlpha ? iCodecAlpha : iCodecBeta;
257 if (current_version != version) {
258 // If we don't already use the compat bitstream version set
259 // it as alpha and announce it. If another codec now got the
260 // majority set it as the opposite of the currently valid bPreferAlpha
262 if (version == (uint32_t)0x8000000b)
265 bPreferAlpha = !bPreferAlpha;
268 iCodecAlpha = version;
270 iCodecBeta = version;
271 } else if (bOpus && enableOpus) {
272 if (connectingClient && !connectingClient->bOpus)
273 Client_textmessage(connectingClient, OPUS_WARN_USING);
277 sendmsg = Msg_create(CodecVersion);
278 sendmsg->payload.codecVersion->alpha = iCodecAlpha;
279 sendmsg->payload.codecVersion->beta = iCodecBeta;
280 sendmsg->payload.codecVersion->prefer_alpha = bPreferAlpha;
281 sendmsg->payload.codecVersion->has_opus = true;
282 sendmsg->payload.codecVersion->opus = enableOpus;
284 Client_send_message_except(NULL, sendmsg);
286 if (enableOpus && !bOpus) {
288 while (Client_iterate(&client_itr) != NULL) {
289 if ((client_itr->authenticated || client_itr == connectingClient) &&
290 !client_itr->bOpus) {
291 Client_textmessage(client_itr, OPUS_WARN_SWITCHING);
294 Log_info("OPUS codec %s", bOpus ? "enabled" : "disabled");
300 static int findFreeSessionId()
303 client_t *itr = NULL;
305 for (id = 1; id < INT_MAX; id++) {
307 while ((itr = Client_iterate(&itr)) != NULL) {
308 if (itr->sessionId == id)
311 if (itr == NULL) /* Found free id */
317 int Client_add(int fd, struct sockaddr_storage *remote)
321 char* addressString = NULL;
323 if (Ban_isBannedAddr(remote)) {
324 addressString = Util_addressToString(remote);
325 Log_info("Address %s banned. Disconnecting", addressString);
330 newclient = Memory_safeCalloc(1, sizeof(client_t));
332 newclient->tcpfd = fd;
333 memcpy(&newclient->remote_tcp, remote, sizeof(struct sockaddr_storage));
334 newclient->ssl = SSLi_newconnection(&newclient->tcpfd, &newclient->SSLready);
335 if (newclient->ssl == NULL) {
336 addressString = Util_addressToString(remote);
337 Log_warn("SSL negotiation failed with %s on port %d", addressString, Util_addressToPort(remote));
342 newclient->availableBandwidth = maxBandwidth;
343 Timer_init(&newclient->lastActivity);
344 Timer_init(&newclient->connectTime);
345 Timer_init(&newclient->idleTime);
346 newclient->sessionId = findFreeSessionId();
347 if (newclient->sessionId < 0)
348 Log_fatal("Could not find a free session ID");
350 init_list_entry(&newclient->txMsgQueue);
351 init_list_entry(&newclient->chan_node);
352 init_list_entry(&newclient->node);
353 init_list_entry(&newclient->voicetargets);
354 init_list_entry(&newclient->codecs);
355 init_list_entry(&newclient->tokens);
357 list_add_tail(&newclient->node, &clients);
360 /* Send version message to client */
361 sendmsg = Msg_create(Version);
362 sendmsg->payload.version->has_version = true;
363 sendmsg->payload.version->version = PROTOCOL_VERSION;
364 sendmsg->payload.version->release = strdup(UMURMUR_VERSION);
365 sendmsg->payload.version->os = strdup(system_string);
366 sendmsg->payload.version->os_version = strdup(version_string);
367 Client_send_message(newclient, sendmsg);
372 void Client_free(client_t *client)
374 struct dlist *itr, *save;
376 bool_t authenticatedLeft = client->authenticated;
378 if (client->authenticated) {
380 leave_id = Chan_userLeave(client);
381 if (leave_id > 0) { /* Remove temp channel */
382 sendmsg = Msg_create(ChannelRemove);
383 sendmsg->payload.channelRemove->channel_id = leave_id;
384 Client_send_message_except(client, sendmsg);
386 sendmsg = Msg_create(UserRemove);
387 sendmsg->payload.userRemove->session = client->sessionId;
388 Client_send_message_except(client, sendmsg);
390 list_iterate_safe(itr, save, &client->txMsgQueue) {
391 list_del(&list_get_entry(itr, message_t, node)->node);
392 Msg_free(list_get_entry(itr, message_t, node));
394 Client_codec_free(client);
395 Voicetarget_free_all(client);
396 Client_token_free(client);
398 list_del(&client->node);
400 SSLi_free(client->ssl);
401 close(client->tcpfd);
404 free(client->release);
407 if (client->os_version)
408 free(client->os_version);
409 if (client->username)
410 free(client->username);
412 free(client->context);
415 if (authenticatedLeft)
416 recheckCodecVersions(NULL); /* Can use better codec now? */
419 void Client_close(client_t *client)
421 SSLi_shutdown(client->ssl);
422 client->shutdown_wait = true;
425 void Client_disconnect_all()
427 struct dlist *itr, *save;
429 list_iterate_safe(itr, save, &clients) {
430 Client_free(list_get_entry(itr, client_t, node));
434 int Client_read_fd(int fd)
437 client_t *client = NULL;
439 list_iterate(itr, &clients) {
440 if (fd == list_get_entry(itr, client_t, node)->tcpfd) {
441 client = list_get_entry(itr, client_t, node);
446 return Client_read(client);
451 int Client_read(client_t *client)
455 Timer_restart(&client->lastActivity);
457 if (client->writeBlockedOnRead) {
458 client->writeBlockedOnRead = false;
459 Log_debug("Client_read: writeBlockedOnRead == true");
460 return Client_write(client);
463 if (client->shutdown_wait) {
467 if (!client->SSLready) {
469 rc = SSLi_nonblockaccept(client->ssl, &client->SSLready);
478 if (!client->msgsize)
479 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
481 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
484 client->rxcount += rc;
485 if (!client->msgsize && client->rxcount >= 6) {
487 memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
488 client->msgsize = ntohl(msgLen);
490 if (client->msgsize > BUFSIZE - 6) {
491 /* XXX - figure out how to handle this. A large size here can represent two cases:
492 * 1. A valid size. The only message that is this big is UserState message with a big texture
493 * 2. An invalid size = protocol error, e.g. connecting with a 1.1.x client
495 // Log_warn("Too big message received (%d bytes). Playing safe and disconnecting client %s:%d",
496 // client->msgsize, inet_ntoa(client->remote_tcp.sin_addr), ntohs(client->remote_tcp.sin_port));
499 /* client->rxcount = client->msgsize = 0; */
501 else if (client->rxcount == client->msgsize + 6) { /* Got all of the message */
502 msg = Msg_networkToMessage(client->rxbuf, client->msgsize + 6);
503 /* pass messsage to handler */
505 Mh_handle_message(client, msg);
506 client->rxcount = client->msgsize = 0;
508 } else /* rc <= 0 */ {
509 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
512 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
513 client->readBlockedOnWrite = true;
516 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_ZERO_RETURN ||
517 SSLi_get_error(client->ssl, rc) == 0) {
518 Log_info_client(client, "Connection closed by peer");
519 Client_close(client);
522 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
524 Log_info_client(client, "Connection closed by peer");
526 Log_info_client(client,"Error: %s - Closing connection (code %d)",
529 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
530 Log_info_client(client, "Connection reset by peer");
533 Log_info_client(client, "SSL error: %d - Closing connection", SSLi_get_error(client->ssl, rc));
539 } while (SSLi_data_pending(client->ssl));
544 int Client_write_fd(int fd)
547 client_t *client = NULL;
549 list_iterate(itr, &clients) {
550 if(fd == list_get_entry(itr, client_t, node)->tcpfd) {
551 client = list_get_entry(itr, client_t, node);
556 return Client_write(client);
561 int Client_write(client_t *client)
565 if (client->readBlockedOnWrite) {
566 client->readBlockedOnWrite = false;
567 Log_debug("Client_write: readBlockedOnWrite == true");
568 return Client_read(client);
570 rc = SSLi_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
572 client->txcount += rc;
573 if (client->txcount == client->txsize)
574 client->txsize = client->txcount = 0;
577 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
578 client->writeBlockedOnRead = true;
581 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
585 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
586 Log_info_client(client, "Error: %s - Closing connection", strerror(errno));
588 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
589 Log_info_client(client, "Connection reset by peer");
592 Log_info_client(client, "SSL error: %d - Closing connection.", SSLi_get_error(client->ssl, rc));
598 if (client->txsize == 0 && !list_empty(&client->txMsgQueue)) {
600 msg = list_get_entry(list_get_first(&client->txMsgQueue), message_t, node);
601 list_del(list_get_first(&client->txMsgQueue));
602 client->txQueueCount--;
603 Client_send_message(client, msg);
608 int Client_send_message_ver(client_t *client, message_t *msg, uint32_t version)
610 if ((version == 0) || (client->version >= version) ||
611 ((version & 0x80000000) && (client->version < (~version))))
612 return Client_send_message(client, msg);
618 int Client_send_message(client_t *client, message_t *msg)
620 if (!client->authenticated && msg->messageType != Version) {
624 if (client->txsize != 0 || !client->SSLready) {
626 if ((client->txQueueCount > 5 && msg->messageType == UDPTunnel) ||
627 client->txQueueCount > 30) {
631 client->txQueueCount++;
632 list_add_tail(&msg->node, &client->txMsgQueue);
633 Log_debug("Queueing message");
636 len = Msg_messageToNetwork(msg, client->txbuf);
637 doAssert(len < BUFSIZE);
639 client->txsize = len;
641 Client_write(client);
647 client_t *Client_iterate(client_t **client_itr)
649 client_t *c = *client_itr;
651 if (list_empty(&clients))
655 c = list_get_entry(list_get_first(&clients), client_t, node);
657 if (list_get_next(&c->node) == &clients)
660 c = list_get_entry(list_get_next(&c->node), client_t, node);
666 void Client_textmessage(client_t *client, char *text)
670 message_t *sendmsg = NULL;
672 message = Memory_safeMalloc(1, strlen(text) + 1);
673 tree_id = Memory_safeMalloc(1, sizeof(uint32_t));
675 sendmsg = Msg_create(TextMessage);
676 sendmsg->payload.textMessage->message = message;
677 sendmsg->payload.textMessage->n_tree_id = 1;
678 sendmsg->payload.textMessage->tree_id = tree_id;
679 strcpy(message, text);
680 Client_send_message(client, sendmsg);
684 int Client_send_message_except(client_t *client, message_t *msg)
686 client_t *itr = NULL;
689 Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
690 while (Client_iterate(&itr) != NULL) {
693 Msg_inc_ref(msg); /* One extra reference for each new copy */
694 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
695 Client_send_message(itr, msg);
698 Msg_free(msg); /* Free our reference to the message */
701 Msg_free(msg); /* If only 1 client is connected then no message is passed
702 * to Client_send_message(). Free it here. */
707 int Client_send_message_except_ver(client_t *client, message_t *msg, uint32_t version)
709 client_t *itr = NULL;
712 Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
713 while (Client_iterate(&itr) != NULL) {
716 Msg_inc_ref(msg); /* One extra reference for each new copy */
717 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
718 Client_send_message_ver(itr, msg, version);
721 Msg_free(msg); /* Free our reference to the message */
724 Msg_free(msg); /* If only 1 client is connected then no message is passed
725 * to Client_send_message(). Free it here. */
730 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
732 if (CryptState_isValid(&client->cryptState) &&
733 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
736 if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
737 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
739 Timer_restart(&client->cryptState.tLastRequest);
741 sendmsg = Msg_create(CryptSetup);
742 Log_info_client(client, "Requesting voice channel crypt resync");
743 Client_send_message(client, sendmsg);
749 #define UDP_PACKET_SIZE 1024
750 int Client_read_udp(int udpsock)
753 struct sockaddr_storage from;
754 socklen_t fromlen = sizeof(struct sockaddr_storage);
755 uint8_t key[KEY_LENGTH];
757 UDPMessageType_t msgType;
758 uint8_t fromaddress[4 * sizeof(in_addr_t)];
761 #if defined(__LP64__)
762 uint8_t encbuff[UDP_PACKET_SIZE + 8];
763 uint8_t *encrypted = encbuff + 4;
765 uint8_t encrypted[UDP_PACKET_SIZE];
767 uint8_t buffer[UDP_PACKET_SIZE];
769 len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
771 memset(key, 0, KEY_LENGTH);
773 fromport = Util_addressToPort(&from);
775 if(from.ss_family == AF_INET) {
776 memcpy(fromaddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
777 memcpy(&key[0], &fromport, 2);
778 memcpy(&key[2], fromaddress, sizeof(in_addr_t));
780 memcpy(fromaddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
781 memcpy(&key[0], &fromport, 2);
782 memcpy(&key[2], fromaddress, 4 * sizeof(in_addr_t));
787 else if (len < 5 || len > UDP_PACKET_SIZE) /* 4 bytes crypt header + type + session */
791 * Reply to ping packet
792 * The second and third uint32_t are the timestamp, which will be returned unmodified
794 if (len == 12 && *encrypted == 0) {
795 uint32_t *ping = (uint32_t *)encrypted;
796 ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
797 ping[3] = htonl((uint32_t)clientcount);
798 ping[4] = htonl((uint32_t)getIntConf(MAX_CLIENTS));
799 ping[5] = htonl((uint32_t)getIntConf(MAX_BANDWIDTH));
801 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
807 while (Client_iterate(&itr) != NULL) {
808 if (memcmp(itr->key, key, KEY_LENGTH) == 0) {
809 if (!checkDecrypt(itr, encrypted, buffer, len))
814 if (itr == NULL) { /* Unknown peer */
815 struct sockaddr_storage itraddressstorage;
816 uint8_t itraddress[4 * sizeof(in_addr_t)];
819 while (Client_iterate(&itr) != NULL) {
820 itraddressstorage = itr->remote_tcp;
821 if(itraddressstorage.ss_family == AF_INET) {
822 memcpy(itraddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
823 addresslength = sizeof(in_addr_t);
825 memcpy(itraddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
826 addresslength = 4 * sizeof(in_addr_t);
829 if (memcmp(itraddress, fromaddress, addresslength) == 0) {
830 if (checkDecrypt(itr, encrypted, buffer, len)) {
831 memcpy(itr->key, key, KEY_LENGTH);
832 char* clientAddressString = Util_clientAddressToString(itr);
833 Log_info_client(itr, "New UDP connection from %s on port %d", clientAddressString, fromport);
834 free(clientAddressString);
835 memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_storage));
841 if (itr == NULL) { /* Couldn't find this peer among connected clients */
846 len -= 4; /* Adjust for crypt header */
847 msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
849 char *clientAddressString = NULL;
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 clientAddressString = Util_clientAddressToString(itr);
866 Log_debug("Unknown UDP message type from %s port %d", clientAddressString, fromport);
867 free(clientAddressString);
875 static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
877 if (IS_AUTH(dst) && dst != src && !dst->deaf && !dst->self_deaf) {
878 if (poslen > 0 && /* Has positional data */
879 src->context != NULL && dst->context != NULL && /* ...both source and destination has context */
880 strcmp(src->context, dst->context) == 0) /* ...and the contexts match */
881 Client_send_udp(dst, data, len);
883 Client_send_udp(dst, data, len - poslen);
887 /* Handle decrypted voice message */
888 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
890 uint8_t buffer[UDP_PACKET_SIZE];
891 pds_t *pdi = Pds_create(data + 1, len - 1);
892 pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
893 unsigned int type = data[0] & 0xe0;
894 unsigned int target = data[0] & 0x1f;
895 unsigned int poslen, counter, size;
896 int offset, packetsize;
899 channel_t *ch = (channel_t *)client->channel;
902 if (!client->authenticated || client->mute || client->self_mute || ch->silent)
905 packetsize = 20 + 8 + 4 + len;
906 if (client->availableBandwidth - packetsize < 0)
907 goto out; /* Discard */
908 client->availableBandwidth -= packetsize;
910 Timer_restart(&client->idleTime);
911 Timer_restart(&client->lastActivity);
913 counter = Pds_get_numval(pdi); /* step past session id */
914 if ((type >> 5) != UDPVoiceOpus) {
916 counter = Pds_next8(pdi);
917 offset = Pds_skip(pdi, counter & 0x7f);
918 } while ((counter & 0x80) && offset > 0);
920 size = Pds_get_numval(pdi);
921 Pds_skip(pdi, size & 0x1fff);
924 poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
926 Pds_add_numval(pds, client->sessionId);
927 Pds_append_data_nosize(pds, data + 1, len - 1);
929 if (target == 0x1f) { /* Loopback */
930 buffer[0] = (uint8_t) type;
931 Client_send_udp(client, buffer, pds->offset + 1);
933 else if (target == 0) { /* regular channel speech */
934 buffer[0] = (uint8_t) type;
939 list_iterate(itr, &ch->clients) {
941 c = list_get_entry(itr, client_t, chan_node);
942 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
944 } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
948 for (i = 0; i < TARGET_MAX_CHANNELS && vt->channels[i].channel != -1; i++) {
949 buffer[0] = (uint8_t) (type | 1);
950 Log_debug("Whisper channel %d", vt->channels[i]);
951 ch = Chan_fromId(vt->channels[i].channel);
954 list_iterate(itr, &ch->clients) {
956 c = list_get_entry(itr, client_t, chan_node);
957 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
960 if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
961 struct dlist *ch_itr;
962 list_iterate(ch_itr, &ch->channel_links) {
965 chl = list_get_entry(ch_itr, channellist_t, node);
967 list_iterate(itr, &ch_link->clients) {
969 c = list_get_entry(itr, client_t, chan_node);
970 Log_debug("Linked voice from %s -> %s", ch->name, ch_link->name);
971 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
976 if (vt->channels[i].children) {
977 struct dlist chanlist, *ch_itr;
978 init_list_entry(&chanlist);
979 Chan_buildTreeList(ch, &chanlist);
980 list_iterate(ch_itr, &chanlist) {
982 sub = list_get_entry(ch_itr, channellist_t, node)->chan;
983 list_iterate(itr, &sub->clients) {
985 c = list_get_entry(itr, client_t, chan_node);
986 Log_debug("Child voice from %s -> %s", ch->name, sub->name);
987 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
990 Chan_freeTreeList(&chanlist);
994 for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
996 buffer[0] = (uint8_t) (type | 2);
997 Log_debug("Whisper session %d", vt->sessions[i]);
998 while (Client_iterate(&c) != NULL) {
999 if (c->sessionId == vt->sessions[i]) {
1000 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
1013 static int Client_send_udp(client_t *client, uint8_t *data, int len)
1015 uint8_t *buf, *mbuf;
1017 int udpsock = (client->remote_udp.ss_family == AF_INET) ? udpsocks[0] : udpsocks[(hasv4) ? 1 : 0];
1019 if (Util_clientAddressToPortUDP(client) != 0 && CryptState_isValid(&client->cryptState) &&
1021 #if defined(__LP64__)
1022 buf = mbuf = Memory_safeMalloc(1, len + 4 + 16);
1025 mbuf = buf = Memory_safeMalloc(1, len + 4);
1027 CryptState_encrypt(&client->cryptState, data, buf, len);
1029 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
1030 sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, client->remote_tcp.ss_len);
1032 sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, sizeof(struct sockaddr_storage));
1038 msg = Msg_CreateVoiceMsg(data, len);
1039 Client_send_message(client, msg);