refactor: Assign malloc return to a local variable first.

Author: iphydf

other/bootstrap_daemon/docker/tox-bootstrapd.sha256

@@ -1 +1 @@
-bc830120a87517f830eb85494b769c523bd1696328938d46e9eac1eefea61d38  /usr/local/bin/tox-bootstrapd
+d5061af781d04d17bf26174c129b6149e0c8a120ef41133a51a8a7cc5e571e37  /usr/local/bin/tox-bootstrapd

toxav/msi.c

@@ -587,7 +587,7 @@ static MSICall *new_call(MSISession *session, uint32_t friend_number)
         session->calls_tail = friend_number;
         session->calls_head = friend_number;
     } else if (session->calls_tail < friend_number) { /* Appending */
-        MSICall **tmp = (MSICall **)realloc(session->calls, sizeof(MSICall *) * (friend_number + 1));
+        MSICall **tmp = (MSICall **)realloc(session->calls,  (friend_number + 1) * sizeof(MSICall *));
 
         if (tmp == nullptr) {
             free(rc);

toxav/toxav.c

@@ -1284,7 +1284,7 @@ static ToxAVCall *call_new(ToxAV *av, uint32_t friend_number, Toxav_Err_Call *er
         av->calls_tail = friend_number;
         av->calls_head = friend_number;
     } else if (av->calls_tail < friend_number) { /* Appending */
-        ToxAVCall **tmp = (ToxAVCall **)realloc(av->calls, sizeof(ToxAVCall *) * (friend_number + 1));
+        ToxAVCall **tmp = (ToxAVCall **)realloc(av->calls, (friend_number + 1) * sizeof(ToxAVCall *));
 
         if (tmp == nullptr) {
             pthread_mutex_destroy(call->toxav_call_mutex);

toxcore/DHT.c

@@ -448,8 +448,8 @@ int dht_create_packet(const Memory *mem, const Random *rng,
                       const uint8_t *plain, size_t plain_length,
                       uint8_t *packet, size_t length)
 {
-    uint8_t *encrypted = (uint8_t *)mem_balloc(mem, plain_length + CRYPTO_MAC_SIZE);
     uint8_t nonce[CRYPTO_NONCE_SIZE];
+    uint8_t *encrypted = (uint8_t *)mem_balloc(mem, plain_length + CRYPTO_MAC_SIZE);
 
     if (encrypted == nullptr) {
         return -1;
@@ -2908,23 +2908,27 @@ static State_Load_Status dht_load_state_callback(void *outer, const uint8_t *dat
             }
 
             mem_delete(dht->mem, dht->loaded_nodes_list);
+
             // Copy to loaded_clients_list
-            dht->loaded_nodes_list = (Node_format *)mem_valloc(dht->mem, MAX_SAVED_DHT_NODES, sizeof(Node_format));
+            Node_format *nodes = (Node_format *)mem_valloc(dht->mem, MAX_SAVED_DHT_NODES, sizeof(Node_format));
 
-            if (dht->loaded_nodes_list == nullptr) {
+            if (nodes == nullptr) {
                 LOGGER_ERROR(dht->log, "could not allocate %u nodes", MAX_SAVED_DHT_NODES);
                 dht->loaded_num_nodes = 0;
                 break;
             }
 
-            const int num = unpack_nodes(dht->loaded_nodes_list, MAX_SAVED_DHT_NODES, nullptr, data, length, false);
+            const int num = unpack_nodes(nodes, MAX_SAVED_DHT_NODES, nullptr, data, length, false);
 
-            if (num > 0) {
-                dht->loaded_num_nodes = num;
-            } else {
+            if (num < 0) {
+                // Unpack error happened, we ignore it.
                 dht->loaded_num_nodes = 0;
+            } else {
+                dht->loaded_num_nodes = num;
             }
 
+            dht->loaded_nodes_list = nodes;
+
             break;
         }
 

toxcore/LAN_discovery.c

@@ -62,35 +62,38 @@ static Broadcast_Info *fetch_broadcast_info(const Network *ns)
         return nullptr;
     }
 
-    IP_ADAPTER_INFO *pAdapterInfo = (IP_ADAPTER_INFO *)malloc(sizeof(IP_ADAPTER_INFO));
-    unsigned long ulOutBufLen = sizeof(IP_ADAPTER_INFO);
+    IP_ADAPTER_INFO *adapter_info = (IP_ADAPTER_INFO *)malloc(sizeof(IP_ADAPTER_INFO));
 
-    if (pAdapterInfo == nullptr) {
+    if (adapter_info == nullptr) {
         free(broadcast);
         return nullptr;
     }
 
-    if (GetAdaptersInfo(pAdapterInfo, &ulOutBufLen) == ERROR_BUFFER_OVERFLOW) {
-        free(pAdapterInfo);
-        pAdapterInfo = (IP_ADAPTER_INFO *)malloc(ulOutBufLen);
+    unsigned long out_buf_len = sizeof(IP_ADAPTER_INFO);
 
-        if (pAdapterInfo == nullptr) {
+    if (GetAdaptersInfo(adapter_info, &out_buf_len) == ERROR_BUFFER_OVERFLOW) {
+        free(adapter_info);
+        IP_ADAPTER_INFO *new_adapter_info = (IP_ADAPTER_INFO *)malloc(out_buf_len);
+
+        if (new_adapter_info == nullptr) {
             free(broadcast);
             return nullptr;
         }
+
+        adapter_info = new_adapter_info;
     }
 
-    const int ret = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen);
+    const int ret = GetAdaptersInfo(adapter_info, &out_buf_len);
 
     if (ret == NO_ERROR) {
-        IP_ADAPTER_INFO *pAdapter = pAdapterInfo;
+        IP_ADAPTER_INFO *adapter = adapter_info;
 
-        while (pAdapter != nullptr) {
+        while (adapter != nullptr) {
             IP gateway = {0};
             IP subnet_mask = {0};
 
-            if (addr_parse_ip(pAdapter->IpAddressList.IpMask.String, &subnet_mask)
-                    && addr_parse_ip(pAdapter->GatewayList.IpAddress.String, &gateway)) {
+            if (addr_parse_ip(adapter->IpAddressList.IpMask.String, &subnet_mask)
+                    && addr_parse_ip(adapter->GatewayList.IpAddress.String, &gateway)) {
                 if (net_family_is_ipv4(gateway.family) && net_family_is_ipv4(subnet_mask.family)) {
                     IP *ip = &broadcast->ips[broadcast->count];
                     ip->family = net_family_ipv4();
@@ -106,12 +109,12 @@ static Broadcast_Info *fetch_broadcast_info(const Network *ns)
                 }
             }
 
-            pAdapter = pAdapter->Next;
+            adapter = adapter->Next;
         }
     }
 
-    if (pAdapterInfo != nullptr) {
-        free(pAdapterInfo);
+    if (adapter_info != nullptr) {
+        free(adapter_info);
     }
 
     return broadcast;

toxcore/TCP_common.c

@@ -105,17 +105,19 @@ static bool add_priority(TCP_Connection *con, const uint8_t *packet, uint16_t si
         return false;
     }
 
-    new_list->next = nullptr;
-    new_list->size = size;
-    new_list->sent = sent;
-    new_list->data = (uint8_t *)mem_balloc(con->mem, size);
+    uint8_t *data = (uint8_t *)mem_balloc(con->mem, size);
 
-    if (new_list->data == nullptr) {
+    if (data == nullptr) {
         mem_delete(con->mem, new_list);
         return false;
     }
 
-    memcpy(new_list->data, packet, size);
+    memcpy(data, packet, size);
+    new_list->data = data;
+    new_list->size = size;
+
+    new_list->next = nullptr;
+    new_list->sent = sent;
 
     if (p != nullptr) {
         p->next = new_list;

toxcore/TCP_server.c

@@ -968,20 +968,22 @@ TCP_Server *new_tcp_server(const Logger *logger, const Memory *mem, const Random
     temp->ns = ns;
     temp->rng = rng;
 
-    temp->socks_listening = (Socket *)mem_valloc(mem, num_sockets, sizeof(Socket));
+    Socket *socks_listening = (Socket *)mem_valloc(mem, num_sockets, sizeof(Socket));
 
-    if (temp->socks_listening == nullptr) {
+    if (socks_listening == nullptr) {
         LOGGER_ERROR(logger, "socket allocation failed");
         mem_delete(mem, temp);
         return nullptr;
     }
 
+    temp->socks_listening = socks_listening;
+
 #ifdef TCP_SERVER_USE_EPOLL
     temp->efd = epoll_create(8);
 
     if (temp->efd == -1) {
         LOGGER_ERROR(logger, "epoll initialisation failed");
-        mem_delete(mem, temp->socks_listening);
+        mem_delete(mem, socks_listening);
         mem_delete(mem, temp);
         return nullptr;
     }

toxcore/announce.c

@@ -243,13 +243,15 @@ bool announce_store_data(Announcements *announce, const uint8_t *data_public_key
             free(entry->data);
         }
 
-        entry->data = (uint8_t *)malloc(length);
+        uint8_t *entry_data = (uint8_t *)malloc(length);
 
-        if (entry->data == nullptr) {
+        if (entry_data == nullptr) {
+            entry->data = nullptr;  // TODO(iphydf): Is this necessary?
             return false;
         }
 
-        memcpy(entry->data, data, length);
+        memcpy(entry_data, data, length);
+        entry->data = entry_data;
     }
 
     entry->length = length;

toxcore/events/conference_invite.c

@@ -81,13 +81,14 @@ static bool tox_event_conference_invite_set_cookie(Tox_Event_Conference_Invite *
         conference_invite->cookie_length = 0;
     }
 
-    conference_invite->cookie = (uint8_t *)malloc(cookie_length);
+    uint8_t *cookie_copy = (uint8_t *)malloc(cookie_length);
 
-    if (conference_invite->cookie == nullptr) {
+    if (cookie_copy == nullptr) {
         return false;
     }
 
-    memcpy(conference_invite->cookie, cookie, cookie_length);
+    memcpy(cookie_copy, cookie, cookie_length);
+    conference_invite->cookie = cookie_copy;
     conference_invite->cookie_length = cookie_length;
     return true;
 }

toxcore/events/conference_message.c

@@ -95,13 +95,14 @@ static bool tox_event_conference_message_set_message(Tox_Event_Conference_Messag
         conference_message->message_length = 0;
     }
 
-    conference_message->message = (uint8_t *)malloc(message_length);
+    uint8_t *message_copy = (uint8_t *)malloc(message_length);
 
-    if (conference_message->message == nullptr) {
+    if (message_copy == nullptr) {
         return false;
     }
 
-    memcpy(conference_message->message, message, message_length);
+    memcpy(message_copy, message, message_length);
+    conference_message->message = message_copy;
     conference_message->message_length = message_length;
     return true;
 }