aboutsummaryrefslogtreecommitdiff
path: root/src/transport/test_transport_api_disconnect.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/transport/test_transport_api_disconnect.c')
-rw-r--r--src/transport/test_transport_api_disconnect.c208
1 files changed, 94 insertions, 114 deletions
diff --git a/src/transport/test_transport_api_disconnect.c b/src/transport/test_transport_api_disconnect.c
index 35cda3d04..08f57b670 100644
--- a/src/transport/test_transport_api_disconnect.c
+++ b/src/transport/test_transport_api_disconnect.c
@@ -67,11 +67,11 @@ static int peers_connected = 0;
67static int counter; 67static int counter;
68static int msgs_recv; 68static int msgs_recv;
69 69
70static GNUNET_SCHEDULER_TaskIdentifier die_task; 70static GNUNET_SCHEDULER_TaskIdentifier die_task;
71 71
72static GNUNET_SCHEDULER_TaskIdentifier tct; 72static GNUNET_SCHEDULER_TaskIdentifier tct;
73 73
74struct GNUNET_TRANSPORT_TransmitHandle * th; 74struct GNUNET_TRANSPORT_TransmitHandle *th;
75 75
76#if VERBOSE 76#if VERBOSE
77#define OKPP do { ok++; fprintf (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0) 77#define OKPP do { ok++; fprintf (stderr, "Now at stage %u at %s:%u\n", ok, __FILE__, __LINE__); } while (0)
@@ -80,18 +80,16 @@ struct GNUNET_TRANSPORT_TransmitHandle * th;
80#endif 80#endif
81 81
82 82
83static void 83static void peers_connect ();
84peers_connect ();
85 84
86static void 85static void
87end () 86end ()
88{ 87{
89 if (GNUNET_SCHEDULER_NO_TASK != die_task) 88 if (GNUNET_SCHEDULER_NO_TASK != die_task)
90 GNUNET_SCHEDULER_cancel (die_task); 89 GNUNET_SCHEDULER_cancel (die_task);
91 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 90 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from transports!\n");
92 "Disconnecting from transports!\n");
93 if (th != NULL) 91 if (th != NULL)
94 GNUNET_TRANSPORT_notify_transmit_ready_cancel(th); 92 GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
95 th = NULL; 93 th = NULL;
96 94
97 if (p1.th != NULL) 95 if (p1.th != NULL)
@@ -100,8 +98,8 @@ end ()
100 if (p2.th != NULL) 98 if (p2.th != NULL)
101 GNUNET_TRANSPORT_disconnect (p2.th); 99 GNUNET_TRANSPORT_disconnect (p2.th);
102 die_task = GNUNET_SCHEDULER_NO_TASK; 100 die_task = GNUNET_SCHEDULER_NO_TASK;
103 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 101 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
104 "Transports disconnected, returning success!\n"); 102 "Transports disconnected, returning success!\n");
105 ok = 0; 103 ok = 0;
106} 104}
107 105
@@ -110,13 +108,13 @@ stop_arm (struct PeerContext *p)
110{ 108{
111#if START_ARM 109#if START_ARM
112 if (NULL != p->arm_proc) 110 if (NULL != p->arm_proc)
113 { 111 {
114 if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM)) 112 if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
115 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); 113 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
116 GNUNET_OS_process_wait (p->arm_proc); 114 GNUNET_OS_process_wait (p->arm_proc);
117 GNUNET_OS_process_close (p->arm_proc); 115 GNUNET_OS_process_close (p->arm_proc);
118 p->arm_proc = NULL; 116 p->arm_proc = NULL;
119 } 117 }
120#endif 118#endif
121 GNUNET_CONFIGURATION_destroy (p->cfg); 119 GNUNET_CONFIGURATION_destroy (p->cfg);
122} 120}
@@ -125,16 +123,15 @@ stop_arm (struct PeerContext *p)
125 123
126 124
127static void 125static void
128exchange_hello_last (void *cls, 126exchange_hello_last (void *cls, const struct GNUNET_MessageHeader *message)
129 const struct GNUNET_MessageHeader *message)
130{ 127{
131 struct PeerContext *me = cls; 128 struct PeerContext *me = cls;
132 129
133 GNUNET_assert (message != NULL); 130 GNUNET_assert (message != NULL);
134 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 131 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
135 "Exchanging HELLO of size %d with peer (%s)!\n", 132 "Exchanging HELLO of size %d with peer (%s)!\n",
136 (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message), 133 (int) GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
137 GNUNET_i2s (&me->id)); 134 message), GNUNET_i2s (&me->id));
138 GNUNET_assert (GNUNET_OK == 135 GNUNET_assert (GNUNET_OK ==
139 GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) 136 GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
140 message, &me->id)); 137 message, &me->id));
@@ -143,8 +140,7 @@ exchange_hello_last (void *cls,
143 140
144 141
145static void 142static void
146exchange_hello (void *cls, 143exchange_hello (void *cls, const struct GNUNET_MessageHeader *message)
147 const struct GNUNET_MessageHeader *message)
148{ 144{
149 struct PeerContext *me = cls; 145 struct PeerContext *me = cls;
150 146
@@ -153,9 +149,9 @@ exchange_hello (void *cls,
153 GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) 149 GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
154 message, &me->id)); 150 message, &me->id));
155 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 151 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
156 "Exchanging HELLO of size %d from peer %s!\n", 152 "Exchanging HELLO of size %d from peer %s!\n",
157 (int) GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *)message), 153 (int) GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *)
158 GNUNET_i2s (&me->id)); 154 message), GNUNET_i2s (&me->id));
159 GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL); 155 GNUNET_TRANSPORT_offer_hello (p2.th, message, NULL, NULL);
160} 156}
161 157
@@ -167,23 +163,23 @@ end_badly ()
167 GNUNET_break (0); 163 GNUNET_break (0);
168 164
169 if (th != NULL) 165 if (th != NULL)
170 { 166 {
171 GNUNET_TRANSPORT_notify_transmit_ready_cancel(th); 167 GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
172 th = NULL; 168 th = NULL;
173 } 169 }
174 else 170 else
175 { 171 {
176 GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2); 172 GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
177 GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1); 173 GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
178 } 174 }
179 175
180 GNUNET_TRANSPORT_disconnect (p1.th); 176 GNUNET_TRANSPORT_disconnect (p1.th);
181 GNUNET_TRANSPORT_disconnect (p2.th); 177 GNUNET_TRANSPORT_disconnect (p2.th);
182 if (GNUNET_SCHEDULER_NO_TASK != tct) 178 if (GNUNET_SCHEDULER_NO_TASK != tct)
183 { 179 {
184 GNUNET_SCHEDULER_cancel (tct); 180 GNUNET_SCHEDULER_cancel (tct);
185 tct = GNUNET_SCHEDULER_NO_TASK; 181 tct = GNUNET_SCHEDULER_NO_TASK;
186 } 182 }
187 ok = 1; 183 ok = 1;
188} 184}
189 185
@@ -196,20 +192,17 @@ notify_receive (void *cls,
196 uint32_t ats_count) 192 uint32_t ats_count)
197{ 193{
198 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 194 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
199 "Received message of type %d from peer %s!\n", 195 "Received message of type %d from peer %s!\n",
200 ntohs(message->type), 196 ntohs (message->type), GNUNET_i2s (peer));
201 GNUNET_i2s (peer));
202 OKPP; 197 OKPP;
203 GNUNET_assert (MTYPE == ntohs (message->type)); 198 GNUNET_assert (MTYPE == ntohs (message->type));
204 GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == 199 GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (message->size));
205 ntohs (message->size));
206 200
207 msgs_recv++; 201 msgs_recv++;
208} 202}
209 203
210static void 204static void
211peers_disconnect (void *cls, 205peers_disconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
212 const struct GNUNET_SCHEDULER_TaskContext *tc);
213 206
214static size_t 207static size_t
215notify_ready (void *cls, size_t size, void *buf) 208notify_ready (void *cls, size_t size, void *buf)
@@ -220,9 +213,8 @@ notify_ready (void *cls, size_t size, void *buf)
220 th = NULL; 213 th = NULL;
221 214
222 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 215 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
223 "Transmitting message with %u bytes to peer %s\n", 216 "Transmitting message with %u bytes to peer %s\n",
224 sizeof (struct GNUNET_MessageHeader), 217 sizeof (struct GNUNET_MessageHeader), GNUNET_i2s (&p->id));
225 GNUNET_i2s (&p->id));
226 GNUNET_assert (size >= 256); 218 GNUNET_assert (size >= 256);
227 OKPP; 219 OKPP;
228 if (buf != NULL) 220 if (buf != NULL)
@@ -245,94 +237,83 @@ notify_connect (void *cls,
245 uint32_t ats_count) 237 uint32_t ats_count)
246{ 238{
247 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 239 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
248 "Peer `%4s' connected to us (%p)!\n", 240 "Peer `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
249 GNUNET_i2s (peer),
250 cls);
251 peers_connected++; 241 peers_connected++;
252 if (cls == &p1) 242 if (cls == &p1)
253 { 243 {
254 GNUNET_assert (ok >= 2); 244 GNUNET_assert (ok >= 2);
255 OKPP; 245 OKPP;
256 OKPP; 246 OKPP;
257 if (GNUNET_SCHEDULER_NO_TASK != die_task) 247 if (GNUNET_SCHEDULER_NO_TASK != die_task)
258 GNUNET_SCHEDULER_cancel (die_task); 248 GNUNET_SCHEDULER_cancel (die_task);
259 if (GNUNET_SCHEDULER_NO_TASK != tct) 249 if (GNUNET_SCHEDULER_NO_TASK != tct)
260 GNUNET_SCHEDULER_cancel (tct); 250 GNUNET_SCHEDULER_cancel (tct);
261 tct = GNUNET_SCHEDULER_NO_TASK; 251 tct = GNUNET_SCHEDULER_NO_TASK;
262 252
263 die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT_TRANSMIT, 253 die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT_TRANSMIT,
264 &end_badly, NULL); 254 &end_badly, NULL);
265 th = GNUNET_TRANSPORT_notify_transmit_ready (p1.th, 255 th = GNUNET_TRANSPORT_notify_transmit_ready (p1.th,
266 &p2.id, 256 &p2.id,
267 256, 0, TIMEOUT, &notify_ready, 257 256, 0, TIMEOUT, &notify_ready,
268 &p1); 258 &p1);
269 } 259 }
270} 260}
271 261
272 262
273static void 263static void
274notify_disconnect (void *cls, 264notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
275 const struct GNUNET_PeerIdentity *peer)
276{ 265{
277 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 266 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
278 "Peer `%4s' disconnected (%p)!\n", 267 "Peer `%4s' disconnected (%p)!\n", GNUNET_i2s (peer), cls);
279 GNUNET_i2s (peer), cls);
280 peers_connected--; 268 peers_connected--;
281} 269}
282 270
283 271
284static void 272static void
285setup_peer (struct PeerContext *p, 273setup_peer (struct PeerContext *p, const char *cfgname)
286 const char *cfgname)
287{ 274{
288 p->cfg = GNUNET_CONFIGURATION_create (); 275 p->cfg = GNUNET_CONFIGURATION_create ();
289 276
290 GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); 277 GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
291 if (GNUNET_CONFIGURATION_have_value (p->cfg,"PATHS", "SERVICEHOME")) 278 if (GNUNET_CONFIGURATION_have_value (p->cfg, "PATHS", "SERVICEHOME"))
292 GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME", &p->servicehome); 279 GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME",
280 &p->servicehome);
293 if (NULL != p->servicehome) 281 if (NULL != p->servicehome)
294 GNUNET_DISK_directory_remove (p->servicehome); 282 GNUNET_DISK_directory_remove (p->servicehome);
295 283
296#if START_ARM 284#if START_ARM
297 p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm", 285 p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
298 "gnunet-service-arm", 286 "gnunet-service-arm",
299#if VERBOSE_ARM 287#if VERBOSE_ARM
300 "-L", "DEBUG", 288 "-L", "DEBUG",
301#endif 289#endif
302 "-c", cfgname, NULL); 290 "-c", cfgname, NULL);
303#endif 291#endif
304 292
305} 293}
306 294
307 295
308static void 296static void
309try_connect (void *cls, 297try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
310 const struct GNUNET_SCHEDULER_TaskContext *tc)
311{ 298{
312 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 299 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking peers to connect...\n");
313 "Asking peers to connect...\n");
314 /* FIXME: 'pX.id' may still be all-zeros here... */ 300 /* FIXME: 'pX.id' may still be all-zeros here... */
315 GNUNET_TRANSPORT_try_connect (p2.th, 301 GNUNET_TRANSPORT_try_connect (p2.th, &p1.id);
316 &p1.id); 302 GNUNET_TRANSPORT_try_connect (p1.th, &p2.id);
317 GNUNET_TRANSPORT_try_connect (p1.th,
318 &p2.id);
319 tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, 303 tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
320 &try_connect, 304 &try_connect, NULL);
321 NULL);
322} 305}
323 306
324 307
325static void 308static void
326peers_disconnect (void *cls, 309peers_disconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
327 const struct GNUNET_SCHEDULER_TaskContext *tc)
328{ 310{
329 if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0) 311 if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
330 return; 312 return;
331 313
332 //while (peers_connected > 0); 314 //while (peers_connected > 0);
333 315
334 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 316 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from Transport \n");
335 "Disconnecting from Transport \n");
336 317
337 GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2); 318 GNUNET_TRANSPORT_get_hello_cancel (p2.th, &exchange_hello_last, &p2);
338 GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1); 319 GNUNET_TRANSPORT_get_hello_cancel (p1.th, &exchange_hello, &p1);
@@ -343,10 +324,10 @@ peers_disconnect (void *cls,
343 GNUNET_TRANSPORT_disconnect (p2.th); 324 GNUNET_TRANSPORT_disconnect (p2.th);
344 p2.th = NULL; 325 p2.th = NULL;
345 326
346 while (peers_connected > 0); 327 while (peers_connected > 0) ;
347 328
348 if (counter < ITERATIONS) 329 if (counter < ITERATIONS)
349 peers_connect(); 330 peers_connect ();
350 else 331 else
351 end (); 332 end ();
352} 333}
@@ -354,8 +335,9 @@ peers_disconnect (void *cls,
354static void 335static void
355peers_connect () 336peers_connect ()
356{ 337{
357 counter ++; 338 counter++;
358 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iteration %i of %i\n", counter, ITERATIONS); 339 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Iteration %i of %i\n", counter,
340 ITERATIONS);
359 341
360 GNUNET_assert (p1.th == NULL); 342 GNUNET_assert (p1.th == NULL);
361 p1.th = GNUNET_TRANSPORT_connect (p1.cfg, 343 p1.th = GNUNET_TRANSPORT_connect (p1.cfg,
@@ -369,8 +351,8 @@ peers_connect ()
369 &notify_receive, 351 &notify_receive,
370 &notify_connect, &notify_disconnect); 352 &notify_connect, &notify_disconnect);
371 353
372 GNUNET_assert(p1.th != NULL); 354 GNUNET_assert (p1.th != NULL);
373 GNUNET_assert(p2.th != NULL); 355 GNUNET_assert (p2.th != NULL);
374 356
375 GNUNET_TRANSPORT_get_hello (p1.th, &exchange_hello, &p1); 357 GNUNET_TRANSPORT_get_hello (p1.th, &exchange_hello, &p1);
376 GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2); 358 GNUNET_TRANSPORT_get_hello (p2.th, &exchange_hello_last, &p2);
@@ -384,8 +366,7 @@ run (void *cls,
384{ 366{
385 GNUNET_assert (ok == 1); 367 GNUNET_assert (ok == 1);
386 OKPP; 368 OKPP;
387 die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, 369 die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
388 &end_badly, NULL);
389 370
390 setup_peer (&p1, "test_transport_api_tcp_peer1.conf"); 371 setup_peer (&p1, "test_transport_api_tcp_peer1.conf");
391 setup_peer (&p2, "test_transport_api_tcp_peer2.conf"); 372 setup_peer (&p2, "test_transport_api_tcp_peer2.conf");
@@ -409,25 +390,24 @@ check ()
409 }; 390 };
410 391
411#if WRITECONFIG 392#if WRITECONFIG
412 setTransportOptions("test_transport_api_data.conf"); 393 setTransportOptions ("test_transport_api_data.conf");
413#endif 394#endif
414 ok = 1; 395 ok = 1;
415 GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, 396 GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
416 argv, "test-transport-api", "nohelp", 397 argv, "test-transport-api", "nohelp", options, &run, &ok);
417 options, &run, &ok);
418 stop_arm (&p1); 398 stop_arm (&p1);
419 stop_arm (&p2); 399 stop_arm (&p2);
420 400
421 if (p1.servicehome != NULL) 401 if (p1.servicehome != NULL)
422 { 402 {
423 GNUNET_DISK_directory_remove (p1.servicehome); 403 GNUNET_DISK_directory_remove (p1.servicehome);
424 GNUNET_free(p1.servicehome); 404 GNUNET_free (p1.servicehome);
425 } 405 }
426 if (p2.servicehome != NULL) 406 if (p2.servicehome != NULL)
427 { 407 {
428 GNUNET_DISK_directory_remove (p2.servicehome); 408 GNUNET_DISK_directory_remove (p2.servicehome);
429 GNUNET_free(p2.servicehome); 409 GNUNET_free (p2.servicehome);
430 } 410 }
431 return ok; 411 return ok;
432} 412}
433 413