src/client.c

   1 /* Copyright (C) 2009, Martin Johansson <martin@fatbob.nu>
   2    Copyright (C) 2005-2009, 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 <errno.h>
  34 #include "log.h"
  35 #include "list.h"
  36 #include "client.h"
  37 #include "ssl.h"
  38 #include "messages.h"
  39 #include "messagehandler.h"
  40 #include "conf.h"
  41 #include "channel.h"
  42
  43 /* Version 0.2.0 XXX fixme */
  44 const uint32_t versionBlob = 1<<16 | 2<<8 | 0;
  45
  46 static int Client_read(client_t *client);
  47 static int Client_write(client_t *client);
  48 static int Client_send_udp(client_t *client, uint8_t *data, int len);
  49 void Client_free(client_t *client);
  50
  51 declare_list(clients);
  52 static int clientcount; /* = 0 */
  53 static int session = 1;
  54 static int maxBandwidth;
  55
  56 static int iCodecAlpha, iCodecBeta;
  57 static bool_t bPreferAlpha;
  58
  59 extern int udpsock;
  60
  61 void Client_init()
  62 {
  63         maxBandwidth = getIntConf(MAX_BANDWIDTH) / 8; /* From bits/s -> bytes/s */
  64 }
  65
  66 int Client_count()
  67 {
  68         return clientcount;
  69 }
  70
  71 int Client_getfds(struct pollfd *pollfds)
  72 {
  73         struct dlist *itr;
  74         int i = 0;
  75         list_iterate(itr, &clients) {
  76                 client_t *c;
  77                 c = list_get_entry(itr, client_t, node);
  78                 pollfds[i].fd = c->tcpfd;
  79                 pollfds[i].events = POLLIN | POLLHUP | POLLERR;
  80                 if (c->txsize > 0 || c->readBlockedOnWrite) /* Data waiting to be sent? */
  81                         pollfds[i].events |= POLLOUT;
  82                 i++;
  83         }
  84         return i;
  85 }
  86
  87 void Client_janitor()
  88 {
  89         struct dlist *itr;
  90         int bwTop = maxBandwidth + maxBandwidth / 4;
  91         list_iterate(itr, &clients) {
  92                 client_t *c;
  93                 c = list_get_entry(itr, client_t, node);
  94                 Log_debug("Client %s BW available %d", c->playerName, c->availableBandwidth);
  95                 c->availableBandwidth += maxBandwidth;
  96                 if (c->availableBandwidth > bwTop)
  97                         c->availableBandwidth = bwTop;
  98
  99                 if (Timer_isElapsed(&c->lastActivity, 1000000LL * INACTICITY_TIMEOUT)) {
 100                         /* No activity from client - assume it is lost and close. */
 101                         Log_info("Session ID %d timeout - closing", c->sessionId);
 102                         Client_free(c);
 103                 }
 104         }
 105 }
 106
 107 void recheckCodecVersions()
 108 {
 109         int codec_map[MAX_CODECS][2];
 110         client_t *itr;
 111         int i, codecindex, max = 0, version, current_version;
 112         message_t *sendmsg;
 113
 114         memset(codec_map, 0, MAX_CODECS * 2 * sizeof(int));
 115         while (Client_iterate(&itr) != NULL) {
 116                 for (i = 0; i < itr->codec_count; i++) {
 117                         for (codecindex = 0; codecindex < MAX_CODECS; codecindex++) {
 118                                 if (codec_map[codecindex][0] == 0)
 119                                         codec_map[codecindex][0] = itr->codecs[i];
 120                                 if (itr->codecs[i] == codec_map[codecindex][0])
 121                                         codec_map[codecindex][1]++;
 122                         }
 123                 }
 124         }
 125         if (codec_map[codecindex][0] == 0)
 126                 return;
 127         for (codecindex = 0; codecindex < MAX_CODECS; codecindex++) {
 128                 if (codec_map[codecindex][0] == 0)
 129                         break;
 130                 if (codec_map[codecindex][1] > max) {
 131                         max = codec_map[codecindex][1];
 132                         version = codec_map[codecindex][0];
 133                 }
 134         }
 135         current_version = bPreferAlpha ? iCodecAlpha : iCodecBeta;
 136         if (current_version == version)
 137                 return;
 138         // If we don't already use the compat bitstream version set
 139         // it as alpha and announce it. If another codec now got the
 140         // majority set it as the opposite of the currently valid bPreferAlpha
 141         // and announce it.
 142         if (version == (uint32_t)0x8000000a)
 143                 bPreferAlpha = true;
 144         else
 145                 bPreferAlpha = ! bPreferAlpha;
 146
 147         if (bPreferAlpha)
 148                 iCodecAlpha = version;
 149         else
 150                 iCodecBeta = version;
 151
 152         sendmsg = Msg_create(CodecVersion);
 153         sendmsg->payload.codecVersion->alpha = version;
 154         sendmsg->payload.codecVersion->beta = version;
 155         sendmsg->payload.codecVersion->beta = bPreferAlpha;
 156         Client_send_message_except(NULL, sendmsg);
 157
 158 }
 159
 160 int Client_add(int fd, struct sockaddr_in *remote)
 161 {
 162         client_t *newclient;
 163         message_t *sendmsg;
 164
 165         newclient = malloc(sizeof(client_t));
 166         if (newclient == NULL)
 167                 Log_fatal("Out of memory");
 168         memset(newclient, 0, sizeof(client_t));
 169
 170         newclient->tcpfd = fd;
 171         memcpy(&newclient->remote_tcp, remote, sizeof(struct sockaddr_in));
 172         newclient->ssl = SSL_newconnection(newclient->tcpfd, &newclient->SSLready);
 173         if (newclient->ssl == NULL) {
 174                 Log_warn("SSL negotiation failed");
 175                 free(newclient);
 176                 return -1;
 177         }
 178         newclient->availableBandwidth = maxBandwidth;
 179         Timer_init(&newclient->lastActivity);
 180         newclient->sessionId = session++; /* XXX - more elaborate? */
 181
 182         init_list_entry(&newclient->txMsgQueue);
 183         init_list_entry(&newclient->chan_node);
 184         init_list_entry(&newclient->node);
 185
 186         list_add_tail(&newclient->node, &clients);
 187         clientcount++;
 188
 189         /* Send version message to client */
 190         sendmsg = Msg_create(Version);
 191         sendmsg->payload.version->has_version = true;
 192         sendmsg->payload.version->version = (1 << 16) | (2 << 8) | 0; /* XXX fix */
 193         sendmsg->payload.version->release = strdup("1.2.0");
 194         sendmsg->payload.version->os = strdup("Linux/OpenWRT");
 195
 196         Client_send_message(newclient, sendmsg);
 197
 198         return 0;
 199 }
 200
 201 void Client_free(client_t *client)
 202 {
 203         struct dlist *itr, *save;
 204         message_t *sendmsg;
 205
 206         Log_info("Disconnect client ID %d addr %s port %d", client->sessionId,
 207                          inet_ntoa(client->remote_tcp.sin_addr),
 208                          ntohs(client->remote_tcp.sin_port));
 209
 210         if (client->authenticated) {
 211                 sendmsg = Msg_create(UserRemove);
 212                 sendmsg->payload.userRemove->session = client->sessionId;
 213                 Client_send_message_except(client, sendmsg);
 214         }
 215         list_iterate_safe(itr, save, &client->txMsgQueue) {
 216                 list_del(&list_get_entry(itr, message_t, node)->node);
 217                 Msg_free(list_get_entry(itr, message_t, node));
 218         }
 219
 220         list_del(&client->node);
 221         list_del(&client->chan_node);
 222         if (client->ssl)
 223                 SSL_free(client->ssl);
 224         close(client->tcpfd);
 225         clientcount--;
 226         if (client->release)
 227                 free(client->release);
 228         if (client->os)
 229                 free(client->os);
 230         free(client);
 231 }
 232
 233 void Client_close(client_t *client)
 234 {
 235         SSL_shutdown(client->ssl);
 236         client->shutdown_wait = true;
 237 }
 238
 239 void Client_disconnect_all()
 240 {
 241         struct dlist *itr, *save;
 242
 243         list_iterate_safe(itr, save, &clients) {
 244                 Client_free(list_get_entry(itr, client_t, node));
 245         }
 246 }
 247
 248 int Client_read_fd(int fd)
 249 {
 250         struct dlist *itr;
 251         client_t *client = NULL;
 252
 253         list_iterate(itr, &clients) {
 254                 if(fd == list_get_entry(itr, client_t, node)->tcpfd) {
 255                         client = list_get_entry(itr, client_t, node);
 256                         break;
 257                 }
 258         }
 259         if (client == NULL)
 260                 Log_fatal("No client found for fd %d", fd);
 261
 262         return Client_read(client);
 263 }
 264
 265 int Client_read(client_t *client)
 266 {
 267         int rc;
 268
 269         Timer_restart(&client->lastActivity);
 270
 271         if (client->writeBlockedOnRead) {
 272                 client->writeBlockedOnRead = false;
 273                 Log_debug("Client_read: writeBlockedOnRead == true");
 274                 return Client_write(client);
 275         }
 276
 277         if (client->shutdown_wait) {
 278                 Client_free(client);
 279                 return 0;
 280         }
 281         if (!client->SSLready) {
 282                 int rc;
 283                 rc = SSL_nonblockaccept(client->ssl, &client->SSLready);
 284                 if (rc < 0) {
 285                         Client_free(client);
 286                         return -1;
 287                 }
 288         }
 289
 290         do {
 291                 errno = 0;
 292                 if (!client->msgsize)
 293                         rc = SSL_read(client->ssl, client->rxbuf, 6 - client->rxcount);
 294                 else if (client->drainleft > 0)
 295                         rc = SSL_read(client->ssl, client->rxbuf, client->drainleft > BUFSIZE ? BUFSIZE : client->drainleft);
 296                 else
 297                         rc = SSL_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
 298                 if (rc > 0) {
 299                         message_t *msg;
 300                         if (client->drainleft > 0)
 301                                 client->drainleft -= rc;
 302                         else {
 303                                 client->rxcount += rc;
 304                                 if (!client->msgsize && client->rxcount >= 6) {
 305                                         uint32_t *msgLen = (uint32_t *) &client->rxbuf[2];
 306                                         client->msgsize = ntohl(*msgLen);
 307                                 }
 308                                 if (client->msgsize > BUFSIZE - 6 && client->drainleft == 0) {
 309                                         Log_warn("Too big message received (%d). Discarding.", client->msgsize);
 310                                         client->rxcount = client->msgsize = 0;
 311                                         client->drainleft = client->msgsize;
 312                                 }
 313                                 else if (client->rxcount == client->msgsize + 6) { /* Got all of the message */
 314                                         msg = Msg_networkToMessage(client->rxbuf, client->msgsize + 6);
 315                                         /* pass messsage to handler */
 316                                         if (msg)
 317                                                         Mh_handle_message(client, msg);
 318                                         client->rxcount = client->msgsize = 0;
 319                                 }
 320                         }
 321                 } else /* rc <= 0 */ {
 322                         if (SSL_get_error(client->ssl, rc) == SSL_ERROR_WANT_READ) {
 323                                 return 0;
 324                         }
 325                         else if (SSL_get_error(client->ssl, rc) == SSL_ERROR_WANT_WRITE) {
 326                                 client->readBlockedOnWrite = true;
 327                                 return 0;
 328                         }
 329                         else if (SSL_get_error(client->ssl, rc) == SSL_ERROR_ZERO_RETURN) {
 330                                 Log_warn("Error: Zero return - closing");
 331                                 if (!client->shutdown_wait)
 332                                         Client_close(client);
 333                         }
 334                         else {
 335                                 if (SSL_get_error(client->ssl, rc) == SSL_ERROR_SYSCALL) {
 336                                         /* Hmm. This is where we end up when the client closes its connection.
 337                                          * Kind of strange...
 338                                          */
 339                                         Log_info("Connection closed by peer");
 340                                 }
 341                                 else {
 342                                         Log_warn("SSL error: %d - Closing connection.", SSL_get_error(client->ssl, rc));
 343                                 }
 344                                 Client_free(client);
 345                                 return -1;
 346                         }
 347                 }
 348         } while (SSL_pending(client->ssl));
 349         return 0;
 350 }
 351
 352 int Client_write_fd(int fd)
 353 {
 354         struct dlist *itr;
 355         client_t *client = NULL;
 356
 357         list_iterate(itr, &clients) {
 358                 if(fd == list_get_entry(itr, client_t, node)->tcpfd) {
 359                         client = list_get_entry(itr, client_t, node);
 360                         break;
 361                 }
 362         }
 363         if (client == NULL)
 364                 Log_fatal("No client found for fd %d", fd);
 365         Client_write(client);
 366         return 0;
 367 }
 368
 369 int Client_write(client_t *client)
 370 {
 371         int rc;
 372
 373         if (client->readBlockedOnWrite) {
 374                 client->readBlockedOnWrite = false;
 375                 Log_debug("Client_write: readBlockedOnWrite == true");
 376                 return Client_read(client);
 377         }
 378         rc = SSL_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
 379         if (rc > 0) {
 380                 client->txcount += rc;
 381                 if (client->txcount == client->txsize)
 382                         client->txsize = client->txcount = 0;
 383         }
 384         else if (rc < 0) {
 385                 if (SSL_get_error(client->ssl, rc) == SSL_ERROR_WANT_READ) {
 386                         client->writeBlockedOnRead = true;
 387                         return 0;
 388                 }
 389                 else if (SSL_get_error(client->ssl, rc) == SSL_ERROR_WANT_WRITE) {
 390                         return 0;
 391                 }
 392                 else {
 393                         if (SSL_get_error(client->ssl, rc) == SSL_ERROR_SYSCALL)
 394                                 Log_warn("Client_write: Error: %s  - Closing connection", strerror(errno));
 395                         else
 396                                 Log_warn("Client_write: SSL error: %d - Closing connection.", SSL_get_error(client->ssl, rc));
 397                         Client_free(client);
 398                         return -1;
 399                 }
 400         }
 401         if (client->txsize == 0 && !list_empty(&client->txMsgQueue)) {
 402                 message_t *msg;
 403                 msg = list_get_entry(list_get_first(&client->txMsgQueue), message_t, node);
 404                 list_del(list_get_first(&client->txMsgQueue));
 405                 client->txQueueCount--;
 406                 Client_send_message(client, msg);
 407         }
 408         return 0;
 409 }
 410
 411 int Client_send_message(client_t *client, message_t *msg)
 412 {
 413         if (!client->authenticated && msg->messageType != Version) {
 414                 Msg_free(msg);
 415                 return 0;
 416         }
 417         if (client->txsize != 0 || !client->SSLready) {
 418                 /* Queue message */
 419                 if ((client->txQueueCount > 5 &&  msg->messageType == UDPTunnel) ||
 420                         client->txQueueCount > 30) {
 421                         Msg_free(msg);
 422                         return -1;
 423                 }
 424                 client->txQueueCount++;
 425                 list_add_tail(&msg->node, &client->txMsgQueue);
 426                 Log_debug("Queueing message");
 427         } else {
 428                 int len;
 429                 memset(client->txbuf, 0, BUFSIZE);
 430                 len = Msg_messageToNetwork(msg, client->txbuf);
 431                 doAssert(len < BUFSIZE);
 432
 433                 client->txsize = len;
 434                 client->txcount = 0;
 435                 Client_write(client);
 436                 Msg_free(msg);
 437         }
 438         return 0;
 439 }
 440
 441 client_t *Client_iterate(client_t **client_itr)
 442 {
 443         client_t *c = *client_itr;
 444
 445         if (list_empty(&clients))
 446                 return NULL;
 447
 448         if (c == NULL) {
 449                 c = list_get_entry(list_get_first(&clients), client_t, node);
 450         } else {
 451                 if (list_get_next(&c->node) == &clients)
 452                         c = NULL;
 453                 else
 454                         c = list_get_entry(list_get_next(&c->node), client_t, node);
 455         }
 456         *client_itr = c;
 457         return c;
 458 }
 459
 460
 461 int Client_send_message_except(client_t *client, message_t *msg)
 462 {
 463         client_t *itr = NULL;
 464         int count = 0;
 465
 466         Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
 467         while (Client_iterate(&itr) != NULL) {
 468                 if (itr != client) {
 469                         if (count++ > 0)
 470                                 Msg_inc_ref(msg); /* One extra reference for each new copy */
 471                         Log_debug("Msg %d to %s refcount %d",  msg->messageType, itr->playerName, msg->refcount);
 472                         Client_send_message(itr, msg);
 473                 }
 474         }
 475         Msg_free(msg); /* Free our reference to the message */
 476
 477         if (count == 0)
 478                 Msg_free(msg); /* If only 1 client is connected then no message is passed
 479                                                 * to Client_send_message(). Free it here. */
 480
 481         return 0;
 482 }
 483
 484 static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
 485 {
 486         if (CryptState_isValid(&client->cryptState) &&
 487                 CryptState_decrypt(&client->cryptState, encrypted, plain, len))
 488                 return true;
 489
 490         if (Timer_elapsed(&client->cryptState.tLastGood) > 5000000ULL) {
 491                 if (Timer_elapsed(&client->cryptState.tLastRequest) > 5000000ULL) {
 492                         message_t *sendmsg;
 493                         Timer_restart(&client->cryptState.tLastRequest);
 494
 495                         sendmsg = Msg_create(CryptSetup);
 496                         Log_info("Requesting voice channel crypt resync");
 497                         Client_send_message(client, sendmsg);
 498                 }
 499         }
 500         return false;
 501 }
 502
 503 #define UDP_PACKET_SIZE 1024
 504 int Client_read_udp()
 505 {
 506         int len;
 507         struct sockaddr_in from;
 508         socklen_t fromlen = sizeof(struct sockaddr_in);
 509         uint64_t key;
 510         client_t *itr;
 511         UDPMessageType_t msgType;
 512
 513 #if defined(__LP64__)
 514         uint8_t encbuff[UDP_PACKET_SIZE + 8];
 515         uint8_t *encrypted = encbuff + 4;
 516 #else
 517         uint8_t encrypted[UDP_PACKET_SIZE];
 518 #endif
 519         uint8_t buffer[UDP_PACKET_SIZE];
 520
 521         len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
 522         if (len == 0) {
 523                 return -1;
 524         } else if (len < 0) {
 525                 return -1;
 526         } else if (len < 5) {
 527                 // 4 bytes crypt header + type + session
 528                 return 0;
 529         } else if (len > UDP_PACKET_SIZE) {
 530                 return 0;
 531         }
 532
 533         /* Ping packet */
 534         if (len == 12 && *encrypted == 0) {
 535                 uint32_t *ping = (uint32_t *)encrypted;
 536                 ping[0] = htons(versionBlob);
 537                 // 1 and 2 will be the timestamp, which we return unmodified.
 538                 ping[3] = htons((uint32_t)clientcount);
 539                 ping[4] = htons((uint32_t)getIntConf(MAX_CLIENTS));
 540                 ping[5] = htons((uint32_t)getIntConf(MAX_BANDWIDTH));
 541
 542                 sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
 543                 return 0;
 544         }
 545
 546         key = (((uint64_t)from.sin_addr.s_addr) << 16) ^ from.sin_port;
 547         itr = NULL;
 548
 549         while (Client_iterate(&itr) != NULL) {
 550                 if (itr->key == key) {
 551                         if (!checkDecrypt(itr, encrypted, buffer, len))
 552                                 goto out;
 553                         break;
 554                 }
 555         }
 556         if (itr == NULL) { /* Unknown peer */
 557                 while (Client_iterate(&itr) != NULL) {
 558                         if (itr->remote_tcp.sin_addr.s_addr == from.sin_addr.s_addr) {
 559                                 if (checkDecrypt(itr, encrypted, buffer, len)) {
 560                                         itr->key = key;
 561                                         Log_info("New UDP connection from %s port %d sessionId %d", inet_ntoa(from.sin_addr), ntohs(from.sin_port), itr->sessionId);
 562                                         memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_in));
 563                                         break;
 564                                 }
 565                                 else Log_warn("Bad cryptstate from peer");
 566                         }
 567                 } /* while */
 568         }
 569         if (itr == NULL) {
 570                 goto out;
 571         }
 572
 573         msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
 574         switch (msgType) {
 575         case UDPVoiceSpeex:
 576         case UDPVoiceCELTAlpha:
 577         case UDPVoiceCELTBeta:
 578                 // u->bUdp = true;
 579                 Client_voiceMsg(itr, buffer, len);
 580                 break;
 581         case UDPPing:
 582                 Client_send_udp(itr, buffer, len);
 583                 break;
 584         default:
 585                 Log_debug("Unknown UDP message type from %s port %d", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
 586                 break;
 587         }
 588 out:
 589         return 0;
 590 }
 591
 592 /* Handle decrypted voice message */
 593 int Client_voiceMsg(client_t *client, uint8_t *data, int len)
 594 {
 595         uint8_t buffer[UDP_PACKET_SIZE];
 596         pds_t *pdi = Pds_create(data + 1, len - 1);
 597         pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
 598         unsigned int type = data[0] & 0xe0;
 599         unsigned int target = data[0] & 0x1f;
 600         unsigned int poslen, counter;
 601         int offset, packetsize;
 602
 603         channel_t *ch = (channel_t *)client->channel;
 604         struct dlist *itr;
 605
 606         if (!client->authenticated || client->mute)
 607                 goto out;
 608
 609         packetsize = 20 + 8 + 4 + len;
 610         if (client->availableBandwidth - packetsize < 0)
 611                 goto out; /* Discard */
 612         client->availableBandwidth -= packetsize;
 613
 614         counter = Pds_get_numval(pdi); /* step past session id */
 615         do {
 616                 counter = Pds_next8(pdi);
 617                 offset = Pds_skip(pdi, counter & 0x7f);
 618         } while ((counter & 0x80) && offset > 0);
 619
 620         poslen = pdi->maxsize - pdi->offset; /* XXX - Add stripping of positional audio */
 621
 622         Pds_add_numval(pds, client->sessionId);
 623         Pds_append_data_nosize(pds, data + 1, len - 1);
 624
 625         if (target & 0x1f) { /* Loopback */
 626                 buffer[0] = (uint8_t) type;
 627                 Client_send_udp(client, buffer, pds->offset + 1);
 628         }
 629         else if (target == 0) { /* regular channel speech */
 630                 buffer[0] = (uint8_t) type;
 631
 632                 if (ch == NULL)
 633                         goto out;
 634
 635                 list_iterate(itr, &ch->clients) {
 636                         client_t *c;
 637                         c = list_get_entry(itr, client_t, chan_node);
 638                         if (c != client && !c->deaf) {
 639                                 Client_send_udp(c, buffer, pds->offset + 1);
 640                         }
 641                 }
 642         }
 643         /* XXX - Add targeted whisper here */
 644 out:
 645         Pds_free(pds);
 646         Pds_free(pdi);
 647
 648         return 0;
 649 }
 650
 651
 652 static int Client_send_udp(client_t *client, uint8_t *data, int len)
 653 {
 654         uint8_t *buf, *mbuf;
 655
 656         if (client->remote_udp.sin_port != 0 && CryptState_isValid(&client->cryptState)) {
 657 #if defined(__LP64__)
 658                 buf = mbuf = malloc(len + 4 + 16);
 659                 buf += 4;
 660 #else
 661                 mbuf = buf = malloc(len + 4);
 662 #endif
 663                 if (mbuf == NULL)
 664                         Log_fatal("Out of memory");
 665
 666                 CryptState_encrypt(&client->cryptState, data, buf, len);
 667
 668                 sendto(udpsock, buf, len + 4, 0, (struct sockaddr *)&client->remote_udp, sizeof(struct sockaddr_in));
 669
 670                 free(mbuf);
 671         } else {
 672                 message_t *msg;
 673                 buf = malloc(len);
 674                 memcpy(buf, data, len);
 675                 msg = Msg_create(UDPTunnel);
 676
 677                 msg->payload.UDPTunnel->packet.data = buf;
 678                 msg->payload.UDPTunnel->packet.len = len;
 679                 Client_send_message(client, msg);
 680         }
 681         return 0;
 682 }