X-Git-Url: http://git.code-monkey.de/?a=blobdiff_plain;f=src%2Fclient.c;h=367f18dee165e383f892b9c4ae3f2e979a8a4759;hb=9bf7a133fd2e6500976bdd7c8a8bc830f54c5c13;hp=141934735629e96c9587cc16156505ff0de49cdf;hpb=c26a4b9cbad862bce96e3dadcfaa85f7e2223de3;p=umurmur.git

diff --git a/src/client.c b/src/client.c
index 1419347..367f18d 100644
--- a/src/client.c
+++ b/src/client.c
@@ -30,8 +30,11 @@
 */
 #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"
@@ -197,7 +200,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;
@@ -247,7 +250,7 @@ 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 with %s:%d", inet_ntoa(remote->sin_addr),
 				 ntohs(remote->sin_port));
@@ -256,6 +259,8 @@ int Client_add(int fd, struct sockaddr_in *remote)
 	}
 	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");
@@ -307,13 +312,15 @@ void Client_free(client_t *client)
 	
 	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)
@@ -323,7 +330,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;
 }
 
@@ -371,7 +378,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;
@@ -381,9 +388,9 @@ int Client_read(client_t *client)
 	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;
@@ -411,33 +418,30 @@ int Client_read(client_t *client)
 				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;
 }
@@ -468,25 +472,25 @@ 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)
+			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;
 		}
@@ -501,6 +505,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) {
@@ -573,6 +586,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) &&
@@ -719,6 +755,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);