src/client.c

   1 /* Copyright (C) 2009-2010, Martin Johansson <martin@fatbob.nu>
   2    Copyright (C) 2005-2010, 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
  49 extern char system_string[], version_string[];
  50
  51 static int Client_read(client_t *client);
  52 static int Client_write(client_t *client);
  53 static int Client_send_udp(client_t *client, uint8_t *data, int len);
  54 void Client_free(client_t *client);
  55
  56 declare_list(clients);
  57 static int clientcount; /* = 0 */
  58 static int maxBandwidth;
  59
  60 int iCodecAlpha, iCodecBeta;
  61 bool_t bPreferAlpha;
  62
  63 extern int udpsock;
  64
  65 void Client_init()
  66 {
  67         maxBandwidth = getIntConf(MAX_BANDWIDTH) / 8; /* From bits/s -> bytes/s */
  68 }
  69
  70 int Client_count()
  71 {
  72         return clientcount;
  73 }
  74
  75 int Client_getfds(struct pollfd *pollfds)
  76 {
  77         struct dlist *itr;
  78         int i = 0;
  79         list_iterate(itr, &clients) {
  80                 client_t *c;
  81                 c = list_get_entry(itr, client_t, node);
  82                 pollfds[i].fd = c->tcpfd;
  83                 pollfds[i].events = POLLIN | POLLHUP | POLLERR;
  84                 if (c->txsize > 0 || c->readBlockedOnWrite) /* Data waiting to be sent? */
  85                         pollfds[i].events |= POLLOUT;
  86                 i++;
  87         }
  88         return i;
  89 }
  90
  91 void Client_janitor()
  92 {
  93         struct dlist *itr;
  94         int bwTop = maxBandwidth + maxBandwidth / 4;
  95         list_iterate(itr, &clients) {
  96                 client_t *c;
  97                 c = list_get_entry(itr, client_t, node);
  98                 Log_debug("Client %s BW available %d", c->username, c->availableBandwidth);
  99                 c->availableBandwidth += maxBandwidth;
 100                 if (c->availableBandwidth > bwTop)
 101                         c->availableBandwidth = bwTop;
 102
 103                 if (Timer_isElapsed(&c->lastActivity, 1000000LL * INACTICITY_TIMEOUT)) {
 104                         /* No activity from client - assume it is lost and close. */
 105                         Log_info_client(c, "Timeout, closing.");
 106                         Client_free(c);
 107                 }
 108         }
 109 }
 110
 111 void Client_codec_add(client_t *client, int codec)
 112 {
 113         codec_t *cd = malloc(sizeof(codec_t));
 114         if (cd == NULL)
 115                 Log_fatal("Out of memory");
 116         init_list_entry(&cd->node);
 117         cd->codec = codec;
 118         list_add_tail(&cd->node, &client->codecs);
 119 }
 120
 121 void Client_codec_free(client_t *client)
 122 {
 123         struct dlist *itr, *save;
 124         list_iterate_safe(itr, save, &client->codecs) {
 125                 list_del(&list_get_entry(itr, codec_t, node)->node);
 126                 free(list_get_entry(itr, codec_t, node));
 127         }
 128 }
 129
 130 codec_t *Client_codec_iterate(client_t *client, codec_t **codec_itr)
 131 {
 132         codec_t *cd = *codec_itr;
 133
 134         if (list_empty(&client->codecs))
 135                 return NULL;
 136
 137         if (cd == NULL) {
 138                 cd = list_get_entry(list_get_first(&client->codecs), codec_t, node);
 139         } else {
 140                 if (list_get_next(&cd->node) == &client->codecs)
 141                         cd = NULL;
 142                 else
 143                         cd = list_get_entry(list_get_next(&cd->node), codec_t, node);
 144         }
 145         *codec_itr = cd;
 146         return cd;
 147 }
 148
 149 void recheckCodecVersions()
 150 {
 151         client_t *client_itr = NULL;
 152         int max = 0, version, current_version;
 153         message_t *sendmsg;
 154         struct dlist codec_list, *itr, *save;
 155         codec_t *codec_itr, *cd;
 156         bool_t found;
 157
 158         init_list_entry(&codec_list);
 159
 160         while (Client_iterate(&client_itr) != NULL) {
 161                 codec_itr = NULL;
 162                 while (Client_codec_iterate(client_itr, &codec_itr) != NULL) {
 163                         found = false;
 164                         list_iterate(itr, &codec_list) {
 165                                 cd = list_get_entry(itr, codec_t, node);
 166                                 if (cd->codec == codec_itr->codec) {
 167                                         cd->count++;
 168                                         found = true;
 169                                 }
 170                         }
 171                         if (!found) {
 172                                 cd = malloc(sizeof(codec_t));
 173                                 if (!cd)
 174                                         Log_fatal("Out of memory");
 175                                 memset(cd, 0, sizeof(codec_t));
 176                                 init_list_entry(&cd->node);
 177                                 cd->codec = codec_itr->codec;
 178                                 cd->count = 1;
 179                                 list_add_tail(&cd->node, &codec_list);
 180                         }
 181                 }
 182         }
 183
 184         list_iterate(itr, &codec_list) {
 185                 cd = list_get_entry(itr, codec_t, node);
 186                 if (cd->count > max) {
 187                         max = cd->count;
 188                         version = cd->codec;
 189                 }
 190         }
 191         list_iterate_safe(itr, save, &codec_list) {
 192                 list_del(&list_get_entry(itr, codec_t, node)->node);
 193                 free(list_get_entry(itr, codec_t, node));
 194         }
 195
 196         current_version = bPreferAlpha ? iCodecAlpha : iCodecBeta;
 197         if (current_version == version)
 198                 return;
 199         // If we don't already use the compat bitstream version set
 200         // it as alpha and announce it. If another codec now got the
 201         // majority set it as the opposite of the currently valid bPreferAlpha
 202         // and announce it.
 203         if (version == (uint32_t)0x8000000a)
 204                 bPreferAlpha = true;
 205         else
 206                 bPreferAlpha = ! bPreferAlpha;
 207
 208         if (bPreferAlpha)
 209                 iCodecAlpha = version;
 210         else
 211                 iCodecBeta = version;
 212
 213         sendmsg = Msg_create(CodecVersion);
 214         sendmsg->payload.codecVersion->alpha = version;
 215         sendmsg->payload.codecVersion->beta = version;
 216         sendmsg->payload.codecVersion->prefer_alpha = bPreferAlpha;
 217         Client_send_message_except(NULL, sendmsg);
 218
 219         Log_info("CELT codec switch 0x%x 0x%x (prefer 0x%x)", iCodecAlpha, iCodecBeta,
 220                          bPreferAlpha ? iCodecAlpha : iCodecBeta);
 221
 222 }
 223
 224 static int findFreeSessionId()
 225 {
 226         int id;
 227         client_t *itr = NULL;
 228
 229         for (id = 1; id < INT_MAX; id++) {
 230                 itr = NULL;
 231                 while ((itr = Client_iterate(&itr)) != NULL) {
 232                         if (itr->sessionId == id)
 233                                 break;
 234                 }
 235                 if (itr == NULL) /* Found free id */
 236                         return id;
 237         }
 238         return -1;
 239 }
 240
 241 int Client_add(int fd, struct sockaddr_in *remote)
 242 {
 243         client_t *newclient;
 244         message_t *sendmsg;
 245
 246         newclient = malloc(sizeof(client_t));
 247         if (newclient == NULL)
 248                 Log_fatal("Out of memory");
 249         memset(newclient, 0, sizeof(client_t));
 250
 251         newclient->tcpfd = fd;
 252         memcpy(&newclient->remote_tcp, remote, sizeof(struct sockaddr_in));
 253         newclient->ssl = SSLi_newconnection(&newclient->tcpfd, &newclient->SSLready);
 254         if (newclient->ssl == NULL) {
 255                 Log_warn("SSL negotiation failed with %s:%d", inet_ntoa(remote->sin_addr),
 256                                  ntohs(remote->sin_port));
 257                 free(newclient);
 258                 return -1;
 259         }
 260         newclient->availableBandwidth = maxBandwidth;
 261         Timer_init(&newclient->lastActivity);
 262         newclient->sessionId = findFreeSessionId();
 263         if (newclient->sessionId < 0)
 264                 Log_fatal("Could not find a free session ID");
 265
 266         init_list_entry(&newclient->txMsgQueue);
 267         init_list_entry(&newclient->chan_node);
 268         init_list_entry(&newclient->node);
 269         init_list_entry(&newclient->voicetargets);
 270         init_list_entry(&newclient->codecs);
 271
 272         list_add_tail(&newclient->node, &clients);
 273         clientcount++;
 274
 275         /* Send version message to client */
 276         sendmsg = Msg_create(Version);
 277         sendmsg->payload.version->has_version = true;
 278         sendmsg->payload.version->version = PROTOCOL_VERSION;
 279         sendmsg->payload.version->release = strdup(UMURMUR_VERSION);
 280         sendmsg->payload.version->os = strdup(system_string);
 281         sendmsg->payload.version->os_version = strdup(version_string);
 282         Client_send_message(newclient, sendmsg);
 283
 284         return 0;
 285 }
 286
 287 void Client_free(client_t *client)
 288 {
 289         struct dlist *itr, *save;
 290         message_t *sendmsg;
 291
 292         if (client->authenticated) {
 293                 int leave_id;
 294                 leave_id = Chan_userLeave(client);
 295                 if (leave_id > 0) { /* Remove temp channel */
 296                         sendmsg = Msg_create(ChannelRemove);
 297                         sendmsg->payload.channelRemove->channel_id = leave_id;
 298                         Client_send_message_except(client, sendmsg);
 299                 }
 300                 sendmsg = Msg_create(UserRemove);
 301                 sendmsg->payload.userRemove->session = client->sessionId;
 302                 Client_send_message_except(client, sendmsg);
 303         }
 304         list_iterate_safe(itr, save, &client->txMsgQueue) {
 305                 list_del(&list_get_entry(itr, message_t, node)->node);
 306                 Msg_free(list_get_entry(itr, message_t, node));
 307         }
 308         Client_codec_free(client);
 309         Voicetarget_free_all(client);
 310
 311         list_del(&client->node);
 312         if (client->ssl)
 313                 SSLi_free(client->ssl);
 314         close(client->tcpfd);
 315         clientcount--;
 316         if (client->release)
 317                 free(client->release);
 318         if (client->os)
 319                 free(client->os);
 320         if (client->username)
 321                 free(client->username);
 322         if (client->context)
 323                 free(client->context);
 324         free(client);
 325 }
 326
 327 void Client_close(client_t *client)
 328 {
 329         SSLi_shutdown(client->ssl);
 330         client->shutdown_wait = true;
 331 }
 332
 333 void Client_disconnect_all()
 334 {
 335         struct dlist *itr, *save;
 336
 337         list_iterate_safe(itr, save, &clients) {
 338                 Client_free(list_get_entry(itr, client_t, node));
 339         }
 340 }
 341
 342 int Client_read_fd(int fd)
 343 {
 344         struct dlist *itr;
 345         client_t *client = NULL;
 346
 347         list_iterate(itr, &clients) {
 348                 if (fd == list_get_entry(itr, client_t, node)->tcpfd) {
 349                         client = list_get_entry(itr, client_t, node);
 350                         break;
 351                 }
 352         }
 353         if (client == NULL)
 354                 Log_fatal("No client found for fd %d", fd);
 355
 356         return Client_read(client);
 357 }
 358
 359 int Client_read(client_t *client)
 360 {
 361         int rc;
 362
 363         Timer_restart(&client->lastActivity);
 364
 365         if (client->writeBlockedOnRead) {
 366                 client->writeBlockedOnRead = false;
 367                 Log_debug("Client_read: writeBlockedOnRead == true");
 368                 return Client_write(client);
 369         }
 370
 371         if (client->shutdown_wait) {
 372                 Client_free(client);
 373                 return 0;
 374         }
 375         if (!client->SSLready) {
 376                 int rc;
 377                 rc = SSLi_nonblockaccept(client->ssl, &client->SSLready);
 378                 if (rc < 0) {
 379                         Client_free(client);
 380                         return -1;
 381                 }
 382         }
 383
 384         do {
 385                 errno = 0;
 386                 if (!client->msgsize)
 387                         rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
 388                 else
 389                         rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
 390                 if (rc > 0) {
 391                         message_t *msg;
 392                         client->rxcount += rc;
 393                         if (!client->msgsize && client->rxcount >= 6) {
 394                                 uint32_t msgLen;
 395                                 memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
 396                                 client->msgsize = ntohl(msgLen);
 397                         }
 398                         if (client->msgsize > BUFSIZE - 6) {
 399                                 /* XXX - figure out how to handle this. A large size here can represent two cases:
 400                                  * 1. A valid size. The only message that is this big is UserState message with a big texture
 401                                  * 2. An invalid size = protocol error, e.g. connecting with a 1.1.x client
 402                                  */
 403                                 Log_warn("Too big message received (%d bytes). Playing safe and disconnecting client %s:%d",
 404                                                  client->msgsize, inet_ntoa(client->remote_tcp.sin_addr), ntohs(client->remote_tcp.sin_port));
 405                                 Client_free(client);
 406                                 return -1;
 407                                 /* client->rxcount = client->msgsize = 0; */
 408                         }
 409                         else if (client->rxcount == client->msgsize + 6) { /* Got all of the message */
 410                                 msg = Msg_networkToMessage(client->rxbuf, client->msgsize + 6);
 411                                 /* pass messsage to handler */
 412                                 if (msg)
 413                                         Mh_handle_message(client, msg);
 414                                 client->rxcount = client->msgsize = 0;
 415                         }
 416                 } else /* rc <= 0 */ {
 417                         if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
 418                                 return 0;
 419                         }
 420                         else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
 421                                 client->readBlockedOnWrite = true;
 422                                 return 0;
 423                         }
 424                         else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_ZERO_RETURN) {
 425                                 Log_info_client(client, "Connection closed by peer");
 426                                 if (!client->shutdown_wait)
 427                                         Client_close(client);
 428                         }
 429                         else {
 430                                 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
 431                                         Log_info_client(client, "Connection closed by peer");
 432                                 }
 433                                 else {
 434                                         Log_info_client(client, "SSL error: %d - Closing connection", SSLi_get_error(client->ssl, rc));
 435                                 }
 436                                 Client_free(client);
 437                                 return -1;
 438                         }
 439                 }
 440         } while (SSLi_data_pending(client->ssl));
 441
 442         return 0;
 443 }
 444
 445 int Client_write_fd(int fd)
 446 {
 447         struct dlist *itr;
 448         client_t *client = NULL;
 449
 450         list_iterate(itr, &clients) {
 451                 if(fd == list_get_entry(itr, client_t, node)->tcpfd) {
 452                         client = list_get_entry(itr, client_t, node);
 453                         break;
 454                 }
 455         }
 456         if (client == NULL)
 457                 Log_fatal("No client found for fd %d", fd);
 458         Client_write(client);
 459         return 0;
 460 }
 461
 462 int Client_write(client_t *client)
 463 {
 464         int rc;
 465
 466         if (client->readBlockedOnWrite) {
 467                 client->readBlockedOnWrite = false;
 468                 Log_debug("Client_write: readBlockedOnWrite == true");
 469                 return Client_read(client);
 470         }
 471         rc = SSLi_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
 472         if (rc > 0) {
 473                 client->txcount += rc;
 474                 if (client->txcount == client->txsize)
 475                         client->txsize = client->txcount = 0;
 476         }
 477         else if (rc < 0) {
 478                 if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
 479                         client->writeBlockedOnRead = true;
 480                         return 0;
 481                 }
 482                 else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
 483                         return 0;
 484                 }
 485                 else {
 486                         if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL)
 487                                 Log_warn("Client_write: Error: %s  - Closing connection", strerror(errno));
 488                         else
 489                                 Log_warn("Client_write: SSL error: %d - Closing connection.", SSLi_get_error(client->ssl, rc));
 490                         Client_free(client);
 491                         return -1;
 492                 }
 493         }
 494         if (client->txsize == 0 && !list_empty(&client->txMsgQueue)) {
 495                 message_t *msg;
 496                 msg = list_get_entry(list_get_first(&client->txMsgQueue), message_t, node);
 497                 list_del(list_get_first(&client->txMsgQueue));
 498                 client->txQueueCount--;
 499                 Client_send_message(client, msg);
 500         }
 501         return 0;
 502 }
 503
 504 int Client_send_message(client_t *client, message_t *msg)
 505 {
 506         if (!client->authenticated && msg->messageType != Version) {
 507                 Msg_free(msg);
 508                 return 0;
 509         }
 510         if (client->txsize != 0 || !client->SSLready) {
 511                 /* Queue message */
 512                 if ((client->txQueueCount > 5 &&  msg->messageType == UDPTunnel) ||
 513                         client->txQueueCount > 30) {
 514                         Msg_free(msg);
 515                         return -1;
 516                 }
 517                 client->txQueueCount++;
 518                 list_add_tail(&msg->node, &client->txMsgQueue);
 519                 Log_debug("Queueing message");
 520         } else {
 521                 int len;
 522                 len = Msg_messageToNetwork(msg, client->txbuf);
 523                 doAssert(len < BUFSIZE);
 524
 525                 client->txsize = len;
 526                 client->txcount = 0;
 527                 Client_write(client);
 528                 Msg_free(msg);
 529         }
 530         return 0;
 531 }
 532
 533 client_t *Client_iterate(client_t **client_itr)
 534 {
 535         client_t *c = *client_itr;
 536
 537         if (list_empty(&clients))
 538                 return NULL;
 539
 540         if (c == NULL) {
 541                 c = list_get_entry(list_get_first(&clients), client_t, node);
 542         } else {
 543                 if (list_get_next(&c->node) == &clients)
 544                         c = NULL;
 545                 else
 546                         c = list_get_entry(list_get_next(&c->node), client_t, node);
 547         }
 548         *client_itr = c;
 549         return c;
 550 }
 551
 552
 553 int Client_send_message_except(client_t *client, message_t *msg)
 554 {
 555         client_t *itr = NULL;
 556         int count = 0;
 557
 558         Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
 559         while (Client_iterate(&itr) != NULL) {
 560                 if (itr != client) {
 561                         if (count++ > 0)
 562                                 Msg_inc_ref(msg); /* One extra reference for each new copy */
 563                         Log_debug("Msg %d to %s refcount %d",  msg->messageType, itr->username, msg->refcount);
 564                         Client_send_message(itr, msg);
 565                 }
 566         }
 567         Msg_free(msg); /* Free our reference to the message */
 568
 569         if (count == 0)
 570                 Msg_free(msg); /* If only 1 client is connected then no message is passed
 571                                                 * to Client_send_message(). Free it here. */
 572
 573         return 0;
 574 }
 575
 576 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
 577 {
 578         if (CryptState_isValid(&client->cryptState) &&
 579                 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
 580                 return true;
 581
 582         if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
 583                 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
 584                         message_t *sendmsg;
 585                         Timer_restart(&client->cryptState.tLastRequest);
 586
 587                         sendmsg = Msg_create(CryptSetup);
 588                         Log_info_client(client, "Requesting voice channel crypt resync");
 589                         Client_send_message(client, sendmsg);
 590                 }
 591         }
 592         return false;
 593 }
 594
 595 #define UDP_PACKET_SIZE 1024
 596 int Client_read_udp()
 597 {
 598         int len;
 599         struct sockaddr_in from;
 600         socklen_t fromlen = sizeof(struct sockaddr_in);
 601         uint64_t key;
 602         client_t *itr;
 603         UDPMessageType_t msgType;
 604
 605 #if defined(__LP64__)
 606         uint8_t encbuff[UDP_PACKET_SIZE + 8];
 607         uint8_t *encrypted = encbuff + 4;
 608 #else
 609         uint8_t encrypted[UDP_PACKET_SIZE];
 610 #endif
 611         uint8_t buffer[UDP_PACKET_SIZE];
 612
 613         len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
 614         if (len == 0) {
 615                 return -1;
 616         } else if (len < 0) {
 617                 return -1;
 618         } else if (len < 5) {
 619                 // 4 bytes crypt header + type + session
 620                 return 0;
 621         } else if (len > UDP_PACKET_SIZE) {
 622                 return 0;
 623         }
 624
 625         /* Ping packet */
 626         if (len == 12 && *encrypted == 0) {
 627                 uint32_t *ping = (uint32_t *)encrypted;
 628                 ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
 629                 // 1 and 2 will be the timestamp, which we return unmodified.
 630                 ping[3] = htonl((uint32_t)clientcount);
 631                 ping[4] = htonl((uint32_t)getIntConf(MAX_CLIENTS));
 632                 ping[5] = htonl((uint32_t)getIntConf(MAX_BANDWIDTH));
 633
 634                 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
 635                 return 0;
 636         }
 637
 638         key = (((uint64_t)from.sin_addr.s_addr) << 16) ^ from.sin_port;
 639         itr = NULL;
 640
 641         while (Client_iterate(&itr) != NULL) {
 642                 if (itr->key == key) {
 643                         if (!checkDecrypt(itr, encrypted, buffer, len))
 644                                 goto out;
 645                         break;
 646                 }
 647         }
 648         if (itr == NULL) { /* Unknown peer */
 649                 while (Client_iterate(&itr) != NULL) {
 650                         if (itr->remote_tcp.sin_addr.s_addr == from.sin_addr.s_addr) {
 651                                 if (checkDecrypt(itr, encrypted, buffer, len)) {
 652                                         itr->key = key;
 653                                         Log_info_client(itr, "New UDP connection port %d", ntohs(from.sin_port));
 654                                         memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_in));
 655                                         break;
 656                                 }
 657                                 else Log_warn("Bad cryptstate from peer");
 658                         }
 659                 } /* while */
 660         }
 661         if (itr == NULL) { /* Couldn't find this peer among connected clients */
 662                 goto out;
 663         }
 664
 665         itr->bUDP = true;
 666         len -= 4; /* Adjust for crypt header */
 667         msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
 668         switch (msgType) {
 669         case UDPVoiceSpeex:
 670         case UDPVoiceCELTAlpha:
 671         case UDPVoiceCELTBeta:
 672                 Client_voiceMsg(itr, buffer, len);
 673                 break;
 674         case UDPPing:
 675                 Log_debug("UDP Ping reply len %d", len);
 676                 Client_send_udp(itr, buffer, len);
 677                 break;
 678         default:
 679                 Log_debug("Unknown UDP message type from %s port %d", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
 680                 break;
 681         }
 682
 683 out:
 684         return 0;
 685 }
 686
 687 static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
 688 {
 689         if (IS_AUTH(dst) && dst != src && !dst->deaf) {
 690                 if (poslen > 0 && /* Has positional data */
 691                         src->context != NULL && dst->context != NULL && /* ...both source and destination has context */
 692                         strcmp(src->context, dst->context) == 0) /* ...and the contexts match */
 693                         Client_send_udp(dst, data, len);
 694                 else
 695                         Client_send_udp(dst, data, len - poslen);
 696         }
 697 }
 698
 699 /* Handle decrypted voice message */
 700 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
 701 {
 702         uint8_t buffer[UDP_PACKET_SIZE];
 703         pds_t *pdi = Pds_create(data + 1, len - 1);
 704         pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
 705         unsigned int type = data[0] & 0xe0;
 706         unsigned int target = data[0] & 0x1f;
 707         unsigned int poslen, counter;
 708         int offset, packetsize;
 709         voicetarget_t *vt;
 710
 711         channel_t *ch = (channel_t *)client->channel;
 712         struct dlist *itr;
 713
 714         if (!client->authenticated || client->mute)
 715                 goto out;
 716
 717         packetsize = 20 + 8 + 4 + len;
 718         if (client->availableBandwidth - packetsize < 0)
 719                 goto out; /* Discard */
 720         client->availableBandwidth -= packetsize;
 721
 722         counter = Pds_get_numval(pdi); /* step past session id */
 723         do {
 724                 counter = Pds_next8(pdi);
 725                 offset = Pds_skip(pdi, counter & 0x7f);
 726         } while ((counter & 0x80) && offset > 0);
 727
 728         poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
 729
 730         Pds_add_numval(pds, client->sessionId);
 731         Pds_append_data_nosize(pds, data + 1, len - 1);
 732
 733         if (target == 0x1f) { /* Loopback */
 734                 buffer[0] = (uint8_t) type;
 735                 Client_send_udp(client, buffer, pds->offset + 1);
 736         }
 737         else if (target == 0) { /* regular channel speech */
 738                 buffer[0] = (uint8_t) type;
 739
 740                 if (ch == NULL)
 741                         goto out;
 742
 743                 list_iterate(itr, &ch->clients) {
 744                         client_t *c;
 745                         c = list_get_entry(itr, client_t, chan_node);
 746                         Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 747                 }
 748         } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
 749                 int i;
 750                 channel_t *ch;
 751                 /* Channels */
 752                 for (i = 0; i < TARGET_MAX_CHANNELS && vt->channels[i].channel != -1; i++) {
 753                         buffer[0] = (uint8_t) (type | 1);
 754                         Log_debug("Whisper channel %d", vt->channels[i]);
 755                         ch = Chan_fromId(vt->channels[i].channel);
 756                         if (ch == NULL)
 757                                 continue;
 758                         list_iterate(itr, &ch->clients) {
 759                                 client_t *c;
 760                                 c = list_get_entry(itr, client_t, chan_node);
 761                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 762                         }
 763                         /* Channel links */
 764                         if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
 765                                 struct dlist *ch_itr;
 766                                 list_iterate(ch_itr, &ch->channel_links) {
 767                                         channel_t *ch_link;
 768                                         ch_link = list_get_entry(ch_itr, channel_t, link_node);
 769                                         list_iterate(itr, &ch_link->clients) {
 770                                                 client_t *c;
 771                                                 c = list_get_entry(itr, client_t, chan_node);
 772                                                 Log_debug("Linked voice from %s -> %s", ch->name, ch_link->name);
 773                                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 774                                         }
 775                                 }
 776                         }
 777                         /* children */
 778                         if (vt->channels[i].children) {
 779                                 struct dlist chanlist, *ch_itr;
 780                                 init_list_entry(&chanlist);
 781                                 Chan_buildTreeList(ch, &chanlist);
 782                                 list_iterate(ch_itr, &chanlist) {
 783                                         channel_t *sub;
 784                                         sub = list_get_entry(ch_itr, channellist_t, node)->chan;
 785                                         list_iterate(itr, &sub->clients) {
 786                                                 client_t *c;
 787                                                 c = list_get_entry(itr, client_t, chan_node);
 788                                                 Log_debug("Child voice from %s -> %s", ch->name, sub->name);
 789                                                 Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 790                                         }
 791                                 }
 792                                 Chan_freeTreeList(&chanlist);
 793                         }
 794                 }
 795                 /* Sessions */
 796                 for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
 797                         client_t *c;
 798                         buffer[0] = (uint8_t) (type | 2);
 799                         Log_debug("Whisper session %d", vt->sessions[i]);
 800                         while (Client_iterate(&c) != NULL) {
 801                                 if (c->sessionId == vt->sessions[i]) {
 802                                         Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
 803                                         break;
 804                                 }
 805                         }
 806                 }
 807         }
 808 out:
 809         Pds_free(pds);
 810         Pds_free(pdi);
 811
 812         return 0;
 813 }
 814
 815
 816 static int Client_send_udp(client_t *client, uint8_t *data, int len)
 817 {
 818         uint8_t *buf, *mbuf;
 819
 820         if (client->remote_udp.sin_port != 0 && CryptState_isValid(&client->cryptState) &&
 821                 client->bUDP) {
 822 #if defined(__LP64__)
 823                 buf = mbuf = malloc(len + 4 + 16);
 824                 buf += 4;
 825 #else
 826                 mbuf = buf = malloc(len + 4);
 827 #endif
 828                 if (mbuf == NULL)
 829                         Log_fatal("Out of memory");
 830
 831                 CryptState_encrypt(&client->cryptState, data, buf, len);
 832
 833                 sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, sizeof(struct sockaddr_in));
 834
 835                 free(mbuf);
 836         } else {
 837                 message_t *msg;
 838                 msg = Msg_CreateVoiceMsg(data, len);
 839                 Client_send_message(client, msg);
 840         }
 841         return 0;
 842 }