Use Memory_safeCalloc() to allocate zeroed memory.

[umurmur.git] / src / client.c

diff --git a/src/client.c b/src/client.c
index 35fa7f250392e3c314edf000de574c84a98e06e6..80cbe3d67802e850d68b7a9d2d570ac3976d8c8f 100644 (file)
--- a/src/client.c
+++ b/src/client.c
@@ -36,6 +36,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include "log.h"
+#include "memory.h"
 #include "list.h"
 #include "client.h"
 #include "ssl.h"
@@ -64,6 +65,7 @@ int iCodecAlpha, iCodecBeta;
 bool_t bPreferAlpha;
 
 extern int* udpsocks;
+extern bool_t hasv4;
 
 void Client_init()
 {
@@ -114,9 +116,7 @@ void Client_janitor()
 
 void Client_codec_add(client_t *client, int codec)
 {
-       codec_t *cd = malloc(sizeof(codec_t));
-       if (cd == NULL)
-               Log_fatal("Out of memory");
+       codec_t *cd = Memory_safeMalloc(1, sizeof(codec_t));
        init_list_entry(&cd->node);
        cd->codec = codec;
        list_add_tail(&cd->node, &client->codecs);
@@ -156,9 +156,7 @@ void Client_token_add(client_t *client, char *token_string)
 
        if (client->tokencount >= MAX_TOKENS)
                return;
-       token = malloc(sizeof(token_t));
-       if (token == NULL)
-               Log_fatal("Out of memory");
+       token = Memory_safeMalloc(1, sizeof(token_t));
        init_list_entry(&token->node);
        token->token = strdup(token_string);
        if (token->token == NULL)
@@ -167,7 +165,7 @@ void Client_token_add(client_t *client, char *token_string)
        client->tokencount++;
 }
 
-bool_t Client_token_match(client_t *client, char *str)
+bool_t Client_token_match(client_t *client, char const *str)
 {
        token_t *token;
        struct dlist *itr;
@@ -226,10 +224,7 @@ void recheckCodecVersions(client_t *connectingClient)
                                }
                        }
                        if (!found) {
-                               cd = malloc(sizeof(codec_t));
-                               if (!cd)
-                                       Log_fatal("Out of memory");
-                               memset(cd, 0, sizeof(codec_t));
+                               cd = Memory_safeCalloc(1, sizeof(codec_t));
                                init_list_entry(&cd->node);
                                cd->codec = codec_itr->codec;
                                cd->count = 1;
@@ -322,20 +317,24 @@ int Client_add(int fd, struct sockaddr_storage *remote)
 {
        client_t* newclient;
        message_t *sendmsg;
+       char* addressString = NULL;
 
        if (Ban_isBannedAddr(remote)) {
-               Log_info("Address %s banned. Disconnecting", Util_addressToString(remote));
+               addressString = Util_addressToString(remote);
+               Log_info("Address %s banned. Disconnecting", addressString);
+               free(addressString);
                return -1;
        }
 
-       if ((newclient = calloc(1, sizeof(client_t))) == NULL)
-               Log_fatal("(%s:%s): Out of memory while allocating %d bytes.", __FILE__, __LINE__, sizeof(client_t));
+       newclient = Memory_safeCalloc(1, sizeof(client_t));
 
        newclient->tcpfd = fd;
        memcpy(&newclient->remote_tcp, remote, sizeof(struct sockaddr_storage));
        newclient->ssl = SSLi_newconnection(&newclient->tcpfd, &newclient->SSLready);
        if (newclient->ssl == NULL) {
-               Log_warn("SSL negotiation failed with %s on port %d", Util_addressToString(remote), Util_addressToPort(remote));
+               addressString = Util_addressToString(remote);
+               Log_warn("SSL negotiation failed with %s on port %d", addressString, Util_addressToPort(remote));
+               free(addressString);
                free(newclient);
                return -1;
        }
@@ -669,12 +668,8 @@ void Client_textmessage(client_t *client, char *text)
        uint32_t *tree_id;
        message_t *sendmsg = NULL;
 
-       message = malloc(strlen(text) + 1);
-       if (!message)
-               Log_fatal("Out of memory");
-       tree_id = malloc(sizeof(uint32_t));
-       if (!tree_id)
-               Log_fatal("Out of memory");
+       message = Memory_safeMalloc(1, strlen(text) + 1);
+       tree_id = Memory_safeMalloc(1, sizeof(uint32_t));
        *tree_id = 0;
        sendmsg = Msg_create(TextMessage);
        sendmsg->payload.textMessage->message = message;
@@ -833,7 +828,9 @@ int Client_read_udp(int udpsock)
                        if (memcmp(itraddress, fromaddress, addresslength) == 0) {
                                if (checkDecrypt(itr, encrypted, buffer, len)) {
                                        memcpy(itr->key, key, KEY_LENGTH);
-                                       Log_info_client(itr, "New UDP connection from %s on port %d", Util_clientAddressToString(itr), fromport);
+                                       char* clientAddressString = Util_clientAddressToString(itr);
+                                       Log_info_client(itr, "New UDP connection from %s on port %d", clientAddressString, fromport);
+                                       free(clientAddressString);
                                        memcpy(&itr->remote_udp, &from, sizeof(struct sockaddr_storage));
                                        break;
                                }
@@ -847,6 +844,9 @@ int Client_read_udp(int udpsock)
        itr->bUDP = true;
        len -= 4; /* Adjust for crypt header */
        msgType = (UDPMessageType_t)((buffer[0] >> 5) & 0x7);
+
+       char *clientAddressString = NULL;
+
        switch (msgType) {
                case UDPVoiceSpeex:
                case UDPVoiceCELTAlpha:
@@ -861,7 +861,9 @@ int Client_read_udp(int udpsock)
                        Client_send_udp(itr, buffer, len);
                        break;
                default:
-                       Log_debug("Unknown UDP message type from %s port %d", Util_clientAddressToString(itr), fromport);
+                       clientAddressString = Util_clientAddressToString(itr);
+                       Log_debug("Unknown UDP message type from %s port %d", clientAddressString, fromport);
+                       free(clientAddressString);
                        break;
        }
 
@@ -957,8 +959,10 @@ int Client_voiceMsg(client_t *client, uint8_t *data, int len)
                        if (vt->channels[i].linked && !list_empty(&ch->channel_links)) {
                                struct dlist *ch_itr;
                                list_iterate(ch_itr, &ch->channel_links) {
+                                       channellist_t *chl;
                                        channel_t *ch_link;
-                                       ch_link = list_get_entry(ch_itr, channel_t, link_node);
+                                       chl = list_get_entry(ch_itr, channellist_t, node);
+                                       ch_link = chl->chan;
                                        list_iterate(itr, &ch_link->clients) {
                                                client_t *c;
                                                c = list_get_entry(itr, client_t, chan_node);
@@ -1008,20 +1012,17 @@ out:
 static int Client_send_udp(client_t *client, uint8_t *data, int len)
 {
        uint8_t *buf, *mbuf;
-       int udpsock = (client->remote_udp.ss_family == AF_INET) ? udpsocks[0] : udpsocks[1];
 
+       int udpsock = (client->remote_udp.ss_family == AF_INET) ? udpsocks[0] : udpsocks[(hasv4) ? 1 : 0];
 
        if (Util_clientAddressToPortUDP(client) != 0 && CryptState_isValid(&client->cryptState) &&
                client->bUDP) {
 #if defined(__LP64__)
-               buf = mbuf = malloc(len + 4 + 16);
+               buf = mbuf = Memory_safeMalloc(1, len + 4 + 16);
                buf += 4;
 #else
-               mbuf = buf = malloc(len + 4);
+               mbuf = buf = Memory_safeMalloc(1, len + 4);
 #endif
-               if (mbuf == NULL)
-                       Log_fatal("Out of memory");
-
                CryptState_encrypt(&client->cryptState, data, buf, len);
 
 #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__)