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 static client_t *Client_find_by_fd(int fd);
  58 void Client_free(client_t *client);
  59
  60 declare_list(clients);
  61 static int clientcount; /* = 0 */
  62 static int maxBandwidth;
  63 bool_t bOpus = true;
  64
  65 int iCodecAlpha, iCodecBeta;
  66 bool_t bPreferAlpha;
  67
  68 extern int* udpsocks;
  69 extern bool_t hasv4;
  70
  71 void Client_init()
  72 {
  73         maxBandwidth = getIntConf(MAX_BANDWIDTH) / 8; /* From bits/s -> bytes/s */
  74 }
  75
  76 int Client_count()
  77 {
  78         return clientcount;
  79 }
  80
  81 int Client_getfds(struct pollfd *pollfds)
  82 {
  83         struct dlist *itr;
  84         int i = 0;
  85         list_iterate(itr, &clients) {
  86                 client_t *c;
  87                 c = list_get_entry(itr, client_t, node);
  88                 pollfds[i].fd = c->tcpfd;
  89                 pollfds[i].events = POLLIN | POLLHUP | POLLERR;
  90                 if (c->txsize > 0 || c->readBlockedOnWrite) /* Data waiting to be sent? */
  91                         pollfds[i].events |= POLLOUT;
  92                 i++;
  93         }
  94         return i;
  95 }
  96
  97 void Client_janitor()
  98 {
  99         struct dlist *itr, *save;
 100         int bwTop = maxBandwidth + maxBandwidth / 4;
 101         list_iterate_safe(itr, save, &clients) {
 102                 client_t *c;
 103                 c = list_get_entry(itr, client_t, node);
 104                 Log_debug("Client %s BW available %d", c->username, c->availableBandwidth);
 105                 c->availableBandwidth += maxBandwidth;
 106                 if (c->availableBandwidth > bwTop)
 107                         c->availableBandwidth = bwTop;
 108
 109                 if (Timer_isElapsed(&c->lastActivity, 1000000LL * INACTIVITY_TIMEOUT)) {
 110                         /* No activity from client - assume it is lost and close. */
 111                         Log_info_client(c, "Timeout, closing.");
 112                         Client_free(c);
 113                 }
 114         }
 115         Ban_pruneBanned();
 116 }
 117
 118 void Client_codec_add(client_t *client, int codec)
 119 {
 120         codec_t *cd = Memory_safeMalloc(1, sizeof(codec_t));
 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 = Memory_safeMalloc(1, sizeof(token_t));
 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 const *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 = Memory_safeCalloc(1, sizeof(codec_t));
 229                                 init_list_entry(&cd->node);
 230                                 cd->codec = codec_itr->codec;
 231                                 cd->count = 1;
 232                                 list_add_tail(&cd->node, &codec_list);
 233                         }
 234                 }
 235                 users++;
 236                 if (client_itr->bOpus)
 237                         opus++;
 238         }
 239         if (users == 0)
 240                 return;
 241
 242         enableOpus = ((opus * 100 / users) >= getIntConf(OPUS_THRESHOLD));
 243
 244         list_iterate(itr, &codec_list) {
 245                 cd = list_get_entry(itr, codec_t, node);
 246                 if (cd->count > max) {
 247                         max = cd->count;
 248                         version = cd->codec;
 249                 }
 250         }
 251         list_iterate_safe(itr, save, &codec_list) {
 252                 list_del(&list_get_entry(itr, codec_t, node)->node);
 253                 free(list_get_entry(itr, codec_t, node));
 254         }
 255
 256         current_version = bPreferAlpha ? iCodecAlpha : iCodecBeta;
 257         if (current_version != version) {
 258                 // If we don't already use the compat bitstream version set
 259                 // it as alpha and announce it. If another codec now got the
 260                 // majority set it as the opposite of the currently valid bPreferAlpha
 261                 // and announce it.
 262                 if (version == (uint32_t)0x8000000b)
 263                         bPreferAlpha = true;
 264                 else
 265                         bPreferAlpha = !bPreferAlpha;
 266
 267                 if (bPreferAlpha)
 268                         iCodecAlpha = version;
 269                 else
 270                         iCodecBeta = version;
 271         } else if (bOpus && enableOpus) {
 272                 if (connectingClient && !connectingClient->bOpus)
 273                         Client_textmessage(connectingClient, OPUS_WARN_USING);
 274                 return;
 275         }
 276
 277         sendmsg = Msg_create(CodecVersion);
 278         sendmsg->payload.codecVersion->alpha = iCodecAlpha;
 279         sendmsg->payload.codecVersion->beta = iCodecBeta;
 280         sendmsg->payload.codecVersion->prefer_alpha = bPreferAlpha;
 281         sendmsg->payload.codecVersion->has_opus = true;
 282         sendmsg->payload.codecVersion->opus = enableOpus;
 283
 284         Client_send_message_except(NULL, sendmsg);
 285
 286         if (enableOpus && !bOpus) {
 287                 client_itr = NULL;
 288                 while (Client_iterate(&client_itr) != NULL) {
 289                         if ((client_itr->authenticated || client_itr == connectingClient) &&
 290                                 !client_itr->bOpus) {
 291                                 Client_textmessage(client_itr, OPUS_WARN_SWITCHING);
 292                         }
 293                 }
 294                 Log_info("OPUS codec %s", bOpus ? "enabled" : "disabled");
 295         }
 296
 297         bOpus = enableOpus;
 298 }
 299
 300 static int findFreeSessionId()
 301 {
 302         int id;
 303         client_t *itr = NULL;
 304
 305         for (id = 1; id < INT_MAX; id++) {
 306                 itr = NULL;
 307                 while ((itr = Client_iterate(&itr)) != NULL) {
 308                         if (itr->sessionId == id)
 309                                 break;
 310                 }
 311                 if (itr == NULL) /* Found free id */
 312                         return id;
 313         }
 314         return -1;
 315 }
 316
 317 int Client_add(int fd, struct sockaddr_storage *remote)
 318 {
 319         client_t* newclient;
 320         message_t *sendmsg;
 321         char* addressString = NULL;
 322
 323         if (Ban_isBannedAddr(remote)) {
 324                 addressString = Util_addressToString(remote);
 325                 Log_info("Address %s banned. Disconnecting", addressString);
 326                 free(addressString);
 327                 return -1;
 328         }
 329
 330         newclient = Memory_safeCalloc(1, sizeof(client_t));
 331
 332         newclient->tcpfd = fd;
 333         memcpy(&newclient->remote_tcp, remote, sizeof(struct sockaddr_storage));
 334         newclient->ssl = SSLi_newconnection(&newclient->tcpfd, &newclient->SSLready);
 335         if (newclient->ssl == NULL) {
 336                 addressString = Util_addressToString(remote);
 337                 Log_warn("SSL negotiation failed with %s on port %d", addressString, Util_addressToPort(remote));
 338                 free(addressString);
 339                 free(newclient);
 340                 return -1;
 341         }
 342         newclient->availableBandwidth = maxBandwidth;
 343         Timer_init(&newclient->lastActivity);
 344         Timer_init(&newclient->connectTime);
 345         Timer_init(&newclient->idleTime);
 346         newclient->sessionId = findFreeSessionId();
 347         if (newclient->sessionId < 0)
 348                 Log_fatal("Could not find a free session ID");
 349
 350         init_list_entry(&newclient->txMsgQueue);
 351         init_list_entry(&newclient->chan_node);
 352         init_list_entry(&newclient->node);
 353         init_list_entry(&newclient->voicetargets);
 354         init_list_entry(&newclient->codecs);
 355         init_list_entry(&newclient->tokens);
 356
 357         list_add_tail(&newclient->node, &clients);
 358         clientcount++;
 359
 360         /* Send version message to client */
 361         sendmsg = Msg_create(Version);
 362         sendmsg->payload.version->has_version = true;
 363         sendmsg->payload.version->version = PROTOCOL_VERSION;
 364         sendmsg->payload.version->release = strdup(UMURMUR_VERSION);
 365         sendmsg->payload.version->os = strdup(system_string);
 366         sendmsg->payload.version->os_version = strdup(version_string);
 367         Client_send_message(newclient, sendmsg);
 368
 369         return 0;
 370 }
 371
 372 void Client_free(client_t *client)
 373 {
 374         struct dlist *itr, *save;
 375         message_t *sendmsg;
 376         bool_t authenticatedLeft = client->authenticated;
 377
 378         if (client->authenticated) {
 379                 int leave_id;
 380                 leave_id = Chan_userLeave(client);
 381                 if (leave_id > 0) { /* Remove temp channel */
 382                         sendmsg = Msg_create(ChannelRemove);
 383                         sendmsg->payload.channelRemove->channel_id = leave_id;
 384                         Client_send_message_except(client, sendmsg);
 385                 }
 386                 sendmsg = Msg_create(UserRemove);
 387                 sendmsg->payload.userRemove->session = client->sessionId;
 388                 Client_send_message_except(client, sendmsg);
 389         }
 390         list_iterate_safe(itr, save, &client->txMsgQueue) {
 391                 list_del(&list_get_entry(itr, message_t, node)->node);
 392                 Msg_free(list_get_entry(itr, message_t, node));
 393         }
 394         Client_codec_free(client);
 395         Voicetarget_free_all(client);
 396         Client_token_free(client);
 397
 398         list_del(&client->node);
 399         if (client->ssl)
 400                 SSLi_free(client->ssl);
 401         close(client->tcpfd);
 402         clientcount--;
 403
 404         free(client->release);
 405         free(client->os);
 406         free(client->os_version);
 407         free(client->username);
 408         free(client->context);
 409         free(client);
 410
 411         if (authenticatedLeft)
 412                 recheckCodecVersions(NULL); /* Can use better codec now? */
 413 }
 414
 415 void Client_close(client_t *client)
 416 {
 417         SSLi_shutdown(client->ssl);
 418         client->shutdown_wait = true;
 419 }
 420
 421 void Client_disconnect_all()
 422 {
 423         struct dlist *itr, *save;
 424
 425         list_iterate_safe(itr, save, &clients) {
 426                 Client_free(list_get_entry(itr, client_t, node));
 427         }
 428 }
 429
 430 client_t *Client_find_by_fd(int fd)
 431 {
 432         struct dlist *itr;
 433
 434         list_iterate(itr, &clients) {
 435                 client_t *client = list_get_entry(itr, client_t, node);
 436
 437                 if (client->tcpfd == fd) {
 438                         return client;
 439                 }
 440         }
 441
 442         return NULL;
 443 }
 444
 445 int Client_read_fd(int fd)
 446 {
 447         client_t *client;
 448
 449         client = Client_find_by_fd(fd);
 450
 451         if (client != NULL)
 452                 return Client_read(client);
 453         else
 454                 return -1;
 455 }
 456
 457 int Client_read(client_t *client)
 458 {
 459         int rc;
 460
 461         Timer_restart(&client->lastActivity);
 462
 463         if (client->writeBlockedOnRead) {
 464                 client->writeBlockedOnRead = false;
 465                 Log_debug("Client_read: writeBlockedOnRead == true");
 466                 return Client_write(client);
 467         }
 468
 469         if (client->shutdown_wait) {
 470                 Client_free(client);
 471                 return 0;
 472         }
 473         if (!client->SSLready) {
 474                 int rc;
 475                 rc = SSLi_nonblockaccept(client->ssl, &client->SSLready);
 476                 if (rc < 0) {
 477                         Client_free(client);
 478                         return -1;
 479                 }
 480         }
 481
 482         do {
 483                 errno = 0;
 484                 if (!client->msgsize)
 485                         rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
 486                 else
 487                         rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
 488                 if (rc > 0) {
 489                         message_t *msg;
 490                         client->rxcount += rc;
 491                         if (!client->msgsize && client->rxcount >= 6) {
 492                                 uint32_t msgLen;
 493                                 memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
 494                                 client->msgsize = ntohl(msgLen);
 495                         }
 496                         if (client->msgsize > BUFSIZE - 6) {
 497                                 /* XXX - figure out how to handle this. A large size here can represent two cases:
 498                                  * 1. A valid size. The only message that is this big is UserState message with a big texture
 499                                  * 2. An invalid size = protocol error, e.g. connecting with a 1.1.x client
 500                                  */
 501                                 //                Log_warn("Too big message received (%d bytes). Playing safe and disconnecting client %s:%d",
 502                                 //                         client->msgsize, inet_ntoa(client->remote_tcp.sin_addr), ntohs(client->remote_tcp.sin_port));
 503                                 Client_free(client);
 504                                 return -1;
 505                                 /* client->rxcount = client->msgsize = 0; */
 506                         }
 507                         else if (client->rxcount == client->msgsize + 6) { /* Got all of the message */
 508                                 msg = Msg_networkToMessage(client->rxbuf, client->msgsize + 6);
 509                                 /* pass messsage to handler */
 510                                 if (msg)
 511                                         Mh_handle_message(client, msg);
 512                                 client->rxcount = client->msgsize = 0;
 513                         }
 514                 } else /* rc <= 0 */ {
 515                         if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
 516                                 return 0;
 517                         }
 518                         else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
 519                                 client->readBlockedOnWrite = true;
 520                                 return 0;
 521                         }
 522                         else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_ZERO_RETURN ||
 523                                 SSLi_get_error(client->ssl, rc) == 0) {
 524                                 Log_info_client(client, "Connection closed by peer");
 525                                 Client_close(client);
 526                         }
 527                         else {
 528                                 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
 529                                         if (errno == 0)
 530                                                 Log_info_client(client, "Connection closed by peer");
 531                                         else
 532                                                 Log_info_client(client,"Error: %s  - Closing connection (code %d)",
 533                                                         strerror(errno));
 534                                 }
 535                                 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
 536                                         Log_info_client(client, "Connection reset by peer");
 537                                 }
 538                                 else {
 539                                         Log_info_client(client, "SSL error: %d - Closing connection", SSLi_get_error(client->ssl, rc));
 540                                 }
 541                                 Client_free(client);
 542                                 return -1;
 543                         }
 544                 }
 545         } while (SSLi_data_pending(client->ssl));
 546
 547         return 0;
 548 }
 549
 550 int Client_write_fd(int fd)
 551 {
 552         client_t *client;
 553
 554         client = Client_find_by_fd(fd);
 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, const char *text)
 668 {
 669         char *message;
 670         uint32_t *tree_id;
 671         message_t *sendmsg = NULL;
 672
 673         message = strdup(text);
 674
 675         if (message == NULL)
 676                 Log_fatal("Out of memory");
 677
 678         tree_id = Memory_safeMalloc(1, sizeof(uint32_t));
 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
 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
 693         while (Client_iterate(&itr) != NULL) {
 694                 if (itr != client) {
 695                         Msg_inc_ref(msg); /* One extra reference for each new copy */
 696                         Log_debug("Msg %d to %s refcount %d",  msg->messageType, itr->username, msg->refcount);
 697                         Client_send_message(itr, msg);
 698                 }
 699         }
 700         Msg_free(msg); /* Consume caller's reference. */
 701
 702         return 0;
 703 }
 704
 705 int Client_send_message_except_ver(client_t *client, message_t *msg, uint32_t version)
 706 {
 707         client_t *itr = NULL;
 708
 709         while (Client_iterate(&itr) != NULL) {
 710                 if (itr != client) {
 711                         Msg_inc_ref(msg); /* One extra reference for each new copy */
 712                         Log_debug("Msg %d to %s refcount %d",  msg->messageType, itr->username, msg->refcount);
 713                         Client_send_message_ver(itr, msg, version);
 714                 }
 715         }
 716         Msg_free(msg); /* Consume caller's reference. */
 717
 718         return 0;
 719 }
 720
 721 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
 722 {
 723         if (CryptState_isValid(&client->cryptState) &&
 724                 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
 725                 return true;
 726
 727         if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
 728                 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
 729                         message_t *sendmsg;
 730                         Timer_restart(&client->cryptState.tLastRequest);
 731
 732                         sendmsg = Msg_create(CryptSetup);
 733                         Log_info_client(client, "Requesting voice channel crypt resync");
 734                         Client_send_message(client, sendmsg);
 735                 }
 736         }
 737         return false;
 738 }
 739
 740 #define UDP_PACKET_SIZE 1024
 741 int Client_read_udp(int udpsock)
 742 {
 743         int len;
 744         struct sockaddr_storage from;
 745         socklen_t fromlen = sizeof(struct sockaddr_storage);
 746         uint8_t key[KEY_LENGTH];
 747         client_t *itr;
 748         UDPMessageType_t msgType;
 749         uint8_t fromaddress[4 * sizeof(in_addr_t)];
 750         uint16_t fromport;
 751
 752 #if defined(__LP64__)
 753         uint8_t encbuff[UDP_PACKET_SIZE + 8];
 754         uint8_t *encrypted = encbuff + 4;
 755 #else
 756         uint8_t encrypted[UDP_PACKET_SIZE];
 757 #endif
 758         uint8_t buffer[UDP_PACKET_SIZE];
 759
 760         len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
 761
 762         memset(key, 0, KEY_LENGTH);
 763
 764         fromport = Util_addressToPort(&from);
 765
 766         if(from.ss_family == AF_INET) {
 767                 memcpy(fromaddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
 768                 memcpy(&key[0], &fromport, 2);
 769                 memcpy(&key[2], fromaddress, sizeof(in_addr_t));
 770         } else {
 771                 memcpy(fromaddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
 772                 memcpy(&key[0], &fromport, 2);
 773                 memcpy(&key[2], fromaddress, 4 * sizeof(in_addr_t));
 774         }
 775
 776         if (len <= 0)
 777                 return -1;
 778         else if (len < 5 || len > UDP_PACKET_SIZE) /* 4 bytes crypt header + type + session */
 779                 return 0;
 780
 781         /*
 782          * Reply to ping packet
 783          * The second and third uint32_t are the timestamp, which will be returned unmodified
 784          */
 785         if (len == 12 && *encrypted == 0) {
 786                 uint32_t *ping = (uint32_t *)encrypted;
 787                 ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
 788                 ping[3] = htonl((uint32_t)clientcount);
 789                 ping[4] = htonl((uint32_t)getIntConf(MAX_CLIENTS));
 790                 ping[5] = htonl((uint32_t)getIntConf(MAX_BANDWIDTH));
 791
 792                 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
 793                 return 0;
 794         }
 795
 796         itr = NULL;
 797
 798         while (Client_iterate(&itr) != NULL) {
 799                 if (memcmp(itr->key, key, KEY_LENGTH) == 0) {
 800                         if (!checkDecrypt(itr, encrypted, buffer, len))
 801                                 goto out;
 802                         break;
 803                 }
 804         }
 805         if (itr == NULL) { /* Unknown peer */
 806                 struct sockaddr_storage itraddressstorage;
 807                 uint8_t itraddress[4 * sizeof(in_addr_t)];
 808                 int addresslength;
 809
 810                 while (Client_iterate(&itr) != NULL) {
 811                         itraddressstorage = itr->remote_tcp;
 812                         if(itraddressstorage.ss_family == AF_INET) {
 813                                 memcpy(itraddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
 814                                 addresslength = sizeof(in_addr_t);
 815                         } else {
 816                                 memcpy(itraddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
 817                                 addresslength = 4 * sizeof(in_addr_t);
 818                         }
 819
 820                         if (memcmp(itraddress, fromaddress, addresslength) == 0) {
 821                                 if (checkDecrypt(itr, encrypted, buffer, len)) {
 822                                         memcpy(itr->key, key, KEY_LENGTH);
 823                                         char* clientAddressString = Util_clientAddressToString(itr);
 824                                         Log_info_client(itr, "New UDP connection from %s on port %d", clientAddressString, fromport);
 825                                         free(clientAddressString);
 826                                         memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_storage));
 827                                         break;
 828                                 }
 829                         }
 830                 } /* while */
 831         }
 832         if (itr == NULL) { /* Couldn't find this peer among connected clients */
 833                 goto out;
 834         }
 835
 836         itr->bUDP = true;
 837         len -= 4; /* Adjust for crypt header */
 838         msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
 839
 840         char *clientAddressString = NULL;
 841
 842         switch (msgType) {
 843                 case UDPVoiceSpeex:
 844                 case UDPVoiceCELTAlpha:
 845                 case UDPVoiceCELTBeta:
 846                         if (bOpus)
 847                                 break;
 848                 case UDPVoiceOpus:
 849                         Client_voiceMsg(itr, buffer, len);
 850                         break;
 851                 case UDPPing:
 852                         Log_debug("UDP Ping reply len %d", len);
 853                         Client_send_udp(itr, buffer, len);
 854                         break;
 855                 default:
 856                         clientAddressString = Util_clientAddressToString(itr);
 857                         Log_debug("Unknown UDP message type from %s port %d", clientAddressString, fromport);
 858                         free(clientAddressString);
 859                         break;
 860         }
 861
 862 out:
 863         return 0;
 864 }
 865
 866 static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
 867 {
 868         if (IS_AUTH(dst) && dst != src && !dst->deaf && !dst->self_deaf) {
 869                 if (poslen > 0 && /* Has positional data */
 870                         src->context != NULL && dst->context != NULL && /* ...both source and destination has context */
 871                         strcmp(src->context, dst->context) == 0) /* ...and the contexts match */
 872                         Client_send_udp(dst, data, len);
 873                 else
 874                         Client_send_udp(dst, data, len - poslen);
 875         }
 876 }
 877
 878 /* Handle decrypted voice message */
 879 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
 880 {
 881         uint8_t buffer[UDP_PACKET_SIZE];
 882         pds_t *pdi = Pds_create(data + 1, len - 1);
 883         pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
 884         unsigned int type = data[0] & 0xe0;
 885         unsigned int target = data[0] & 0x1f;
 886         unsigned int poslen, counter, size;
 887         int offset, packetsize;
 888         voicetarget_t *vt;
 889
 890         channel_t *ch = client->channel;
 891         struct dlist *itr;
 892
 893         if (!client->authenticated || client->mute || client->self_mute || ch->silent)
 894                 goto out;
 895
 896         packetsize = 20 + 8 + 4 + len;
 897         if (client->availableBandwidth - packetsize < 0)
 898                 goto out; /* Discard */
 899         client->availableBandwidth -= packetsize;
 900
 901         Timer_restart(&client->idleTime);
 902         Timer_restart(&client->lastActivity);
 903
 904         counter = Pds_get_numval(pdi); /* step past session id */
 905         if ((type >> 5) != UDPVoiceOpus) {
 906                 do {
 907                         counter = Pds_next8(pdi);
 908                         offset = Pds_skip(pdi, counter & 0x7f);
 909                 } while ((counter & 0x80) && offset > 0);
 910         } else {
 911                 size = Pds_get_numval(pdi);
 912                 Pds_skip(pdi, size & 0x1fff);
 913         }
 914
 915         poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
 916
 917         Pds_add_numval(pds, client->sessionId);
 918         Pds_append_data_nosize(pds, data + 1, len - 1);
 919
 920         if (target == 0x1f) { /* Loopback */
 921                 buffer[0] = (uint8_t) type;
 922                 Client_send_udp(client, buffer, pds->offset + 1);
 923         }
 924         else if (target == 0) { /* regular channel speech */
 925                 buffer[0] = (uint8_t) type;
 926
 927                 if (ch == NULL)
 928                         goto out;
 929
 930                 list_iterate(itr, &ch->clients) {
 931                         client_t *c;
 932                         c = list_get_entry(itr, client_t, chan_node);
 933                         Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 934                 }
 935         } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
 936                 int i;
 937                 channel_t *ch;
 938                 /* Channels */
 939                 for (i = 0; i < TARGET_MAX_CHANNELS && vt->channels[i].channel != -1; i++) {
 940                         buffer[0] = (uint8_t) (type | 1);
 941                         Log_debug("Whisper channel %d", vt->channels[i]);
 942                         ch = Chan_fromId(vt->channels[i].channel);
 943                         if (ch == NULL)
 944                                 continue;
 945                         list_iterate(itr, &ch->clients) {
 946                                 client_t *c;
 947                                 c = list_get_entry(itr, client_t, chan_node);
 948                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 949                         }
 950                         /* Channel links */
 951                         if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
 952                                 struct dlist *ch_itr;
 953                                 list_iterate(ch_itr, &ch->channel_links) {
 954                                         channellist_t *chl;
 955                                         channel_t *ch_link;
 956                                         chl = list_get_entry(ch_itr, channellist_t, node);
 957                                         ch_link = chl->chan;
 958                                         list_iterate(itr, &ch_link->clients) {
 959                                                 client_t *c;
 960                                                 c = list_get_entry(itr, client_t, chan_node);
 961                                                 Log_debug("Linked voice from %s -> %s", ch->name, ch_link->name);
 962                                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 963                                         }
 964                                 }
 965                         }
 966                         /* children */
 967                         if (vt->channels[i].children) {
 968                                 struct dlist chanlist, *ch_itr;
 969                                 init_list_entry(&chanlist);
 970                                 Chan_buildTreeList(ch, &chanlist);
 971                                 list_iterate(ch_itr, &chanlist) {
 972                                         channel_t *sub;
 973                                         sub = list_get_entry(ch_itr, channellist_t, node)->chan;
 974                                         list_iterate(itr, &sub->clients) {
 975                                                 client_t *c;
 976                                                 c = list_get_entry(itr, client_t, chan_node);
 977                                                 Log_debug("Child voice from %s -> %s", ch->name, sub->name);
 978                                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 979                                         }
 980                                 }
 981                                 Chan_freeTreeList(&chanlist);
 982                         }
 983                 }
 984                 /* Sessions */
 985                 for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
 986                         client_t *c = NULL;
 987                         buffer[0] = (uint8_t) (type | 2);
 988                         Log_debug("Whisper session %d", vt->sessions[i]);
 989                         while (Client_iterate(&c) != NULL) {
 990                                 if (c->sessionId == vt->sessions[i]) {
 991                                         Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 992                                         break;
 993                                 }
 994                         }
 995                 }
 996         }
 997 out:
 998         Pds_free(pds);
 999         Pds_free(pdi);
1000
1001         return 0;
1002 }
1003
1004 static int Client_send_udp(client_t *client, uint8_t *data, int len)
1005 {
1006         uint8_t *buf, *mbuf;
1007
1008         int udpsock = (client->remote_udp.ss_family == AF_INET) ? udpsocks[0] : udpsocks[(hasv4) ? 1 : 0];
1009
1010         if (Util_clientAddressToPortUDP(client) != 0 && CryptState_isValid(&client->cryptState) &&
1011                 client->bUDP) {
1012 #if defined(__LP64__)
1013                 buf = mbuf = Memory_safeMalloc(1, len + 4 + 16);
1014                 buf += 4;
1015 #else
1016                 mbuf = buf = Memory_safeMalloc(1, len + 4);
1017 #endif
1018                 CryptState_encrypt(&client->cryptState, data, buf, len);
1019
1020 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
1021                         sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, client->remote_tcp.ss_len);
1022 #else
1023                         sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, sizeof(struct sockaddr_storage));
1024 #endif
1025
1026                 free(mbuf);
1027         } else {
1028                 message_t *msg;
1029                 msg = Msg_CreateVoiceMsg(data, len);
1030                 Client_send_message(client, msg);
1031         }
1032         return 0;
1033 }