diff options
Diffstat (limited to 'src/nat-auto/gnunet-nat-auto_legacy.c')
-rw-r--r-- | src/nat-auto/gnunet-nat-auto_legacy.c | 459 |
1 files changed, 231 insertions, 228 deletions
diff --git a/src/nat-auto/gnunet-nat-auto_legacy.c b/src/nat-auto/gnunet-nat-auto_legacy.c index 333e75529..0a531d5cd 100644 --- a/src/nat-auto/gnunet-nat-auto_legacy.c +++ b/src/nat-auto/gnunet-nat-auto_legacy.c | |||
@@ -28,15 +28,16 @@ | |||
28 | #include "gnunet_nat_lib.h" | 28 | #include "gnunet_nat_lib.h" |
29 | #include "nat.h" | 29 | #include "nat.h" |
30 | 30 | ||
31 | #define LOG(kind, ...) GNUNET_log_from(kind, "nat", __VA_ARGS__) | 31 | #define LOG(kind, ...) GNUNET_log_from (kind, "nat", __VA_ARGS__) |
32 | 32 | ||
33 | #define NAT_SERVER_TIMEOUT \ | 33 | #define NAT_SERVER_TIMEOUT \ |
34 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30) | 34 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) |
35 | 35 | ||
36 | /** | 36 | /** |
37 | * Entry we keep for each incoming connection. | 37 | * Entry we keep for each incoming connection. |
38 | */ | 38 | */ |
39 | struct NatActivity { | 39 | struct NatActivity |
40 | { | ||
40 | /** | 41 | /** |
41 | * This is a doubly-linked list. | 42 | * This is a doubly-linked list. |
42 | */ | 43 | */ |
@@ -67,7 +68,8 @@ struct NatActivity { | |||
67 | /** | 68 | /** |
68 | * Entry we keep for each connection to the gnunet-nat-service. | 69 | * Entry we keep for each connection to the gnunet-nat-service. |
69 | */ | 70 | */ |
70 | struct ClientActivity { | 71 | struct ClientActivity |
72 | { | ||
71 | /** | 73 | /** |
72 | * This is a doubly-linked list. | 74 | * This is a doubly-linked list. |
73 | */ | 75 | */ |
@@ -93,7 +95,8 @@ struct ClientActivity { | |||
93 | /** | 95 | /** |
94 | * Handle to a NAT test. | 96 | * Handle to a NAT test. |
95 | */ | 97 | */ |
96 | struct GNUNET_NAT_Test { | 98 | struct GNUNET_NAT_Test |
99 | { | ||
97 | /** | 100 | /** |
98 | * Configuration used | 101 | * Configuration used |
99 | */ | 102 | */ |
@@ -180,22 +183,22 @@ struct GNUNET_NAT_Test { | |||
180 | * @param addrlen actual lenght of the @a addr | 183 | * @param addrlen actual lenght of the @a addr |
181 | */ | 184 | */ |
182 | static void | 185 | static void |
183 | reversal_cb(void *cls, const struct sockaddr *addr, socklen_t addrlen) | 186 | reversal_cb (void *cls, const struct sockaddr *addr, socklen_t addrlen) |
184 | { | 187 | { |
185 | struct GNUNET_NAT_Test *h = cls; | 188 | struct GNUNET_NAT_Test *h = cls; |
186 | const struct sockaddr_in *sa; | 189 | const struct sockaddr_in *sa; |
187 | 190 | ||
188 | if (sizeof(struct sockaddr_in) != addrlen) | 191 | if (sizeof(struct sockaddr_in) != addrlen) |
189 | return; | 192 | return; |
190 | sa = (const struct sockaddr_in *)addr; | 193 | sa = (const struct sockaddr_in *) addr; |
191 | if (h->data != sa->sin_port) | 194 | if (h->data != sa->sin_port) |
192 | { | 195 | { |
193 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 196 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
194 | "Received connection reversal request for wrong port\n"); | 197 | "Received connection reversal request for wrong port\n"); |
195 | return; /* wrong port */ | 198 | return; /* wrong port */ |
196 | } | 199 | } |
197 | /* report success */ | 200 | /* report success */ |
198 | h->report(h->report_cls, GNUNET_NAT_ERROR_SUCCESS); | 201 | h->report (h->report_cls, GNUNET_NAT_ERROR_SUCCESS); |
199 | } | 202 | } |
200 | 203 | ||
201 | 204 | ||
@@ -206,31 +209,31 @@ reversal_cb(void *cls, const struct sockaddr *addr, socklen_t addrlen) | |||
206 | * @param cls the `struct GNUNET_NAT_Test` | 209 | * @param cls the `struct GNUNET_NAT_Test` |
207 | */ | 210 | */ |
208 | static void | 211 | static void |
209 | do_udp_read(void *cls) | 212 | do_udp_read (void *cls) |
210 | { | 213 | { |
211 | struct GNUNET_NAT_Test *tst = cls; | 214 | struct GNUNET_NAT_Test *tst = cls; |
212 | uint16_t data; | 215 | uint16_t data; |
213 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 216 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
214 | 217 | ||
215 | tc = GNUNET_SCHEDULER_get_task_context(); | 218 | tc = GNUNET_SCHEDULER_get_task_context (); |
216 | tst->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | 219 | tst->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
217 | tst->lsock, | 220 | tst->lsock, |
218 | &do_udp_read, | 221 | &do_udp_read, |
219 | tst); | 222 | tst); |
220 | if ((NULL != tc->write_ready) && | 223 | if ((NULL != tc->write_ready) && |
221 | (GNUNET_NETWORK_fdset_isset(tc->read_ready, tst->lsock)) && | 224 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, tst->lsock)) && |
222 | (sizeof(data) == | 225 | (sizeof(data) == |
223 | GNUNET_NETWORK_socket_recv(tst->lsock, &data, sizeof(data)))) | 226 | GNUNET_NETWORK_socket_recv (tst->lsock, &data, sizeof(data)))) |
224 | { | 227 | { |
225 | if (data == tst->data) | 228 | if (data == tst->data) |
226 | tst->report(tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); | 229 | tst->report (tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); |
227 | else | 230 | else |
228 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 231 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
229 | "Received data mismatches expected value\n"); | 232 | "Received data mismatches expected value\n"); |
230 | } | 233 | } |
231 | else | 234 | else |
232 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 235 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
233 | "Failed to receive data from inbound connection\n"); | 236 | "Failed to receive data from inbound connection\n"); |
234 | } | 237 | } |
235 | 238 | ||
236 | 239 | ||
@@ -241,33 +244,33 @@ do_udp_read(void *cls) | |||
241 | * @param cls the `struct NatActivity` | 244 | * @param cls the `struct NatActivity` |
242 | */ | 245 | */ |
243 | static void | 246 | static void |
244 | do_read(void *cls) | 247 | do_read (void *cls) |
245 | { | 248 | { |
246 | struct NatActivity *na = cls; | 249 | struct NatActivity *na = cls; |
247 | struct GNUNET_NAT_Test *tst; | 250 | struct GNUNET_NAT_Test *tst; |
248 | uint16_t data; | 251 | uint16_t data; |
249 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 252 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
250 | 253 | ||
251 | tc = GNUNET_SCHEDULER_get_task_context(); | 254 | tc = GNUNET_SCHEDULER_get_task_context (); |
252 | na->rtask = NULL; | 255 | na->rtask = NULL; |
253 | tst = na->h; | 256 | tst = na->h; |
254 | GNUNET_CONTAINER_DLL_remove(tst->na_head, tst->na_tail, na); | 257 | GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, na); |
255 | if ((NULL != tc->write_ready) && | 258 | if ((NULL != tc->write_ready) && |
256 | (GNUNET_NETWORK_fdset_isset(tc->read_ready, na->sock)) && | 259 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, na->sock)) && |
257 | (sizeof(data) == | 260 | (sizeof(data) == |
258 | GNUNET_NETWORK_socket_recv(na->sock, &data, sizeof(data)))) | 261 | GNUNET_NETWORK_socket_recv (na->sock, &data, sizeof(data)))) |
259 | { | 262 | { |
260 | if (data == tst->data) | 263 | if (data == tst->data) |
261 | tst->report(tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); | 264 | tst->report (tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); |
262 | else | 265 | else |
263 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 266 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
264 | "Received data does not match expected value\n"); | 267 | "Received data does not match expected value\n"); |
265 | } | 268 | } |
266 | else | 269 | else |
267 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 270 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
268 | "Failed to receive data from inbound connection\n"); | 271 | "Failed to receive data from inbound connection\n"); |
269 | GNUNET_NETWORK_socket_close(na->sock); | 272 | GNUNET_NETWORK_socket_close (na->sock); |
270 | GNUNET_free(na); | 273 | GNUNET_free (na); |
271 | } | 274 | } |
272 | 275 | ||
273 | 276 | ||
@@ -278,32 +281,32 @@ do_read(void *cls) | |||
278 | * @param cls the `struct GNUNET_NAT_Test` | 281 | * @param cls the `struct GNUNET_NAT_Test` |
279 | */ | 282 | */ |
280 | static void | 283 | static void |
281 | do_accept(void *cls) | 284 | do_accept (void *cls) |
282 | { | 285 | { |
283 | struct GNUNET_NAT_Test *tst = cls; | 286 | struct GNUNET_NAT_Test *tst = cls; |
284 | struct GNUNET_NETWORK_Handle *s; | 287 | struct GNUNET_NETWORK_Handle *s; |
285 | struct NatActivity *wl; | 288 | struct NatActivity *wl; |
286 | 289 | ||
287 | tst->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | 290 | tst->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
288 | tst->lsock, | 291 | tst->lsock, |
289 | &do_accept, | 292 | &do_accept, |
290 | tst); | 293 | tst); |
291 | s = GNUNET_NETWORK_socket_accept(tst->lsock, NULL, NULL); | 294 | s = GNUNET_NETWORK_socket_accept (tst->lsock, NULL, NULL); |
292 | if (NULL == s) | 295 | if (NULL == s) |
293 | { | 296 | { |
294 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_INFO, "accept"); | 297 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "accept"); |
295 | return; /* odd error */ | 298 | return; /* odd error */ |
296 | } | 299 | } |
297 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 300 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
298 | "Got an inbound connection, waiting for data\n"); | 301 | "Got an inbound connection, waiting for data\n"); |
299 | wl = GNUNET_new(struct NatActivity); | 302 | wl = GNUNET_new (struct NatActivity); |
300 | wl->sock = s; | 303 | wl->sock = s; |
301 | wl->h = tst; | 304 | wl->h = tst; |
302 | wl->rtask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | 305 | wl->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
303 | wl->sock, | 306 | wl->sock, |
304 | &do_read, | 307 | &do_read, |
305 | wl); | 308 | wl); |
306 | GNUNET_CONTAINER_DLL_insert(tst->na_head, tst->na_tail, wl); | 309 | GNUNET_CONTAINER_DLL_insert (tst->na_head, tst->na_tail, wl); |
307 | } | 310 | } |
308 | 311 | ||
309 | 312 | ||
@@ -315,14 +318,14 @@ do_accept(void *cls) | |||
315 | * @param error error code | 318 | * @param error error code |
316 | */ | 319 | */ |
317 | static void | 320 | static void |
318 | mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | 321 | mq_error_handler (void *cls, enum GNUNET_MQ_Error error) |
319 | { | 322 | { |
320 | struct ClientActivity *ca = cls; | 323 | struct ClientActivity *ca = cls; |
321 | struct GNUNET_NAT_Test *tst = ca->h; | 324 | struct GNUNET_NAT_Test *tst = ca->h; |
322 | 325 | ||
323 | GNUNET_CONTAINER_DLL_remove(tst->ca_head, tst->ca_tail, ca); | 326 | GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, ca); |
324 | GNUNET_MQ_destroy(ca->mq); | 327 | GNUNET_MQ_destroy (ca->mq); |
325 | GNUNET_free(ca); | 328 | GNUNET_free (ca); |
326 | } | 329 | } |
327 | 330 | ||
328 | 331 | ||
@@ -336,10 +339,10 @@ mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | |||
336 | * @param addrlen actual length of the @a addr | 339 | * @param addrlen actual length of the @a addr |
337 | */ | 340 | */ |
338 | static void | 341 | static void |
339 | addr_cb(void *cls, | 342 | addr_cb (void *cls, |
340 | int add_remove, | 343 | int add_remove, |
341 | const struct sockaddr *addr, | 344 | const struct sockaddr *addr, |
342 | socklen_t addrlen) | 345 | socklen_t addrlen) |
343 | { | 346 | { |
344 | struct GNUNET_NAT_Test *h = cls; | 347 | struct GNUNET_NAT_Test *h = cls; |
345 | struct ClientActivity *ca; | 348 | struct ClientActivity *ca; |
@@ -350,38 +353,38 @@ addr_cb(void *cls, | |||
350 | if (GNUNET_YES != add_remove) | 353 | if (GNUNET_YES != add_remove) |
351 | return; | 354 | return; |
352 | if (addrlen != sizeof(struct sockaddr_in)) | 355 | if (addrlen != sizeof(struct sockaddr_in)) |
353 | { | 356 | { |
354 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 357 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
355 | "NAT test ignores IPv6 address `%s' returned from NAT library\n", | 358 | "NAT test ignores IPv6 address `%s' returned from NAT library\n", |
356 | GNUNET_a2s(addr, addrlen)); | 359 | GNUNET_a2s (addr, addrlen)); |
357 | return; /* ignore IPv6 here */ | 360 | return; /* ignore IPv6 here */ |
358 | } | 361 | } |
359 | LOG(GNUNET_ERROR_TYPE_INFO, | 362 | LOG (GNUNET_ERROR_TYPE_INFO, |
360 | "Asking gnunet-nat-server to connect to `%s'\n", | 363 | "Asking gnunet-nat-server to connect to `%s'\n", |
361 | GNUNET_a2s(addr, addrlen)); | 364 | GNUNET_a2s (addr, addrlen)); |
362 | 365 | ||
363 | ca = GNUNET_new(struct ClientActivity); | 366 | ca = GNUNET_new (struct ClientActivity); |
364 | ca->h = h; | 367 | ca->h = h; |
365 | ca->mq = GNUNET_CLIENT_connect(h->cfg, | 368 | ca->mq = GNUNET_CLIENT_connect (h->cfg, |
366 | "gnunet-nat-server", | 369 | "gnunet-nat-server", |
367 | NULL, | 370 | NULL, |
368 | &mq_error_handler, | 371 | &mq_error_handler, |
369 | ca); | 372 | ca); |
370 | if (NULL == ca->mq) | 373 | if (NULL == ca->mq) |
371 | { | 374 | { |
372 | GNUNET_free(ca); | 375 | GNUNET_free (ca); |
373 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 376 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
374 | _("Failed to connect to `gnunet-nat-server'\n")); | 377 | _ ("Failed to connect to `gnunet-nat-server'\n")); |
375 | return; | 378 | return; |
376 | } | 379 | } |
377 | GNUNET_CONTAINER_DLL_insert(h->ca_head, h->ca_tail, ca); | 380 | GNUNET_CONTAINER_DLL_insert (h->ca_head, h->ca_tail, ca); |
378 | sa = (const struct sockaddr_in *)addr; | 381 | sa = (const struct sockaddr_in *) addr; |
379 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_NAT_TEST); | 382 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAT_TEST); |
380 | msg->dst_ipv4 = sa->sin_addr.s_addr; | 383 | msg->dst_ipv4 = sa->sin_addr.s_addr; |
381 | msg->dport = sa->sin_port; | 384 | msg->dport = sa->sin_port; |
382 | msg->data = h->data; | 385 | msg->data = h->data; |
383 | msg->is_tcp = htonl((uint32_t)h->is_tcp); | 386 | msg->is_tcp = htonl ((uint32_t) h->is_tcp); |
384 | GNUNET_MQ_send(ca->mq, env); | 387 | GNUNET_MQ_send (ca->mq, env); |
385 | } | 388 | } |
386 | 389 | ||
387 | 390 | ||
@@ -394,15 +397,15 @@ addr_cb(void *cls, | |||
394 | * @param cls handle to the timed out NAT test | 397 | * @param cls handle to the timed out NAT test |
395 | */ | 398 | */ |
396 | static void | 399 | static void |
397 | do_timeout(void *cls) | 400 | do_timeout (void *cls) |
398 | { | 401 | { |
399 | struct GNUNET_NAT_Test *nh = cls; | 402 | struct GNUNET_NAT_Test *nh = cls; |
400 | 403 | ||
401 | nh->ttask = NULL; | 404 | nh->ttask = NULL; |
402 | nh->report(nh->report_cls, | 405 | nh->report (nh->report_cls, |
403 | (GNUNET_NAT_ERROR_SUCCESS == nh->status) | 406 | (GNUNET_NAT_ERROR_SUCCESS == nh->status) |
404 | ? GNUNET_NAT_ERROR_TIMEOUT | 407 | ? GNUNET_NAT_ERROR_TIMEOUT |
405 | : nh->status); | 408 | : nh->status); |
406 | } | 409 | } |
407 | 410 | ||
408 | 411 | ||
@@ -422,27 +425,27 @@ do_timeout(void *cls) | |||
422 | * @return handle to cancel NAT test or NULL. The error is always indicated via the report callback | 425 | * @return handle to cancel NAT test or NULL. The error is always indicated via the report callback |
423 | */ | 426 | */ |
424 | struct GNUNET_NAT_Test * | 427 | struct GNUNET_NAT_Test * |
425 | GNUNET_NAT_test_start(const struct GNUNET_CONFIGURATION_Handle *cfg, | 428 | GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, |
426 | int is_tcp, | 429 | int is_tcp, |
427 | uint16_t bnd_port, | 430 | uint16_t bnd_port, |
428 | uint16_t adv_port, | 431 | uint16_t adv_port, |
429 | struct GNUNET_TIME_Relative timeout, | 432 | struct GNUNET_TIME_Relative timeout, |
430 | GNUNET_NAT_TestCallback report, | 433 | GNUNET_NAT_TestCallback report, |
431 | void *report_cls) | 434 | void *report_cls) |
432 | { | 435 | { |
433 | struct GNUNET_NAT_Test *nh; | 436 | struct GNUNET_NAT_Test *nh; |
434 | struct sockaddr_in sa; | 437 | struct sockaddr_in sa; |
435 | const struct sockaddr *addrs[] = { (const struct sockaddr *)&sa }; | 438 | const struct sockaddr *addrs[] = { (const struct sockaddr *) &sa }; |
436 | const socklen_t addrlens[] = { sizeof(sa) }; | 439 | const socklen_t addrlens[] = { sizeof(sa) }; |
437 | 440 | ||
438 | memset(&sa, 0, sizeof(sa)); | 441 | memset (&sa, 0, sizeof(sa)); |
439 | sa.sin_family = AF_INET; | 442 | sa.sin_family = AF_INET; |
440 | sa.sin_port = htons(bnd_port); | 443 | sa.sin_port = htons (bnd_port); |
441 | #if HAVE_SOCKADDR_IN_SIN_LEN | 444 | #if HAVE_SOCKADDR_IN_SIN_LEN |
442 | sa.sin_len = sizeof(sa); | 445 | sa.sin_len = sizeof(sa); |
443 | #endif | 446 | #endif |
444 | 447 | ||
445 | nh = GNUNET_new(struct GNUNET_NAT_Test); | 448 | nh = GNUNET_new (struct GNUNET_NAT_Test); |
446 | nh->cfg = cfg; | 449 | nh->cfg = cfg; |
447 | nh->is_tcp = is_tcp; | 450 | nh->is_tcp = is_tcp; |
448 | nh->data = bnd_port; | 451 | nh->data = bnd_port; |
@@ -451,93 +454,93 @@ GNUNET_NAT_test_start(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
451 | nh->report_cls = report_cls; | 454 | nh->report_cls = report_cls; |
452 | nh->status = GNUNET_NAT_ERROR_SUCCESS; | 455 | nh->status = GNUNET_NAT_ERROR_SUCCESS; |
453 | if (0 == bnd_port) | 456 | if (0 == bnd_port) |
457 | { | ||
458 | nh->nat = GNUNET_NAT_register (cfg, | ||
459 | is_tcp, | ||
460 | 0, | ||
461 | 0, | ||
462 | NULL, | ||
463 | NULL, | ||
464 | &addr_cb, | ||
465 | &reversal_cb, | ||
466 | nh, | ||
467 | NULL); | ||
468 | } | ||
469 | else | ||
470 | { | ||
471 | nh->lsock = | ||
472 | GNUNET_NETWORK_socket_create (AF_INET, | ||
473 | (is_tcp == GNUNET_YES) ? SOCK_STREAM | ||
474 | : SOCK_DGRAM, | ||
475 | 0); | ||
476 | if ((nh->lsock == NULL) || | ||
477 | (GNUNET_OK != GNUNET_NETWORK_socket_bind (nh->lsock, | ||
478 | (const struct sockaddr *) &sa, | ||
479 | sizeof(sa)))) | ||
454 | { | 480 | { |
455 | nh->nat = GNUNET_NAT_register(cfg, | 481 | GNUNET_log ( |
456 | is_tcp, | 482 | GNUNET_ERROR_TYPE_ERROR, |
457 | 0, | 483 | _ ("Failed to create listen socket bound to `%s' for NAT test: %s\n"), |
458 | 0, | 484 | GNUNET_a2s ((const struct sockaddr *) &sa, sizeof(sa)), |
459 | NULL, | 485 | strerror (errno)); |
460 | NULL, | 486 | if (NULL != nh->lsock) |
461 | &addr_cb, | 487 | { |
462 | &reversal_cb, | 488 | GNUNET_NETWORK_socket_close (nh->lsock); |
463 | nh, | 489 | nh->lsock = NULL; |
464 | NULL); | 490 | } |
491 | nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR; | ||
492 | nh->ttask = GNUNET_SCHEDULER_add_now (&do_timeout, nh); | ||
493 | return nh; | ||
465 | } | 494 | } |
466 | else | 495 | if (GNUNET_YES == is_tcp) |
496 | { | ||
497 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_listen (nh->lsock, 5)); | ||
498 | nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | ||
499 | nh->lsock, | ||
500 | &do_accept, | ||
501 | nh); | ||
502 | } | ||
503 | else | ||
504 | { | ||
505 | nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | ||
506 | nh->lsock, | ||
507 | &do_udp_read, | ||
508 | nh); | ||
509 | } | ||
510 | LOG (GNUNET_ERROR_TYPE_INFO, | ||
511 | "NAT test listens on port %u (%s)\n", | ||
512 | bnd_port, | ||
513 | (GNUNET_YES == is_tcp) ? "tcp" : "udp"); | ||
514 | nh->nat = GNUNET_NAT_register (cfg, | ||
515 | is_tcp, | ||
516 | adv_port, | ||
517 | 1, | ||
518 | addrs, | ||
519 | addrlens, | ||
520 | &addr_cb, | ||
521 | NULL, | ||
522 | nh, | ||
523 | NULL); | ||
524 | if (NULL == nh->nat) | ||
467 | { | 525 | { |
468 | nh->lsock = | 526 | LOG (GNUNET_ERROR_TYPE_INFO, |
469 | GNUNET_NETWORK_socket_create(AF_INET, | 527 | _ ("NAT test failed to start NAT library\n")); |
470 | (is_tcp == GNUNET_YES) ? SOCK_STREAM | 528 | if (NULL != nh->ltask) |
471 | : SOCK_DGRAM, | 529 | { |
472 | 0); | 530 | GNUNET_SCHEDULER_cancel (nh->ltask); |
473 | if ((nh->lsock == NULL) || | 531 | nh->ltask = NULL; |
474 | (GNUNET_OK != GNUNET_NETWORK_socket_bind(nh->lsock, | 532 | } |
475 | (const struct sockaddr *)&sa, | 533 | if (NULL != nh->lsock) |
476 | sizeof(sa)))) | 534 | { |
477 | { | 535 | GNUNET_NETWORK_socket_close (nh->lsock); |
478 | GNUNET_log( | 536 | nh->lsock = NULL; |
479 | GNUNET_ERROR_TYPE_ERROR, | 537 | } |
480 | _("Failed to create listen socket bound to `%s' for NAT test: %s\n"), | 538 | nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED; |
481 | GNUNET_a2s((const struct sockaddr *)&sa, sizeof(sa)), | 539 | nh->ttask = GNUNET_SCHEDULER_add_now (&do_timeout, nh); |
482 | strerror(errno)); | 540 | return nh; |
483 | if (NULL != nh->lsock) | ||
484 | { | ||
485 | GNUNET_NETWORK_socket_close(nh->lsock); | ||
486 | nh->lsock = NULL; | ||
487 | } | ||
488 | nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR; | ||
489 | nh->ttask = GNUNET_SCHEDULER_add_now(&do_timeout, nh); | ||
490 | return nh; | ||
491 | } | ||
492 | if (GNUNET_YES == is_tcp) | ||
493 | { | ||
494 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_listen(nh->lsock, 5)); | ||
495 | nh->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
496 | nh->lsock, | ||
497 | &do_accept, | ||
498 | nh); | ||
499 | } | ||
500 | else | ||
501 | { | ||
502 | nh->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
503 | nh->lsock, | ||
504 | &do_udp_read, | ||
505 | nh); | ||
506 | } | ||
507 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
508 | "NAT test listens on port %u (%s)\n", | ||
509 | bnd_port, | ||
510 | (GNUNET_YES == is_tcp) ? "tcp" : "udp"); | ||
511 | nh->nat = GNUNET_NAT_register(cfg, | ||
512 | is_tcp, | ||
513 | adv_port, | ||
514 | 1, | ||
515 | addrs, | ||
516 | addrlens, | ||
517 | &addr_cb, | ||
518 | NULL, | ||
519 | nh, | ||
520 | NULL); | ||
521 | if (NULL == nh->nat) | ||
522 | { | ||
523 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
524 | _("NAT test failed to start NAT library\n")); | ||
525 | if (NULL != nh->ltask) | ||
526 | { | ||
527 | GNUNET_SCHEDULER_cancel(nh->ltask); | ||
528 | nh->ltask = NULL; | ||
529 | } | ||
530 | if (NULL != nh->lsock) | ||
531 | { | ||
532 | GNUNET_NETWORK_socket_close(nh->lsock); | ||
533 | nh->lsock = NULL; | ||
534 | } | ||
535 | nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED; | ||
536 | nh->ttask = GNUNET_SCHEDULER_add_now(&do_timeout, nh); | ||
537 | return nh; | ||
538 | } | ||
539 | } | 541 | } |
540 | nh->ttask = GNUNET_SCHEDULER_add_delayed(timeout, &do_timeout, nh); | 542 | } |
543 | nh->ttask = GNUNET_SCHEDULER_add_delayed (timeout, &do_timeout, nh); | ||
541 | return nh; | 544 | return nh; |
542 | } | 545 | } |
543 | 546 | ||
@@ -548,46 +551,46 @@ GNUNET_NAT_test_start(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
548 | * @param tst test to stop. | 551 | * @param tst test to stop. |
549 | */ | 552 | */ |
550 | void | 553 | void |
551 | GNUNET_NAT_test_stop(struct GNUNET_NAT_Test *tst) | 554 | GNUNET_NAT_test_stop (struct GNUNET_NAT_Test *tst) |
552 | { | 555 | { |
553 | struct NatActivity *pos; | 556 | struct NatActivity *pos; |
554 | struct ClientActivity *cpos; | 557 | struct ClientActivity *cpos; |
555 | 558 | ||
556 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Stopping NAT test\n"); | 559 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Stopping NAT test\n"); |
557 | while (NULL != (cpos = tst->ca_head)) | 560 | while (NULL != (cpos = tst->ca_head)) |
558 | { | 561 | { |
559 | GNUNET_CONTAINER_DLL_remove(tst->ca_head, tst->ca_tail, cpos); | 562 | GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, cpos); |
560 | GNUNET_MQ_destroy(cpos->mq); | 563 | GNUNET_MQ_destroy (cpos->mq); |
561 | GNUNET_free(cpos); | 564 | GNUNET_free (cpos); |
562 | } | 565 | } |
563 | while (NULL != (pos = tst->na_head)) | 566 | while (NULL != (pos = tst->na_head)) |
564 | { | 567 | { |
565 | GNUNET_CONTAINER_DLL_remove(tst->na_head, tst->na_tail, pos); | 568 | GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, pos); |
566 | GNUNET_SCHEDULER_cancel(pos->rtask); | 569 | GNUNET_SCHEDULER_cancel (pos->rtask); |
567 | GNUNET_NETWORK_socket_close(pos->sock); | 570 | GNUNET_NETWORK_socket_close (pos->sock); |
568 | GNUNET_free(pos); | 571 | GNUNET_free (pos); |
569 | } | 572 | } |
570 | if (NULL != tst->ttask) | 573 | if (NULL != tst->ttask) |
571 | { | 574 | { |
572 | GNUNET_SCHEDULER_cancel(tst->ttask); | 575 | GNUNET_SCHEDULER_cancel (tst->ttask); |
573 | tst->ttask = NULL; | 576 | tst->ttask = NULL; |
574 | } | 577 | } |
575 | if (NULL != tst->ltask) | 578 | if (NULL != tst->ltask) |
576 | { | 579 | { |
577 | GNUNET_SCHEDULER_cancel(tst->ltask); | 580 | GNUNET_SCHEDULER_cancel (tst->ltask); |
578 | tst->ltask = NULL; | 581 | tst->ltask = NULL; |
579 | } | 582 | } |
580 | if (NULL != tst->lsock) | 583 | if (NULL != tst->lsock) |
581 | { | 584 | { |
582 | GNUNET_NETWORK_socket_close(tst->lsock); | 585 | GNUNET_NETWORK_socket_close (tst->lsock); |
583 | tst->lsock = NULL; | 586 | tst->lsock = NULL; |
584 | } | 587 | } |
585 | if (NULL != tst->nat) | 588 | if (NULL != tst->nat) |
586 | { | 589 | { |
587 | GNUNET_NAT_unregister(tst->nat); | 590 | GNUNET_NAT_unregister (tst->nat); |
588 | tst->nat = NULL; | 591 | tst->nat = NULL; |
589 | } | 592 | } |
590 | GNUNET_free(tst); | 593 | GNUNET_free (tst); |
591 | } | 594 | } |
592 | 595 | ||
593 | /* end of nat_test.c */ | 596 | /* end of nat_test.c */ |