perf: Make the code for adding group peers non-recursive.

Replaces the recursive implementation of add_to_closest in with an
equivalent iterative loop. This eliminates the risk of stack overflow
during deep peer eviction chains.

Author: iphydf

toxcore/group.c

@@ -442,73 +442,83 @@ static bool add_to_closest(Group_c *_Nonnull g, const uint8_t *_Nonnull real_pk,
         return false;
     }
 
-    unsigned int index = DESIRED_CLOSEST;
-
     for (unsigned int i = 0; i < DESIRED_CLOSEST; ++i) {
         if (g->closest_peers[i].active && pk_equal(real_pk, g->closest_peers[i].real_pk)) {
             return true;
         }
     }
 
-    for (unsigned int i = 0; i < DESIRED_CLOSEST; ++i) {
-        if (!g->closest_peers[i].active) {
-            index = i;
-            break;
-        }
-    }
+    uint8_t cur_real_pk[CRYPTO_PUBLIC_KEY_SIZE];
+    uint8_t cur_temp_pk[CRYPTO_PUBLIC_KEY_SIZE];
+    memcpy(cur_real_pk, real_pk, CRYPTO_PUBLIC_KEY_SIZE);
+    memcpy(cur_temp_pk, temp_pk, CRYPTO_PUBLIC_KEY_SIZE);
 
-    if (index == DESIRED_CLOSEST) {
-        uint64_t comp_val = calculate_comp_value(g->real_pk, real_pk);
-        uint64_t comp_d = 0;
+    bool added = false;
 
-        for (unsigned int i = 0; i < (DESIRED_CLOSEST / 2); ++i) {
-            const uint64_t comp = calculate_comp_value(g->real_pk, g->closest_peers[i].real_pk);
+    while (true) {
+        unsigned int index = DESIRED_CLOSEST;
 
-            if (comp > comp_val && comp > comp_d) {
+        for (unsigned int i = 0; i < DESIRED_CLOSEST; ++i) {
+            if (!g->closest_peers[i].active) {
                 index = i;
-                comp_d = comp;
+                break;
             }
         }
 
-        comp_val = calculate_comp_value(real_pk, g->real_pk);
+        if (index == DESIRED_CLOSEST) {
+            uint64_t comp_val = calculate_comp_value(g->real_pk, cur_real_pk);
+            uint64_t comp_d = 0;
 
-        for (unsigned int i = DESIRED_CLOSEST / 2; i < DESIRED_CLOSEST; ++i) {
-            const uint64_t comp = calculate_comp_value(g->closest_peers[i].real_pk, g->real_pk);
+            for (unsigned int i = 0; i < (DESIRED_CLOSEST / 2); ++i) {
+                const uint64_t comp = calculate_comp_value(g->real_pk, g->closest_peers[i].real_pk);
 
-            if (comp > comp_val && comp > comp_d) {
-                index = i;
-                comp_d = comp;
+                if (comp > comp_val && comp > comp_d) {
+                    index = i;
+                    comp_d = comp;
+                }
             }
-        }
-    }
 
-    if (index == DESIRED_CLOSEST) {
-        return false;
-    }
+            comp_val = calculate_comp_value(cur_real_pk, g->real_pk);
 
-    uint8_t old_real_pk[CRYPTO_PUBLIC_KEY_SIZE];
-    uint8_t old_temp_pk[CRYPTO_PUBLIC_KEY_SIZE];
-    bool old = false;
+            for (unsigned int i = DESIRED_CLOSEST / 2; i < DESIRED_CLOSEST; ++i) {
+                const uint64_t comp = calculate_comp_value(g->closest_peers[i].real_pk, g->real_pk);
 
-    if (g->closest_peers[index].active) {
-        memcpy(old_real_pk, g->closest_peers[index].real_pk, CRYPTO_PUBLIC_KEY_SIZE);
-        memcpy(old_temp_pk, g->closest_peers[index].temp_pk, CRYPTO_PUBLIC_KEY_SIZE);
-        old = true;
-    }
+                if (comp > comp_val && comp > comp_d) {
+                    index = i;
+                    comp_d = comp;
+                }
+            }
+        }
+
+        if (index == DESIRED_CLOSEST) {
+            break;
+        }
 
-    g->closest_peers[index].active = true;
-    memcpy(g->closest_peers[index].real_pk, real_pk, CRYPTO_PUBLIC_KEY_SIZE);
-    memcpy(g->closest_peers[index].temp_pk, temp_pk, CRYPTO_PUBLIC_KEY_SIZE);
+        if (g->closest_peers[index].active) {
+            uint8_t tmp[CRYPTO_PUBLIC_KEY_SIZE];
+            memcpy(tmp, g->closest_peers[index].real_pk, CRYPTO_PUBLIC_KEY_SIZE);
+            memcpy(g->closest_peers[index].real_pk, cur_real_pk, CRYPTO_PUBLIC_KEY_SIZE);
+            memcpy(cur_real_pk, tmp, CRYPTO_PUBLIC_KEY_SIZE);
 
-    if (old) {
-        add_to_closest(g, old_real_pk, old_temp_pk);
+            memcpy(tmp, g->closest_peers[index].temp_pk, CRYPTO_PUBLIC_KEY_SIZE);
+            memcpy(g->closest_peers[index].temp_pk, cur_temp_pk, CRYPTO_PUBLIC_KEY_SIZE);
+            memcpy(cur_temp_pk, tmp, CRYPTO_PUBLIC_KEY_SIZE);
+        } else {
+            g->closest_peers[index].active = true;
+            memcpy(g->closest_peers[index].real_pk, cur_real_pk, CRYPTO_PUBLIC_KEY_SIZE);
+            memcpy(g->closest_peers[index].temp_pk, cur_temp_pk, CRYPTO_PUBLIC_KEY_SIZE);
+            added = true;
+            break;
+        }
+
+        added = true;
     }
 
-    if (g->changed == GROUPCHAT_CLOSEST_CHANGE_NONE) {
+    if (added && g->changed == GROUPCHAT_CLOSEST_CHANGE_NONE) {
         g->changed = GROUPCHAT_CLOSEST_CHANGE_ADDED;
     }
 
-    return true;
+    return added;
 }
 
 static bool pk_in_closest_peers(const Group_c *_Nonnull g, const uint8_t *_Nonnull real_pk)