diff options
-rw-r--r-- | src/transport/Makefile.am | 22 | ||||
-rw-r--r-- | src/transport/test_transport_api.c | 40 | ||||
-rw-r--r-- | src/transport/test_transport_api_bidirectional_connect.c | 448 | ||||
-rw-r--r-- | src/transport/test_transport_api_bidirectional_connect_peer1.conf | 43 | ||||
-rw-r--r-- | src/transport/test_transport_api_bidirectional_connect_peer2.conf | 43 | ||||
-rw-r--r-- | src/transport/test_transport_api_blacklisting.c | 450 | ||||
-rw-r--r-- | src/transport/test_transport_api_blacklisting_tcp_peer1.conf | 9 | ||||
-rw-r--r-- | src/transport/test_transport_api_blacklisting_tcp_peer2.conf | 9 | ||||
-rw-r--r-- | src/transport/test_transport_api_slow_ats_peer2.conf | 2 | ||||
-rw-r--r-- | src/transport/transport-testing-main.c | 69 | ||||
-rw-r--r-- | src/transport/transport-testing.c | 45 | ||||
-rw-r--r-- | src/transport/transport-testing.h | 23 |
12 files changed, 265 insertions, 938 deletions
diff --git a/src/transport/Makefile.am b/src/transport/Makefile.am index 34fbe9caf..2c6c7dfd8 100644 --- a/src/transport/Makefile.am +++ b/src/transport/Makefile.am | |||
@@ -445,9 +445,8 @@ check_PROGRAMS = \ | |||
445 | $(HTTPS_CLIENT_PLUGIN_TEST) \ | 445 | $(HTTPS_CLIENT_PLUGIN_TEST) \ |
446 | $(HTTP_SERVER_PLUGIN_TEST) \ | 446 | $(HTTP_SERVER_PLUGIN_TEST) \ |
447 | $(HTTPS_SERVER_PLUGIN_TEST) \ | 447 | $(HTTPS_SERVER_PLUGIN_TEST) \ |
448 | test_transport_api_blacklisting \ | 448 | test_transport_api_blacklisting_tcp \ |
449 | test_transport_api_disconnect_tcp \ | 449 | test_transport_api_disconnect_tcp \ |
450 | test_transport_api_bidirectional_connect \ | ||
451 | test_transport_api_tcp \ | 450 | test_transport_api_tcp \ |
452 | test_transport_api_restart_1peer \ | 451 | test_transport_api_restart_1peer \ |
453 | test_transport_api_timeout_tcp \ | 452 | test_transport_api_timeout_tcp \ |
@@ -516,9 +515,8 @@ TESTS = \ | |||
516 | $(UNIX_TEST) \ | 515 | $(UNIX_TEST) \ |
517 | $(WLAN_PLUGIN_TEST) \ | 516 | $(WLAN_PLUGIN_TEST) \ |
518 | $(BT_PLUGIN_TEST) \ | 517 | $(BT_PLUGIN_TEST) \ |
519 | test_transport_api_blacklisting \ | 518 | test_transport_api_blacklisting_tcp \ |
520 | test_transport_api_disconnect_tcp \ | 519 | test_transport_api_disconnect_tcp \ |
521 | test_transport_api_bidirectional_connect \ | ||
522 | test_transport_api_tcp \ | 520 | test_transport_api_tcp \ |
523 | test_transport_api_restart_1peer \ | 521 | test_transport_api_restart_1peer \ |
524 | test_transport_api_restart_2peers \ | 522 | test_transport_api_restart_2peers \ |
@@ -592,9 +590,9 @@ test_transport_testing_restart_LDADD = \ | |||
592 | $(top_builddir)/src/hello/libgnunethello.la \ | 590 | $(top_builddir)/src/hello/libgnunethello.la \ |
593 | libgnunettransporttesting.la | 591 | libgnunettransporttesting.la |
594 | 592 | ||
595 | test_transport_api_blacklisting_SOURCES = \ | 593 | test_transport_api_blacklisting_tcp_SOURCES = \ |
596 | test_transport_api_blacklisting.c | 594 | test_transport_api_blacklisting.c |
597 | test_transport_api_blacklisting_LDADD = \ | 595 | test_transport_api_blacklisting_tcp_LDADD = \ |
598 | libgnunettransport.la \ | 596 | libgnunettransport.la \ |
599 | $(top_builddir)/src/hello/libgnunethello.la \ | 597 | $(top_builddir)/src/hello/libgnunethello.la \ |
600 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ | 598 | $(top_builddir)/src/statistics/libgnunetstatistics.la \ |
@@ -763,14 +761,6 @@ test_transport_api_tcp_LDADD = \ | |||
763 | $(top_builddir)/src/util/libgnunetutil.la \ | 761 | $(top_builddir)/src/util/libgnunetutil.la \ |
764 | libgnunettransporttesting.la | 762 | libgnunettransporttesting.la |
765 | 763 | ||
766 | test_transport_api_bidirectional_connect_SOURCES = \ | ||
767 | test_transport_api_bidirectional_connect.c | ||
768 | test_transport_api_bidirectional_connect_LDADD = \ | ||
769 | libgnunettransport.la \ | ||
770 | $(top_builddir)/src/hello/libgnunethello.la \ | ||
771 | $(top_builddir)/src/util/libgnunetutil.la \ | ||
772 | libgnunettransporttesting.la | ||
773 | |||
774 | test_transport_api_restart_1peer_SOURCES = \ | 764 | test_transport_api_restart_1peer_SOURCES = \ |
775 | test_transport_api_restart_1peer.c | 765 | test_transport_api_restart_1peer.c |
776 | test_transport_api_restart_1peer_LDADD = \ | 766 | test_transport_api_restart_1peer_LDADD = \ |
@@ -1264,6 +1254,8 @@ test_quota_compliance_wlan_asymmetric_peer2.conf\ | |||
1264 | test_quota_compliance_bluetooth_asymmetric_peer1.conf\ | 1254 | test_quota_compliance_bluetooth_asymmetric_peer1.conf\ |
1265 | test_quota_compliance_bluetooth_asymmetric_peer2.conf\ | 1255 | test_quota_compliance_bluetooth_asymmetric_peer2.conf\ |
1266 | test_transport_api_data.conf\ | 1256 | test_transport_api_data.conf\ |
1257 | test_transport_api_blacklisting_tcp_peer1.conf \ | ||
1258 | test_transport_api_blacklisting_tcp_peer2.conf \ | ||
1267 | test_transport_api_http_peer1.conf\ | 1259 | test_transport_api_http_peer1.conf\ |
1268 | test_transport_api_http_peer2.conf\ | 1260 | test_transport_api_http_peer2.conf\ |
1269 | test_transport_api_https_peer1.conf\ | 1261 | test_transport_api_https_peer1.conf\ |
@@ -1286,8 +1278,6 @@ test_transport_api_reliability_wlan_peer1.conf\ | |||
1286 | test_transport_api_reliability_wlan_peer2.conf\ | 1278 | test_transport_api_reliability_wlan_peer2.conf\ |
1287 | test_transport_api_reliability_bluetooth_peer1.conf\ | 1279 | test_transport_api_reliability_bluetooth_peer1.conf\ |
1288 | test_transport_api_reliability_bluetooth_peer2.conf\ | 1280 | test_transport_api_reliability_bluetooth_peer2.conf\ |
1289 | test_transport_api_bidirectional_connect_peer1.conf\ | ||
1290 | test_transport_api_bidirectional_connect_peer2.conf\ | ||
1291 | test_transport_api_manipulation_send_tcp_peer1.conf\ | 1281 | test_transport_api_manipulation_send_tcp_peer1.conf\ |
1292 | test_transport_api_manipulation_send_tcp_peer2.conf\ | 1282 | test_transport_api_manipulation_send_tcp_peer2.conf\ |
1293 | test_transport_api_manipulation_recv_tcp_peer1.conf\ | 1283 | test_transport_api_manipulation_recv_tcp_peer1.conf\ |
diff --git a/src/transport/test_transport_api.c b/src/transport/test_transport_api.c index bb10116e2..ad078f582 100644 --- a/src/transport/test_transport_api.c +++ b/src/transport/test_transport_api.c | |||
@@ -20,6 +20,7 @@ | |||
20 | /** | 20 | /** |
21 | * @file transport/test_transport_api.c | 21 | * @file transport/test_transport_api.c |
22 | * @brief base test case for transport implementations | 22 | * @brief base test case for transport implementations |
23 | * @author Christian Grothoff | ||
23 | * | 24 | * |
24 | * This test case serves as a base for tcp, udp, and udp-nat | 25 | * This test case serves as a base for tcp, udp, and udp-nat |
25 | * transport test cases. Based on the executable being run | 26 | * transport test cases. Based on the executable being run |
@@ -33,12 +34,12 @@ | |||
33 | /** | 34 | /** |
34 | * How long until we give up on transmitting the message? | 35 | * How long until we give up on transmitting the message? |
35 | */ | 36 | */ |
36 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) | 37 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) |
37 | 38 | ||
38 | /** | 39 | /** |
39 | * How long until we give up on transmitting the message? | 40 | * How long until we give up on transmitting the message? |
40 | */ | 41 | */ |
41 | #define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) | 42 | #define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5) |
42 | 43 | ||
43 | #define TEST_MESSAGE_SIZE 2600 | 44 | #define TEST_MESSAGE_SIZE 2600 |
44 | 45 | ||
@@ -58,9 +59,6 @@ custom_shutdown (void *cls) | |||
58 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); | 59 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); |
59 | th = NULL; | 60 | th = NULL; |
60 | } | 61 | } |
61 | else | ||
62 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
63 | "Peers were not ready to send data\n"); | ||
64 | } | 62 | } |
65 | 63 | ||
66 | 64 | ||
@@ -148,7 +146,7 @@ sendtask (void *cls) | |||
148 | char *receiver_s = GNUNET_strdup (GNUNET_i2s (&ccc->p[0]->id)); | 146 | char *receiver_s = GNUNET_strdup (GNUNET_i2s (&ccc->p[0]->id)); |
149 | 147 | ||
150 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 148 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
151 | "Sending message from peer %u (`%4s') -> peer %u (`%s') !\n", | 149 | "Sending message from peer %u (`%s') -> peer %u (`%s') !\n", |
152 | ccc->p[1]->no, | 150 | ccc->p[1]->no, |
153 | GNUNET_i2s (&ccc->p[1]->id), | 151 | GNUNET_i2s (&ccc->p[1]->id), |
154 | ccc->p[0]->no, | 152 | ccc->p[0]->no, |
@@ -162,6 +160,7 @@ sendtask (void *cls) | |||
162 | TIMEOUT_TRANSMIT, | 160 | TIMEOUT_TRANSMIT, |
163 | ¬ify_ready, | 161 | ¬ify_ready, |
164 | ccc->p[0]); | 162 | ccc->p[0]); |
163 | GNUNET_assert (NULL != th); | ||
165 | } | 164 | } |
166 | 165 | ||
167 | 166 | ||
@@ -181,9 +180,16 @@ notify_disconnect (void *cls, | |||
181 | } | 180 | } |
182 | 181 | ||
183 | 182 | ||
184 | int | 183 | /** |
185 | main (int argc, | 184 | * Runs the test. |
186 | char *argv[]) | 185 | * |
186 | * @param argv the argv argument from main() | ||
187 | * @param bi_directional should we try to establish connections | ||
188 | * in both directions simultaneously? | ||
189 | */ | ||
190 | static int | ||
191 | test (char *argv[], | ||
192 | int bi_directional) | ||
187 | { | 193 | { |
188 | struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext my_ccc = { | 194 | struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext my_ccc = { |
189 | .connect_continuation = &sendtask, | 195 | .connect_continuation = &sendtask, |
@@ -192,7 +198,8 @@ main (int argc, | |||
192 | .nc = &GNUNET_TRANSPORT_TESTING_log_connect, | 198 | .nc = &GNUNET_TRANSPORT_TESTING_log_connect, |
193 | .nd = ¬ify_disconnect, | 199 | .nd = ¬ify_disconnect, |
194 | .shutdown_task = &custom_shutdown, | 200 | .shutdown_task = &custom_shutdown, |
195 | .timeout = TIMEOUT | 201 | .timeout = TIMEOUT, |
202 | .bi_directional = bi_directional | ||
196 | }; | 203 | }; |
197 | 204 | ||
198 | ccc = &my_ccc; | 205 | ccc = &my_ccc; |
@@ -204,4 +211,17 @@ main (int argc, | |||
204 | return 0; | 211 | return 0; |
205 | } | 212 | } |
206 | 213 | ||
214 | |||
215 | int | ||
216 | main (int argc, | ||
217 | char *argv[]) | ||
218 | { | ||
219 | if ( (0 != test (argv, | ||
220 | GNUNET_NO)) || | ||
221 | (0 != test (argv, | ||
222 | GNUNET_YES) ) ) | ||
223 | return 1; | ||
224 | return 0; | ||
225 | } | ||
226 | |||
207 | /* end of test_transport_api.c */ | 227 | /* end of test_transport_api.c */ |
diff --git a/src/transport/test_transport_api_bidirectional_connect.c b/src/transport/test_transport_api_bidirectional_connect.c deleted file mode 100644 index 10b20e21e..000000000 --- a/src/transport/test_transport_api_bidirectional_connect.c +++ /dev/null | |||
@@ -1,448 +0,0 @@ | |||
1 | /* | ||
2 | This file is part of GNUnet. | ||
3 | Copyright (C) 2009, 2010 GNUnet e.V. | ||
4 | |||
5 | GNUnet is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License as published | ||
7 | by the Free Software Foundation; either version 3, or (at your | ||
8 | 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 | General Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License | ||
16 | along with GNUnet; see the file COPYING. If not, write to the | ||
17 | Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, | ||
18 | Boston, MA 02110-1301, USA. | ||
19 | */ | ||
20 | /** | ||
21 | * @file transport/test_transport_api_bidirectional_connect.c | ||
22 | * @brief base test case for transport implementations | ||
23 | * | ||
24 | * Perform a 3-way handshake connection set up in both directions at | ||
25 | * (almost) the same time | ||
26 | */ | ||
27 | #include "platform.h" | ||
28 | #include "gnunet_transport_service.h" | ||
29 | #include "transport-testing.h" | ||
30 | |||
31 | |||
32 | /** | ||
33 | * How long until we give up on transmitting the message? | ||
34 | */ | ||
35 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) | ||
36 | |||
37 | /** | ||
38 | * How long until we give up on transmitting the message? | ||
39 | */ | ||
40 | #define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60) | ||
41 | |||
42 | #define MTYPE 12345 | ||
43 | |||
44 | static char *test_source; | ||
45 | |||
46 | static char *test_plugin; | ||
47 | |||
48 | static char *test_name; | ||
49 | |||
50 | static int ok; | ||
51 | |||
52 | static struct GNUNET_SCHEDULER_Task * die_task; | ||
53 | |||
54 | static struct GNUNET_SCHEDULER_Task * send_task; | ||
55 | |||
56 | static struct GNUNET_TRANSPORT_TESTING_PeerContext *p1; | ||
57 | |||
58 | static struct GNUNET_TRANSPORT_TESTING_PeerContext *p2; | ||
59 | |||
60 | static struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc1; | ||
61 | static struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc2; | ||
62 | |||
63 | static struct GNUNET_TRANSPORT_TransmitHandle *th; | ||
64 | |||
65 | static struct GNUNET_TRANSPORT_TESTING_Handle *tth; | ||
66 | |||
67 | static char *cfg_file_p1; | ||
68 | |||
69 | static char *cfg_file_p2; | ||
70 | |||
71 | |||
72 | static void | ||
73 | end () | ||
74 | { | ||
75 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n"); | ||
76 | |||
77 | if (send_task != NULL) | ||
78 | { | ||
79 | GNUNET_SCHEDULER_cancel (send_task); | ||
80 | send_task = NULL; | ||
81 | } | ||
82 | |||
83 | if (die_task != NULL) | ||
84 | GNUNET_SCHEDULER_cancel (die_task); | ||
85 | |||
86 | if (NULL != th) | ||
87 | { | ||
88 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); | ||
89 | th = NULL; | ||
90 | } | ||
91 | |||
92 | GNUNET_TRANSPORT_TESTING_stop_peer (p1); | ||
93 | GNUNET_TRANSPORT_TESTING_stop_peer (p2); | ||
94 | } | ||
95 | |||
96 | |||
97 | static void | ||
98 | end_badly (void *cls) | ||
99 | { | ||
100 | die_task = NULL; | ||
101 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n"); | ||
102 | if (send_task != NULL) | ||
103 | { | ||
104 | GNUNET_SCHEDULER_cancel (send_task); | ||
105 | send_task = NULL; | ||
106 | } | ||
107 | |||
108 | if (NULL != cc2) | ||
109 | { | ||
110 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Fail! Could not connect peers\n")); | ||
111 | GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc2); | ||
112 | cc2 = NULL; | ||
113 | } | ||
114 | if (NULL != cc1) | ||
115 | { | ||
116 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Fail! Could not connect peers\n")); | ||
117 | GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc1); | ||
118 | cc1 = NULL; | ||
119 | } | ||
120 | if (NULL != th) | ||
121 | { | ||
122 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); | ||
123 | th = NULL; | ||
124 | } | ||
125 | if (p1 != NULL) | ||
126 | GNUNET_TRANSPORT_TESTING_stop_peer (p1); | ||
127 | if (p2 != NULL) | ||
128 | GNUNET_TRANSPORT_TESTING_stop_peer (p2); | ||
129 | |||
130 | ok = GNUNET_SYSERR; | ||
131 | } | ||
132 | |||
133 | |||
134 | static void | ||
135 | notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer, | ||
136 | const struct GNUNET_MessageHeader *message) | ||
137 | { | ||
138 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; | ||
139 | struct GNUNET_TRANSPORT_TESTING_PeerContext *t = NULL; | ||
140 | |||
141 | if (0 == memcmp (peer, &p1->id, sizeof (struct GNUNET_PeerIdentity))) | ||
142 | t = p1; | ||
143 | if (0 == memcmp (peer, &p2->id, sizeof (struct GNUNET_PeerIdentity))) | ||
144 | t = p2; | ||
145 | GNUNET_assert (t != NULL); | ||
146 | |||
147 | char *ps = GNUNET_strdup (GNUNET_i2s (&p->id)); | ||
148 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
149 | "Peer %u (`%4s') received message of type %d and size %u size from peer %u (`%4s')!\n", | ||
150 | p->no, ps, ntohs (message->type), ntohs (message->size), t->no, | ||
151 | GNUNET_i2s (&t->id)); | ||
152 | GNUNET_free (ps); | ||
153 | if ((MTYPE == ntohs (message->type)) && | ||
154 | (sizeof (struct GNUNET_MessageHeader) == ntohs (message->size))) | ||
155 | { | ||
156 | ok = 0; | ||
157 | end (); | ||
158 | } | ||
159 | else | ||
160 | { | ||
161 | GNUNET_break (0); | ||
162 | ok = 1; | ||
163 | end (); | ||
164 | } | ||
165 | } | ||
166 | |||
167 | |||
168 | static size_t | ||
169 | notify_ready (void *cls, size_t size, void *buf) | ||
170 | { | ||
171 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; | ||
172 | struct GNUNET_MessageHeader *hdr; | ||
173 | |||
174 | th = NULL; | ||
175 | |||
176 | if (buf == NULL) | ||
177 | { | ||
178 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
179 | "Timeout occurred while waiting for transmit_ready\n"); | ||
180 | if (NULL != die_task) | ||
181 | GNUNET_SCHEDULER_cancel (die_task); | ||
182 | die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL); | ||
183 | ok = 42; | ||
184 | return 0; | ||
185 | } | ||
186 | |||
187 | GNUNET_assert (size >= 256); | ||
188 | hdr = buf; | ||
189 | hdr->size = htons (sizeof (struct GNUNET_MessageHeader)); | ||
190 | hdr->type = htons (MTYPE); | ||
191 | |||
192 | { | ||
193 | char *ps = GNUNET_strdup (GNUNET_i2s (&p2->id)); | ||
194 | |||
195 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
196 | "Peer %u (`%4s') sending message with type %u and size %u bytes to peer %u (`%4s')\n", | ||
197 | p2->no, | ||
198 | ps, | ||
199 | ntohs (hdr->type), | ||
200 | ntohs (hdr->size), | ||
201 | p->no, | ||
202 | GNUNET_i2s (&p->id)); | ||
203 | GNUNET_free (ps); | ||
204 | } | ||
205 | |||
206 | return sizeof (struct GNUNET_MessageHeader); | ||
207 | } | ||
208 | |||
209 | |||
210 | static void | ||
211 | sendtask (void *cls) | ||
212 | { | ||
213 | char *receiver_s; | ||
214 | |||
215 | send_task = NULL; | ||
216 | receiver_s = GNUNET_strdup (GNUNET_i2s (&p1->id)); | ||
217 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
218 | "Sending message from peer %u (`%4s') -> peer %u (`%s') !\n", | ||
219 | p2->no, GNUNET_i2s (&p2->id), p1->no, receiver_s); | ||
220 | GNUNET_free (receiver_s); | ||
221 | |||
222 | th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th, &p1->id, 256, | ||
223 | TIMEOUT_TRANSMIT, ¬ify_ready, | ||
224 | p1); | ||
225 | } | ||
226 | |||
227 | |||
228 | static void | ||
229 | notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer) | ||
230 | { | ||
231 | static int c; | ||
232 | |||
233 | c++; | ||
234 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; | ||
235 | struct GNUNET_TRANSPORT_TESTING_PeerContext *t = NULL; | ||
236 | |||
237 | if (0 == memcmp (peer, &p1->id, sizeof (struct GNUNET_PeerIdentity))) | ||
238 | t = p1; | ||
239 | if (0 == memcmp (peer, &p2->id, sizeof (struct GNUNET_PeerIdentity))) | ||
240 | t = p2; | ||
241 | GNUNET_assert (t != NULL); | ||
242 | |||
243 | { | ||
244 | char *ps = GNUNET_strdup (GNUNET_i2s (&p->id)); | ||
245 | |||
246 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
247 | "Peer %u (`%4s'): peer %u (`%s') connected to me!\n", | ||
248 | p->no, | ||
249 | ps, | ||
250 | t->no, | ||
251 | GNUNET_i2s (peer)); | ||
252 | GNUNET_free (ps); | ||
253 | } | ||
254 | } | ||
255 | |||
256 | |||
257 | static void | ||
258 | notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) | ||
259 | { | ||
260 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; | ||
261 | |||
262 | { | ||
263 | char *ps = GNUNET_strdup (GNUNET_i2s (&p->id)); | ||
264 | |||
265 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
266 | "Peer %u (`%4s'): peer (`%s') disconnected from me!\n", | ||
267 | p->no, | ||
268 | ps, | ||
269 | GNUNET_i2s (peer)); | ||
270 | GNUNET_free (ps); | ||
271 | } | ||
272 | if (NULL != send_task) | ||
273 | { | ||
274 | GNUNET_SCHEDULER_cancel(send_task); | ||
275 | GNUNET_break (0); | ||
276 | send_task = NULL; | ||
277 | } | ||
278 | if (NULL != th) | ||
279 | { | ||
280 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); | ||
281 | th = NULL; | ||
282 | } | ||
283 | } | ||
284 | |||
285 | |||
286 | static void | ||
287 | testing_connect_cb (void *cls) | ||
288 | { | ||
289 | static int connected = GNUNET_NO; | ||
290 | |||
291 | if ((cls == cc1) && (NULL != cc2)) | ||
292 | { | ||
293 | GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc2); | ||
294 | } | ||
295 | if ((cls == cc2) && (NULL != cc1)) | ||
296 | { | ||
297 | GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc1); | ||
298 | } | ||
299 | cc1 = NULL; | ||
300 | cc2 = NULL; | ||
301 | |||
302 | if (connected > 0) | ||
303 | return; | ||
304 | connected++; | ||
305 | |||
306 | { | ||
307 | char *p1_c = GNUNET_strdup (GNUNET_i2s (&p1->id)); | ||
308 | |||
309 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
310 | "Peers connected: %u (%s) <-> %u (%s)\n", | ||
311 | p1->no, | ||
312 | p1_c, | ||
313 | p2->no, | ||
314 | GNUNET_i2s (&p2->id)); | ||
315 | GNUNET_free (p1_c); | ||
316 | } | ||
317 | send_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, | ||
318 | &sendtask, | ||
319 | NULL); | ||
320 | } | ||
321 | |||
322 | |||
323 | static void | ||
324 | start_cb (struct GNUNET_TRANSPORT_TESTING_PeerContext *p, void *cls) | ||
325 | { | ||
326 | static int started; | ||
327 | |||
328 | started++; | ||
329 | |||
330 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
331 | "Peer %u (`%s') started\n", | ||
332 | p->no, | ||
333 | GNUNET_i2s (&p->id)); | ||
334 | |||
335 | if (started != 2) | ||
336 | return; | ||
337 | |||
338 | char *sender_c = GNUNET_strdup (GNUNET_i2s (&p1->id)); | ||
339 | |||
340 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
341 | "Test tries to connect peer %u (`%s') <-> peer %u (`%s')\n", | ||
342 | p1->no, sender_c, p2->no, GNUNET_i2s (&p2->id)); | ||
343 | GNUNET_free (sender_c); | ||
344 | cc1 = | ||
345 | GNUNET_TRANSPORT_TESTING_connect_peers (p2, | ||
346 | p1, | ||
347 | &testing_connect_cb, | ||
348 | cc1); | ||
349 | cc2 = | ||
350 | GNUNET_TRANSPORT_TESTING_connect_peers (p1, | ||
351 | p2, | ||
352 | &testing_connect_cb, | ||
353 | cc2); | ||
354 | } | ||
355 | |||
356 | |||
357 | static void | ||
358 | run (void *cls, char *const *args, const char *cfgfile, | ||
359 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
360 | { | ||
361 | die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL); | ||
362 | |||
363 | p1 = GNUNET_TRANSPORT_TESTING_start_peer (tth, | ||
364 | cfg_file_p1, 1, | ||
365 | ¬ify_receive, | ||
366 | ¬ify_connect, | ||
367 | ¬ify_disconnect, | ||
368 | &start_cb, | ||
369 | NULL); | ||
370 | |||
371 | p2 = GNUNET_TRANSPORT_TESTING_start_peer (tth, | ||
372 | cfg_file_p2, | ||
373 | 2, | ||
374 | ¬ify_receive, | ||
375 | ¬ify_connect, | ||
376 | ¬ify_disconnect, | ||
377 | &start_cb, | ||
378 | NULL); | ||
379 | |||
380 | if ((p1 == NULL) || (p2 == NULL)) | ||
381 | { | ||
382 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Fail! Could not start peers!\n"); | ||
383 | if (die_task != NULL) | ||
384 | GNUNET_SCHEDULER_cancel (die_task); | ||
385 | die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL); | ||
386 | return; | ||
387 | } | ||
388 | } | ||
389 | |||
390 | |||
391 | static int | ||
392 | check () | ||
393 | { | ||
394 | static char *const argv[] = { "test-transport-api", | ||
395 | "-c", | ||
396 | "test_transport_api_data.conf", | ||
397 | NULL | ||
398 | }; | ||
399 | static struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
400 | GNUNET_GETOPT_OPTION_END | ||
401 | }; | ||
402 | |||
403 | #if WRITECONFIG | ||
404 | setTransportOptions ("test_transport_api_data.conf"); | ||
405 | #endif | ||
406 | send_task = NULL; | ||
407 | |||
408 | ok = 1; | ||
409 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv, test_name, | ||
410 | "nohelp", options, &run, &ok); | ||
411 | |||
412 | return ok; | ||
413 | } | ||
414 | |||
415 | int | ||
416 | main (int argc, char *argv[]) | ||
417 | { | ||
418 | int ret; | ||
419 | |||
420 | test_name = GNUNET_TRANSPORT_TESTING_get_test_name (argv[0]); | ||
421 | GNUNET_log_setup (test_name, | ||
422 | "WARNING", | ||
423 | NULL); | ||
424 | |||
425 | test_source = GNUNET_TRANSPORT_TESTING_get_test_source_name (__FILE__); | ||
426 | test_plugin = GNUNET_TRANSPORT_TESTING_get_test_plugin_name (argv[0], | ||
427 | test_source); | ||
428 | |||
429 | tth = GNUNET_TRANSPORT_TESTING_init (); | ||
430 | |||
431 | cfg_file_p1 = GNUNET_TRANSPORT_TESTING_get_config_name (argv[0], 1); | ||
432 | cfg_file_p2 = GNUNET_TRANSPORT_TESTING_get_config_name (argv[0], 2); | ||
433 | |||
434 | ret = check (); | ||
435 | |||
436 | GNUNET_free (cfg_file_p1); | ||
437 | GNUNET_free (cfg_file_p2); | ||
438 | |||
439 | GNUNET_free (test_source); | ||
440 | GNUNET_free (test_plugin); | ||
441 | GNUNET_free (test_name); | ||
442 | |||
443 | GNUNET_TRANSPORT_TESTING_done (tth); | ||
444 | |||
445 | return ret; | ||
446 | } | ||
447 | |||
448 | /* end of test_transport_api_bidirectional_connect.c */ | ||
diff --git a/src/transport/test_transport_api_bidirectional_connect_peer1.conf b/src/transport/test_transport_api_bidirectional_connect_peer1.conf deleted file mode 100644 index dff464e45..000000000 --- a/src/transport/test_transport_api_bidirectional_connect_peer1.conf +++ /dev/null | |||
@@ -1,43 +0,0 @@ | |||
1 | @INLINE@ template_cfg_peer1.conf | ||
2 | [PATHS] | ||
3 | GNUNET_TEST_HOME = /tmp/test-transport/api-tcp-p1/ | ||
4 | |||
5 | [arm] | ||
6 | PORT = 12000 | ||
7 | UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-arm.sock | ||
8 | |||
9 | [statistics] | ||
10 | PORT = 12001 | ||
11 | UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-statistics.sock | ||
12 | |||
13 | [resolver] | ||
14 | PORT = 12002 | ||
15 | UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-resolver.sock | ||
16 | |||
17 | [peerinfo] | ||
18 | PORT = 12003 | ||
19 | UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-peerinfo.sock | ||
20 | |||
21 | [transport] | ||
22 | PORT = 12004 | ||
23 | UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p1-service-transport.sock | ||
24 | |||
25 | [transport-tcp] | ||
26 | PORT = 12005 | ||
27 | TIMEOUT = 5 s | ||
28 | |||
29 | [transport-udp] | ||
30 | PORT = 12006 | ||
31 | TIMEOUT = 5 s | ||
32 | |||
33 | [transport-unix] | ||
34 | PORT = 12007 | ||
35 | TIMEOUT = 5 s | ||
36 | |||
37 | [transport-http] | ||
38 | PORT = 12008 | ||
39 | TIMEOUT = 5 s | ||
40 | |||
41 | [transport-https] | ||
42 | PORT = 12009 | ||
43 | TIMEOUT = 5 s | ||
diff --git a/src/transport/test_transport_api_bidirectional_connect_peer2.conf b/src/transport/test_transport_api_bidirectional_connect_peer2.conf deleted file mode 100644 index 245175788..000000000 --- a/src/transport/test_transport_api_bidirectional_connect_peer2.conf +++ /dev/null | |||
@@ -1,43 +0,0 @@ | |||
1 | @INLINE@ template_cfg_peer2.conf | ||
2 | [PATHS] | ||
3 | GNUNET_TEST_HOME = /tmp/test-transport/api-tcp-p2/ | ||
4 | |||
5 | [arm] | ||
6 | PORT = 12010 | ||
7 | UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-arm.sock | ||
8 | |||
9 | [statistics] | ||
10 | PORT = 12011 | ||
11 | UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-statistics.sock | ||
12 | |||
13 | [resolver] | ||
14 | PORT = 12012 | ||
15 | UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-resolver.sock | ||
16 | |||
17 | [peerinfo] | ||
18 | PORT = 12013 | ||
19 | UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-peerinfo.sock | ||
20 | |||
21 | [transport] | ||
22 | PORT = 12014 | ||
23 | UNIXPATH = $GNUNET_RUNTIME_DIR/gnunet-p2-service-transport.sock | ||
24 | |||
25 | [transport-tcp] | ||
26 | PORT = 12015 | ||
27 | TIMEOUT = 5 s | ||
28 | |||
29 | [transport-udp] | ||
30 | PORT = 12016 | ||
31 | TIMEOUT = 5 s | ||
32 | |||
33 | [transport-unix] | ||
34 | PORT = 12017 | ||
35 | TIMEOUT = 5 s | ||
36 | |||
37 | [transport-http] | ||
38 | PORT = 12018 | ||
39 | TIMEOUT = 5 s | ||
40 | |||
41 | [transport-https] | ||
42 | PORT = 12019 | ||
43 | TIMEOUT = 5 s | ||
diff --git a/src/transport/test_transport_api_blacklisting.c b/src/transport/test_transport_api_blacklisting.c index 8dce4d48d..72f8a71a3 100644 --- a/src/transport/test_transport_api_blacklisting.c +++ b/src/transport/test_transport_api_blacklisting.c | |||
@@ -1,6 +1,6 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | Copyright (C) 2009, 2010, 2011 GNUnet e.V. | 3 | Copyright (C) 2009, 2010, 2011, 2016 GNUnet e.V. |
4 | 4 | ||
5 | GNUnet is free software; you can redistribute it and/or modify | 5 | GNUnet is free software; you can redistribute it and/or modify |
6 | it under the terms of the GNU General Public License as published | 6 | it under the terms of the GNU General Public License as published |
@@ -19,242 +19,127 @@ | |||
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file transport/transport_api_blacklisting.c | 22 | * @file transport/test_transport_api_blacklisting.c |
23 | * @brief test for the blacklisting API | 23 | * @brief test for the blacklisting API |
24 | * @author Matthias Wachs | 24 | * @author Matthias Wachs |
25 | * | 25 | * @author Christian Grothoff |
26 | */ | 26 | */ |
27 | #include "platform.h" | 27 | #include "platform.h" |
28 | #include "gnunet_transport_service.h" | 28 | #include "gnunet_transport_service.h" |
29 | #include "transport-testing.h" | 29 | #include "transport-testing.h" |
30 | 30 | ||
31 | static struct GNUNET_TRANSPORT_TESTING_PeerContext *p1; | 31 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) |
32 | |||
33 | static struct GNUNET_TRANSPORT_TESTING_PeerContext *p2; | ||
34 | |||
35 | static struct GNUNET_TRANSPORT_TESTING_ConnectRequest * cc; | ||
36 | |||
37 | static struct GNUNET_TRANSPORT_TransmitHandle *th; | ||
38 | |||
39 | static struct GNUNET_TRANSPORT_TESTING_Handle *tth; | ||
40 | |||
41 | /** | ||
42 | * How long until we give up on transmitting the message? | ||
43 | */ | ||
44 | #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120) | ||
45 | |||
46 | /** | ||
47 | * How long until we give up on transmitting the message? | ||
48 | */ | ||
49 | #define TIMEOUT_TRANSMIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60) | ||
50 | 32 | ||
51 | #define TEST_MESSAGE_SIZE 2600 | 33 | #define TEST_MESSAGE_SIZE 2600 |
52 | 34 | ||
53 | #define TEST_MESSAGE_TYPE 12345 | 35 | #define TEST_MESSAGE_TYPE 12345 |
54 | 36 | ||
55 | 37 | ||
56 | static int ok; | 38 | static struct GNUNET_TRANSPORT_TransmitHandle *th; |
39 | |||
40 | static struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc; | ||
41 | |||
57 | static int connected; | 42 | static int connected; |
58 | static int blacklist_request_p1; | ||
59 | static int blacklist_request_p2; | ||
60 | 43 | ||
61 | static struct GNUNET_TRANSPORT_Blacklist * blacklist_p1; | 44 | static int blacklist_request_p1; |
62 | 45 | ||
63 | static struct GNUNET_TRANSPORT_Blacklist * blacklist_p2; | 46 | static int blacklist_request_p2; |
64 | 47 | ||
65 | static struct GNUNET_SCHEDULER_Task * die_task; | 48 | static struct GNUNET_TRANSPORT_Blacklist *blacklist_p1; |
66 | 49 | ||
67 | static struct GNUNET_SCHEDULER_Task * send_task; | 50 | static struct GNUNET_TRANSPORT_Blacklist *blacklist_p2; |
68 | 51 | ||
69 | static struct GNUNET_SCHEDULER_Task * shutdown_task; | 52 | static struct GNUNET_SCHEDULER_Task *send_task; |
70 | 53 | ||
71 | #if VERBOSE | 54 | static struct GNUNET_SCHEDULER_Task *shutdown_task; |
72 | #define OKPP do { ok++; FPRINTF (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0) | ||
73 | #else | ||
74 | #define OKPP do { ok++; } while (0) | ||
75 | #endif | ||
76 | 55 | ||
77 | 56 | ||
78 | static void | 57 | static void |
79 | end (void *cls) | 58 | end (void *cls) |
80 | { | 59 | { |
81 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping\n"); | 60 | shutdown_task = NULL; |
82 | 61 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | |
83 | if (send_task != NULL) | 62 | "Stopping\n"); |
84 | GNUNET_SCHEDULER_cancel (send_task); | 63 | if ((GNUNET_YES == blacklist_request_p1) && |
85 | 64 | (GNUNET_YES == blacklist_request_p2) && | |
86 | if (die_task != NULL) | 65 | (GNUNET_NO == connected) ) |
87 | { | ||
88 | GNUNET_SCHEDULER_cancel (die_task); | ||
89 | die_task = NULL; | ||
90 | } | ||
91 | |||
92 | if (cc != NULL) | ||
93 | { | ||
94 | GNUNET_TRANSPORT_TESTING_connect_peers_cancel(cc); | ||
95 | cc = NULL; | ||
96 | } | ||
97 | |||
98 | if (th != NULL) | ||
99 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); | ||
100 | th = NULL; | ||
101 | |||
102 | if (blacklist_p1 != NULL) | ||
103 | { | ||
104 | GNUNET_TRANSPORT_blacklist_cancel (blacklist_p1); | ||
105 | blacklist_p1 = NULL; | ||
106 | } | ||
107 | |||
108 | if (blacklist_p2 != NULL) | ||
109 | { | ||
110 | GNUNET_TRANSPORT_blacklist_cancel (blacklist_p2); | ||
111 | blacklist_p2 = NULL; | ||
112 | } | ||
113 | |||
114 | if (p1 != NULL) | ||
115 | { | ||
116 | GNUNET_TRANSPORT_TESTING_stop_peer (p1); | ||
117 | p1 = NULL; | ||
118 | } | ||
119 | if (p2 != NULL) | ||
120 | { | ||
121 | GNUNET_TRANSPORT_TESTING_stop_peer (p2); | ||
122 | p2 = NULL; | ||
123 | } | ||
124 | |||
125 | if ((blacklist_request_p1 == GNUNET_YES) && | ||
126 | (blacklist_request_p2 == GNUNET_YES) && | ||
127 | (connected == GNUNET_NO)) | ||
128 | { | 66 | { |
129 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Peers were not connected, success\n")); | 67 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
130 | ok = 0; | 68 | "Peers were never connected, success\n"); |
69 | ccc->global_ret = GNUNET_OK; | ||
131 | } | 70 | } |
132 | else | 71 | else |
133 | { | 72 | { |
134 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Peers were not connected, fail\n")); | 73 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
135 | ok = 1; | 74 | "Peers were not connected, fail\n"); |
75 | ccc->global_ret = GNUNET_SYSERR; | ||
136 | } | 76 | } |
77 | GNUNET_SCHEDULER_shutdown (); | ||
137 | } | 78 | } |
138 | 79 | ||
139 | 80 | ||
140 | static void | 81 | static void |
141 | end_badly (void *cls) | 82 | custom_shutdown (void *cls) |
142 | { | 83 | { |
143 | if (send_task != NULL) | 84 | if (NULL != send_task) |
144 | { | 85 | { |
145 | GNUNET_SCHEDULER_cancel (send_task); | 86 | GNUNET_SCHEDULER_cancel (send_task); |
146 | send_task = NULL; | 87 | send_task = NULL; |
147 | } | 88 | } |
148 | 89 | if (NULL != shutdown_task) | |
149 | if (shutdown_task != NULL) | ||
150 | { | 90 | { |
151 | GNUNET_SCHEDULER_cancel (shutdown_task); | 91 | GNUNET_SCHEDULER_cancel (shutdown_task); |
152 | shutdown_task = NULL; | 92 | shutdown_task = NULL; |
153 | } | 93 | } |
154 | 94 | if (NULL != th) | |
155 | if (cc != NULL) | ||
156 | { | 95 | { |
157 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Fail! Could not connect peers\n")); | ||
158 | GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc); | ||
159 | cc = NULL; | ||
160 | } | ||
161 | |||
162 | if (th != NULL) | ||
163 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); | 96 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); |
164 | th = NULL; | 97 | th = NULL; |
165 | 98 | } | |
166 | if (blacklist_p1 != NULL) | 99 | if (NULL != blacklist_p1) |
100 | { | ||
167 | GNUNET_TRANSPORT_blacklist_cancel (blacklist_p1); | 101 | GNUNET_TRANSPORT_blacklist_cancel (blacklist_p1); |
168 | 102 | blacklist_p1 = NULL; | |
169 | if (blacklist_p2 != NULL) | 103 | } |
104 | if (NULL != blacklist_p2) | ||
105 | { | ||
170 | GNUNET_TRANSPORT_blacklist_cancel (blacklist_p2); | 106 | GNUNET_TRANSPORT_blacklist_cancel (blacklist_p2); |
171 | 107 | blacklist_p2 = NULL; | |
172 | if (p1 != NULL) | 108 | } |
173 | GNUNET_TRANSPORT_TESTING_stop_peer (p1); | ||
174 | if (p2 != NULL) | ||
175 | GNUNET_TRANSPORT_TESTING_stop_peer (p2); | ||
176 | |||
177 | ok = GNUNET_SYSERR; | ||
178 | } | 109 | } |
179 | 110 | ||
180 | 111 | ||
181 | static void | 112 | static void |
182 | notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer, | 113 | notify_receive (void *cls, |
114 | struct GNUNET_TRANSPORT_TESTING_PeerContext *receiver, | ||
115 | const struct GNUNET_PeerIdentity *sender, | ||
183 | const struct GNUNET_MessageHeader *message) | 116 | const struct GNUNET_MessageHeader *message) |
184 | { | 117 | { |
185 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; | 118 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
186 | struct GNUNET_TRANSPORT_TESTING_PeerContext *t = NULL; | 119 | "Unexpectedly even received the message despite blacklist\n"); |
187 | 120 | GNUNET_SCHEDULER_shutdown (); | |
188 | if (0 == memcmp (peer, &p1->id, sizeof (struct GNUNET_PeerIdentity))) | ||
189 | t = p1; | ||
190 | if (0 == memcmp (peer, &p2->id, sizeof (struct GNUNET_PeerIdentity))) | ||
191 | t = p2; | ||
192 | GNUNET_assert (t != NULL); | ||
193 | |||
194 | char *ps = GNUNET_strdup (GNUNET_i2s (&p->id)); | ||
195 | |||
196 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
197 | "Peer %u (`%4s') received message of type %d and size %u size from peer %u (`%4s')!\n", | ||
198 | p->no, ps, ntohs (message->type), ntohs (message->size), t->no, | ||
199 | GNUNET_i2s (&t->id)); | ||
200 | GNUNET_free (ps); | ||
201 | |||
202 | if ((TEST_MESSAGE_TYPE == ntohs (message->type)) && | ||
203 | (TEST_MESSAGE_SIZE == ntohs (message->size))) | ||
204 | { | ||
205 | ok = 0; | ||
206 | shutdown_task = GNUNET_SCHEDULER_add_now(&end, NULL); | ||
207 | } | ||
208 | else | ||
209 | { | ||
210 | GNUNET_break (0); | ||
211 | ok = 1; | ||
212 | shutdown_task = GNUNET_SCHEDULER_add_now(&end, NULL); | ||
213 | } | ||
214 | } | 121 | } |
215 | 122 | ||
216 | 123 | ||
217 | static size_t | 124 | static size_t |
218 | notify_ready (void *cls, size_t size, void *buf) | 125 | notify_ready (void *cls, |
126 | size_t size, | ||
127 | void *buf) | ||
219 | { | 128 | { |
220 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; | ||
221 | struct GNUNET_MessageHeader *hdr; | 129 | struct GNUNET_MessageHeader *hdr; |
222 | 130 | ||
223 | th = NULL; | 131 | th = NULL; |
224 | 132 | if (NULL == buf) | |
225 | if (buf == NULL) | ||
226 | { | 133 | { |
227 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 134 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
228 | "Timeout occurred while waiting for transmit_ready\n"); | 135 | "Timeout occurred while waiting for transmit_ready\n"); |
229 | if (NULL != die_task) | 136 | GNUNET_SCHEDULER_shutdown (); |
230 | { | ||
231 | GNUNET_SCHEDULER_cancel (die_task); | ||
232 | die_task = NULL; | ||
233 | } | ||
234 | die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL); | ||
235 | ok = 42; | ||
236 | return 0; | 137 | return 0; |
237 | } | 138 | } |
238 | |||
239 | GNUNET_assert (size >= TEST_MESSAGE_SIZE); | 139 | GNUNET_assert (size >= TEST_MESSAGE_SIZE); |
240 | hdr = buf; | 140 | hdr = buf; |
241 | hdr->size = htons (TEST_MESSAGE_SIZE); | 141 | hdr->size = htons (TEST_MESSAGE_SIZE); |
242 | hdr->type = htons (TEST_MESSAGE_TYPE); | 142 | hdr->type = htons (TEST_MESSAGE_TYPE); |
243 | |||
244 | { | ||
245 | char *ps = GNUNET_strdup (GNUNET_i2s (&p2->id)); | ||
246 | |||
247 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
248 | "Peer %u (`%4s') sending message with type %u and size %u bytes to peer %u (`%4s')\n", | ||
249 | p2->no, | ||
250 | ps, | ||
251 | ntohs (hdr->type), | ||
252 | ntohs (hdr->size), | ||
253 | p->no, | ||
254 | GNUNET_i2s (&p->id)); | ||
255 | GNUNET_free (ps); | ||
256 | } | ||
257 | |||
258 | return TEST_MESSAGE_SIZE; | 143 | return TEST_MESSAGE_SIZE; |
259 | } | 144 | } |
260 | 145 | ||
@@ -262,222 +147,123 @@ notify_ready (void *cls, size_t size, void *buf) | |||
262 | static void | 147 | static void |
263 | sendtask (void *cls) | 148 | sendtask (void *cls) |
264 | { | 149 | { |
265 | send_task = NULL; | 150 | th = GNUNET_TRANSPORT_notify_transmit_ready (ccc->p[1]->th, |
266 | char *receiver_s = GNUNET_strdup (GNUNET_i2s (&p1->id)); | 151 | &ccc->p[0]->id, |
267 | |||
268 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
269 | "Sending message from peer %u (`%4s') -> peer %u (`%s') !\n", | ||
270 | p2->no, GNUNET_i2s (&p2->id), p1->no, receiver_s); | ||
271 | GNUNET_free (receiver_s); | ||
272 | |||
273 | th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th, &p1->id, | ||
274 | TEST_MESSAGE_SIZE, | 152 | TEST_MESSAGE_SIZE, |
275 | TIMEOUT_TRANSMIT, ¬ify_ready, | 153 | TIMEOUT, |
276 | p1); | 154 | ¬ify_ready, |
155 | ccc->p[0]); | ||
277 | } | 156 | } |
278 | 157 | ||
279 | 158 | ||
280 | static void | 159 | static void |
281 | notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer) | 160 | notify_connect (void *cls, |
161 | struct GNUNET_TRANSPORT_TESTING_PeerContext *me, | ||
162 | const struct GNUNET_PeerIdentity *other) | ||
282 | { | 163 | { |
283 | static int c; | 164 | GNUNET_TRANSPORT_TESTING_log_connect (cls, |
284 | 165 | me, | |
285 | c++; | 166 | other); |
286 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; | 167 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
287 | struct GNUNET_TRANSPORT_TESTING_PeerContext *t = NULL; | 168 | "Peers connected despite blacklist!\n"); |
288 | 169 | connected = GNUNET_YES; /* this test now failed */ | |
289 | connected = GNUNET_YES; | 170 | GNUNET_SCHEDULER_cancel (shutdown_task); |
290 | if (0 == memcmp (peer, &p1->id, sizeof (struct GNUNET_PeerIdentity))) | 171 | end (NULL); |
291 | t = p1; | ||
292 | if (0 == memcmp (peer, &p2->id, sizeof (struct GNUNET_PeerIdentity))) | ||
293 | t = p2; | ||
294 | GNUNET_assert (t != NULL); | ||
295 | |||
296 | { | ||
297 | char *ps = GNUNET_strdup (GNUNET_i2s (&p->id)); | ||
298 | |||
299 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
300 | "Peer %u (`%4s'): peer %u (`%s') connected to me!\n", | ||
301 | p->no, | ||
302 | ps, | ||
303 | t->no, | ||
304 | GNUNET_i2s (peer)); | ||
305 | GNUNET_free (ps); | ||
306 | } | ||
307 | } | 172 | } |
308 | 173 | ||
309 | 174 | ||
310 | static void | 175 | static void |
311 | notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer) | 176 | notify_disconnect (void *cls, |
177 | struct GNUNET_TRANSPORT_TESTING_PeerContext *me, | ||
178 | const struct GNUNET_PeerIdentity *other) | ||
312 | { | 179 | { |
313 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; | 180 | GNUNET_TRANSPORT_TESTING_log_disconnect (cls, |
314 | char *ps = GNUNET_strdup (GNUNET_i2s (&p->id)); | 181 | me, |
315 | 182 | other); | |
316 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 183 | if (NULL != th) |
317 | "Peer %u (`%4s'): peer (`%s') disconnected from me!\n", p->no, ps, | 184 | { |
318 | GNUNET_i2s (peer)); | ||
319 | |||
320 | GNUNET_free (ps); | ||
321 | |||
322 | if (th != NULL) | ||
323 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); | 185 | GNUNET_TRANSPORT_notify_transmit_ready_cancel (th); |
324 | th = NULL; | 186 | th = NULL; |
325 | } | 187 | } |
326 | |||
327 | |||
328 | static void | ||
329 | testing_connect_cb (void *cls) | ||
330 | { | ||
331 | cc = NULL; | ||
332 | char *p1_c = GNUNET_strdup (GNUNET_i2s (&p1->id)); | ||
333 | |||
334 | connected = GNUNET_YES; | ||
335 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected: %u (%s) <-> %u (%s)\n", | ||
336 | p1->no, p1_c, p2->no, GNUNET_i2s (&p2->id)); | ||
337 | GNUNET_free (p1_c); | ||
338 | |||
339 | |||
340 | |||
341 | send_task = GNUNET_SCHEDULER_add_now (&sendtask, NULL); | ||
342 | } | 188 | } |
343 | 189 | ||
344 | 190 | ||
345 | static int | 191 | static int |
346 | blacklist_cb (void *cls, | 192 | blacklist_cb (void *cls, |
347 | const struct | 193 | const struct GNUNET_PeerIdentity *pid) |
348 | GNUNET_PeerIdentity * pid) | ||
349 | { | 194 | { |
350 | struct GNUNET_TRANSPORT_TESTING_PeerContext * p = cls; | 195 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; |
351 | int res = GNUNET_SYSERR; | 196 | int res = GNUNET_SYSERR; |
352 | 197 | ||
353 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 198 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
354 | "Peer %u : Blacklist request for peer `%s'\n", | 199 | "Peer %u: Blacklist request for peer `%s'\n", |
355 | p->no, | 200 | p->no, |
356 | GNUNET_i2s (pid)); | 201 | GNUNET_i2s (pid)); |
357 | 202 | ||
358 | if (p == p1) | 203 | if (p == ccc->p[0]) |
359 | { | 204 | { |
360 | blacklist_request_p1 = GNUNET_YES; | 205 | blacklist_request_p1 = GNUNET_YES; |
361 | res = GNUNET_OK; | 206 | res = GNUNET_OK; |
362 | } | 207 | } |
363 | else if (p == p2) | 208 | if (p == ccc->p[1]) |
364 | { | 209 | { |
365 | blacklist_request_p2 = GNUNET_YES; | 210 | blacklist_request_p2 = GNUNET_YES; |
366 | res = GNUNET_SYSERR; | 211 | res = GNUNET_SYSERR; |
367 | } | 212 | } |
368 | 213 | ||
369 | if (((blacklist_request_p2 == GNUNET_YES) && (blacklist_request_p1 == GNUNET_YES)) && (shutdown_task == NULL)) | 214 | if ( (GNUNET_YES == blacklist_request_p2) && |
215 | (GNUNET_YES == blacklist_request_p1) && | ||
216 | (NULL == shutdown_task) ) | ||
370 | { | 217 | { |
371 | shutdown_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 3), &end, NULL); | 218 | shutdown_task |
219 | = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3), | ||
220 | &end, | ||
221 | NULL); | ||
372 | } | 222 | } |
373 | |||
374 | return res; | 223 | return res; |
375 | } | 224 | } |
376 | 225 | ||
377 | 226 | ||
378 | static void | 227 | static void |
379 | start_cb (struct GNUNET_TRANSPORT_TESTING_PeerContext *p, void *cls) | 228 | start_blacklist (void *cls) |
380 | { | 229 | { |
381 | static int started; | ||
382 | |||
383 | started++; | ||
384 | |||
385 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer %u (`%s') started\n", p->no, | ||
386 | GNUNET_i2s (&p->id)); | ||
387 | |||
388 | if (started != 2) | ||
389 | return; | ||
390 | |||
391 | char *sender_c = GNUNET_strdup (GNUNET_i2s (&p1->id)); | ||
392 | |||
393 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 230 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
394 | "Test tries to connect peer %u (`%s') -> peer %u (`%s')\n", | 231 | "Starting blacklists\n"); |
395 | p1->no, sender_c, p2->no, GNUNET_i2s (&p2->id)); | 232 | blacklist_p1 = GNUNET_TRANSPORT_blacklist (ccc->p[0]->cfg, |
396 | GNUNET_free (sender_c); | ||
397 | |||
398 | cc = GNUNET_TRANSPORT_TESTING_connect_peers (p1, | ||
399 | p2, | ||
400 | &testing_connect_cb, | ||
401 | NULL); | ||
402 | |||
403 | } | ||
404 | |||
405 | |||
406 | static void | ||
407 | run (void *cls, char *const *args, const char *cfgfile, | ||
408 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
409 | { | ||
410 | die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, | ||
411 | &end_badly, | ||
412 | NULL); | ||
413 | connected = GNUNET_NO; | ||
414 | blacklist_request_p1 = GNUNET_NO; | ||
415 | blacklist_request_p2 = GNUNET_NO; | ||
416 | |||
417 | p1 = GNUNET_TRANSPORT_TESTING_start_peer (tth, | ||
418 | "test_transport_api_tcp_peer1.conf", 1, | ||
419 | ¬ify_receive, | ||
420 | ¬ify_connect, | ||
421 | ¬ify_disconnect, | ||
422 | &start_cb, | ||
423 | NULL); | ||
424 | |||
425 | p2 = GNUNET_TRANSPORT_TESTING_start_peer (tth, | ||
426 | "test_transport_api_tcp_peer2.conf", 2, | ||
427 | ¬ify_receive, | ||
428 | ¬ify_connect, | ||
429 | ¬ify_disconnect, | ||
430 | &start_cb, | ||
431 | NULL); | ||
432 | |||
433 | blacklist_p1 = GNUNET_TRANSPORT_blacklist (p1->cfg, | ||
434 | &blacklist_cb, | 233 | &blacklist_cb, |
435 | p1); | 234 | ccc->p[0]); |
436 | 235 | GNUNET_assert (NULL != blacklist_p1); | |
437 | blacklist_p2 = GNUNET_TRANSPORT_blacklist (p2->cfg, | 236 | blacklist_p2 = GNUNET_TRANSPORT_blacklist (ccc->p[1]->cfg, |
438 | &blacklist_cb, | 237 | &blacklist_cb, |
439 | p2); | 238 | ccc->p[1]); |
440 | 239 | GNUNET_assert (NULL != blacklist_p2); | |
441 | GNUNET_assert (blacklist_p1 != NULL); | ||
442 | GNUNET_assert (blacklist_p2 != NULL); | ||
443 | } | 240 | } |
444 | 241 | ||
445 | 242 | ||
446 | static int | 243 | int |
447 | check () | 244 | main (int argc, |
245 | char *argv[]) | ||
448 | { | 246 | { |
449 | static char *const argv[] = { "test-transport-api-blacklisting", | 247 | struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext my_ccc = { |
450 | "-c", | 248 | .pre_connect_task = &start_blacklist, |
451 | "test_transport_api_data.conf", | 249 | .connect_continuation = &sendtask, |
452 | NULL | 250 | .config_file = "test_transport_api_data.conf", |
251 | .rec = ¬ify_receive, | ||
252 | .nc = ¬ify_connect, | ||
253 | .nd = ¬ify_disconnect, | ||
254 | .shutdown_task = &custom_shutdown, | ||
255 | .timeout = TIMEOUT, | ||
256 | .bi_directional = GNUNET_YES | ||
453 | }; | 257 | }; |
454 | static struct GNUNET_GETOPT_CommandLineOption options[] = { | ||
455 | GNUNET_GETOPT_OPTION_END | ||
456 | }; | ||
457 | |||
458 | ok = 1; | ||
459 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv, "test-transport-api-blacklisting", | ||
460 | "nohelp", options, &run, &ok); | ||
461 | 258 | ||
462 | return ok; | 259 | ccc = &my_ccc; |
260 | if (GNUNET_OK != | ||
261 | GNUNET_TRANSPORT_TESTING_main (2, | ||
262 | &GNUNET_TRANSPORT_TESTING_connect_check, | ||
263 | ccc)) | ||
264 | return 1; | ||
265 | return 0; | ||
463 | } | 266 | } |
464 | 267 | ||
465 | int | ||
466 | main (int argc, char *argv[]) | ||
467 | { | ||
468 | int ret; | ||
469 | |||
470 | GNUNET_log_setup ("test-transport-api-blacklisting", | ||
471 | "WARNING", | ||
472 | NULL); | ||
473 | |||
474 | tth = GNUNET_TRANSPORT_TESTING_init (); | ||
475 | |||
476 | ret = check (); | ||
477 | |||
478 | GNUNET_TRANSPORT_TESTING_done (tth); | ||
479 | |||
480 | return ret; | ||
481 | } | ||
482 | 268 | ||
483 | /* end of transport_api_blacklisting.c */ | 269 | /* end of transport_api_blacklisting.c */ |
diff --git a/src/transport/test_transport_api_blacklisting_tcp_peer1.conf b/src/transport/test_transport_api_blacklisting_tcp_peer1.conf new file mode 100644 index 000000000..4bfe9b6ca --- /dev/null +++ b/src/transport/test_transport_api_blacklisting_tcp_peer1.conf | |||
@@ -0,0 +1,9 @@ | |||
1 | @INLINE@ template_cfg_peer1.conf | ||
2 | [PATHS] | ||
3 | GNUNET_TEST_HOME = /tmp/test-transport/api-tcp-p1/ | ||
4 | |||
5 | [transport] | ||
6 | PLUGINS = tcp | ||
7 | |||
8 | #[transport] | ||
9 | #PREFIX = valgrind | ||
diff --git a/src/transport/test_transport_api_blacklisting_tcp_peer2.conf b/src/transport/test_transport_api_blacklisting_tcp_peer2.conf new file mode 100644 index 000000000..e68cdbee4 --- /dev/null +++ b/src/transport/test_transport_api_blacklisting_tcp_peer2.conf | |||
@@ -0,0 +1,9 @@ | |||
1 | @INLINE@ template_cfg_peer2.conf | ||
2 | [PATHS] | ||
3 | GNUNET_TEST_HOME = /tmp/test-transport/api-tcp-p2/ | ||
4 | |||
5 | [transport] | ||
6 | PLUGINS = tcp | ||
7 | |||
8 | #[transport] | ||
9 | #PREFIX = valgrind | ||
diff --git a/src/transport/test_transport_api_slow_ats_peer2.conf b/src/transport/test_transport_api_slow_ats_peer2.conf index 4895e4c4f..6b67c89d8 100644 --- a/src/transport/test_transport_api_slow_ats_peer2.conf +++ b/src/transport/test_transport_api_slow_ats_peer2.conf | |||
@@ -6,4 +6,4 @@ GNUNET_TEST_HOME = /tmp/test-transport/api-slow-ats-p2/ | |||
6 | PLUGINS = tcp | 6 | PLUGINS = tcp |
7 | 7 | ||
8 | [ats] | 8 | [ats] |
9 | PREFIX = ./test_delay -t 30 -- | 9 | PREFIX = ./test_delay -t 10 -- |
diff --git a/src/transport/transport-testing-main.c b/src/transport/transport-testing-main.c index b8dbb9c03..de2ec3d0c 100644 --- a/src/transport/transport-testing-main.c +++ b/src/transport/transport-testing-main.c | |||
@@ -83,6 +83,11 @@ do_shutdown (void *cls) | |||
83 | GNUNET_SCHEDULER_cancel (ccc->timeout_task); | 83 | GNUNET_SCHEDULER_cancel (ccc->timeout_task); |
84 | ccc->timeout_task = NULL; | 84 | ccc->timeout_task = NULL; |
85 | } | 85 | } |
86 | if (NULL != ccc->connect_task) | ||
87 | { | ||
88 | GNUNET_SCHEDULER_cancel (ccc->connect_task); | ||
89 | ccc->connect_task = NULL; | ||
90 | } | ||
86 | while (NULL != (crl = ccc->crl_head)) | 91 | while (NULL != (crl = ccc->crl_head)) |
87 | { | 92 | { |
88 | GNUNET_CONTAINER_DLL_remove (ccc->crl_head, | 93 | GNUNET_CONTAINER_DLL_remove (ccc->crl_head, |
@@ -263,33 +268,23 @@ my_rec (void *cls, | |||
263 | 268 | ||
264 | 269 | ||
265 | /** | 270 | /** |
266 | * Function called once we have successfully launched a peer. | 271 | * Connect the peers as a clique. |
267 | * Once all peers have been launched, we connect all of them | ||
268 | * in a clique. | ||
269 | * | 272 | * |
270 | * @param p peer that was launched (redundant, kill ASAP) | 273 | * @param cls our `struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext` |
271 | * @param cls our `struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *` | ||
272 | */ | 274 | */ |
273 | static void | 275 | static void |
274 | start_cb (struct GNUNET_TRANSPORT_TESTING_PeerContext *p, | 276 | do_connect (void *cls) |
275 | void *cls) | ||
276 | { | 277 | { |
277 | struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *ipi = cls; | 278 | struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = cls; |
278 | struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = ipi->ccc; | ||
279 | |||
280 | ccc->started++; | ||
281 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
282 | "Peer %u (`%s') started\n", | ||
283 | p->no, | ||
284 | GNUNET_i2s (&p->id)); | ||
285 | if (ccc->started != ccc->num_peers) | ||
286 | return; | ||
287 | 279 | ||
280 | ccc->connect_task = NULL; | ||
288 | for (unsigned int i=0;i<ccc->num_peers;i++) | 281 | for (unsigned int i=0;i<ccc->num_peers;i++) |
289 | for (unsigned int j=i+1;j<ccc->num_peers;j++) | 282 | for (unsigned int j=(ccc->bi_directional ? 0 : i+1);j<ccc->num_peers;j++) |
290 | { | 283 | { |
291 | struct GNUNET_TRANSPORT_TESTING_ConnectRequestList *crl; | 284 | struct GNUNET_TRANSPORT_TESTING_ConnectRequestList *crl; |
292 | 285 | ||
286 | if (i == j) | ||
287 | continue; | ||
293 | crl = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_ConnectRequestList); | 288 | crl = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_ConnectRequestList); |
294 | GNUNET_CONTAINER_DLL_insert (ccc->crl_head, | 289 | GNUNET_CONTAINER_DLL_insert (ccc->crl_head, |
295 | ccc->crl_tail, | 290 | ccc->crl_tail, |
@@ -317,6 +312,44 @@ start_cb (struct GNUNET_TRANSPORT_TESTING_PeerContext *p, | |||
317 | 312 | ||
318 | 313 | ||
319 | /** | 314 | /** |
315 | * Function called once we have successfully launched a peer. | ||
316 | * Once all peers have been launched, we connect all of them | ||
317 | * in a clique. | ||
318 | * | ||
319 | * @param p peer that was launched (redundant, kill ASAP) | ||
320 | * @param cls our `struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *` | ||
321 | */ | ||
322 | static void | ||
323 | start_cb (struct GNUNET_TRANSPORT_TESTING_PeerContext *p, | ||
324 | void *cls) | ||
325 | { | ||
326 | struct GNUNET_TRANSPORT_TESTING_InternalPeerContext *ipi = cls; | ||
327 | struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext *ccc = ipi->ccc; | ||
328 | |||
329 | ccc->started++; | ||
330 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
331 | "Peer %u (`%s') started\n", | ||
332 | p->no, | ||
333 | GNUNET_i2s (&p->id)); | ||
334 | if (ccc->started != ccc->num_peers) | ||
335 | return; | ||
336 | if (NULL != ccc->pre_connect_task) | ||
337 | { | ||
338 | /* Run the custom per-connect job, then give it a second to | ||
339 | go into effect before we continue connecting peers. */ | ||
340 | ccc->pre_connect_task (ccc->pre_connect_task_cls); | ||
341 | ccc->connect_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, | ||
342 | &do_connect, | ||
343 | ccc); | ||
344 | } | ||
345 | else | ||
346 | { | ||
347 | do_connect (ccc); | ||
348 | } | ||
349 | } | ||
350 | |||
351 | |||
352 | /** | ||
320 | * Function run from #GNUNET_TRANSPORT_TESTING_connect_check | 353 | * Function run from #GNUNET_TRANSPORT_TESTING_connect_check |
321 | * once the scheduler is up. Should launch the peers and | 354 | * once the scheduler is up. Should launch the peers and |
322 | * then in the continuations try to connect them. | 355 | * then in the continuations try to connect them. |
diff --git a/src/transport/transport-testing.c b/src/transport/transport-testing.c index 95f4eb671..ae878a79e 100644 --- a/src/transport/transport-testing.c +++ b/src/transport/transport-testing.c | |||
@@ -44,23 +44,30 @@ find_peer_context (struct GNUNET_TRANSPORT_TESTING_Handle *tth, | |||
44 | } | 44 | } |
45 | 45 | ||
46 | 46 | ||
47 | static struct GNUNET_TRANSPORT_TESTING_ConnectRequest * | 47 | static void |
48 | find_connecting_context (struct GNUNET_TRANSPORT_TESTING_Handle *tth, | 48 | notify_connecting_context (struct GNUNET_TRANSPORT_TESTING_Handle *tth, |
49 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p1, | 49 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p1, |
50 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p2) | 50 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p2) |
51 | { | 51 | { |
52 | struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc; | 52 | struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc; |
53 | struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn; | ||
53 | 54 | ||
54 | for (cc = tth->cc_head; NULL != cc; cc = cc->next) | 55 | for (cc = tth->cc_head; NULL != cc; cc = ccn) |
55 | { | 56 | { |
57 | ccn = cc->next; | ||
56 | if ( (cc->p1 == p1) && | 58 | if ( (cc->p1 == p1) && |
57 | (cc->p2 == p2) ) | 59 | (cc->p2 == p2) ) |
58 | return cc; | 60 | cc->p1_c = GNUNET_YES; |
59 | if ( (cc->p1 == p2) && | 61 | if ( (cc->p1 == p2) && |
60 | (cc->p2 == p1) ) | 62 | (cc->p2 == p1) ) |
61 | return cc; | 63 | cc->p2_c = GNUNET_YES; |
64 | if ( (cc->p1_c == GNUNET_YES) && | ||
65 | (cc->p2_c == GNUNET_YES) ) | ||
66 | { | ||
67 | cc->cb (cc->cb_cls); | ||
68 | GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc); | ||
69 | } | ||
62 | } | 70 | } |
63 | return NULL; | ||
64 | } | 71 | } |
65 | 72 | ||
66 | 73 | ||
@@ -71,7 +78,6 @@ notify_connect (void *cls, | |||
71 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; | 78 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls; |
72 | char *p2_s; | 79 | char *p2_s; |
73 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p2; | 80 | struct GNUNET_TRANSPORT_TESTING_PeerContext *p2; |
74 | struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc; | ||
75 | 81 | ||
76 | p2 = find_peer_context (p->tth, | 82 | p2 = find_peer_context (p->tth, |
77 | peer); | 83 | peer); |
@@ -94,24 +100,9 @@ notify_connect (void *cls, | |||
94 | p->no, | 100 | p->no, |
95 | GNUNET_i2s (&p->id)); | 101 | GNUNET_i2s (&p->id)); |
96 | GNUNET_free (p2_s); | 102 | GNUNET_free (p2_s); |
97 | 103 | notify_connecting_context (p->tth, | |
98 | /* Find ConnectingContext */ | 104 | p, |
99 | cc = find_connecting_context (p->tth, | 105 | p2); |
100 | p, | ||
101 | p2); | ||
102 | if (NULL == cc) | ||
103 | return; | ||
104 | if (p == cc->p1) | ||
105 | cc->p1_c = GNUNET_YES; | ||
106 | if (p == cc->p2) | ||
107 | cc->p2_c = GNUNET_YES; | ||
108 | |||
109 | if ( (cc->p1_c == GNUNET_YES) && | ||
110 | (cc->p2_c == GNUNET_YES) ) | ||
111 | { | ||
112 | cc->cb (cc->cb_cls); | ||
113 | GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc); | ||
114 | } | ||
115 | } | 106 | } |
116 | 107 | ||
117 | 108 | ||
diff --git a/src/transport/transport-testing.h b/src/transport/transport-testing.h index 842c88374..b78d11dbe 100644 --- a/src/transport/transport-testing.h +++ b/src/transport/transport-testing.h | |||
@@ -459,10 +459,28 @@ struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext | |||
459 | void *shutdown_task_cls; | 459 | void *shutdown_task_cls; |
460 | 460 | ||
461 | /** | 461 | /** |
462 | * Custom task to run after peers were started but before we try to | ||
463 | * connect them. If this function is set, we wait ONE second after | ||
464 | * running this function until we continue with connecting the | ||
465 | * peers. | ||
466 | */ | ||
467 | GNUNET_SCHEDULER_TaskCallback pre_connect_task; | ||
468 | |||
469 | /** | ||
470 | * Closure for @e shutdown_task. | ||
471 | */ | ||
472 | void *pre_connect_task_cls; | ||
473 | |||
474 | /** | ||
462 | * When should the testcase time out? | 475 | * When should the testcase time out? |
463 | */ | 476 | */ |
464 | struct GNUNET_TIME_Relative timeout; | 477 | struct GNUNET_TIME_Relative timeout; |
465 | 478 | ||
479 | /** | ||
480 | * Should we try to create connections in both directions? | ||
481 | */ | ||
482 | int bi_directional; | ||
483 | |||
466 | /* ******* fields set by #GNUNET_TRANSPORT_TESTING_connect_check **** */ | 484 | /* ******* fields set by #GNUNET_TRANSPORT_TESTING_connect_check **** */ |
467 | 485 | ||
468 | /** | 486 | /** |
@@ -514,6 +532,11 @@ struct GNUNET_TRANSPORT_TESTING_ConnectCheckContext | |||
514 | struct GNUNET_SCHEDULER_Task *timeout_task; | 532 | struct GNUNET_SCHEDULER_Task *timeout_task; |
515 | 533 | ||
516 | /** | 534 | /** |
535 | * Task run to connect peers. | ||
536 | */ | ||
537 | struct GNUNET_SCHEDULER_Task *connect_task; | ||
538 | |||
539 | /** | ||
517 | * Number of peers that have been started. | 540 | * Number of peers that have been started. |
518 | */ | 541 | */ |
519 | unsigned int started; | 542 | unsigned int started; |