*/
#include <sys/poll.h>
#include <sys/socket.h>
+#include <fcntl.h>
#include <errno.h>
#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
#include "log.h"
#include "list.h"
#include "client.h"
// 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;
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);
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 with %s:%d", inet_ntoa(remote->sin_addr),
ntohs(remote->sin_port));
}
newclient->availableBandwidth = maxBandwidth;
Timer_init(&newclient->lastActivity);
+ Timer_init(&newclient->connectTime);
+ Timer_init(&newclient->idleTime);
newclient->sessionId = findFreeSessionId();
if (newclient->sessionId < 0)
Log_fatal("Could not find a free session ID");
list_del(&client->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->os_version)
+ free(client->os_version);
if (client->username)
free(client->username);
if (client->context)
void Client_close(client_t *client)
{
- SSL_shutdown(client->ssl);
+ SSLi_shutdown(client->ssl);
client->shutdown_wait = true;
}
}
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;
do {
errno = 0;
if (!client->msgsize)
- rc = SSL_read(client->ssl, &client->rxbuf[client->rxcount], 6 - client->rxcount);
+ 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;
client->rxcount += rc;
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) {
+ 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...
- */
+ if (SSLi_get_error(client->ssl, rc) == SSLI_ERROR_SYSCALL) {
Log_info_client(client, "Connection closed by peer");
}
else {
- Log_info_client(client, "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));
+ } while (SSLi_data_pending(client->ssl));
return 0;
}
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)
+ if (SSLi_get_error(client->ssl, rc) == SSLI_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));
+ Log_warn("Client_write: SSL error: %d - Closing connection.", SSLi_get_error(client->ssl, rc));
Client_free(client);
return -1;
}
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) {
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) &&
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:
- itr->bUDP = true;
Client_voiceMsg(itr, buffer, len);
break;
case UDPPing:
goto out; /* Discard */
client->availableBandwidth -= packetsize;
+ Timer_restart(&client->idleTime);
+
counter = Pds_get_numval(pdi); /* step past session id */
do {
counter = Pds_next8(pdi);
projects / umurmur.git / blobdiff