feat: Add dht_get_nodes_response event to the events system.

Should probably rename it to something starting with `debug_` and make
it opt-in. Right now, it absolutely spams the events object.

CMakeLists.txt

@@ -231,6 +231,7 @@ set(toxcore_SOURCES
   toxcore/events/conference_peer_list_changed.c
   toxcore/events/conference_peer_name.c
   toxcore/events/conference_title.c
+  toxcore/events/dht_get_nodes_response.c
   toxcore/events/events_alloc.c
   toxcore/events/events_alloc.h
   toxcore/events/file_chunk_request.c

other/bootstrap_daemon/docker/tox-bootstrapd.sha256

@@ -1 +1 @@
-50123098ff16637a19253e4ea24c0b7bc7d1ef35f6e7c9f2783bddd303a6c6f3  /usr/local/bin/tox-bootstrapd
+378ea1e777235c7ec702af0e0ef2c2265ce4d622cf00f48f5fc66f490f2b3881  /usr/local/bin/tox-bootstrapd

toxcore/Makefile.inc

@@ -21,6 +21,7 @@ libtoxcore_la_SOURCES = ../third_party/cmp/cmp.c \
                         ../toxcore/events/conference_peer_list_changed.c \
                         ../toxcore/events/conference_peer_name.c \
                         ../toxcore/events/conference_title.c \
+                        ../toxcore/events/dht_get_nodes_response.c \
                         ../toxcore/events/events_alloc.c \
                         ../toxcore/events/events_alloc.h \
                         ../toxcore/events/file_chunk_request.c \

toxcore/events/dht_get_nodes_response.c

@@ -0,0 +1,237 @@
+/* SPDX-License-Identifier: GPL-3.0-or-later
+ * Copyright © 2022 The TokTok team.
+ */
+
+#include "events_alloc.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "../bin_pack.h"
+#include "../bin_unpack.h"
+#include "../ccompat.h"
+#include "../mem.h"
+#include "../tox.h"
+#include "../tox_events.h"
+#include "../tox_private.h"
+
+
+/*****************************************************
+ *
+ * :: struct and accessors
+ *
+ *****************************************************/
+
+
+struct Tox_Event_Dht_Get_Nodes_Response {
+    uint8_t public_key[TOX_PUBLIC_KEY_SIZE];
+    uint8_t *ip;
+    uint32_t ip_length;
+    uint16_t port;
+};
+
+non_null()
+static bool tox_event_dht_get_nodes_response_set_public_key(Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response, const uint8_t *public_key)
+{
+    assert(dht_get_nodes_response != nullptr);
+
+    memcpy(dht_get_nodes_response->public_key, public_key, TOX_PUBLIC_KEY_SIZE);
+    return true;
+}
+const uint8_t *tox_event_dht_get_nodes_response_get_public_key(const Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response)
+{
+    assert(dht_get_nodes_response != nullptr);
+    return dht_get_nodes_response->public_key;
+}
+
+non_null()
+static bool tox_event_dht_get_nodes_response_set_ip(Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response,
+        const char *ip, uint32_t ip_length, const Memory *mem)
+{
+    assert(dht_get_nodes_response != nullptr);
+
+    if (dht_get_nodes_response->ip != nullptr) {
+        mem_delete(mem, dht_get_nodes_response->ip);
+        dht_get_nodes_response->ip = nullptr;
+        dht_get_nodes_response->ip_length = 0;
+    }
+
+    uint8_t *ip_tmp = (uint8_t *)mem_balloc(mem, ip_length);
+
+    if (ip_tmp == nullptr) {
+        return false;
+    }
+
+    memcpy(ip_tmp, ip, ip_length);
+    dht_get_nodes_response->ip = ip_tmp;
+    dht_get_nodes_response->ip_length = ip_length;
+    return true;
+}
+uint32_t tox_event_dht_get_nodes_response_get_ip_length(const Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response)
+{
+    assert(dht_get_nodes_response != nullptr);
+    return dht_get_nodes_response->ip_length;
+}
+const uint8_t *tox_event_dht_get_nodes_response_get_ip(const Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response)
+{
+    assert(dht_get_nodes_response != nullptr);
+    return dht_get_nodes_response->ip;
+}
+
+non_null()
+static bool tox_event_dht_get_nodes_response_set_port(Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response, uint16_t port)
+{
+    assert(dht_get_nodes_response != nullptr);
+
+    dht_get_nodes_response->port = port;
+    return true;
+}
+uint16_t tox_event_dht_get_nodes_response_get_port(const Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response)
+{
+    assert(dht_get_nodes_response != nullptr);
+    return dht_get_nodes_response->port;
+}
+
+non_null()
+static void tox_event_dht_get_nodes_response_construct(Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response)
+{
+    *dht_get_nodes_response = (Tox_Event_Dht_Get_Nodes_Response) {
+        0
+    };
+}
+non_null()
+static void tox_event_dht_get_nodes_response_destruct(Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response, const Memory *mem)
+{
+    mem_delete(mem, dht_get_nodes_response->ip);
+}
+
+bool tox_event_dht_get_nodes_response_pack(
+    const Tox_Event_Dht_Get_Nodes_Response *event, Bin_Pack *bp)
+{
+    assert(event != nullptr);
+    return bin_pack_array(bp, 2)
+           && bin_pack_bin(bp, event->public_key, TOX_PUBLIC_KEY_SIZE)
+           && bin_pack_bin(bp, event->ip, event->ip_length)
+           && bin_pack_u16(bp, event->port);
+}
+
+non_null()
+static bool tox_event_dht_get_nodes_response_unpack_into(
+    Tox_Event_Dht_Get_Nodes_Response *event, Bin_Unpack *bu)
+{
+    assert(event != nullptr);
+    if (!bin_unpack_array_fixed(bu, 2, nullptr)) {
+        return false;
+    }
+
+    return bin_unpack_bin_fixed(bu, event->public_key, TOX_PUBLIC_KEY_SIZE)
+           && bin_unpack_bin(bu, &event->ip, &event->ip_length)
+           && bin_unpack_u16(bu, &event->port);
+}
+
+const Tox_Event_Dht_Get_Nodes_Response *tox_event_get_dht_get_nodes_response(
+    const Tox_Event *event)
+{
+    return event->type == TOX_EVENT_DHT_GET_NODES_RESPONSE ? event->data.dht_get_nodes_response : nullptr;
+}
+
+Tox_Event_Dht_Get_Nodes_Response *tox_event_dht_get_nodes_response_new(const Memory *mem)
+{
+    Tox_Event_Dht_Get_Nodes_Response *const dht_get_nodes_response =
+        (Tox_Event_Dht_Get_Nodes_Response *)mem_alloc(mem, sizeof(Tox_Event_Dht_Get_Nodes_Response));
+
+    if (dht_get_nodes_response == nullptr) {
+        return nullptr;
+    }
+
+    tox_event_dht_get_nodes_response_construct(dht_get_nodes_response);
+    return dht_get_nodes_response;
+}
+
+void tox_event_dht_get_nodes_response_free(Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response, const Memory *mem)
+{
+    if (dht_get_nodes_response != nullptr) {
+        tox_event_dht_get_nodes_response_destruct(dht_get_nodes_response, mem);
+    }
+    mem_delete(mem, dht_get_nodes_response);
+}
+
+non_null()
+static Tox_Event_Dht_Get_Nodes_Response *tox_events_add_dht_get_nodes_response(Tox_Events *events, const Memory *mem)
+{
+    Tox_Event_Dht_Get_Nodes_Response *const dht_get_nodes_response = tox_event_dht_get_nodes_response_new(mem);
+
+    if (dht_get_nodes_response == nullptr) {
+        return nullptr;
+    }
+
+    Tox_Event event;
+    event.type = TOX_EVENT_DHT_GET_NODES_RESPONSE;
+    event.data.dht_get_nodes_response = dht_get_nodes_response;
+
+    tox_events_add(events, &event);
+    return dht_get_nodes_response;
+}
+
+bool tox_event_dht_get_nodes_response_unpack(
+    Tox_Event_Dht_Get_Nodes_Response **event, Bin_Unpack *bu, const Memory *mem)
+{
+    assert(event != nullptr);
+    *event = tox_event_dht_get_nodes_response_new(mem);
+
+    if (*event == nullptr) {
+        return false;
+    }
+
+    return tox_event_dht_get_nodes_response_unpack_into(*event, bu);
+}
+
+non_null()
+static Tox_Event_Dht_Get_Nodes_Response *tox_event_dht_get_nodes_response_alloc(void *user_data)
+{
+    Tox_Events_State *state = tox_events_alloc(user_data);
+    assert(state != nullptr);
+
+    if (state->events == nullptr) {
+        return nullptr;
+    }
+
+    Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response = tox_events_add_dht_get_nodes_response(state->events, state->mem);
+
+    if (dht_get_nodes_response == nullptr) {
+        state->error = TOX_ERR_EVENTS_ITERATE_MALLOC;
+        return nullptr;
+    }
+
+    return dht_get_nodes_response;
+}
+
+
+/*****************************************************
+ *
+ * :: event handler
+ *
+ *****************************************************/
+
+
+void tox_events_handle_dht_get_nodes_response(
+        Tox *tox, const uint8_t *public_key, const char *ip, uint16_t port,
+        void *user_data)
+{
+    Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response = tox_event_dht_get_nodes_response_alloc(user_data);
+
+    if (dht_get_nodes_response == nullptr) {
+        return;
+    }
+
+    const size_t ip_length = strlen(ip);
+    if (ip_length >= UINT32_MAX) {
+        return;
+    }
+
+    const Tox_System *sys = tox_get_system(tox);
+
+    tox_event_dht_get_nodes_response_set_public_key(dht_get_nodes_response, public_key);
+    tox_event_dht_get_nodes_response_set_ip(dht_get_nodes_response, ip, ip_length + 1, sys->mem);
+    tox_event_dht_get_nodes_response_set_port(dht_get_nodes_response, port);
+}

toxcore/events/events_alloc.h

@@ -34,6 +34,7 @@ tox_conference_message_cb tox_events_handle_conference_message;
 tox_conference_peer_list_changed_cb tox_events_handle_conference_peer_list_changed;
 tox_conference_peer_name_cb tox_events_handle_conference_peer_name;
 tox_conference_title_cb tox_events_handle_conference_title;
+tox_dht_get_nodes_response_cb tox_events_handle_dht_get_nodes_response;
 tox_file_chunk_request_cb tox_events_handle_file_chunk_request;
 tox_file_recv_cb tox_events_handle_file_recv;
 tox_file_recv_chunk_cb tox_events_handle_file_recv_chunk;

toxcore/tox_dispatch.c

@@ -52,6 +52,7 @@ struct Tox_Dispatch {
     tox_events_group_self_join_cb *group_self_join_callback;
     tox_events_group_join_fail_cb *group_join_fail_callback;
     tox_events_group_moderation_cb *group_moderation_callback;
+    tox_events_dht_get_nodes_response_cb *dht_get_nodes_response_callback;
 };
 
 Tox_Dispatch *tox_dispatch_new(Tox_Err_Dispatch_New *error)
@@ -277,6 +278,11 @@ void tox_events_callback_group_moderation(
 {
     dispatch->group_moderation_callback = callback;
 }
+void tox_events_callback_dht_get_nodes_response(
+    Tox_Dispatch *dispatch, tox_events_dht_get_nodes_response_cb *callback)
+{
+    dispatch->dht_get_nodes_response_callback = callback;
+}
 
 non_null(1, 2) nullable(3, 4)
 static void tox_dispatch_invoke_event(const Tox_Dispatch *dispatch, const Tox_Event *event, Tox *tox, void *user_data)
@@ -594,6 +600,14 @@ static void tox_dispatch_invoke_event(const Tox_Dispatch *dispatch, const Tox_Ev
             break;
         }
 
+        case TOX_EVENT_DHT_GET_NODES_RESPONSE: {
+            if (dispatch->dht_get_nodes_response_callback != nullptr) {
+                dispatch->dht_get_nodes_response_callback(tox, event->data.dht_get_nodes_response, user_data);
+            }
+
+            break;
+        }
+
         case TOX_EVENT_INVALID: {
             break;
         }

toxcore/tox_dispatch.h

@@ -129,6 +129,8 @@ typedef void tox_events_group_join_fail_cb(
     Tox *tox, const Tox_Event_Group_Join_Fail *event, void *user_data);
 typedef void tox_events_group_moderation_cb(
     Tox *tox, const Tox_Event_Group_Moderation *event, void *user_data);
+typedef void tox_events_dht_get_nodes_response_cb(
+    Tox *tox, const Tox_Event_Dht_Get_Nodes_Response *event, void *user_data);
 
 void tox_events_callback_conference_connected(
     Tox_Dispatch *dispatch, tox_events_conference_connected_cb *callback);
@@ -208,6 +210,8 @@ void tox_events_callback_group_join_fail(
     Tox_Dispatch *dispatch, tox_events_group_join_fail_cb *callback);
 void tox_events_callback_group_moderation(
     Tox_Dispatch *dispatch, tox_events_group_moderation_cb *callback);
+void tox_events_callback_dht_get_nodes_response(
+    Tox_Dispatch *dispatch, tox_events_dht_get_nodes_response_cb *callback);
 
 #ifdef __cplusplus
 }

toxcore/tox_event.c

@@ -132,6 +132,9 @@ const char *tox_event_type_to_string(Tox_Event_Type type)
         case TOX_EVENT_GROUP_MODERATION:
             return "TOX_EVENT_GROUP_MODERATION";
 
+        case TOX_EVENT_DHT_GET_NODES_RESPONSE:
+            return "TOX_EVENT_DHT_GET_NODES_RESPONSE";
+
         case TOX_EVENT_INVALID:
             return "TOX_EVENT_INVALID";
     }
