-/* Copyright (C) 2009, Martin Johansson <martin@fatbob.nu>
- Copyright (C) 2005-2009, Thorvald Natvig <thorvald@natvig.com>
+/* Copyright (C) 2009-2012, Martin Johansson <martin@fatbob.nu>
+ Copyright (C) 2005-2012, Thorvald Natvig <thorvald@natvig.com>
All rights reserved.
*/
#include <sys/poll.h>
#include <sys/socket.h>
+#include <fcntl.h>
#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
#include "log.h"
#include "list.h"
#include "client.h"
#include "ssl.h"
#include "messages.h"
#include "messagehandler.h"
-#include "pds.h"
#include "conf.h"
#include "channel.h"
+#include "version.h"
+#include "voicetarget.h"
+#include "ban.h"
-
+extern char system_string[], version_string[];
static int Client_read(client_t *client);
static int Client_write(client_t *client);
-static int Client_voiceMsg(client_t *client, pds_t *pds);
static int Client_send_udp(client_t *client, uint8_t *data, int len);
-static void Client_voiceMsg_tunnel(client_t *client, message_t *msg);
+void Client_free(client_t *client);
declare_list(clients);
static int clientcount; /* = 0 */
-static int session = 1;
static int maxBandwidth;
+int iCodecAlpha, iCodecBeta;
+bool_t bPreferAlpha;
+
extern int udpsock;
void Client_init()
{
- maxBandwidth = getIntConf(MAX_BANDWIDTH);
+ maxBandwidth = getIntConf(MAX_BANDWIDTH) / 8; /* From bits/s -> bytes/s */
}
int Client_count()
void Client_janitor()
{
- struct dlist *itr;
+ struct dlist *itr, *save;
int bwTop = maxBandwidth + maxBandwidth / 4;
- list_iterate(itr, &clients) {
+ list_iterate_safe(itr, save, &clients) {
client_t *c;
c = list_get_entry(itr, client_t, node);
- Log_debug("Client %s BW available %d", c->playerName, c->availableBandwidth);
+ Log_debug("Client %s BW available %d", c->username, c->availableBandwidth);
c->availableBandwidth += maxBandwidth;
if (c->availableBandwidth > bwTop)
c->availableBandwidth = bwTop;
if (Timer_isElapsed(&c->lastActivity, 1000000LL * INACTICITY_TIMEOUT)) {
/* No activity from client - assume it is lost and close. */
- Log_info("Session ID %d timeout - closing", c->sessionId);
+ Log_info_client(c, "Timeout, closing.");
Client_free(c);
}
}
+ Ban_pruneBanned();
+}
+
+void Client_codec_add(client_t *client, int codec)
+{
+ codec_t *cd = malloc(sizeof(codec_t));
+ if (cd == NULL)
+ Log_fatal("Out of memory");
+ init_list_entry(&cd->node);
+ cd->codec = codec;
+ list_add_tail(&cd->node, &client->codecs);
+}
+
+void Client_codec_free(client_t *client)
+{
+ struct dlist *itr, *save;
+ list_iterate_safe(itr, save, &client->codecs) {
+ list_del(&list_get_entry(itr, codec_t, node)->node);
+ free(list_get_entry(itr, codec_t, node));
+ }
+}
+
+codec_t *Client_codec_iterate(client_t *client, codec_t **codec_itr)
+{
+ codec_t *cd = *codec_itr;
+
+ if (list_empty(&client->codecs))
+ return NULL;
+
+ if (cd == NULL) {
+ cd = list_get_entry(list_get_first(&client->codecs), codec_t, node);
+ } else {
+ if (list_get_next(&cd->node) == &client->codecs)
+ cd = NULL;
+ else
+ cd = list_get_entry(list_get_next(&cd->node), codec_t, node);
+ }
+ *codec_itr = cd;
+ return cd;
+}
+
+void Client_token_add(client_t *client, char *token_string)
+{
+ token_t *token;
+
+ if (client->tokencount >= MAX_TOKENS)
+ return;
+ token = malloc(sizeof(token_t));
+ if (token == NULL)
+ Log_fatal("Out of memory");
+ init_list_entry(&token->node);
+ token->token = strdup(token_string);
+ if (token->token == NULL)
+ Log_fatal("Out of memory");
+ list_add_tail(&token->node, &client->tokens);
+ client->tokencount++;
+}
+
+bool_t Client_token_match(client_t *client, char *str)
+{
+ token_t *token;
+ struct dlist *itr;
+
+ if (list_empty(&client->tokens))
+ return false;
+ list_iterate(itr, &client->tokens) {
+ token = list_get_entry(itr, token_t, node);
+ if (strncasecmp(token->token, str, MAX_TOKENSIZE) == 0)
+ return true;
+ }
+ return false;
+}
+
+void Client_token_free(client_t *client)
+{
+ struct dlist *itr, *save;
+ token_t *token;
+
+ list_iterate_safe(itr, save, &client->tokens) {
+ token = list_get_entry(itr, token_t, node);
+ list_del(&token->node);
+ free(token->token);
+ free(token);
+ }
+ client->tokencount = 0;
+}
+
+void recheckCodecVersions()
+{
+ client_t *client_itr = NULL;
+ int max = 0, version, current_version;
+ message_t *sendmsg;
+ struct dlist codec_list, *itr, *save;
+ codec_t *codec_itr, *cd;
+ bool_t found;
+
+ init_list_entry(&codec_list);
+
+ while (Client_iterate(&client_itr) != NULL) {
+ codec_itr = NULL;
+ while (Client_codec_iterate(client_itr, &codec_itr) != NULL) {
+ found = false;
+ list_iterate(itr, &codec_list) {
+ cd = list_get_entry(itr, codec_t, node);
+ if (cd->codec == codec_itr->codec) {
+ cd->count++;
+ found = true;
+ }
+ }
+ if (!found) {
+ cd = malloc(sizeof(codec_t));
+ if (!cd)
+ Log_fatal("Out of memory");
+ memset(cd, 0, sizeof(codec_t));
+ init_list_entry(&cd->node);
+ cd->codec = codec_itr->codec;
+ cd->count = 1;
+ list_add_tail(&cd->node, &codec_list);
+ }
+ }
+ }
+
+ list_iterate(itr, &codec_list) {
+ cd = list_get_entry(itr, codec_t, node);
+ if (cd->count > max) {
+ max = cd->count;
+ version = cd->codec;
+ }
+ }
+ list_iterate_safe(itr, save, &codec_list) {
+ list_del(&list_get_entry(itr, codec_t, node)->node);
+ free(list_get_entry(itr, codec_t, node));
+ }
+
+ current_version = bPreferAlpha ? iCodecAlpha : iCodecBeta;
+ if (current_version == version)
+ return;
+ // If we don't already use the compat bitstream version set
+ // it as alpha and announce it. If another codec now got the
+ // majority set it as the opposite of the currently valid bPreferAlpha
+ // and announce it.
+ if (version == (uint32_t)0x8000000b)
+ bPreferAlpha = true;
+ else
+ bPreferAlpha = ! bPreferAlpha;
+
+ if (bPreferAlpha)
+ iCodecAlpha = version;
+ else
+ iCodecBeta = version;
+
+ sendmsg = Msg_create(CodecVersion);
+ sendmsg->payload.codecVersion->alpha = iCodecAlpha;
+ sendmsg->payload.codecVersion->beta = iCodecBeta;
+ sendmsg->payload.codecVersion->prefer_alpha = bPreferAlpha;
+ Client_send_message_except(NULL, sendmsg);
+
+ Log_info("CELT codec switch 0x%x 0x%x (prefer 0x%x)", iCodecAlpha, iCodecBeta,
+ bPreferAlpha ? iCodecAlpha : iCodecBeta);
+
+}
+
+static int findFreeSessionId()
+{
+ int id;
+ client_t *itr = NULL;
+
+ for (id = 1; id < INT_MAX; id++) {
+ itr = NULL;
+ while ((itr = Client_iterate(&itr)) != NULL) {
+ if (itr->sessionId == id)
+ break;
+ }
+ if (itr == NULL) /* Found free id */
+ return id;
+ }
+ return -1;
}
int Client_add(int fd, struct sockaddr_in *remote)
{
client_t *newclient;
+ message_t *sendmsg;
+ if (Ban_isBannedAddr((in_addr_t *)&remote->sin_addr)) {
+ Log_info("Address %s banned. Disconnecting", inet_ntoa(remote->sin_addr));
+ return -1;
+ }
newclient = malloc(sizeof(client_t));
if (newclient == NULL)
Log_fatal("Out of memory");
newclient->tcpfd = fd;
memcpy(&newclient->remote_tcp, remote, sizeof(struct sockaddr_in));
- newclient->ssl = SSL_newconnection(newclient->tcpfd, &newclient->SSLready);
+ newclient->ssl = SSLi_newconnection(&newclient->tcpfd, &newclient->SSLready);
if (newclient->ssl == NULL) {
- Log_warn("SSL negotiation failed");
+ Log_warn("SSL negotiation failed with %s:%d", inet_ntoa(remote->sin_addr),
+ ntohs(remote->sin_port));
free(newclient);
return -1;
}
newclient->availableBandwidth = maxBandwidth;
Timer_init(&newclient->lastActivity);
- newclient->sessionId = session++; /* XXX - more elaborate? */
+ Timer_init(&newclient->connectTime);
+ Timer_init(&newclient->idleTime);
+ newclient->sessionId = findFreeSessionId();
+ if (newclient->sessionId < 0)
+ Log_fatal("Could not find a free session ID");
init_list_entry(&newclient->txMsgQueue);
init_list_entry(&newclient->chan_node);
init_list_entry(&newclient->node);
+ init_list_entry(&newclient->voicetargets);
+ init_list_entry(&newclient->codecs);
+ init_list_entry(&newclient->tokens);
list_add_tail(&newclient->node, &clients);
clientcount++;
+
+ /* Send version message to client */
+ sendmsg = Msg_create(Version);
+ sendmsg->payload.version->has_version = true;
+ sendmsg->payload.version->version = PROTOCOL_VERSION;
+ sendmsg->payload.version->release = strdup(UMURMUR_VERSION);
+ sendmsg->payload.version->os = strdup(system_string);
+ sendmsg->payload.version->os_version = strdup(version_string);
+ Client_send_message(newclient, sendmsg);
+
return 0;
}
struct dlist *itr, *save;
message_t *sendmsg;
- Log_info("Disconnect client ID %d addr %s port %d", client->sessionId,
- inet_ntoa(client->remote_tcp.sin_addr),
- ntohs(client->remote_tcp.sin_port));
-
if (client->authenticated) {
- sendmsg = Msg_create(ServerLeave);
- sendmsg->sessionId = client->sessionId;
+ int leave_id;
+ leave_id = Chan_userLeave(client);
+ if (leave_id > 0) { /* Remove temp channel */
+ sendmsg = Msg_create(ChannelRemove);
+ sendmsg->payload.channelRemove->channel_id = leave_id;
+ Client_send_message_except(client, sendmsg);
+ }
+ sendmsg = Msg_create(UserRemove);
+ sendmsg->payload.userRemove->session = client->sessionId;
Client_send_message_except(client, sendmsg);
}
list_iterate_safe(itr, save, &client->txMsgQueue) {
list_del(&list_get_entry(itr, message_t, node)->node);
Msg_free(list_get_entry(itr, message_t, node));
}
-
+ Client_codec_free(client);
+ Voicetarget_free_all(client);
+ Client_token_free(client);
+
list_del(&client->node);
- list_del(&client->chan_node);
if (client->ssl)
- SSL_free(client->ssl);
+ SSLi_free(client->ssl);
close(client->tcpfd);
clientcount--;
+ if (client->release)
+ free(client->release);
+ if (client->os)
+ free(client->os);
+ if (client->os_version)
+ free(client->os_version);
+ if (client->username)
+ free(client->username);
+ if (client->context)
+ free(client->context);
free(client);
}
void Client_close(client_t *client)
{
- SSL_shutdown(client->ssl);
+ SSLi_shutdown(client->ssl);
client->shutdown_wait = true;
}
client_t *client = NULL;
list_iterate(itr, &clients) {
- if(fd == list_get_entry(itr, client_t, node)->tcpfd) {
+ if (fd == list_get_entry(itr, client_t, node)->tcpfd) {
client = list_get_entry(itr, client_t, node);
break;
}
}
- if (client == NULL)
- Log_fatal("No client found for fd %d", fd);
-
- return Client_read(client);
+ if (client != NULL)
+ return Client_read(client);
+ else
+ return -1;
}
int Client_read(client_t *client)
}
if (!client->SSLready) {
int rc;
- rc = SSL_nonblockaccept(client->ssl, &client->SSLready);
+ rc = SSLi_nonblockaccept(client->ssl, &client->SSLready);
if (rc < 0) {
Client_free(client);
return -1;
do {
errno = 0;
if (!client->msgsize)
- rc = SSL_read(client->ssl, client->rxbuf, 3 - client->rxcount);
- else if (client->drainleft > 0)
- rc = SSL_read(client->ssl, client->rxbuf, client->drainleft > BUFSIZE ? BUFSIZE : client->drainleft);
+ rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
else
- rc = SSL_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
+ rc = SSLi_read(client->ssl, &client->rxbuf[client->rxcount], client->msgsize);
if (rc > 0) {
message_t *msg;
- if (client->drainleft > 0)
- client->drainleft -= rc;
- else {
- client->rxcount += rc;
- if (!client->msgsize && rc >= 3)
- client->msgsize = ((client->rxbuf[0] & 0xff) << 16) |
- ((client->rxbuf[1] & 0xff) << 8) |
- (client->rxbuf[2] & 0xff);
- if (client->msgsize > BUFSIZE - 3 && client->drainleft == 0) {
- Log_warn("Too big message received (%d). Discarding.", client->msgsize);
- client->rxcount = client->msgsize = 0;
- client->drainleft = client->msgsize;
- }
- else if (client->rxcount == client->msgsize + 3) { /* Got all of the message */
- msg = Msg_networkToMessage(&client->rxbuf[3], client->msgsize);
- /* pass messsage to handler */
- if (msg) {
- if (msg->messageType == Speex) /* Tunneled voice message */
- Client_voiceMsg_tunnel(client, msg);
- else
- Mh_handle_message(client, msg);
- }
- client->rxcount = client->msgsize = 0;
- }
+ client->rxcount += rc;
+ if (!client->msgsize && client->rxcount >= 6) {
+ uint32_t msgLen;
+ memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
+ client->msgsize = ntohl(msgLen);
+ }
+ if (client->msgsize > BUFSIZE - 6) {
+ /* XXX - figure out how to handle this. A large size here can represent two cases:
+ * 1. A valid size. The only message that is this big is UserState message with a big texture
+ * 2. An invalid size = protocol error, e.g. connecting with a 1.1.x client
+ */
+ Log_warn("Too big message received (%d bytes). Playing safe and disconnecting client %s:%d",
+ client->msgsize, inet_ntoa(client->remote_tcp.sin_addr), ntohs(client->remote_tcp.sin_port));
+ Client_free(client);
+ return -1;
+ /* client->rxcount = client->msgsize = 0; */
+ }
+ else if (client->rxcount == client->msgsize + 6) { /* Got all of the message */
+ msg = Msg_networkToMessage(client->rxbuf, client->msgsize + 6);
+ /* pass messsage to handler */
+ if (msg)
+ Mh_handle_message(client, msg);
+ client->rxcount = client->msgsize = 0;
}
} else /* rc <= 0 */ {
- if (SSL_get_error(client->ssl, rc) == SSL_ERROR_WANT_READ) {
+ if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
return 0;
}
- else if (SSL_get_error(client->ssl, rc) == SSL_ERROR_WANT_WRITE) {
+ else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
client->readBlockedOnWrite = true;
return 0;
}
- else if (SSL_get_error(client->ssl, rc) == SSL_ERROR_ZERO_RETURN) {
- Log_warn("Error: Zero return - closing");
+ else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_ZERO_RETURN) {
+ Log_info_client(client, "Connection closed by peer");
if (!client->shutdown_wait)
Client_close(client);
}
else {
- if (SSL_get_error(client->ssl, rc) == SSL_ERROR_SYSCALL) {
- /* Hmm. This is where we end up when the client closes its connection.
- * Kind of strange...
- */
- Log_info("Connection closed by peer");
+ if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
+ Log_info_client(client,"Error: %s - Closing connection", strerror(errno));
+ }
+ else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
+ Log_info_client(client, "Connection reset by peer");
}
else {
- Log_warn("SSL error: %d - Closing connection.", SSL_get_error(client->ssl, rc));
+ Log_info_client(client, "SSL error: %d - Closing connection", SSLi_get_error(client->ssl, rc));
}
Client_free(client);
return -1;
}
}
- } while (SSL_pending(client->ssl));
- return 0;
+ } while (SSLi_data_pending(client->ssl));
+
+ return 0;
}
int Client_write_fd(int fd)
break;
}
}
- if (client == NULL)
- Log_fatal("No client found for fd %d", fd);
- Client_write(client);
- return 0;
+ if (client != NULL)
+ return Client_write(client);
+ else
+ return -1;
}
int Client_write(client_t *client)
Log_debug("Client_write: readBlockedOnWrite == true");
return Client_read(client);
}
- rc = SSL_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
+ rc = SSLi_write(client->ssl, &client->txbuf[client->txcount], client->txsize - client->txcount);
if (rc > 0) {
client->txcount += rc;
if (client->txcount == client->txsize)
client->txsize = client->txcount = 0;
}
else if (rc < 0) {
- if (SSL_get_error(client->ssl, rc) == SSL_ERROR_WANT_READ) {
+ if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_READ) {
client->writeBlockedOnRead = true;
return 0;
}
- else if (SSL_get_error(client->ssl, rc) == SSL_ERROR_WANT_WRITE) {
+ else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_WANT_WRITE) {
return 0;
}
else {
- if (SSL_get_error(client->ssl, rc) == SSL_ERROR_SYSCALL)
- Log_warn("Client_write: Error: %s - Closing connection", strerror(errno));
- else
- Log_warn("Client_write: SSL error: %d - Closing connection.", SSL_get_error(client->ssl, rc));
+ if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
+ Log_info_client(client, "Error: %s - Closing connection", strerror(errno));
+ }
+ else if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_CONNRESET) {
+ Log_info_client(client, "Connection reset by peer");
+ }
+ else {
+ Log_info_client(client, "SSL error: %d - Closing connection.", SSLi_get_error(client->ssl, rc));
+ }
Client_free(client);
return -1;
}
return 0;
}
+int Client_send_message_ver(client_t *client, message_t *msg, uint32_t version)
+{
+ if ((version == 0) || (client->version >= version) ||
+ ((version & 0x80000000) && (client->version < (~version))))
+ return Client_send_message(client, msg);
+ else
+ Msg_free(msg);
+}
+
int Client_send_message(client_t *client, message_t *msg)
{
- if (!client->authenticated || !client->SSLready) {
+ if (!client->authenticated && msg->messageType != Version) {
Msg_free(msg);
return 0;
}
- if (client->txsize != 0) {
+ if (client->txsize != 0 || !client->SSLready) {
/* Queue message */
- if ((client->txQueueCount > 5 && msg->messageType == Speex) ||
+ if ((client->txQueueCount > 5 && msg->messageType == UDPTunnel) ||
client->txQueueCount > 30) {
Msg_free(msg);
return -1;
}
client->txQueueCount++;
list_add_tail(&msg->node, &client->txMsgQueue);
+ Log_debug("Queueing message");
} else {
int len;
- memset(client->txbuf, 0, BUFSIZE);
- len = Msg_messageToNetwork(msg, &client->txbuf[3], BUFSIZE - 3);
- doAssert(len < BUFSIZE - 3);
-
- client->txbuf[0] = (len >> 16) & 0xff;
- client->txbuf[1] = (len >> 8) & 0xff;
- client->txbuf[2] = len & 0xff;
- client->txsize = len + 3;
+ len = Msg_messageToNetwork(msg, client->txbuf);
+ doAssert(len < BUFSIZE);
+
+ client->txsize = len;
client->txcount = 0;
Client_write(client);
Msg_free(msg);
client_t *Client_iterate(client_t **client_itr)
{
client_t *c = *client_itr;
+
+ if (list_empty(&clients))
+ return NULL;
- if (c == NULL && !list_empty(&clients)) {
+ if (c == NULL) {
c = list_get_entry(list_get_first(&clients), client_t, node);
} else {
if (list_get_next(&c->node) == &clients)
if (itr != client) {
if (count++ > 0)
Msg_inc_ref(msg); /* One extra reference for each new copy */
- Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->playerName, msg->refcount);
+ Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
Client_send_message(itr, msg);
}
}
return 0;
}
+int Client_send_message_except_ver(client_t *client, message_t *msg, uint32_t version)
+{
+ client_t *itr = NULL;
+ int count = 0;
+
+ Msg_inc_ref(msg); /* Make sure a reference is held during the whole iteration. */
+ while (Client_iterate(&itr) != NULL) {
+ if (itr != client) {
+ if (count++ > 0)
+ Msg_inc_ref(msg); /* One extra reference for each new copy */
+ Log_debug("Msg %d to %s refcount %d", msg->messageType, itr->username, msg->refcount);
+ Client_send_message_ver(itr, msg, version);
+ }
+ }
+ Msg_free(msg); /* Free our reference to the message */
+
+ if (count == 0)
+ Msg_free(msg); /* If only 1 client is connected then no message is passed
+ * to Client_send_message(). Free it here. */
+
+ return 0;
+}
+
static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t *plain, unsigned int len)
{
if (CryptState_isValid(&client->cryptState) &&
message_t *sendmsg;
Timer_restart(&client->cryptState.tLastRequest);
- sendmsg = Msg_create(CryptSync);
- sendmsg->sessionId = client->sessionId;
- sendmsg->payload.cryptSync.empty = true;
- Log_info("Requesting voice channel crypt resync");
+ sendmsg = Msg_create(CryptSetup);
+ Log_info_client(client, "Requesting voice channel crypt resync");
Client_send_message(client, sendmsg);
}
}
return false;
}
+#define UDP_PACKET_SIZE 1024
int Client_read_udp()
{
int len;
socklen_t fromlen = sizeof(struct sockaddr_in);
uint64_t key;
client_t *itr;
- int msgType = 0;
- uint32_t sessionId = 0;
- pds_t *pds;
+ UDPMessageType_t msgType;
#if defined(__LP64__)
- uint8_t encbuff[512 + 8];
+ uint8_t encbuff[UDP_PACKET_SIZE + 8];
uint8_t *encrypted = encbuff + 4;
#else
- uint8_t encrypted[512];
+ uint8_t encrypted[UDP_PACKET_SIZE];
#endif
- uint8_t buffer[512];
+ uint8_t buffer[UDP_PACKET_SIZE];
- len = recvfrom(udpsock, encrypted, 512, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
+ len = recvfrom(udpsock, encrypted, UDP_PACKET_SIZE, MSG_TRUNC, (struct sockaddr *)&from, &fromlen);
if (len == 0) {
return -1;
} else if (len < 0) {
return -1;
- } else if (len < 6) {
+ } else if (len < 5) {
// 4 bytes crypt header + type + session
return 0;
- } else if (len > 512) {
+ } else if (len > UDP_PACKET_SIZE) {
+ return 0;
+ }
+
+ /* Ping packet */
+ if (len == 12 && *encrypted == 0) {
+ uint32_t *ping = (uint32_t *)encrypted;
+ ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
+ // 1 and 2 will be the timestamp, which we return unmodified.
+ ping[3] = htonl((uint32_t)clientcount);
+ ping[4] = htonl((uint32_t)getIntConf(MAX_CLIENTS));
+ ping[5] = htonl((uint32_t)getIntConf(MAX_BANDWIDTH));
+
+ sendto(udpsock, encrypted, 6 * sizeof(uint32_t), 0, (struct sockaddr *)&from, fromlen);
return 0;
}
key = (((uint64_t)from.sin_addr.s_addr) << 16) ^ from.sin_port;
- pds = Pds_create(buffer, len - 4);
itr = NULL;
while (Client_iterate(&itr) != NULL) {
if (itr->key == key) {
if (!checkDecrypt(itr, encrypted, buffer, len))
goto out;
- msgType = Pds_get_numval(pds);
- sessionId = Pds_get_numval(pds);
- if (itr->sessionId != sessionId)
- goto out;
break;
}
}
if (itr == NULL) { /* Unknown peer */
while (Client_iterate(&itr) != NULL) {
- pds->offset = 0;
if (itr->remote_tcp.sin_addr.s_addr == from.sin_addr.s_addr) {
if (checkDecrypt(itr, encrypted, buffer, len)) {
- msgType = Pds_get_numval(pds);
- sessionId = Pds_get_numval(pds);
- if (itr->sessionId == sessionId) { /* Found matching client */
- itr->key = key;
- Log_info("New UDP connection from %s port %d sessionId %d", inet_ntoa(from.sin_addr), ntohs(from.sin_port), sessionId);
- memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_in));
- break;
- }
+ itr->key = key;
+ Log_info_client(itr, "New UDP connection port %d", ntohs(from.sin_port));
+ memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_in));
+ break;
}
- else Log_warn("Bad cryptstate from peer");
}
} /* while */
}
- if (itr == NULL) {
+ if (itr == NULL) { /* Couldn't find this peer among connected clients */
goto out;
}
- len -= 4;
- if (msgType != Speex && msgType != Ping)
- goto out;
- if (msgType == Ping) {
+ itr->bUDP = true;
+ len -= 4; /* Adjust for crypt header */
+ msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
+ switch (msgType) {
+ case UDPVoiceSpeex:
+ case UDPVoiceCELTAlpha:
+ case UDPVoiceCELTBeta:
+ Client_voiceMsg(itr, buffer, len);
+ break;
+ case UDPPing:
+ Log_debug("UDP Ping reply len %d", len);
Client_send_udp(itr, buffer, len);
- }
- else {
- Client_voiceMsg(itr, pds);
+ break;
+ default:
+ Log_debug("Unknown UDP message type from %s port %d", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
+ break;
}
out:
- Pds_free(pds);
return 0;
}
-static void Client_voiceMsg_tunnel(client_t *client, message_t *msg)
+static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
{
- uint8_t buf[512];
- pds_t *pds = Pds_create(buf, 512);
-
- Pds_add_numval(pds, msg->messageType);
- Pds_add_numval(pds, msg->sessionId);
- Pds_add_numval(pds, msg->payload.speex.seq);
- Pds_append_data_nosize(pds, msg->payload.speex.data, msg->payload.speex.size);
-
- Msg_free(msg);
-
- if (!pds->bOk)
- Log_warn("Large Speex message from TCP"); /* XXX - pds resize? */
- pds->maxsize = pds->offset;
- Client_voiceMsg(client, pds);
-
- Pds_free(pds);
+ if (IS_AUTH(dst) && dst != src && !dst->deaf && !dst->self_deaf) {
+ if (poslen > 0 && /* Has positional data */
+ src->context != NULL && dst->context != NULL && /* ...both source and destination has context */
+ strcmp(src->context, dst->context) == 0) /* ...and the contexts match */
+ Client_send_udp(dst, data, len);
+ else
+ Client_send_udp(dst, data, len - poslen);
+ }
}
-static int Client_voiceMsg(client_t *client, pds_t *pds)
+/* Handle decrypted voice message */
+int Client_voiceMsg(client_t *client, uint8_t *data, int len)
{
- int seq, flags, msgType, sessionId, packetsize;
+ uint8_t buffer[UDP_PACKET_SIZE];
+ pds_t *pdi = Pds_create(data + 1, len - 1);
+ pds_t *pds = Pds_create(buffer + 1, UDP_PACKET_SIZE - 1);
+ unsigned int type = data[0] & 0xe0;
+ unsigned int target = data[0] & 0x1f;
+ unsigned int poslen, counter;
+ int offset, packetsize;
+ voicetarget_t *vt;
+
channel_t *ch = (channel_t *)client->channel;
struct dlist *itr;
- if (!client->authenticated || client->mute)
- return 0;
-
+ if (!client->authenticated || client->mute || client->self_mute)
+ goto out;
- pds->offset = 0;
- msgType = Pds_get_numval(pds);
- sessionId = Pds_get_numval(pds);
- seq = Pds_get_numval(pds);
- flags = Pds_get_numval(pds);
-
- packetsize = 20 + 8 + 4 + pds->maxsize - pds->offset;
+ packetsize = 20 + 8 + 4 + len;
if (client->availableBandwidth - packetsize < 0)
- return 0; /* Discard */
-
+ goto out; /* Discard */
client->availableBandwidth -= packetsize;
- pds->offset = 0;
+ Timer_restart(&client->idleTime);
- if (flags & LoopBack) {
- Client_send_udp(client, pds->data, pds->maxsize);
- return 0;
- }
- if (ch == NULL)
- return 0;
+ counter = Pds_get_numval(pdi); /* step past session id */
+ do {
+ counter = Pds_next8(pdi);
+ offset = Pds_skip(pdi, counter & 0x7f);
+ } while ((counter & 0x80) && offset > 0);
+
+ poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
- list_iterate(itr, &ch->clients) {
- client_t *c;
- c = list_get_entry(itr, client_t, chan_node);
- if (c != client && !c->deaf) {
- Client_send_udp(c, pds->data, pds->maxsize);
+ Pds_add_numval(pds, client->sessionId);
+ Pds_append_data_nosize(pds, data + 1, len - 1);
+
+ if (target == 0x1f) { /* Loopback */
+ buffer[0] = (uint8_t) type;
+ Client_send_udp(client, buffer, pds->offset + 1);
+ }
+ else if (target == 0) { /* regular channel speech */
+ buffer[0] = (uint8_t) type;
+
+ if (ch == NULL)
+ goto out;
+
+ list_iterate(itr, &ch->clients) {
+ client_t *c;
+ c = list_get_entry(itr, client_t, chan_node);
+ Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
+ }
+ } else if ((vt = Voicetarget_get_id(client, target)) != NULL) { /* Targeted whisper */
+ int i;
+ channel_t *ch;
+ /* Channels */
+ for (i = 0; i < TARGET_MAX_CHANNELS && vt->channels[i].channel != -1; i++) {
+ buffer[0] = (uint8_t) (type | 1);
+ Log_debug("Whisper channel %d", vt->channels[i]);
+ ch = Chan_fromId(vt->channels[i].channel);
+ if (ch == NULL)
+ continue;
+ list_iterate(itr, &ch->clients) {
+ client_t *c;
+ c = list_get_entry(itr, client_t, chan_node);
+ Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
+ }
+ /* Channel links */
+ if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
+ struct dlist *ch_itr;
+ list_iterate(ch_itr, &ch->channel_links) {
+ channel_t *ch_link;
+ ch_link = list_get_entry(ch_itr, channel_t, link_node);
+ list_iterate(itr, &ch_link->clients) {
+ client_t *c;
+ c = list_get_entry(itr, client_t, chan_node);
+ Log_debug("Linked voice from %s -> %s", ch->name, ch_link->name);
+ Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
+ }
+ }
+ }
+ /* children */
+ if (vt->channels[i].children) {
+ struct dlist chanlist, *ch_itr;
+ init_list_entry(&chanlist);
+ Chan_buildTreeList(ch, &chanlist);
+ list_iterate(ch_itr, &chanlist) {
+ channel_t *sub;
+ sub = list_get_entry(ch_itr, channellist_t, node)->chan;
+ list_iterate(itr, &sub->clients) {
+ client_t *c;
+ c = list_get_entry(itr, client_t, chan_node);
+ Log_debug("Child voice from %s -> %s", ch->name, sub->name);
+ Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
+ }
+ }
+ Chan_freeTreeList(&chanlist);
+ }
+ }
+ /* Sessions */
+ for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
+ client_t *c;
+ buffer[0] = (uint8_t) (type | 2);
+ Log_debug("Whisper session %d", vt->sessions[i]);
+ while (Client_iterate(&c) != NULL) {
+ if (c->sessionId == vt->sessions[i]) {
+ Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
+ break;
+ }
+ }
}
}
+out:
+ Pds_free(pds);
+ Pds_free(pdi);
+
return 0;
}
static int Client_send_udp(client_t *client, uint8_t *data, int len)
{
uint8_t *buf, *mbuf;
- message_t *sendmsg;
- if (client->remote_udp.sin_port != 0 && CryptState_isValid(&client->cryptState)) {
+ if (client->remote_udp.sin_port != 0 && CryptState_isValid(&client->cryptState) &&
+ client->bUDP) {
#if defined(__LP64__)
buf = mbuf = malloc(len + 4 + 16);
buf += 4;
free(mbuf);
} else {
- pds_t *pds = Pds_create(data, len);
-
- sendmsg = Msg_create(Pds_get_numval(pds));
- sendmsg->sessionId = Pds_get_numval(pds);
-
- if (sendmsg->messageType == Speex || sendmsg->messageType == Ping) {
- if (sendmsg->messageType == Speex) {
- sendmsg->payload.speex.seq = Pds_get_numval(pds);
- sendmsg->payload.speex.size = pds->maxsize - pds->offset;
- doAssert(pds->maxsize - pds->offset <= SPEEX_DATA_SIZE);
- memcpy(sendmsg->payload.speex.data, data + pds->offset, pds->maxsize - pds->offset);
- } else { /* Ping */
- sendmsg->payload.ping.timestamp = Pds_get_numval(pds);
- }
- Client_send_message(client, sendmsg);
- } else {
- Log_warn("TCP fallback: Unsupported message type %d", sendmsg->messageType);
- Msg_free(sendmsg);
- }
- Pds_free(pds);
+ message_t *msg;
+ msg = Msg_CreateVoiceMsg(data, len);
+ Client_send_message(client, msg);
}
return 0;
}
projects / umurmur.git / blobdiff