X-Git-Url: http://git.code-monkey.de/?a=blobdiff_plain;f=src%2Fclient.c;h=9f7576eff20051feb3d96ca36fa53ae8c19799c2;hb=ad3bc56f96b024ac31e8927f21d1f5e7b8f61b56;hp=2294b3aa23c18ee546a7ca463a37eebce2abe3c2;hpb=c7df54e693e34de4037a8cc8b7a28828302c7fa5;p=umurmur.git diff --git a/src/client.c b/src/client.c index 2294b3a..9f7576e 100644 --- a/src/client.c +++ b/src/client.c @@ -1,5 +1,5 @@ -/* Copyright (C) 2010, Martin Johansson - Copyright (C) 2005-2010, Thorvald Natvig +/* Copyright (C) 2009-2012, Martin Johansson + Copyright (C) 2005-2012, Thorvald Natvig All rights reserved. @@ -30,7 +30,11 @@ */ #include #include +#include #include +#include +#include +#include #include "log.h" #include "list.h" #include "client.h" @@ -41,6 +45,9 @@ #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); @@ -49,7 +56,6 @@ void Client_free(client_t *client); declare_list(clients); static int clientcount; /* = 0 */ -static int session = 1; static int maxBandwidth; int iCodecAlpha, iCodecBeta; @@ -85,53 +91,156 @@ int Client_getfds(struct pollfd *pollfds) 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() { - 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; @@ -139,7 +248,7 @@ void recheckCodecVersions() // 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) + if (version == (uint32_t)0x8000000b) bPreferAlpha = true; else bPreferAlpha = ! bPreferAlpha; @@ -150,8 +259,8 @@ void recheckCodecVersions() iCodecBeta = version; sendmsg = Msg_create(CodecVersion); - sendmsg->payload.codecVersion->alpha = version; - sendmsg->payload.codecVersion->beta = version; + sendmsg->payload.codecVersion->alpha = iCodecAlpha; + sendmsg->payload.codecVersion->beta = iCodecBeta; sendmsg->payload.codecVersion->prefer_alpha = bPreferAlpha; Client_send_message_except(NULL, sendmsg); @@ -160,11 +269,32 @@ void recheckCodecVersions() } +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"); @@ -172,20 +302,27 @@ int Client_add(int fd, struct sockaddr_in *remote) 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++; @@ -195,9 +332,8 @@ int Client_add(int fd, struct sockaddr_in *remote) 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; @@ -208,11 +344,14 @@ void Client_free(client_t *client) 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); @@ -221,20 +360,23 @@ void Client_free(client_t *client) 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->playerName) - free(client->playerName); + if (client->os_version) + free(client->os_version); + if (client->username) + free(client->username); if (client->context) free(client->context); free(client); @@ -242,7 +384,7 @@ void Client_free(client_t *client) void Client_close(client_t *client) { - SSL_shutdown(client->ssl); + SSLi_shutdown(client->ssl); client->shutdown_wait = true; } @@ -266,10 +408,10 @@ int Client_read_fd(int fd) 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) @@ -290,7 +432,7 @@ 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; @@ -300,63 +442,65 @@ int Client_read(client_t *client) do { errno = 0; if (!client->msgsize) - 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); + 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 && 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 + 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) { + 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) @@ -370,10 +514,10 @@ 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) @@ -385,25 +529,30 @@ 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; } @@ -418,6 +567,15 @@ int Client_write(client_t *client) 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 && msg->messageType != Version) { @@ -436,7 +594,6 @@ int Client_send_message(client_t *client, message_t *msg) Log_debug("Queueing message"); } else { int len; - memset(client->txbuf, 0, BUFSIZE); len = Msg_messageToNetwork(msg, client->txbuf); doAssert(len < BUFSIZE); @@ -478,7 +635,7 @@ int Client_send_message_except(client_t *client, message_t *msg) 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); } } @@ -491,6 +648,29 @@ int Client_send_message_except(client_t *client, message_t *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) && @@ -503,7 +683,7 @@ static bool_t checkDecrypt(client_t *client, const uint8_t *encrypted, uint8_t * 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); } } @@ -568,24 +748,24 @@ int Client_read_udp() 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; } - else Log_warn("Bad cryptstate from peer"); } } /* while */ } - if (itr == NULL) { + if (itr == NULL) { /* Couldn't find this peer among connected clients */ goto out; } + itr->bUDP = true; + len -= 4; /* Adjust for crypt header */ 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: @@ -596,16 +776,19 @@ int Client_read_udp() Log_debug("Unknown UDP message type from %s port %d", inet_ntoa(from.sin_addr), ntohs(from.sin_port)); break; } + out: 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 && strcmp(src->context, dst->context) == 0) + 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 + else Client_send_udp(dst, data, len - poslen); } } @@ -625,7 +808,7 @@ int Client_voiceMsg(client_t *client, uint8_t *data, int len) channel_t *ch = (channel_t *)client->channel; struct dlist *itr; - if (!client->authenticated || client->mute) + if (!client->authenticated || client->mute || client->self_mute) goto out; packetsize = 20 + 8 + 4 + len; @@ -633,6 +816,8 @@ int Client_voiceMsg(client_t *client, uint8_t *data, int len) goto out; /* Discard */ client->availableBandwidth -= packetsize; + Timer_restart(&client->idleTime); + counter = Pds_get_numval(pdi); /* step past session id */ do { counter = Pds_next8(pdi); @@ -659,27 +844,14 @@ int Client_voiceMsg(client_t *client, uint8_t *data, int len) c = list_get_entry(itr, client_t, chan_node); 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++) { + 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]); + ch = Chan_fromId(vt->channels[i].channel); if (ch == NULL) continue; list_iterate(itr, &ch->clients) { @@ -687,10 +859,42 @@ int Client_voiceMsg(client_t *client, uint8_t *data, int len) 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]) { @@ -712,7 +916,8 @@ static int Client_send_udp(client_t *client, uint8_t *data, int len) { uint8_t *buf, *mbuf; - 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; @@ -729,12 +934,7 @@ static int Client_send_udp(client_t *client, uint8_t *data, int len) free(mbuf); } else { message_t *msg; - buf = malloc(len); - memcpy(buf, data, len); - msg = Msg_create(UDPTunnel); - - msg->payload.UDPTunnel->packet.data = buf; - msg->payload.UDPTunnel->packet.len = len; + msg = Msg_CreateVoiceMsg(data, len); Client_send_message(client, msg); } return 0;