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