src/client.c

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