src/client.c

   1 /* Copyright (C) 2009-2014, Martin Johansson <martin@fatbob.nu>
   2    Copyright (C) 2005-2014, Thorvald Natvig <thorvald@natvig.com>
   3
   4    All rights reserved.
   5
   6    Redistribution and use in source and binary forms, with or without
   7    modification, are permitted provided that the following conditions
   8    are met:
   9
  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.
  18
  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.
  30    */
  31 #include <sys/poll.h>
  32 #include <sys/socket.h>
  33 #include <fcntl.h>
  34 #include <errno.h>
  35 #include <limits.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include "log.h"
  39 #include "memory.h"
  40 #include "list.h"
  41 #include "client.h"
  42 #include "ssl.h"
  43 #include "messages.h"
  44 #include "messagehandler.h"
  45 #include "conf.h"
  46 #include "channel.h"
  47 #include "version.h"
  48 #include "voicetarget.h"
  49 #include "ban.h"
  50 #include "util.h"
  51
  52 extern char system_string[], version_string[];
  53
  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);
  58
  59 declare_list(clients);
  60 static int clientcount; /* = 0 */
  61 static int maxBandwidth;
  62 bool_t bOpus = true;
  63
  64 int iCodecAlpha, iCodecBeta;
  65 bool_t bPreferAlpha;
  66
  67 extern int* udpsocks;
  68 extern bool_t hasv4;
  69
  70 void Client_init()
  71 {
  72         maxBandwidth = getIntConf(MAX_BANDWIDTH) / 8; /* From bits/s -> bytes/s */
  73 }
  74
  75 int Client_count()
  76 {
  77         return clientcount;
  78 }
  79
  80 int Client_getfds(struct pollfd *pollfds)
  81 {
  82         struct dlist *itr;
  83         int i = 0;
  84         list_iterate(itr, &clients) {
  85                 client_t *c;
  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;
  91                 i++;
  92         }
  93         return i;
  94 }
  95
  96 void Client_janitor()
  97 {
  98         struct dlist *itr, *save;
  99         int bwTop = maxBandwidth + maxBandwidth / 4;
 100         list_iterate_safe(itr, save, &clients) {
 101                 client_t *c;
 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;
 107
 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.");
 111                         Client_free(c);
 112                 }
 113         }
 114         Ban_pruneBanned();
 115 }
 116
 117 void Client_codec_add(client_t *client, int codec)
 118 {
 119         codec_t *cd = Memory_safeMalloc(1, sizeof(codec_t));
 120         init_list_entry(&cd->node);
 121         cd->codec = codec;
 122         list_add_tail(&cd->node, &client->codecs);
 123 }
 124
 125 void Client_codec_free(client_t *client)
 126 {
 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));
 131         }
 132 }
 133
 134 codec_t *Client_codec_iterate(client_t *client, codec_t **codec_itr)
 135 {
 136         codec_t *cd = *codec_itr;
 137
 138         if (list_empty(&client->codecs))
 139                 return NULL;
 140
 141         if (cd == NULL) {
 142                 cd = list_get_entry(list_get_first(&client->codecs), codec_t, node);
 143         } else {
 144                 if (list_get_next(&cd->node) == &client->codecs)
 145                         cd = NULL;
 146                 else
 147                         cd = list_get_entry(list_get_next(&cd->node), codec_t, node);
 148         }
 149         *codec_itr = cd;
 150         return cd;
 151 }
 152
 153 void Client_token_add(client_t *client, char *token_string)
 154 {
 155         token_t *token;
 156
 157         if (client->tokencount >= MAX_TOKENS)
 158                 return;
 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++;
 166 }
 167
 168 bool_t Client_token_match(client_t *client, char const *str)
 169 {
 170         token_t *token;
 171         struct dlist *itr;
 172
 173         if (list_empty(&client->tokens))
 174                 return false;
 175         list_iterate(itr, &client->tokens) {
 176                 token = list_get_entry(itr, token_t, node);
 177                 if (strncasecmp(token->token, str, MAX_TOKENSIZE) == 0)
 178                         return true;
 179         }
 180         return false;
 181 }
 182
 183 void Client_token_free(client_t *client)
 184 {
 185         struct dlist *itr, *save;
 186         token_t *token;
 187
 188         list_iterate_safe(itr, save, &client->tokens) {
 189                 token = list_get_entry(itr, token_t, node);
 190                 list_del(&token->node);
 191                 free(token->token);
 192                 free(token);
 193         }
 194         client->tokencount = 0;
 195 }
 196
 197
 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)
 201 {
 202         client_t *client_itr = NULL;
 203         int max = 0, version, current_version;
 204         int users = 0, opus = 0;
 205         message_t *sendmsg;
 206         struct dlist codec_list, *itr, *save;
 207         codec_t *codec_itr, *cd;
 208         bool_t found;
 209         bool_t enableOpus;
 210
 211         init_list_entry(&codec_list);
 212
 213         while (Client_iterate(&client_itr) != NULL) {
 214                 codec_itr = NULL;
 215                 if (client_itr->codec_count == 0 && !client_itr->bOpus)
 216                         continue;
 217                 while (Client_codec_iterate(client_itr, &codec_itr) != NULL) {
 218                         found = false;
 219                         list_iterate(itr, &codec_list) {
 220                                 cd = list_get_entry(itr, codec_t, node);
 221                                 if (cd->codec == codec_itr->codec) {
 222                                         cd->count++;
 223                                         found = true;
 224                                 }
 225                         }
 226                         if (!found) {
 227                                 cd = Memory_safeCalloc(1, sizeof(codec_t));
 228                                 init_list_entry(&cd->node);
 229                                 cd->codec = codec_itr->codec;
 230                                 cd->count = 1;
 231                                 list_add_tail(&cd->node, &codec_list);
 232                         }
 233                 }
 234                 users++;
 235                 if (client_itr->bOpus)
 236                         opus++;
 237         }
 238         if (users == 0)
 239                 return;
 240
 241         enableOpus = ((opus * 100 / users) >= getIntConf(OPUS_THRESHOLD));
 242
 243         list_iterate(itr, &codec_list) {
 244                 cd = list_get_entry(itr, codec_t, node);
 245                 if (cd->count > max) {
 246                         max = cd->count;
 247                         version = cd->codec;
 248                 }
 249         }
 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));
 253         }
 254
 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
 260                 // and announce it.
 261                 if (version == (uint32_t)0x8000000b)
 262                         bPreferAlpha = true;
 263                 else
 264                         bPreferAlpha = !bPreferAlpha;
 265
 266                 if (bPreferAlpha)
 267                         iCodecAlpha = version;
 268                 else
 269                         iCodecBeta = version;
 270         } else if (bOpus && enableOpus) {
 271                 if (connectingClient && !connectingClient->bOpus)
 272                         Client_textmessage(connectingClient, OPUS_WARN_USING);
 273                 return;
 274         }
 275
 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;
 282
 283         Client_send_message_except(NULL, sendmsg);
 284
 285         if (enableOpus && !bOpus) {
 286                 client_itr = NULL;
 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);
 291                         }
 292                 }
 293                 Log_info("OPUS codec %s", bOpus ? "enabled" : "disabled");
 294         }
 295
 296         bOpus = enableOpus;
 297 }
 298
 299 static int findFreeSessionId()
 300 {
 301         int id;
 302         client_t *itr = NULL;
 303
 304         for (id = 1; id < INT_MAX; id++) {
 305                 itr = NULL;
 306                 while ((itr = Client_iterate(&itr)) != NULL) {
 307                         if (itr->sessionId == id)
 308                                 break;
 309                 }
 310                 if (itr == NULL) /* Found free id */
 311                         return id;
 312         }
 313         return -1;
 314 }
 315
 316 int Client_add(int fd, struct sockaddr_storage *remote)
 317 {
 318         client_t* newclient;
 319         message_t *sendmsg;
 320         char* addressString = NULL;
 321
 322         if (Ban_isBannedAddr(remote)) {
 323                 addressString = Util_addressToString(remote);
 324                 Log_info("Address %s banned. Disconnecting", addressString);
 325                 free(addressString);
 326                 return -1;
 327         }
 328
 329         newclient = Memory_safeCalloc(1, sizeof(client_t));
 330
 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));
 337                 free(addressString);
 338                 free(newclient);
 339                 return -1;
 340         }
 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");
 348
 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);
 355
 356         list_add_tail(&newclient->node, &clients);
 357         clientcount++;
 358
 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);
 367
 368         return 0;
 369 }
 370
 371 void Client_free(client_t *client)
 372 {
 373         struct dlist *itr, *save;
 374         message_t *sendmsg;
 375         bool_t authenticatedLeft = client->authenticated;
 376
 377         if (client->authenticated) {
 378                 int leave_id;
 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);
 384                 }
 385                 sendmsg = Msg_create(UserRemove);
 386                 sendmsg->payload.userRemove->session = client->sessionId;
 387                 Client_send_message_except(client, sendmsg);
 388         }
 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));
 392         }
 393         Client_codec_free(client);
 394         Voicetarget_free_all(client);
 395         Client_token_free(client);
 396
 397         list_del(&client->node);
 398         if (client->ssl)
 399                 SSLi_free(client->ssl);
 400         close(client->tcpfd);
 401         clientcount--;
 402
 403         free(client->release);
 404         free(client->os);
 405         free(client->os_version);
 406         free(client->username);
 407         free(client->context);
 408         free(client);
 409
 410         if (authenticatedLeft)
 411                 recheckCodecVersions(NULL); /* Can use better codec now? */
 412 }
 413
 414 void Client_close(client_t *client)
 415 {
 416         SSLi_shutdown(client->ssl);
 417         client->shutdown_wait = true;
 418 }
 419
 420 void Client_disconnect_all()
 421 {
 422         struct dlist *itr, *save;
 423
 424         list_iterate_safe(itr, save, &clients) {
 425                 Client_free(list_get_entry(itr, client_t, node));
 426         }
 427 }
 428
 429 int Client_read_fd(int fd)
 430 {
 431         struct dlist *itr;
 432         client_t *client = NULL;
 433
 434         list_iterate(itr, &clients) {
 435                 if (fd == list_get_entry(itr, client_t, node)->tcpfd) {
 436                         client = list_get_entry(itr, client_t, node);
 437                         break;
 438                 }
 439         }
 440         if (client != NULL)
 441                 return Client_read(client);
 442         else
 443                 return -1;
 444 }
 445
 446 int Client_read(client_t *client)
 447 {
 448         int rc;
 449
 450         Timer_restart(&client->lastActivity);
 451
 452         if (client->writeBlockedOnRead) {
 453                 client->writeBlockedOnRead = false;
 454                 Log_debug("Client_read: writeBlockedOnRead == true");
 455                 return Client_write(client);
 456         }
 457
 458         if (client->shutdown_wait) {
 459                 Client_free(client);
 460                 return 0;
 461         }
 462         if (!client->SSLready) {
 463                 int rc;
 464                 rc = SSLi_nonblockaccept(client->ssl, &client->SSLready);
 465                 if (rc < 0) {
 466                         Client_free(client);
 467                         return -1;
 468                 }
 469         }
 470
 471         do {
 472                 errno = 0;
 473                 if (!client->msgsize)
 474                         rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
 475                 else
 476                         rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
 477                 if (rc > 0) {
 478                         message_t *msg;
 479                         client->rxcount += rc;
 480                         if (!client->msgsize && client->rxcount >= 6) {
 481                                 uint32_t msgLen;
 482                                 memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
 483                                 client->msgsize = ntohl(msgLen);
 484                         }
 485                         if (client->msgsize > BUFSIZE - 6) {
 486                                 /* XXX - figure out how to handle this. A large size here can represent two cases:
 487                                  * 1. A valid size. The only message that is this big is UserState message with a big texture
 488                                  * 2. An invalid size = protocol error, e.g. connecting with a 1.1.x client
 489                                  */
 490                                 //                Log_warn("Too big message received (%d bytes). Playing safe and disconnecting client %s:%d",
 491                                 //                         client->msgsize, inet_ntoa(client->remote_tcp.sin_addr), ntohs(client->remote_tcp.sin_port));
 492                                 Client_free(client);
 493                                 return -1;
 494                                 /* client->rxcount = client->msgsize = 0; */
 495                         }
 496                         else if (client->rxcount == client->msgsize + 6) { /* Got all of the message */
 497                                 msg = Msg_networkToMessage(client->rxbuf, client->msgsize + 6);
 498                                 /* pass messsage to handler */
 499                                 if (msg)
 500                                         Mh_handle_message(client, msg);
 501                                 client->rxcount = client->msgsize = 0;
 502                         }
 503                 } else /* rc <= 0 */ {
 504                         if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
 505                                 return 0;
 506                         }
 507                         else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
 508                                 client->readBlockedOnWrite = true;
 509                                 return 0;
 510                         }
 511                         else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_ZERO_RETURN ||
 512                                 SSLi_get_error(client->ssl, rc) == 0) {
 513                                 Log_info_client(client, "Connection closed by peer");
 514                                 Client_close(client);
 515                         }
 516                         else {
 517                                 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
 518                                         if (errno == 0)
 519                                                 Log_info_client(client, "Connection closed by peer");
 520                                         else
 521                                                 Log_info_client(client,"Error: %s  - Closing connection (code %d)",
 522                                                         strerror(errno));
 523                                 }
 524                                 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
 525                                         Log_info_client(client, "Connection reset by peer");
 526                                 }
 527                                 else {
 528                                         Log_info_client(client, "SSL error: %d - Closing connection", SSLi_get_error(client->ssl, rc));
 529                                 }
 530                                 Client_free(client);
 531                                 return -1;
 532                         }
 533                 }
 534         } while (SSLi_data_pending(client->ssl));
 535
 536         return 0;
 537 }
 538
 539 int Client_write_fd(int fd)
 540 {
 541         struct dlist *itr;
 542         client_t *client = NULL;
 543
 544         list_iterate(itr, &clients) {
 545                 if(fd == list_get_entry(itr, client_t, node)->tcpfd) {
 546                         client = list_get_entry(itr, client_t, node);
 547                         break;
 548                 }
 549         }
 550         if (client != NULL)
 551                 return Client_write(client);
 552         else
 553                 return -1;
 554 }
 555
 556 int Client_write(client_t *client)
 557 {
 558         int rc;
 559
 560         if (client->readBlockedOnWrite) {
 561                 client->readBlockedOnWrite = false;
 562                 Log_debug("Client_write: readBlockedOnWrite == true");
 563                 return Client_read(client);
 564         }
 565         rc = SSLi_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
 566         if (rc > 0) {
 567                 client->txcount += rc;
 568                 if (client->txcount == client->txsize)
 569                         client->txsize = client->txcount = 0;
 570         }
 571         else if (rc < 0) {
 572                 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
 573                         client->writeBlockedOnRead = true;
 574                         return 0;
 575                 }
 576                 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
 577                         return 0;
 578                 }
 579                 else {
 580                         if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
 581                                 Log_info_client(client, "Error: %s      - Closing connection", strerror(errno));
 582                         }
 583                         else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
 584                                 Log_info_client(client, "Connection reset by peer");
 585                         }
 586                         else {
 587                                 Log_info_client(client, "SSL error: %d - Closing connection.", SSLi_get_error(client->ssl, rc));
 588                         }
 589                         Client_free(client);
 590                         return -1;
 591                 }
 592         }
 593         if (client->txsize == 0 && !list_empty(&client->txMsgQueue)) {
 594                 message_t *msg;
 595                 msg = list_get_entry(list_get_first(&client->txMsgQueue), message_t, node);
 596                 list_del(list_get_first(&client->txMsgQueue));
 597                 client->txQueueCount--;
 598                 Client_send_message(client, msg);
 599         }
 600         return 0;
 601 }
 602
 603 int Client_send_message_ver(client_t *client, message_t *msg, uint32_t version)
 604 {
 605         if ((version == 0) || (client->version >= version) ||
 606                 ((version & 0x80000000) && (client->version < (~version))))
 607                 return Client_send_message(client, msg);
 608         else
 609                 Msg_free(msg);
 610         return -1;
 611 }
 612
 613 int Client_send_message(client_t *client, message_t *msg)
 614 {
 615         if (!client->authenticated && msg->messageType != Version) {
 616                 Msg_free(msg);
 617                 return 0;
 618         }
 619         if (client->txsize != 0 || !client->SSLready) {
 620                 /* Queue message */
 621                 if ((client->txQueueCount > 5 &&  msg->messageType == UDPTunnel) ||
 622                         client->txQueueCount > 30) {
 623                         Msg_free(msg);
 624                         return -1;
 625                 }
 626                 client->txQueueCount++;
 627                 list_add_tail(&msg->node, &client->txMsgQueue);
 628                 Log_debug("Queueing message");
 629         } else {
 630                 int len;
 631                 len = Msg_messageToNetwork(msg, client->txbuf);
 632                 doAssert(len < BUFSIZE);
 633
 634                 client->txsize = len;
 635                 client->txcount = 0;
 636                 Client_write(client);
 637                 Msg_free(msg);
 638         }
 639         return 0;
 640 }
 641
 642 client_t *Client_iterate(client_t **client_itr)
 643 {
 644         client_t *c = *client_itr;
 645
 646         if (list_empty(&clients))
 647                 return NULL;
 648
 649         if (c == NULL) {
 650                 c = list_get_entry(list_get_first(&clients), client_t, node);
 651         } else {
 652                 if (list_get_next(&c->node) == &clients)
 653                         c = NULL;
 654                 else
 655                         c = list_get_entry(list_get_next(&c->node), client_t, node);
 656         }
 657         *client_itr = c;
 658         return c;
 659 }
 660
 661 void Client_textmessage(client_t *client, char *text)
 662 {
 663         char *message;
 664         uint32_t *tree_id;
 665         message_t *sendmsg = NULL;
 666
 667         message = Memory_safeMalloc(1, strlen(text) + 1);
 668         tree_id = Memory_safeMalloc(1, sizeof(uint32_t));
 669         *tree_id = 0;
 670         sendmsg = Msg_create(TextMessage);
 671         sendmsg->payload.textMessage->message = message;
 672         sendmsg->payload.textMessage->n_tree_id = 1;
 673         sendmsg->payload.textMessage->tree_id = tree_id;
 674         strcpy(message, text);
 675         Client_send_message(client, sendmsg);
 676 }
 677
 678
 679 int Client_send_message_except(client_t *client, message_t *msg)
 680 {
 681         client_t *itr = NULL;
 682         int count = 0;
 683
 684         Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
 685         while (Client_iterate(&itr) != NULL) {
 686                 if (itr != client) {
 687                         if (count++ > 0)
 688                                 Msg_inc_ref(msg); /* One extra reference for each new copy */
 689                         Log_debug("Msg %d to %s refcount %d",  msg->messageType, itr->username, msg->refcount);
 690                         Client_send_message(itr, msg);
 691                 }
 692         }
 693         Msg_free(msg); /* Free our reference to the message */
 694
 695         if (count == 0)
 696                 Msg_free(msg); /* If only 1 client is connected then no message is passed
 697                                                 * to Client_send_message(). Free it here. */
 698
 699         return 0;
 700 }
 701
 702 int Client_send_message_except_ver(client_t *client, message_t *msg, uint32_t version)
 703 {
 704         client_t *itr = NULL;
 705         int count = 0;
 706
 707         Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
 708         while (Client_iterate(&itr) != NULL) {
 709                 if (itr != client) {
 710                         if (count++ > 0)
 711                                 Msg_inc_ref(msg); /* One extra reference for each new copy */
 712                         Log_debug("Msg %d to %s refcount %d",  msg->messageType, itr->username, msg->refcount);
 713                         Client_send_message_ver(itr, msg, version);
 714                 }
 715         }
 716         Msg_free(msg); /* Free our reference to the message */
 717
 718         if (count == 0)
 719                 Msg_free(msg); /* If only 1 client is connected then no message is passed
 720                                                 * to Client_send_message(). Free it here. */
 721
 722         return 0;
 723 }
 724
 725 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
 726 {
 727         if (CryptState_isValid(&client->cryptState) &&
 728                 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
 729                 return true;
 730
 731         if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
 732                 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
 733                         message_t *sendmsg;
 734                         Timer_restart(&client->cryptState.tLastRequest);
 735
 736                         sendmsg = Msg_create(CryptSetup);
 737                         Log_info_client(client, "Requesting voice channel crypt resync");
 738                         Client_send_message(client, sendmsg);
 739                 }
 740         }
 741         return false;
 742 }
 743
 744 #define UDP_PACKET_SIZE 1024
 745 int Client_read_udp(int udpsock)
 746 {
 747         int len;
 748         struct sockaddr_storage from;
 749         socklen_t fromlen = sizeof(struct sockaddr_storage);
 750         uint8_t key[KEY_LENGTH];
 751         client_t *itr;
 752         UDPMessageType_t msgType;
 753         uint8_t fromaddress[4 * sizeof(in_addr_t)];
 754         uint16_t fromport;
 755
 756 #if defined(__LP64__)
 757         uint8_t encbuff[UDP_PACKET_SIZE + 8];
 758         uint8_t *encrypted = encbuff + 4;
 759 #else
 760         uint8_t encrypted[UDP_PACKET_SIZE];
 761 #endif
 762         uint8_t buffer[UDP_PACKET_SIZE];
 763
 764         len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
 765
 766         memset(key, 0, KEY_LENGTH);
 767
 768         fromport = Util_addressToPort(&from);
 769
 770         if(from.ss_family == AF_INET) {
 771                 memcpy(fromaddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
 772                 memcpy(&key[0], &fromport, 2);
 773                 memcpy(&key[2], fromaddress, sizeof(in_addr_t));
 774         } else {
 775                 memcpy(fromaddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
 776                 memcpy(&key[0], &fromport, 2);
 777                 memcpy(&key[2], fromaddress, 4 * sizeof(in_addr_t));
 778         }
 779
 780         if (len <= 0)
 781                 return -1;
 782         else if (len < 5 || len > UDP_PACKET_SIZE) /* 4 bytes crypt header + type + session */
 783                 return 0;
 784
 785         /*
 786          * Reply to ping packet
 787          * The second and third uint32_t are the timestamp, which will be returned unmodified
 788          */
 789         if (len == 12 && *encrypted == 0) {
 790                 uint32_t *ping = (uint32_t *)encrypted;
 791                 ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
 792                 ping[3] = htonl((uint32_t)clientcount);
 793                 ping[4] = htonl((uint32_t)getIntConf(MAX_CLIENTS));
 794                 ping[5] = htonl((uint32_t)getIntConf(MAX_BANDWIDTH));
 795
 796                 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
 797                 return 0;
 798         }
 799
 800         itr = NULL;
 801
 802         while (Client_iterate(&itr) != NULL) {
 803                 if (memcmp(itr->key, key, KEY_LENGTH) == 0) {
 804                         if (!checkDecrypt(itr, encrypted, buffer, len))
 805                                 goto out;
 806                         break;
 807                 }
 808         }
 809         if (itr == NULL) { /* Unknown peer */
 810                 struct sockaddr_storage itraddressstorage;
 811                 uint8_t itraddress[4 * sizeof(in_addr_t)];
 812                 int addresslength;
 813
 814                 while (Client_iterate(&itr) != NULL) {
 815                         itraddressstorage = itr->remote_tcp;
 816                         if(itraddressstorage.ss_family == AF_INET) {
 817                                 memcpy(itraddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
 818                                 addresslength = sizeof(in_addr_t);
 819                         } else {
 820                                 memcpy(itraddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
 821                                 addresslength = 4 * sizeof(in_addr_t);
 822                         }
 823
 824                         if (memcmp(itraddress, fromaddress, addresslength) == 0) {
 825                                 if (checkDecrypt(itr, encrypted, buffer, len)) {
 826                                         memcpy(itr->key, key, KEY_LENGTH);
 827                                         char* clientAddressString = Util_clientAddressToString(itr);
 828                                         Log_info_client(itr, "New UDP connection from %s on port %d", clientAddressString, fromport);
 829                                         free(clientAddressString);
 830                                         memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_storage));
 831                                         break;
 832                                 }
 833                         }
 834                 } /* while */
 835         }
 836         if (itr == NULL) { /* Couldn't find this peer among connected clients */
 837                 goto out;
 838         }
 839
 840         itr->bUDP = true;
 841         len -= 4; /* Adjust for crypt header */
 842         msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
 843
 844         char *clientAddressString = NULL;
 845
 846         switch (msgType) {
 847                 case UDPVoiceSpeex:
 848                 case UDPVoiceCELTAlpha:
 849                 case UDPVoiceCELTBeta:
 850                         if (bOpus)
 851                                 break;
 852                 case UDPVoiceOpus:
 853                         Client_voiceMsg(itr, buffer, len);
 854                         break;
 855                 case UDPPing:
 856                         Log_debug("UDP Ping reply len %d", len);
 857                         Client_send_udp(itr, buffer, len);
 858                         break;
 859                 default:
 860                         clientAddressString = Util_clientAddressToString(itr);
 861                         Log_debug("Unknown UDP message type from %s port %d", clientAddressString, fromport);
 862                         free(clientAddressString);
 863                         break;
 864         }
 865
 866 out:
 867         return 0;
 868 }
 869
 870 static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
 871 {
 872         if (IS_AUTH(dst) && dst != src && !dst->deaf && !dst->self_deaf) {
 873                 if (poslen > 0 && /* Has positional data */
 874                         src->context != NULL && dst->context != NULL && /* ...both source and destination has context */
 875                         strcmp(src->context, dst->context) == 0) /* ...and the contexts match */
 876                         Client_send_udp(dst, data, len);
 877                 else
 878                         Client_send_udp(dst, data, len - poslen);
 879         }
 880 }
 881
 882 /* Handle decrypted voice message */
 883 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
 884 {
 885         uint8_t buffer[UDP_PACKET_SIZE];
 886         pds_t *pdi = Pds_create(data + 1, len - 1);
 887         pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
 888         unsigned int type = data[0] & 0xe0;
 889         unsigned int target = data[0] & 0x1f;
 890         unsigned int poslen, counter, size;
 891         int offset, packetsize;
 892         voicetarget_t *vt;
 893
 894         channel_t *ch = (channel_t *)client->channel;
 895         struct dlist *itr;
 896
 897         if (!client->authenticated || client->mute || client->self_mute || ch->silent)
 898                 goto out;
 899
 900         packetsize = 20 + 8 + 4 + len;
 901         if (client->availableBandwidth - packetsize < 0)
 902                 goto out; /* Discard */
 903         client->availableBandwidth -= packetsize;
 904
 905         Timer_restart(&client->idleTime);
 906         Timer_restart(&client->lastActivity);
 907
 908         counter = Pds_get_numval(pdi); /* step past session id */
 909         if ((type >> 5) != UDPVoiceOpus) {
 910                 do {
 911                         counter = Pds_next8(pdi);
 912                         offset = Pds_skip(pdi, counter & 0x7f);
 913                 } while ((counter & 0x80) && offset > 0);
 914         } else {
 915                 size = Pds_get_numval(pdi);
 916                 Pds_skip(pdi, size & 0x1fff);
 917         }
 918
 919         poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
 920
 921         Pds_add_numval(pds, client->sessionId);
 922         Pds_append_data_nosize(pds, data + 1, len - 1);
 923
 924         if (target == 0x1f) { /* Loopback */
 925                 buffer[0] = (uint8_t) type;
 926                 Client_send_udp(client, buffer, pds->offset + 1);
 927         }
 928         else if (target == 0) { /* regular channel speech */
 929                 buffer[0] = (uint8_t) type;
 930
 931                 if (ch == NULL)
 932                         goto out;
 933
 934                 list_iterate(itr, &ch->clients) {
 935                         client_t *c;
 936                         c = list_get_entry(itr, client_t, chan_node);
 937                         Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 938                 }
 939         } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
 940                 int i;
 941                 channel_t *ch;
 942                 /* Channels */
 943                 for (i = 0; i < TARGET_MAX_CHANNELS && vt->channels[i].channel != -1; i++) {
 944                         buffer[0] = (uint8_t) (type | 1);
 945                         Log_debug("Whisper channel %d", vt->channels[i]);
 946                         ch = Chan_fromId(vt->channels[i].channel);
 947                         if (ch == NULL)
 948                                 continue;
 949                         list_iterate(itr, &ch->clients) {
 950                                 client_t *c;
 951                                 c = list_get_entry(itr, client_t, chan_node);
 952                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 953                         }
 954                         /* Channel links */
 955                         if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
 956                                 struct dlist *ch_itr;
 957                                 list_iterate(ch_itr, &ch->channel_links) {
 958                                         channellist_t *chl;
 959                                         channel_t *ch_link;
 960                                         chl = list_get_entry(ch_itr, channellist_t, node);
 961                                         ch_link = chl->chan;
 962                                         list_iterate(itr, &ch_link->clients) {
 963                                                 client_t *c;
 964                                                 c = list_get_entry(itr, client_t, chan_node);
 965                                                 Log_debug("Linked voice from %s -> %s", ch->name, ch_link->name);
 966                                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 967                                         }
 968                                 }
 969                         }
 970                         /* children */
 971                         if (vt->channels[i].children) {
 972                                 struct dlist chanlist, *ch_itr;
 973                                 init_list_entry(&chanlist);
 974                                 Chan_buildTreeList(ch, &chanlist);
 975                                 list_iterate(ch_itr, &chanlist) {
 976                                         channel_t *sub;
 977                                         sub = list_get_entry(ch_itr, channellist_t, node)->chan;
 978                                         list_iterate(itr, &sub->clients) {
 979                                                 client_t *c;
 980                                                 c = list_get_entry(itr, client_t, chan_node);
 981                                                 Log_debug("Child voice from %s -> %s", ch->name, sub->name);
 982                                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 983                                         }
 984                                 }
 985                                 Chan_freeTreeList(&chanlist);
 986                         }
 987                 }
 988                 /* Sessions */
 989                 for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
 990                         client_t *c;
 991                         buffer[0] = (uint8_t) (type | 2);
 992                         Log_debug("Whisper session %d", vt->sessions[i]);
 993                         while (Client_iterate(&c) != NULL) {
 994                                 if (c->sessionId == vt->sessions[i]) {
 995                                         Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 996                                         break;
 997                                 }
 998                         }
 999                 }
1000         }
1001 out:
1002         Pds_free(pds);
1003         Pds_free(pdi);
1004
1005         return 0;
1006 }
1007
1008 static int Client_send_udp(client_t *client, uint8_t *data, int len)
1009 {
1010         uint8_t *buf, *mbuf;
1011
1012         int udpsock = (client->remote_udp.ss_family == AF_INET) ? udpsocks[0] : udpsocks[(hasv4) ? 1 : 0];
1013
1014         if (Util_clientAddressToPortUDP(client) != 0 && CryptState_isValid(&client->cryptState) &&
1015                 client->bUDP) {
1016 #if defined(__LP64__)
1017                 buf = mbuf = Memory_safeMalloc(1, len + 4 + 16);
1018                 buf += 4;
1019 #else
1020                 mbuf = buf = Memory_safeMalloc(1, len + 4);
1021 #endif
1022                 CryptState_encrypt(&client->cryptState, data, buf, len);
1023
1024 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
1025                         sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, client->remote_tcp.ss_len);
1026 #else
1027                         sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, sizeof(struct sockaddr_storage));
1028 #endif
1029
1030                 free(mbuf);
1031         } else {
1032                 message_t *msg;
1033                 msg = Msg_CreateVoiceMsg(data, len);
1034                 Client_send_message(client, msg);
1035         }
1036         return 0;
1037 }