-/* Copyright (C) 2010, Martin Johansson <martin@fatbob.nu>
+/* Copyright (C) 2009-2010, Martin Johansson <martin@fatbob.nu>
Copyright (C) 2005-2010, Thorvald Natvig <thorvald@natvig.com>
All rights reserved.
#include <sys/poll.h>
#include <sys/socket.h>
#include <errno.h>
+#include <limits.h>
#include "log.h"
#include "list.h"
#include "client.h"
#include "version.h"
#include "voicetarget.h"
+extern char system_string[], version_string[];
+
static int Client_read(client_t *client);
static int Client_write(client_t *client);
static int Client_send_udp(client_t *client, uint8_t *data, int len);
declare_list(clients);
static int clientcount; /* = 0 */
-static int session = 1;
static int maxBandwidth;
int iCodecAlpha, iCodecBeta;
list_iterate(itr, &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);
}
}
}
+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 recheckCodecVersions()
{
- int codec_map[MAX_CODECS][2];
- client_t *itr = NULL;
- int i, codecindex, max = 0, version, current_version;
+ 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;
- 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;
+ 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 (itr->codecs[i] == codec_map[codecindex][0])
- codec_map[codecindex][1]++;
+ }
+ 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);
}
}
}
- 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];
+
+ 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;
}
+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;
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;
}
newclient->availableBandwidth = maxBandwidth;
Timer_init(&newclient->lastActivity);
- newclient->sessionId = session++; /* XXX - more elaborate? */
+ 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);
list_add_tail(&newclient->node, &clients);
clientcount++;
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"); */
-
+ 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_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_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);
list_del(&client->node);
- list_del(&client->chan_node);
if (client->ssl)
SSL_free(client->ssl);
close(client->tcpfd);
free(client->release);
if (client->os)
free(client->os);
- if (client->playerName)
- free(client->playerName);
+ if (client->username)
+ free(client->username);
if (client->context)
free(client->context);
free(client);
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;
Log_debug("Queueing message");
} else {
int len;
- memset(client->txbuf, 0, BUFSIZE);
len = Msg_messageToNetwork(msg, client->txbuf);
doAssert(len < BUFSIZE);
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);
}
}
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);
}
}
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;
}
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 && strcmp(src->context, dst->context) == 0)
+ 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);