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 @@
-0b904988d79b9576bb88c6c7316d107b5a61bd6119a0992ebd7c1fa43db70abf  /usr/local/bin/tox-bootstrapd
+0b58b866f87d92267db4577d26eebe10dcf5a96ff53ac5a863dade83f471961c  /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,224 @@
+/* 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[TOX_PUBLIC_KEY_SIZE])
+{
+    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)
+{
+    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)
+{
+    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)
+{
+    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)
+{
+    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)
+{
+    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)
+{
+    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)
+{
+    return bin_pack_array(bp, 3)
+           && 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)
+{
+    if (!bin_unpack_array_fixed(bu, 3, 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)
+{
+    *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[TOX_PUBLIC_KEY_SIZE],
+        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;
     }

toxcore/tox_event.h

@@ -10,6 +10,7 @@
 #include "bin_unpack.h"
 #include "mem.h"
 #include "tox_events.h"
+#include "tox_private.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -60,6 +61,7 @@ typedef union Tox_Event_Data {
     Tox_Event_Group_Self_Join *group_self_join;
     Tox_Event_Group_Join_Fail *group_join_fail;
     Tox_Event_Group_Moderation *group_moderation;
+    Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response;
 } Tox_Event_Data;
 
 struct Tox_Event {
@@ -111,6 +113,7 @@ non_null() Tox_Event_Group_Peer_Exit *tox_event_group_peer_exit_new(const Memory
 non_null() Tox_Event_Group_Self_Join *tox_event_group_self_join_new(const Memory *mem);
 non_null() Tox_Event_Group_Join_Fail *tox_event_group_join_fail_new(const Memory *mem);
 non_null() Tox_Event_Group_Moderation *tox_event_group_moderation_new(const Memory *mem);
+non_null() Tox_Event_Dht_Get_Nodes_Response *tox_event_dht_get_nodes_response_new(const Memory *mem);
 
 /**
  * Destructor.
@@ -156,6 +159,7 @@ non_null(2) nullable(1) void tox_event_group_peer_exit_free(Tox_Event_Group_Peer
 non_null(2) nullable(1) void tox_event_group_self_join_free(Tox_Event_Group_Self_Join *group_self_join, const Memory *mem);
 non_null(2) nullable(1) void tox_event_group_join_fail_free(Tox_Event_Group_Join_Fail *group_join_fail, const Memory *mem);
 non_null(2) nullable(1) void tox_event_group_moderation_free(Tox_Event_Group_Moderation *group_moderation, const Memory *mem);
+non_null(2) nullable(1) void tox_event_dht_get_nodes_response_free(Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response, const Memory *mem);
 
 /**
  * Pack into msgpack.
@@ -201,6 +205,7 @@ non_null() bool tox_event_group_peer_exit_pack(const Tox_Event_Group_Peer_Exit *
 non_null() bool tox_event_group_self_join_pack(const Tox_Event_Group_Self_Join *event, Bin_Pack *bp);
 non_null() bool tox_event_group_join_fail_pack(const Tox_Event_Group_Join_Fail *event, Bin_Pack *bp);
 non_null() bool tox_event_group_moderation_pack(const Tox_Event_Group_Moderation *event, Bin_Pack *bp);
+non_null() bool tox_event_dht_get_nodes_response_pack(const Tox_Event_Dht_Get_Nodes_Response *event, Bin_Pack *bp);
 
 /**
  * Unpack from msgpack.
@@ -246,6 +251,7 @@ non_null() bool tox_event_group_peer_exit_unpack(Tox_Event_Group_Peer_Exit **eve
 non_null() bool tox_event_group_self_join_unpack(Tox_Event_Group_Self_Join **event, Bin_Unpack *bu, const Memory *mem);
 non_null() bool tox_event_group_join_fail_unpack(Tox_Event_Group_Join_Fail **event, Bin_Unpack *bu, const Memory *mem);
 non_null() bool tox_event_group_moderation_unpack(Tox_Event_Group_Moderation **event, Bin_Unpack *bu, const Memory *mem);
+non_null() bool tox_event_dht_get_nodes_response_unpack(Tox_Event_Dht_Get_Nodes_Response **event, Bin_Unpack *bu, const Memory *mem);
 
 #ifdef __cplusplus
 }

toxcore/tox_events.c

@@ -67,6 +67,7 @@ void tox_events_init(Tox *tox)
     tox_callback_group_self_join(tox, tox_events_handle_group_self_join);
     tox_callback_group_join_fail(tox, tox_events_handle_group_join_fail);
     tox_callback_group_moderation(tox, tox_events_handle_group_moderation);
+    tox_callback_dht_get_nodes_response(tox, tox_events_handle_dht_get_nodes_response);
 }
 
 uint32_t tox_events_get_size(const Tox_Events *events)

toxcore/tox_events.h

@@ -343,6 +343,16 @@ uint32_t tox_event_group_moderation_get_target_peer_id(
 Tox_Group_Mod_Event tox_event_group_moderation_get_mod_type(
     const Tox_Event_Group_Moderation *group_moderation);
 
+typedef struct Tox_Event_Dht_Get_Nodes_Response Tox_Event_Dht_Get_Nodes_Response;
+const uint8_t *tox_event_dht_get_nodes_response_get_public_key(
+    const Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response);
+const uint8_t *tox_event_dht_get_nodes_response_get_ip(
+    const Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response);
+uint32_t tox_event_dht_get_nodes_response_get_ip_length(
+    const Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response);
+uint16_t tox_event_dht_get_nodes_response_get_port(
+    const Tox_Event_Dht_Get_Nodes_Response *dht_get_nodes_response);
+
 typedef enum Tox_Event_Type {
     TOX_EVENT_SELF_CONNECTION_STATUS        = 0,
 
@@ -391,6 +401,8 @@ typedef enum Tox_Event_Type {
     TOX_EVENT_GROUP_JOIN_FAIL               = 37,
     TOX_EVENT_GROUP_MODERATION              = 38,
 
+    TOX_EVENT_DHT_GET_NODES_RESPONSE        = 39,
+
     TOX_EVENT_INVALID                       = 255,
 } Tox_Event_Type;
 
@@ -486,6 +498,8 @@ const Tox_Event_Group_Join_Fail *tox_event_get_group_join_fail(
     const Tox_Event *event);
 const Tox_Event_Group_Moderation *tox_event_get_group_moderation(
     const Tox_Event *event);
+const Tox_Event_Dht_Get_Nodes_Response *tox_event_get_dht_get_nodes_response(
+    const Tox_Event *event);
 
 /**
  * Container object for all Tox core events.