src/client.c

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