diff options
29 files changed, 2012 insertions, 380 deletions
diff --git a/src/include/gnunet_protocols.h b/src/include/gnunet_protocols.h index 41f2876e6..9e278eb92 100644 --- a/src/include/gnunet_protocols.h +++ b/src/include/gnunet_protocols.h | |||
@@ -3579,7 +3579,11 @@ extern "C" { | |||
3579 | 3579 | ||
3580 | #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_PEERS_STARTED 1703 | 3580 | #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_PEERS_STARTED 1703 |
3581 | 3581 | ||
3582 | #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED 1704 | 3582 | #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_TEST_PREPARED 1704 |
3583 | |||
3584 | #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_LOCAL_TESTS_PREPARED 1705 | ||
3585 | |||
3586 | #define GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED 1706 | ||
3583 | 3587 | ||
3584 | /*********************************************************************************/ | 3588 | /*********************************************************************************/ |
3585 | 3589 | ||
diff --git a/src/include/gnunet_testing_ng_lib.h b/src/include/gnunet_testing_ng_lib.h index 31665f8f7..6138f567b 100644 --- a/src/include/gnunet_testing_ng_lib.h +++ b/src/include/gnunet_testing_ng_lib.h | |||
@@ -79,17 +79,17 @@ enum GNUNET_TESTING_NODE_TYPE | |||
79 | GNUNET_TESTING_GLOBAL_NODE | 79 | GNUNET_TESTING_GLOBAL_NODE |
80 | }; | 80 | }; |
81 | 81 | ||
82 | struct GNUNET_TESTING_ADDRESS_PREFIX | 82 | struct GNUNET_TESTING_AddressPrefix |
83 | { | 83 | { |
84 | /** | 84 | /** |
85 | * Pointer to the previous prefix in the DLL. | 85 | * Pointer to the previous prefix in the DLL. |
86 | */ | 86 | */ |
87 | struct GNUNET_TESTING_ADDRESS_PREFIX *prev; | 87 | struct GNUNET_TESTING_AddressPrefix *prev; |
88 | 88 | ||
89 | /** | 89 | /** |
90 | * Pointer to the next prefix in the DLL. | 90 | * Pointer to the next prefix in the DLL. |
91 | */ | 91 | */ |
92 | struct GNUNET_TESTING_ADDRESS_PREFIX *next; | 92 | struct GNUNET_TESTING_AddressPrefix *next; |
93 | 93 | ||
94 | /** | 94 | /** |
95 | * The address prefix. | 95 | * The address prefix. |
@@ -138,12 +138,12 @@ struct GNUNET_TESTING_NodeConnection | |||
138 | /** | 138 | /** |
139 | * Head of the DLL with the address prefixes for the protocolls this node is reachable. | 139 | * Head of the DLL with the address prefixes for the protocolls this node is reachable. |
140 | */ | 140 | */ |
141 | struct GNUNET_TESTING_ADDRESS_PREFIX *address_prefixes_head; | 141 | struct GNUNET_TESTING_AddressPrefix *address_prefixes_head; |
142 | 142 | ||
143 | /** | 143 | /** |
144 | * Tail of the DLL with the address prefixes for the protocolls this node is reachable. | 144 | * Tail of the DLL with the address prefixes for the protocolls this node is reachable. |
145 | */ | 145 | */ |
146 | struct GNUNET_TESTING_ADDRESS_PREFIX *address_prefixes_tail; | 146 | struct GNUNET_TESTING_AddressPrefix *address_prefixes_tail; |
147 | }; | 147 | }; |
148 | 148 | ||
149 | /** | 149 | /** |
@@ -379,6 +379,11 @@ struct GNUNET_TESTING_Command | |||
379 | */ | 379 | */ |
380 | bool asynchronous_finish; | 380 | bool asynchronous_finish; |
381 | 381 | ||
382 | /** | ||
383 | * Shall the scheduler shutdown, when end cmd is reach? | ||
384 | */ | ||
385 | bool shutdown_on_end; | ||
386 | |||
382 | }; | 387 | }; |
383 | 388 | ||
384 | 389 | ||
@@ -450,6 +455,15 @@ GNUNET_TESTING_cmd_end (void); | |||
450 | 455 | ||
451 | 456 | ||
452 | /** | 457 | /** |
458 | * Create command array terminator without shutdown. | ||
459 | * | ||
460 | * @return a end-command. | ||
461 | */ | ||
462 | struct GNUNET_TESTING_Command | ||
463 | GNUNET_TESTING_cmd_end_without_shutdown (void); | ||
464 | |||
465 | |||
466 | /** | ||
453 | * Turn asynchronous command into non blocking command by setting asynchronous_finish to true. | 467 | * Turn asynchronous command into non blocking command by setting asynchronous_finish to true. |
454 | * | 468 | * |
455 | * @param cmd command to make synchronous. | 469 | * @param cmd command to make synchronous. |
@@ -661,6 +675,55 @@ GNUNET_TESTING_get_topo_from_file (const char *filename); | |||
661 | 675 | ||
662 | 676 | ||
663 | /** | 677 | /** |
678 | * Get the connections to other nodes for a specific node. | ||
679 | * | ||
680 | * @param num The specific node we want the connections for. | ||
681 | * @param topology The topology we get the connections from. | ||
682 | * @return The connections of the node. | ||
683 | */ | ||
684 | struct GNUNET_TESTING_NodeConnection * | ||
685 | GNUNET_TESTING_get_connections (unsigned int num, struct | ||
686 | GNUNET_TESTING_NetjailTopology *topology); | ||
687 | |||
688 | |||
689 | /** | ||
690 | * Get the address for a specific communicator from a connection. | ||
691 | * | ||
692 | * @param connection The connection we like to have the address from. | ||
693 | * @param prefix The communicator protocol prefix. | ||
694 | * @return The address of the communicator. | ||
695 | */ | ||
696 | char * | ||
697 | GNUNET_TESTING_get_address (struct GNUNET_TESTING_NodeConnection *connection, | ||
698 | char *prefix); | ||
699 | |||
700 | |||
701 | /** | ||
702 | * Calculate the unique id identifying a node from a given connction. | ||
703 | * | ||
704 | * @param node_connection The connection we calculate the id from. | ||
705 | * @param topology The topology we get all needed information from. | ||
706 | * @return The unique id of the node from the connection. | ||
707 | */ | ||
708 | unsigned int | ||
709 | GNUNET_TESTING_calculate_num (struct | ||
710 | GNUNET_TESTING_NodeConnection *node_connection, | ||
711 | struct GNUNET_TESTING_NetjailTopology *topology); | ||
712 | |||
713 | |||
714 | /** | ||
715 | * Retrieve the public key from the test system with the unique node id. | ||
716 | * | ||
717 | * @param num The unique node id. | ||
718 | * @param tl_system The test system. | ||
719 | * @return The peer identity wrapping the public key. | ||
720 | */ | ||
721 | struct GNUNET_PeerIdentity * | ||
722 | GNUNET_TESTING_get_pub_key (unsigned int num, struct | ||
723 | GNUNET_TESTING_System *tl_system); | ||
724 | |||
725 | |||
726 | /** | ||
664 | * Obtain performance data from the interpreter. | 727 | * Obtain performance data from the interpreter. |
665 | * | 728 | * |
666 | * @param timers what commands (by label) to obtain runtimes for | 729 | * @param timers what commands (by label) to obtain runtimes for |
@@ -1183,12 +1246,36 @@ GNUNET_TESTING_cmd_block_until_external_trigger (const char *label, | |||
1183 | unsigned int * | 1246 | unsigned int * |
1184 | stop_blocking); | 1247 | stop_blocking); |
1185 | 1248 | ||
1249 | |||
1186 | struct GNUNET_TESTING_Command | 1250 | struct GNUNET_TESTING_Command |
1187 | GNUNET_TESTING_cmd_send_peer_ready (const char *label, | 1251 | GNUNET_TESTING_cmd_send_peer_ready (const char *label, |
1188 | TESTING_CMD_HELPER_write_cb write_message); | 1252 | TESTING_CMD_HELPER_write_cb write_message); |
1189 | 1253 | ||
1254 | |||
1255 | /** | ||
1256 | * Create command. | ||
1257 | * | ||
1258 | * @param label name for command. | ||
1259 | * @param write_message Callback to write messages to the master loop. | ||
1260 | * @return command. | ||
1261 | */ | ||
1190 | struct GNUNET_TESTING_Command | 1262 | struct GNUNET_TESTING_Command |
1191 | GNUNET_TESTING_cmd_local_test_finished (const char *label, | 1263 | GNUNET_TESTING_cmd_local_test_finished (const char *label, |
1192 | TESTING_CMD_HELPER_write_cb | 1264 | TESTING_CMD_HELPER_write_cb |
1193 | write_message); | 1265 | write_message); |
1266 | |||
1267 | /** | ||
1268 | * Create command. | ||
1269 | * | ||
1270 | * @param label name for command. | ||
1271 | * @param write_message Callback to write messages to the master loop. | ||
1272 | * @param all_local_tests_prepared Flag which will be set from outside. | ||
1273 | * @return command. | ||
1274 | */ | ||
1275 | struct GNUNET_TESTING_Command | ||
1276 | GNUNET_TESTING_cmd_local_test_prepared (const char *label, | ||
1277 | TESTING_CMD_HELPER_write_cb | ||
1278 | write_message, | ||
1279 | unsigned int * | ||
1280 | all_local_tests_prepared); | ||
1194 | #endif | 1281 | #endif |
diff --git a/src/include/gnunet_testing_plugin.h b/src/include/gnunet_testing_plugin.h index 151827d4b..4a6a9368e 100644 --- a/src/include/gnunet_testing_plugin.h +++ b/src/include/gnunet_testing_plugin.h | |||
@@ -48,9 +48,15 @@ typedef void | |||
48 | char *m, | 48 | char *m, |
49 | char *local_m); | 49 | char *local_m); |
50 | 50 | ||
51 | |||
51 | typedef void | 52 | typedef void |
52 | (*GNUNET_TESTING_PLUGIN_ALL_PEERS_STARTED) (); | 53 | (*GNUNET_TESTING_PLUGIN_ALL_PEERS_STARTED) (); |
53 | 54 | ||
55 | |||
56 | typedef void | ||
57 | (*GNUNET_TESTING_PLUGIN_ALL_LOCAL_TESTS_PREPARED) (); | ||
58 | |||
59 | |||
54 | struct GNUNET_TESTING_PluginFunctions | 60 | struct GNUNET_TESTING_PluginFunctions |
55 | { | 61 | { |
56 | /** | 62 | /** |
@@ -61,6 +67,8 @@ struct GNUNET_TESTING_PluginFunctions | |||
61 | GNUNET_TESTING_PLUGIN_StartTestCase start_testcase; | 67 | GNUNET_TESTING_PLUGIN_StartTestCase start_testcase; |
62 | 68 | ||
63 | GNUNET_TESTING_PLUGIN_ALL_PEERS_STARTED all_peers_started; | 69 | GNUNET_TESTING_PLUGIN_ALL_PEERS_STARTED all_peers_started; |
70 | |||
71 | GNUNET_TESTING_PLUGIN_ALL_LOCAL_TESTS_PREPARED all_local_tests_prepared; | ||
64 | }; | 72 | }; |
65 | 73 | ||
66 | #if 0 /* keep Emacsens' auto-indent happy */ | 74 | #if 0 /* keep Emacsens' auto-indent happy */ |
diff --git a/src/testing/Makefile.am b/src/testing/Makefile.am index efb22b279..07caeb44e 100644 --- a/src/testing/Makefile.am +++ b/src/testing/Makefile.am | |||
@@ -44,6 +44,7 @@ libgnunet_test_testing_plugin_testcmd_la_LDFLAGS = \ | |||
44 | 44 | ||
45 | libgnunettesting_la_SOURCES = \ | 45 | libgnunettesting_la_SOURCES = \ |
46 | testing_api_cmd_local_test_finished.c \ | 46 | testing_api_cmd_local_test_finished.c \ |
47 | testing_api_cmd_local_test_prepared.c \ | ||
47 | testing_api_cmd_send_peer_ready.c \ | 48 | testing_api_cmd_send_peer_ready.c \ |
48 | testing_api_cmd_block_until_all_peers_started.c \ | 49 | testing_api_cmd_block_until_all_peers_started.c \ |
49 | testing_api_cmd_block_until_external_trigger.c \ | 50 | testing_api_cmd_block_until_external_trigger.c \ |
diff --git a/src/testing/gnunet-cmds-helper.c b/src/testing/gnunet-cmds-helper.c index e50db0cf6..4aeccb115 100644 --- a/src/testing/gnunet-cmds-helper.c +++ b/src/testing/gnunet-cmds-helper.c | |||
@@ -418,9 +418,19 @@ tokenizer_cb (void *cls, const struct GNUNET_MessageHeader *message) | |||
418 | else if (GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_PEERS_STARTED == ntohs ( | 418 | else if (GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_PEERS_STARTED == ntohs ( |
419 | message->type)) | 419 | message->type)) |
420 | { | 420 | { |
421 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
422 | "all peers started\n"); | ||
421 | plugin->api->all_peers_started (); | 423 | plugin->api->all_peers_started (); |
422 | return GNUNET_OK; | 424 | return GNUNET_OK; |
423 | } | 425 | } |
426 | else if (GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_LOCAL_TESTS_PREPARED == ntohs ( | ||
427 | message->type)) | ||
428 | { | ||
429 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
430 | "all local tests prepared\n"); | ||
431 | plugin->api->all_local_tests_prepared (); | ||
432 | return GNUNET_OK; | ||
433 | } | ||
424 | else | 434 | else |
425 | { | 435 | { |
426 | LOG (GNUNET_ERROR_TYPE_WARNING, "Received unexpected message -- exiting\n"); | 436 | LOG (GNUNET_ERROR_TYPE_WARNING, "Received unexpected message -- exiting\n"); |
diff --git a/src/testing/test_testing_topology.c b/src/testing/test_testing_topology.c new file mode 100644 index 000000000..cfc91e609 --- /dev/null +++ b/src/testing/test_testing_topology.c | |||
@@ -0,0 +1,44 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet | ||
3 | Copyright (C) 2021 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software: you can redistribute it and/or modify it | ||
6 | under the terms of the GNU Affero General Public License as published | ||
7 | by the Free Software Foundation, either version 3 of the License, | ||
8 | or (at your option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Affero General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Affero General Public License | ||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
17 | |||
18 | SPDX-License-Identifier: AGPL3.0-or-later | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @file testbed/plugin_testcmd.c | ||
23 | * @brief a plugin to provide the API for running test cases. | ||
24 | * @author t3sserakt | ||
25 | */ | ||
26 | #include "platform.h" | ||
27 | #include "gnunet_util_lib.h" | ||
28 | #include "gnunet_testing_ng_lib.h" | ||
29 | |||
30 | #define LOG(kind, ...) GNUNET_log_from (kind, "testing-api", __VA_ARGS__) | ||
31 | |||
32 | int | ||
33 | main (int argc, | ||
34 | char *const *argv) | ||
35 | { | ||
36 | GNUNET_log_setup ("test-topology", | ||
37 | "DEBUG", | ||
38 | NULL); | ||
39 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
40 | "Test\n"); | ||
41 | GNUNET_TESTING_get_topo_from_file ("topo.conf"); | ||
42 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
43 | "Test2\n"); | ||
44 | } | ||
diff --git a/src/testing/testing.c b/src/testing/testing.c index a11d404a5..d3acd4689 100644 --- a/src/testing/testing.c +++ b/src/testing/testing.c | |||
@@ -37,6 +37,15 @@ | |||
37 | 37 | ||
38 | #define LOG(kind, ...) GNUNET_log_from (kind, "testing-api", __VA_ARGS__) | 38 | #define LOG(kind, ...) GNUNET_log_from (kind, "testing-api", __VA_ARGS__) |
39 | 39 | ||
40 | #define CONNECT_ADDRESS_TEMPLATE "%s-192.168.15.%u:60002" | ||
41 | |||
42 | #define ROUTER_CONNECT_ADDRESS_TEMPLATE "%s-92.68.150.%u:60002" | ||
43 | |||
44 | #define KNOWN_CONNECT_ADDRESS_TEMPLATE "%s-92.68.151.%u:60002" | ||
45 | |||
46 | #define PREFIX_TCP "tcp" | ||
47 | |||
48 | #define PREFIX_UDP "udp" | ||
40 | 49 | ||
41 | /** | 50 | /** |
42 | * Lowest port used for GNUnet testing. Should be high enough to not | 51 | * Lowest port used for GNUnet testing. Should be high enough to not |
@@ -1900,7 +1909,7 @@ get_connect_value (char *line, struct GNUNET_TESTING_NetjailNode *node) | |||
1900 | unsigned int namespace_n; | 1909 | unsigned int namespace_n; |
1901 | char *rest = NULL; | 1910 | char *rest = NULL; |
1902 | char *rest2 = NULL; | 1911 | char *rest2 = NULL; |
1903 | struct GNUNET_TESTING_ADDRESS_PREFIX *prefix; | 1912 | struct GNUNET_TESTING_AddressPrefix *prefix; |
1904 | 1913 | ||
1905 | node_connection = GNUNET_new (struct GNUNET_TESTING_NodeConnection); | 1914 | node_connection = GNUNET_new (struct GNUNET_TESTING_NodeConnection); |
1906 | node_connection->node = node; | 1915 | node_connection->node = node; |
@@ -1936,7 +1945,7 @@ get_connect_value (char *line, struct GNUNET_TESTING_NetjailNode *node) | |||
1936 | } | 1945 | } |
1937 | while (NULL != (token = strtok_r (NULL, ":", &rest))) | 1946 | while (NULL != (token = strtok_r (NULL, ":", &rest))) |
1938 | { | 1947 | { |
1939 | prefix = GNUNET_new (struct GNUNET_TESTING_ADDRESS_PREFIX); | 1948 | prefix = GNUNET_new (struct GNUNET_TESTING_AddressPrefix); |
1940 | token2 = strtok_r (token, "}", &rest2); | 1949 | token2 = strtok_r (token, "}", &rest2); |
1941 | if (NULL != token2) | 1950 | if (NULL != token2) |
1942 | { | 1951 | { |
@@ -1958,13 +1967,12 @@ get_connect_value (char *line, struct GNUNET_TESTING_NetjailNode *node) | |||
1958 | GNUNET_CONTAINER_DLL_insert (node_connection->address_prefixes_head, | 1967 | GNUNET_CONTAINER_DLL_insert (node_connection->address_prefixes_head, |
1959 | node_connection->address_prefixes_tail, | 1968 | node_connection->address_prefixes_tail, |
1960 | prefix); | 1969 | prefix); |
1970 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
1971 | "address_prefix %s\n", | ||
1972 | prefix->address_prefix); | ||
1961 | } | 1973 | } |
1962 | 1974 | ||
1963 | GNUNET_free (copy); | 1975 | GNUNET_free (copy); |
1964 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
1965 | "address_prefix %s\n", | ||
1966 | prefix->address_prefix); | ||
1967 | |||
1968 | return node_connection; | 1976 | return node_connection; |
1969 | } | 1977 | } |
1970 | 1978 | ||
@@ -2006,6 +2014,250 @@ node_connections (char *line, struct GNUNET_TESTING_NetjailNode *node) | |||
2006 | } | 2014 | } |
2007 | 2015 | ||
2008 | 2016 | ||
2017 | static int | ||
2018 | log_nodes (void *cls, const struct GNUNET_ShortHashCode *id, void *value) | ||
2019 | { | ||
2020 | struct GNUNET_TESTING_NetjailNode *node = value; | ||
2021 | struct GNUNET_TESTING_NodeConnection *pos_connection; | ||
2022 | struct GNUNET_TESTING_AddressPrefix *pos_prefix; | ||
2023 | |||
2024 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
2025 | "plugin: %s space: %u node: %u global: %u\n", | ||
2026 | node->plugin, | ||
2027 | node->namespace_n, | ||
2028 | node->node_n, | ||
2029 | node->is_global); | ||
2030 | |||
2031 | for (pos_connection = node->node_connections_head; NULL != pos_connection; | ||
2032 | pos_connection = pos_connection->next) | ||
2033 | { | ||
2034 | |||
2035 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
2036 | "namespace_n: %u node_n: %u node_type: %u\n", | ||
2037 | pos_connection->namespace_n, | ||
2038 | pos_connection->node_n, | ||
2039 | pos_connection->node_type); | ||
2040 | |||
2041 | for (pos_prefix = pos_connection->address_prefixes_head; NULL != pos_prefix; | ||
2042 | pos_prefix = | ||
2043 | pos_prefix->next) | ||
2044 | { | ||
2045 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
2046 | "prefix: %s\n", | ||
2047 | pos_prefix->address_prefix); | ||
2048 | } | ||
2049 | } | ||
2050 | return GNUNET_YES; | ||
2051 | } | ||
2052 | |||
2053 | |||
2054 | static int | ||
2055 | log_namespaces (void *cls, const struct GNUNET_ShortHashCode *id, void *value) | ||
2056 | { | ||
2057 | struct GNUNET_TESTING_NetjailNamespace *namespace = value; | ||
2058 | struct GNUNET_TESTING_NetjailRouter *router = namespace->router; | ||
2059 | |||
2060 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
2061 | "router_tcp: %u router_udp: %u spaces: %u\n", | ||
2062 | router->tcp_port, | ||
2063 | router->udp_port, | ||
2064 | namespace->namespace_n); | ||
2065 | GNUNET_CONTAINER_multishortmap_iterate (namespace->nodes, &log_nodes, NULL); | ||
2066 | return GNUNET_YES; | ||
2067 | } | ||
2068 | |||
2069 | |||
2070 | static int | ||
2071 | log_topo (struct GNUNET_TESTING_NetjailTopology *topology) | ||
2072 | { | ||
2073 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
2074 | "plugin: %s spaces: %u nodes: %u known: %u\n", | ||
2075 | topology->plugin, | ||
2076 | topology->namespaces_n, | ||
2077 | topology->nodes_m, | ||
2078 | topology->nodes_x); | ||
2079 | |||
2080 | GNUNET_CONTAINER_multishortmap_iterate (topology->map_namespaces, | ||
2081 | log_namespaces, NULL); | ||
2082 | GNUNET_CONTAINER_multishortmap_iterate (topology->map_globals, &log_nodes, | ||
2083 | NULL); | ||
2084 | return GNUNET_YES; | ||
2085 | } | ||
2086 | |||
2087 | |||
2088 | /** | ||
2089 | * Get the connections to other nodes for a specific node. | ||
2090 | * | ||
2091 | * @param num The specific node we want the connections for. | ||
2092 | * @param topology The topology we get the connections from. | ||
2093 | * @return The connections of the node. | ||
2094 | */ | ||
2095 | struct GNUNET_TESTING_NodeConnection * | ||
2096 | GNUNET_TESTING_get_connections (unsigned int num, struct | ||
2097 | GNUNET_TESTING_NetjailTopology *topology) | ||
2098 | { | ||
2099 | struct GNUNET_TESTING_NetjailNode *node; | ||
2100 | struct GNUNET_ShortHashCode *hkey; | ||
2101 | struct GNUNET_HashCode hc; | ||
2102 | struct GNUNET_TESTING_NetjailNamespace *namespace; | ||
2103 | unsigned int namespace_n, node_m; | ||
2104 | |||
2105 | log_topo (topology); | ||
2106 | |||
2107 | hkey = GNUNET_new (struct GNUNET_ShortHashCode); | ||
2108 | if (topology->nodes_x >= num) | ||
2109 | { | ||
2110 | |||
2111 | GNUNET_CRYPTO_hash (&num, sizeof(num), &hc); | ||
2112 | memcpy (hkey, | ||
2113 | &hc, | ||
2114 | sizeof (*hkey)); | ||
2115 | node = GNUNET_CONTAINER_multishortmap_get (topology->map_globals, | ||
2116 | hkey); | ||
2117 | } | ||
2118 | else | ||
2119 | { | ||
2120 | namespace_n = (unsigned int) floor ((num - topology->nodes_x) | ||
2121 | / topology->nodes_m); | ||
2122 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
2123 | "num: %u nodes_x: %u nodes_m: %u namespace_n: %u\n", | ||
2124 | num, | ||
2125 | topology->nodes_x, | ||
2126 | topology->nodes_m, | ||
2127 | namespace_n); | ||
2128 | hkey = GNUNET_new (struct GNUNET_ShortHashCode); | ||
2129 | GNUNET_CRYPTO_hash (&namespace_n, sizeof(namespace_n), &hc); | ||
2130 | memcpy (hkey, | ||
2131 | &hc, | ||
2132 | sizeof (*hkey)); | ||
2133 | namespace = GNUNET_CONTAINER_multishortmap_get (topology->map_namespaces, | ||
2134 | hkey); | ||
2135 | node_m = num - topology->nodes_x - topology->nodes_m * (namespace_n - 1); | ||
2136 | hkey = GNUNET_new (struct GNUNET_ShortHashCode); | ||
2137 | GNUNET_CRYPTO_hash (&node_m, sizeof(node_m), &hc); | ||
2138 | memcpy (hkey, | ||
2139 | &hc, | ||
2140 | sizeof (*hkey)); | ||
2141 | node = GNUNET_CONTAINER_multishortmap_get (namespace->nodes, | ||
2142 | hkey); | ||
2143 | } | ||
2144 | |||
2145 | |||
2146 | return node->node_connections_head; | ||
2147 | } | ||
2148 | |||
2149 | |||
2150 | /** | ||
2151 | * Retrieve the public key from the test system with the unique node id. | ||
2152 | * | ||
2153 | * @param num The unique node id. | ||
2154 | * @param tl_system The test system. | ||
2155 | * @return The peer identity wrapping the public key. | ||
2156 | */ | ||
2157 | struct GNUNET_PeerIdentity * | ||
2158 | GNUNET_TESTING_get_pub_key (unsigned int num, struct | ||
2159 | GNUNET_TESTING_System *tl_system) | ||
2160 | { | ||
2161 | struct GNUNET_PeerIdentity *peer = GNUNET_new (struct GNUNET_PeerIdentity); | ||
2162 | struct GNUNET_CRYPTO_EddsaPublicKey *pub_key = GNUNET_new (struct | ||
2163 | GNUNET_CRYPTO_EddsaPublicKey); | ||
2164 | struct GNUNET_CRYPTO_EddsaPrivateKey *priv_key = GNUNET_new (struct | ||
2165 | GNUNET_CRYPTO_EddsaPrivateKey); | ||
2166 | |||
2167 | priv_key = GNUNET_TESTING_hostkey_get (tl_system, | ||
2168 | num, | ||
2169 | peer); | ||
2170 | |||
2171 | GNUNET_CRYPTO_eddsa_key_get_public (priv_key, | ||
2172 | pub_key); | ||
2173 | peer->public_key = *pub_key; | ||
2174 | return peer; | ||
2175 | } | ||
2176 | |||
2177 | |||
2178 | /** | ||
2179 | * Calculate the unique id identifying a node from a given connction. | ||
2180 | * | ||
2181 | * @param node_connection The connection we calculate the id from. | ||
2182 | * @param topology The topology we get all needed information from. | ||
2183 | * @return The unique id of the node from the connection. | ||
2184 | */ | ||
2185 | unsigned int | ||
2186 | GNUNET_TESTING_calculate_num (struct | ||
2187 | GNUNET_TESTING_NodeConnection *node_connection, | ||
2188 | struct GNUNET_TESTING_NetjailTopology *topology) | ||
2189 | { | ||
2190 | unsigned int n, m, num; | ||
2191 | |||
2192 | n = node_connection->namespace_n; | ||
2193 | m = node_connection->node_n; | ||
2194 | |||
2195 | if (0 == n) | ||
2196 | num = m; | ||
2197 | else | ||
2198 | num = (n - 1) * topology->nodes_m + m + topology->nodes_x; | ||
2199 | |||
2200 | return num; | ||
2201 | } | ||
2202 | |||
2203 | |||
2204 | /** | ||
2205 | * Get the address for a specific communicator from a connection. | ||
2206 | * | ||
2207 | * @param connection The connection we like to have the address from. | ||
2208 | * @param prefix The communicator protocol prefix. | ||
2209 | * @return The address of the communicator. | ||
2210 | */ | ||
2211 | char * | ||
2212 | GNUNET_TESTING_get_address (struct GNUNET_TESTING_NodeConnection *connection, | ||
2213 | char *prefix) | ||
2214 | { | ||
2215 | struct GNUNET_TESTING_NetjailNode *node; | ||
2216 | char *addr; | ||
2217 | char *template; | ||
2218 | |||
2219 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
2220 | "node_n: %u\n", | ||
2221 | connection->node_n); | ||
2222 | |||
2223 | node = connection->node; | ||
2224 | if (connection->namespace_n == node->namespace_n) | ||
2225 | { | ||
2226 | template = CONNECT_ADDRESS_TEMPLATE; | ||
2227 | } | ||
2228 | else if (0 == connection->namespace_n) | ||
2229 | { | ||
2230 | template = KNOWN_CONNECT_ADDRESS_TEMPLATE; | ||
2231 | } | ||
2232 | else | ||
2233 | { | ||
2234 | template = ROUTER_CONNECT_ADDRESS_TEMPLATE; | ||
2235 | } | ||
2236 | |||
2237 | if (0 == strcmp (PREFIX_TCP, prefix)) | ||
2238 | { | ||
2239 | |||
2240 | GNUNET_asprintf (&addr, | ||
2241 | template, | ||
2242 | prefix, | ||
2243 | connection->node_n); | ||
2244 | } | ||
2245 | else if (0 == strcmp (PREFIX_UDP, prefix)) | ||
2246 | { | ||
2247 | GNUNET_asprintf (&addr, | ||
2248 | template, | ||
2249 | prefix, | ||
2250 | connection->node_n); | ||
2251 | } | ||
2252 | else | ||
2253 | { | ||
2254 | GNUNET_break (0); | ||
2255 | } | ||
2256 | |||
2257 | return addr; | ||
2258 | } | ||
2259 | |||
2260 | |||
2009 | /** | 2261 | /** |
2010 | * Getting the topology from file. | 2262 | * Getting the topology from file. |
2011 | * | 2263 | * |
diff --git a/src/testing/testing_api_cmd_local_test_finished.c b/src/testing/testing_api_cmd_local_test_finished.c index 383de4c10..b50e471e9 100644 --- a/src/testing/testing_api_cmd_local_test_finished.c +++ b/src/testing/testing_api_cmd_local_test_finished.c | |||
@@ -115,7 +115,7 @@ local_test_finished_finish (void *cls, | |||
115 | GNUNET_SCHEDULER_TaskCallback cont, | 115 | GNUNET_SCHEDULER_TaskCallback cont, |
116 | void *cont_cls) | 116 | void *cont_cls) |
117 | { | 117 | { |
118 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 118 | LOG (GNUNET_ERROR_TYPE_ERROR, |
119 | "Stopping local loop\n"); | 119 | "Stopping local loop\n"); |
120 | return GNUNET_YES; | 120 | return GNUNET_YES; |
121 | } | 121 | } |
diff --git a/src/testing/testing_api_cmd_local_test_prepared.c b/src/testing/testing_api_cmd_local_test_prepared.c new file mode 100644 index 000000000..4e915c7c0 --- /dev/null +++ b/src/testing/testing_api_cmd_local_test_prepared.c | |||
@@ -0,0 +1,168 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet | ||
3 | Copyright (C) 2021 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software: you can redistribute it and/or modify it | ||
6 | under the terms of the GNU Affero General Public License as published | ||
7 | by the Free Software Foundation, either version 3 of the License, | ||
8 | or (at your option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Affero General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Affero General Public License | ||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
17 | |||
18 | SPDX-License-Identifier: AGPL3.0-or-later | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @file testing_api_cmd_local_test_prepared.c | ||
23 | * @brief cmd to block the interpreter loop until all peers started. | ||
24 | * @author t3sserakt | ||
25 | */ | ||
26 | #include "platform.h" | ||
27 | #include "gnunet_util_lib.h" | ||
28 | #include "gnunet_testing_ng_lib.h" | ||
29 | #include "testing_cmds.h" | ||
30 | |||
31 | /** | ||
32 | * Generic logging shortcut | ||
33 | */ | ||
34 | #define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__) | ||
35 | |||
36 | |||
37 | /** | ||
38 | * Struct to hold information for callbacks. | ||
39 | * | ||
40 | */ | ||
41 | struct LocalPreparedState | ||
42 | { | ||
43 | /** | ||
44 | * Callback to write messages to the master loop. | ||
45 | * | ||
46 | */ | ||
47 | TESTING_CMD_HELPER_write_cb write_message; | ||
48 | |||
49 | /** | ||
50 | * The message send back to the master loop. | ||
51 | * | ||
52 | */ | ||
53 | struct GNUNET_CMDS_LOCAL_TEST_PREPARED *reply; | ||
54 | |||
55 | /** | ||
56 | * Flag indicating if all local tests finished. | ||
57 | */ | ||
58 | unsigned int *all_local_tests_prepared; | ||
59 | }; | ||
60 | |||
61 | |||
62 | /** | ||
63 | * Trait function of this cmd does nothing. | ||
64 | * | ||
65 | */ | ||
66 | static int | ||
67 | local_test_prepared_traits (void *cls, | ||
68 | const void **ret, | ||
69 | const char *trait, | ||
70 | unsigned int index) | ||
71 | { | ||
72 | return GNUNET_OK; | ||
73 | } | ||
74 | |||
75 | |||
76 | /** | ||
77 | * The cleanup function of this cmd frees resources the cmd allocated. | ||
78 | * | ||
79 | */ | ||
80 | static void | ||
81 | local_test_prepared_cleanup (void *cls, | ||
82 | const struct GNUNET_TESTING_Command *cmd) | ||
83 | { | ||
84 | struct LocalPreparedState *lfs = cls; | ||
85 | |||
86 | GNUNET_free (lfs->reply); | ||
87 | GNUNET_free (lfs); | ||
88 | } | ||
89 | |||
90 | |||
91 | /** | ||
92 | * This function sends a GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_TESTS_PREPARED message to the master loop. | ||
93 | * | ||
94 | */ | ||
95 | static void | ||
96 | local_test_prepared_run (void *cls, | ||
97 | const struct GNUNET_TESTING_Command *cmd, | ||
98 | struct GNUNET_TESTING_Interpreter *is) | ||
99 | { | ||
100 | struct LocalPreparedState *lfs = cls; | ||
101 | |||
102 | struct GNUNET_CMDS_LOCAL_TEST_PREPARED *reply; | ||
103 | size_t msg_length; | ||
104 | |||
105 | msg_length = sizeof(struct GNUNET_CMDS_LOCAL_TEST_PREPARED); | ||
106 | reply = GNUNET_new (struct GNUNET_CMDS_LOCAL_TEST_PREPARED); | ||
107 | reply->header.type = htons ( | ||
108 | GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_TEST_PREPARED); | ||
109 | reply->header.size = htons ((uint16_t) msg_length); | ||
110 | lfs->reply = reply; | ||
111 | lfs->write_message ((struct GNUNET_MessageHeader *) reply, msg_length); | ||
112 | } | ||
113 | |||
114 | |||
115 | /** | ||
116 | * This finish function will stop the local loop without shutting down the scheduler, because we do not call the continuation, which is the interpreter_next method. | ||
117 | * | ||
118 | */ | ||
119 | static int | ||
120 | local_test_prepared_finish (void *cls, | ||
121 | GNUNET_SCHEDULER_TaskCallback cont, | ||
122 | void *cont_cls) | ||
123 | { | ||
124 | struct LocalPreparedState *lfs = cls; | ||
125 | unsigned int *ret = lfs->all_local_tests_prepared; | ||
126 | |||
127 | if (GNUNET_YES == *ret) | ||
128 | { | ||
129 | cont (cont_cls); | ||
130 | } | ||
131 | |||
132 | return *ret; | ||
133 | |||
134 | } | ||
135 | |||
136 | |||
137 | /** | ||
138 | * Create command. | ||
139 | * | ||
140 | * @param label name for command. | ||
141 | * @param write_message Callback to write messages to the master loop. | ||
142 | * @param all_local_tests_prepared Flag which will be set from outside. | ||
143 | * @return command. | ||
144 | */ | ||
145 | struct GNUNET_TESTING_Command | ||
146 | GNUNET_TESTING_cmd_local_test_prepared (const char *label, | ||
147 | TESTING_CMD_HELPER_write_cb | ||
148 | write_message, | ||
149 | unsigned int * | ||
150 | all_local_tests_prepared) | ||
151 | { | ||
152 | struct LocalPreparedState *lfs; | ||
153 | |||
154 | lfs = GNUNET_new (struct LocalPreparedState); | ||
155 | lfs->write_message = write_message; | ||
156 | lfs->all_local_tests_prepared = all_local_tests_prepared; | ||
157 | |||
158 | struct GNUNET_TESTING_Command cmd = { | ||
159 | .cls = lfs, | ||
160 | .label = label, | ||
161 | .run = &local_test_prepared_run, | ||
162 | .finish = &local_test_prepared_finish, | ||
163 | .cleanup = &local_test_prepared_cleanup, | ||
164 | .traits = &local_test_prepared_traits | ||
165 | }; | ||
166 | |||
167 | return cmd; | ||
168 | } | ||
diff --git a/src/testing/testing_api_cmd_netjail_start_testsystem_v2.c b/src/testing/testing_api_cmd_netjail_start_testsystem_v2.c index ccb3f5ae8..5e27a7a82 100644 --- a/src/testing/testing_api_cmd_netjail_start_testsystem_v2.c +++ b/src/testing/testing_api_cmd_netjail_start_testsystem_v2.c | |||
@@ -30,6 +30,11 @@ | |||
30 | #define NETJAIL_EXEC_SCRIPT "./../testing/netjail_exec_v2.sh" | 30 | #define NETJAIL_EXEC_SCRIPT "./../testing/netjail_exec_v2.sh" |
31 | 31 | ||
32 | /** | 32 | /** |
33 | * Generic logging shortcut | ||
34 | */ | ||
35 | #define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__) | ||
36 | |||
37 | /** | ||
33 | * Struct to store messages send/received by the helper into a DLL | 38 | * Struct to store messages send/received by the helper into a DLL |
34 | * | 39 | * |
35 | */ | 40 | */ |
@@ -116,13 +121,13 @@ struct NetJailState | |||
116 | /** | 121 | /** |
117 | * The send handle for the helper | 122 | * The send handle for the helper |
118 | */ | 123 | */ |
119 | struct GNUNET_HELPER_SendHandle **shandle; | 124 | // struct GNUNET_HELPER_SendHandle **shandle; |
120 | 125 | ||
121 | /** | 126 | /** |
122 | * Size of the array NetJailState#shandle. | 127 | * Size of the array NetJailState#shandle. |
123 | * | 128 | * |
124 | */ | 129 | */ |
125 | unsigned int n_shandle; | 130 | // unsigned int n_shandle; |
126 | 131 | ||
127 | /** | 132 | /** |
128 | * The messages send to the helper. | 133 | * The messages send to the helper. |
@@ -151,7 +156,13 @@ struct NetJailState | |||
151 | * Number of local tests finished. | 156 | * Number of local tests finished. |
152 | * | 157 | * |
153 | */ | 158 | */ |
154 | unsigned int number_of_local_test_finished; | 159 | unsigned int number_of_local_tests_finished; |
160 | |||
161 | /** | ||
162 | * Number of local tests prepared to finish. | ||
163 | * | ||
164 | */ | ||
165 | unsigned int number_of_local_tests_prepared; | ||
155 | 166 | ||
156 | /** | 167 | /** |
157 | * Name of the test case plugin the helper will load. | 168 | * Name of the test case plugin the helper will load. |
@@ -189,6 +200,17 @@ struct TestingSystemCount | |||
189 | struct TestingSystemCount *prev; | 200 | struct TestingSystemCount *prev; |
190 | 201 | ||
191 | /** | 202 | /** |
203 | * The send handle for the helper | ||
204 | */ | ||
205 | struct GNUNET_HELPER_SendHandle *shandle;// **shandle; | ||
206 | |||
207 | /** | ||
208 | * Size of the array NetJailState#shandle. | ||
209 | * | ||
210 | */ | ||
211 | // unsigned int n_shandle; | ||
212 | |||
213 | /** | ||
192 | * The number of the test environment. | 214 | * The number of the test environment. |
193 | * | 215 | * |
194 | */ | 216 | */ |
@@ -277,10 +299,9 @@ netjail_exec_traits (void *cls, | |||
277 | * @return #GNUNET_OK on success. | 299 | * @return #GNUNET_OK on success. |
278 | */ | 300 | */ |
279 | int | 301 | int |
280 | GNUNET_TESTING_get_trait_helper_handles_v2 (const struct | 302 | GNUNET_TESTING_get_trait_helper_handles_v2 ( |
281 | GNUNET_TESTING_Command *cmd, | 303 | const struct GNUNET_TESTING_Command *cmd, |
282 | struct GNUNET_HELPER_Handle *** | 304 | struct GNUNET_HELPER_Handle ***helper) |
283 | helper) | ||
284 | { | 305 | { |
285 | return cmd->traits (cmd->cls, | 306 | return cmd->traits (cmd->cls, |
286 | (const void **) helper, | 307 | (const void **) helper, |
@@ -293,18 +314,19 @@ GNUNET_TESTING_get_trait_helper_handles_v2 (const struct | |||
293 | * Continuation function from GNUNET_HELPER_send() | 314 | * Continuation function from GNUNET_HELPER_send() |
294 | * | 315 | * |
295 | * @param cls closure | 316 | * @param cls closure |
296 | * @param result GNUNET_OK on success, | 317 | * @param result #GNUNET_OK on success, |
297 | * GNUNET_NO if helper process died | 318 | * #GNUNET_NO if helper process died |
298 | * GNUNET_SYSERR during GNUNET_HELPER_stop | 319 | * #GNUNET_SYSERR during GNUNET_HELPER_stop |
299 | */ | 320 | */ |
300 | static void | 321 | static void |
301 | clear_msg (void *cls, int result) | 322 | clear_msg (void *cls, |
323 | int result) | ||
302 | { | 324 | { |
303 | struct TestingSystemCount *tbc = cls; | 325 | struct TestingSystemCount *tbc = cls; |
304 | struct NetJailState *ns = tbc->ns; | 326 | struct NetJailState *ns = tbc->ns; |
305 | 327 | ||
306 | GNUNET_assert (NULL != ns->shandle[tbc->count - 1]); | 328 | GNUNET_assert (NULL != tbc->shandle);// [tbc->count - 1]); |
307 | ns->shandle[tbc->count - 1] = NULL; | 329 | tbc->shandle = NULL;// [tbc->count - 1] = NULL; |
308 | GNUNET_free (ns->msg[tbc->count - 1]); | 330 | GNUNET_free (ns->msg[tbc->count - 1]); |
309 | ns->msg[tbc->count - 1] = NULL; | 331 | ns->msg[tbc->count - 1] = NULL; |
310 | } | 332 | } |
@@ -323,10 +345,11 @@ clear_msg (void *cls, int result) | |||
323 | * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing | 345 | * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing |
324 | */ | 346 | */ |
325 | static int | 347 | static int |
326 | helper_mst (void *cls, const struct GNUNET_MessageHeader *message) | 348 | helper_mst (void *cls, |
349 | const struct GNUNET_MessageHeader *message) | ||
327 | { | 350 | { |
328 | struct TestingSystemCount *tbc = cls; | 351 | // struct TestingSystemCount *tbc = cls; |
329 | struct NetJailState *ns = tbc->ns; | 352 | struct NetJailState *ns = cls;// tbc->ns; |
330 | struct HelperMessage *hp_msg; | 353 | struct HelperMessage *hp_msg; |
331 | 354 | ||
332 | if (GNUNET_MESSAGE_TYPE_CMDS_HELPER_REPLY == ntohs (message->type)) | 355 | if (GNUNET_MESSAGE_TYPE_CMDS_HELPER_REPLY == ntohs (message->type)) |
@@ -338,10 +361,18 @@ helper_mst (void *cls, const struct GNUNET_MessageHeader *message) | |||
338 | { | 361 | { |
339 | ns->number_of_peers_started++; | 362 | ns->number_of_peers_started++; |
340 | } | 363 | } |
364 | else if (GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_TEST_PREPARED == ntohs ( | ||
365 | message->type)) | ||
366 | { | ||
367 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
368 | "received prepare msg %u\n", | ||
369 | ns->number_of_local_tests_prepared); | ||
370 | ns->number_of_local_tests_prepared++; | ||
371 | } | ||
341 | else if (GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED == ntohs ( | 372 | else if (GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_FINISHED == ntohs ( |
342 | message->type)) | 373 | message->type)) |
343 | { | 374 | { |
344 | ns->number_of_local_test_finished++; | 375 | ns->number_of_local_tests_finished++; |
345 | } | 376 | } |
346 | else | 377 | else |
347 | { | 378 | { |
@@ -364,8 +395,10 @@ static void | |||
364 | exp_cb (void *cls) | 395 | exp_cb (void *cls) |
365 | { | 396 | { |
366 | struct NetJailState *ns = cls; | 397 | struct NetJailState *ns = cls; |
398 | unsigned int *rv = ns->rv; | ||
399 | |||
367 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Called exp_cb.\n"); | 400 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Called exp_cb.\n"); |
368 | *ns->rv = 1; | 401 | *rv = 1; |
369 | } | 402 | } |
370 | 403 | ||
371 | 404 | ||
@@ -420,6 +453,7 @@ start_helper (struct NetJailState *ns, struct | |||
420 | struct GNUNET_TESTING_NetjailTopology *topology = ns->topology; | 453 | struct GNUNET_TESTING_NetjailTopology *topology = ns->topology; |
421 | struct GNUNET_TESTING_NetjailNode *node; | 454 | struct GNUNET_TESTING_NetjailNode *node; |
422 | struct GNUNET_TESTING_NetjailNamespace *namespace; | 455 | struct GNUNET_TESTING_NetjailNamespace *namespace; |
456 | unsigned int *rv = ns->rv; | ||
423 | 457 | ||
424 | 458 | ||
425 | if (0 == n) | 459 | if (0 == n) |
@@ -460,7 +494,8 @@ start_helper (struct NetJailState *ns, struct | |||
460 | else | 494 | else |
461 | tbc->count = (n - 1) * ns->local_m + m + ns->known; | 495 | tbc->count = (n - 1) * ns->local_m + m + ns->known; |
462 | 496 | ||
463 | GNUNET_CONTAINER_DLL_insert (ns->tbcs_head, ns->tbcs_tail, | 497 | GNUNET_CONTAINER_DLL_insert (ns->tbcs_head, |
498 | ns->tbcs_tail, | ||
464 | tbc); | 499 | tbc); |
465 | 500 | ||
466 | 501 | ||
@@ -469,14 +504,14 @@ start_helper (struct NetJailState *ns, struct | |||
469 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 504 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
470 | "No SUID for %s!\n", | 505 | "No SUID for %s!\n", |
471 | NETJAIL_EXEC_SCRIPT); | 506 | NETJAIL_EXEC_SCRIPT); |
472 | *ns->rv = 1; | 507 | *rv = 1; |
473 | } | 508 | } |
474 | else if (GNUNET_NO == helper_check) | 509 | else if (GNUNET_NO == helper_check) |
475 | { | 510 | { |
476 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 511 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
477 | "%s not found!\n", | 512 | "%s not found!\n", |
478 | NETJAIL_EXEC_SCRIPT); | 513 | NETJAIL_EXEC_SCRIPT); |
479 | *ns->rv = 1; | 514 | *rv = 1; |
480 | } | 515 | } |
481 | 516 | ||
482 | GNUNET_array_append (ns->helper, ns->n_helper, GNUNET_HELPER_start ( | 517 | GNUNET_array_append (ns->helper, ns->n_helper, GNUNET_HELPER_start ( |
@@ -485,7 +520,7 @@ start_helper (struct NetJailState *ns, struct | |||
485 | script_argv, | 520 | script_argv, |
486 | &helper_mst, | 521 | &helper_mst, |
487 | &exp_cb, | 522 | &exp_cb, |
488 | tbc)); | 523 | ns)); |
489 | 524 | ||
490 | helper = ns->helper[tbc->count - 1]; | 525 | helper = ns->helper[tbc->count - 1]; |
491 | 526 | ||
@@ -542,19 +577,20 @@ start_helper (struct NetJailState *ns, struct | |||
542 | 577 | ||
543 | GNUNET_array_append (ns->msg, ns->n_msg, &msg->header); | 578 | GNUNET_array_append (ns->msg, ns->n_msg, &msg->header); |
544 | 579 | ||
545 | GNUNET_array_append (ns->shandle, ns->n_shandle, GNUNET_HELPER_send ( | 580 | // GNUNET_array_append (tbc->shandle, tbc->n_shandle, |
546 | helper, | 581 | tbc->shandle = GNUNET_HELPER_send ( |
547 | &msg->header, | 582 | helper, |
548 | GNUNET_NO, | 583 | &msg->header, |
549 | &clear_msg, | 584 | GNUNET_NO, |
550 | tbc)); | 585 | &clear_msg, |
586 | tbc); // ); | ||
551 | 587 | ||
552 | if (NULL == ns->shandle[tbc->count - 1]) | 588 | if (NULL == tbc->shandle)// [tbc->count - 1]) |
553 | { | 589 | { |
554 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 590 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
555 | "Send handle is NULL!\n"); | 591 | "Send handle is NULL!\n"); |
556 | GNUNET_free (msg); | 592 | GNUNET_free (msg); |
557 | *ns->rv = 1; | 593 | *rv = 1; |
558 | } | 594 | } |
559 | } | 595 | } |
560 | 596 | ||
@@ -595,39 +631,76 @@ netjail_exec_run (void *cls, | |||
595 | 631 | ||
596 | 632 | ||
597 | static void | 633 | static void |
598 | send_all_peers_started (unsigned int i, unsigned int j, struct NetJailState *ns) | 634 | send_message_to_locals ( |
635 | unsigned int i, | ||
636 | unsigned int j, | ||
637 | struct NetJailState *ns, | ||
638 | struct GNUNET_MessageHeader *header | ||
639 | ) | ||
599 | { | 640 | { |
600 | unsigned int total_number = ns->local_m * ns->global_n + ns->known; | 641 | // unsigned int total_number = ns->local_m * ns->global_n + ns->known; |
601 | struct GNUNET_CMDS_ALL_PEERS_STARTED *reply; | ||
602 | size_t msg_length; | ||
603 | struct GNUNET_HELPER_Handle *helper; | 642 | struct GNUNET_HELPER_Handle *helper; |
604 | struct TestingSystemCount *tbc; | 643 | struct TestingSystemCount *tbc; |
605 | 644 | ||
645 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
646 | "send message to locals\n"); | ||
606 | tbc = GNUNET_new (struct TestingSystemCount); | 647 | tbc = GNUNET_new (struct TestingSystemCount); |
607 | tbc->ns = ns; | 648 | tbc->ns = ns; |
608 | // TODO This needs to be more generic. As we send more messages back and forth, we can not grow the arrays again and again, because this is to error prone. | 649 | // TODO This needs to be more generic. As we send more messages back and forth, we can not grow the arrays again and again, because this is to error prone. |
609 | if (0 == i) | 650 | if (0 == i) |
610 | tbc->count = j + total_number; | 651 | tbc->count = j; // + total_number; |
611 | else | 652 | else |
612 | tbc->count = (i - 1) * ns->local_m + j + total_number + ns->known; | 653 | tbc->count = (i - 1) * ns->local_m + j + ns->known; // + total_number ; |
613 | 654 | ||
614 | helper = ns->helper[tbc->count - 1 - total_number]; | 655 | helper = ns->helper[tbc->count - 1];// - total_number]; |
615 | msg_length = sizeof(struct GNUNET_CMDS_ALL_PEERS_STARTED); | ||
616 | reply = GNUNET_new (struct GNUNET_CMDS_ALL_PEERS_STARTED); | ||
617 | reply->header.type = htons ( | ||
618 | GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_PEERS_STARTED); | ||
619 | reply->header.size = htons ((uint16_t) msg_length); | ||
620 | 656 | ||
621 | GNUNET_array_append (ns->msg, ns->n_msg, &reply->header); | 657 | GNUNET_array_append (ns->msg, ns->n_msg, header); |
622 | 658 | ||
623 | struct GNUNET_HELPER_SendHandle *sh = GNUNET_HELPER_send ( | 659 | struct GNUNET_HELPER_SendHandle *sh = GNUNET_HELPER_send ( |
624 | helper, | 660 | helper, |
625 | &reply->header, | 661 | header, |
626 | GNUNET_NO, | 662 | GNUNET_NO, |
627 | &clear_msg, | 663 | &clear_msg, |
628 | tbc); | 664 | tbc); |
629 | 665 | ||
630 | GNUNET_array_append (ns->shandle, ns->n_shandle, sh); | 666 | tbc->shandle = sh; |
667 | // GNUNET_array_append (tbc->shandle, tbc->n_shandle, sh); | ||
668 | } | ||
669 | |||
670 | |||
671 | static void | ||
672 | send_all_local_tests_prepared (unsigned int i, unsigned int j, struct | ||
673 | NetJailState *ns) | ||
674 | { | ||
675 | struct GNUNET_CMDS_ALL_LOCAL_TESTS_PREPARED *reply; | ||
676 | size_t msg_length; | ||
677 | |||
678 | |||
679 | msg_length = sizeof(struct GNUNET_CMDS_ALL_LOCAL_TESTS_PREPARED); | ||
680 | reply = GNUNET_new (struct GNUNET_CMDS_ALL_LOCAL_TESTS_PREPARED); | ||
681 | reply->header.type = htons ( | ||
682 | GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_LOCAL_TESTS_PREPARED); | ||
683 | reply->header.size = htons ((uint16_t) msg_length); | ||
684 | |||
685 | send_message_to_locals (i, j, ns, &reply->header); | ||
686 | } | ||
687 | |||
688 | |||
689 | static void | ||
690 | send_all_peers_started (unsigned int i, unsigned int j, struct NetJailState *ns) | ||
691 | { | ||
692 | |||
693 | struct GNUNET_CMDS_ALL_PEERS_STARTED *reply; | ||
694 | size_t msg_length; | ||
695 | |||
696 | |||
697 | msg_length = sizeof(struct GNUNET_CMDS_ALL_PEERS_STARTED); | ||
698 | reply = GNUNET_new (struct GNUNET_CMDS_ALL_PEERS_STARTED); | ||
699 | reply->header.type = htons ( | ||
700 | GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_PEERS_STARTED); | ||
701 | reply->header.size = htons ((uint16_t) msg_length); | ||
702 | |||
703 | send_message_to_locals (i, j, ns, &reply->header); | ||
631 | } | 704 | } |
632 | 705 | ||
633 | 706 | ||
@@ -650,12 +723,28 @@ netjail_start_finish (void *cls, | |||
650 | unsigned int total_number = ns->local_m * ns->global_n + ns->known; | 723 | unsigned int total_number = ns->local_m * ns->global_n + ns->known; |
651 | 724 | ||
652 | 725 | ||
653 | if (ns->number_of_local_test_finished == total_number) | 726 | if (ns->number_of_local_tests_finished == total_number) |
654 | { | 727 | { |
655 | ret = GNUNET_YES; | 728 | ret = GNUNET_YES; |
656 | cont (cont_cls); | 729 | cont (cont_cls); |
657 | } | 730 | } |
658 | 731 | ||
732 | if (ns->number_of_local_tests_prepared == total_number) | ||
733 | { | ||
734 | for (int i = 1; i <= ns->known; i++) | ||
735 | { | ||
736 | send_all_local_tests_prepared (0,i, ns); | ||
737 | } | ||
738 | |||
739 | for (int i = 1; i <= ns->global_n; i++) | ||
740 | { | ||
741 | for (int j = 1; j <= ns->local_m; j++) | ||
742 | { | ||
743 | send_all_local_tests_prepared (i,j, ns); | ||
744 | } | ||
745 | } | ||
746 | } | ||
747 | |||
659 | if (ns->number_of_testsystems_started == total_number) | 748 | if (ns->number_of_testsystems_started == total_number) |
660 | { | 749 | { |
661 | ns->number_of_testsystems_started = 0; | 750 | ns->number_of_testsystems_started = 0; |
diff --git a/src/testing/testing_api_cmd_netjail_start_v2.c b/src/testing/testing_api_cmd_netjail_start_v2.c index 36fbb0e10..7d802db6a 100644 --- a/src/testing/testing_api_cmd_netjail_start_v2.c +++ b/src/testing/testing_api_cmd_netjail_start_v2.c | |||
@@ -75,7 +75,7 @@ netjail_start_cleanup (void *cls, | |||
75 | { | 75 | { |
76 | GNUNET_assert (0 == | 76 | GNUNET_assert (0 == |
77 | GNUNET_OS_process_kill (ns->start_proc, | 77 | GNUNET_OS_process_kill (ns->start_proc, |
78 | SIGKILL)); | 78 | SIGTERM)); |
79 | GNUNET_assert (GNUNET_OK == | 79 | GNUNET_assert (GNUNET_OK == |
80 | GNUNET_OS_process_wait (ns->start_proc)); | 80 | GNUNET_OS_process_wait (ns->start_proc)); |
81 | GNUNET_OS_process_destroy (ns->start_proc); | 81 | GNUNET_OS_process_destroy (ns->start_proc); |
diff --git a/src/testing/testing_api_cmd_netjail_stop_testsystem_v2.c b/src/testing/testing_api_cmd_netjail_stop_testsystem_v2.c index 8eccc5764..6ce106eaa 100644 --- a/src/testing/testing_api_cmd_netjail_stop_testsystem_v2.c +++ b/src/testing/testing_api_cmd_netjail_stop_testsystem_v2.c | |||
@@ -45,6 +45,12 @@ struct StopHelperState | |||
45 | unsigned int local_m; | 45 | unsigned int local_m; |
46 | 46 | ||
47 | unsigned int global_n; | 47 | unsigned int global_n; |
48 | |||
49 | /** | ||
50 | * Number of global known nodes. | ||
51 | * | ||
52 | */ | ||
53 | unsigned int known; | ||
48 | }; | 54 | }; |
49 | 55 | ||
50 | 56 | ||
@@ -97,11 +103,24 @@ stop_testing_system_run (void *cls, | |||
97 | GNUNET_TESTING_get_trait_helper_handles (start_helper_cmd, | 103 | GNUNET_TESTING_get_trait_helper_handles (start_helper_cmd, |
98 | &helper); | 104 | &helper); |
99 | 105 | ||
106 | for (int i = 1; i <= shs->known; i++) | ||
107 | { | ||
108 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
109 | "i: %u\n", | ||
110 | i); | ||
111 | GNUNET_HELPER_stop (helper[i - 1], | ||
112 | GNUNET_YES); | ||
113 | } | ||
114 | |||
100 | for (int i = 1; i <= shs->global_n; i++) | 115 | for (int i = 1; i <= shs->global_n; i++) |
101 | { | 116 | { |
102 | for (int j = 1; j <= shs->local_m; j++) | 117 | for (int j = 1; j <= shs->local_m; j++) |
103 | { | 118 | { |
104 | GNUNET_HELPER_stop (helper[(i - 1) * shs->local_m + j - 1], | 119 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
120 | "i: %u j: %u\n", | ||
121 | i, | ||
122 | j); | ||
123 | GNUNET_HELPER_stop (helper[(i - 1) * shs->local_m + j + shs->known - 1], | ||
105 | GNUNET_YES); | 124 | GNUNET_YES); |
106 | } | 125 | } |
107 | } | 126 | } |
@@ -130,6 +149,7 @@ GNUNET_TESTING_cmd_stop_testing_system_v2 (const char *label, | |||
130 | shs->helper_start_label = helper_start_label; | 149 | shs->helper_start_label = helper_start_label; |
131 | shs->local_m = topology->nodes_m; | 150 | shs->local_m = topology->nodes_m; |
132 | shs->global_n = topology->namespaces_n; | 151 | shs->global_n = topology->namespaces_n; |
152 | shs->known = topology->nodes_x; | ||
133 | 153 | ||
134 | struct GNUNET_TESTING_Command cmd = { | 154 | struct GNUNET_TESTING_Command cmd = { |
135 | .cls = shs, | 155 | .cls = shs, |
diff --git a/src/testing/testing_api_loop.c b/src/testing/testing_api_loop.c index 0c24c0e26..ab095aafa 100644 --- a/src/testing/testing_api_loop.c +++ b/src/testing/testing_api_loop.c | |||
@@ -408,6 +408,22 @@ GNUNET_TESTING_cmd_end (void) | |||
408 | { | 408 | { |
409 | static struct GNUNET_TESTING_Command cmd; | 409 | static struct GNUNET_TESTING_Command cmd; |
410 | cmd.label = NULL; | 410 | cmd.label = NULL; |
411 | cmd.shutdown_on_end = GNUNET_YES; | ||
412 | |||
413 | return cmd; | ||
414 | } | ||
415 | |||
416 | /** | ||
417 | * Create command array terminator without shutdown. | ||
418 | * | ||
419 | * @return a end-command. | ||
420 | */ | ||
421 | struct GNUNET_TESTING_Command | ||
422 | GNUNET_TESTING_cmd_end_without_shutdown (void) | ||
423 | { | ||
424 | static struct GNUNET_TESTING_Command cmd; | ||
425 | cmd.label = NULL; | ||
426 | cmd.shutdown_on_end = GNUNET_NO; | ||
411 | 427 | ||
412 | return cmd; | 428 | return cmd; |
413 | } | 429 | } |
@@ -447,7 +463,8 @@ interpreter_run (void *cls) | |||
447 | "Running command END %p\n", | 463 | "Running command END %p\n", |
448 | is); | 464 | is); |
449 | is->result = GNUNET_OK; | 465 | is->result = GNUNET_OK; |
450 | GNUNET_SCHEDULER_shutdown (); | 466 | if (GNUNET_YES == cmd->shutdown_on_end) |
467 | GNUNET_SCHEDULER_shutdown (); | ||
451 | return; | 468 | return; |
452 | } | 469 | } |
453 | else if (NULL != cmd) | 470 | else if (NULL != cmd) |
diff --git a/src/testing/testing_cmds.h b/src/testing/testing_cmds.h index 7a5860aea..005402a73 100644 --- a/src/testing/testing_cmds.h +++ b/src/testing/testing_cmds.h | |||
@@ -85,6 +85,23 @@ struct GNUNET_CMDS_LOCAL_FINISHED | |||
85 | struct GNUNET_MessageHeader header; | 85 | struct GNUNET_MessageHeader header; |
86 | }; | 86 | }; |
87 | 87 | ||
88 | struct GNUNET_CMDS_LOCAL_TEST_PREPARED | ||
89 | { | ||
90 | /** | ||
91 | * Type is GNUNET_MESSAGE_TYPE_CMDS_HELPER_LOCAL_TEST_PREPARED | ||
92 | */ | ||
93 | struct GNUNET_MessageHeader header; | ||
94 | }; | ||
95 | |||
96 | struct GNUNET_CMDS_ALL_LOCAL_TESTS_PREPARED | ||
97 | { | ||
98 | /** | ||
99 | * Type is GNUNET_MESSAGE_TYPE_CMDS_HELPER_ALL_LOCAL_TESTS_PREPARED | ||
100 | */ | ||
101 | struct GNUNET_MessageHeader header; | ||
102 | }; | ||
103 | |||
88 | GNUNET_NETWORK_STRUCT_END | 104 | GNUNET_NETWORK_STRUCT_END |
105 | |||
89 | #endif | 106 | #endif |
90 | /* end of testing_cmds.h */ | 107 | /* end of testing_cmds.h */ |
diff --git a/src/transport/Makefile.am b/src/transport/Makefile.am index 32075ee16..73544a8d5 100644 --- a/src/transport/Makefile.am +++ b/src/transport/Makefile.am | |||
@@ -163,12 +163,14 @@ libgnunettransporttesting2_la_SOURCES = \ | |||
163 | transport_api_cmd_connecting_peers.c \ | 163 | transport_api_cmd_connecting_peers.c \ |
164 | transport_api_cmd_connecting_peers_v2.c \ | 164 | transport_api_cmd_connecting_peers_v2.c \ |
165 | transport_api_cmd_connecting_peers_v3.c \ | 165 | transport_api_cmd_connecting_peers_v3.c \ |
166 | transport_api_cmd_backchannel_check.c \ | ||
166 | transport_api_cmd_start_peer.c \ | 167 | transport_api_cmd_start_peer.c \ |
167 | transport_api_cmd_start_peer_v2.c \ | 168 | transport_api_cmd_start_peer_v2.c \ |
168 | transport_api_cmd_start_peer_v3.c \ | 169 | transport_api_cmd_start_peer_v3.c \ |
169 | transport_api_cmd_stop_peer.c \ | 170 | transport_api_cmd_stop_peer.c \ |
170 | transport_api_cmd_send_simple.c \ | 171 | transport_api_cmd_send_simple.c \ |
171 | transport_api_cmd_send_simple_v2.c \ | 172 | transport_api_cmd_send_simple_v2.c \ |
173 | transport_api_cmd_send_simple_v3.c \ | ||
172 | transport-testing2.c transport-testing2.h \ | 174 | transport-testing2.c transport-testing2.h \ |
173 | transport-testing-cmds.h \ | 175 | transport-testing-cmds.h \ |
174 | transport-testing-filenames2.c \ | 176 | transport-testing-filenames2.c \ |
diff --git a/src/transport/gnunet-communicator-tcp.c b/src/transport/gnunet-communicator-tcp.c index d8bf7c1a8..025326de7 100644 --- a/src/transport/gnunet-communicator-tcp.c +++ b/src/transport/gnunet-communicator-tcp.c | |||
@@ -1119,6 +1119,10 @@ pass_plaintext_to_core (struct Queue *queue, | |||
1119 | const struct GNUNET_MessageHeader *hdr = plaintext; | 1119 | const struct GNUNET_MessageHeader *hdr = plaintext; |
1120 | int ret; | 1120 | int ret; |
1121 | 1121 | ||
1122 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1123 | "pass message from %s to core\n", | ||
1124 | GNUNET_i2s (&queue->target)); | ||
1125 | |||
1122 | if (ntohs (hdr->size) != plaintext_len) | 1126 | if (ntohs (hdr->size) != plaintext_len) |
1123 | { | 1127 | { |
1124 | /* NOTE: If we ever allow multiple CORE messages in one | 1128 | /* NOTE: If we ever allow multiple CORE messages in one |
@@ -1132,6 +1136,8 @@ pass_plaintext_to_core (struct Queue *queue, | |||
1132 | ADDRESS_VALIDITY_PERIOD, | 1136 | ADDRESS_VALIDITY_PERIOD, |
1133 | &core_read_finished_cb, | 1137 | &core_read_finished_cb, |
1134 | queue); | 1138 | queue); |
1139 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1140 | "passed to core\n"); | ||
1135 | if (GNUNET_OK == ret) | 1141 | if (GNUNET_OK == ret) |
1136 | queue->backpressure++; | 1142 | queue->backpressure++; |
1137 | GNUNET_break (GNUNET_NO != ret); /* backpressure not working!? */ | 1143 | GNUNET_break (GNUNET_NO != ret); /* backpressure not working!? */ |
@@ -1795,7 +1801,7 @@ try_handle_plaintext (struct Queue *queue) | |||
1795 | queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch, | 1801 | queue->qh = GNUNET_TRANSPORT_communicator_mq_add (ch, |
1796 | &queue->target, | 1802 | &queue->target, |
1797 | foreign_addr, | 1803 | foreign_addr, |
1798 | UINT32_MAX, /* no MTU */ | 1804 | UINT16_MAX, /* no MTU */ |
1799 | GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED, | 1805 | GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED, |
1800 | 0, /* Priority */ | 1806 | 0, /* Priority */ |
1801 | queue->nt, | 1807 | queue->nt, |
@@ -2444,7 +2450,7 @@ boot_queue (struct Queue *queue) | |||
2444 | * Generate and transmit our ephemeral key and the signature for | 2450 | * Generate and transmit our ephemeral key and the signature for |
2445 | * the initial KX with the other peer. Must be called first, before | 2451 | * the initial KX with the other peer. Must be called first, before |
2446 | * any other bytes are ever written to the output buffer. Note that | 2452 | * any other bytes are ever written to the output buffer. Note that |
2447 | * our cipher must already be initialized when calling this function. | 2453 | * our cipher must already be initialized when calling thi function. |
2448 | * Helper function for #start_initial_kx_out(). | 2454 | * Helper function for #start_initial_kx_out(). |
2449 | * | 2455 | * |
2450 | * @param queue queue to do KX for | 2456 | * @param queue queue to do KX for |
@@ -2725,6 +2731,9 @@ proto_read_kx (void *cls) | |||
2725 | queue->listen_sock = pq->listen_sock; | 2731 | queue->listen_sock = pq->listen_sock; |
2726 | queue->sock = pq->sock; | 2732 | queue->sock = pq->sock; |
2727 | 2733 | ||
2734 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2735 | "created queue with target %s\n", | ||
2736 | GNUNET_i2s (&queue->target)); | ||
2728 | 2737 | ||
2729 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2738 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2730 | "start kx proto\n"); | 2739 | "start kx proto\n"); |
@@ -2984,6 +2993,9 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address) | |||
2984 | queue->sock = sock; | 2993 | queue->sock = sock; |
2985 | queue->cs = GNUNET_TRANSPORT_CS_OUTBOUND; | 2994 | queue->cs = GNUNET_TRANSPORT_CS_OUTBOUND; |
2986 | boot_queue (queue); | 2995 | boot_queue (queue); |
2996 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
2997 | "booted queue with target %s\n", | ||
2998 | GNUNET_i2s (&queue->target)); | ||
2987 | // queue->mq_awaits_continue = GNUNET_YES; | 2999 | // queue->mq_awaits_continue = GNUNET_YES; |
2988 | queue->read_task = | 3000 | queue->read_task = |
2989 | GNUNET_SCHEDULER_add_read_net (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, | 3001 | GNUNET_SCHEDULER_add_read_net (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, |
@@ -3646,6 +3658,10 @@ main (int argc, char *const *argv) | |||
3646 | }; | 3658 | }; |
3647 | int ret; | 3659 | int ret; |
3648 | 3660 | ||
3661 | GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_DEBUG, | ||
3662 | "transport", | ||
3663 | "Starting tcp communicator\n"); | ||
3664 | |||
3649 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) | 3665 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) |
3650 | return 2; | 3666 | return 2; |
3651 | 3667 | ||
diff --git a/src/transport/gnunet-communicator-udp.c b/src/transport/gnunet-communicator-udp.c index ef7b1d6c0..659fd7d26 100644 --- a/src/transport/gnunet-communicator-udp.c +++ b/src/transport/gnunet-communicator-udp.c | |||
@@ -1494,7 +1494,27 @@ add_acks (struct SharedSecret *ss, int acks_to_add) | |||
1494 | 1494 | ||
1495 | GNUNET_assert (NULL != ss); | 1495 | GNUNET_assert (NULL != ss); |
1496 | GNUNET_assert (NULL != receiver); | 1496 | GNUNET_assert (NULL != receiver); |
1497 | GNUNET_assert (NULL != receiver->d_qh); | 1497 | |
1498 | if (NULL == receiver->d_qh) | ||
1499 | { | ||
1500 | receiver->d_qh = | ||
1501 | GNUNET_TRANSPORT_communicator_mq_add (ch, | ||
1502 | &receiver->target, | ||
1503 | receiver->foreign_addr, | ||
1504 | receiver->d_mtu, | ||
1505 | acks_to_add, | ||
1506 | 1, /* Priority */ | ||
1507 | receiver->nt, | ||
1508 | GNUNET_TRANSPORT_CS_OUTBOUND, | ||
1509 | receiver->d_mq); | ||
1510 | } | ||
1511 | else | ||
1512 | { | ||
1513 | GNUNET_TRANSPORT_communicator_mq_update (ch, | ||
1514 | receiver->d_qh, | ||
1515 | acks_to_add, | ||
1516 | 1); | ||
1517 | } | ||
1498 | 1518 | ||
1499 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1519 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1500 | "Tell transport we have %u more acks!\n", | 1520 | "Tell transport we have %u more acks!\n", |
@@ -1502,10 +1522,7 @@ add_acks (struct SharedSecret *ss, int acks_to_add) | |||
1502 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1522 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1503 | "%u kce for rekeying.\n", | 1523 | "%u kce for rekeying.\n", |
1504 | receiver->number_rekeying_kce); | 1524 | receiver->number_rekeying_kce); |
1505 | GNUNET_TRANSPORT_communicator_mq_update (ch, | 1525 | |
1506 | receiver->d_qh, | ||
1507 | acks_to_add, | ||
1508 | 1); | ||
1509 | // Until here for alternativ 1 | 1526 | // Until here for alternativ 1 |
1510 | 1527 | ||
1511 | /* move ss to head to avoid discarding it anytime soon! */ | 1528 | /* move ss to head to avoid discarding it anytime soon! */ |
@@ -1744,7 +1761,7 @@ kce_generate_cb (void *cls) | |||
1744 | if (((GNUNET_NO == ss->sender->rekeying) && (ss->sender->acks_available < | 1761 | if (((GNUNET_NO == ss->sender->rekeying) && (ss->sender->acks_available < |
1745 | KCN_TARGET) ) || | 1762 | KCN_TARGET) ) || |
1746 | ((ss->sender->ss_rekey == ss) && (GNUNET_YES == ss->sender->rekeying) && | 1763 | ((ss->sender->ss_rekey == ss) && (GNUNET_YES == ss->sender->rekeying) && |
1747 | (ss->sender->acks_available < 128))) | 1764 | (ss->sender->acks_available < KCN_TARGET))) |
1748 | { | 1765 | { |
1749 | 1766 | ||
1750 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1767 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
@@ -1754,20 +1771,24 @@ kce_generate_cb (void *cls) | |||
1754 | for (int i = 0; i < GENERATE_AT_ONCE; i++) | 1771 | for (int i = 0; i < GENERATE_AT_ONCE; i++) |
1755 | kce_generate (ss, ++ss->sequence_allowed); | 1772 | kce_generate (ss, ++ss->sequence_allowed); |
1756 | 1773 | ||
1757 | ss->sender->kce_task = GNUNET_SCHEDULER_add_delayed ( | 1774 | if (KCN_TARGET > ss->sender->acks_available) |
1758 | WORKING_QUEUE_INTERVALL, | 1775 | { |
1759 | kce_generate_cb, | 1776 | ss->sender->kce_task = GNUNET_SCHEDULER_add_delayed ( |
1760 | ss); | 1777 | WORKING_QUEUE_INTERVALL, |
1761 | } | 1778 | kce_generate_cb, |
1762 | else | 1779 | ss); |
1763 | { | 1780 | } |
1764 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1781 | else |
1765 | "We have enough keys.\n"); | 1782 | { |
1766 | ss_finished = ss; | 1783 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1767 | ss->sender->kce_task_finished = GNUNET_YES; | 1784 | "We have enough keys.\n"); |
1785 | ss_finished = ss; | ||
1786 | ss->sender->kce_task_finished = GNUNET_YES; | ||
1787 | } | ||
1768 | } | 1788 | } |
1769 | 1789 | ||
1770 | 1790 | ||
1791 | |||
1771 | } | 1792 | } |
1772 | 1793 | ||
1773 | 1794 | ||
@@ -1850,7 +1871,17 @@ consider_ss_ack (struct SharedSecret *ss, int initial) | |||
1850 | kce_generate (ss, ++ss->sequence_allowed); | 1871 | kce_generate (ss, ++ss->sequence_allowed); |
1851 | }*/ | 1872 | }*/ |
1852 | 1873 | ||
1853 | if (((NULL != kce_task) && kce_task_finished) || (GNUNET_NO == initial)) | 1874 | if (NULL != kce_task) |
1875 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1876 | "kce_task is not NULL\n"); | ||
1877 | if (kce_task_finished) | ||
1878 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1879 | "kce_task_finished: GNUNET_YES\n"); | ||
1880 | if (initial) | ||
1881 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
1882 | "initial: GNUNET_YES\n"); | ||
1883 | |||
1884 | if ( kce_task_finished || (GNUNET_NO == initial)) | ||
1854 | { | 1885 | { |
1855 | struct UDPAck ack; | 1886 | struct UDPAck ack; |
1856 | struct SharedSecret *ss_tell; | 1887 | struct SharedSecret *ss_tell; |
@@ -1877,8 +1908,7 @@ consider_ss_ack (struct SharedSecret *ss, int initial) | |||
1877 | if (GNUNET_NO != initial) | 1908 | if (GNUNET_NO != initial) |
1878 | { | 1909 | { |
1879 | destroy_all_secrets (ss, GNUNET_YES); | 1910 | destroy_all_secrets (ss, GNUNET_YES); |
1880 | kce_task = NULL; | 1911 | ss->sender->kce_task_finished = GNUNET_NO; |
1881 | kce_task_finished = GNUNET_NO; | ||
1882 | } | 1912 | } |
1883 | } | 1913 | } |
1884 | else if ((NULL == kce_task) && ((KCN_THRESHOLD > | 1914 | else if ((NULL == kce_task) && ((KCN_THRESHOLD > |
@@ -2678,8 +2708,10 @@ mq_send_kx (struct GNUNET_MQ_Handle *mq, | |||
2678 | receiver->address_len)) | 2708 | receiver->address_len)) |
2679 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); | 2709 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); |
2680 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2710 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2681 | "Sending KX to %s\n", GNUNET_a2s (receiver->address, | 2711 | "Sending KX with payload size %u to %s\n", |
2682 | receiver->address_len)); | 2712 | msize, |
2713 | GNUNET_a2s (receiver->address, | ||
2714 | receiver->address_len)); | ||
2683 | GNUNET_MQ_impl_send_continue (mq); | 2715 | GNUNET_MQ_impl_send_continue (mq); |
2684 | } | 2716 | } |
2685 | 2717 | ||
@@ -2940,7 +2972,8 @@ mq_send_d (struct GNUNET_MQ_Handle *mq, | |||
2940 | receiver->address_len)) | 2972 | receiver->address_len)) |
2941 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); | 2973 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "send"); |
2942 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 2974 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2943 | "Sending UDPBox %u acks left\n", | 2975 | "Sending UDPBox with payload size %u, %u acks left\n", |
2976 | msize, | ||
2944 | receiver->acks_available); | 2977 | receiver->acks_available); |
2945 | GNUNET_MQ_impl_send_continue (mq); | 2978 | GNUNET_MQ_impl_send_continue (mq); |
2946 | receiver->acks_available--; | 2979 | receiver->acks_available--; |
@@ -3135,17 +3168,6 @@ setup_receiver_mq (struct ReceiverAddress *receiver) | |||
3135 | receiver->nt, | 3168 | receiver->nt, |
3136 | GNUNET_TRANSPORT_CS_OUTBOUND, | 3169 | GNUNET_TRANSPORT_CS_OUTBOUND, |
3137 | receiver->kx_mq); | 3170 | receiver->kx_mq); |
3138 | receiver->d_qh = | ||
3139 | GNUNET_TRANSPORT_communicator_mq_add (ch, | ||
3140 | &receiver->target, | ||
3141 | receiver->foreign_addr, | ||
3142 | receiver->d_mtu, | ||
3143 | 0, /* Initialize with 0 acks */ | ||
3144 | 1, /* Priority */ | ||
3145 | receiver->nt, | ||
3146 | GNUNET_TRANSPORT_CS_OUTBOUND, | ||
3147 | receiver->d_mq); | ||
3148 | |||
3149 | } | 3171 | } |
3150 | 3172 | ||
3151 | 3173 | ||
@@ -3755,9 +3777,11 @@ run (void *cls, | |||
3755 | GNUNET_free (bindto); | 3777 | GNUNET_free (bindto); |
3756 | in = (struct sockaddr *) &in_sto; | 3778 | in = (struct sockaddr *) &in_sto; |
3757 | in_len = sto_len; | 3779 | in_len = sto_len; |
3758 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 3780 | GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_DEBUG, |
3759 | "Bound to `%s'\n", | 3781 | "transport", |
3760 | GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len)); | 3782 | "Bound to `%s'\n", |
3783 | GNUNET_a2s ((const struct sockaddr *) &in_sto, | ||
3784 | sto_len)); | ||
3761 | switch (in->sa_family) | 3785 | switch (in->sa_family) |
3762 | { | 3786 | { |
3763 | case AF_INET: | 3787 | case AF_INET: |
@@ -3853,6 +3877,9 @@ main (int argc, char *const *argv) | |||
3853 | }; | 3877 | }; |
3854 | int ret; | 3878 | int ret; |
3855 | 3879 | ||
3880 | GNUNET_log_from_nocheck (GNUNET_ERROR_TYPE_DEBUG, | ||
3881 | "transport", | ||
3882 | "Starting udp communicator\n"); | ||
3856 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) | 3883 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) |
3857 | return 2; | 3884 | return 2; |
3858 | 3885 | ||
diff --git a/src/transport/gnunet-service-tng.c b/src/transport/gnunet-service-tng.c index a7e2a8c04..a90bef3b5 100644 --- a/src/transport/gnunet-service-tng.c +++ b/src/transport/gnunet-service-tng.c | |||
@@ -1736,6 +1736,11 @@ struct Queue | |||
1736 | const char *address; | 1736 | const char *address; |
1737 | 1737 | ||
1738 | /** | 1738 | /** |
1739 | * Is this queue of unlimited length. | ||
1740 | */ | ||
1741 | unsigned int unlimited_length; | ||
1742 | |||
1743 | /** | ||
1739 | * Task scheduled for the time when this queue can (likely) transmit the | 1744 | * Task scheduled for the time when this queue can (likely) transmit the |
1740 | * next message. | 1745 | * next message. |
1741 | */ | 1746 | */ |
@@ -1787,6 +1792,11 @@ struct Queue | |||
1787 | unsigned int queue_length; | 1792 | unsigned int queue_length; |
1788 | 1793 | ||
1789 | /** | 1794 | /** |
1795 | * Capacity of the queue. | ||
1796 | */ | ||
1797 | uint64_t q_capacity; | ||
1798 | |||
1799 | /** | ||
1790 | * Queue priority | 1800 | * Queue priority |
1791 | */ | 1801 | */ |
1792 | uint32_t priority; | 1802 | uint32_t priority; |
@@ -3446,6 +3456,35 @@ transmit_on_queue (void *cls); | |||
3446 | 3456 | ||
3447 | 3457 | ||
3448 | /** | 3458 | /** |
3459 | * Check if the communicator has another queue with higher prio ready for sending. | ||
3460 | */ | ||
3461 | static unsigned int | ||
3462 | check_for_queue_with_higher_prio (struct Queue *queue, struct Queue *queue_head) | ||
3463 | { | ||
3464 | for (struct Queue *s = queue_head; NULL != s; | ||
3465 | s = s->next_client) | ||
3466 | { | ||
3467 | if (s->tc->details.communicator.address_prefix != | ||
3468 | queue->tc->details.communicator.address_prefix) | ||
3469 | { | ||
3470 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
3471 | "queue address %s qid %u compare with queue: address %s qid %u\n", | ||
3472 | queue->address, | ||
3473 | queue->qid, | ||
3474 | s->address, | ||
3475 | s->qid); | ||
3476 | if ((s->priority > queue->priority) && (0 < s->q_capacity) && | ||
3477 | (QUEUE_LENGTH_LIMIT > s->queue_length) ) | ||
3478 | return GNUNET_YES; | ||
3479 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
3480 | "Lower prio\n"); | ||
3481 | } | ||
3482 | } | ||
3483 | return GNUNET_NO; | ||
3484 | } | ||
3485 | |||
3486 | |||
3487 | /** | ||
3449 | * Called whenever something changed that might effect when we | 3488 | * Called whenever something changed that might effect when we |
3450 | * try to do the next transmission on @a queue using #transmit_on_queue(). | 3489 | * try to do the next transmission on @a queue using #transmit_on_queue(). |
3451 | * | 3490 | * |
@@ -3456,6 +3495,11 @@ static void | |||
3456 | schedule_transmit_on_queue (struct Queue *queue, | 3495 | schedule_transmit_on_queue (struct Queue *queue, |
3457 | enum GNUNET_SCHEDULER_Priority p) | 3496 | enum GNUNET_SCHEDULER_Priority p) |
3458 | { | 3497 | { |
3498 | if (check_for_queue_with_higher_prio (queue, | ||
3499 | queue->tc->details.communicator. | ||
3500 | queue_head)) | ||
3501 | return; | ||
3502 | |||
3459 | if (queue->tc->details.communicator.total_queue_length >= | 3503 | if (queue->tc->details.communicator.total_queue_length >= |
3460 | COMMUNICATOR_TOTAL_QUEUE_LIMIT) | 3504 | COMMUNICATOR_TOTAL_QUEUE_LIMIT) |
3461 | { | 3505 | { |
@@ -3480,6 +3524,19 @@ schedule_transmit_on_queue (struct Queue *queue, | |||
3480 | queue->idle = GNUNET_NO; | 3524 | queue->idle = GNUNET_NO; |
3481 | return; | 3525 | return; |
3482 | } | 3526 | } |
3527 | if (0 == queue->q_capacity) | ||
3528 | { | ||
3529 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
3530 | "Transmission throttled due to communicator message queue qid %u has capacity %lu.\n", | ||
3531 | queue->qid, | ||
3532 | queue->q_capacity); | ||
3533 | GNUNET_STATISTICS_update (GST_stats, | ||
3534 | "# Transmission throttled due to message queue capacity", | ||
3535 | 1, | ||
3536 | GNUNET_NO); | ||
3537 | queue->idle = GNUNET_NO; | ||
3538 | return; | ||
3539 | } | ||
3483 | /* queue might indeed be ready, schedule it */ | 3540 | /* queue might indeed be ready, schedule it */ |
3484 | if (NULL != queue->transmit_task) | 3541 | if (NULL != queue->transmit_task) |
3485 | GNUNET_SCHEDULER_cancel (queue->transmit_task); | 3542 | GNUNET_SCHEDULER_cancel (queue->transmit_task); |
@@ -3582,8 +3639,9 @@ free_queue (struct Queue *queue) | |||
3582 | tc->details.communicator.queue_head, | 3639 | tc->details.communicator.queue_head, |
3583 | tc->details.communicator.queue_tail, | 3640 | tc->details.communicator.queue_tail, |
3584 | queue); | 3641 | queue); |
3585 | maxxed = (COMMUNICATOR_TOTAL_QUEUE_LIMIT >= | 3642 | maxxed = (COMMUNICATOR_TOTAL_QUEUE_LIMIT <= |
3586 | tc->details.communicator.total_queue_length); | 3643 | tc->details.communicator. |
3644 | total_queue_length); | ||
3587 | while (NULL != (qe = queue->queue_head)) | 3645 | while (NULL != (qe = queue->queue_head)) |
3588 | { | 3646 | { |
3589 | GNUNET_CONTAINER_DLL_remove (queue->queue_head, queue->queue_tail, qe); | 3647 | GNUNET_CONTAINER_DLL_remove (queue->queue_head, queue->queue_tail, qe); |
@@ -3597,7 +3655,7 @@ free_queue (struct Queue *queue) | |||
3597 | GNUNET_free (qe); | 3655 | GNUNET_free (qe); |
3598 | } | 3656 | } |
3599 | GNUNET_assert (0 == queue->queue_length); | 3657 | GNUNET_assert (0 == queue->queue_length); |
3600 | if ((maxxed) && (COMMUNICATOR_TOTAL_QUEUE_LIMIT < | 3658 | if ((maxxed) && (COMMUNICATOR_TOTAL_QUEUE_LIMIT > |
3601 | tc->details.communicator.total_queue_length)) | 3659 | tc->details.communicator.total_queue_length)) |
3602 | { | 3660 | { |
3603 | /* Communicator dropped below threshold, resume all _other_ queues */ | 3661 | /* Communicator dropped below threshold, resume all _other_ queues */ |
@@ -4223,18 +4281,36 @@ queue_send_msg (struct Queue *queue, | |||
4223 | if (NULL != pm) | 4281 | if (NULL != pm) |
4224 | { | 4282 | { |
4225 | qe->pm = pm; | 4283 | qe->pm = pm; |
4226 | GNUNET_assert (NULL == pm->qe); | 4284 | // TODO Why do we have a retransmission. When we know, make decision if we still want this. |
4285 | // GNUNET_assert (NULL == pm->qe); | ||
4286 | /*if (NULL != pm->qe) | ||
4287 | { | ||
4288 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
4289 | "Retransmitting message <%llu> remove pm from qe with MID: %llu \n", | ||
4290 | pm->logging_uuid, | ||
4291 | (unsigned long long) pm->qe->mid); | ||
4292 | pm->qe->pm = NULL; | ||
4293 | }*/ | ||
4227 | pm->qe = qe; | 4294 | pm->qe = qe; |
4228 | } | 4295 | } |
4229 | GNUNET_CONTAINER_DLL_insert (queue->queue_head, queue->queue_tail, qe); | 4296 | GNUNET_CONTAINER_DLL_insert (queue->queue_head, queue->queue_tail, qe); |
4230 | GNUNET_assert (CT_COMMUNICATOR == queue->tc->type); | 4297 | GNUNET_assert (CT_COMMUNICATOR == queue->tc->type); |
4231 | queue->queue_length++; | 4298 | queue->queue_length++; |
4232 | queue->tc->details.communicator.total_queue_length++; | 4299 | queue->tc->details.communicator.total_queue_length++; |
4300 | if (GNUNET_NO == queue->unlimited_length) | ||
4301 | queue->q_capacity--; | ||
4302 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
4303 | "Queue %s with qid %u has capacity %lu\n", | ||
4304 | queue->address, | ||
4305 | queue->qid, | ||
4306 | queue->q_capacity); | ||
4233 | if (COMMUNICATOR_TOTAL_QUEUE_LIMIT == | 4307 | if (COMMUNICATOR_TOTAL_QUEUE_LIMIT == |
4234 | queue->tc->details.communicator.total_queue_length) | 4308 | queue->tc->details.communicator.total_queue_length) |
4235 | queue->idle = GNUNET_NO; | 4309 | queue->idle = GNUNET_NO; |
4236 | if (QUEUE_LENGTH_LIMIT == queue->queue_length) | 4310 | if (QUEUE_LENGTH_LIMIT == queue->queue_length) |
4237 | queue->idle = GNUNET_NO; | 4311 | queue->idle = GNUNET_NO; |
4312 | if (0 == queue->q_capacity) | ||
4313 | queue->idle = GNUNET_NO; | ||
4238 | GNUNET_MQ_send (queue->tc->mq, env); | 4314 | GNUNET_MQ_send (queue->tc->mq, env); |
4239 | } | 4315 | } |
4240 | } | 4316 | } |
@@ -4672,8 +4748,16 @@ route_control_message_without_fc (const struct GNUNET_PeerIdentity *target, | |||
4672 | struct GNUNET_TIME_Relative rtt1; | 4748 | struct GNUNET_TIME_Relative rtt1; |
4673 | struct GNUNET_TIME_Relative rtt2; | 4749 | struct GNUNET_TIME_Relative rtt2; |
4674 | 4750 | ||
4751 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
4752 | "Trying to route message of type %u to %s without fc\n", | ||
4753 | ntohs (hdr->type), | ||
4754 | GNUNET_i2s (target)); | ||
4755 | |||
4756 | // TODO Do this elsewhere. vl should be given as parameter to method. | ||
4675 | vl = lookup_virtual_link (target); | 4757 | vl = lookup_virtual_link (target); |
4676 | GNUNET_assert (NULL != vl); | 4758 | GNUNET_assert (NULL != vl); |
4759 | if (NULL == vl) | ||
4760 | return GNUNET_TIME_UNIT_FOREVER_REL; | ||
4677 | n = vl->n; | 4761 | n = vl->n; |
4678 | dv = (0 != (options & RMO_DV_ALLOWED)) ? vl->dv : NULL; | 4762 | dv = (0 != (options & RMO_DV_ALLOWED)) ? vl->dv : NULL; |
4679 | if (0 == (options & RMO_UNCONFIRMED_ALLOWED)) | 4763 | if (0 == (options & RMO_UNCONFIRMED_ALLOWED)) |
@@ -4718,6 +4802,10 @@ route_control_message_without_fc (const struct GNUNET_PeerIdentity *target, | |||
4718 | rtt2 = GNUNET_TIME_UNIT_FOREVER_REL; | 4802 | rtt2 = GNUNET_TIME_UNIT_FOREVER_REL; |
4719 | if (NULL != n) | 4803 | if (NULL != n) |
4720 | { | 4804 | { |
4805 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
4806 | "Try to route message of type %u to %s without fc via neighbour\n", | ||
4807 | ntohs (hdr->type), | ||
4808 | GNUNET_i2s (target)); | ||
4721 | rtt1 = route_via_neighbour (n, hdr, options); | 4809 | rtt1 = route_via_neighbour (n, hdr, options); |
4722 | } | 4810 | } |
4723 | if (NULL != dv) | 4811 | if (NULL != dv) |
@@ -4889,7 +4977,9 @@ check_vl_transmission (struct VirtualLink *vl) | |||
4889 | schedule_transmit_on_queue (queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | 4977 | schedule_transmit_on_queue (queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); |
4890 | else | 4978 | else |
4891 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 4979 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
4892 | "Queue busy or invalid\n"); | 4980 | "Neighbour Queue QID: %u (%u) busy or invalid\n", |
4981 | queue->qid, | ||
4982 | queue->idle); | ||
4893 | } | 4983 | } |
4894 | } | 4984 | } |
4895 | /* Notify queues via DV that we are interested */ | 4985 | /* Notify queues via DV that we are interested */ |
@@ -4910,6 +5000,11 @@ check_vl_transmission (struct VirtualLink *vl) | |||
4910 | (queue->validated_until.abs_value_us > now.abs_value_us)) | 5000 | (queue->validated_until.abs_value_us > now.abs_value_us)) |
4911 | schedule_transmit_on_queue (queue, | 5001 | schedule_transmit_on_queue (queue, |
4912 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND); | 5002 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND); |
5003 | else | ||
5004 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5005 | "DV Queue QID: %u (%u) busy or invalid\n", | ||
5006 | queue->qid, | ||
5007 | queue->idle); | ||
4913 | } | 5008 | } |
4914 | } | 5009 | } |
4915 | } | 5010 | } |
@@ -4996,8 +5091,9 @@ handle_communicator_backchannel ( | |||
4996 | (const struct GNUNET_MessageHeader *) &cb[1]; | 5091 | (const struct GNUNET_MessageHeader *) &cb[1]; |
4997 | uint16_t isize = ntohs (inbox->size); | 5092 | uint16_t isize = ntohs (inbox->size); |
4998 | const char *is = ((const char *) &cb[1]) + isize; | 5093 | const char *is = ((const char *) &cb[1]) + isize; |
5094 | size_t slen = strlen (is) + 1; | ||
4999 | char | 5095 | char |
5000 | mbuf[isize | 5096 | mbuf[slen + isize |
5001 | + sizeof(struct | 5097 | + sizeof(struct |
5002 | TransportBackchannelEncapsulationMessage)] GNUNET_ALIGN; | 5098 | TransportBackchannelEncapsulationMessage)] GNUNET_ALIGN; |
5003 | struct TransportBackchannelEncapsulationMessage *be = | 5099 | struct TransportBackchannelEncapsulationMessage *be = |
@@ -5006,9 +5102,10 @@ handle_communicator_backchannel ( | |||
5006 | /* 0-termination of 'is' was checked already in | 5102 | /* 0-termination of 'is' was checked already in |
5007 | #check_communicator_backchannel() */ | 5103 | #check_communicator_backchannel() */ |
5008 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 5104 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
5009 | "Preparing backchannel transmission to %s:%s of type %u\n", | 5105 | "Preparing backchannel transmission to %s:%s of type %u and size %u\n", |
5010 | GNUNET_i2s (&cb->pid), | 5106 | GNUNET_i2s (&cb->pid), |
5011 | is, | 5107 | is, |
5108 | ntohs (inbox->type), | ||
5012 | ntohs (inbox->size)); | 5109 | ntohs (inbox->size)); |
5013 | /* encapsulate and encrypt message */ | 5110 | /* encapsulate and encrypt message */ |
5014 | be->header.type = | 5111 | be->header.type = |
@@ -5264,6 +5361,11 @@ handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh) | |||
5264 | uint16_t size = ntohs (mh->size); | 5361 | uint16_t size = ntohs (mh->size); |
5265 | int have_core; | 5362 | int have_core; |
5266 | 5363 | ||
5364 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5365 | "Handling message of type %u with %u bytes\n", | ||
5366 | (unsigned int) ntohs (mh->type), | ||
5367 | (unsigned int) ntohs (mh->size)); | ||
5368 | |||
5267 | if ((size > UINT16_MAX - sizeof(struct InboundMessage)) || | 5369 | if ((size > UINT16_MAX - sizeof(struct InboundMessage)) || |
5268 | (size < sizeof(struct GNUNET_MessageHeader))) | 5370 | (size < sizeof(struct GNUNET_MessageHeader))) |
5269 | { | 5371 | { |
@@ -5290,6 +5392,10 @@ handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh) | |||
5290 | 1, | 5392 | 1, |
5291 | GNUNET_NO); | 5393 | GNUNET_NO); |
5292 | 5394 | ||
5395 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5396 | "CORE messages of type %u with %u bytes dropped (virtual link still down)\n", | ||
5397 | (unsigned int) ntohs (mh->type), | ||
5398 | (unsigned int) ntohs (mh->size)); | ||
5293 | finish_cmc_handling (cmc); | 5399 | finish_cmc_handling (cmc); |
5294 | return; | 5400 | return; |
5295 | } | 5401 | } |
@@ -5299,7 +5405,10 @@ handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh) | |||
5299 | "# CORE messages dropped (FC arithmetic overflow)", | 5405 | "# CORE messages dropped (FC arithmetic overflow)", |
5300 | 1, | 5406 | 1, |
5301 | GNUNET_NO); | 5407 | GNUNET_NO); |
5302 | 5408 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | |
5409 | "CORE messages of type %u with %u bytes dropped (FC arithmetic overflow)\n", | ||
5410 | (unsigned int) ntohs (mh->type), | ||
5411 | (unsigned int) ntohs (mh->size)); | ||
5303 | finish_cmc_handling (cmc); | 5412 | finish_cmc_handling (cmc); |
5304 | return; | 5413 | return; |
5305 | } | 5414 | } |
@@ -5309,6 +5418,10 @@ handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh) | |||
5309 | "# CORE messages dropped (FC window overflow)", | 5418 | "# CORE messages dropped (FC window overflow)", |
5310 | 1, | 5419 | 1, |
5311 | GNUNET_NO); | 5420 | GNUNET_NO); |
5421 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5422 | "CORE messages of type %u with %u bytes dropped (FC window overflow)\n", | ||
5423 | (unsigned int) ntohs (mh->type), | ||
5424 | (unsigned int) ntohs (mh->size)); | ||
5312 | finish_cmc_handling (cmc); | 5425 | finish_cmc_handling (cmc); |
5313 | return; | 5426 | return; |
5314 | } | 5427 | } |
@@ -5345,6 +5458,10 @@ handle_raw_message (void *cls, const struct GNUNET_MessageHeader *mh) | |||
5345 | perspective of the other peer! */ | 5458 | perspective of the other peer! */ |
5346 | vl->incoming_fc_window_size_used += size; | 5459 | vl->incoming_fc_window_size_used += size; |
5347 | /* TODO-M1 */ | 5460 | /* TODO-M1 */ |
5461 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
5462 | "Dropped message of type %u with %u bytes to CORE: no CORE client connected!", | ||
5463 | (unsigned int) ntohs (mh->type), | ||
5464 | (unsigned int) ntohs (mh->size)); | ||
5348 | finish_cmc_handling (cmc); | 5465 | finish_cmc_handling (cmc); |
5349 | return; | 5466 | return; |
5350 | } | 5467 | } |
@@ -6074,6 +6191,15 @@ handle_backchannel_encapsulation ( | |||
6074 | (const struct GNUNET_MessageHeader *) &be[1]; | 6191 | (const struct GNUNET_MessageHeader *) &be[1]; |
6075 | uint16_t isize = ntohs (inbox->size); | 6192 | uint16_t isize = ntohs (inbox->size); |
6076 | const char *target_communicator = ((const char *) inbox) + isize; | 6193 | const char *target_communicator = ((const char *) inbox) + isize; |
6194 | char *sender; | ||
6195 | char *self; | ||
6196 | |||
6197 | GNUNET_asprintf (&sender, | ||
6198 | "%s", | ||
6199 | GNUNET_i2s (&cmc->im.sender)); | ||
6200 | GNUNET_asprintf (&self, | ||
6201 | "%s", | ||
6202 | GNUNET_i2s (&GST_my_identity)); | ||
6077 | 6203 | ||
6078 | /* Find client providing this communicator */ | 6204 | /* Find client providing this communicator */ |
6079 | for (tc = clients_head; NULL != tc; tc = tc->next) | 6205 | for (tc = clients_head; NULL != tc; tc = tc->next) |
@@ -6095,8 +6221,9 @@ handle_backchannel_encapsulation ( | |||
6095 | } | 6221 | } |
6096 | /* Finally, deliver backchannel message to communicator */ | 6222 | /* Finally, deliver backchannel message to communicator */ |
6097 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 6223 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
6098 | "Delivering backchannel message from %s of type %u to %s\n", | 6224 | "Delivering backchannel message from %s to %s of type %u to %s\n", |
6099 | GNUNET_i2s (&cmc->im.sender), | 6225 | sender, |
6226 | self, | ||
6100 | ntohs (inbox->type), | 6227 | ntohs (inbox->type), |
6101 | target_communicator); | 6228 | target_communicator); |
6102 | env = GNUNET_MQ_msg_extra ( | 6229 | env = GNUNET_MQ_msg_extra ( |
@@ -8407,14 +8534,15 @@ fragment_message (struct Queue *queue, | |||
8407 | struct PendingMessage *ff; | 8534 | struct PendingMessage *ff; |
8408 | uint16_t mtu; | 8535 | uint16_t mtu; |
8409 | 8536 | ||
8410 | mtu = (0 == queue->mtu) | 8537 | mtu = (UINT16_MAX == queue->mtu) |
8411 | ? UINT16_MAX - sizeof(struct GNUNET_TRANSPORT_SendMessageTo) | 8538 | ? UINT16_MAX - sizeof(struct GNUNET_TRANSPORT_SendMessageTo) |
8412 | : queue->mtu; | 8539 | : queue->mtu; |
8413 | set_pending_message_uuid (pm); | 8540 | set_pending_message_uuid (pm); |
8414 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 8541 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
8415 | "Fragmenting message %llu <%llu> to %s for MTU %u\n", | 8542 | "Fragmenting message %llu <%llu> with size %u to %s for MTU %u\n", |
8416 | (unsigned long long) pm->msg_uuid.uuid, | 8543 | (unsigned long long) pm->msg_uuid.uuid, |
8417 | pm->logging_uuid, | 8544 | pm->logging_uuid, |
8545 | pm->bytes_msg, | ||
8418 | GNUNET_i2s (&pm->vl->target), | 8546 | GNUNET_i2s (&pm->vl->target), |
8419 | (unsigned int) mtu); | 8547 | (unsigned int) mtu); |
8420 | pa = prepare_pending_acknowledgement (queue, dvh, pm); | 8548 | pa = prepare_pending_acknowledgement (queue, dvh, pm); |
@@ -8700,7 +8828,7 @@ select_best_pending_from_link (struct PendingMessageScoreContext *sc, | |||
8700 | GNUNET_TRANSPORT_SendMessageTo)) | 8828 | GNUNET_TRANSPORT_SendMessageTo)) |
8701 | || | 8829 | || |
8702 | (NULL != pos->head_frag /* fragments already exist, should | 8830 | (NULL != pos->head_frag /* fragments already exist, should |
8703 | respect that even if MTU is 0 for | 8831 | respect that even if MTU is UINT16_MAX for |
8704 | this queue */)) | 8832 | this queue */)) |
8705 | { | 8833 | { |
8706 | frag = GNUNET_YES; | 8834 | frag = GNUNET_YES; |
@@ -9069,12 +9197,17 @@ handle_send_message_ack (void *cls, | |||
9069 | qep = qep->next) | 9197 | qep = qep->next) |
9070 | { | 9198 | { |
9071 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 9199 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
9072 | "QueueEntry MID: %llu, Ack MID: %llu\n", | 9200 | "QueueEntry MID: %llu on queue QID: %llu, Ack MID: %llu\n", |
9073 | (unsigned long long) qep->mid, | 9201 | (unsigned long long) qep->mid, |
9202 | (unsigned long long) queue->qid, | ||
9074 | (unsigned long long) sma->mid); | 9203 | (unsigned long long) sma->mid); |
9075 | if (qep->mid != sma->mid) | 9204 | if (qep->mid != sma->mid) |
9076 | continue; | 9205 | continue; |
9077 | qe = qep; | 9206 | qe = qep; |
9207 | if ((NULL != qe->pm)&&(qe->pm->qe != qe)) | ||
9208 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9209 | "For pending message %llu we had retransmissions.\n", | ||
9210 | qe->pm->logging_uuid); | ||
9078 | break; | 9211 | break; |
9079 | } | 9212 | } |
9080 | } | 9213 | } |
@@ -9125,12 +9258,26 @@ handle_send_message_ack (void *cls, | |||
9125 | GNUNET_NO); | 9258 | GNUNET_NO); |
9126 | schedule_transmit_on_queue (qe->queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | 9259 | schedule_transmit_on_queue (qe->queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); |
9127 | } | 9260 | } |
9261 | else if (1 == qe->queue->q_capacity) | ||
9262 | { | ||
9263 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
9264 | "Transmission rescheduled due to communicator message queue with qid %u has capacity %lu.\n", | ||
9265 | qe->queue->qid, | ||
9266 | qe->queue->q_capacity); | ||
9267 | /* message queue has capacity; only resume this one queue */ | ||
9268 | /* queue dropped below threshold; only resume this one queue */ | ||
9269 | GNUNET_STATISTICS_update (GST_stats, | ||
9270 | "# Transmission throttled due to message queue capacity", | ||
9271 | -1, | ||
9272 | GNUNET_NO); | ||
9273 | schedule_transmit_on_queue (qe->queue, GNUNET_SCHEDULER_PRIORITY_DEFAULT); | ||
9274 | } | ||
9128 | 9275 | ||
9129 | if (NULL != (pm = qe->pm)) | 9276 | if (NULL != (pm = qe->pm)) |
9130 | { | 9277 | { |
9131 | struct VirtualLink *vl; | 9278 | struct VirtualLink *vl; |
9132 | 9279 | ||
9133 | GNUNET_assert (qe == pm->qe); | 9280 | // GNUNET_assert (qe == pm->qe); |
9134 | pm->qe = NULL; | 9281 | pm->qe = NULL; |
9135 | /* If waiting for this communicator may have blocked transmission | 9282 | /* If waiting for this communicator may have blocked transmission |
9136 | of pm on other queues for this neighbour, force schedule | 9283 | of pm on other queues for this neighbour, force schedule |
@@ -9671,16 +9818,20 @@ handle_add_queue_message (void *cls, | |||
9671 | addr_len = ntohs (aqm->header.size) - sizeof(*aqm); | 9818 | addr_len = ntohs (aqm->header.size) - sizeof(*aqm); |
9672 | addr = (const char *) &aqm[1]; | 9819 | addr = (const char *) &aqm[1]; |
9673 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 9820 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
9674 | "New queue %s to %s available with QID %llu\n", | 9821 | "New queue %s to %s available with QID %llu and q_len %lu \n", |
9675 | addr, | 9822 | addr, |
9676 | GNUNET_i2s (&aqm->receiver), | 9823 | GNUNET_i2s (&aqm->receiver), |
9677 | (unsigned long long) aqm->qid); | 9824 | (unsigned long long) aqm->qid, |
9825 | GNUNET_ntohll (aqm->q_len)); | ||
9678 | queue = GNUNET_malloc (sizeof(struct Queue) + addr_len); | 9826 | queue = GNUNET_malloc (sizeof(struct Queue) + addr_len); |
9679 | queue->tc = tc; | 9827 | queue->tc = tc; |
9680 | queue->address = (const char *) &queue[1]; | 9828 | queue->address = (const char *) &queue[1]; |
9681 | queue->pd.aged_rtt = GNUNET_TIME_UNIT_FOREVER_REL; | 9829 | queue->pd.aged_rtt = GNUNET_TIME_UNIT_FOREVER_REL; |
9682 | queue->qid = aqm->qid; | 9830 | queue->qid = aqm->qid; |
9683 | queue->neighbour = neighbour; | 9831 | queue->neighbour = neighbour; |
9832 | if (GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED == GNUNET_ntohll (aqm->q_len)) | ||
9833 | queue->unlimited_length = GNUNET_YES; | ||
9834 | queue->q_capacity = GNUNET_ntohll (aqm->q_len); | ||
9684 | memcpy (&queue[1], addr, addr_len); | 9835 | memcpy (&queue[1], addr, addr_len); |
9685 | /* notify monitors about new queue */ | 9836 | /* notify monitors about new queue */ |
9686 | { | 9837 | { |
@@ -9752,10 +9903,14 @@ handle_update_queue_message (void *cls, | |||
9752 | target_queue->mtu = ntohl (msg->mtu); | 9903 | target_queue->mtu = ntohl (msg->mtu); |
9753 | target_queue->cs = msg->cs; | 9904 | target_queue->cs = msg->cs; |
9754 | target_queue->priority = ntohl (msg->priority); | 9905 | target_queue->priority = ntohl (msg->priority); |
9755 | /* The update message indicates how many _additional_ | 9906 | /* The update message indicates how many messages |
9756 | * messages the queue should be able to handle | 9907 | * the queue should be able to handle. |
9757 | */ | 9908 | */ |
9758 | target_queue->queue_length += GNUNET_ntohll (msg->q_len); | 9909 | if (GNUNET_TRANSPORT_QUEUE_LENGTH_UNLIMITED == GNUNET_ntohll (msg->q_len)) |
9910 | target_queue->unlimited_length = GNUNET_YES; | ||
9911 | else | ||
9912 | target_queue->unlimited_length = GNUNET_NO; | ||
9913 | target_queue->q_capacity = GNUNET_ntohll (msg->q_len); | ||
9759 | GNUNET_SERVICE_client_continue (tc->client); | 9914 | GNUNET_SERVICE_client_continue (tc->client); |
9760 | } | 9915 | } |
9761 | 9916 | ||
@@ -10179,8 +10334,18 @@ static void | |||
10179 | shutdown_task (void *cls) | 10334 | shutdown_task (void *cls) |
10180 | { | 10335 | { |
10181 | in_shutdown = GNUNET_YES; | 10336 | in_shutdown = GNUNET_YES; |
10337 | |||
10182 | if (NULL == clients_head) | 10338 | if (NULL == clients_head) |
10183 | do_shutdown (cls); | 10339 | { |
10340 | for (struct TransportClient *tc = clients_head; NULL != tc; tc = tc->next) | ||
10341 | { | ||
10342 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
10343 | "client still connected: %u\n", | ||
10344 | tc->type); | ||
10345 | } | ||
10346 | } | ||
10347 | do_shutdown (cls); | ||
10348 | |||
10184 | } | 10349 | } |
10185 | 10350 | ||
10186 | 10351 | ||
diff --git a/src/transport/test_transport_plugin_cmd_simple_send.c b/src/transport/test_transport_plugin_cmd_simple_send.c index 07255a1a5..b578219ca 100644 --- a/src/transport/test_transport_plugin_cmd_simple_send.c +++ b/src/transport/test_transport_plugin_cmd_simple_send.c | |||
@@ -180,7 +180,8 @@ start_testcase (TESTING_CMD_HELPER_write_cb write_message, char *router_ip, | |||
180 | GNUNET_TESTING_cmd_system_destroy ("system-destroy", | 180 | GNUNET_TESTING_cmd_system_destroy ("system-destroy", |
181 | "system-create"), | 181 | "system-create"), |
182 | GNUNET_TESTING_cmd_local_test_finished ("local-test-finished", | 182 | GNUNET_TESTING_cmd_local_test_finished ("local-test-finished", |
183 | write_message) | 183 | write_message), |
184 | GNUNET_TESTING_cmd_end_without_shutdown () | ||
184 | }; | 185 | }; |
185 | 186 | ||
186 | GNUNET_TESTING_run (NULL, | 187 | GNUNET_TESTING_run (NULL, |
@@ -201,6 +202,10 @@ libgnunet_test_transport_plugin_cmd_simple_send_init (void *cls) | |||
201 | { | 202 | { |
202 | struct GNUNET_TESTING_PluginFunctions *api; | 203 | struct GNUNET_TESTING_PluginFunctions *api; |
203 | 204 | ||
205 | GNUNET_log_setup ("simple-send", | ||
206 | "DEBUG", | ||
207 | NULL); | ||
208 | |||
204 | api = GNUNET_new (struct GNUNET_TESTING_PluginFunctions); | 209 | api = GNUNET_new (struct GNUNET_TESTING_PluginFunctions); |
205 | api->start_testcase = &start_testcase; | 210 | api->start_testcase = &start_testcase; |
206 | api->all_peers_started = &all_peers_started; | 211 | api->all_peers_started = &all_peers_started; |
diff --git a/src/transport/test_transport_plugin_cmd_simple_send_v2.c b/src/transport/test_transport_plugin_cmd_simple_send_v2.c index c79b5c7e2..acfe784d6 100644 --- a/src/transport/test_transport_plugin_cmd_simple_send_v2.c +++ b/src/transport/test_transport_plugin_cmd_simple_send_v2.c | |||
@@ -185,7 +185,8 @@ start_testcase (TESTING_CMD_HELPER_write_cb write_message, char *router_ip, | |||
185 | GNUNET_TESTING_cmd_system_destroy ("system-destroy", | 185 | GNUNET_TESTING_cmd_system_destroy ("system-destroy", |
186 | "system-create"), | 186 | "system-create"), |
187 | GNUNET_TESTING_cmd_local_test_finished ("local-test-finished", | 187 | GNUNET_TESTING_cmd_local_test_finished ("local-test-finished", |
188 | write_message) | 188 | write_message), |
189 | GNUNET_TESTING_cmd_end_without_shutdown () | ||
189 | }; | 190 | }; |
190 | 191 | ||
191 | GNUNET_TESTING_run (NULL, | 192 | GNUNET_TESTING_run (NULL, |
diff --git a/src/transport/test_transport_plugin_cmd_udp_backchannel.c b/src/transport/test_transport_plugin_cmd_udp_backchannel.c index 90e474aea..e2e0b258b 100644 --- a/src/transport/test_transport_plugin_cmd_udp_backchannel.c +++ b/src/transport/test_transport_plugin_cmd_udp_backchannel.c | |||
@@ -58,6 +58,12 @@ char *cfgname; | |||
58 | unsigned int are_all_peers_started; | 58 | unsigned int are_all_peers_started; |
59 | 59 | ||
60 | /** | 60 | /** |
61 | * Flag indicating if all local tests are prepared to finish. | ||
62 | * | ||
63 | */ | ||
64 | unsigned int are_all_local_tests_prepared; | ||
65 | |||
66 | /** | ||
61 | * Flag indicating a received message. | 67 | * Flag indicating a received message. |
62 | */ | 68 | */ |
63 | unsigned int message_received; | 69 | unsigned int message_received; |
@@ -85,6 +91,8 @@ static void | |||
85 | handle_test (void *cls, | 91 | handle_test (void *cls, |
86 | const struct GNUNET_TRANSPORT_TESTING_TestMessage *message) | 92 | const struct GNUNET_TRANSPORT_TESTING_TestMessage *message) |
87 | { | 93 | { |
94 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
95 | "Message received.\n"); | ||
88 | message_received = GNUNET_YES; | 96 | message_received = GNUNET_YES; |
89 | } | 97 | } |
90 | 98 | ||
@@ -104,6 +112,16 @@ all_peers_started () | |||
104 | 112 | ||
105 | 113 | ||
106 | /** | 114 | /** |
115 | * Callback to set the flag indicating all peers are prepared to finish. Will be called via the plugin api. | ||
116 | */ | ||
117 | static void | ||
118 | all_local_tests_prepared () | ||
119 | { | ||
120 | are_all_local_tests_prepared = GNUNET_YES; | ||
121 | } | ||
122 | |||
123 | |||
124 | /** | ||
107 | * Function to start a local test case. | 125 | * Function to start a local test case. |
108 | * | 126 | * |
109 | * @param write_message Callback to send a message to the master loop. | 127 | * @param write_message Callback to send a message to the master loop. |
@@ -179,17 +197,23 @@ start_testcase (TESTING_CMD_HELPER_write_cb write_message, char *router_ip, | |||
179 | "system-create", | 197 | "system-create", |
180 | num, | 198 | num, |
181 | topology), | 199 | topology), |
182 | GNUNET_TRANSPORT_cmd_send_simple_v2 ("send-simple", | 200 | GNUNET_TRANSPORT_cmd_backchannel_check ("backchannel-check", |
183 | "start-peer", | 201 | "start-peer", |
184 | num), | 202 | "system-create", |
185 | GNUNET_TESTING_cmd_block_until_external_trigger ("block-receive", | 203 | num, |
186 | &message_received), | 204 | m_int, |
205 | n_int, | ||
206 | topology), | ||
207 | GNUNET_TESTING_cmd_local_test_prepared ("local-test-prepared", | ||
208 | write_message, | ||
209 | &are_all_local_tests_prepared), | ||
187 | GNUNET_TRANSPORT_cmd_stop_peer ("stop-peer", | 210 | GNUNET_TRANSPORT_cmd_stop_peer ("stop-peer", |
188 | "start-peer"), | 211 | "start-peer"), |
189 | GNUNET_TESTING_cmd_system_destroy ("system-destroy", | 212 | GNUNET_TESTING_cmd_system_destroy ("system-destroy", |
190 | "system-create"), | 213 | "system-create"), |
191 | GNUNET_TESTING_cmd_local_test_finished ("local-test-finished", | 214 | GNUNET_TESTING_cmd_local_test_finished ("local-test-finished", |
192 | write_message) | 215 | write_message), |
216 | GNUNET_TESTING_cmd_end_without_shutdown () | ||
193 | }; | 217 | }; |
194 | 218 | ||
195 | GNUNET_TESTING_run (NULL, | 219 | GNUNET_TESTING_run (NULL, |
@@ -217,6 +241,7 @@ libgnunet_test_transport_plugin_cmd_udp_backchannel_init (void *cls) | |||
217 | api = GNUNET_new (struct GNUNET_TESTING_PluginFunctions); | 241 | api = GNUNET_new (struct GNUNET_TESTING_PluginFunctions); |
218 | api->start_testcase = &start_testcase; | 242 | api->start_testcase = &start_testcase; |
219 | api->all_peers_started = &all_peers_started; | 243 | api->all_peers_started = &all_peers_started; |
244 | api->all_local_tests_prepared = all_local_tests_prepared; | ||
220 | return api; | 245 | return api; |
221 | } | 246 | } |
222 | 247 | ||
diff --git a/src/transport/test_transport_udp_backchannel.sh b/src/transport/test_transport_udp_backchannel.sh index 3322e5853..0c37be469 100755 --- a/src/transport/test_transport_udp_backchannel.sh +++ b/src/transport/test_transport_udp_backchannel.sh | |||
@@ -1,2 +1,4 @@ | |||
1 | #!/bin/bash | 1 | #!/bin/bash |
2 | #exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; valgrind --leak-check=full --track-origins=yes --trace-children=yes --trace-children-skip=/usr/bin/awk,/usr/bin/cut,/usr/bin/seq,/sbin/ip ./test_transport_start_with_config test_transport_udp_backchannel_topo.conf" | ||
2 | exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; ./test_transport_start_with_config test_transport_udp_backchannel_topo.conf" | 3 | exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; ./test_transport_start_with_config test_transport_udp_backchannel_topo.conf" |
4 | # exec unshare -r -nmU bash -c "mount -t tmpfs --make-rshared tmpfs /run/netns; valgrind --leak-check=full --track-origins=yes ./test_transport_start_with_config test_transport_udp_backchannel_topo.conf" | ||
diff --git a/src/transport/transport-testing-cmds.h b/src/transport/transport-testing-cmds.h index ecdabd35f..67e5723f5 100644 --- a/src/transport/transport-testing-cmds.h +++ b/src/transport/transport-testing-cmds.h | |||
@@ -228,22 +228,36 @@ GNUNET_TRANSPORT_cmd_start_peer (const char *label, | |||
228 | struct GNUNET_MQ_MessageHandler *handlers, | 228 | struct GNUNET_MQ_MessageHandler *handlers, |
229 | const char *cfgname); | 229 | const char *cfgname); |
230 | 230 | ||
231 | |||
231 | struct GNUNET_TESTING_Command | 232 | struct GNUNET_TESTING_Command |
232 | GNUNET_TRANSPORT_cmd_stop_peer (const char *label, | 233 | GNUNET_TRANSPORT_cmd_stop_peer (const char *label, |
233 | const char *start_label); | 234 | const char *start_label); |
234 | 235 | ||
236 | |||
235 | struct GNUNET_TESTING_Command | 237 | struct GNUNET_TESTING_Command |
236 | GNUNET_TRANSPORT_cmd_connect_peers (const char *label, | 238 | GNUNET_TRANSPORT_cmd_connect_peers (const char *label, |
237 | const char *start_peer_label, | 239 | const char *start_peer_label, |
238 | const char *create_label, | 240 | const char *create_label, |
239 | uint32_t num); | 241 | uint32_t num); |
240 | 242 | ||
243 | |||
241 | struct GNUNET_TESTING_Command | 244 | struct GNUNET_TESTING_Command |
242 | GNUNET_TRANSPORT_cmd_connect_peers_v2 (const char *label, | 245 | GNUNET_TRANSPORT_cmd_connect_peers_v2 (const char *label, |
243 | const char *start_peer_label, | 246 | const char *start_peer_label, |
244 | const char *create_label, | 247 | const char *create_label, |
245 | uint32_t num); | 248 | uint32_t num); |
246 | 249 | ||
250 | |||
251 | /** | ||
252 | * Create command. | ||
253 | * | ||
254 | * @param label name for command. | ||
255 | * @param start_peer_label Label of the cmd to start a peer. | ||
256 | * @param create_label Label of the cmd to create the testing system. | ||
257 | * @param num Number globally identifying the node. | ||
258 | * @param The topology for the test setup. | ||
259 | * @return command. | ||
260 | */ | ||
247 | struct GNUNET_TESTING_Command | 261 | struct GNUNET_TESTING_Command |
248 | GNUNET_TRANSPORT_cmd_connect_peers_v3 (const char *label, | 262 | GNUNET_TRANSPORT_cmd_connect_peers_v3 (const char *label, |
249 | const char *start_peer_label, | 263 | const char *start_peer_label, |
@@ -252,6 +266,40 @@ GNUNET_TRANSPORT_cmd_connect_peers_v3 (const char *label, | |||
252 | struct GNUNET_TESTING_NetjailTopology * | 266 | struct GNUNET_TESTING_NetjailTopology * |
253 | topology); | 267 | topology); |
254 | 268 | ||
269 | |||
270 | /** | ||
271 | * Create command. | ||
272 | * | ||
273 | * @param label name for command. | ||
274 | * @param start_peer_label Label of the cmd to start a peer. | ||
275 | * @param create_label Label of the cmd to create the testing system. | ||
276 | * @param num Number globally identifying the node. | ||
277 | * @param node_n The number of the node in a network namespace. | ||
278 | * @param namespace_n The number of the network namespace. | ||
279 | * @param The topology for the test setup. | ||
280 | * @return command. | ||
281 | */ | ||
282 | struct GNUNET_TESTING_Command | ||
283 | GNUNET_TRANSPORT_cmd_backchannel_check (const char *label, | ||
284 | const char *start_peer_label, | ||
285 | const char *create_label, | ||
286 | uint32_t num, | ||
287 | unsigned int node_n, | ||
288 | unsigned int namespace_n, | ||
289 | struct GNUNET_TESTING_NetjailTopology * | ||
290 | topology); | ||
291 | |||
292 | |||
293 | /** | ||
294 | * Create command. | ||
295 | * | ||
296 | * @param label name for command. | ||
297 | * @param m The number of the local node of the actual network namespace. | ||
298 | * @param n The number of the actual namespace. | ||
299 | * @param num Number globally identifying the node. | ||
300 | * @param start_peer_label Label of the cmd to start a peer. | ||
301 | * @return command. | ||
302 | */ | ||
255 | struct GNUNET_TESTING_Command | 303 | struct GNUNET_TESTING_Command |
256 | GNUNET_TRANSPORT_cmd_send_simple (const char *label, | 304 | GNUNET_TRANSPORT_cmd_send_simple (const char *label, |
257 | char *m, | 305 | char *m, |
@@ -263,10 +311,8 @@ GNUNET_TRANSPORT_cmd_send_simple (const char *label, | |||
263 | * Create command. | 311 | * Create command. |
264 | * | 312 | * |
265 | * @param label name for command. | 313 | * @param label name for command. |
266 | * @param m The number of the local node of the actual network namespace. | ||
267 | * @param n The number of the actual namespace. | ||
268 | * @param num Number globally identifying the node. | ||
269 | * @param start_peer_label Label of the cmd to start a peer. | 314 | * @param start_peer_label Label of the cmd to start a peer. |
315 | * @param num Number globally identifying the node. | ||
270 | * @return command. | 316 | * @return command. |
271 | */ | 317 | */ |
272 | struct GNUNET_TESTING_Command | 318 | struct GNUNET_TESTING_Command |
@@ -274,6 +320,26 @@ GNUNET_TRANSPORT_cmd_send_simple_v2 (const char *label, | |||
274 | const char *start_peer_label, | 320 | const char *start_peer_label, |
275 | uint32_t num); | 321 | uint32_t num); |
276 | 322 | ||
323 | |||
324 | /** | ||
325 | * Create command. | ||
326 | * | ||
327 | * @param label name for command. | ||
328 | * @param start_peer_label Label of the cmd to start a peer. | ||
329 | * @param start_peer_label Label of the cmd which started the test system. | ||
330 | * @param num Number globally identifying the node. | ||
331 | * @param The topology for the test setup. | ||
332 | * @return command. | ||
333 | */ | ||
334 | struct GNUNET_TESTING_Command | ||
335 | GNUNET_TRANSPORT_cmd_send_simple_v3 (const char *label, | ||
336 | const char *start_peer_label, | ||
337 | const char *create_label, | ||
338 | uint32_t num, | ||
339 | struct GNUNET_TESTING_NetjailTopology * | ||
340 | topology); | ||
341 | |||
342 | |||
277 | int | 343 | int |
278 | GNUNET_TRANSPORT_get_trait_peer_id (const struct | 344 | GNUNET_TRANSPORT_get_trait_peer_id (const struct |
279 | GNUNET_TESTING_Command *cmd, | 345 | GNUNET_TESTING_Command *cmd, |
diff --git a/src/transport/transport_api2_communication.c b/src/transport/transport_api2_communication.c index 446add6f6..2a80db87b 100644 --- a/src/transport/transport_api2_communication.c +++ b/src/transport/transport_api2_communication.c | |||
@@ -904,6 +904,10 @@ GNUNET_TRANSPORT_communicator_receive ( | |||
904 | struct GNUNET_TRANSPORT_IncomingMessage *im; | 904 | struct GNUNET_TRANSPORT_IncomingMessage *im; |
905 | uint16_t msize; | 905 | uint16_t msize; |
906 | 906 | ||
907 | |||
908 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
909 | "communicator receive\n"); | ||
910 | |||
907 | if (NULL == ch->mq) | 911 | if (NULL == ch->mq) |
908 | return GNUNET_SYSERR; | 912 | return GNUNET_SYSERR; |
909 | if ((NULL == cb) && (GNUNET_MQ_get_length (ch->mq) >= ch->max_queue_length)) | 913 | if ((NULL == cb) && (GNUNET_MQ_get_length (ch->mq) >= ch->max_queue_length)) |
@@ -986,6 +990,9 @@ GNUNET_TRANSPORT_communicator_mq_add ( | |||
986 | { | 990 | { |
987 | struct GNUNET_TRANSPORT_QueueHandle *qh; | 991 | struct GNUNET_TRANSPORT_QueueHandle *qh; |
988 | 992 | ||
993 | // Do not notify the service if there is no intial capacity. | ||
994 | GNUNET_assert (0 < q_len); | ||
995 | |||
989 | qh = GNUNET_new (struct GNUNET_TRANSPORT_QueueHandle); | 996 | qh = GNUNET_new (struct GNUNET_TRANSPORT_QueueHandle); |
990 | qh->ch = ch; | 997 | qh->ch = ch; |
991 | qh->peer = *peer; | 998 | qh->peer = *peer; |
@@ -1106,7 +1113,7 @@ GNUNET_TRANSPORT_communicator_address_remove ( | |||
1106 | */ | 1113 | */ |
1107 | void | 1114 | void |
1108 | GNUNET_TRANSPORT_communicator_address_remove_all ( | 1115 | GNUNET_TRANSPORT_communicator_address_remove_all ( |
1109 | struct GNUNET_TRANSPORT_CommunicatorHandle *ch) | 1116 | struct GNUNET_TRANSPORT_CommunicatorHandle *ch) |
1110 | { | 1117 | { |
1111 | for (struct GNUNET_TRANSPORT_AddressIdentifier *ai = ch->ai_head; NULL != ai; | 1118 | for (struct GNUNET_TRANSPORT_AddressIdentifier *ai = ch->ai_head; NULL != ai; |
1112 | ai = ai->next) | 1119 | ai = ai->next) |
diff --git a/src/transport/transport_api_cmd_backchannel_check.c b/src/transport/transport_api_cmd_backchannel_check.c new file mode 100644 index 000000000..da44e91ca --- /dev/null +++ b/src/transport/transport_api_cmd_backchannel_check.c | |||
@@ -0,0 +1,628 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet | ||
3 | Copyright (C) 2021 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software: you can redistribute it and/or modify it | ||
6 | under the terms of the GNU Affero General Public License as published | ||
7 | by the Free Software Foundation, either version 3 of the License, | ||
8 | or (at your option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Affero General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Affero General Public License | ||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
17 | |||
18 | SPDX-License-Identifier: AGPL3.0-or-later | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @file testing_api_cmd_backchannel_check.c | ||
23 | * @brief cmd to start a peer. | ||
24 | * @author t3sserakt | ||
25 | */ | ||
26 | #include "platform.h" | ||
27 | #include "gnunet_common.h" | ||
28 | #include "gnunet_util_lib.h" | ||
29 | #include "gnunet_testing_ng_lib.h" | ||
30 | #include "gnunet_transport_application_service.h" | ||
31 | #include "gnunet_hello_lib.h" | ||
32 | #include "gnunet_transport_service.h" | ||
33 | #include "transport-testing-cmds.h" | ||
34 | |||
35 | /** | ||
36 | * Generic logging shortcut | ||
37 | */ | ||
38 | #define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__) | ||
39 | |||
40 | #define UDP "udp" | ||
41 | |||
42 | /** | ||
43 | * Maximum length allowed for line input. | ||
44 | */ | ||
45 | #define MAX_LINE_LENGTH 1024 | ||
46 | |||
47 | /** | ||
48 | * Struct to store information needed in callbacks. | ||
49 | * | ||
50 | */ | ||
51 | struct CheckState | ||
52 | { | ||
53 | /** | ||
54 | * The number of the node in a network namespace. | ||
55 | */ | ||
56 | unsigned int node_n; | ||
57 | |||
58 | /** | ||
59 | * The number of the network namespace. | ||
60 | */ | ||
61 | unsigned int namespace_n; | ||
62 | |||
63 | /** | ||
64 | * The testing system of this node. | ||
65 | */ | ||
66 | struct GNUNET_TESTING_System *tl_system; | ||
67 | |||
68 | // Label of the cmd which started the test system. | ||
69 | const char *create_label; | ||
70 | |||
71 | /** | ||
72 | * Number globally identifying the node. | ||
73 | * | ||
74 | */ | ||
75 | uint32_t num; | ||
76 | |||
77 | /** | ||
78 | * Label of the cmd to start a peer. | ||
79 | * | ||
80 | */ | ||
81 | const char *start_peer_label; | ||
82 | |||
83 | /** | ||
84 | * The topology of the test setup. | ||
85 | */ | ||
86 | struct GNUNET_TESTING_NetjailTopology *topology; | ||
87 | |||
88 | /** | ||
89 | * Connections to other peers. | ||
90 | */ | ||
91 | struct GNUNET_TESTING_NodeConnection *node_connections_head; | ||
92 | |||
93 | /** | ||
94 | * Number of connections. | ||
95 | */ | ||
96 | unsigned int con_num; | ||
97 | |||
98 | /** | ||
99 | * Number of received backchannel messages. | ||
100 | */ | ||
101 | unsigned int received_backchannel_msgs; | ||
102 | |||
103 | /** | ||
104 | * Array with search strings. | ||
105 | */ | ||
106 | char **search_string; | ||
107 | |||
108 | /** | ||
109 | * File handle for log file. | ||
110 | */ | ||
111 | struct GNUNET_DISK_FileHandle *fh; | ||
112 | |||
113 | /** | ||
114 | * Task which handles the reading | ||
115 | */ | ||
116 | struct GNUNET_SCHEDULER_Task *task; | ||
117 | |||
118 | /** | ||
119 | * Stream to read log file lines. | ||
120 | */ | ||
121 | FILE *stream; | ||
122 | |||
123 | /** | ||
124 | * Did we get all bachchannel messages. | ||
125 | */ | ||
126 | enum GNUNET_GenericReturnValue finished; | ||
127 | }; | ||
128 | |||
129 | /** | ||
130 | * | ||
131 | * @param cls The cmd state CheckState. | ||
132 | */ | ||
133 | static void | ||
134 | read_from_log (void *cls) | ||
135 | { | ||
136 | struct CheckState *cs = cls; | ||
137 | char line[MAX_LINE_LENGTH + 1]; | ||
138 | char *search_string; | ||
139 | |||
140 | |||
141 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
142 | "read_from_log\n"); | ||
143 | |||
144 | cs->fh = GNUNET_DISK_file_open ("test.out", | ||
145 | GNUNET_DISK_OPEN_READ, | ||
146 | GNUNET_DISK_PERM_USER_READ); | ||
147 | |||
148 | cs->task = NULL; | ||
149 | |||
150 | /* read message from line and handle it */ | ||
151 | cs->stream = fdopen (cs->fh->fd, "r"); | ||
152 | memset (line, 0, MAX_LINE_LENGTH + 1); | ||
153 | |||
154 | // fgets (line, MAX_LINE_LENGTH, cs->stream); | ||
155 | // while (NULL != line && 0 != strcmp (line, ""))// '\0' != line[0]) | ||
156 | while (NULL != fgets (line, MAX_LINE_LENGTH, cs->stream)) | ||
157 | { | ||
158 | /*LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
159 | "cs->received_backchannel_msgs: %u\n", | ||
160 | cs->received_backchannel_msgs);*/ | ||
161 | /*if (NULL == strstr (line, "line")) | ||
162 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
163 | "line: %s", | ||
164 | line);*/ | ||
165 | |||
166 | |||
167 | for (int i = 0; i < cs->con_num; i++) | ||
168 | { | ||
169 | search_string = cs->search_string[i]; | ||
170 | /*LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
171 | "search %u %u: %s %p\n", | ||
172 | i, | ||
173 | cs->con_num, | ||
174 | cs->search_string[i], | ||
175 | cs->search_string); | ||
176 | fprintf (stderr, | ||
177 | line);*/ | ||
178 | if (NULL != strstr (line, | ||
179 | search_string)) | ||
180 | // "Delivering backchannel message from 4TTC to F7B5 of type 1460 to udp")) | ||
181 | // cs->search_string[i])) | ||
182 | { | ||
183 | cs->received_backchannel_msgs++; | ||
184 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
185 | "received_backchannel_msgs %u con_num %u\n", | ||
186 | cs->received_backchannel_msgs, | ||
187 | cs->con_num); | ||
188 | if (cs->received_backchannel_msgs == cs->con_num) | ||
189 | { | ||
190 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
191 | "search finished %lu %lu %u\n", | ||
192 | strlen (cs->search_string[i]), | ||
193 | strlen ( | ||
194 | "Delivering backchannel message from 4TTC to F7B5 of type 1460 to udp"), | ||
195 | strcmp ( | ||
196 | "Delivering backchannel message from 4TTC to F7B5 of type 1460 to udp", | ||
197 | cs->search_string[i])); | ||
198 | if (NULL != strstr (line, | ||
199 | cs->search_string[i])) | ||
200 | { | ||
201 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
202 | "gaga\n"); | ||
203 | } | ||
204 | cs->finished = GNUNET_YES; | ||
205 | fclose (cs->stream); | ||
206 | return; | ||
207 | } | ||
208 | } | ||
209 | } | ||
210 | } | ||
211 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
212 | "read_from_log end\n"); | ||
213 | fclose (cs->stream); | ||
214 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS, | ||
215 | &read_from_log, | ||
216 | cs); | ||
217 | /*if (NULL == fgets (line, MAX_LINE_LENGTH, cs->stream)) | ||
218 | { | ||
219 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
220 | "read null\n"); | ||
221 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, | ||
222 | &read_from_log, | ||
223 | cs); | ||
224 | return; | ||
225 | }*/ | ||
226 | /*else { | ||
227 | cs->task = | ||
228 | GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, | ||
229 | cs->fh, | ||
230 | &read_from_log, | ||
231 | cs); | ||
232 | |||
233 | |||
234 | }*/ | ||
235 | } | ||
236 | |||
237 | |||
238 | static enum GNUNET_GenericReturnValue | ||
239 | will_the_other_node_connect_via_udp ( | ||
240 | struct CheckState *cs, | ||
241 | const struct GNUNET_TESTING_NetjailNode *node) | ||
242 | // struct GNUNET_TESTING_NodeConnection *connection) | ||
243 | { | ||
244 | // struct GNUNET_TESTING_NetjailTopology *topology = cs->topology; | ||
245 | // unsigned int node_n = connection->node_n; | ||
246 | // unsigned int namespace_n = connection->namespace_n; | ||
247 | // struct GNUNET_HashCode hc; | ||
248 | // struct GNUNET_ShortHashCode *key = GNUNET_new (struct GNUNET_ShortHashCode); | ||
249 | // struct GNUNET_HashCode hc_namespace; | ||
250 | /*struct GNUNET_ShortHashCode *key_namespace = GNUNET_new (struct | ||
251 | GNUNET_ShortHashCode);*/ | ||
252 | // struct GNUNET_TESTING_NetjailNode *node; | ||
253 | struct GNUNET_TESTING_NodeConnection *pos_connection; | ||
254 | struct GNUNET_TESTING_AddressPrefix *pos_prefix; | ||
255 | // struct GNUNET_TESTING_NetjailNamespace *namespace; | ||
256 | // struct GNUNET_CONTAINER_MultiShortmap *map; | ||
257 | |||
258 | /* if (0 == connection->namespace_n) */ | ||
259 | /* { */ | ||
260 | /* map = topology->map_globals; */ | ||
261 | /* } */ | ||
262 | /* else */ | ||
263 | /* { */ | ||
264 | /* GNUNET_CRYPTO_hash (&namespace_n, sizeof(namespace_n), &hc_namespace); */ | ||
265 | /* memcpy (key_namespace, */ | ||
266 | /* &hc_namespace, */ | ||
267 | /* sizeof (*key_namespace)); */ | ||
268 | /* if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains ( */ | ||
269 | /* topology->map_namespaces, */ | ||
270 | /* key_namespace)) */ | ||
271 | /* { */ | ||
272 | /* namespace = GNUNET_CONTAINER_multishortmap_get (topology->map_namespaces, */ | ||
273 | /* key_namespace); */ | ||
274 | /* map = namespace->nodes; */ | ||
275 | /* } */ | ||
276 | /* else */ | ||
277 | /* GNUNET_assert (0); */ | ||
278 | /* } */ | ||
279 | |||
280 | /* GNUNET_CRYPTO_hash (&node_n, sizeof(node_n), &hc); */ | ||
281 | /* memcpy (key, */ | ||
282 | /* &hc, */ | ||
283 | /* sizeof (*key)); */ | ||
284 | /* if (GNUNET_YES == GNUNET_CONTAINER_multishortmap_contains ( */ | ||
285 | /* map, */ | ||
286 | /* key)) */ | ||
287 | /* { */ | ||
288 | /* node = GNUNET_CONTAINER_multishortmap_get (cs->topology->map_globals, */ | ||
289 | /* key); */ | ||
290 | /* for (pos_connection = node->node_connections_head; NULL != pos_connection; */ | ||
291 | /* pos_connection = pos_connection->next) */ | ||
292 | /* { */ | ||
293 | /* if ((node->namespace_n == pos_connection->namespace_n) && */ | ||
294 | /* (node->node_n == pos_connection->node_n) ) */ | ||
295 | /* { */ | ||
296 | /* for (pos_prefix = pos_connection->address_prefixes_head; NULL != */ | ||
297 | /* pos_prefix; */ | ||
298 | /* pos_prefix = */ | ||
299 | /* pos_prefix->next) */ | ||
300 | /* { */ | ||
301 | /* if (0 == strcmp (UDP, pos_prefix->address_prefix)) */ | ||
302 | /* { */ | ||
303 | /* return GNUNET_YES; */ | ||
304 | /* } */ | ||
305 | /* } */ | ||
306 | /* } */ | ||
307 | /* } */ | ||
308 | /* } */ | ||
309 | |||
310 | for (pos_connection = node->node_connections_head; NULL != pos_connection; | ||
311 | pos_connection = pos_connection->next) | ||
312 | { | ||
313 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
314 | "connect via udp %u %u %u %u\n", | ||
315 | node->namespace_n, | ||
316 | cs->namespace_n, | ||
317 | node->node_n, | ||
318 | cs->node_n); | ||
319 | if ((pos_connection->namespace_n == cs->namespace_n) && | ||
320 | (pos_connection->node_n == cs->node_n) ) | ||
321 | { | ||
322 | for (pos_prefix = pos_connection->address_prefixes_head; NULL != | ||
323 | pos_prefix; | ||
324 | pos_prefix = | ||
325 | pos_prefix->next) | ||
326 | { | ||
327 | if (0 == strcmp (UDP, pos_prefix->address_prefix)) | ||
328 | { | ||
329 | return GNUNET_YES; | ||
330 | } | ||
331 | } | ||
332 | } | ||
333 | } | ||
334 | |||
335 | return GNUNET_NO; | ||
336 | } | ||
337 | |||
338 | static void | ||
339 | add_search_string (struct CheckState *cs, const struct | ||
340 | GNUNET_TESTING_NetjailNode *node) | ||
341 | { | ||
342 | unsigned int num; | ||
343 | struct GNUNET_PeerIdentity *peer; | ||
344 | struct GNUNET_PeerIdentity *us; | ||
345 | char *buf; | ||
346 | char *part_one = "Delivering backchannel message from "; | ||
347 | char *part_two = " to "; | ||
348 | char *part_three = " of type 1460 to udp"; | ||
349 | char *peer_id; | ||
350 | char *us_id; | ||
351 | |||
352 | if (0 == node->namespace_n) | ||
353 | num = node->node_n; | ||
354 | else | ||
355 | num = (node->namespace_n - 1) * cs->topology->nodes_m + node->node_n | ||
356 | + cs->topology->nodes_x; | ||
357 | |||
358 | // num = GNUNET_TESTING_calculate_num (pos_connection, cs->topology); | ||
359 | peer = GNUNET_TESTING_get_pub_key (num, cs->tl_system); | ||
360 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
361 | "peer: %s num %u\n", | ||
362 | GNUNET_i2s (peer), | ||
363 | num); | ||
364 | us = GNUNET_TESTING_get_pub_key (cs->num, cs->tl_system); | ||
365 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
366 | "us: %s cs->num %d\n", | ||
367 | GNUNET_i2s (us), | ||
368 | cs->num); | ||
369 | |||
370 | GNUNET_asprintf (&peer_id, | ||
371 | "%s", | ||
372 | GNUNET_i2s (peer)); | ||
373 | GNUNET_asprintf (&us_id, | ||
374 | "%s", | ||
375 | GNUNET_i2s (us)); | ||
376 | |||
377 | if (0 < GNUNET_asprintf (&buf, | ||
378 | "%s%s%s%s%s", | ||
379 | part_one, | ||
380 | us_id, | ||
381 | part_two, | ||
382 | peer_id, | ||
383 | part_three)) | ||
384 | { | ||
385 | GNUNET_array_append (cs->search_string, | ||
386 | cs->con_num, | ||
387 | buf); | ||
388 | /*LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
389 | "con_num: %u search: %s %p\n", | ||
390 | cs->con_num, | ||
391 | cs->search_string[cs->con_num - 1], | ||
392 | cs->search_string);*/ | ||
393 | } | ||
394 | else | ||
395 | GNUNET_assert (0); | ||
396 | } | ||
397 | |||
398 | |||
399 | /** | ||
400 | * The run method of this cmd will connect to peers. | ||
401 | * | ||
402 | */ | ||
403 | static void | ||
404 | backchannel_check_run (void *cls, | ||
405 | const struct GNUNET_TESTING_Command *cmd, | ||
406 | struct GNUNET_TESTING_Interpreter *is) | ||
407 | { | ||
408 | struct CheckState *cs = cls; | ||
409 | // char *buf; | ||
410 | // char *part_one = "Delivering backchannel message from "; | ||
411 | // char *part_two = " of type 1460 to udp"; | ||
412 | const struct GNUNET_TESTING_Command *system_cmd; | ||
413 | struct GNUNET_TESTING_System *tl_system; | ||
414 | const struct GNUNET_TESTING_Command *peer1_cmd; | ||
415 | struct GNUNET_TRANSPORT_ApplicationHandle *ah; | ||
416 | // struct GNUNET_PeerIdentity *peer; | ||
417 | // uint32_t num; | ||
418 | // struct GNUNET_TESTING_NodeConnection *pos_connection; | ||
419 | // unsigned int con_num = 0; | ||
420 | struct GNUNET_CONTAINER_MultiShortmapIterator *node_it; | ||
421 | struct GNUNET_CONTAINER_MultiShortmapIterator *namespace_it; | ||
422 | struct GNUNET_ShortHashCode node_key; | ||
423 | struct GNUNET_ShortHashCode namespace_key; | ||
424 | const struct GNUNET_TESTING_NetjailNode *node; | ||
425 | const struct GNUNET_TESTING_NetjailNamespace *namespace; | ||
426 | |||
427 | peer1_cmd = GNUNET_TESTING_interpreter_lookup_command ( | ||
428 | cs->start_peer_label); | ||
429 | GNUNET_TRANSPORT_get_trait_application_handle_v2 (peer1_cmd, | ||
430 | &ah); | ||
431 | |||
432 | system_cmd = GNUNET_TESTING_interpreter_lookup_command (cs->create_label); | ||
433 | GNUNET_TESTING_get_trait_test_system (system_cmd, | ||
434 | &tl_system); | ||
435 | |||
436 | cs->tl_system = tl_system; | ||
437 | |||
438 | cs->node_connections_head = GNUNET_TESTING_get_connections (cs->num, | ||
439 | cs->topology); | ||
440 | |||
441 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
442 | "check run\n"); | ||
443 | |||
444 | |||
445 | node_it = GNUNET_CONTAINER_multishortmap_iterator_create ( | ||
446 | cs->topology->map_globals); | ||
447 | |||
448 | while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next (node_it, | ||
449 | &node_key, | ||
450 | (const | ||
451 | void**) & | ||
452 | node)) | ||
453 | { | ||
454 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
455 | "namespace_n %u node_n %u\n", | ||
456 | node->namespace_n, | ||
457 | node->node_n); | ||
458 | if (GNUNET_YES == will_the_other_node_connect_via_udp (cs, node)) | ||
459 | { | ||
460 | add_search_string (cs, node); | ||
461 | } | ||
462 | } | ||
463 | namespace_it = GNUNET_CONTAINER_multishortmap_iterator_create ( | ||
464 | cs->topology->map_namespaces); | ||
465 | while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next ( | ||
466 | namespace_it, | ||
467 | &namespace_key, | ||
468 | (const | ||
469 | void**) &namespace)) | ||
470 | { | ||
471 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
472 | "namespace_n %u\n", | ||
473 | node->namespace_n); | ||
474 | node_it = GNUNET_CONTAINER_multishortmap_iterator_create ( | ||
475 | namespace->nodes); | ||
476 | while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next (node_it, | ||
477 | &node_key, | ||
478 | (const | ||
479 | void**) | ||
480 | &node)) | ||
481 | { | ||
482 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
483 | "namespace_n %u node_n %u\n", | ||
484 | node->namespace_n, | ||
485 | node->node_n); | ||
486 | if (GNUNET_YES == will_the_other_node_connect_via_udp (cs, node)) | ||
487 | { | ||
488 | add_search_string (cs, node); | ||
489 | } | ||
490 | } | ||
491 | } | ||
492 | /* for (pos_connection = cs->node_connections_head; NULL != pos_connection; */ | ||
493 | /* pos_connection = pos_connection->next) */ | ||
494 | /* { */ | ||
495 | |||
496 | /* if (GNUNET_YES == will_the_other_node_connect_via_udp (cs, node)) */ | ||
497 | /* { */ | ||
498 | /* num = GNUNET_TESTING_calculate_num (pos_connection, cs->topology); */ | ||
499 | /* peer = GNUNET_TESTING_get_pub_key (num, tl_system); */ | ||
500 | /* LOG (GNUNET_ERROR_TYPE_DEBUG, */ | ||
501 | /* "peer: %s\n", */ | ||
502 | /* GNUNET_i2s (peer)); */ | ||
503 | |||
504 | /* if (0 < GNUNET_asprintf (&buf, */ | ||
505 | /* "%s%s%s", */ | ||
506 | /* part_one, */ | ||
507 | /* GNUNET_i2s (peer), */ | ||
508 | /* part_two)) */ | ||
509 | /* { */ | ||
510 | /* GNUNET_array_append (cs->search_string, */ | ||
511 | /* con_num, */ | ||
512 | /* buf); */ | ||
513 | /* /\*LOG (GNUNET_ERROR_TYPE_DEBUG, */ | ||
514 | /* "con_num: %u search: %s %p\n", */ | ||
515 | /* con_num, */ | ||
516 | /* cs->search_string[con_num - 1], */ | ||
517 | /* cs->search_string);*\/ */ | ||
518 | /* } */ | ||
519 | /* else */ | ||
520 | /* GNUNET_assert (0); */ | ||
521 | /* } */ | ||
522 | |||
523 | |||
524 | /* } */ | ||
525 | // cs->con_num = con_num; | ||
526 | if (0 != cs->con_num) | ||
527 | { | ||
528 | cs->task = | ||
529 | GNUNET_SCHEDULER_add_now (&read_from_log, | ||
530 | cs); | ||
531 | } | ||
532 | else | ||
533 | cs->finished = GNUNET_YES; | ||
534 | |||
535 | } | ||
536 | |||
537 | |||
538 | /** | ||
539 | * The finish function of this cmd will check if the peers we are trying to | ||
540 | * connect to are in the connected peers map of the start peer cmd for this peer. | ||
541 | * | ||
542 | */ | ||
543 | static int | ||
544 | backchannel_check_finish (void *cls, | ||
545 | GNUNET_SCHEDULER_TaskCallback cont, | ||
546 | void *cont_cls) | ||
547 | { | ||
548 | struct CheckState *cs = cls; | ||
549 | |||
550 | if (cs->finished) | ||
551 | { | ||
552 | cont (cont_cls); | ||
553 | } | ||
554 | return cs->finished; | ||
555 | } | ||
556 | |||
557 | |||
558 | /** | ||
559 | * Trait function of this cmd does nothing. | ||
560 | * | ||
561 | */ | ||
562 | static int | ||
563 | backchannel_check_traits (void *cls, | ||
564 | const void **ret, | ||
565 | const char *trait, | ||
566 | unsigned int index) | ||
567 | { | ||
568 | return GNUNET_OK; | ||
569 | } | ||
570 | |||
571 | |||
572 | /** | ||
573 | * The cleanup function of this cmd frees resources the cmd allocated. | ||
574 | * | ||
575 | */ | ||
576 | static void | ||
577 | backchannel_check_cleanup (void *cls, | ||
578 | const struct GNUNET_TESTING_Command *cmd) | ||
579 | { | ||
580 | struct ConnectPeersState *cs = cls; | ||
581 | |||
582 | GNUNET_free (cs); | ||
583 | } | ||
584 | |||
585 | |||
586 | /** | ||
587 | * Create command. | ||
588 | * | ||
589 | * @param label name for command. | ||
590 | * @param start_peer_label Label of the cmd to start a peer. | ||
591 | * @param create_label Label of the cmd to create the testing system. | ||
592 | * @param num Number globally identifying the node. | ||
593 | * @param node_n The number of the node in a network namespace. | ||
594 | * @param namespace_n The number of the network namespace. | ||
595 | * @param The topology for the test setup. | ||
596 | * @return command. | ||
597 | */ | ||
598 | struct GNUNET_TESTING_Command | ||
599 | GNUNET_TRANSPORT_cmd_backchannel_check (const char *label, | ||
600 | const char *start_peer_label, | ||
601 | const char *create_label, | ||
602 | uint32_t num, | ||
603 | unsigned int node_n, | ||
604 | unsigned int namespace_n, | ||
605 | struct GNUNET_TESTING_NetjailTopology * | ||
606 | topology) | ||
607 | { | ||
608 | struct CheckState *cs; | ||
609 | |||
610 | cs = GNUNET_new (struct CheckState); | ||
611 | cs->start_peer_label = start_peer_label; | ||
612 | cs->num = num; | ||
613 | cs->create_label = create_label; | ||
614 | cs->topology = topology; | ||
615 | cs->node_n = node_n; | ||
616 | cs->namespace_n = namespace_n; | ||
617 | |||
618 | struct GNUNET_TESTING_Command cmd = { | ||
619 | .cls = cs, | ||
620 | .label = label, | ||
621 | .run = &backchannel_check_run, | ||
622 | .finish = &backchannel_check_finish, | ||
623 | .cleanup = &backchannel_check_cleanup, | ||
624 | .traits = &backchannel_check_traits | ||
625 | }; | ||
626 | |||
627 | return cmd; | ||
628 | } | ||
diff --git a/src/transport/transport_api_cmd_connecting_peers.c b/src/transport/transport_api_cmd_connecting_peers.c index 09ca9e54c..39c7db450 100644 --- a/src/transport/transport_api_cmd_connecting_peers.c +++ b/src/transport/transport_api_cmd_connecting_peers.c | |||
@@ -91,7 +91,7 @@ connect_peers_run (void *cls, | |||
91 | char *hello; | 91 | char *hello; |
92 | // size_t *hello_size; | 92 | // size_t *hello_size; |
93 | enum GNUNET_NetworkType nt = 0; | 93 | enum GNUNET_NetworkType nt = 0; |
94 | char *peer_id; | 94 | // char *peer_id; |
95 | struct GNUNET_PeerIdentity *id; | 95 | struct GNUNET_PeerIdentity *id; |
96 | struct GNUNET_PeerIdentity *other = GNUNET_new (struct GNUNET_PeerIdentity); | 96 | struct GNUNET_PeerIdentity *other = GNUNET_new (struct GNUNET_PeerIdentity); |
97 | uint32_t num; | 97 | uint32_t num; |
@@ -122,12 +122,12 @@ connect_peers_run (void *cls, | |||
122 | if (2 == num) | 122 | if (2 == num) |
123 | { | 123 | { |
124 | addr = "tcp-192.168.15.2:60002"; | 124 | addr = "tcp-192.168.15.2:60002"; |
125 | peer_id = "F2F3X9G1YNCTXKK7A4J6M4ZM4BBSKC9DEXZVHCWQ475M0C7PNWCG"; | 125 | // peer_id = "F2F3X9G1YNCTXKK7A4J6M4ZM4BBSKC9DEXZVHCWQ475M0C7PNWCG"; |
126 | } | 126 | } |
127 | else | 127 | else |
128 | { | 128 | { |
129 | addr = "tcp-192.168.15.1:60002"; | 129 | addr = "tcp-192.168.15.1:60002"; |
130 | peer_id = "4TTC9WBSVP9RJT6DVEZ7E0TDW7TQXC11NR1EMR2F8ARS87WZ2730"; | 130 | // peer_id = "4TTC9WBSVP9RJT6DVEZ7E0TDW7TQXC11NR1EMR2F8ARS87WZ2730"; |
131 | } | 131 | } |
132 | 132 | ||
133 | priv_key = GNUNET_TESTING_hostkey_get (tl_system, | 133 | priv_key = GNUNET_TESTING_hostkey_get (tl_system, |
@@ -137,16 +137,16 @@ connect_peers_run (void *cls, | |||
137 | GNUNET_CRYPTO_eddsa_key_get_public (priv_key, | 137 | GNUNET_CRYPTO_eddsa_key_get_public (priv_key, |
138 | pub_key); | 138 | pub_key); |
139 | 139 | ||
140 | GNUNET_CRYPTO_eddsa_public_key_from_string (peer_id, | 140 | /*GNUNET_CRYPTO_eddsa_public_key_from_string (peer_id, |
141 | strlen (peer_id), | 141 | strlen (peer_id), |
142 | &peer->public_key); | 142 | &peer->public_key);*/ |
143 | 143 | ||
144 | peer->public_key = *pub_key; | 144 | peer->public_key = *pub_key; |
145 | 145 | ||
146 | LOG (GNUNET_ERROR_TYPE_ERROR, | 146 | LOG (GNUNET_ERROR_TYPE_ERROR, |
147 | "\nnum: %u\n peer_id: %s\n pub_key %s\n", | 147 | "num: %u id: %s pub_key %s\n", |
148 | num, | 148 | num, |
149 | peer_id, | 149 | GNUNET_i2s_full (id), |
150 | GNUNET_CRYPTO_eddsa_public_key_to_string (pub_key)); | 150 | GNUNET_CRYPTO_eddsa_public_key_to_string (pub_key)); |
151 | 151 | ||
152 | cps->id = peer; | 152 | cps->id = peer; |
diff --git a/src/transport/transport_api_cmd_connecting_peers_v3.c b/src/transport/transport_api_cmd_connecting_peers_v3.c index e90781637..2273d9852 100644 --- a/src/transport/transport_api_cmd_connecting_peers_v3.c +++ b/src/transport/transport_api_cmd_connecting_peers_v3.c | |||
@@ -36,22 +36,6 @@ | |||
36 | */ | 36 | */ |
37 | #define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__) | 37 | #define LOG(kind, ...) GNUNET_log (kind, __VA_ARGS__) |
38 | 38 | ||
39 | #define CONNECT_ADDRESS_TEMPLATE_TCP "tcp-192.168.15.%u:60002" | ||
40 | |||
41 | #define CONNECT_ADDRESS_TEMPLATE_UDP "udp-192.168.15.%u:60002" | ||
42 | |||
43 | #define ROUTER_CONNECT_ADDRESS_TEMPLATE_TCP "tcp-92.68.150.%u:60002" | ||
44 | |||
45 | #define ROUTER_CONNECT_ADDRESS_TEMPLATE_UDP "udp-92.68.150.%u:60002" | ||
46 | |||
47 | #define GLOBAL_CONNECT_ADDRESS_TEMPLATE_TCP "tcp-92.68.151.%u:60002" | ||
48 | |||
49 | #define GLOBAL_CONNECT_ADDRESS_TEMPLATE_UDP "udp-92.68.151.%u:60002" | ||
50 | |||
51 | #define PREFIX_TCP "tcp" | ||
52 | |||
53 | #define PREFIX_UDP "udp" | ||
54 | |||
55 | /** | 39 | /** |
56 | * Struct to store information needed in callbacks. | 40 | * Struct to store information needed in callbacks. |
57 | * | 41 | * |
@@ -101,222 +85,6 @@ struct ConnectPeersState | |||
101 | }; | 85 | }; |
102 | 86 | ||
103 | 87 | ||
104 | static struct GNUNET_PeerIdentity * | ||
105 | get_pub_key (unsigned int num, struct GNUNET_TESTING_System *tl_system) | ||
106 | { | ||
107 | struct GNUNET_PeerIdentity *peer = GNUNET_new (struct GNUNET_PeerIdentity); | ||
108 | struct GNUNET_CRYPTO_EddsaPublicKey *pub_key = GNUNET_new (struct | ||
109 | GNUNET_CRYPTO_EddsaPublicKey); | ||
110 | struct GNUNET_CRYPTO_EddsaPrivateKey *priv_key = GNUNET_new (struct | ||
111 | GNUNET_CRYPTO_EddsaPrivateKey); | ||
112 | |||
113 | priv_key = GNUNET_TESTING_hostkey_get (tl_system, | ||
114 | num, | ||
115 | peer); | ||
116 | |||
117 | GNUNET_CRYPTO_eddsa_key_get_public (priv_key, | ||
118 | pub_key); | ||
119 | peer->public_key = *pub_key; | ||
120 | return peer; | ||
121 | } | ||
122 | |||
123 | |||
124 | static int | ||
125 | log_nodes (void *cls, const struct GNUNET_ShortHashCode *id, void *value) | ||
126 | { | ||
127 | struct GNUNET_TESTING_NetjailNode *node = value; | ||
128 | struct GNUNET_TESTING_NodeConnection *pos_connection; | ||
129 | struct GNUNET_TESTING_ADDRESS_PREFIX *pos_prefix; | ||
130 | |||
131 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
132 | "plugin: %s space: %u node: %u global: %u\n", | ||
133 | node->plugin, | ||
134 | node->namespace_n, | ||
135 | node->node_n, | ||
136 | node->is_global); | ||
137 | |||
138 | for (pos_connection = node->node_connections_head; NULL != pos_connection; | ||
139 | pos_connection = pos_connection->next) | ||
140 | { | ||
141 | |||
142 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
143 | "namespace_n: %u node_n: %u node_type: %u\n", | ||
144 | pos_connection->namespace_n, | ||
145 | pos_connection->node_n, | ||
146 | pos_connection->node_type); | ||
147 | |||
148 | for (pos_prefix = pos_connection->address_prefixes_head; NULL != pos_prefix; | ||
149 | pos_prefix = | ||
150 | pos_prefix->next) | ||
151 | { | ||
152 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
153 | "prefix: %s\n", | ||
154 | pos_prefix->address_prefix); | ||
155 | } | ||
156 | } | ||
157 | return GNUNET_YES; | ||
158 | } | ||
159 | |||
160 | |||
161 | static int | ||
162 | log_namespaces (void *cls, const struct GNUNET_ShortHashCode *id, void *value) | ||
163 | { | ||
164 | struct GNUNET_TESTING_NetjailNamespace *namespace = value; | ||
165 | struct GNUNET_TESTING_NetjailRouter *router = namespace->router; | ||
166 | |||
167 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
168 | "router_tcp: %u router_udp: %u spaces: %u\n", | ||
169 | router->tcp_port, | ||
170 | router->udp_port, | ||
171 | namespace->namespace_n); | ||
172 | GNUNET_CONTAINER_multishortmap_iterate (namespace->nodes, &log_nodes, NULL); | ||
173 | return GNUNET_YES; | ||
174 | } | ||
175 | |||
176 | |||
177 | static int | ||
178 | log_topo (struct GNUNET_TESTING_NetjailTopology *topology) | ||
179 | { | ||
180 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
181 | "plugin: %s spaces: %u nodes: %u known: %u\n", | ||
182 | topology->plugin, | ||
183 | topology->namespaces_n, | ||
184 | topology->nodes_m, | ||
185 | topology->nodes_x); | ||
186 | |||
187 | GNUNET_CONTAINER_multishortmap_iterate (topology->map_namespaces, | ||
188 | log_namespaces, NULL); | ||
189 | GNUNET_CONTAINER_multishortmap_iterate (topology->map_globals, &log_nodes, | ||
190 | NULL); | ||
191 | return GNUNET_YES; | ||
192 | } | ||
193 | |||
194 | |||
195 | static struct GNUNET_TESTING_NodeConnection * | ||
196 | get_connections (unsigned int num, struct | ||
197 | GNUNET_TESTING_NetjailTopology *topology) | ||
198 | { | ||
199 | struct GNUNET_TESTING_NetjailNode *node; | ||
200 | struct GNUNET_ShortHashCode *hkey; | ||
201 | struct GNUNET_HashCode hc; | ||
202 | struct GNUNET_TESTING_NetjailNamespace *namespace; | ||
203 | unsigned int namespace_n, node_m; | ||
204 | |||
205 | log_topo (topology); | ||
206 | |||
207 | hkey = GNUNET_new (struct GNUNET_ShortHashCode); | ||
208 | if (topology->nodes_x >= num) | ||
209 | { | ||
210 | |||
211 | GNUNET_CRYPTO_hash (&num, sizeof(num), &hc); | ||
212 | memcpy (hkey, | ||
213 | &hc, | ||
214 | sizeof (*hkey)); | ||
215 | node = GNUNET_CONTAINER_multishortmap_get (topology->map_globals, | ||
216 | hkey); | ||
217 | } | ||
218 | else | ||
219 | { | ||
220 | namespace_n = (unsigned int) floor ((num - topology->nodes_x) | ||
221 | / topology->nodes_m); | ||
222 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
223 | "num: %u nodes_x: %u nodes_m: %u namespace_n: %u\n", | ||
224 | num, | ||
225 | topology->nodes_x, | ||
226 | topology->nodes_m, | ||
227 | namespace_n); | ||
228 | hkey = GNUNET_new (struct GNUNET_ShortHashCode); | ||
229 | GNUNET_CRYPTO_hash (&namespace_n, sizeof(namespace_n), &hc); | ||
230 | memcpy (hkey, | ||
231 | &hc, | ||
232 | sizeof (*hkey)); | ||
233 | namespace = GNUNET_CONTAINER_multishortmap_get (topology->map_namespaces, | ||
234 | hkey); | ||
235 | node_m = num - topology->nodes_x - topology->nodes_m * (namespace_n - 1); | ||
236 | hkey = GNUNET_new (struct GNUNET_ShortHashCode); | ||
237 | GNUNET_CRYPTO_hash (&node_m, sizeof(node_m), &hc); | ||
238 | memcpy (hkey, | ||
239 | &hc, | ||
240 | sizeof (*hkey)); | ||
241 | node = GNUNET_CONTAINER_multishortmap_get (namespace->nodes, | ||
242 | hkey); | ||
243 | } | ||
244 | |||
245 | |||
246 | return node->node_connections_head; | ||
247 | } | ||
248 | |||
249 | |||
250 | static unsigned int | ||
251 | calculate_num (struct GNUNET_TESTING_NodeConnection *node_connection, | ||
252 | struct GNUNET_TESTING_NetjailTopology *topology) | ||
253 | { | ||
254 | unsigned int n, m, num; | ||
255 | |||
256 | n = node_connection->namespace_n; | ||
257 | m = node_connection->node_n; | ||
258 | |||
259 | if (0 == n) | ||
260 | num = m; | ||
261 | else | ||
262 | num = (n - 1) * topology->nodes_m + m + topology->nodes_x; | ||
263 | |||
264 | return num; | ||
265 | } | ||
266 | |||
267 | static char * | ||
268 | get_address (struct GNUNET_TESTING_NodeConnection *connection, | ||
269 | char *prefix) | ||
270 | { | ||
271 | struct GNUNET_TESTING_NetjailNode *node; | ||
272 | char *addr; | ||
273 | |||
274 | node = connection->node; | ||
275 | if (connection->namespace_n == node->namespace_n) | ||
276 | { | ||
277 | if (0 == strcmp (PREFIX_TCP, prefix)) | ||
278 | { | ||
279 | |||
280 | GNUNET_asprintf (&addr, | ||
281 | CONNECT_ADDRESS_TEMPLATE_TCP, | ||
282 | connection->node_n); | ||
283 | } | ||
284 | else if (0 == strcmp (PREFIX_UDP, prefix)) | ||
285 | { | ||
286 | GNUNET_asprintf (&addr, | ||
287 | CONNECT_ADDRESS_TEMPLATE_UDP, | ||
288 | connection->node_n); | ||
289 | } | ||
290 | else | ||
291 | { | ||
292 | GNUNET_break (0); | ||
293 | } | ||
294 | } | ||
295 | else | ||
296 | { | ||
297 | if (0 == strcmp (PREFIX_TCP, prefix)) | ||
298 | { | ||
299 | |||
300 | GNUNET_asprintf (&addr, | ||
301 | ROUTER_CONNECT_ADDRESS_TEMPLATE_TCP, | ||
302 | connection->namespace_n); | ||
303 | } | ||
304 | else if (0 == strcmp (PREFIX_UDP, prefix)) | ||
305 | { | ||
306 | GNUNET_asprintf (&addr, | ||
307 | ROUTER_CONNECT_ADDRESS_TEMPLATE_UDP, | ||
308 | connection->namespace_n); | ||
309 | } | ||
310 | else | ||
311 | { | ||
312 | GNUNET_break (0); | ||
313 | } | ||
314 | } | ||
315 | |||
316 | return addr; | ||
317 | } | ||
318 | |||
319 | |||
320 | /** | 88 | /** |
321 | * The run method of this cmd will connect to peers. | 89 | * The run method of this cmd will connect to peers. |
322 | * | 90 | * |
@@ -338,7 +106,7 @@ connect_peers_run (void *cls, | |||
338 | enum GNUNET_NetworkType nt = 0; | 106 | enum GNUNET_NetworkType nt = 0; |
339 | uint32_t num; | 107 | uint32_t num; |
340 | struct GNUNET_TESTING_NodeConnection *pos_connection; | 108 | struct GNUNET_TESTING_NodeConnection *pos_connection; |
341 | struct GNUNET_TESTING_ADDRESS_PREFIX *pos_prefix; | 109 | struct GNUNET_TESTING_AddressPrefix *pos_prefix; |
342 | unsigned int con_num = 0; | 110 | unsigned int con_num = 0; |
343 | 111 | ||
344 | peer1_cmd = GNUNET_TESTING_interpreter_lookup_command (cps->start_peer_label); | 112 | peer1_cmd = GNUNET_TESTING_interpreter_lookup_command (cps->start_peer_label); |
@@ -351,13 +119,14 @@ connect_peers_run (void *cls, | |||
351 | 119 | ||
352 | cps->tl_system = tl_system; | 120 | cps->tl_system = tl_system; |
353 | 121 | ||
354 | cps->node_connections_head = get_connections (cps->num, cps->topology); | 122 | cps->node_connections_head = GNUNET_TESTING_get_connections (cps->num, |
123 | cps->topology); | ||
355 | 124 | ||
356 | for (pos_connection = cps->node_connections_head; NULL != pos_connection; | 125 | for (pos_connection = cps->node_connections_head; NULL != pos_connection; |
357 | pos_connection = pos_connection->next) | 126 | pos_connection = pos_connection->next) |
358 | { | 127 | { |
359 | con_num++; | 128 | con_num++; |
360 | num = calculate_num (pos_connection, cps->topology); | 129 | num = GNUNET_TESTING_calculate_num (pos_connection, cps->topology); |
361 | for (pos_prefix = pos_connection->address_prefixes_head; NULL != pos_prefix; | 130 | for (pos_prefix = pos_connection->address_prefixes_head; NULL != pos_prefix; |
362 | pos_prefix = | 131 | pos_prefix = |
363 | pos_prefix->next) | 132 | pos_prefix->next) |
@@ -367,9 +136,10 @@ connect_peers_run (void *cls, | |||
367 | "prefix: %s\n", | 136 | "prefix: %s\n", |
368 | pos_prefix->address_prefix); | 137 | pos_prefix->address_prefix); |
369 | 138 | ||
370 | addr = get_address (pos_connection, pos_prefix->address_prefix); | 139 | addr = GNUNET_TESTING_get_address (pos_connection, |
140 | pos_prefix->address_prefix); | ||
371 | 141 | ||
372 | peer = get_pub_key (num, tl_system); | 142 | peer = GNUNET_TESTING_get_pub_key (num, tl_system); |
373 | 143 | ||
374 | LOG (GNUNET_ERROR_TYPE_ERROR, | 144 | LOG (GNUNET_ERROR_TYPE_ERROR, |
375 | "num: %u pub_key %s addr: %s\n", | 145 | "num: %u pub_key %s addr: %s\n", |
@@ -417,8 +187,8 @@ connect_peers_finish (void *cls, | |||
417 | for (pos_connection = cps->node_connections_head; NULL != pos_connection; | 187 | for (pos_connection = cps->node_connections_head; NULL != pos_connection; |
418 | pos_connection = pos_connection->next) | 188 | pos_connection = pos_connection->next) |
419 | { | 189 | { |
420 | num = calculate_num (pos_connection, cps->topology); | 190 | num = GNUNET_TESTING_calculate_num (pos_connection, cps->topology); |
421 | peer = get_pub_key (num, cps->tl_system); | 191 | peer = GNUNET_TESTING_get_pub_key (num, cps->tl_system); |
422 | GNUNET_CRYPTO_hash (&(peer->public_key), sizeof(peer->public_key), &hc); | 192 | GNUNET_CRYPTO_hash (&(peer->public_key), sizeof(peer->public_key), &hc); |
423 | memcpy (key, | 193 | memcpy (key, |
424 | &hc, | 194 | &hc, |
@@ -476,6 +246,9 @@ connect_peers_cleanup (void *cls, | |||
476 | * | 246 | * |
477 | * @param label name for command. | 247 | * @param label name for command. |
478 | * @param start_peer_label Label of the cmd to start a peer. | 248 | * @param start_peer_label Label of the cmd to start a peer. |
249 | * @param create_label Label of the cmd to create the testing system. | ||
250 | * @param num Number globally identifying the node. | ||
251 | * @param The topology for the test setup. | ||
479 | * @return command. | 252 | * @return command. |
480 | */ | 253 | */ |
481 | struct GNUNET_TESTING_Command | 254 | struct GNUNET_TESTING_Command |
diff --git a/src/transport/transport_api_cmd_send_simple_v3.c b/src/transport/transport_api_cmd_send_simple_v3.c new file mode 100644 index 000000000..a4ce2c4e9 --- /dev/null +++ b/src/transport/transport_api_cmd_send_simple_v3.c | |||
@@ -0,0 +1,194 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet | ||
3 | Copyright (C) 2021 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software: you can redistribute it and/or modify it | ||
6 | under the terms of the GNU Affero General Public License as published | ||
7 | by the Free Software Foundation, either version 3 of the License, | ||
8 | or (at your option) any later version. | ||
9 | |||
10 | GNUnet is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
13 | Affero General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU Affero General Public License | ||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
17 | |||
18 | SPDX-License-Identifier: AGPL3.0-or-later | ||
19 | */ | ||
20 | |||
21 | /** | ||
22 | * @file testing_api_cmd_start_peer.c | ||
23 | * @brief cmd to start a peer. | ||
24 | * @author t3sserakt | ||
25 | */ | ||
26 | #include "platform.h" | ||
27 | #include "gnunet_util_lib.h" | ||
28 | #include "gnunet_testing_ng_lib.h" | ||
29 | #include "transport-testing2.h" | ||
30 | #include "transport-testing-cmds.h" | ||
31 | |||
32 | /** | ||
33 | * Struct to hold information for callbacks. | ||
34 | * | ||
35 | */ | ||
36 | struct SendSimpleState | ||
37 | { | ||
38 | /** | ||
39 | * Number globally identifying the node. | ||
40 | * | ||
41 | */ | ||
42 | uint32_t num; | ||
43 | |||
44 | /** | ||
45 | * Label of the cmd to start a peer. | ||
46 | * | ||
47 | */ | ||
48 | const char *start_peer_label; | ||
49 | |||
50 | /** | ||
51 | * Label of the cmd which started the test system. | ||
52 | * | ||
53 | */ | ||
54 | const char *create_label; | ||
55 | |||
56 | /** | ||
57 | * The topology we get the connected nodes from. | ||
58 | */ | ||
59 | struct GNUNET_TESTING_NetjailTopology *topology; | ||
60 | }; | ||
61 | |||
62 | |||
63 | /** | ||
64 | * Trait function of this cmd does nothing. | ||
65 | * | ||
66 | */ | ||
67 | static int | ||
68 | send_simple_traits (void *cls, | ||
69 | const void **ret, | ||
70 | const char *trait, | ||
71 | unsigned int index) | ||
72 | { | ||
73 | return GNUNET_OK; | ||
74 | } | ||
75 | |||
76 | |||
77 | /** | ||
78 | * The cleanup function of this cmd frees resources the cmd allocated. | ||
79 | * | ||
80 | */ | ||
81 | static void | ||
82 | send_simple_cleanup (void *cls, | ||
83 | const struct GNUNET_TESTING_Command *cmd) | ||
84 | { | ||
85 | struct SendSimpleState *sss = cls; | ||
86 | |||
87 | GNUNET_free (sss); | ||
88 | } | ||
89 | |||
90 | |||
91 | /** | ||
92 | * The run method of this cmd will send a simple message to the connected peers. | ||
93 | * | ||
94 | */ | ||
95 | static void | ||
96 | send_simple_run (void *cls, | ||
97 | const struct GNUNET_TESTING_Command *cmd, | ||
98 | struct GNUNET_TESTING_Interpreter *is) | ||
99 | { | ||
100 | struct SendSimpleState *sss = cls; | ||
101 | struct GNUNET_MQ_Envelope *env; | ||
102 | struct GNUNET_TRANSPORT_TESTING_TestMessage *test; | ||
103 | struct GNUNET_MQ_Handle *mq; | ||
104 | struct GNUNET_CONTAINER_MultiShortmap *connected_peers_map; | ||
105 | const struct GNUNET_TESTING_Command *peer1_cmd; | ||
106 | struct GNUNET_ShortHashCode *key = GNUNET_new (struct GNUNET_ShortHashCode); | ||
107 | struct GNUNET_HashCode hc; | ||
108 | struct GNUNET_TESTING_NodeConnection *node_connections_head; | ||
109 | struct GNUNET_PeerIdentity *peer; | ||
110 | struct GNUNET_CRYPTO_EddsaPublicKey public_key; | ||
111 | uint32_t num; | ||
112 | struct GNUNET_TESTING_NodeConnection *pos_connection; | ||
113 | const struct GNUNET_TESTING_Command *system_cmd; | ||
114 | struct GNUNET_TESTING_System *tl_system; | ||
115 | |||
116 | peer1_cmd = GNUNET_TESTING_interpreter_lookup_command (sss->start_peer_label); | ||
117 | GNUNET_TRANSPORT_get_trait_connected_peers_map (peer1_cmd, | ||
118 | &connected_peers_map); | ||
119 | |||
120 | system_cmd = GNUNET_TESTING_interpreter_lookup_command (sss->create_label); | ||
121 | GNUNET_TESTING_get_trait_test_system (system_cmd, | ||
122 | &tl_system); | ||
123 | |||
124 | node_connections_head = GNUNET_TESTING_get_connections (sss->num, | ||
125 | sss->topology); | ||
126 | |||
127 | for (int i = 0; i < 1; i++) | ||
128 | { | ||
129 | for (pos_connection = node_connections_head; NULL != pos_connection; | ||
130 | pos_connection = pos_connection->next) | ||
131 | { | ||
132 | num = GNUNET_TESTING_calculate_num (pos_connection, sss->topology); | ||
133 | peer = GNUNET_TESTING_get_pub_key (num, tl_system); | ||
134 | public_key = peer->public_key; | ||
135 | GNUNET_CRYPTO_hash (&public_key, sizeof(public_key), &hc); | ||
136 | |||
137 | memcpy (key, | ||
138 | &hc, | ||
139 | sizeof (*key)); | ||
140 | mq = GNUNET_CONTAINER_multishortmap_get (connected_peers_map, | ||
141 | key); | ||
142 | env = GNUNET_MQ_msg_extra (test, | ||
143 | 1000 - sizeof(*test), | ||
144 | GNUNET_TRANSPORT_TESTING_SIMPLE_MTYPE); | ||
145 | test->num = htonl (sss->num); | ||
146 | memset (&test[1], | ||
147 | sss->num, | ||
148 | 1000 - sizeof(*test)); | ||
149 | GNUNET_MQ_send (mq, | ||
150 | env); | ||
151 | } | ||
152 | } | ||
153 | |||
154 | GNUNET_free (key); | ||
155 | |||
156 | } | ||
157 | |||
158 | |||
159 | /** | ||
160 | * Create command. | ||
161 | * | ||
162 | * @param label name for command. | ||
163 | * @param start_peer_label Label of the cmd to start a peer. | ||
164 | * @param start_peer_label Label of the cmd which started the test system. | ||
165 | * @param num Number globally identifying the node. | ||
166 | * @param The topology for the test setup. | ||
167 | * @return command. | ||
168 | */ | ||
169 | struct GNUNET_TESTING_Command | ||
170 | GNUNET_TRANSPORT_cmd_send_simple_v3 (const char *label, | ||
171 | const char *start_peer_label, | ||
172 | const char *create_label, | ||
173 | uint32_t num, | ||
174 | struct GNUNET_TESTING_NetjailTopology * | ||
175 | topology) | ||
176 | { | ||
177 | struct SendSimpleState *sss; | ||
178 | |||
179 | sss = GNUNET_new (struct SendSimpleState); | ||
180 | sss->num = num; | ||
181 | sss->start_peer_label = start_peer_label; | ||
182 | sss->create_label = create_label; | ||
183 | sss->topology = topology; | ||
184 | |||
185 | struct GNUNET_TESTING_Command cmd = { | ||
186 | .cls = sss, | ||
187 | .label = label, | ||
188 | .run = &send_simple_run, | ||
189 | .cleanup = &send_simple_cleanup, | ||
190 | .traits = &send_simple_traits | ||
191 | }; | ||
192 | |||
193 | return cmd; | ||
194 | } | ||
diff --git a/src/util/helper.c b/src/util/helper.c index dcb55d8c7..0809c1f17 100644 --- a/src/util/helper.c +++ b/src/util/helper.c | |||
@@ -407,6 +407,8 @@ start_helper (struct GNUNET_HELPER_Handle *h) | |||
407 | if ((h->helper_in == NULL) || (h->helper_out == NULL)) | 407 | if ((h->helper_in == NULL) || (h->helper_out == NULL)) |
408 | { | 408 | { |
409 | /* out of file descriptors? try again later... */ | 409 | /* out of file descriptors? try again later... */ |
410 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
411 | "out of file descriptors? try again later\n"); | ||
410 | stop_helper (h, GNUNET_NO); | 412 | stop_helper (h, GNUNET_NO); |
411 | h->restart_task = GNUNET_SCHEDULER_add_delayed ( | 413 | h->restart_task = GNUNET_SCHEDULER_add_delayed ( |
412 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, | 414 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, |
@@ -434,6 +436,8 @@ start_helper (struct GNUNET_HELPER_Handle *h) | |||
434 | if (NULL == h->helper_proc) | 436 | if (NULL == h->helper_proc) |
435 | { | 437 | { |
436 | /* failed to start process? try again later... */ | 438 | /* failed to start process? try again later... */ |
439 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
440 | "failed to start process? try again later\n"); | ||
437 | stop_helper (h, GNUNET_NO); | 441 | stop_helper (h, GNUNET_NO); |
438 | h->restart_task = GNUNET_SCHEDULER_add_delayed ( | 442 | h->restart_task = GNUNET_SCHEDULER_add_delayed ( |
439 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, | 443 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, |