#include <sys/poll.h>
#include <sys/socket.h>
#include <errno.h>
+#include <limits.h>
#include "log.h"
#include "list.h"
#include "client.h"
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;
}
}
+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;
}
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++;
if (client->authenticated) {
int leave_id;
- leave_id = Chan_playerLeave(client);
+ leave_id = Chan_userLeave(client);
if (leave_id > 0) { /* Remove temp channel */
sendmsg = Msg_create(ChannelRemove);
sendmsg->payload.channelRemove->channel_id = leave_id;
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);
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);
errno = 0;
if (!client->msgsize)
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
rc = SSL_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 && client->rxcount >= 6) {
- uint32_t msgLen;
- memcpy(&msgLen, &client->rxbuf[2], sizeof(uint32_t));
- client->msgsize = ntohl(msgLen);
- }
- if (client->msgsize > BUFSIZE - 6 && client->drainleft == 0) {
- Log_info_client(client, "Too big message received (%d bytes). Discarding.", client->msgsize);
- client->rxcount = client->msgsize = 0;
- client->drainleft = 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)
- 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) {
}
}
} while (SSL_pending(client->ssl));
- return 0;
+
+ return 0;
}
int Client_write_fd(int fd)
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);
}
}