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, char *text)
 668 {
 669         char *message;
 670         uint32_t *tree_id;
 671         message_t *sendmsg = NULL;
 672
 673         message = Memory_safeMalloc(1, strlen(text) + 1);
 674         tree_id = Memory_safeMalloc(1, sizeof(uint32_t));
 675         *tree_id = 0;
 676         sendmsg = Msg_create(TextMessage);
 677         sendmsg->payload.textMessage->message = message;
 678         sendmsg->payload.textMessage->n_tree_id = 1;
 679         sendmsg->payload.textMessage->tree_id = tree_id;
 680         strcpy(message, text);
 681         Client_send_message(client, sendmsg);
 682 }
 683
 684
 685 int Client_send_message_except(client_t *client, message_t *msg)
 686 {
 687         client_t *itr = NULL;
 688
 689         while (Client_iterate(&itr) != NULL) {
 690                 if (itr != client) {
 691                         Msg_inc_ref(msg); /* One extra reference for each new copy */
 692                         Log_debug("Msg %d to %s refcount %d",  msg->messageType, itr->username, msg->refcount);
 693                         Client_send_message(itr, msg);
 694                 }
 695         }
 696         Msg_free(msg); /* Consume caller's reference. */
 697
 698         return 0;
 699 }
 700
 701 int Client_send_message_except_ver(client_t *client, message_t *msg, uint32_t version)
 702 {
 703         client_t *itr = NULL;
 704
 705         while (Client_iterate(&itr) != NULL) {
 706                 if (itr != client) {
 707                         Msg_inc_ref(msg); /* One extra reference for each new copy */
 708                         Log_debug("Msg %d to %s refcount %d",  msg->messageType, itr->username, msg->refcount);
 709                         Client_send_message_ver(itr, msg, version);
 710                 }
 711         }
 712         Msg_free(msg); /* Consume caller's reference. */
 713
 714         return 0;
 715 }
 716
 717 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
 718 {
 719         if (CryptState_isValid(&client->cryptState) &&
 720                 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
 721                 return true;
 722
 723         if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
 724                 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
 725                         message_t *sendmsg;
 726                         Timer_restart(&client->cryptState.tLastRequest);
 727
 728                         sendmsg = Msg_create(CryptSetup);
 729                         Log_info_client(client, "Requesting voice channel crypt resync");
 730                         Client_send_message(client, sendmsg);
 731                 }
 732         }
 733         return false;
 734 }
 735
 736 #define UDP_PACKET_SIZE 1024
 737 int Client_read_udp(int udpsock)
 738 {
 739         int len;
 740         struct sockaddr_storage from;
 741         socklen_t fromlen = sizeof(struct sockaddr_storage);
 742         uint8_t key[KEY_LENGTH];
 743         client_t *itr;
 744         UDPMessageType_t msgType;
 745         uint8_t fromaddress[4 * sizeof(in_addr_t)];
 746         uint16_t fromport;
 747
 748 #if defined(__LP64__)
 749         uint8_t encbuff[UDP_PACKET_SIZE + 8];
 750         uint8_t *encrypted = encbuff + 4;
 751 #else
 752         uint8_t encrypted[UDP_PACKET_SIZE];
 753 #endif
 754         uint8_t buffer[UDP_PACKET_SIZE];
 755
 756         len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
 757
 758         memset(key, 0, KEY_LENGTH);
 759
 760         fromport = Util_addressToPort(&from);
 761
 762         if(from.ss_family == AF_INET) {
 763                 memcpy(fromaddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
 764                 memcpy(&key[0], &fromport, 2);
 765                 memcpy(&key[2], fromaddress, sizeof(in_addr_t));
 766         } else {
 767                 memcpy(fromaddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
 768                 memcpy(&key[0], &fromport, 2);
 769                 memcpy(&key[2], fromaddress, 4 * sizeof(in_addr_t));
 770         }
 771
 772         if (len <= 0)
 773                 return -1;
 774         else if (len < 5 || len > UDP_PACKET_SIZE) /* 4 bytes crypt header + type + session */
 775                 return 0;
 776
 777         /*
 778          * Reply to ping packet
 779          * The second and third uint32_t are the timestamp, which will be returned unmodified
 780          */
 781         if (len == 12 && *encrypted == 0) {
 782                 uint32_t *ping = (uint32_t *)encrypted;
 783                 ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
 784                 ping[3] = htonl((uint32_t)clientcount);
 785                 ping[4] = htonl((uint32_t)getIntConf(MAX_CLIENTS));
 786                 ping[5] = htonl((uint32_t)getIntConf(MAX_BANDWIDTH));
 787
 788                 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
 789                 return 0;
 790         }
 791
 792         itr = NULL;
 793
 794         while (Client_iterate(&itr) != NULL) {
 795                 if (memcmp(itr->key, key, KEY_LENGTH) == 0) {
 796                         if (!checkDecrypt(itr, encrypted, buffer, len))
 797                                 goto out;
 798                         break;
 799                 }
 800         }
 801         if (itr == NULL) { /* Unknown peer */
 802                 struct sockaddr_storage itraddressstorage;
 803                 uint8_t itraddress[4 * sizeof(in_addr_t)];
 804                 int addresslength;
 805
 806                 while (Client_iterate(&itr) != NULL) {
 807                         itraddressstorage = itr->remote_tcp;
 808                         if(itraddressstorage.ss_family == AF_INET) {
 809                                 memcpy(itraddress, &((struct sockaddr_in*)&from)->sin_addr, sizeof(in_addr_t));
 810                                 addresslength = sizeof(in_addr_t);
 811                         } else {
 812                                 memcpy(itraddress, &((struct sockaddr_in6*)&from)->sin6_addr, 4 * sizeof(in_addr_t));
 813                                 addresslength = 4 * sizeof(in_addr_t);
 814                         }
 815
 816                         if (memcmp(itraddress, fromaddress, addresslength) == 0) {
 817                                 if (checkDecrypt(itr, encrypted, buffer, len)) {
 818                                         memcpy(itr->key, key, KEY_LENGTH);
 819                                         char* clientAddressString = Util_clientAddressToString(itr);
 820                                         Log_info_client(itr, "New UDP connection from %s on port %d", clientAddressString, fromport);
 821                                         free(clientAddressString);
 822                                         memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_storage));
 823                                         break;
 824                                 }
 825                         }
 826                 } /* while */
 827         }
 828         if (itr == NULL) { /* Couldn't find this peer among connected clients */
 829                 goto out;
 830         }
 831
 832         itr->bUDP = true;
 833         len -= 4; /* Adjust for crypt header */
 834         msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
 835
 836         char *clientAddressString = NULL;
 837
 838         switch (msgType) {
 839                 case UDPVoiceSpeex:
 840                 case UDPVoiceCELTAlpha:
 841                 case UDPVoiceCELTBeta:
 842                         if (bOpus)
 843                                 break;
 844                 case UDPVoiceOpus:
 845                         Client_voiceMsg(itr, buffer, len);
 846                         break;
 847                 case UDPPing:
 848                         Log_debug("UDP Ping reply len %d", len);
 849                         Client_send_udp(itr, buffer, len);
 850                         break;
 851                 default:
 852                         clientAddressString = Util_clientAddressToString(itr);
 853                         Log_debug("Unknown UDP message type from %s port %d", clientAddressString, fromport);
 854                         free(clientAddressString);
 855                         break;
 856         }
 857
 858 out:
 859         return 0;
 860 }
 861
 862 static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
 863 {
 864         if (IS_AUTH(dst) && dst != src && !dst->deaf && !dst->self_deaf) {
 865                 if (poslen > 0 && /* Has positional data */
 866                         src->context != NULL && dst->context != NULL && /* ...both source and destination has context */
 867                         strcmp(src->context, dst->context) == 0) /* ...and the contexts match */
 868                         Client_send_udp(dst, data, len);
 869                 else
 870                         Client_send_udp(dst, data, len - poslen);
 871         }
 872 }
 873
 874 /* Handle decrypted voice message */
 875 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
 876 {
 877         uint8_t buffer[UDP_PACKET_SIZE];
 878         pds_t *pdi = Pds_create(data + 1, len - 1);
 879         pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
 880         unsigned int type = data[0] & 0xe0;
 881         unsigned int target = data[0] & 0x1f;
 882         unsigned int poslen, counter, size;
 883         int offset, packetsize;
 884         voicetarget_t *vt;
 885
 886         channel_t *ch = client->channel;
 887         struct dlist *itr;
 888
 889         if (!client->authenticated || client->mute || client->self_mute || ch->silent)
 890                 goto out;
 891
 892         packetsize = 20 + 8 + 4 + len;
 893         if (client->availableBandwidth - packetsize < 0)
 894                 goto out; /* Discard */
 895         client->availableBandwidth -= packetsize;
 896
 897         Timer_restart(&client->idleTime);
 898         Timer_restart(&client->lastActivity);
 899
 900         counter = Pds_get_numval(pdi); /* step past session id */
 901         if ((type >> 5) != UDPVoiceOpus) {
 902                 do {
 903                         counter = Pds_next8(pdi);
 904                         offset = Pds_skip(pdi, counter & 0x7f);
 905                 } while ((counter & 0x80) && offset > 0);
 906         } else {
 907                 size = Pds_get_numval(pdi);
 908                 Pds_skip(pdi, size & 0x1fff);
 909         }
 910
 911         poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
 912
 913         Pds_add_numval(pds, client->sessionId);
 914         Pds_append_data_nosize(pds, data + 1, len - 1);
 915
 916         if (target == 0x1f) { /* Loopback */
 917                 buffer[0] = (uint8_t) type;
 918                 Client_send_udp(client, buffer, pds->offset + 1);
 919         }
 920         else if (target == 0) { /* regular channel speech */
 921                 buffer[0] = (uint8_t) type;
 922
 923                 if (ch == NULL)
 924                         goto out;
 925
 926                 list_iterate(itr, &ch->clients) {
 927                         client_t *c;
 928                         c = list_get_entry(itr, client_t, chan_node);
 929                         Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 930                 }
 931         } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
 932                 int i;
 933                 channel_t *ch;
 934                 /* Channels */
 935                 for (i = 0; i < TARGET_MAX_CHANNELS && vt->channels[i].channel != -1; i++) {
 936                         buffer[0] = (uint8_t) (type | 1);
 937                         Log_debug("Whisper channel %d", vt->channels[i]);
 938                         ch = Chan_fromId(vt->channels[i].channel);
 939                         if (ch == NULL)
 940                                 continue;
 941                         list_iterate(itr, &ch->clients) {
 942                                 client_t *c;
 943                                 c = list_get_entry(itr, client_t, chan_node);
 944                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 945                         }
 946                         /* Channel links */
 947                         if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
 948                                 struct dlist *ch_itr;
 949                                 list_iterate(ch_itr, &ch->channel_links) {
 950                                         channellist_t *chl;
 951                                         channel_t *ch_link;
 952                                         chl = list_get_entry(ch_itr, channellist_t, node);
 953                                         ch_link = chl->chan;
 954                                         list_iterate(itr, &ch_link->clients) {
 955                                                 client_t *c;
 956                                                 c = list_get_entry(itr, client_t, chan_node);
 957                                                 Log_debug("Linked voice from %s -> %s", ch->name, ch_link->name);
 958                                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 959                                         }
 960                                 }
 961                         }
 962                         /* children */
 963                         if (vt->channels[i].children) {
 964                                 struct dlist chanlist, *ch_itr;
 965                                 init_list_entry(&chanlist);
 966                                 Chan_buildTreeList(ch, &chanlist);
 967                                 list_iterate(ch_itr, &chanlist) {
 968                                         channel_t *sub;
 969                                         sub = list_get_entry(ch_itr, channellist_t, node)->chan;
 970                                         list_iterate(itr, &sub->clients) {
 971                                                 client_t *c;
 972                                                 c = list_get_entry(itr, client_t, chan_node);
 973                                                 Log_debug("Child voice from %s -> %s", ch->name, sub->name);
 974                                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 975                                         }
 976                                 }
 977                                 Chan_freeTreeList(&chanlist);
 978                         }
 979                 }
 980                 /* Sessions */
 981                 for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
 982                         client_t *c;
 983                         buffer[0] = (uint8_t) (type | 2);
 984                         Log_debug("Whisper session %d", vt->sessions[i]);
 985                         while (Client_iterate(&c) != NULL) {
 986                                 if (c->sessionId == vt->sessions[i]) {
 987                                         Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 988                                         break;
 989                                 }
 990                         }
 991                 }
 992         }
 993 out:
 994         Pds_free(pds);
 995         Pds_free(pdi);
 996
 997         return 0;
 998 }
 999
1000 static int Client_send_udp(client_t *client, uint8_t *data, int len)
1001 {
1002         uint8_t *buf, *mbuf;
1003
1004         int udpsock = (client->remote_udp.ss_family == AF_INET) ? udpsocks[0] : udpsocks[(hasv4) ? 1 : 0];
1005
1006         if (Util_clientAddressToPortUDP(client) != 0 && CryptState_isValid(&client->cryptState) &&
1007                 client->bUDP) {
1008 #if defined(__LP64__)
1009                 buf = mbuf = Memory_safeMalloc(1, len + 4 + 16);
1010                 buf += 4;
1011 #else
1012                 mbuf = buf = Memory_safeMalloc(1, len + 4);
1013 #endif
1014                 CryptState_encrypt(&client->cryptState, data, buf, len);
1015
1016 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
1017                         sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, client->remote_tcp.ss_len);
1018 #else
1019                         sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, sizeof(struct sockaddr_storage));
1020 #endif
1021
1022                 free(mbuf);
1023         } else {
1024                 message_t *msg;
1025                 msg = Msg_CreateVoiceMsg(data, len);
1026                 Client_send_message(client, msg);
1027         }
1028         return 0;
1029 }