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_safeMalloc(1, sizeof(codec_t));
 228                                 memset(cd, 0, sizeof(codec_t));
 229                                 init_list_entry(&cd->node);
 230                                 cd->codec = codec_itr->codec;
 231                                 cd->count = 1;
 232                                 list_add_tail(&cd->node, &codec_list);
 233                         }
 234                 }
 235                 users++;
 236                 if (client_itr->bOpus)
 237                         opus++;
 238         }
 239         if (users == 0)
 240                 return;
 241
 242         enableOpus = ((opus * 100 / users) >= getIntConf(OPUS_THRESHOLD));
 243
 244         list_iterate(itr, &codec_list) {
 245                 cd = list_get_entry(itr, codec_t, node);
 246                 if (cd->count > max) {
 247                         max = cd->count;
 248                         version = cd->codec;
 249                 }
 250         }
 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));
 254         }
 255
 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
 261                 // and announce it.
 262                 if (version == (uint32_t)0x8000000b)
 263                         bPreferAlpha = true;
 264                 else
 265                         bPreferAlpha = !bPreferAlpha;
 266
 267                 if (bPreferAlpha)
 268                         iCodecAlpha = version;
 269                 else
 270                         iCodecBeta = version;
 271         } else if (bOpus && enableOpus) {
 272                 if (connectingClient && !connectingClient->bOpus)
 273                         Client_textmessage(connectingClient, OPUS_WARN_USING);
 274                 return;
 275         }
 276
 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;
 283
 284         Client_send_message_except(NULL, sendmsg);
 285
 286         if (enableOpus && !bOpus) {
 287                 client_itr = NULL;
 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);
 292                         }
 293                 }
 294                 Log_info("OPUS codec %s", bOpus ? "enabled" : "disabled");
 295         }
 296
 297         bOpus = enableOpus;
 298 }
 299
 300 static int findFreeSessionId()
 301 {
 302         int id;
 303         client_t *itr = NULL;
 304
 305         for (id = 1; id < INT_MAX; id++) {
 306                 itr = NULL;
 307                 while ((itr = Client_iterate(&itr)) != NULL) {
 308                         if (itr->sessionId == id)
 309                                 break;
 310                 }
 311                 if (itr == NULL) /* Found free id */
 312                         return id;
 313         }
 314         return -1;
 315 }
 316
 317 int Client_add(int fd, struct sockaddr_storage *remote)
 318 {
 319         client_t* newclient;
 320         message_t *sendmsg;
 321         char* addressString = NULL;
 322
 323         if (Ban_isBannedAddr(remote)) {
 324                 addressString = Util_addressToString(remote);
 325                 Log_info("Address %s banned. Disconnecting", addressString);
 326                 free(addressString);
 327                 return -1;
 328         }
 329
 330         newclient = Memory_safeCalloc(1, sizeof(client_t));
 331
 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));
 338                 free(addressString);
 339                 free(newclient);
 340                 return -1;
 341         }
 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");
 349
 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);
 356
 357         list_add_tail(&newclient->node, &clients);
 358         clientcount++;
 359
 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);
 368
 369         return 0;
 370 }
 371
 372 void Client_free(client_t *client)
 373 {
 374         struct dlist *itr, *save;
 375         message_t *sendmsg;
 376         bool_t authenticatedLeft = client->authenticated;
 377
 378         if (client->authenticated) {
 379                 int leave_id;
 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);
 385                 }
 386                 sendmsg = Msg_create(UserRemove);
 387                 sendmsg->payload.userRemove->session = client->sessionId;
 388                 Client_send_message_except(client, sendmsg);
 389         }
 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));
 393         }
 394         Client_codec_free(client);
 395         Voicetarget_free_all(client);
 396         Client_token_free(client);
 397
 398         list_del(&client->node);
 399         if (client->ssl)
 400                 SSLi_free(client->ssl);
 401         close(client->tcpfd);
 402         clientcount--;
 403         if (client->release)
 404                 free(client->release);
 405         if (client->os)
 406                 free(client->os);
 407         if (client->os_version)
 408                 free(client->os_version);
 409         if (client->username)
 410                 free(client->username);
 411         if (client->context)
 412                 free(client->context);
 413         free(client);
 414
 415         if (authenticatedLeft)
 416                 recheckCodecVersions(NULL); /* Can use better codec now? */
 417 }
 418
 419 void Client_close(client_t *client)
 420 {
 421         SSLi_shutdown(client->ssl);
 422         client->shutdown_wait = true;
 423 }
 424
 425 void Client_disconnect_all()
 426 {
 427         struct dlist *itr, *save;
 428
 429         list_iterate_safe(itr, save, &clients) {
 430                 Client_free(list_get_entry(itr, client_t, node));
 431         }
 432 }
 433
 434 int Client_read_fd(int fd)
 435 {
 436         struct dlist *itr;
 437         client_t *client = NULL;
 438
 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);
 442                         break;
 443                 }
 444         }
 445         if (client != NULL)
 446                 return Client_read(client);
 447         else
 448                 return -1;
 449 }
 450
 451 int Client_read(client_t *client)
 452 {
 453         int rc;
 454
 455         Timer_restart(&client->lastActivity);
 456
 457         if (client->writeBlockedOnRead) {
 458                 client->writeBlockedOnRead = false;
 459                 Log_debug("Client_read: writeBlockedOnRead == true");
 460                 return Client_write(client);
 461         }
 462
 463         if (client->shutdown_wait) {
 464                 Client_free(client);
 465                 return 0;
 466         }
 467         if (!client->SSLready) {
 468                 int rc;
 469                 rc = SSLi_nonblockaccept(client->ssl, &client->SSLready);
 470                 if (rc < 0) {
 471                         Client_free(client);
 472                         return -1;
 473                 }
 474         }
 475
 476         do {
 477                 errno = 0;
 478                 if (!client->msgsize)
 479                         rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
 480                 else
 481                         rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
 482                 if (rc > 0) {
 483                         message_t *msg;
 484                         client->rxcount += rc;
 485                         if (!client->msgsize && client->rxcount >= 6) {
 486                                 uint32_t msgLen;
 487                                 memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
 488                                 client->msgsize = ntohl(msgLen);
 489                         }
 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
 494                                  */
 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));
 497                                 Client_free(client);
 498                                 return -1;
 499                                 /* client->rxcount = client->msgsize = 0; */
 500                         }
 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 */
 504                                 if (msg)
 505                                         Mh_handle_message(client, msg);
 506                                 client->rxcount = client->msgsize = 0;
 507                         }
 508                 } else /* rc <= 0 */ {
 509                         if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
 510                                 return 0;
 511                         }
 512                         else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
 513                                 client->readBlockedOnWrite = true;
 514                                 return 0;
 515                         }
 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);
 520                         }
 521                         else {
 522                                 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
 523                                         if (errno == 0)
 524                                                 Log_info_client(client, "Connection closed by peer");
 525                                         else
 526                                                 Log_info_client(client,"Error: %s  - Closing connection (code %d)",
 527                                                         strerror(errno));
 528                                 }
 529                                 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
 530                                         Log_info_client(client, "Connection reset by peer");
 531                                 }
 532                                 else {
 533                                         Log_info_client(client, "SSL error: %d - Closing connection", SSLi_get_error(client->ssl, rc));
 534                                 }
 535                                 Client_free(client);
 536                                 return -1;
 537                         }
 538                 }
 539         } while (SSLi_data_pending(client->ssl));
 540
 541         return 0;
 542 }
 543
 544 int Client_write_fd(int fd)
 545 {
 546         struct dlist *itr;
 547         client_t *client = NULL;
 548
 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);
 552                         break;
 553                 }
 554         }
 555         if (client != NULL)
 556                 return Client_write(client);
 557         else
 558                 return -1;
 559 }
 560
 561 int Client_write(client_t *client)
 562 {
 563         int rc;
 564
 565         if (client->readBlockedOnWrite) {
 566                 client->readBlockedOnWrite = false;
 567                 Log_debug("Client_write: readBlockedOnWrite == true");
 568                 return Client_read(client);
 569         }
 570         rc = SSLi_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
 571         if (rc > 0) {
 572                 client->txcount += rc;
 573                 if (client->txcount == client->txsize)
 574                         client->txsize = client->txcount = 0;
 575         }
 576         else if (rc < 0) {
 577                 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
 578                         client->writeBlockedOnRead = true;
 579                         return 0;
 580                 }
 581                 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
 582                         return 0;
 583                 }
 584                 else {
 585                         if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
 586                                 Log_info_client(client, "Error: %s      - Closing connection", strerror(errno));
 587                         }
 588                         else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
 589                                 Log_info_client(client, "Connection reset by peer");
 590                         }
 591                         else {
 592                                 Log_info_client(client, "SSL error: %d - Closing connection.", SSLi_get_error(client->ssl, rc));
 593                         }
 594                         Client_free(client);
 595                         return -1;
 596                 }
 597         }
 598         if (client->txsize == 0 && !list_empty(&client->txMsgQueue)) {
 599                 message_t *msg;
 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);
 604         }
 605         return 0;
 606 }
 607
 608 int Client_send_message_ver(client_t *client, message_t *msg, uint32_t version)
 609 {
 610         if ((version == 0) || (client->version >= version) ||
 611                 ((version & 0x80000000) && (client->version < (~version))))
 612                 return Client_send_message(client, msg);
 613         else
 614                 Msg_free(msg);
 615         return -1;
 616 }
 617
 618 int Client_send_message(client_t *client, message_t *msg)
 619 {
 620         if (!client->authenticated && msg->messageType != Version) {
 621                 Msg_free(msg);
 622                 return 0;
 623         }
 624         if (client->txsize != 0 || !client->SSLready) {
 625                 /* Queue message */
 626                 if ((client->txQueueCount > 5 &&  msg->messageType == UDPTunnel) ||
 627                         client->txQueueCount > 30) {
 628                         Msg_free(msg);
 629                         return -1;
 630                 }
 631                 client->txQueueCount++;
 632                 list_add_tail(&msg->node, &client->txMsgQueue);
 633                 Log_debug("Queueing message");
 634         } else {
 635                 int len;
 636                 len = Msg_messageToNetwork(msg, client->txbuf);
 637                 doAssert(len < BUFSIZE);
 638
 639                 client->txsize = len;
 640                 client->txcount = 0;
 641                 Client_write(client);
 642                 Msg_free(msg);
 643         }
 644         return 0;
 645 }
 646
 647 client_t *Client_iterate(client_t **client_itr)
 648 {
 649         client_t *c = *client_itr;
 650
 651         if (list_empty(&clients))
 652                 return NULL;
 653
 654         if (c == NULL) {
 655                 c = list_get_entry(list_get_first(&clients), client_t, node);
 656         } else {
 657                 if (list_get_next(&c->node) == &clients)
 658                         c = NULL;
 659                 else
 660                         c = list_get_entry(list_get_next(&c->node), client_t, node);
 661         }
 662         *client_itr = c;
 663         return c;
 664 }
 665
 666 void Client_textmessage(client_t *client, char *text)
 667 {
 668         char *message;
 669         uint32_t *tree_id;
 670         message_t *sendmsg = NULL;
 671
 672         message = Memory_safeMalloc(1, strlen(text) + 1);
 673         tree_id = Memory_safeMalloc(1, sizeof(uint32_t));
 674         *tree_id = 0;
 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);
 681 }
 682
 683
 684 int Client_send_message_except(client_t *client, message_t *msg)
 685 {
 686         client_t *itr = NULL;
 687         int count = 0;
 688
 689         Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
 690         while (Client_iterate(&itr) != NULL) {
 691                 if (itr != client) {
 692                         if (count++ > 0)
 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);
 696                 }
 697         }
 698         Msg_free(msg); /* Free our reference to the message */
 699
 700         if (count == 0)
 701                 Msg_free(msg); /* If only 1 client is connected then no message is passed
 702                                                 * to Client_send_message(). Free it here. */
 703
 704         return 0;
 705 }
 706
 707 int Client_send_message_except_ver(client_t *client, message_t *msg, uint32_t version)
 708 {
 709         client_t *itr = NULL;
 710         int count = 0;
 711
 712         Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
 713         while (Client_iterate(&itr) != NULL) {
 714                 if (itr != client) {
 715                         if (count++ > 0)
 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);
 719                 }
 720         }
 721         Msg_free(msg); /* Free our reference to the message */
 722
 723         if (count == 0)
 724                 Msg_free(msg); /* If only 1 client is connected then no message is passed
 725                                                 * to Client_send_message(). Free it here. */
 726
 727         return 0;
 728 }
 729
 730 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
 731 {
 732         if (CryptState_isValid(&client->cryptState) &&
 733                 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
 734                 return true;
 735
 736         if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
 737                 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
 738                         message_t *sendmsg;
 739                         Timer_restart(&client->cryptState.tLastRequest);
 740
 741                         sendmsg = Msg_create(CryptSetup);
 742                         Log_info_client(client, "Requesting voice channel crypt resync");
 743                         Client_send_message(client, sendmsg);
 744                 }
 745         }
 746         return false;
 747 }
 748
 749 #define UDP_PACKET_SIZE 1024
 750 int Client_read_udp(int udpsock)
 751 {
 752         int len;
 753         struct sockaddr_storage from;
 754         socklen_t fromlen = sizeof(struct sockaddr_storage);
 755         uint8_t key[KEY_LENGTH];
 756         client_t *itr;
 757         UDPMessageType_t msgType;
 758         uint8_t fromaddress[4 * sizeof(in_addr_t)];
 759         uint16_t fromport;
 760
 761 #if defined(__LP64__)
 762         uint8_t encbuff[UDP_PACKET_SIZE + 8];
 763         uint8_t *encrypted = encbuff + 4;
 764 #else
 765         uint8_t encrypted[UDP_PACKET_SIZE];
 766 #endif
 767         uint8_t buffer[UDP_PACKET_SIZE];
 768
 769         len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
 770
 771         memset(key, 0, KEY_LENGTH);
 772
 773         fromport = Util_addressToPort(&from);
 774
 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));
 779         } else {
 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));
 783         }
 784
 785         if (len <= 0)
 786                 return -1;
 787         else if (len < 5 || len > UDP_PACKET_SIZE) /* 4 bytes crypt header + type + session */
 788                 return 0;
 789
 790         /*
 791          * Reply to ping packet
 792          * The second and third uint32_t are the timestamp, which will be returned unmodified
 793          */
 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));
 800
 801                 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
 802                 return 0;
 803         }
 804
 805         itr = NULL;
 806
 807         while (Client_iterate(&itr) != NULL) {
 808                 if (memcmp(itr->key, key, KEY_LENGTH) == 0) {
 809                         if (!checkDecrypt(itr, encrypted, buffer, len))
 810                                 goto out;
 811                         break;
 812                 }
 813         }
 814         if (itr == NULL) { /* Unknown peer */
 815                 struct sockaddr_storage itraddressstorage;
 816                 uint8_t itraddress[4 * sizeof(in_addr_t)];
 817                 int addresslength;
 818
 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);
 824                         } else {
 825                                 memcpy(itraddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
 826                                 addresslength = 4 * sizeof(in_addr_t);
 827                         }
 828
 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));
 836                                         break;
 837                                 }
 838                         }
 839                 } /* while */
 840         }
 841         if (itr == NULL) { /* Couldn't find this peer among connected clients */
 842                 goto out;
 843         }
 844
 845         itr->bUDP = true;
 846         len -= 4; /* Adjust for crypt header */
 847         msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
 848
 849         char *clientAddressString = NULL;
 850
 851         switch (msgType) {
 852                 case UDPVoiceSpeex:
 853                 case UDPVoiceCELTAlpha:
 854                 case UDPVoiceCELTBeta:
 855                         if (bOpus)
 856                                 break;
 857                 case UDPVoiceOpus:
 858                         Client_voiceMsg(itr, buffer, len);
 859                         break;
 860                 case UDPPing:
 861                         Log_debug("UDP Ping reply len %d", len);
 862                         Client_send_udp(itr, buffer, len);
 863                         break;
 864                 default:
 865                         clientAddressString = Util_clientAddressToString(itr);
 866                         Log_debug("Unknown UDP message type from %s port %d", clientAddressString, fromport);
 867                         free(clientAddressString);
 868                         break;
 869         }
 870
 871 out:
 872         return 0;
 873 }
 874
 875 static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
 876 {
 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);
 882                 else
 883                         Client_send_udp(dst, data, len - poslen);
 884         }
 885 }
 886
 887 /* Handle decrypted voice message */
 888 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
 889 {
 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;
 897         voicetarget_t *vt;
 898
 899         channel_t *ch = (channel_t *)client->channel;
 900         struct dlist *itr;
 901
 902         if (!client->authenticated || client->mute || client->self_mute || ch->silent)
 903                 goto out;
 904
 905         packetsize = 20 + 8 + 4 + len;
 906         if (client->availableBandwidth - packetsize < 0)
 907                 goto out; /* Discard */
 908         client->availableBandwidth -= packetsize;
 909
 910         Timer_restart(&client->idleTime);
 911         Timer_restart(&client->lastActivity);
 912
 913         counter = Pds_get_numval(pdi); /* step past session id */
 914         if ((type >> 5) != UDPVoiceOpus) {
 915                 do {
 916                         counter = Pds_next8(pdi);
 917                         offset = Pds_skip(pdi, counter & 0x7f);
 918                 } while ((counter & 0x80) && offset > 0);
 919         } else {
 920                 size = Pds_get_numval(pdi);
 921                 Pds_skip(pdi, size & 0x1fff);
 922         }
 923
 924         poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
 925
 926         Pds_add_numval(pds, client->sessionId);
 927         Pds_append_data_nosize(pds, data + 1, len - 1);
 928
 929         if (target == 0x1f) { /* Loopback */
 930                 buffer[0] = (uint8_t) type;
 931                 Client_send_udp(client, buffer, pds->offset + 1);
 932         }
 933         else if (target == 0) { /* regular channel speech */
 934                 buffer[0] = (uint8_t) type;
 935
 936                 if (ch == NULL)
 937                         goto out;
 938
 939                 list_iterate(itr, &ch->clients) {
 940                         client_t *c;
 941                         c = list_get_entry(itr, client_t, chan_node);
 942                         Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 943                 }
 944         } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
 945                 int i;
 946                 channel_t *ch;
 947                 /* Channels */
 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);
 952                         if (ch == NULL)
 953                                 continue;
 954                         list_iterate(itr, &ch->clients) {
 955                                 client_t *c;
 956                                 c = list_get_entry(itr, client_t, chan_node);
 957                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 958                         }
 959                         /* Channel links */
 960                         if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
 961                                 struct dlist *ch_itr;
 962                                 list_iterate(ch_itr, &ch->channel_links) {
 963                                         channellist_t *chl;
 964                                         channel_t *ch_link;
 965                                         chl = list_get_entry(ch_itr, channellist_t, node);
 966                                         ch_link = chl->chan;
 967                                         list_iterate(itr, &ch_link->clients) {
 968                                                 client_t *c;
 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);
 972                                         }
 973                                 }
 974                         }
 975                         /* children */
 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) {
 981                                         channel_t *sub;
 982                                         sub = list_get_entry(ch_itr, channellist_t, node)->chan;
 983                                         list_iterate(itr, &sub->clients) {
 984                                                 client_t *c;
 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);
 988                                         }
 989                                 }
 990                                 Chan_freeTreeList(&chanlist);
 991                         }
 992                 }
 993                 /* Sessions */
 994                 for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
 995                         client_t *c;
 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);
