#include "ssl.h"
#include "messages.h"
#include "messagehandler.h"
-#include "pds.h"
#include "conf.h"
#include "channel.h"
-
-
+#include "version.h"
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()
if (c->availableBandwidth > bwTop)
c->availableBandwidth = bwTop;
- if (Timer_isElapsed(&c->lastActivity, 1000000LL * INACTICITY_TIMEOUT))
- Client_close(c);
+ 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);
+ Client_free(c);
+ }
}
}
+void recheckCodecVersions()
+{
+ int codec_map[MAX_CODECS][2];
+ client_t *itr;
+ int i, codecindex, max = 0, version, current_version;
+ message_t *sendmsg;
+
+ memset(codec_map, 0, MAX_CODECS * 2 * sizeof(int));
+ while (Client_iterate(&itr) != NULL) {
+ for (i = 0; i < itr->codec_count; i++) {
+ for (codecindex = 0; codecindex < MAX_CODECS; codecindex++) {
+ if (codec_map[codecindex][0] == 0)
+ codec_map[codecindex][0] = itr->codecs[i];
+ if (itr->codecs[i] == codec_map[codecindex][0])
+ codec_map[codecindex][1]++;
+ }
+ }
+ }
+ if (codec_map[codecindex][0] == 0)
+ return;
+ for (codecindex = 0; codecindex < MAX_CODECS; codecindex++) {
+ if (codec_map[codecindex][0] == 0)
+ break;
+ if (codec_map[codecindex][1] > max) {
+ max = codec_map[codecindex][1];
+ version = codec_map[codecindex][0];
+ }
+ }
+ 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)0x8000000a)
+ bPreferAlpha = true;
+ else
+ bPreferAlpha = ! bPreferAlpha;
+
+ if (bPreferAlpha)
+ iCodecAlpha = version;
+ else
+ iCodecBeta = version;
+
+ sendmsg = Msg_create(CodecVersion);
+ sendmsg->payload.codecVersion->alpha = version;
+ sendmsg->payload.codecVersion->beta = version;
+ 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);
+
+}
+
int Client_add(int fd, struct sockaddr_in *remote)
{
client_t *newclient;
-
+ message_t *sendmsg;
+
newclient = malloc(sizeof(client_t));
if (newclient == NULL)
Log_fatal("Out of memory");
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);
+ /* XXX - set OS to something relevant? */
+ /* sendmsg->payload.version->os = strdup("Linux/OpenWRT"); */
+
+ Client_send_message(newclient, sendmsg);
+
return 0;
}
ntohs(client->remote_tcp.sin_port));
if (client->authenticated) {
- sendmsg = Msg_create(ServerLeave);
- sendmsg->sessionId = client->sessionId;
+ sendmsg = Msg_create(UserRemove);
+ sendmsg->payload.userRemove->session = client->sessionId;
Client_send_message_except(client, sendmsg);
}
list_iterate_safe(itr, save, &client->txMsgQueue) {
SSL_free(client->ssl);
close(client->tcpfd);
clientcount--;
+ if (client->release)
+ free(client->release);
+ if (client->os)
+ free(client->os);
+ if (client->playerName)
+ free(client->playerName);
free(client);
}
do {
errno = 0;
if (!client->msgsize)
- rc = SSL_read(client->ssl, client->rxbuf, 3 - client->rxcount);
+ rc = SSL_read(client->ssl, client->rxbuf, 6 - client->rxcount);
else if (client->drainleft > 0)
rc = SSL_read(client->ssl, client->rxbuf, client->drainleft > BUFSIZE ? BUFSIZE : client->drainleft);
else
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) {
+ if (!client->msgsize && client->rxcount >= 6) {
+ uint32_t *msgLen = (uint32_t *) &client->rxbuf[2];
+ client->msgsize = ntohl(*msgLen);
+ }
+ if (client->msgsize > BUFSIZE - 6 && 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);
+ 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) {
- if (msg->messageType == Speex) /* Tunneled voice message */
- Client_voiceMsg_tunnel(client, msg);
- else
+ if (msg)
Mh_handle_message(client, msg);
- }
client->rxcount = client->msgsize = 0;
}
}
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);
+ len = Msg_messageToNetwork(msg, client->txbuf);
+ doAssert(len < BUFSIZE);
- client->txbuf[0] = (len >> 16) & 0xff;
- client->txbuf[1] = (len >> 8) & 0xff;
- client->txbuf[2] = len & 0xff;
- client->txsize = len + 3;
+ 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)
message_t *sendmsg;
Timer_restart(&client->cryptState.tLastRequest);
- sendmsg = Msg_create(CryptSync);
- sendmsg->sessionId = client->sessionId;
- sendmsg->payload.cryptSync.empty = true;
+ sendmsg = Msg_create(CryptSetup);
Log_info("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("New UDP connection from %s port %d sessionId %d", inet_ntoa(from.sin_addr), ntohs(from.sin_port), itr->sessionId);
+ memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_in));
+ break;
}
else Log_warn("Bad cryptstate from peer");
}
if (itr == NULL) {
goto out;
}
- len -= 4;
- if (msgType != Speex && msgType != Ping)
- goto out;
- if (msgType == Ping) {
+ msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
+ switch (msgType) {
+ case UDPVoiceSpeex:
+ case UDPVoiceCELTAlpha:
+ case UDPVoiceCELTBeta:
+ // u->bUdp = true;
+ Client_voiceMsg(itr, buffer, len);
+ break;
+ case UDPPing:
Client_send_udp(itr, buffer, len);
+ break;
+ default:
+ Log_debug("Unknown UDP message type from %s port %d", inet_ntoa(from.sin_addr), ntohs(from.sin_port));
+ break;
}
- else {
- Client_voiceMsg(itr, pds);
- }
-
out:
- Pds_free(pds);
return 0;
}
-static void Client_voiceMsg_tunnel(client_t *client, message_t *msg)
+/* Handle decrypted voice message */
+int Client_voiceMsg(client_t *client, uint8_t *data, int len)
{
- 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);
- if (!pds->bOk)
- Log_warn("Large Speex message from TCP"); /* XXX - pds resize? */
- pds->maxsize = pds->offset;
- Client_voiceMsg(client, pds);
- Pds_free(pds);
-}
+ 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;
-static int Client_voiceMsg(client_t *client, pds_t *pds)
-{
- int seq, flags, msgType, sessionId, packetsize;
channel_t *ch = (channel_t *)client->channel;
struct dlist *itr;
if (!client->authenticated || client->mute)
- return 0;
-
+ 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;
+ 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; /* XXX - Add stripping of positional audio */
- if (flags & LoopBack) {
- Client_send_udp(client, pds->data, pds->maxsize);
- return 0;
- }
- if (ch == NULL)
- return 0;
+ Pds_add_numval(pds, client->sessionId);
+ Pds_append_data_nosize(pds, data + 1, len - 1);
- 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);
+ 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);
+ if (c != client && !c->deaf) {
+ Client_send_udp(c, buffer, pds->offset + 1);
+ }
}
}
+ /* XXX - Add targeted whisper here */
+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 defined(__LP64__)
free(mbuf);
} else {
- pds_t *pds = Pds_create(data, len);
-
- sendmsg = Msg_create(Pds_get_numval(pds));
- sendmsg->sessionId = Pds_get_numval(pds);
+ message_t *msg;
+ buf = malloc(len);
+ memcpy(buf, data, len);
+ msg = Msg_create(UDPTunnel);
- 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);
+ msg->payload.UDPTunnel->packet.data = buf;
+ msg->payload.UDPTunnel->packet.len = len;
+ Client_send_message(client, msg);
}
return 0;
}