diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/nat-auto/nat_auto_api_test.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/nat-auto/nat_auto_api_test.c')
-rw-r--r-- | src/nat-auto/nat_auto_api_test.c | 473 |
1 files changed, 238 insertions, 235 deletions
diff --git a/src/nat-auto/nat_auto_api_test.c b/src/nat-auto/nat_auto_api_test.c index daea3063c..0d35d869f 100644 --- a/src/nat-auto/nat_auto_api_test.c +++ b/src/nat-auto/nat_auto_api_test.c | |||
@@ -28,15 +28,16 @@ | |||
28 | #include "gnunet_nat_auto_service.h" | 28 | #include "gnunet_nat_auto_service.h" |
29 | #include "nat-auto.h" | 29 | #include "nat-auto.h" |
30 | 30 | ||
31 | #define LOG(kind, ...) GNUNET_log_from(kind, "nat-auto", __VA_ARGS__) | 31 | #define LOG(kind, ...) GNUNET_log_from (kind, "nat-auto", __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_AUTO_Test { | 98 | struct GNUNET_NAT_AUTO_Test |
99 | { | ||
97 | /** | 100 | /** |
98 | * Configuration used | 101 | * Configuration used |
99 | */ | 102 | */ |
@@ -180,22 +183,22 @@ struct GNUNET_NAT_AUTO_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_AUTO_Test *h = cls; | 188 | struct GNUNET_NAT_AUTO_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_AUTO_Test` | 209 | * @param cls the `struct GNUNET_NAT_AUTO_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_AUTO_Test *tst = cls; | 214 | struct GNUNET_NAT_AUTO_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_AUTO_Test *tst; | 250 | struct GNUNET_NAT_AUTO_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_AUTO_Test` | 281 | * @param cls the `struct GNUNET_NAT_AUTO_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_AUTO_Test *tst = cls; | 286 | struct GNUNET_NAT_AUTO_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_AUTO_Test *tst = ca->h; | 324 | struct GNUNET_NAT_AUTO_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 | ||
@@ -339,12 +342,12 @@ mq_error_handler(void *cls, enum GNUNET_MQ_Error error) | |||
339 | * @param addrlen actual length of the @a addr | 342 | * @param addrlen actual length of the @a addr |
340 | */ | 343 | */ |
341 | static void | 344 | static void |
342 | addr_cb(void *cls, | 345 | addr_cb (void *cls, |
343 | void **app_ctx, | 346 | void **app_ctx, |
344 | int add_remove, | 347 | int add_remove, |
345 | enum GNUNET_NAT_AddressClass ac, | 348 | enum GNUNET_NAT_AddressClass ac, |
346 | const struct sockaddr *addr, | 349 | const struct sockaddr *addr, |
347 | socklen_t addrlen) | 350 | socklen_t addrlen) |
348 | { | 351 | { |
349 | struct GNUNET_NAT_AUTO_Test *h = cls; | 352 | struct GNUNET_NAT_AUTO_Test *h = cls; |
350 | struct ClientActivity *ca; | 353 | struct ClientActivity *ca; |
@@ -352,42 +355,42 @@ addr_cb(void *cls, | |||
352 | struct GNUNET_NAT_AUTO_TestMessage *msg; | 355 | struct GNUNET_NAT_AUTO_TestMessage *msg; |
353 | const struct sockaddr_in *sa; | 356 | const struct sockaddr_in *sa; |
354 | 357 | ||
355 | (void)app_ctx; | 358 | (void) app_ctx; |
356 | if (GNUNET_YES != add_remove) | 359 | if (GNUNET_YES != add_remove) |
357 | return; | 360 | return; |
358 | if (addrlen != sizeof(struct sockaddr_in)) | 361 | if (addrlen != sizeof(struct sockaddr_in)) |
359 | { | 362 | { |
360 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 363 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
361 | "NAT test ignores IPv6 address `%s' returned from NAT library\n", | 364 | "NAT test ignores IPv6 address `%s' returned from NAT library\n", |
362 | GNUNET_a2s(addr, addrlen)); | 365 | GNUNET_a2s (addr, addrlen)); |
363 | return; /* ignore IPv6 here */ | 366 | return; /* ignore IPv6 here */ |
364 | } | 367 | } |
365 | LOG(GNUNET_ERROR_TYPE_INFO, | 368 | LOG (GNUNET_ERROR_TYPE_INFO, |
366 | "Asking gnunet-nat-server to connect to `%s'\n", | 369 | "Asking gnunet-nat-server to connect to `%s'\n", |
367 | GNUNET_a2s(addr, addrlen)); | 370 | GNUNET_a2s (addr, addrlen)); |
368 | 371 | ||
369 | ca = GNUNET_new(struct ClientActivity); | 372 | ca = GNUNET_new (struct ClientActivity); |
370 | ca->h = h; | 373 | ca->h = h; |
371 | ca->mq = GNUNET_CLIENT_connect(h->cfg, | 374 | ca->mq = GNUNET_CLIENT_connect (h->cfg, |
372 | "gnunet-nat-server", | 375 | "gnunet-nat-server", |
373 | NULL, | 376 | NULL, |
374 | &mq_error_handler, | 377 | &mq_error_handler, |
375 | ca); | 378 | ca); |
376 | if (NULL == ca->mq) | 379 | if (NULL == ca->mq) |
377 | { | 380 | { |
378 | GNUNET_free(ca); | 381 | GNUNET_free (ca); |
379 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 382 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
380 | _("Failed to connect to `gnunet-nat-server'\n")); | 383 | _ ("Failed to connect to `gnunet-nat-server'\n")); |
381 | return; | 384 | return; |
382 | } | 385 | } |
383 | GNUNET_CONTAINER_DLL_insert(h->ca_head, h->ca_tail, ca); | 386 | GNUNET_CONTAINER_DLL_insert (h->ca_head, h->ca_tail, ca); |
384 | sa = (const struct sockaddr_in *)addr; | 387 | sa = (const struct sockaddr_in *) addr; |
385 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_NAT_TEST); | 388 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAT_TEST); |
386 | msg->dst_ipv4 = sa->sin_addr.s_addr; | 389 | msg->dst_ipv4 = sa->sin_addr.s_addr; |
387 | msg->dport = sa->sin_port; | 390 | msg->dport = sa->sin_port; |
388 | msg->data = h->data; | 391 | msg->data = h->data; |
389 | msg->is_tcp = htonl((uint32_t)(h->proto == IPPROTO_TCP)); | 392 | msg->is_tcp = htonl ((uint32_t) (h->proto == IPPROTO_TCP)); |
390 | GNUNET_MQ_send(ca->mq, env); | 393 | GNUNET_MQ_send (ca->mq, env); |
391 | } | 394 | } |
392 | 395 | ||
393 | 396 | ||
@@ -399,12 +402,12 @@ addr_cb(void *cls, | |||
399 | * @param cls handle to the timed out NAT test | 402 | * @param cls handle to the timed out NAT test |
400 | */ | 403 | */ |
401 | static void | 404 | static void |
402 | do_fail(void *cls) | 405 | do_fail (void *cls) |
403 | { | 406 | { |
404 | struct GNUNET_NAT_AUTO_Test *nh = cls; | 407 | struct GNUNET_NAT_AUTO_Test *nh = cls; |
405 | 408 | ||
406 | nh->ttask = NULL; | 409 | nh->ttask = NULL; |
407 | nh->report(nh->report_cls, nh->status); | 410 | nh->report (nh->report_cls, nh->status); |
408 | } | 411 | } |
409 | 412 | ||
410 | 413 | ||
@@ -420,128 +423,128 @@ do_fail(void *cls) | |||
420 | * @return handle to cancel NAT test | 423 | * @return handle to cancel NAT test |
421 | */ | 424 | */ |
422 | struct GNUNET_NAT_AUTO_Test * | 425 | struct GNUNET_NAT_AUTO_Test * |
423 | GNUNET_NAT_AUTO_test_start(const struct GNUNET_CONFIGURATION_Handle *cfg, | 426 | GNUNET_NAT_AUTO_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, |
424 | uint8_t proto, | 427 | uint8_t proto, |
425 | const char *section_name, | 428 | const char *section_name, |
426 | GNUNET_NAT_TestCallback report, | 429 | GNUNET_NAT_TestCallback report, |
427 | void *report_cls) | 430 | void *report_cls) |
428 | { | 431 | { |
429 | struct GNUNET_NAT_AUTO_Test *nh; | 432 | struct GNUNET_NAT_AUTO_Test *nh; |
430 | unsigned long long bnd_port; | 433 | unsigned long long bnd_port; |
431 | struct sockaddr_in sa; | 434 | struct sockaddr_in sa; |
432 | const struct sockaddr *addrs[] = { (const struct sockaddr *)&sa }; | 435 | const struct sockaddr *addrs[] = { (const struct sockaddr *) &sa }; |
433 | const socklen_t addrlens[] = { sizeof(sa) }; | 436 | const socklen_t addrlens[] = { sizeof(sa) }; |
434 | 437 | ||
435 | if ((GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, | 438 | if ((GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, |
436 | section_name, | 439 | section_name, |
437 | "PORT", | 440 | "PORT", |
438 | &bnd_port)) || | 441 | &bnd_port)) || |
439 | (bnd_port > 65535)) | 442 | (bnd_port > 65535)) |
440 | { | 443 | { |
441 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 444 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
442 | _("Failed to find valid PORT in section `%s'\n"), | 445 | _ ("Failed to find valid PORT in section `%s'\n"), |
443 | section_name); | 446 | section_name); |
444 | return NULL; | 447 | return NULL; |
445 | } | 448 | } |
446 | 449 | ||
447 | memset(&sa, 0, sizeof(sa)); | 450 | memset (&sa, 0, sizeof(sa)); |
448 | sa.sin_family = AF_INET; | 451 | sa.sin_family = AF_INET; |
449 | sa.sin_port = htons((uint16_t)bnd_port); | 452 | sa.sin_port = htons ((uint16_t) bnd_port); |
450 | #if HAVE_SOCKADDR_IN_SIN_LEN | 453 | #if HAVE_SOCKADDR_IN_SIN_LEN |
451 | sa.sin_len = sizeof(sa); | 454 | sa.sin_len = sizeof(sa); |
452 | #endif | 455 | #endif |
453 | 456 | ||
454 | nh = GNUNET_new(struct GNUNET_NAT_AUTO_Test); | 457 | nh = GNUNET_new (struct GNUNET_NAT_AUTO_Test); |
455 | nh->cfg = cfg; | 458 | nh->cfg = cfg; |
456 | nh->proto = proto; | 459 | nh->proto = proto; |
457 | nh->section_name = GNUNET_strdup(section_name); | 460 | nh->section_name = GNUNET_strdup (section_name); |
458 | nh->report = report; | 461 | nh->report = report; |
459 | nh->report_cls = report_cls; | 462 | nh->report_cls = report_cls; |
460 | nh->status = GNUNET_NAT_ERROR_SUCCESS; | 463 | nh->status = GNUNET_NAT_ERROR_SUCCESS; |
461 | if (0 == bnd_port) | 464 | if (0 == bnd_port) |
465 | { | ||
466 | nh->nat = GNUNET_NAT_register (cfg, | ||
467 | section_name, | ||
468 | proto, | ||
469 | 0, | ||
470 | NULL, | ||
471 | NULL, | ||
472 | &addr_cb, | ||
473 | &reversal_cb, | ||
474 | nh); | ||
475 | } | ||
476 | else | ||
477 | { | ||
478 | nh->lsock = | ||
479 | GNUNET_NETWORK_socket_create (AF_INET, | ||
480 | (IPPROTO_UDP == proto) ? SOCK_DGRAM | ||
481 | : SOCK_STREAM, | ||
482 | proto); | ||
483 | if ((NULL == nh->lsock) || | ||
484 | (GNUNET_OK != GNUNET_NETWORK_socket_bind (nh->lsock, | ||
485 | (const struct sockaddr *) &sa, | ||
486 | sizeof(sa)))) | ||
462 | { | 487 | { |
463 | nh->nat = GNUNET_NAT_register(cfg, | 488 | LOG (GNUNET_ERROR_TYPE_ERROR, |
464 | section_name, | 489 | _ ("Failed to create socket bound to `%s' for NAT test: %s\n"), |
465 | proto, | 490 | GNUNET_a2s ((const struct sockaddr *) &sa, sizeof(sa)), |
466 | 0, | 491 | strerror (errno)); |
467 | NULL, | 492 | if (NULL != nh->lsock) |
468 | NULL, | 493 | { |
469 | &addr_cb, | 494 | GNUNET_NETWORK_socket_close (nh->lsock); |
470 | &reversal_cb, | 495 | nh->lsock = NULL; |
471 | nh); | 496 | } |
497 | nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR; | ||
498 | nh->ttask = GNUNET_SCHEDULER_add_now (&do_fail, nh); | ||
499 | return nh; | ||
472 | } | 500 | } |
473 | else | 501 | if (IPPROTO_TCP == proto) |
502 | { | ||
503 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_listen (nh->lsock, 5)); | ||
504 | nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | ||
505 | nh->lsock, | ||
506 | &do_accept, | ||
507 | nh); | ||
508 | } | ||
509 | else | ||
474 | { | 510 | { |
475 | nh->lsock = | 511 | nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
476 | GNUNET_NETWORK_socket_create(AF_INET, | 512 | nh->lsock, |
477 | (IPPROTO_UDP == proto) ? SOCK_DGRAM | 513 | &do_udp_read, |
478 | : SOCK_STREAM, | 514 | nh); |
479 | proto); | ||
480 | if ((NULL == nh->lsock) || | ||
481 | (GNUNET_OK != GNUNET_NETWORK_socket_bind(nh->lsock, | ||
482 | (const struct sockaddr *)&sa, | ||
483 | sizeof(sa)))) | ||
484 | { | ||
485 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
486 | _("Failed to create socket bound to `%s' for NAT test: %s\n"), | ||
487 | GNUNET_a2s((const struct sockaddr *)&sa, sizeof(sa)), | ||
488 | strerror(errno)); | ||
489 | if (NULL != nh->lsock) | ||
490 | { | ||
491 | GNUNET_NETWORK_socket_close(nh->lsock); | ||
492 | nh->lsock = NULL; | ||
493 | } | ||
494 | nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR; | ||
495 | nh->ttask = GNUNET_SCHEDULER_add_now(&do_fail, nh); | ||
496 | return nh; | ||
497 | } | ||
498 | if (IPPROTO_TCP == proto) | ||
499 | { | ||
500 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_listen(nh->lsock, 5)); | ||
501 | nh->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
502 | nh->lsock, | ||
503 | &do_accept, | ||
504 | nh); | ||
505 | } | ||
506 | else | ||
507 | { | ||
508 | nh->ltask = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
509 | nh->lsock, | ||
510 | &do_udp_read, | ||
511 | nh); | ||
512 | } | ||
513 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
514 | "NAT test listens on port %llu (%s)\n", | ||
515 | bnd_port, | ||
516 | (IPPROTO_TCP == proto) ? "tcp" : "udp"); | ||
517 | nh->nat = GNUNET_NAT_register(cfg, | ||
518 | section_name, | ||
519 | proto, | ||
520 | 1, | ||
521 | addrs, | ||
522 | addrlens, | ||
523 | &addr_cb, | ||
524 | NULL, | ||
525 | nh); | ||
526 | if (NULL == nh->nat) | ||
527 | { | ||
528 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
529 | _("NAT test failed to start NAT library\n")); | ||
530 | if (NULL != nh->ltask) | ||
531 | { | ||
532 | GNUNET_SCHEDULER_cancel(nh->ltask); | ||
533 | nh->ltask = NULL; | ||
534 | } | ||
535 | if (NULL != nh->lsock) | ||
536 | { | ||
537 | GNUNET_NETWORK_socket_close(nh->lsock); | ||
538 | nh->lsock = NULL; | ||
539 | } | ||
540 | nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED; | ||
541 | nh->ttask = GNUNET_SCHEDULER_add_now(&do_fail, nh); | ||
542 | return nh; | ||
543 | } | ||
544 | } | 515 | } |
516 | LOG (GNUNET_ERROR_TYPE_INFO, | ||
517 | "NAT test listens on port %llu (%s)\n", | ||
518 | bnd_port, | ||
519 | (IPPROTO_TCP == proto) ? "tcp" : "udp"); | ||
520 | nh->nat = GNUNET_NAT_register (cfg, | ||
521 | section_name, | ||
522 | proto, | ||
523 | 1, | ||
524 | addrs, | ||
525 | addrlens, | ||
526 | &addr_cb, | ||
527 | NULL, | ||
528 | nh); | ||
529 | if (NULL == nh->nat) | ||
530 | { | ||
531 | LOG (GNUNET_ERROR_TYPE_INFO, | ||
532 | _ ("NAT test failed to start NAT library\n")); | ||
533 | if (NULL != nh->ltask) | ||
534 | { | ||
535 | GNUNET_SCHEDULER_cancel (nh->ltask); | ||
536 | nh->ltask = NULL; | ||
537 | } | ||
538 | if (NULL != nh->lsock) | ||
539 | { | ||
540 | GNUNET_NETWORK_socket_close (nh->lsock); | ||
541 | nh->lsock = NULL; | ||
542 | } | ||
543 | nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED; | ||
544 | nh->ttask = GNUNET_SCHEDULER_add_now (&do_fail, nh); | ||
545 | return nh; | ||
546 | } | ||
547 | } | ||
545 | return nh; | 548 | return nh; |
546 | } | 549 | } |
547 | 550 | ||
@@ -552,47 +555,47 @@ GNUNET_NAT_AUTO_test_start(const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
552 | * @param tst test to stop. | 555 | * @param tst test to stop. |
553 | */ | 556 | */ |
554 | void | 557 | void |
555 | GNUNET_NAT_AUTO_test_stop(struct GNUNET_NAT_AUTO_Test *tst) | 558 | GNUNET_NAT_AUTO_test_stop (struct GNUNET_NAT_AUTO_Test *tst) |
556 | { | 559 | { |
557 | struct NatActivity *pos; | 560 | struct NatActivity *pos; |
558 | struct ClientActivity *cpos; | 561 | struct ClientActivity *cpos; |
559 | 562 | ||
560 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Stopping NAT test\n"); | 563 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Stopping NAT test\n"); |
561 | while (NULL != (cpos = tst->ca_head)) | 564 | while (NULL != (cpos = tst->ca_head)) |
562 | { | 565 | { |
563 | GNUNET_CONTAINER_DLL_remove(tst->ca_head, tst->ca_tail, cpos); | 566 | GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, cpos); |
564 | GNUNET_MQ_destroy(cpos->mq); | 567 | GNUNET_MQ_destroy (cpos->mq); |
565 | GNUNET_free(cpos); | 568 | GNUNET_free (cpos); |
566 | } | 569 | } |
567 | while (NULL != (pos = tst->na_head)) | 570 | while (NULL != (pos = tst->na_head)) |
568 | { | 571 | { |
569 | GNUNET_CONTAINER_DLL_remove(tst->na_head, tst->na_tail, pos); | 572 | GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, pos); |
570 | GNUNET_SCHEDULER_cancel(pos->rtask); | 573 | GNUNET_SCHEDULER_cancel (pos->rtask); |
571 | GNUNET_NETWORK_socket_close(pos->sock); | 574 | GNUNET_NETWORK_socket_close (pos->sock); |
572 | GNUNET_free(pos); | 575 | GNUNET_free (pos); |
573 | } | 576 | } |
574 | if (NULL != tst->ttask) | 577 | if (NULL != tst->ttask) |
575 | { | 578 | { |
576 | GNUNET_SCHEDULER_cancel(tst->ttask); | 579 | GNUNET_SCHEDULER_cancel (tst->ttask); |
577 | tst->ttask = NULL; | 580 | tst->ttask = NULL; |
578 | } | 581 | } |
579 | if (NULL != tst->ltask) | 582 | if (NULL != tst->ltask) |
580 | { | 583 | { |
581 | GNUNET_SCHEDULER_cancel(tst->ltask); | 584 | GNUNET_SCHEDULER_cancel (tst->ltask); |
582 | tst->ltask = NULL; | 585 | tst->ltask = NULL; |
583 | } | 586 | } |
584 | if (NULL != tst->lsock) | 587 | if (NULL != tst->lsock) |
585 | { | 588 | { |
586 | GNUNET_NETWORK_socket_close(tst->lsock); | 589 | GNUNET_NETWORK_socket_close (tst->lsock); |
587 | tst->lsock = NULL; | 590 | tst->lsock = NULL; |
588 | } | 591 | } |
589 | if (NULL != tst->nat) | 592 | if (NULL != tst->nat) |
590 | { | 593 | { |
591 | GNUNET_NAT_unregister(tst->nat); | 594 | GNUNET_NAT_unregister (tst->nat); |
592 | tst->nat = NULL; | 595 | tst->nat = NULL; |
593 | } | 596 | } |
594 | GNUNET_free(tst->section_name); | 597 | GNUNET_free (tst->section_name); |
595 | GNUNET_free(tst); | 598 | GNUNET_free (tst); |
596 | } | 599 | } |
597 | 600 | ||
598 | /* end of nat_auto_api_test.c */ | 601 | /* end of nat_auto_api_test.c */ |