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