1001                                         break;
1002                                 }
1003                         }
1004                 }
1005         }
1006 out:
1007         Pds_free(pds);
1008         Pds_free(pdi);
1009
1010         return 0;
1011 }
1012
1013 static int Client_send_udp(client_t *client, uint8_t *data, int len)
1014 {
1015         uint8_t *buf, *mbuf;
1016
1017         int udpsock = (client->remote_udp.ss_family == AF_INET) ? udpsocks[0] : udpsocks[(hasv4) ? 1 : 0];
1018
1019         if (Util_clientAddressToPortUDP(client) != 0 && CryptState_isValid(&client->cryptState) &&
1020                 client->bUDP) {
1021 #if defined(__LP64__)
1022                 buf = mbuf = Memory_safeMalloc(1, len + 4 + 16);
1023                 buf += 4;
1024 #else
1025                 mbuf = buf = Memory_safeMalloc(1, len + 4);
1026 #endif
1027                 CryptState_encrypt(&client->cryptState, data, buf, len);
1028
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);
1031 #else
1032                         sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, sizeof(struct sockaddr_storage));
1033 #endif
1034
1035                 free(mbuf);
1036         } else {
1037                 message_t *msg;
1038                 msg = Msg_CreateVoiceMsg(data, len);
1039                 Client_send_message(client, msg);
1040         }
1041         return 0;
1042 }