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"
50 extern char system_string[], version_string[];
52 static int Client_read(client_t *client);
53 static int Client_write(client_t *client);
54 static int Client_send_udp(client_t *client, uint8_t *data, int len);
55 void Client_free(client_t *client);
57 declare_list(clients);
58 static int clientcount; /* = 0 */
59 static int maxBandwidth;
62 int iCodecAlpha, iCodecBeta;
69 maxBandwidth = getIntConf(MAX_BANDWIDTH) / 8; /* From bits/s -> bytes/s */
77 int Client_getfds(struct pollfd *pollfds)
81 list_iterate(itr, &clients) {
83 c = list_get_entry(itr, client_t, node);
84 pollfds[i].fd = c->tcpfd;
85 pollfds[i].events = POLLIN | POLLHUP | POLLERR;
86 if (c->txsize > 0 || c->readBlockedOnWrite) /* Data waiting to be sent? */
87 pollfds[i].events |= POLLOUT;
95 struct dlist *itr, *save;
96 int bwTop = maxBandwidth + maxBandwidth / 4;
97 list_iterate_safe(itr, save, &clients) {
99 c = list_get_entry(itr, client_t, node);
100 Log_debug("Client %s BW available %d", c->username, c->availableBandwidth);
101 c->availableBandwidth += maxBandwidth;
102 if (c->availableBandwidth > bwTop)
103 c->availableBandwidth = bwTop;
105 if (Timer_isElapsed(&c->lastActivity, 1000000LL * INACTIVITY_TIMEOUT)) {
106 /* No activity from client - assume it is lost and close. */
107 Log_info_client(c, "Timeout, closing.");
114 void Client_codec_add(client_t *client, int codec)
116 codec_t *cd = malloc(sizeof(codec_t));
118 Log_fatal("Out of memory");
119 init_list_entry(&cd->node);
121 list_add_tail(&cd->node, &client->codecs);
124 void Client_codec_free(client_t *client)
126 struct dlist *itr, *save;
127 list_iterate_safe(itr, save, &client->codecs) {
128 list_del(&list_get_entry(itr, codec_t, node)->node);
129 free(list_get_entry(itr, codec_t, node));
133 codec_t *Client_codec_iterate(client_t *client, codec_t **codec_itr)
135 codec_t *cd = *codec_itr;
137 if (list_empty(&client->codecs))
141 cd = list_get_entry(list_get_first(&client->codecs), codec_t, node);
143 if (list_get_next(&cd->node) == &client->codecs)
146 cd = list_get_entry(list_get_next(&cd->node), codec_t, node);
152 void Client_token_add(client_t *client, char *token_string)
156 if (client->tokencount >= MAX_TOKENS)
158 token = malloc(sizeof(token_t));
160 Log_fatal("Out of memory");
161 init_list_entry(&token->node);
162 token->token = strdup(token_string);
163 if (token->token == NULL)
164 Log_fatal("Out of memory");
165 list_add_tail(&token->node, &client->tokens);
166 client->tokencount++;
169 bool_t Client_token_match(client_t *client, char *str)
174 if (list_empty(&client->tokens))
176 list_iterate(itr, &client->tokens) {
177 token = list_get_entry(itr, token_t, node);
178 if (strncasecmp(token->token, str, MAX_TOKENSIZE) == 0)
184 void Client_token_free(client_t *client)
186 struct dlist *itr, *save;
189 list_iterate_safe(itr, save, &client->tokens) {
190 token = list_get_entry(itr, token_t, node);
191 list_del(&token->node);
195 client->tokencount = 0;
199 #define OPUS_WARN_USING "<strong>WARNING:</strong> Your client doesn't support the Opus codec the server is using, you won't be able to talk or hear anyone. Please upgrade your Mumble client."
200 #define OPUS_WARN_SWITCHING "<strong>WARNING:</strong> Your client doesn't support the Opus codec the server is switching to, you won't be able to talk or hear anyone. Please upgrade your Mumble client."
201 void recheckCodecVersions(client_t *connectingClient)
203 client_t *client_itr = NULL;
204 int max = 0, version, current_version;
205 int users = 0, opus = 0;
207 struct dlist codec_list, *itr, *save;
208 codec_t *codec_itr, *cd;
212 init_list_entry(&codec_list);
214 while (Client_iterate(&client_itr) != NULL) {
216 if (client_itr->codec_count == 0 && !client_itr->bOpus)
218 while (Client_codec_iterate(client_itr, &codec_itr) != NULL) {
220 list_iterate(itr, &codec_list) {
221 cd = list_get_entry(itr, codec_t, node);
222 if (cd->codec == codec_itr->codec) {
228 cd = malloc(sizeof(codec_t));
230 Log_fatal("Out of memory");
231 memset(cd, 0, sizeof(codec_t));
232 init_list_entry(&cd->node);
233 cd->codec = codec_itr->codec;
235 list_add_tail(&cd->node, &codec_list);
239 if (client_itr->bOpus)
245 enableOpus = ((opus * 100 / users) >= getIntConf(OPUS_THRESHOLD));
247 list_iterate(itr, &codec_list) {
248 cd = list_get_entry(itr, codec_t, node);
249 if (cd->count > max) {
254 list_iterate_safe(itr, save, &codec_list) {
255 list_del(&list_get_entry(itr, codec_t, node)->node);
256 free(list_get_entry(itr, codec_t, node));
259 current_version = bPreferAlpha ? iCodecAlpha : iCodecBeta;
260 if (current_version != version) {
261 // If we don't already use the compat bitstream version set
262 // it as alpha and announce it. If another codec now got the
263 // majority set it as the opposite of the currently valid bPreferAlpha
265 if (version == (uint32_t)0x8000000b)
268 bPreferAlpha = !bPreferAlpha;
271 iCodecAlpha = version;
273 iCodecBeta = version;
274 } else if (bOpus && enableOpus) {
275 if (connectingClient && !connectingClient->bOpus)
276 Client_textmessage(connectingClient, OPUS_WARN_USING);
280 sendmsg = Msg_create(CodecVersion);
281 sendmsg->payload.codecVersion->alpha = iCodecAlpha;
282 sendmsg->payload.codecVersion->beta = iCodecBeta;
283 sendmsg->payload.codecVersion->prefer_alpha = bPreferAlpha;
284 sendmsg->payload.codecVersion->has_opus = true;
285 sendmsg->payload.codecVersion->opus = enableOpus;
287 Client_send_message_except(NULL, sendmsg);
289 if (enableOpus && !bOpus) {
291 while (Client_iterate(&client_itr) != NULL) {
292 if ((client_itr->authenticated || client_itr == connectingClient) &&
293 !client_itr->bOpus) {
294 Client_textmessage(client_itr, OPUS_WARN_SWITCHING);
297 Log_info("OPUS codec %s", bOpus ? "enabled" : "disabled");
303 static int findFreeSessionId()
306 client_t *itr = NULL;
308 for (id = 1; id < INT_MAX; id++) {
310 while ((itr = Client_iterate(&itr)) != NULL) {
311 if (itr->sessionId == id)
314 if (itr == NULL) /* Found free id */
320 int Client_add(int fd, struct sockaddr_storage *remote)
324 char addressPresentation[INET6_ADDRSTRLEN];
327 #warning FIX BANNING BEFORE RELEASE
329 if (Ban_isBannedAddr((in_addr_t *)&remote->sin_addr)) {
330 Log_info("Address %s banned. Disconnecting", inet_ntoa(remote->sin_addr));
335 if ((newclient = calloc(1, sizeof(client_t))) == NULL)
336 Log_fatal("Out of memory (%s:%s)", __FILE__, __LINE__);
338 if(remote->ss_family == AF_INET) {
339 inet_ntop(AF_INET, &((struct sockaddr_in*)remote)->sin_addr, addressPresentation, INET6_ADDRSTRLEN);
340 port = ntohs(((struct sockaddr_in*)remote)->sin_port);
342 inet_ntop(AF_INET6, &((struct sockaddr_in6*)remote)->sin6_addr, addressPresentation, INET6_ADDRSTRLEN);
343 port = ntohs(((struct sockaddr_in6*)remote)->sin6_port);
346 memcpy(newclient->addressString, addressPresentation, INET6_ADDRSTRLEN);
348 newclient->tcpfd = fd;
349 memcpy(&newclient->remote_tcp, remote, sizeof(struct sockaddr_storage));
350 newclient->ssl = SSLi_newconnection(&newclient->tcpfd, &newclient->SSLready);
351 if (newclient->ssl == NULL) {
352 Log_warn("SSL negotiation failed with %s on port %d", addressPresentation, port);
356 newclient->availableBandwidth = maxBandwidth;
357 Timer_init(&newclient->lastActivity);
358 Timer_init(&newclient->connectTime);
359 Timer_init(&newclient->idleTime);
360 newclient->sessionId = findFreeSessionId();
361 if (newclient->sessionId < 0)
362 Log_fatal("Could not find a free session ID");
364 init_list_entry(&newclient->txMsgQueue);
365 init_list_entry(&newclient->chan_node);
366 init_list_entry(&newclient->node);
367 init_list_entry(&newclient->voicetargets);
368 init_list_entry(&newclient->codecs);
369 init_list_entry(&newclient->tokens);
371 list_add_tail(&newclient->node, &clients);
374 /* Send version message to client */
375 sendmsg = Msg_create(Version);
376 sendmsg->payload.version->has_version = true;
377 sendmsg->payload.version->version = PROTOCOL_VERSION;
378 sendmsg->payload.version->release = strdup(UMURMUR_VERSION);
379 sendmsg->payload.version->os = strdup(system_string);
380 sendmsg->payload.version->os_version = strdup(version_string);
381 Client_send_message(newclient, sendmsg);
386 void Client_free(client_t *client)
388 struct dlist *itr, *save;
390 bool_t authenticatedLeft = client->authenticated;
392 if (client->authenticated) {
394 leave_id = Chan_userLeave(client);
395 if (leave_id > 0) { /* Remove temp channel */
396 sendmsg = Msg_create(ChannelRemove);
397 sendmsg->payload.channelRemove->channel_id = leave_id;
398 Client_send_message_except(client, sendmsg);
400 sendmsg = Msg_create(UserRemove);
401 sendmsg->payload.userRemove->session = client->sessionId;
402 Client_send_message_except(client, sendmsg);
404 list_iterate_safe(itr, save, &client->txMsgQueue) {
405 list_del(&list_get_entry(itr, message_t, node)->node);
406 Msg_free(list_get_entry(itr, message_t, node));
408 Client_codec_free(client);
409 Voicetarget_free_all(client);
410 Client_token_free(client);
412 list_del(&client->node);
414 SSLi_free(client->ssl);
415 close(client->tcpfd);
418 free(client->release);
421 if (client->os_version)
422 free(client->os_version);
423 if (client->username)
424 free(client->username);
426 free(client->context);
429 if (authenticatedLeft)
430 recheckCodecVersions(NULL); /* Can use better codec now? */
433 void Client_close(client_t *client)
435 SSLi_shutdown(client->ssl);
436 client->shutdown_wait = true;
439 void Client_disconnect_all()
441 struct dlist *itr, *save;
443 list_iterate_safe(itr, save, &clients) {
444 Client_free(list_get_entry(itr, client_t, node));
448 int Client_read_fd(int fd)
451 client_t *client = NULL;
453 list_iterate(itr, &clients) {
454 if (fd == list_get_entry(itr, client_t, node)->tcpfd) {
455 client = list_get_entry(itr, client_t, node);
460 return Client_read(client);
465 int Client_read(client_t *client)
469 Timer_restart(&client->lastActivity);
471 if (client->writeBlockedOnRead) {
472 client->writeBlockedOnRead = false;
473 Log_debug("Client_read: writeBlockedOnRead == true");
474 return Client_write(client);
477 if (client->shutdown_wait) {
481 if (!client->SSLready) {
483 rc = SSLi_nonblockaccept(client->ssl, &client->SSLready);
492 if (!client->msgsize)
493 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
495 rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
498 client->rxcount += rc;
499 if (!client->msgsize && client->rxcount >= 6) {
501 memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
502 client->msgsize = ntohl(msgLen);
504 if (client->msgsize > BUFSIZE - 6) {
505 /* XXX - figure out how to handle this. A large size here can represent two cases:
506 * 1. A valid size. The only message that is this big is UserState message with a big texture
507 * 2. An invalid size = protocol error, e.g. connecting with a 1.1.x client
509 // Log_warn("Too big message received (%d bytes). Playing safe and disconnecting client %s:%d",
510 // client->msgsize, inet_ntoa(client->remote_tcp.sin_addr), ntohs(client->remote_tcp.sin_port));
513 /* client->rxcount = client->msgsize = 0; */
515 else if (client->rxcount == client->msgsize + 6) { /* Got all of the message */
516 msg = Msg_networkToMessage(client->rxbuf, client->msgsize + 6);
517 /* pass messsage to handler */
519 Mh_handle_message(client, msg);
520 client->rxcount = client->msgsize = 0;
522 } else /* rc <= 0 */ {
523 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
526 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
527 client->readBlockedOnWrite = true;
530 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_ZERO_RETURN ||
531 SSLi_get_error(client->ssl, rc) == 0) {
532 Log_info_client(client, "Connection closed by peer");
533 Client_close(client);
536 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
538 Log_info_client(client, "Connection closed by peer");
540 Log_info_client(client,"Error: %s - Closing connection (code %d)",
543 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
544 Log_info_client(client, "Connection reset by peer");
547 Log_info_client(client, "SSL error: %d - Closing connection", SSLi_get_error(client->ssl, rc));
553 } while (SSLi_data_pending(client->ssl));
558 int Client_write_fd(int fd)
561 client_t *client = NULL;
563 list_iterate(itr, &clients) {
564 if(fd == list_get_entry(itr, client_t, node)->tcpfd) {
565 client = list_get_entry(itr, client_t, node);
570 return Client_write(client);
575 int Client_write(client_t *client)
579 if (client->readBlockedOnWrite) {
580 client->readBlockedOnWrite = false;
581 Log_debug("Client_write: readBlockedOnWrite == true");
582 return Client_read(client);
584 rc = SSLi_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
586 client->txcount += rc;
587 if (client->txcount == client->txsize)
588 client->txsize = client->txcount = 0;
591 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
592 client->writeBlockedOnRead = true;
595 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
599 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
600 Log_info_client(client, "Error: %s - Closing connection", strerror(errno));
602 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
603 Log_info_client(client, "Connection reset by peer");
606 Log_info_client(client, "SSL error: %d - Closing connection.", SSLi_get_error(client->ssl, rc));
612 if (client->txsize == 0 && !list_empty(&client->txMsgQueue)) {
614 msg = list_get_entry(list_get_first(&client->txMsgQueue), message_t, node);
615 list_del(list_get_first(&client->txMsgQueue));
616 client->txQueueCount--;
617 Client_send_message(client, msg);
622 int Client_send_message_ver(client_t *client, message_t *msg, uint32_t version)
624 if ((version == 0) || (client->version >= version) ||
625 ((version & 0x80000000) && (client->version < (~version))))
626 return Client_send_message(client, msg);
631 int Client_send_message(client_t *client, message_t *msg)
633 if (!client->authenticated && msg->messageType != Version) {
637 if (client->txsize != 0 || !client->SSLready) {
639 if ((client->txQueueCount > 5 && msg->messageType == UDPTunnel) ||
640 client->txQueueCount > 30) {
644 client->txQueueCount++;
645 list_add_tail(&msg->node, &client->txMsgQueue);
646 Log_debug("Queueing message");
649 len = Msg_messageToNetwork(msg, client->txbuf);
650 doAssert(len < BUFSIZE);
652 client->txsize = len;
654 Client_write(client);
660 client_t *Client_iterate(client_t **client_itr)
662 client_t *c = *client_itr;
664 if (list_empty(&clients))
668 c = list_get_entry(list_get_first(&clients), client_t, node);
670 if (list_get_next(&c->node) == &clients)
673 c = list_get_entry(list_get_next(&c->node), client_t, node);
679 void Client_textmessage(client_t *client, char *text)
683 message_t *sendmsg = NULL;
685 message = malloc(strlen(text) + 1);
687 Log_fatal("Out of memory");
688 tree_id = malloc(sizeof(uint32_t));
690 Log_fatal("Out of memory");
692 sendmsg = Msg_create(TextMessage);
693 sendmsg->payload.textMessage->message = message;
694 sendmsg->payload.textMessage->n_tree_id = 1;
695 sendmsg->payload.textMessage->tree_id = tree_id;
696 strcpy(message, text);
697 Client_send_message(client, sendmsg);
701 int Client_send_message_except(client_t *client, message_t *msg)
703 client_t *itr = NULL;
706 Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
707 while (Client_iterate(&itr) != NULL) {
710 Msg_inc_ref(msg); /* One extra reference for each new copy */
711 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
712 Client_send_message(itr, msg);
715 Msg_free(msg); /* Free our reference to the message */
718 Msg_free(msg); /* If only 1 client is connected then no message is passed
719 * to Client_send_message(). Free it here. */
724 int Client_send_message_except_ver(client_t *client, message_t *msg, uint32_t version)
726 client_t *itr = NULL;
729 Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
730 while (Client_iterate(&itr) != NULL) {
733 Msg_inc_ref(msg); /* One extra reference for each new copy */
734 Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
735 Client_send_message_ver(itr, msg, version);
738 Msg_free(msg); /* Free our reference to the message */
741 Msg_free(msg); /* If only 1 client is connected then no message is passed
742 * to Client_send_message(). Free it here. */
747 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
749 if (CryptState_isValid(&client->cryptState) &&
750 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
753 if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
754 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
756 Timer_restart(&client->cryptState.tLastRequest);
758 sendmsg = Msg_create(CryptSetup);
759 Log_info_client(client, "Requesting voice channel crypt resync");
760 Client_send_message(client, sendmsg);
766 #define UDP_PACKET_SIZE 1024
767 int Client_read_udp(int udpsock)
770 struct sockaddr_storage from;
771 socklen_t fromlen = sizeof(struct sockaddr_storage);
772 uint8_t key[KEY_LENGTH];
774 UDPMessageType_t msgType;
775 uint8_t fromaddress[4 * sizeof(in_addr_t)];
778 #if defined(__LP64__)
779 uint8_t encbuff[UDP_PACKET_SIZE + 8];
780 uint8_t *encrypted = encbuff + 4;
782 uint8_t encrypted[UDP_PACKET_SIZE];
784 uint8_t buffer[UDP_PACKET_SIZE];
786 len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
788 memset(key, 0, KEY_LENGTH);
790 if(from.ss_family == AF_INET) {
791 memcpy(fromaddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
792 fromport = ntohs(((struct sockaddr_in*)&from)->sin_port);
793 memcpy(&key[0], &fromport, 2);
794 memcpy(&key[2], fromaddress, sizeof(in_addr_t));
796 memcpy(fromaddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
797 fromport = ntohs(((struct sockaddr_in6*)&from)->sin6_port);
798 memcpy(&key[0], &fromport, 2);
799 memcpy(&key[2], fromaddress, 4 * sizeof(in_addr_t));
804 } else if (len < 0) {
806 } else if (len < 5) {
807 // 4 bytes crypt header + type + session
809 } else if (len > UDP_PACKET_SIZE) {
814 if (len == 12 && *encrypted == 0) {
815 uint32_t *ping = (uint32_t *)encrypted;
816 ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
817 // 1 and 2 will be the timestamp, which we return unmodified.
818 ping[3] = htonl((uint32_t)clientcount);
819 ping[4] = htonl((uint32_t)getIntConf(MAX_CLIENTS));
820 ping[5] = htonl((uint32_t)getIntConf(MAX_BANDWIDTH));
822 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
828 while (Client_iterate(&itr) != NULL) {
829 if (memcmp(itr->key, key, KEY_LENGTH) == 0) {
830 if (!checkDecrypt(itr, encrypted, buffer, len))
835 if (itr == NULL) { /* Unknown peer */
836 struct sockaddr_storage itraddressstorage;
837 uint8_t itraddress[4 * sizeof(in_addr_t)];
840 while (Client_iterate(&itr) != NULL) {
841 itraddressstorage = itr->remote_tcp;
842 if(itraddressstorage.ss_family == AF_INET) {
843 memcpy(itraddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
844 addresslength = sizeof(in_addr_t);
846 memcpy(itraddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
847 addresslength = 4 * sizeof(in_addr_t);
850 if (memcmp(itraddress, fromaddress, addresslength) == 0) {
851 if (checkDecrypt(itr, encrypted, buffer, len)) {
852 memcpy(itr->key, key, KEY_LENGTH);
853 Log_info_client(itr, "New UDP connection from %s on port %d", itr->addressString, fromport);
854 memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_storage));
860 if (itr == NULL) { /* Couldn't find this peer among connected clients */
865 len -= 4; /* Adjust for crypt header */
866 msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
869 case UDPVoiceCELTAlpha:
870 case UDPVoiceCELTBeta:
874 Client_voiceMsg(itr, buffer, len);
877 Log_debug("UDP Ping reply len %d", len);
878 Client_send_udp(itr, buffer, len);
881 Log_debug("Unknown UDP message type from %s port %d", itr->addressString, fromport);
889 static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
891 if (IS_AUTH(dst) && dst != src && !dst->deaf && !dst->self_deaf) {
892 if (poslen > 0 && /* Has positional data */
893 src->context != NULL && dst->context != NULL && /* ...both source and destination has context */
894 strcmp(src->context, dst->context) == 0) /* ...and the contexts match */
895 Client_send_udp(dst, data, len);
897 Client_send_udp(dst, data, len - poslen);
901 /* Handle decrypted voice message */
902 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
904 uint8_t buffer[UDP_PACKET_SIZE];
905 pds_t *pdi = Pds_create(data + 1, len - 1);
906 pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
907 unsigned int type = data[0] & 0xe0;
908 unsigned int target = data[0] & 0x1f;
909 unsigned int poslen, counter, size;
910 int offset, packetsize;
913 channel_t *ch = (channel_t *)client->channel;
916 if (!client->authenticated || client->mute || client->self_mute || ch->silent)
919 packetsize = 20 + 8 + 4 + len;
920 if (client->availableBandwidth - packetsize < 0)
921 goto out; /* Discard */
922 client->availableBandwidth -= packetsize;
924 Timer_restart(&client->idleTime);
925 Timer_restart(&client->lastActivity);
927 counter = Pds_get_numval(pdi); /* step past session id */
928 if ((type >> 5) != UDPVoiceOpus) {
930 counter = Pds_next8(pdi);
931 offset = Pds_skip(pdi, counter & 0x7f);
932 } while ((counter & 0x80) && offset > 0);
934 size = Pds_get_numval(pdi);
935 Pds_skip(pdi, size & 0x1fff);
938 poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
940 Pds_add_numval(pds, client->sessionId);
941 Pds_append_data_nosize(pds, data + 1, len - 1);
943 if (target == 0x1f) { /* Loopback */
944 buffer[0] = (uint8_t) type;
945 Client_send_udp(client, buffer, pds->offset + 1);
947 else if (target == 0) { /* regular channel speech */
948 buffer[0] = (uint8_t) type;
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);
958 } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
962 for (i = 0; i < TARGET_MAX_CHANNELS && vt->channels[i].channel != -1; i++) {
963 buffer[0] = (uint8_t) (type | 1);
964 Log_debug("Whisper channel %d", vt->channels[i]);
965 ch = Chan_fromId(vt->channels[i].channel);
968 list_iterate(itr, &ch->clients) {
970 c = list_get_entry(itr, client_t, chan_node);
971 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
974 if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
975 struct dlist *ch_itr;
976 list_iterate(ch_itr, &ch->channel_links) {
978 ch_link = list_get_entry(ch_itr, channel_t, link_node);
979 list_iterate(itr, &ch_link->clients) {
981 c = list_get_entry(itr, client_t, chan_node);
982 Log_debug("Linked voice from %s -> %s", ch->name, ch_link->name);
983 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
988 if (vt->channels[i].children) {
989 struct dlist chanlist, *ch_itr;
990 init_list_entry(&chanlist);
991 Chan_buildTreeList(ch, &chanlist);
992 list_iterate(ch_itr, &chanlist) {
994 sub = list_get_entry(ch_itr, channellist_t, node)->chan;
995 list_iterate(itr, &sub->clients) {
997 c = list_get_entry(itr, client_t, chan_node);
998 Log_debug("Child voice from %s -> %s", ch->name, sub->name);
999 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
1002 Chan_freeTreeList(&chanlist);
1006 for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
1008 buffer[0] = (uint8_t) (type | 2);
1009 Log_debug("Whisper session %d", vt->sessions[i]);
1010 while (Client_iterate(&c) != NULL) {
1011 if (c->sessionId == vt->sessions[i]) {
1012 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
1025 static int Client_send_udp(client_t *client, uint8_t *data, int len)
1027 uint8_t *buf, *mbuf;
1028 uint16_t clientport;
1029 int udpsock = (client->remote_udp.ss_family == AF_INET) ? udpsocks[0] : udpsocks[1];
1031 if (client->remote_udp.ss_family == AF_INET)
1032 clientport = ntohs(((struct sockaddr_in*)&client->remote_udp)->sin_port);
1034 clientport = ntohs(((struct sockaddr_in6*)&client->remote_udp)->sin6_port);
1036 if (clientport != 0 && CryptState_isValid(&client->cryptState) &&
1038 #if defined(__LP64__)
1039 buf = mbuf = malloc(len + 4 + 16);
1042 mbuf = buf = malloc(len + 4);
1045 Log_fatal("Out of memory");
1047 CryptState_encrypt(&client->cryptState, data, buf, len);
1049 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
1050 sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, client->remote_tcp.ss_len);
1052 sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, sizeof(struct sockaddr_storage));
1058 msg = Msg_CreateVoiceMsg(data, len);
1059 Client_send_message(client, msg);