/* This file is part of GNUnet Copyright (C) 2021 GNUnet e.V. GNUnet is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. GNUnet is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. You should have received a copy of the GNU Affero General Public License along with this program. If not, see . SPDX-License-Identifier: AGPL3.0-or-later */ /** * @file testing_api_cmd_start_peer.c * @brief cmd to start a peer. * @author t3sserakt */ #include "platform.h" #include "gnunet_util_lib.h" #include "gnunet_testing_ng_lib.h" #include "gnunet_transport_application_service.h" #include "gnunet_hello_lib.h" #include "gnunet_transport_service.h" #include "transport-testing-cmds.h" /** * Generic logging shortcut */ #define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__) #define CONNECT_ADDRESS_TEMPLATE_TCP "tcp-192.168.15.%u:60002" #define CONNECT_ADDRESS_TEMPLATE_UDP "udp-192.168.15.%u:60002" #define ROUTER_CONNECT_ADDRESS_TEMPLATE_TCP "tcp-92.68.150.%u:60002" #define ROUTER_CONNECT_ADDRESS_TEMPLATE_UDP "udp-92.68.150.%u:60002" #define GLOBAL_CONNECT_ADDRESS_TEMPLATE_TCP "tcp-92.68.151.%u:60002" #define GLOBAL_CONNECT_ADDRESS_TEMPLATE_UDP "udp-92.68.151.%u:60002" #define PREFIX_TCP "tcp" #define PREFIX_UDP "udp" static struct GNUNET_PeerIdentity * get_pub_key (unsigned int num, struct GNUNET_TESTING_System *tl_system) { struct GNUNET_PeerIdentity *peer = GNUNET_new (struct GNUNET_PeerIdentity); struct GNUNET_CRYPTO_EddsaPublicKey *pub_key = GNUNET_new (struct GNUNET_CRYPTO_EddsaPublicKey); struct GNUNET_CRYPTO_EddsaPrivateKey *priv_key = GNUNET_new (struct GNUNET_CRYPTO_EddsaPrivateKey); priv_key = GNUNET_TESTING_hostkey_get (tl_system, num, peer); GNUNET_CRYPTO_eddsa_key_get_public (priv_key, pub_key); peer->public_key = *pub_key; return peer; } static int log_nodes (void *cls, const struct GNUNET_ShortHashCode *id, void *value) { struct GNUNET_TESTING_NetjailNode *node = value; struct GNUNET_TESTING_NodeConnection *pos_connection; struct GNUNET_TESTING_ADDRESS_PREFIX *pos_prefix; LOG (GNUNET_ERROR_TYPE_ERROR, "plugin: %s space: %u node: %u global: %u\n", node->plugin, node->namespace_n, node->node_n, node->is_global); for (pos_connection = node->node_connections_head; NULL != pos_connection; pos_connection = pos_connection->next) { LOG (GNUNET_ERROR_TYPE_ERROR, "namespace_n: %u node_n: %u node_type: %u\n", pos_connection->namespace_n, pos_connection->node_n, pos_connection->node_type); for (pos_prefix = pos_connection->address_prefixes_head; NULL != pos_prefix; pos_prefix = pos_prefix->next) { LOG (GNUNET_ERROR_TYPE_ERROR, "prefix: %s\n", pos_prefix->address_prefix); } } return GNUNET_YES; } static int log_namespaces (void *cls, const struct GNUNET_ShortHashCode *id, void *value) { struct GNUNET_TESTING_NetjailNamespace *namespace = value; struct GNUNET_TESTING_NetjailRouter *router = namespace->router; LOG (GNUNET_ERROR_TYPE_ERROR, "router_tcp: %u router_udp: %u spaces: %u\n", router->tcp_port, router->udp_port, namespace->namespace_n); GNUNET_CONTAINER_multishortmap_iterate (namespace->nodes, &log_nodes, NULL); return GNUNET_YES; } static int log_topo (struct GNUNET_TESTING_NetjailTopology *topology) { LOG (GNUNET_ERROR_TYPE_ERROR, "plugin: %s spaces: %u nodes: %u known: %u\n", topology->plugin, topology->namespaces_n, topology->nodes_m, topology->nodes_x); GNUNET_CONTAINER_multishortmap_iterate (topology->map_namespaces, log_namespaces, NULL); GNUNET_CONTAINER_multishortmap_iterate (topology->map_globals, &log_nodes, NULL); return GNUNET_YES; } static struct GNUNET_TESTING_NodeConnection * get_connections (unsigned int num, struct GNUNET_TESTING_NetjailTopology *topology) { struct GNUNET_TESTING_NetjailNode *node; struct GNUNET_ShortHashCode *hkey; struct GNUNET_HashCode hc; struct GNUNET_TESTING_NetjailNamespace *namespace; unsigned int namespace_n, node_m; log_topo (topology); hkey = GNUNET_new (struct GNUNET_ShortHashCode); if (topology->nodes_x >= num) { GNUNET_CRYPTO_hash (&num, sizeof(num), &hc); memcpy (hkey, &hc, sizeof (*hkey)); node = GNUNET_CONTAINER_multishortmap_get (topology->map_globals, hkey); } else { namespace_n = (unsigned int) floor ((num - topology->nodes_x) / topology->nodes_m); LOG (GNUNET_ERROR_TYPE_ERROR, "num: %u nodes_x: %u nodes_m: %u namespace_n: %u\n", num, topology->nodes_x, topology->nodes_m, namespace_n); hkey = GNUNET_new (struct GNUNET_ShortHashCode); GNUNET_CRYPTO_hash (&namespace_n, sizeof(namespace_n), &hc); memcpy (hkey, &hc, sizeof (*hkey)); namespace = GNUNET_CONTAINER_multishortmap_get (topology->map_namespaces, hkey); node_m = num - topology->nodes_x - topology->nodes_m * (namespace_n - 1); hkey = GNUNET_new (struct GNUNET_ShortHashCode); GNUNET_CRYPTO_hash (&node_m, sizeof(node_m), &hc); memcpy (hkey, &hc, sizeof (*hkey)); node = GNUNET_CONTAINER_multishortmap_get (namespace->nodes, hkey); } return node->node_connections_head; } static unsigned int calculate_num (struct GNUNET_TESTING_NodeConnection *node_connection, struct GNUNET_TESTING_NetjailTopology *topology) { unsigned int n, m, num; n = node_connection->namespace_n; m = node_connection->node_n; if (0 == n) num = m; else num = (n - 1) * topology->nodes_m + m + topology->nodes_x; return num; } static char * get_address (struct GNUNET_TESTING_NodeConnection *connection, char *prefix) { struct GNUNET_TESTING_NetjailNode *node; char *addr; node = connection->node; if (connection->namespace_n == node->namespace_n) { if (0 == strcmp (PREFIX_TCP, prefix)) { GNUNET_asprintf (&addr, CONNECT_ADDRESS_TEMPLATE_TCP, connection->node_n); } else if (0 == strcmp (PREFIX_UDP, prefix)) { GNUNET_asprintf (&addr, CONNECT_ADDRESS_TEMPLATE_UDP, connection->node_n); } else { GNUNET_break (0); } } else { if (0 == strcmp (PREFIX_TCP, prefix)) { GNUNET_asprintf (&addr, ROUTER_CONNECT_ADDRESS_TEMPLATE_TCP, connection->namespace_n); } else if (0 == strcmp (PREFIX_UDP, prefix)) { GNUNET_asprintf (&addr, ROUTER_CONNECT_ADDRESS_TEMPLATE_UDP, connection->namespace_n); } else { GNUNET_break (0); } } return addr; } /** * The run method of this cmd will connect to peers. * */ static void connect_peers_run (void *cls, struct GNUNET_TESTING_Interpreter *is) { struct ConnectPeersState *cps = cls; const struct GNUNET_TESTING_Command *system_cmd; struct GNUNET_TESTING_System *tl_system; const struct GNUNET_TESTING_Command *peer1_cmd; struct GNUNET_TRANSPORT_ApplicationHandle *ah; struct GNUNET_PeerIdentity *peer; char *addr; enum GNUNET_NetworkType nt = 0; uint32_t num; struct GNUNET_TESTING_NodeConnection *pos_connection; struct GNUNET_TESTING_ADDRESS_PREFIX *pos_prefix; unsigned int con_num = 0; cps->is = is; peer1_cmd = GNUNET_TESTING_interpreter_lookup_command (is, cps->start_peer_label); GNUNET_TRANSPORT_get_trait_application_handle (peer1_cmd, &ah); system_cmd = GNUNET_TESTING_interpreter_lookup_command (is, cps->create_label); GNUNET_TESTING_get_trait_test_system (system_cmd, &tl_system); cps->tl_system = tl_system; cps->node_connections_head = get_connections (cps->num, cps->topology); for (pos_connection = cps->node_connections_head; NULL != pos_connection; pos_connection = pos_connection->next) { con_num++; num = calculate_num (pos_connection, cps->topology); for (pos_prefix = pos_connection->address_prefixes_head; NULL != pos_prefix; pos_prefix = pos_prefix->next) { LOG (GNUNET_ERROR_TYPE_ERROR, "prefix: %s\n", pos_prefix->address_prefix); addr = get_address (pos_connection, pos_prefix->address_prefix); peer = get_pub_key (num, tl_system); LOG (GNUNET_ERROR_TYPE_ERROR, "num: %u pub_key %s addr: %s\n", num, GNUNET_CRYPTO_eddsa_public_key_to_string (&(peer->public_key)), addr); cps->id = peer; GNUNET_TRANSPORT_application_validate (ah, peer, nt, addr); } } cps->con_num = con_num; } /** * Callback from start peer cmd for signaling a peer got connected. * */ static void * notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq) { struct ConnectPeersState *cps = cls; struct GNUNET_PeerIdentity *peer_connection; unsigned int con_num = 0; struct GNUNET_TESTING_NodeConnection *pos_connection; unsigned int num; void *ret = NULL; for (pos_connection = cps->node_connections_head; NULL != pos_connection; pos_connection = pos_connection->next) { num = calculate_num (pos_connection, cps->topology); peer_connection = get_pub_key (num, cps->tl_system); if (0 == GNUNET_memcmp (peer, peer_connection)) con_num++; } if (cps->con_num == con_num) { GNUNET_TESTING_async_finish (&cps->ac); } return ret; } /** * The cleanup function of this cmd frees resources the cmd allocated. * */ static void connect_peers_cleanup (void *cls) { struct ConnectPeersState *cps = cls; GNUNET_free (cps->id); GNUNET_free (cps); } /** * This function prepares an array with traits. * */ static int connect_peers_traits (void *cls, const void **ret, const char *trait, unsigned int index) { struct StartPeerState *cps = cls; struct GNUNET_TESTING_Trait traits[] = { { .index = 0, .trait_name = "state", .ptr = (const void *) cps, }, GNUNET_TESTING_trait_end () }; return GNUNET_TESTING_get_trait (traits, ret, trait, index); } /** * Function to get the trait with the struct ConnectPeersState. * * @param[out] sps struct ConnectPeersState. * @return #GNUNET_OK if no error occurred, #GNUNET_SYSERR otherwise. * */ int GNUNET_TESTING_get_trait_connect_peer_state ( const struct GNUNET_TESTING_Command *cmd, struct ConnectPeersState **cps) { return cmd->traits (cmd->cls, (const void **) cps, "state", (unsigned int) 0); } struct GNUNET_TESTING_Command GNUNET_TRANSPORT_cmd_connect_peers (const char *label, const char *start_peer_label, const char *create_label, uint32_t num, struct GNUNET_TESTING_NetjailTopology * topology) { struct ConnectPeersState *cps; cps = GNUNET_new (struct ConnectPeersState); cps->start_peer_label = start_peer_label; cps->num = num; cps->create_label = create_label; cps->topology = topology; cps->notify_connect = ¬ify_connect; { struct GNUNET_TESTING_Command cmd = { .cls = cps, .label = label, .run = &connect_peers_run, .ac = &cps->ac, .cleanup = &connect_peers_cleanup, .traits = &connect_peers_traits }; return cmd; } }