[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[gnunet] 13/19: Refactoring the burst logic.
|
From: |
gnunet |
|
Subject: |
[gnunet] 13/19: Refactoring the burst logic. |
|
Date: |
Wed, 28 Aug 2024 11:19:43 +0200 |
This is an automated email from the git hooks/post-receive script.
t3sserakt pushed a commit to branch master
in repository gnunet.
commit d6925db2ef45db61fcc24e411432ddd889c4c225
Author: t3sserakt <t3ss@posteo.de>
AuthorDate: Fri Aug 23 10:58:54 2024 +0200
Refactoring the burst logic.
---
src/include/gnunet_nat_lib.h | 34 +-
src/include/gnunet_protocols.h | 5 +
.../gnunet_transport_communication_service.h | 7 +
src/lib/util/nat.c | 184 +++++++---
src/service/transport/gnunet-communicator-udp.c | 25 +-
src/service/transport/gnunet-service-transport.c | 399 +++++++++++++--------
src/service/transport/transport.h | 13 +-
.../transport/transport_api2_communication.c | 27 +-
8 files changed, 469 insertions(+), 225 deletions(-)
diff --git a/src/include/gnunet_nat_lib.h b/src/include/gnunet_nat_lib.h
index 65fb29fa0..ba6179f06 100644
--- a/src/include/gnunet_nat_lib.h
+++ b/src/include/gnunet_nat_lib.h
@@ -74,16 +74,6 @@ struct GNUNET_BurstMessage
*/
struct GNUNET_StartBurstCls
{
- /**
- * Kept in a DLL.
- */
- struct GNUNET_StartBurstCls *next;
-
- /**
- * Kept in a DLL.
- */
- struct GNUNET_StartBurstCls *prev;
-
/**
* A Context which can be inserted into this struct, which is specific for
the caller.
*/
@@ -109,6 +99,11 @@ struct GNUNET_StartBurstCls
* The VirtualLink of the peer to which we like to burst with.
*/
struct VirtualLink *vl;
+
+ /**
+ * We are ready to start the burst.
+ */
+ unsigned int sync_ready;
};
struct GNUNET_UdpSocketInfo;
@@ -154,13 +149,28 @@ struct GNUNET_UdpSocketInfo
/**
* The read task for retrieving a burst message for this socket.
*/
- struct GNUNET_SCHEDULER_Task *task;
+ struct GNUNET_SCHEDULER_Task *read_task;
+ /**
+ * Timeout task for this socket.
+ */
+ struct GNUNET_SCHEDULER_Task *timeout_task;
+
/**
* The address of the other peer without port.
*/
const char *address;
+ /**
+ * Our address without port.
+ */
+ const char *bind_address;
+
+ /**
+ * The port we are bound to.
+ */
+ unsigned int port;
+
/**
* The address of the other peer we received a burst message from.
*/
@@ -202,7 +212,7 @@ GNUNET_get_burst_sync_msg (struct GNUNET_TIME_Relative
rtt_avarage,
*
* @return Are we burst ready. This is independent from the other peer being
ready.
*/
-enum GNUNET_GenericReturnValue
+void
GNUNET_is_burst_ready (struct GNUNET_TIME_Relative rtt_avarage,
struct GNUNET_BurstSync *burst_sync,
GNUNET_SCHEDULER_TaskCallback task,
diff --git a/src/include/gnunet_protocols.h b/src/include/gnunet_protocols.h
index 9645c206e..e99a2468f 100644
--- a/src/include/gnunet_protocols.h
+++ b/src/include/gnunet_protocols.h
@@ -3425,6 +3425,11 @@ extern "C" {
*/
#define GNUNET_MESSAGE_TYPE_TRANSPORT_START_BURST 1253
+/**
+ * Burst message we send to another peer for hole punching.
+ */
+#define GNUNET_MESSAGE_TYPE_TRANSPORT_BURST_FINISHED 1254
+
/**
* Message exchanged between communicators to confirm
* successful KX (and address validation).
diff --git a/src/include/gnunet_transport_communication_service.h
b/src/include/gnunet_transport_communication_service.h
index 721b16605..43242e89b 100644
--- a/src/include/gnunet_transport_communication_service.h
+++ b/src/include/gnunet_transport_communication_service.h
@@ -230,6 +230,13 @@ GNUNET_TRANSPORT_communicator_receive (
void *cb_cls);
+/**
+ * The communicator tells the transport service that it finished the burst.*
+ * @param handle connection to transport service.
+ */
+void
+GNUNET_TRANSPORT_communicator_burst_finished (struct
GNUNET_TRANSPORT_CommunicatorHandle *ch);
+
/* ************************* Discovery *************************** */
/**
diff --git a/src/lib/util/nat.c b/src/lib/util/nat.c
index badfd1d5e..7f2ad9126 100644
--- a/src/lib/util/nat.c
+++ b/src/lib/util/nat.c
@@ -33,8 +33,8 @@
#define SEND_DELAY \
GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 10)
-#define READ_TIMEOUT \
- GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 500)
+#define TIMEOUT_DELAY \
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
/**
* Difference of the avarage RTT for the DistanceVector calculate by us and
the target
@@ -49,10 +49,13 @@ static struct GNUNET_UdpSocketInfo *sock_infos_tail;
static struct GNUNET_SCHEDULER_Task *read_send_task;
-static struct GNUNET_SCHEDULER_Task *timeout_task;
-
unsigned int udp_port;
+/**
+ * Maximum of open sockets.
+ */
+unsigned int nr_open_sockets;
+
/**
* Create @a GNUNET_BurstSync message.
*
@@ -82,7 +85,7 @@ GNUNET_get_burst_sync_msg (struct GNUNET_TIME_Relative
rtt_avarage,
*
* @return Are we burst ready. This is independent from the other peer being
ready.
*/
-enum GNUNET_GenericReturnValue
+void
GNUNET_is_burst_ready (struct GNUNET_TIME_Relative rtt_avarage,
struct GNUNET_BurstSync *burst_sync,
GNUNET_SCHEDULER_TaskCallback task,
@@ -123,14 +126,14 @@ GNUNET_is_burst_ready (struct GNUNET_TIME_Relative
rtt_avarage,
task_cls->delay = GNUNET_TIME_relative_saturating_multiply (rtt_avarage,
4);
}
+ task_cls->sync_ready = GNUNET_YES;
task (task_cls);
- return GNUNET_YES;
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"other sync ready 6\n");
- return GNUNET_NO;
+ task_cls->sync_ready = GNUNET_NO;
}
}
@@ -187,11 +190,12 @@ sock_read (void *cls)
/* first, see if it is a GNUNET_BurstMessage */
if (rcvd == sizeof (struct GNUNET_BurstMessage))
{
- struct GNUNET_BurstMessage *bm = GNUNET_new (struct GNUNET_BurstMessage);
+ struct GNUNET_BurstMessage *bm = (struct GNUNET_BurstMessage *) buf;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received a burst message from local port %u!\n",
- bm->local_port);
+ "Received a burst message from remote port %u to local port
%u!\n",
+ bm->local_port,
+ sock_info->port);
sock_info->actual_address = (struct sockaddr *) &sa;
sock_info->nus (sock_info);
GNUNET_stop_burst(sock_info->udp_sock);
@@ -308,8 +312,19 @@ timeout_task_cb (void *cls)
{
struct GNUNET_UdpSocketInfo *sock_info = cls;
- GNUNET_SCHEDULER_cancel (sock_info->task);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "timeout task\n");
+ if (NULL != sock_info->read_task)
+ GNUNET_SCHEDULER_cancel (sock_info->read_task);
GNUNET_NETWORK_socket_close (sock_info->udp_sock);
+ nr_open_sockets--;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "timeout nr_open_sockets %u\n",
+ nr_open_sockets);
+ GNUNET_CONTAINER_DLL_remove (sock_infos_head,
+ sock_infos_tail,
+ sock_info);
+ GNUNET_free (sock_info->address);
GNUNET_free (sock_info);
}
@@ -319,73 +334,117 @@ read_send (void *cls)
{
struct GNUNET_UdpSocketInfo *sock_info = cls;
struct GNUNET_UdpSocketInfo *si = GNUNET_new (struct GNUNET_UdpSocketInfo);
- struct GNUNET_NETWORK_Handle *udp_sock;
- struct GNUNET_SCHEDULER_Task *read_task;
+ struct GNUNET_NETWORK_Handle *udp_sock;;
struct GNUNET_BurstMessage *bm = GNUNET_new (struct GNUNET_BurstMessage);
struct sockaddr *in;
socklen_t in_len;
char *address;
+ struct sockaddr *bind_in;
+ socklen_t bind_in_len;
+ char *bind_address;
+ struct GNUNET_TIME_Relative again = GNUNET_TIME_relative_multiply
(sock_info->rtt,
+ 4);
+
+ if (sock_info->std_port == udp_port)
+ udp_port++;
+ if (512 < nr_open_sockets){
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Trying again in %s",
+ GNUNET_STRINGS_relative_time_to_string (again, GNUNET_NO));
+ read_send_task = GNUNET_SCHEDULER_add_delayed (again,
+ &read_send,
+ sock_info);
+ }
GNUNET_asprintf (&address,
"%s:%u",
sock_info->address,
udp_port);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "3 sock addr %s addr %s %u\n",
+ sock_info->address,
+ address,
+ nr_open_sockets);
in = udp_address_to_sockaddr (address, &in_len);
if (NULL == in)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to setup UDP socket address with path `%s'\n",
- sock_info->address);
- return;
+ address);
+ GNUNET_assert (0);
+ }
+ GNUNET_asprintf (&bind_address,
+ "%s:%u",
+ sock_info->bind_address,
+ udp_port);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "4 sock addr %s addr %s\n",
+ sock_info->bind_address,
+ bind_address);
+ bind_in = udp_address_to_sockaddr (bind_address, &bind_in_len);
+ if (NULL == bind_in)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Failed to setup UDP socket bind address with path `%s'\n",
+ bind_address);
+ GNUNET_assert (0);
}
udp_sock =
- GNUNET_NETWORK_socket_create (in->sa_family,
+ GNUNET_NETWORK_socket_create (bind_in->sa_family,
SOCK_DGRAM,
IPPROTO_UDP);
if (NULL == udp_sock)
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Failed to create socket for %s family %d\n",
- GNUNET_a2s (in,
- in_len),
+ GNUNET_a2s (bind_in,
+ bind_in_len),
in->sa_family);
- GNUNET_free (in);
- GNUNET_free (address);
- GNUNET_free (bm);
- return;
+ if (EMFILE == errno)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Trying again in %s, because of EMFILE\n",
+ GNUNET_STRINGS_relative_time_to_string (again, GNUNET_NO));
+ read_send_task = GNUNET_SCHEDULER_add_delayed (again,
+ &read_send,
+ sock_info);
+ return;
+ }
+ goto next_port;
}
if (GNUNET_OK !=
GNUNET_NETWORK_socket_bind (udp_sock,
- in,
- in_len))
+ bind_in,
+ bind_in_len))
{
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
- "bind",
- address);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Failed to bind socket for %s family %d sock %p\n",
- GNUNET_a2s (in,
- in_len),
- in->sa_family,
+ GNUNET_a2s (bind_in,
+ bind_in_len),
+ bind_in->sa_family,
udp_sock);
GNUNET_NETWORK_socket_close (udp_sock);
udp_sock = NULL;
- GNUNET_free (in);
- GNUNET_free (address);
- GNUNET_free (bm);
- return;
+ goto next_port;
}
+ nr_open_sockets++;
bm->local_port = udp_port;
sock_info->udp_sock = udp_sock;
- read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+ sock_info->port = udp_port;
+ sock_info->read_task = GNUNET_SCHEDULER_add_read_net
(GNUNET_TIME_UNIT_FOREVER_REL,
udp_sock,
&sock_read,
sock_info);
- timeout_task = GNUNET_SCHEDULER_add_delayed (READ_TIMEOUT,
- &timeout_task_cb,
- sock_info);
- sock_info->task = read_task;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Timeout in %s\n",
+ GNUNET_STRINGS_relative_time_to_string (TIMEOUT_DELAY,
GNUNET_NO));
+ sock_info->timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT_DELAY,
+ &timeout_task_cb,
+ sock_info);
+
+ GNUNET_memcpy (si, sock_info, sizeof (struct GNUNET_UdpSocketInfo));
GNUNET_CONTAINER_DLL_insert (sock_infos_head, sock_infos_tail, sock_info);
if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
@@ -394,27 +453,29 @@ read_send (void *cls)
in,
in_len))
{
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending burst to %s family %d failed sock %p\n",
GNUNET_a2s (in,
in_len),
in->sa_family,
udp_sock);
- read_send_task = NULL;
- GNUNET_free (in);
- GNUNET_free (address);
- GNUNET_free (bm);
- return;
+ timeout_task_cb (sock_info);
}
- udp_port++;
- GNUNET_memcpy (si, sock_info, sizeof (struct GNUNET_UdpSocketInfo));
- read_send_task = GNUNET_SCHEDULER_add_delayed (SEND_DELAY,
- &read_send,
- si);
+
+ next_port:
GNUNET_free (in);
+ GNUNET_free (bind_in);
GNUNET_free (address);
+ GNUNET_free (bind_address);
GNUNET_free (bm);
+
+ if (65535 == udp_port)
+ return;
+ udp_port++;
+
+ read_send_task = GNUNET_SCHEDULER_add_delayed (SEND_DELAY,
+ &read_send,
+ si);
}
@@ -440,14 +501,12 @@ GNUNET_get_udp_socket (struct GNUNET_UdpSocketInfo
*sock_info,
in,
in_len))
{
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send");
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Sending burst to %s family %d failed sock %p\n",
GNUNET_a2s (in,
in_len),
in->sa_family,
sock_info->udp_sock);
- return NULL;
}
udp_port = 1024;
@@ -455,9 +514,11 @@ GNUNET_get_udp_socket (struct GNUNET_UdpSocketInfo
*sock_info,
sock_info->nus = nus;
GNUNET_memcpy (si, sock_info, sizeof (struct GNUNET_UdpSocketInfo));
+
read_send_task = GNUNET_SCHEDULER_add_delayed (SEND_DELAY,
- &read_send,
- si);
+ &read_send,
+ si);
+ GNUNET_free (in);
GNUNET_free (bm);
GNUNET_free (address);
return read_send_task;
@@ -480,10 +541,15 @@ GNUNET_stop_burst (struct GNUNET_NETWORK_Handle
*do_not_touch)
{
sock_info = pos;
pos = sock_info->next;
+ GNUNET_CONTAINER_DLL_remove (sock_infos_head,
+ sock_infos_tail,
+ sock_info);
if (do_not_touch != sock_info->udp_sock)
{
- GNUNET_SCHEDULER_cancel (sock_info->task);
+ if (NULL != sock_info->read_task)
+ GNUNET_SCHEDULER_cancel (sock_info->read_task);
GNUNET_NETWORK_socket_close (sock_info->udp_sock);
+ GNUNET_free (sock_info->address);
GNUNET_free (sock_info);
}
}
diff --git a/src/service/transport/gnunet-communicator-udp.c
b/src/service/transport/gnunet-communicator-udp.c
index c2133e944..40a19ba23 100644
--- a/src/service/transport/gnunet-communicator-udp.c
+++ b/src/service/transport/gnunet-communicator-udp.c
@@ -856,6 +856,11 @@ static struct GNUNET_NAT_Handle *nat;
*/
static uint16_t my_port;
+/**
+ * Our ipv4 address.
+ */
+char *my_ipv4;
+
/**
* IPv6 disabled or not.
*/
@@ -2314,10 +2319,13 @@ sock_read (void *cls)
char *address = sockaddr_to_udpaddr_string (addr, sizeof (*addr));
GNUNET_assert (0 == bm->local_port);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Received a burst message for default port\n");
create_receiver (&bm->peer,
address,
NULL);
GNUNET_stop_burst(default_udp_sock);
+ GNUNET_TRANSPORT_communicator_burst_finished (ch);
GNUNET_free (address);
return;
}
@@ -3489,6 +3497,7 @@ static void udp_socket_notify (struct
GNUNET_UdpSocketInfo *sock_info)
address,
default_udp_sock == sock_info->udp_sock ?
NULL : sock_info->udp_sock);
+ GNUNET_TRANSPORT_communicator_burst_finished (ch);
GNUNET_free (sock_info);
}
@@ -3500,13 +3509,24 @@ start_burst (const char *addr,
{
struct GNUNET_UdpSocketInfo *sock_info;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Communicator was called to start burst to address %s from %s\n",
+ addr,
+ my_ipv4);
+
sock_info = GNUNET_new (struct GNUNET_UdpSocketInfo);
- sock_info->address = addr;
+ sock_info->address = GNUNET_strdup (addr);
+ sock_info->bind_address = my_ipv4;
sock_info->has_port = GNUNET_YES;
sock_info->udp_sock = default_udp_sock;
sock_info->rtt = rtt;
sock_info->pid = pid;;
sock_info->std_port = my_port;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "1 sock addr %s addr %s rtt %lu\n",
+ sock_info->address,
+ addr,
+ sock_info->rtt);
burst_task = GNUNET_get_udp_socket (sock_info,
&udp_socket_notify);
GNUNET_free (sock_info);
@@ -3643,7 +3663,10 @@ run (void *cls,
switch (in->sa_family)
{
case AF_INET:
+ const struct sockaddr_in *v4 = (const struct sockaddr_in *)in;
+ my_ipv4 = GNUNET_malloc (INET_ADDRSTRLEN);
my_port = ntohs (((struct sockaddr_in *) in)->sin_port);
+ inet_ntop(AF_INET, &v4->sin_addr, my_ipv4, in_len);
break;
case AF_INET6:
diff --git a/src/service/transport/gnunet-service-transport.c
b/src/service/transport/gnunet-service-transport.c
index 231df7a9c..01fae54e9 100644
--- a/src/service/transport/gnunet-service-transport.c
+++ b/src/service/transport/gnunet-service-transport.c
@@ -1434,6 +1434,16 @@ struct VirtualLink
*/
struct GNUNET_SCHEDULER_Task *fc_retransmit_task;
+ /**
+ * The actual GNUNET_StartBurstCls of this VirtualLink.
+ */
+ struct GNUNET_StartBurstCls *sb_cls;
+
+ /**
+ * global addresses for the peer.
+ */
+ char *burst_addr;
+
/**
* Number of FC retransmissions for this running task.
*/
@@ -1491,9 +1501,9 @@ struct VirtualLink
struct GNUNET_TIME_Relative other_rtt;
/**
- * The task to start the burst.
+ * IterationContext for searching a burst address.
*/
- struct GNUNET_SCHEDULER_Task *burst_task;
+ struct GNUNET_PEERSTORE_IterateContext *ic;
/**
* Used to generate unique UUIDs for messages that are being
@@ -3027,6 +3037,11 @@ static unsigned int ir_total;
*/
static unsigned long long logging_uuid_gen;
+/**
+ * Is there a burst running?
+ */
+static enum GNUNET_GenericReturnValue burst_running;
+
/**
* Monotonic time we use for HELLOs generated at this time. TODO: we
* should increase this value from time to time (i.e. whenever a
@@ -3044,21 +3059,11 @@ static struct GNUNET_TIME_Absolute hello_mono_time;
static int in_shutdown;
/**
- * Head of a DLL with all GNUNET_StartBurstCls. We can only have one active
- * burst. Therefore all other peers ready to burst must be stored here.
- */
-static struct GNUNET_StartBurstCls *bursts_head;
+ * The task to start the burst.
+ */
+static struct GNUNET_SCHEDULER_Task *burst_task;
-/**
- * Tail of a DLL with all GNUNET_StartBurstCls. We can only have one active
- * burst. Therefore all other peers ready to burst must be stored here.
- */
-static struct GNUNET_StartBurstCls *bursts_tail;
-
-/**
- * The GNUNET_StartBurstCls for the active burst, if there is one.
- */
-static struct GNUNET_StartBurstCls *actual_burst;
+struct GNUNET_SCHEDULER_Task *burst_timeout_task;
/**
* Get an offset into the transmission history buffer for `struct
@@ -5419,18 +5424,13 @@ add_global_addresses (void *cls,
struct AddGlobalAddressesContext *ctx = cls;
struct TransportGlobalNattedAddress *tgna = value;
char *addr = (char *) &tgna[1];
- size_t address_len = strlen (addr);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "sending address %s length %lu\n",
+ "sending address %s length %u\n",
addr,
- address_len);
- tgna = GNUNET_malloc (sizeof (struct TransportGlobalNattedAddress) +
address_len);
- tgna->address_length = htonl (address_len);
- GNUNET_memcpy (&tgna[1], addr, address_len);
- GNUNET_memcpy (&(ctx->tgnas[ctx->off]), tgna, sizeof (struct
TransportGlobalNattedAddress) + address_len);
- GNUNET_free (tgna);
- ctx->off += sizeof(struct TransportGlobalNattedAddress) + address_len;
+ ntohl (tgna->address_length));
+ GNUNET_memcpy (&(ctx->tgnas[ctx->off]), tgna, sizeof (struct
TransportGlobalNattedAddress) + ntohl (tgna->address_length));
+ ctx->off += sizeof(struct TransportGlobalNattedAddress) + ntohl
(tgna->address_length);
return GNUNET_OK;
}
@@ -5996,6 +5996,7 @@ create_address_entry (struct TransportClient *tc,
size_t slen)
{
struct AddressListEntry *ale;
+ char *address_without_port;
ale = GNUNET_malloc (sizeof(struct AddressListEntry) + slen);
ale->tc = tc;
@@ -6004,7 +6005,14 @@ create_address_entry (struct TransportClient *tc,
ale->aid = aid;
ale->nt = nt;
memcpy (&ale[1], address, slen);
- ale->st = GNUNET_SCHEDULER_add_now (&store_pi, ale);
+ address_without_port = get_address_without_port (ale->address);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Is this %s a local address (%s)\n",
+ address_without_port,
+ ale->address);
+ if (0 != strcmp ("127.0.0.1", address_without_port))
+ ale->st = GNUNET_SCHEDULER_add_now (&store_pi, ale);
+ GNUNET_free (address_without_port);
return ale;
}
@@ -7348,6 +7356,7 @@ activate_core_visible_dv_path (struct DistanceVectorHop
*hop)
"Creating new virtual link %p to %s using DV!\n",
vl,
GNUNET_i2s (&dv->target));
+ vl->burst_addr = NULL;
vl->confirmed = GNUNET_YES;
vl->message_uuid_ctr =
GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
@@ -9633,6 +9642,7 @@ handle_validation_response (
"Creating new virtual link %p to %s using direct neighbour!\n",
vl,
GNUNET_i2s (&vs->pid));
+ vl->burst_addr = NULL;
vl->confirmed = GNUNET_YES;
vl->message_uuid_ctr =
GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
@@ -9774,9 +9784,7 @@ iterate_address_start_burst (void *cls,
const struct GNUNET_PeerIdentity *pid,
const char *uri)
{
- struct GNUNET_StartBurstCls *sb_cls = cls;
- struct GNUNET_MQ_Envelope *env;
- struct GNUNET_TRANSPORT_StartBurst *sb;
+ struct VirtualLink *vl = cls;
const char *slash;
char *address_uri;
char *prefix;
@@ -9792,56 +9800,31 @@ iterate_address_start_burst (void *cls,
slash);
uri_without_port = get_address_without_port (address_uri);
- if (0 == strcmp (uri_without_port, uri))
- {
- char buf[sizeof (uri_without_port) + 1];
-
- GNUNET_memcpy (buf, uri_without_port, strlen (uri_without_port));
- buf[strlen (uri_without_port) + 1] = '\0';
- env =
- GNUNET_MQ_msg_extra (sb ,
- strlen (uri_without_port) + 1,
- GNUNET_MESSAGE_TYPE_TRANSPORT_START_BURST);
- sb->rtt = GNUNET_TIME_relative_hton (sb_cls->rtt);
- sb->pid = (struct GNUNET_PeerIdentity *) pid;
- memcpy (&sb[1], buf, strlen (uri_without_port) + 1);
- for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
- {
- if (CT_COMMUNICATOR != tc->type)
- continue;
- if (GNUNET_YES == tc->details.communicator.can_burst)
- GNUNET_MQ_send (tc->mq, env);
- }
- GNUNET_free (sb);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "iterate_address_start_burst %s %s %s %s\n",
+ uri_without_port,
+ uri,
+ address_uri,
+ slash);
+ if (0 == strcmp (uri_without_port, slash))
+ {
+ vl->burst_addr = GNUNET_strndup (uri_without_port, strlen
(uri_without_port));
}
+ else
+ vl->burst_addr = NULL;
GNUNET_free (prefix);
- GNUNET_free (address_uri);
GNUNET_free (uri_without_port);
}
-static void
-start_burst_for_address_error_cb (void *cls)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Error in PEERSTORE monitoring starting burst for a specific
address\n");
-}
-
static void
-start_burst_for_address_sync_cb (void *cls)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Done with initial PEERSTORE iteration during monitoring
starting burst for a specific address\n");
-}
-
-
-static void
-start_burst_for_address (void *cls,
- const struct GNUNET_PEERSTORE_Record *record,
- const char *emsg)
+check_for_burst_address (void *cls,
+ const struct GNUNET_PEERSTORE_Record *record,
+ const char *emsg)
{
struct GNUNET_StartBurstCls *sb_cls = cls;
+ struct VirtualLink *vl = sb_cls->vl;
struct GNUNET_MessageHeader *hello;
struct GNUNET_HELLO_Builder *builder;
@@ -9854,18 +9837,32 @@ start_burst_for_address (void *cls,
}
if (NULL == record)
{
- sb_cls->mo = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Hello iteration end for %s\n",
+ GNUNET_i2s (&vl->target));
+ vl->ic = NULL;
+ GNUNET_free (sb_cls);
return;
}
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "check_for_burst_address\n");
hello = record->value;
builder = GNUNET_HELLO_builder_from_msg (hello);
GNUNET_HELLO_builder_iterate (builder,
&iterate_address_start_burst,
- sb_cls);
+ vl);
GNUNET_HELLO_builder_free (builder);
- GNUNET_PEERSTORE_monitor_stop (sb_cls->mo);
+ GNUNET_PEERSTORE_iteration_stop (vl->ic);
+ GNUNET_free (sb_cls);
+}
+
+
+static void
+burst_timeout (void *cls)
+{
+ burst_running = GNUNET_NO;
}
@@ -9873,18 +9870,48 @@ static void
start_burst (void *cls)
{
struct GNUNET_StartBurstCls *sb_cls = cls;
+ struct VirtualLink *vl = sb_cls->vl;
+ struct GNUNET_TRANSPORT_StartBurst *sb;
+ struct GNUNET_MQ_Envelope *env;
+ char *uri_without_port = vl->burst_addr;
- sb_cls->mo = GNUNET_PEERSTORE_monitor_start (GST_cfg,
- GNUNET_YES,
- "peerstore",
- &sb_cls->vl->target,
- GNUNET_PEERSTORE_HELLO_KEY,
- &start_burst_for_address_error_cb,
- NULL,
- &start_burst_for_address_sync_cb,
- NULL,
- &start_burst_for_address,
- sb_cls);
+ burst_task = NULL;
+ /*char buf[strlen (uri_without_port) + 1];
+
+ GNUNET_memcpy (buf, uri_without_port, strlen (uri_without_port));
+ buf[strlen (uri_without_port)] = '\0';*/
+ env =
+ GNUNET_MQ_msg_extra (sb ,
+ strlen (uri_without_port) + 1,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_START_BURST);
+ sb->rtt = GNUNET_TIME_relative_hton (sb_cls->rtt);
+ sb->pid = &vl->target;
+ memcpy (&sb[1], uri_without_port, strlen (uri_without_port) + 1);
+ for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "iterate_address_start_burst client tc prefix %s\n",
+ tc->details.communicator.address_prefix);
+ if (CT_COMMUNICATOR != tc->type)
+ continue;
+ if (GNUNET_YES == tc->details.communicator.can_burst){
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "iterate_address_start_burst %s call %lu %u rtt %lu\n",
+ uri_without_port,
+ strlen (uri_without_port),
+ ntohs (sb->header.size),
+ sb_cls->rtt.rel_value_us);
+ GNUNET_MQ_send (tc->mq, env);
+ burst_running = GNUNET_YES;
+ burst_timeout_task = GNUNET_SCHEDULER_add_delayed
(GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+
60),
+ &burst_timeout,
+ NULL);
+ //TODO We need some algo to choose from available communicators. Can we
run two bursts at once? Atm we only implemented udp burst.
+ break;
+ }
+ }
+ GNUNET_free (sb_cls);
}
@@ -9892,28 +9919,36 @@ static void
queue_burst (void *cls)
{
struct GNUNET_StartBurstCls *sb_cls = cls;
+ struct VirtualLink *vl = sb_cls->vl;
- if (NULL == bursts_head && NULL == actual_burst)
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "burst_task %p ready %s burst addr %s (%p)\n",
+ burst_task,
+ sb_cls->sync_ready ? "yes" : "no",
+ vl->burst_addr,
+ vl->burst_addr);
+ if (NULL != burst_task && GNUNET_NO == sb_cls->sync_ready)
+ {
+ GNUNET_SCHEDULER_cancel (burst_task);
+ burst_task = NULL;
+ GNUNET_free (sb_cls);
+ return;
+ }
+ if (GNUNET_NO == burst_running && NULL != vl->burst_addr && NULL ==
burst_task)
{
- sb_cls->vl->burst_task = GNUNET_SCHEDULER_add_delayed (sb_cls->delay,
+ burst_task = GNUNET_SCHEDULER_add_delayed (sb_cls->delay,
&start_burst,
sb_cls);
- actual_burst = sb_cls;
}
- else
- GNUNET_CONTAINER_DLL_insert_tail (bursts_head, bursts_tail, sb_cls);
-
- if (NULL == actual_burst)
+ else if (NULL == vl->burst_addr)
{
- bursts_head->vl->burst_task = GNUNET_SCHEDULER_add_delayed (sb_cls->delay,
- &start_burst,
- bursts_head);
- actual_burst = bursts_head;
- GNUNET_CONTAINER_DLL_remove (bursts_head, bursts_tail, actual_burst);
+ vl->ic = GNUNET_PEERSTORE_iteration_start (peerstore,
+ "peerstore",
+ &vl->target,
+ GNUNET_PEERSTORE_HELLO_KEY,
+ check_for_burst_address,
+ sb_cls);
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Burst started \n");
- GNUNET_free (sb_cls);
}
/**
@@ -9946,6 +9981,7 @@ handle_flow_control (void *cls, const struct
TransportFlowControlMessage *fc)
"No virtual link for %p FC creating new unconfirmed virtual
link to %s!\n",
vl,
GNUNET_i2s (&cmc->im.sender));
+ vl->burst_addr = NULL;
vl->confirmed = GNUNET_NO;
vl->message_uuid_ctr =
GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
@@ -9975,30 +10011,23 @@ handle_flow_control (void *cls, const struct
TransportFlowControlMessage *fc)
{
struct GNUNET_TIME_Relative rtt;
struct GNUNET_BurstSync burst_sync;
- struct GNUNET_StartBurstCls *cls;
+ struct GNUNET_StartBurstCls *bcls;
- cls = GNUNET_new (struct GNUNET_StartBurstCls);
- cls->vl = vl;
- cls->rtt = GNUNET_TIME_relative_ntoh (burst_sync.rtt_avarage);
+ bcls = GNUNET_new (struct GNUNET_StartBurstCls);
+ bcls->vl = vl;
+ vl->sb_cls = bcls;
if (NULL != vl->dv)
rtt = calculate_rtt (vl->dv);
else
rtt = GNUNET_TIME_UNIT_FOREVER_REL;
burst_sync.rtt_avarage = fc->rtt;
+ bcls->rtt = GNUNET_TIME_relative_ntoh (burst_sync.rtt_avarage);
burst_sync.sync_ready = fc->sync_ready;
- vl->sync_ready = GNUNET_is_burst_ready (rtt,
+ GNUNET_is_burst_ready (rtt,
&burst_sync,
&queue_burst,
- cls);
- GNUNET_free (cls);
- if (NULL != vl->burst_task &&
- GNUNET_NO == vl->sync_ready)
- {
- GNUNET_SCHEDULER_cancel (vl->burst_task);
- vl->burst_task = NULL;
- actual_burst = NULL;
- }
+ bcls);
}
if (0 != ntohl (fc->number_of_addresses))
{
@@ -11373,6 +11402,18 @@ handle_send_message_ack (void *cls,
}
+/**
+ * The burst finished.
+ *
+ * @param cls the client
+ */
+static void
+handle_burst_finished ()
+{
+ burst_running = GNUNET_NO;
+}
+
+
/**
* Iterator telling new MONITOR client about all existing
* queues to peers.
@@ -11922,6 +11963,7 @@ iterate_address_and_compare_cb (void *cls,
const char *uri)
{
struct Queue *queue = cls;
+ struct sockaddr_in v4;
const char *slash;
char *address_uri;
char *prefix;
@@ -11937,15 +11979,51 @@ iterate_address_and_compare_cb (void *cls,
prefix,
slash);
- address_uri_without_port = get_address_without_port (queue->address);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "1 not global natted_address %u %s %s %s\n",
+ queue->is_global_natted,
+ uri,
+ queue->address,
+ slash);
+
+ uri_without_port = get_address_without_port (address_uri);
+ if (1 != inet_pton (AF_INET, uri_without_port, &v4.sin_addr))
+ return;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "2 not global natted_address %u %s %s\n",
+ queue->is_global_natted,
+ uri,
+ queue->address);
+
+ if (GNUNET_NO == queue->is_global_natted)
+ return;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "3 not global natted_address %u %s %s\n",
+ queue->is_global_natted,
+ uri,
+ queue->address);
+
uri_without_port = get_address_without_port (address_uri);
+
+ if (0 == strcmp (uri_without_port, address_uri))
+ return;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "4 not global natted_address %u %s %s\n",
+ queue->is_global_natted,
+ uri,
+ queue->address);
+
+ address_uri_without_port = get_address_without_port (queue->address);
if (0 == strcmp (uri_without_port, address_uri_without_port))
{
queue->is_global_natted = GNUNET_NO;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "not global natted %u %s %s %s %s %s %u\n",
+ "not global natted_address %u %s %s %s %s %s %u\n",
queue->is_global_natted,
uri,
queue->address,
@@ -11960,22 +12038,6 @@ iterate_address_and_compare_cb (void *cls,
}
-static void
-check_for_global_natted_error_cb (void *cls)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Error in PEERSTORE monitoring for checking global natted\n");
-}
-
-
-static void
-check_for_global_natted_sync_cb (void *cls)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Done with initial PEERSTORE iteration during monitoring for
checking global natted\n");
-}
-
-
struct TransportGlobalNattedAddressClosure
{
/**
@@ -12009,6 +12071,22 @@ contains_address (void *cls,
}
+static void
+check_for_global_natted_error_cb (void *cls)
+{
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Error in PEERSTORE monitoring for checking global natted\n");
+}
+
+
+static void
+check_for_global_natted_sync_cb (void *cls)
+{
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Done with initial PEERSTORE iteration during monitoring for
checking global natted\n");
+}
+
+
static void
check_for_global_natted (void *cls,
const struct GNUNET_PEERSTORE_Record *record,
@@ -12028,11 +12106,6 @@ check_for_global_natted (void *cls,
emsg);
return;
}
- if (NULL == record)
- {
- queue->mo = NULL;
- return;
- }
if (0 == record->value_size)
{
GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
@@ -12054,8 +12127,16 @@ check_for_global_natted (void *cls,
GNUNET_HELLO_builder_free (builder);
tgna_cls.addr = get_address_without_port (queue->address);
- tgna_cls.tgna = NULL;
address_len_without_port = strlen (tgna_cls.addr);
+ /*{
+ char buf[address_len_without_port + 1];
+
+ GNUNET_memcpy (&buf, addr, address_len_without_port);
+ buf[address_len_without_port] = '\0';
+ GNUNET_free (addr);
+ GNUNET_memcpy (tgna_cls.addr, buf, address_len_without_port + 1);
+ }*/
+ tgna_cls.tgna = NULL;
GNUNET_CONTAINER_multipeermap_get_multiple (neighbour->natted_addresses,
&neighbour->pid,
&contains_address,
@@ -12079,10 +12160,12 @@ check_for_global_natted (void *cls,
tgna,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
neighbour->number_of_addresses++;
- neighbour->size_of_global_addresses += address_len_without_port;
+ neighbour->size_of_global_addresses += address_len_without_port + 1;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Created tgna %p\n",
- tgna);
+ "Created tgna %p with address %s and length %lu\n",
+ tgna,
+ tgna_cls.addr,
+ address_len_without_port + 1);
}
else if (NULL != tgna_cls.tgna && GNUNET_NO == queue->is_global_natted)
{
@@ -12098,8 +12181,8 @@ check_for_global_natted (void *cls,
tgna_cls.tgna);
GNUNET_free (tgna_cls.tgna);
}
- GNUNET_free (tgna_cls.addr);
GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
+ GNUNET_free (tgna_cls.addr);
}
@@ -12214,17 +12297,27 @@ handle_add_queue_message (void *cls,
queue->nt = (enum GNUNET_NetworkType) ntohl (aqm->nt);
queue->cs = (enum GNUNET_TRANSPORT_ConnectionStatus) ntohl (aqm->cs);
queue->idle = GNUNET_YES;
- queue->mo = GNUNET_PEERSTORE_monitor_start (GST_cfg,
- GNUNET_YES,
- "peerstore",
- &neighbour->pid,
- GNUNET_PEERSTORE_HELLO_KEY,
- &check_for_global_natted_error_cb,
- NULL,
- &check_for_global_natted_sync_cb,
- NULL,
- &check_for_global_natted,
- queue);
+
+ {
+ struct sockaddr_in v4;
+ char *addr_without = get_address_without_port (queue->address);
+ if (1 == inet_pton (AF_INET, addr_without, &v4.sin_addr))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "start not global natted\n");
+ queue->mo = GNUNET_PEERSTORE_monitor_start (GST_cfg,
+ GNUNET_YES,
+ "peerstore",
+ &neighbour->pid,
+ GNUNET_PEERSTORE_HELLO_KEY,
+
&check_for_global_natted_error_cb,
+ NULL,
+
&check_for_global_natted_sync_cb,
+ NULL,
+ &check_for_global_natted,
+ queue);
+ }
+ }
/* check if valdiations are waiting for the queue */
if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (validation_map,
&aqm->receiver))
@@ -12971,6 +13064,10 @@ GNUNET_SERVICE_MAIN (
GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK,
struct GNUNET_TRANSPORT_SendMessageToAck,
NULL),
+ GNUNET_MQ_hd_fixed_size (burst_finished,
+ GNUNET_MESSAGE_TYPE_TRANSPORT_BURST_FINISHED,
+ struct GNUNET_TRANSPORT_BurstFinished,
+ NULL),
/* communication with monitors */
GNUNET_MQ_hd_fixed_size (monitor_start,
GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_START,
diff --git a/src/service/transport/transport.h
b/src/service/transport/transport.h
index fd262928c..753aa1b44 100644
--- a/src/service/transport/transport.h
+++ b/src/service/transport/transport.h
@@ -673,10 +673,13 @@ struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming
message to the communicator */
};
+/**
+ * Message from transport to communicator to start a burst.
+ */
struct GNUNET_TRANSPORT_StartBurst
{
/**
- * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_BURST_START.
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_START_BURST.
*/
struct GNUNET_MessageHeader header;
@@ -690,6 +693,14 @@ struct GNUNET_TRANSPORT_StartBurst
/* followed by UTF-8 encoded, 0-terminated human-readable address */
};
+struct GNUNET_TRANSPORT_BurstFinished
+{
+ /**
+ * Type will be #GNUNET_MESSAGE_TYPE_TRANSPORT_BURST_FINISHED.
+ */
+ struct GNUNET_MessageHeader header;
+};
+
/**
* Request to start monitoring.
*/
diff --git a/src/service/transport/transport_api2_communication.c
b/src/service/transport/transport_api2_communication.c
index 2a32804bc..fe149b90f 100644
--- a/src/service/transport/transport_api2_communication.c
+++ b/src/service/transport/transport_api2_communication.c
@@ -784,6 +784,12 @@ check_start_burst (void *cls,
const struct GNUNET_TRANSPORT_StartBurst *sb)
{
(void) cls;
+ const char *str = (const char *) &sb[1];
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "check_start_burst %s %lu\n",
+ str,
+ strlen (str));
GNUNET_MQ_check_zero_termination (sb);
return GNUNET_OK;
}
@@ -795,8 +801,16 @@ handle_start_burst (void *cls,
{
struct GNUNET_TRANSPORT_CommunicatorHandle *ch = cls;
const char *addr = (const char *) &sb[1];
+ struct GNUNET_TIME_Relative rtt = GNUNET_TIME_relative_ntoh (sb->rtt);
- ch->sb (addr, GNUNET_TIME_relative_ntoh (sb->rtt), sb->pid);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Calling communicator to start burst to %s is %s rtt %lu\n",
+ addr,
+ NULL == sb ? "not possible" : "possible",
+ rtt.rel_value_us);
+
+ if (NULL != ch->sb)
+ ch->sb (addr, GNUNET_TIME_relative_ntoh (sb->rtt), sb->pid);
}
@@ -1159,5 +1173,16 @@ GNUNET_TRANSPORT_communicator_notify (
GNUNET_MQ_send (ch->mq, env);
}
+/* ************************* Burst *************************** */
+
+void
+GNUNET_TRANSPORT_communicator_burst_finished (struct
GNUNET_TRANSPORT_CommunicatorHandle *ch)
+{
+ struct GNUNET_MQ_Envelope *env;
+ struct GNUNET_TRANSPORT_BurstFinished *bf;
+
+ env = GNUNET_MQ_msg (bf, GNUNET_MESSAGE_TYPE_TRANSPORT_BURST_FINISHED);
+ GNUNET_MQ_send (ch->mq, env);
+}
/* end of transport_api2_communication.c */
--
To stop receiving notification emails like this one, please contact
gnunet@gnunet.org.
- [gnunet] branch master updated (7322b322b -> 9a97ab1a8), gnunet, 2024/08/28
- [gnunet] 02/19: Added test case to start Android SDK emulator., gnunet, 2024/08/28
- [gnunet] 01/19: Transport: Added test case to simulate router NAT mapping behavior., gnunet, 2024/08/28
- [gnunet] 04/19: Added sync protocol., gnunet, 2024/08/28
- [gnunet] 03/19: Added functionality to check if all services and communicators are started., gnunet, 2024/08/28
- [gnunet] 08/19: Implemented burst mode., gnunet, 2024/08/28
- [gnunet] 13/19: Refactoring the burst logic.,
gnunet <=
- [gnunet] 06/19: Moved sync protocol to util., gnunet, 2024/08/28
- [gnunet] 12/19: Fixed Generic and specific test setup and code., gnunet, 2024/08/28
- [gnunet] 07/19: NAT: Added missing missing files, gnunet, 2024/08/28
- [gnunet] 05/19: Fixed bug with new queues inheriting the validated_until value of existing queues., gnunet, 2024/08/28
- [gnunet] 15/19: Make hole punch socket available, and some bug fixes., gnunet, 2024/08/28
- [gnunet] 09/19: Merge branch 'master' into dev/t3ss/probnatt, gnunet, 2024/08/28
- [gnunet] 17/19: Merge master into branch., gnunet, 2024/08/28
- [gnunet] 10/19: Make the test framework work to run full peers., gnunet, 2024/08/28
- [gnunet] 11/19: Added msssing config., gnunet, 2024/08/28
- [gnunet] 14/19: Fixed bug adding global addresses to nat service., gnunet, 2024/08/28