-/* Copyright (C) 2009, Martin Johansson <martin@fatbob.nu>
- Copyright (C) 2005-2009, Thorvald Natvig <thorvald@natvig.com>
+/* Copyright (C) 2009-2010, Martin Johansson <martin@fatbob.nu>
+ Copyright (C) 2005-2010, Thorvald Natvig <thorvald@natvig.com>
All rights reserved.
#include "messagehandler.h"
#include "conf.h"
#include "channel.h"
+#include "version.h"
+#include "voicetarget.h"
-/* Version 0.2.0 XXX fixme */
-const uint32_t versionBlob = 1<<16 | 2<<8 | 0;
+extern char system_string[], version_string[];
static int Client_read(client_t *client);
static int Client_write(client_t *client);
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 (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);
}
}
}
+void recheckCodecVersions()
+{
+ int codec_map[MAX_CODECS][2];
+ client_t *itr = NULL;
+ 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];
+ codec_map[codecindex][1] = 1;
+ break;
+ }
+ if (itr->codecs[i] == codec_map[codecindex][0])
+ codec_map[codecindex][1]++;
+ }
+ }
+ }
+ 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");
memcpy(&newclient->remote_tcp, remote, sizeof(struct sockaddr_in));
newclient->ssl = SSL_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;
}
init_list_entry(&newclient->txMsgQueue);
init_list_entry(&newclient->chan_node);
init_list_entry(&newclient->node);
+ init_list_entry(&newclient->voicetargets);
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) {
+ int leave_id;
+ leave_id = Chan_playerLeave(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_del(&list_get_entry(itr, message_t, node)->node);
Msg_free(list_get_entry(itr, message_t, node));
}
-
+ Voicetarget_free_all(client);
+
list_del(&client->node);
- list_del(&client->chan_node);
if (client->ssl)
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);
+ if (client->context)
+ free(client->context);
free(client);
}
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;
}
do {
errno = 0;
if (!client->msgsize)
- rc = SSL_read(client->ssl, client->rxbuf, 6 - client->rxcount);
+ rc = SSL_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
else if (client->drainleft > 0)
rc = SSL_read(client->ssl, client->rxbuf, client->drainleft > BUFSIZE ? BUFSIZE : client->drainleft);
else
else {
client->rxcount += rc;
if (!client->msgsize && client->rxcount >= 6) {
- uint32_t *msgLen = (uint32_t *) &client->rxbuf[2];
- client->msgsize = ntohl(*msgLen);
+ uint32_t msgLen;
+ memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
+ client->msgsize = ntohl(msgLen);
}
if (client->msgsize > BUFSIZE - 6 && client->drainleft == 0) {
- Log_warn("Too big message received (%d). Discarding.", client->msgsize);
+ Log_info_client(client, "Too big message received (%d bytes). Discarding.", client->msgsize);
client->rxcount = client->msgsize = 0;
client->drainleft = client->msgsize;
}
return 0;
}
else if (SSL_get_error(client->ssl, rc) == SSL_ERROR_ZERO_RETURN) {
- Log_warn("Error: Zero return - closing");
+ Log_info_client(client, "Connection closed by peer");
if (!client->shutdown_wait)
Client_close(client);
}
/* Hmm. This is where we end up when the client closes its connection.
* Kind of strange...
*/
- Log_info("Connection closed by peer");
+ Log_info_client(client, "Connection closed 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", SSL_get_error(client->ssl, rc));
}
Client_free(client);
return -1;
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 == UDPTunnel) ||
client->txQueueCount > 30) {
Timer_restart(&client->cryptState.tLastRequest);
sendmsg = Msg_create(CryptSetup);
- Log_info("Requesting voice channel crypt resync");
+ Log_info_client(client, "Requesting voice channel crypt resync");
Client_send_message(client, sendmsg);
}
}
/* Ping packet */
if (len == 12 && *encrypted == 0) {
uint32_t *ping = (uint32_t *)encrypted;
- ping[0] = htons(versionBlob);
+ ping[0] = htonl((uint32_t)PROTOCOL_VERSION);
// 1 and 2 will be the timestamp, which we return unmodified.
- ping[3] = htons((uint32_t)clientcount);
- ping[4] = htons((uint32_t)getIntConf(MAX_CLIENTS));
- ping[5] = htons((uint32_t)getIntConf(MAX_BANDWIDTH));
+ 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;
if (itr->remote_tcp.sin_addr.s_addr == from.sin_addr.s_addr) {
if (checkDecrypt(itr, encrypted, buffer, len)) {
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);
+ Log_info_client(itr, "New UDP connection port %d", ntohs(from.sin_port));
memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_in));
break;
}
Client_voiceMsg(itr, buffer, len);
break;
case UDPPing:
+ Log_debug("UDP Ping reply len %d", len);
Client_send_udp(itr, buffer, len);
break;
default:
return 0;
}
+static inline void Client_send_voice(client_t *src, client_t *dst, uint8_t *data, int len, int poslen)
+{
+ if (IS_AUTH(dst) && dst != src && !dst->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);
+ }
+}
+
/* Handle decrypted voice message */
int Client_voiceMsg(client_t *client, uint8_t *data, int len)
{
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;
+ goto out;
packetsize = 20 + 8 + 4 + len;
if (client->availableBandwidth - packetsize < 0)
- return 0; /* Discard */
+ goto out; /* Discard */
client->availableBandwidth -= packetsize;
- counter = Pds_get_numval(pdi); /* Seems like this... */
+ 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 */
+ poslen = pdi->maxsize - pdi->offset; /* For stripping of positional info */
Pds_add_numval(pds, client->sessionId);
Pds_append_data_nosize(pds, data + 1, len - 1);
- if (target & 0x1f) { /* Loopback */
+ if (target == 0x1f) { /* Loopback */
buffer[0] = (uint8_t) type;
Client_send_udp(client, buffer, pds->offset + 1);
}
buffer[0] = (uint8_t) type;
if (ch == NULL)
- return 0;
+ 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);
+ Client_send_voice(client, c, buffer, pds->offset + 1, poslen);
+ }
+ /* Channel links */
+ if (!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);
+ }
+ }
+ }
+ } 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] != -1; i++) {
+ Log_debug("Whisper channel %d", vt->channels[i]);
+ ch = Chan_fromId(vt->channels[i]);
+ 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);
+ }
+ }
+ /* Sessions */
+ for (i = 0; i < TARGET_MAX_SESSIONS && vt->sessions[i] != -1; i++) {
+ client_t *c;
+ 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;
+ }
}
}
}
- /* XXX - Add targeted whisper here */
+out:
Pds_free(pds);
Pds_free(pdi);
projects / umurmur.git / blobdiff