src/client.c

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