@@ -346,6 +349,11 @@ bool tox_event_construct(Tox_Event *event, Tox_Event_Type type, const Memory *me
             break;
         }
 
+        case TOX_EVENT_DHT_GET_NODES_RESPONSE: {
+            event->data.dht_get_nodes_response = tox_event_dht_get_nodes_response_new(mem);
+            break;
+        }
+
         case TOX_EVENT_INVALID: {
             return false;
         }
@@ -556,6 +564,11 @@ void tox_event_destruct(Tox_Event *event, const Memory *mem)
             break;
         }
 
+        case TOX_EVENT_DHT_GET_NODES_RESPONSE: {
+            tox_event_dht_get_nodes_response_free(event->data.dht_get_nodes_response, mem);
+            break;
+        }
+
         case TOX_EVENT_INVALID: {
             break;
         }
@@ -691,6 +704,9 @@ static bool tox_event_data_pack(Tox_Event_Type type, const Tox_Event_Data *data,
         case TOX_EVENT_GROUP_MODERATION:
             return tox_event_group_moderation_pack(data->group_moderation, bp);
 
+        case TOX_EVENT_DHT_GET_NODES_RESPONSE:
+            return tox_event_dht_get_nodes_response_pack(data->dht_get_nodes_response, bp);
+
         case TOX_EVENT_INVALID:
             return false;
     }
@@ -906,6 +922,11 @@ static bool tox_event_type_from_int(uint32_t value, Tox_Event_Type *out)
             return true;
         }
 
+        case TOX_EVENT_DHT_GET_NODES_RESPONSE: {
+            *out = TOX_EVENT_DHT_GET_NODES_RESPONSE;
+            return true;
+        }
+
         case TOX_EVENT_INVALID: {
             *out = TOX_EVENT_INVALID;
             return true;
@@ -1062,6 +1083,9 @@ bool tox_event_unpack_into(Tox_Event *event, Bin_Unpack *bu, const Memory *mem)
         case TOX_EVENT_GROUP_MODERATION:
             return tox_event_group_moderation_unpack(&event->data.group_moderation, bu, mem);
 
+        case TOX_EVENT_DHT_GET_NODES_RESPONSE:
+            return tox_event_dht_get_nodes_response_unpack(&event->data.dht_get_nodes_response, bu, mem);
+
         case TOX_EVENT_INVALID:
             return false;
     }