diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/hostlist/gnunet-daemon-hostlist_client.c | 530 | ||||
-rw-r--r-- | src/mysql/mysql.c | 2 | ||||
-rw-r--r-- | src/nat-auto/gnunet-nat-auto_legacy.c | 208 | ||||
-rw-r--r-- | src/transport/gnunet-helper-transport-wlan-dummy.c | 128 | ||||
-rw-r--r-- | src/transport/gnunet-transport-wlan-receiver.c | 42 | ||||
-rw-r--r-- | src/transport/gnunet-transport-wlan-sender.c | 127 |
6 files changed, 527 insertions, 510 deletions
diff --git a/src/hostlist/gnunet-daemon-hostlist_client.c b/src/hostlist/gnunet-daemon-hostlist_client.c index 539760966..0428e64b8 100644 --- a/src/hostlist/gnunet-daemon-hostlist_client.c +++ b/src/hostlist/gnunet-daemon-hostlist_client.c | |||
@@ -34,7 +34,6 @@ | |||
34 | #include "gnunet_curl_lib.h" | 34 | #include "gnunet_curl_lib.h" |
35 | 35 | ||
36 | 36 | ||
37 | |||
38 | /** | 37 | /** |
39 | * Number of connections that we must have to NOT download | 38 | * Number of connections that we must have to NOT download |
40 | * hostlists anymore. | 39 | * hostlists anymore. |
@@ -49,17 +48,20 @@ | |||
49 | /** | 48 | /** |
50 | * Time interval hostlists are saved to disk | 49 | * Time interval hostlists are saved to disk |
51 | */ | 50 | */ |
52 | #define SAVING_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30) | 51 | #define SAVING_INTERVAL \ |
52 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30) | ||
53 | 53 | ||
54 | /** | 54 | /** |
55 | * Time interval between two hostlist tests | 55 | * Time interval between two hostlist tests |
56 | */ | 56 | */ |
57 | #define TESTING_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3) | 57 | #define TESTING_INTERVAL \ |
58 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3) | ||
58 | 59 | ||
59 | /** | 60 | /** |
60 | * Time interval for download dispatcher before a download is re-scheduled | 61 | * Time interval for download dispatcher before a download is re-scheduled |
61 | */ | 62 | */ |
62 | #define WAITING_INTERVAL GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1) | 63 | #define WAITING_INTERVAL \ |
64 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1) | ||
63 | 65 | ||
64 | /** | 66 | /** |
65 | * Defines concerning the hostlist quality metric | 67 | * Defines concerning the hostlist quality metric |
@@ -86,7 +88,6 @@ | |||
86 | #define HOSTLIST_SUCCESSFUL_HELLO 1 | 88 | #define HOSTLIST_SUCCESSFUL_HELLO 1 |
87 | 89 | ||
88 | 90 | ||
89 | |||
90 | /** | 91 | /** |
91 | * A single hostlist obtained by hostlist advertisements | 92 | * A single hostlist obtained by hostlist advertisements |
92 | */ | 93 | */ |
@@ -136,7 +137,6 @@ struct Hostlist | |||
136 | * Number of times the hostlist was successfully obtained | 137 | * Number of times the hostlist was successfully obtained |
137 | */ | 138 | */ |
138 | uint32_t times_used; | 139 | uint32_t times_used; |
139 | |||
140 | }; | 140 | }; |
141 | 141 | ||
142 | 142 | ||
@@ -321,10 +321,7 @@ static struct GNUNET_PEERINFO_Handle *pi; | |||
321 | * @return number of bytes that were processed (always size*nmemb) | 321 | * @return number of bytes that were processed (always size*nmemb) |
322 | */ | 322 | */ |
323 | static size_t | 323 | static size_t |
324 | callback_download (void *ptr, | 324 | callback_download (void *ptr, size_t size, size_t nmemb, void *ctx) |
325 | size_t size, | ||
326 | size_t nmemb, | ||
327 | void *ctx) | ||
328 | { | 325 | { |
329 | static char download_buffer[GNUNET_MAX_MESSAGE_SIZE - 1]; | 326 | static char download_buffer[GNUNET_MAX_MESSAGE_SIZE - 1]; |
330 | const char *cbuf = ptr; | 327 | const char *cbuf = ptr; |
@@ -338,13 +335,14 @@ callback_download (void *ptr, | |||
338 | stat_bytes_downloaded += total; | 335 | stat_bytes_downloaded += total; |
339 | if ((total == 0) || (stat_bogus_url)) | 336 | if ((total == 0) || (stat_bogus_url)) |
340 | { | 337 | { |
341 | return total; /* ok, no data or bogus data */ | 338 | return total; /* ok, no data or bogus data */ |
342 | } | 339 | } |
343 | 340 | ||
344 | GNUNET_STATISTICS_update (stats, | 341 | GNUNET_STATISTICS_update (stats, |
345 | gettext_noop | 342 | gettext_noop ( |
346 | ("# bytes downloaded from hostlist servers"), | 343 | "# bytes downloaded from hostlist servers"), |
347 | (int64_t) total, GNUNET_NO); | 344 | (int64_t) total, |
345 | GNUNET_NO); | ||
348 | left = total; | 346 | left = total; |
349 | while ((left > 0) || (download_pos > 0)) | 347 | while ((left > 0) || (download_pos > 0)) |
350 | { | 348 | { |
@@ -362,13 +360,15 @@ callback_download (void *ptr, | |||
362 | msize = ntohs (msg->size); | 360 | msize = ntohs (msg->size); |
363 | if (msize < sizeof (struct GNUNET_MessageHeader)) | 361 | if (msize < sizeof (struct GNUNET_MessageHeader)) |
364 | { | 362 | { |
365 | GNUNET_STATISTICS_update (stats, | 363 | GNUNET_STATISTICS_update ( |
366 | gettext_noop | 364 | stats, |
367 | ("# invalid HELLOs downloaded from hostlist servers"), | 365 | gettext_noop ("# invalid HELLOs downloaded from hostlist servers"), |
368 | 1, GNUNET_NO); | 366 | 1, |
367 | GNUNET_NO); | ||
369 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 368 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
370 | _("Invalid `%s' message received from hostlist at `%s'\n"), | 369 | _ ("Invalid `%s' message received from hostlist at `%s'\n"), |
371 | "HELLO", current_url); | 370 | "HELLO", |
371 | current_url); | ||
372 | stat_hellos_obtained++; | 372 | stat_hellos_obtained++; |
373 | stat_bogus_url = 1; | 373 | stat_bogus_url = 1; |
374 | return total; | 374 | return total; |
@@ -383,32 +383,34 @@ callback_download (void *ptr, | |||
383 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 383 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
384 | "Received valid `%s' message from hostlist server.\n", | 384 | "Received valid `%s' message from hostlist server.\n", |
385 | "HELLO"); | 385 | "HELLO"); |
386 | GNUNET_STATISTICS_update (stats, | 386 | GNUNET_STATISTICS_update ( |
387 | gettext_noop | 387 | stats, |
388 | ("# valid HELLOs downloaded from hostlist servers"), | 388 | gettext_noop ("# valid HELLOs downloaded from hostlist servers"), |
389 | 1, GNUNET_NO); | 389 | 1, |
390 | GNUNET_NO); | ||
390 | stat_hellos_obtained++; | 391 | stat_hellos_obtained++; |
391 | (void) GNUNET_PEERINFO_add_peer (pi, | 392 | (void) |
392 | (const struct GNUNET_HELLO_Message *) msg, | 393 | GNUNET_PEERINFO_add_peer (pi, |
393 | NULL, | 394 | (const struct GNUNET_HELLO_Message *) msg, |
394 | NULL); | 395 | NULL, |
396 | NULL); | ||
395 | } | 397 | } |
396 | else | 398 | else |
397 | { | 399 | { |
398 | GNUNET_STATISTICS_update (stats, | 400 | GNUNET_STATISTICS_update ( |
399 | gettext_noop | 401 | stats, |
400 | ("# invalid HELLOs downloaded from hostlist servers"), | 402 | gettext_noop ("# invalid HELLOs downloaded from hostlist servers"), |
401 | 1, GNUNET_NO); | 403 | 1, |
404 | GNUNET_NO); | ||
402 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 405 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
403 | _("Invalid `%s' message received from hostlist at `%s'\n"), | 406 | _ ("Invalid `%s' message received from hostlist at `%s'\n"), |
404 | "HELLO", current_url); | 407 | "HELLO", |
408 | current_url); | ||
405 | stat_bogus_url = GNUNET_YES; | 409 | stat_bogus_url = GNUNET_YES; |
406 | stat_hellos_obtained++; | 410 | stat_hellos_obtained++; |
407 | return total; | 411 | return total; |
408 | } | 412 | } |
409 | memmove (download_buffer, | 413 | memmove (download_buffer, &download_buffer[msize], download_pos - msize); |
410 | &download_buffer[msize], | ||
411 | download_pos - msize); | ||
412 | download_pos -= msize; | 414 | download_pos -= msize; |
413 | } | 415 | } |
414 | return total; | 416 | return total; |
@@ -428,12 +430,14 @@ get_bootstrap_server () | |||
428 | size_t urls; | 430 | size_t urls; |
429 | size_t pos; | 431 | size_t pos; |
430 | 432 | ||
431 | if (GNUNET_OK != | 433 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, |
432 | GNUNET_CONFIGURATION_get_value_string (cfg, "HOSTLIST", "SERVERS", | 434 | "HOSTLIST", |
433 | &servers)) | 435 | "SERVERS", |
436 | &servers)) | ||
434 | { | 437 | { |
435 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, | 438 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, |
436 | "hostlist", "SERVERS"); | 439 | "hostlist", |
440 | "SERVERS"); | ||
437 | return NULL; | 441 | return NULL; |
438 | } | 442 | } |
439 | 443 | ||
@@ -452,7 +456,8 @@ get_bootstrap_server () | |||
452 | if (urls == 0) | 456 | if (urls == 0) |
453 | { | 457 | { |
454 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, | 458 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, |
455 | "hostlist", "SERVERS"); | 459 | "hostlist", |
460 | "SERVERS"); | ||
456 | GNUNET_free (servers); | 461 | GNUNET_free (servers); |
457 | return NULL; | 462 | return NULL; |
458 | } | 463 | } |
@@ -514,7 +519,7 @@ download_get_url () | |||
514 | return get_bootstrap_server (); | 519 | return get_bootstrap_server (); |
515 | } | 520 | } |
516 | index = | 521 | index = |
517 | GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, linked_list_size); | 522 | GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, linked_list_size); |
518 | counter = 0; | 523 | counter = 0; |
519 | pos = linked_list_head; | 524 | pos = linked_list_head; |
520 | while (counter < index) | 525 | while (counter < index) |
@@ -522,14 +527,26 @@ download_get_url () | |||
522 | pos = pos->next; | 527 | pos = pos->next; |
523 | counter++; | 528 | counter++; |
524 | } | 529 | } |
525 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Using learned hostlist `%s'\n", | 530 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
531 | "Using learned hostlist `%s'\n", | ||
526 | pos->hostlist_uri); | 532 | pos->hostlist_uri); |
527 | current_hostlist = pos; | 533 | current_hostlist = pos; |
528 | return GNUNET_strdup (pos->hostlist_uri); | 534 | return GNUNET_strdup (pos->hostlist_uri); |
529 | } | 535 | } |
530 | 536 | ||
531 | 537 | ||
532 | #define CURL_EASY_SETOPT(c, a, b) do { ret = curl_easy_setopt (c, a, b); if (CURLE_OK != ret) GNUNET_log(GNUNET_ERROR_TYPE_WARNING, _("%s failed at %s:%d: `%s'\n"), "curl_easy_setopt", __FILE__, __LINE__, curl_easy_strerror (ret)); } while (0) | 538 | #define CURL_EASY_SETOPT(c, a, b) \ |
539 | do \ | ||
540 | { \ | ||
541 | ret = curl_easy_setopt (c, a, b); \ | ||
542 | if (CURLE_OK != ret) \ | ||
543 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, \ | ||
544 | _ ("%s failed at %s:%d: `%s'\n"), \ | ||
545 | "curl_easy_setopt", \ | ||
546 | __FILE__, \ | ||
547 | __LINE__, \ | ||
548 | curl_easy_strerror (ret)); \ | ||
549 | } while (0) | ||
533 | 550 | ||
534 | 551 | ||
535 | /** | 552 | /** |
@@ -549,8 +566,7 @@ save_hostlist_file (int shutdown); | |||
549 | * @return result | 566 | * @return result |
550 | */ | 567 | */ |
551 | static uint64_t | 568 | static uint64_t |
552 | checked_add (uint64_t val1, | 569 | checked_add (uint64_t val1, uint64_t val2) |
553 | uint64_t val2) | ||
554 | { | 570 | { |
555 | static uint64_t temp; | 571 | static uint64_t temp; |
556 | static uint64_t maxv; | 572 | static uint64_t maxv; |
@@ -573,8 +589,7 @@ checked_add (uint64_t val1, | |||
573 | * @return result | 589 | * @return result |
574 | */ | 590 | */ |
575 | static uint64_t | 591 | static uint64_t |
576 | checked_sub (uint64_t val1, | 592 | checked_sub (uint64_t val1, uint64_t val2) |
577 | uint64_t val2) | ||
578 | { | 593 | { |
579 | if (val1 <= val2) | 594 | if (val1 <= val2) |
580 | return 0; | 595 | return 0; |
@@ -643,20 +658,25 @@ insert_hostlist () | |||
643 | /* No free entries available, replace existing entry */ | 658 | /* No free entries available, replace existing entry */ |
644 | lowest_quality = linked_list_get_lowest_quality (); | 659 | lowest_quality = linked_list_get_lowest_quality (); |
645 | GNUNET_assert (lowest_quality != NULL); | 660 | GNUNET_assert (lowest_quality != NULL); |
646 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 661 | GNUNET_log ( |
647 | "Removing hostlist with URI `%s' which has the worst quality of all (%llu)\n", | 662 | GNUNET_ERROR_TYPE_DEBUG, |
648 | lowest_quality->hostlist_uri, | 663 | "Removing hostlist with URI `%s' which has the worst quality of all (%llu)\n", |
649 | (unsigned long long) lowest_quality->quality); | 664 | lowest_quality->hostlist_uri, |
650 | GNUNET_CONTAINER_DLL_remove (linked_list_head, linked_list_tail, | 665 | (unsigned long long) lowest_quality->quality); |
666 | GNUNET_CONTAINER_DLL_remove (linked_list_head, | ||
667 | linked_list_tail, | ||
651 | lowest_quality); | 668 | lowest_quality); |
652 | linked_list_size--; | 669 | linked_list_size--; |
653 | GNUNET_free (lowest_quality); | 670 | GNUNET_free (lowest_quality); |
654 | } | 671 | } |
655 | GNUNET_CONTAINER_DLL_insert (linked_list_head, linked_list_tail, | 672 | GNUNET_CONTAINER_DLL_insert (linked_list_head, |
673 | linked_list_tail, | ||
656 | hostlist_to_test); | 674 | hostlist_to_test); |
657 | linked_list_size++; | 675 | linked_list_size++; |
658 | GNUNET_STATISTICS_set (stats, gettext_noop ("# advertised hostlist URIs"), | 676 | GNUNET_STATISTICS_set (stats, |
659 | linked_list_size, GNUNET_NO); | 677 | gettext_noop ("# advertised hostlist URIs"), |
678 | linked_list_size, | ||
679 | GNUNET_NO); | ||
660 | stat_testing_hostlist = GNUNET_NO; | 680 | stat_testing_hostlist = GNUNET_NO; |
661 | } | 681 | } |
662 | 682 | ||
@@ -678,14 +698,15 @@ update_hostlist () | |||
678 | current_hostlist->hello_count = stat_hellos_obtained; | 698 | current_hostlist->hello_count = stat_hellos_obtained; |
679 | current_hostlist->time_last_usage = GNUNET_TIME_absolute_get (); | 699 | current_hostlist->time_last_usage = GNUNET_TIME_absolute_get (); |
680 | current_hostlist->quality = | 700 | current_hostlist->quality = |
681 | checked_add (current_hostlist->quality, | 701 | checked_add (current_hostlist->quality, |
682 | (stat_hellos_obtained * HOSTLIST_SUCCESSFUL_HELLO)); | 702 | (stat_hellos_obtained * HOSTLIST_SUCCESSFUL_HELLO)); |
683 | if (GNUNET_YES == stat_download_successful) | 703 | if (GNUNET_YES == stat_download_successful) |
684 | { | 704 | { |
685 | current_hostlist->times_used++; | 705 | current_hostlist->times_used++; |
686 | current_hostlist->quality = | 706 | current_hostlist->quality = |
687 | checked_add (current_hostlist->quality, HOSTLIST_SUCCESSFUL_DOWNLOAD); | 707 | checked_add (current_hostlist->quality, HOSTLIST_SUCCESSFUL_DOWNLOAD); |
688 | GNUNET_asprintf (&stat, gettext_noop ("# advertised URI `%s' downloaded"), | 708 | GNUNET_asprintf (&stat, |
709 | gettext_noop ("# advertised URI `%s' downloaded"), | ||
689 | current_hostlist->hostlist_uri); | 710 | current_hostlist->hostlist_uri); |
690 | 711 | ||
691 | GNUNET_STATISTICS_update (stats, stat, 1, GNUNET_YES); | 712 | GNUNET_STATISTICS_update (stats, stat, 1, GNUNET_YES); |
@@ -693,7 +714,7 @@ update_hostlist () | |||
693 | } | 714 | } |
694 | else | 715 | else |
695 | current_hostlist->quality = | 716 | current_hostlist->quality = |
696 | checked_sub (current_hostlist->quality, HOSTLIST_FAILED_DOWNLOAD); | 717 | checked_sub (current_hostlist->quality, HOSTLIST_FAILED_DOWNLOAD); |
697 | } | 718 | } |
698 | current_hostlist = NULL; | 719 | current_hostlist = NULL; |
699 | /* Alternating the usage of preconfigured and learned hostlists */ | 720 | /* Alternating the usage of preconfigured and learned hostlists */ |
@@ -722,14 +743,14 @@ clean_up () | |||
722 | { | 743 | { |
723 | CURLMcode mret; | 744 | CURLMcode mret; |
724 | 745 | ||
725 | if ( (stat_testing_hostlist == GNUNET_YES) && | 746 | if ((stat_testing_hostlist == GNUNET_YES) && |
726 | (GNUNET_NO == stat_download_successful) && | 747 | (GNUNET_NO == stat_download_successful) && (NULL != hostlist_to_test)) |
727 | (NULL != hostlist_to_test) ) | ||
728 | { | 748 | { |
729 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 749 | GNUNET_log ( |
730 | _ | 750 | GNUNET_ERROR_TYPE_INFO, |
731 | ("Advertised hostlist with URI `%s' could not be downloaded. Advertised URI gets dismissed.\n"), | 751 | _ ( |
732 | hostlist_to_test->hostlist_uri); | 752 | "Advertised hostlist with URI `%s' could not be downloaded. Advertised URI gets dismissed.\n"), |
753 | hostlist_to_test->hostlist_uri); | ||
733 | } | 754 | } |
734 | 755 | ||
735 | if (stat_testing_hostlist == GNUNET_YES) | 756 | if (stat_testing_hostlist == GNUNET_YES) |
@@ -747,14 +768,20 @@ clean_up () | |||
747 | mret = curl_multi_remove_handle (multi, curl); | 768 | mret = curl_multi_remove_handle (multi, curl); |
748 | if (mret != CURLM_OK) | 769 | if (mret != CURLM_OK) |
749 | { | 770 | { |
750 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("%s failed at %s:%d: `%s'\n"), | 771 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
751 | "curl_multi_remove_handle", __FILE__, __LINE__, | 772 | _ ("%s failed at %s:%d: `%s'\n"), |
773 | "curl_multi_remove_handle", | ||
774 | __FILE__, | ||
775 | __LINE__, | ||
752 | curl_multi_strerror (mret)); | 776 | curl_multi_strerror (mret)); |
753 | } | 777 | } |
754 | mret = curl_multi_cleanup (multi); | 778 | mret = curl_multi_cleanup (multi); |
755 | if (mret != CURLM_OK) | 779 | if (mret != CURLM_OK) |
756 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("%s failed at %s:%d: `%s'\n"), | 780 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
757 | "curl_multi_cleanup", __FILE__, __LINE__, | 781 | _ ("%s failed at %s:%d: `%s'\n"), |
782 | "curl_multi_cleanup", | ||
783 | __FILE__, | ||
784 | __LINE__, | ||
758 | curl_multi_strerror (mret)); | 785 | curl_multi_strerror (mret)); |
759 | multi = NULL; | 786 | multi = NULL; |
760 | } | 787 | } |
@@ -805,8 +832,11 @@ download_prepare () | |||
805 | mret = curl_multi_fdset (multi, &rs, &ws, &es, &max); | 832 | mret = curl_multi_fdset (multi, &rs, &ws, &es, &max); |
806 | if (mret != CURLM_OK) | 833 | if (mret != CURLM_OK) |
807 | { | 834 | { |
808 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("%s failed at %s:%d: `%s'\n"), | 835 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
809 | "curl_multi_fdset", __FILE__, __LINE__, | 836 | _ ("%s failed at %s:%d: `%s'\n"), |
837 | "curl_multi_fdset", | ||
838 | __FILE__, | ||
839 | __LINE__, | ||
810 | curl_multi_strerror (mret)); | 840 | curl_multi_strerror (mret)); |
811 | clean_up (); | 841 | clean_up (); |
812 | return; | 842 | return; |
@@ -814,26 +844,30 @@ download_prepare () | |||
814 | mret = curl_multi_timeout (multi, &timeout); | 844 | mret = curl_multi_timeout (multi, &timeout); |
815 | if (mret != CURLM_OK) | 845 | if (mret != CURLM_OK) |
816 | { | 846 | { |
817 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("%s failed at %s:%d: `%s'\n"), | 847 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
818 | "curl_multi_timeout", __FILE__, __LINE__, | 848 | _ ("%s failed at %s:%d: `%s'\n"), |
849 | "curl_multi_timeout", | ||
850 | __FILE__, | ||
851 | __LINE__, | ||
819 | curl_multi_strerror (mret)); | 852 | curl_multi_strerror (mret)); |
820 | clean_up (); | 853 | clean_up (); |
821 | return; | 854 | return; |
822 | } | 855 | } |
823 | rtime = | 856 | rtime = GNUNET_TIME_relative_min ( |
824 | GNUNET_TIME_relative_min (GNUNET_TIME_absolute_get_remaining (end_time), | 857 | GNUNET_TIME_absolute_get_remaining (end_time), |
825 | GNUNET_TIME_relative_multiply | 858 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, timeout)); |
826 | (GNUNET_TIME_UNIT_MILLISECONDS, timeout)); | ||
827 | grs = GNUNET_NETWORK_fdset_create (); | 859 | grs = GNUNET_NETWORK_fdset_create (); |
828 | gws = GNUNET_NETWORK_fdset_create (); | 860 | gws = GNUNET_NETWORK_fdset_create (); |
829 | GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1); | 861 | GNUNET_NETWORK_fdset_copy_native (grs, &rs, max + 1); |
830 | GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1); | 862 | GNUNET_NETWORK_fdset_copy_native (gws, &ws, max + 1); |
831 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 863 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
832 | "Scheduling task for hostlist download using cURL\n"); | 864 | "Scheduling task for hostlist download using cURL\n"); |
833 | ti_download = | 865 | ti_download = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, |
834 | GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, | 866 | rtime, |
835 | rtime, grs, gws, | 867 | grs, |
836 | &task_download, multi); | 868 | gws, |
869 | &task_download, | ||
870 | multi); | ||
837 | GNUNET_NETWORK_fdset_destroy (gws); | 871 | GNUNET_NETWORK_fdset_destroy (gws); |
838 | GNUNET_NETWORK_fdset_destroy (grs); | 872 | GNUNET_NETWORK_fdset_destroy (grs); |
839 | } | 873 | } |
@@ -856,7 +890,7 @@ task_download (void *cls) | |||
856 | if (0 == GNUNET_TIME_absolute_get_remaining (end_time).rel_value_us) | 890 | if (0 == GNUNET_TIME_absolute_get_remaining (end_time).rel_value_us) |
857 | { | 891 | { |
858 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 892 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
859 | _("Timeout trying to download hostlist from `%s'\n"), | 893 | _ ("Timeout trying to download hostlist from `%s'\n"), |
860 | current_url); | 894 | current_url); |
861 | update_hostlist (); | 895 | update_hostlist (); |
862 | clean_up (); | 896 | clean_up (); |
@@ -870,7 +904,8 @@ task_download (void *cls) | |||
870 | if (stat_bytes_downloaded > MAX_BYTES_PER_HOSTLISTS) | 904 | if (stat_bytes_downloaded > MAX_BYTES_PER_HOSTLISTS) |
871 | { | 905 | { |
872 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 906 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
873 | _("Download limit of %u bytes exceeded, stopping download\n"), | 907 | _ ( |
908 | "Download limit of %u bytes exceeded, stopping download\n"), | ||
874 | MAX_BYTES_PER_HOSTLISTS); | 909 | MAX_BYTES_PER_HOSTLISTS); |
875 | clean_up (); | 910 | clean_up (); |
876 | return; | 911 | return; |
@@ -890,22 +925,22 @@ task_download (void *cls) | |||
890 | if ((msg->data.result != CURLE_OK) && | 925 | if ((msg->data.result != CURLE_OK) && |
891 | (msg->data.result != CURLE_GOT_NOTHING)) | 926 | (msg->data.result != CURLE_GOT_NOTHING)) |
892 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 927 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
893 | _("Download of hostlist from `%s' failed: `%s'\n"), | 928 | _ ("Download of hostlist from `%s' failed: `%s'\n"), |
894 | current_url, | 929 | current_url, |
895 | curl_easy_strerror (msg->data.result)); | 930 | curl_easy_strerror (msg->data.result)); |
896 | else | 931 | else |
897 | { | 932 | { |
898 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 933 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
899 | _("Download of hostlist `%s' completed.\n"), | 934 | _ ("Download of hostlist `%s' completed.\n"), |
900 | current_url); | 935 | current_url); |
901 | stat_download_successful = GNUNET_YES; | 936 | stat_download_successful = GNUNET_YES; |
902 | update_hostlist (); | 937 | update_hostlist (); |
903 | if (GNUNET_YES == stat_testing_hostlist) | 938 | if (GNUNET_YES == stat_testing_hostlist) |
904 | { | 939 | { |
905 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 940 | GNUNET_log ( |
906 | _ | 941 | GNUNET_ERROR_TYPE_INFO, |
907 | ("Adding successfully tested hostlist `%s' datastore.\n"), | 942 | _ ("Adding successfully tested hostlist `%s' datastore.\n"), |
908 | current_url); | 943 | current_url); |
909 | insert_hostlist (); | 944 | insert_hostlist (); |
910 | hostlist_to_test = NULL; | 945 | hostlist_to_test = NULL; |
911 | stat_testing_hostlist = GNUNET_NO; | 946 | stat_testing_hostlist = GNUNET_NO; |
@@ -917,16 +952,17 @@ task_download (void *cls) | |||
917 | break; | 952 | break; |
918 | } | 953 | } |
919 | 954 | ||
920 | } | 955 | } while ((running > 0)); |
921 | while ((running > 0)); | ||
922 | } | 956 | } |
923 | } | 957 | } while (mret == CURLM_CALL_MULTI_PERFORM); |
924 | while (mret == CURLM_CALL_MULTI_PERFORM); | ||
925 | 958 | ||
926 | if (mret != CURLM_OK) | 959 | if (mret != CURLM_OK) |
927 | { | 960 | { |
928 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("%s failed at %s:%d: `%s'\n"), | 961 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
929 | "curl_multi_perform", __FILE__, __LINE__, | 962 | _ ("%s failed at %s:%d: `%s'\n"), |
963 | "curl_multi_perform", | ||
964 | __FILE__, | ||
965 | __LINE__, | ||
930 | curl_multi_strerror (mret)); | 966 | curl_multi_strerror (mret)); |
931 | clean_up (); | 967 | clean_up (); |
932 | } | 968 | } |
@@ -957,7 +993,8 @@ download_hostlist () | |||
957 | return; | 993 | return; |
958 | } | 994 | } |
959 | GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK, | 995 | GNUNET_log (GNUNET_ERROR_TYPE_INFO | GNUNET_ERROR_TYPE_BULK, |
960 | _("Bootstrapping using hostlist at `%s'.\n"), current_url); | 996 | _ ("Bootstrapping using hostlist at `%s'.\n"), |
997 | current_url); | ||
961 | 998 | ||
962 | stat_download_in_progress = GNUNET_YES; | 999 | stat_download_in_progress = GNUNET_YES; |
963 | stat_download_successful = GNUNET_NO; | 1000 | stat_download_successful = GNUNET_NO; |
@@ -965,7 +1002,8 @@ download_hostlist () | |||
965 | stat_bytes_downloaded = 0; | 1002 | stat_bytes_downloaded = 0; |
966 | 1003 | ||
967 | GNUNET_STATISTICS_update (stats, | 1004 | GNUNET_STATISTICS_update (stats, |
968 | gettext_noop ("# hostlist downloads initiated"), 1, | 1005 | gettext_noop ("# hostlist downloads initiated"), |
1006 | 1, | ||
969 | GNUNET_NO); | 1007 | GNUNET_NO); |
970 | if (NULL != proxy) | 1008 | if (NULL != proxy) |
971 | { | 1009 | { |
@@ -991,7 +1029,9 @@ download_hostlist () | |||
991 | return; | 1029 | return; |
992 | } | 1030 | } |
993 | CURL_EASY_SETOPT (curl, CURLOPT_FOLLOWLOCATION, 1); | 1031 | CURL_EASY_SETOPT (curl, CURLOPT_FOLLOWLOCATION, 1); |
994 | CURL_EASY_SETOPT (curl, CURLOPT_REDIR_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS); | 1032 | CURL_EASY_SETOPT (curl, |
1033 | CURLOPT_REDIR_PROTOCOLS, | ||
1034 | CURLPROTO_HTTP | CURLPROTO_HTTPS); | ||
995 | CURL_EASY_SETOPT (curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS); | 1035 | CURL_EASY_SETOPT (curl, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS); |
996 | CURL_EASY_SETOPT (curl, CURLOPT_MAXREDIRS, 4); | 1036 | CURL_EASY_SETOPT (curl, CURLOPT_MAXREDIRS, 4); |
997 | /* no need to abort if the above failed */ | 1037 | /* no need to abort if the above failed */ |
@@ -1020,13 +1060,19 @@ download_hostlist () | |||
1020 | mret = curl_multi_add_handle (multi, curl); | 1060 | mret = curl_multi_add_handle (multi, curl); |
1021 | if (mret != CURLM_OK) | 1061 | if (mret != CURLM_OK) |
1022 | { | 1062 | { |
1023 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("%s failed at %s:%d: `%s'\n"), | 1063 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1024 | "curl_multi_add_handle", __FILE__, __LINE__, | 1064 | _ ("%s failed at %s:%d: `%s'\n"), |
1065 | "curl_multi_add_handle", | ||
1066 | __FILE__, | ||
1067 | __LINE__, | ||
1025 | curl_multi_strerror (mret)); | 1068 | curl_multi_strerror (mret)); |
1026 | mret = curl_multi_cleanup (multi); | 1069 | mret = curl_multi_cleanup (multi); |
1027 | if (mret != CURLM_OK) | 1070 | if (mret != CURLM_OK) |
1028 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("%s failed at %s:%d: `%s'\n"), | 1071 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1029 | "curl_multi_cleanup", __FILE__, __LINE__, | 1072 | _ ("%s failed at %s:%d: `%s'\n"), |
1073 | "curl_multi_cleanup", | ||
1074 | __FILE__, | ||
1075 | __LINE__, | ||
1030 | curl_multi_strerror (mret)); | 1076 | curl_multi_strerror (mret)); |
1031 | multi = NULL; | 1077 | multi = NULL; |
1032 | clean_up (); | 1078 | clean_up (); |
@@ -1052,8 +1098,9 @@ task_download_dispatcher (void *cls) | |||
1052 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1098 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1053 | "Download in progess, have to wait...\n"); | 1099 | "Download in progess, have to wait...\n"); |
1054 | ti_download_dispatcher_task = | 1100 | ti_download_dispatcher_task = |
1055 | GNUNET_SCHEDULER_add_delayed (WAITING_INTERVAL, | 1101 | GNUNET_SCHEDULER_add_delayed (WAITING_INTERVAL, |
1056 | &task_download_dispatcher, NULL); | 1102 | &task_download_dispatcher, |
1103 | NULL); | ||
1057 | } | 1104 | } |
1058 | } | 1105 | } |
1059 | 1106 | ||
@@ -1073,12 +1120,12 @@ task_check (void *cls) | |||
1073 | if (stats == NULL) | 1120 | if (stats == NULL) |
1074 | { | 1121 | { |
1075 | curl_global_cleanup (); | 1122 | curl_global_cleanup (); |
1076 | return; /* in shutdown */ | 1123 | return; /* in shutdown */ |
1077 | } | 1124 | } |
1078 | if ( (stat_connection_count < MIN_CONNECTIONS) && | 1125 | if ((stat_connection_count < MIN_CONNECTIONS) && |
1079 | (NULL == ti_download_dispatcher_task) ) | 1126 | (NULL == ti_download_dispatcher_task)) |
1080 | ti_download_dispatcher_task = | 1127 | ti_download_dispatcher_task = |
1081 | GNUNET_SCHEDULER_add_now (&task_download_dispatcher, NULL); | 1128 | GNUNET_SCHEDULER_add_now (&task_download_dispatcher, NULL); |
1082 | 1129 | ||
1083 | delay = hostlist_delay; | 1130 | delay = hostlist_delay; |
1084 | if (0 == hostlist_delay.rel_value_us) | 1131 | if (0 == hostlist_delay.rel_value_us) |
@@ -1088,24 +1135,25 @@ task_check (void *cls) | |||
1088 | if (hostlist_delay.rel_value_us > | 1135 | if (hostlist_delay.rel_value_us > |
1089 | GNUNET_TIME_UNIT_HOURS.rel_value_us * (1 + stat_connection_count)) | 1136 | GNUNET_TIME_UNIT_HOURS.rel_value_us * (1 + stat_connection_count)) |
1090 | hostlist_delay = | 1137 | hostlist_delay = |
1091 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, | 1138 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, |
1092 | (1 + stat_connection_count)); | 1139 | (1 + stat_connection_count)); |
1093 | GNUNET_STATISTICS_set (stats, | 1140 | GNUNET_STATISTICS_set (stats, |
1094 | gettext_noop | 1141 | gettext_noop ( |
1095 | ("# milliseconds between hostlist downloads"), | 1142 | "# milliseconds between hostlist downloads"), |
1096 | hostlist_delay.rel_value_us / 1000LL, | 1143 | hostlist_delay.rel_value_us / 1000LL, |
1097 | GNUNET_YES); | 1144 | GNUNET_YES); |
1098 | if (0 == once) | 1145 | if (0 == once) |
1099 | { | 1146 | { |
1100 | delay = GNUNET_TIME_UNIT_ZERO; | 1147 | delay = GNUNET_TIME_UNIT_ZERO; |
1101 | once = 1; | 1148 | once = 1; |
1102 | } | 1149 | } |
1103 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1150 | GNUNET_log ( |
1104 | _("Have %u/%u connections. Will consider downloading hostlist in %s\n"), | 1151 | GNUNET_ERROR_TYPE_INFO, |
1105 | stat_connection_count, MIN_CONNECTIONS, | 1152 | _ ("Have %u/%u connections. Will consider downloading hostlist in %s\n"), |
1106 | GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); | 1153 | stat_connection_count, |
1107 | ti_check_download = GNUNET_SCHEDULER_add_delayed (delay, | 1154 | MIN_CONNECTIONS, |
1108 | &task_check, NULL); | 1155 | GNUNET_STRINGS_relative_time_to_string (delay, GNUNET_YES)); |
1156 | ti_check_download = GNUNET_SCHEDULER_add_delayed (delay, &task_check, NULL); | ||
1109 | } | 1157 | } |
1110 | 1158 | ||
1111 | 1159 | ||
@@ -1137,11 +1185,10 @@ task_hostlist_saving (void *cls) | |||
1137 | 1185 | ||
1138 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1186 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1139 | "Hostlists will be saved to file again in %s\n", | 1187 | "Hostlists will be saved to file again in %s\n", |
1140 | GNUNET_STRINGS_relative_time_to_string(SAVING_INTERVAL, GNUNET_YES)); | 1188 | GNUNET_STRINGS_relative_time_to_string (SAVING_INTERVAL, |
1189 | GNUNET_YES)); | ||
1141 | ti_saving_task = | 1190 | ti_saving_task = |
1142 | GNUNET_SCHEDULER_add_delayed (SAVING_INTERVAL, | 1191 | GNUNET_SCHEDULER_add_delayed (SAVING_INTERVAL, &task_hostlist_saving, NULL); |
1143 | &task_hostlist_saving, | ||
1144 | NULL); | ||
1145 | } | 1192 | } |
1146 | 1193 | ||
1147 | 1194 | ||
@@ -1154,14 +1201,14 @@ task_hostlist_saving (void *cls) | |||
1154 | */ | 1201 | */ |
1155 | static void * | 1202 | static void * |
1156 | handler_connect (void *cls, | 1203 | handler_connect (void *cls, |
1157 | const struct GNUNET_PeerIdentity *peer, | 1204 | const struct GNUNET_PeerIdentity *peer, |
1158 | struct GNUNET_MQ_Handle *mq) | 1205 | struct GNUNET_MQ_Handle *mq) |
1159 | { | 1206 | { |
1160 | GNUNET_assert (stat_connection_count < UINT_MAX); | 1207 | GNUNET_assert (stat_connection_count < UINT_MAX); |
1161 | stat_connection_count++; | 1208 | stat_connection_count++; |
1162 | GNUNET_STATISTICS_update (stats, | 1209 | GNUNET_STATISTICS_update (stats, |
1163 | gettext_noop ("# active connections"), | 1210 | gettext_noop ("# active connections"), |
1164 | 1, | 1211 | 1, |
1165 | GNUNET_NO); | 1212 | GNUNET_NO); |
1166 | return NULL; | 1213 | return NULL; |
1167 | } | 1214 | } |
@@ -1175,14 +1222,14 @@ handler_connect (void *cls, | |||
1175 | */ | 1222 | */ |
1176 | static void | 1223 | static void |
1177 | handler_disconnect (void *cls, | 1224 | handler_disconnect (void *cls, |
1178 | const struct GNUNET_PeerIdentity *peer, | 1225 | const struct GNUNET_PeerIdentity *peer, |
1179 | void *internal_cls) | 1226 | void *internal_cls) |
1180 | { | 1227 | { |
1181 | GNUNET_assert (stat_connection_count > 0); | 1228 | GNUNET_assert (stat_connection_count > 0); |
1182 | stat_connection_count--; | 1229 | stat_connection_count--; |
1183 | GNUNET_STATISTICS_update (stats, | 1230 | GNUNET_STATISTICS_update (stats, |
1184 | gettext_noop ("# active connections"), | 1231 | gettext_noop ("# active connections"), |
1185 | -1, | 1232 | -1, |
1186 | GNUNET_NO); | 1233 | GNUNET_NO); |
1187 | } | 1234 | } |
1188 | 1235 | ||
@@ -1201,33 +1248,31 @@ handler_advertisement (const char *uri) | |||
1201 | uri_size = strlen (uri) + 1; | 1248 | uri_size = strlen (uri) + 1; |
1202 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1249 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1203 | "Hostlist client recieved advertisement containing URI `%s'\n", | 1250 | "Hostlist client recieved advertisement containing URI `%s'\n", |
1204 | uri); | 1251 | uri); |
1205 | if (GNUNET_NO != linked_list_contains (uri)) | 1252 | if (GNUNET_NO != linked_list_contains (uri)) |
1206 | { | 1253 | { |
1207 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1254 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "URI `%s' is already known\n", uri); |
1208 | "URI `%s' is already known\n", | ||
1209 | uri); | ||
1210 | return; | 1255 | return; |
1211 | } | 1256 | } |
1212 | 1257 | ||
1213 | if (GNUNET_NO == stat_testing_allowed) | 1258 | if (GNUNET_NO == stat_testing_allowed) |
1214 | { | 1259 | { |
1215 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1260 | GNUNET_log ( |
1216 | "Currently not accepting new advertisements: interval between to advertisements is not reached\n"); | 1261 | GNUNET_ERROR_TYPE_DEBUG, |
1262 | "Currently not accepting new advertisements: interval between to advertisements is not reached\n"); | ||
1217 | return; | 1263 | return; |
1218 | } | 1264 | } |
1219 | if (GNUNET_YES == stat_testing_hostlist) | 1265 | if (GNUNET_YES == stat_testing_hostlist) |
1220 | { | 1266 | { |
1221 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1267 | GNUNET_log ( |
1222 | "Currently not accepting new advertisements: we are already testing a hostlist\n"); | 1268 | GNUNET_ERROR_TYPE_DEBUG, |
1269 | "Currently not accepting new advertisements: we are already testing a hostlist\n"); | ||
1223 | return; | 1270 | return; |
1224 | } | 1271 | } |
1225 | 1272 | ||
1226 | hostlist = GNUNET_malloc (sizeof (struct Hostlist) + uri_size); | 1273 | hostlist = GNUNET_malloc (sizeof (struct Hostlist) + uri_size); |
1227 | hostlist->hostlist_uri = (const char *) &hostlist[1]; | 1274 | hostlist->hostlist_uri = (const char *) &hostlist[1]; |
1228 | GNUNET_memcpy (&hostlist[1], | 1275 | GNUNET_memcpy (&hostlist[1], uri, uri_size); |
1229 | uri, | ||
1230 | uri_size); | ||
1231 | hostlist->time_creation = GNUNET_TIME_absolute_get (); | 1276 | hostlist->time_creation = GNUNET_TIME_absolute_get (); |
1232 | hostlist->quality = HOSTLIST_INITIAL; | 1277 | hostlist->quality = HOSTLIST_INITIAL; |
1233 | hostlist_to_test = hostlist; | 1278 | hostlist_to_test = hostlist; |
@@ -1235,18 +1280,17 @@ handler_advertisement (const char *uri) | |||
1235 | stat_testing_hostlist = GNUNET_YES; | 1280 | stat_testing_hostlist = GNUNET_YES; |
1236 | stat_testing_allowed = GNUNET_NO; | 1281 | stat_testing_allowed = GNUNET_NO; |
1237 | ti_testing_intervall_task = | 1282 | ti_testing_intervall_task = |
1238 | GNUNET_SCHEDULER_add_delayed (TESTING_INTERVAL, | 1283 | GNUNET_SCHEDULER_add_delayed (TESTING_INTERVAL, |
1239 | &task_testing_intervall_reset, | 1284 | &task_testing_intervall_reset, |
1240 | NULL); | 1285 | NULL); |
1241 | 1286 | ||
1242 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1287 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1243 | "Testing new hostlist advertisements is locked for the next %s\n", | 1288 | "Testing new hostlist advertisements is locked for the next %s\n", |
1244 | GNUNET_STRINGS_relative_time_to_string (TESTING_INTERVAL, | 1289 | GNUNET_STRINGS_relative_time_to_string (TESTING_INTERVAL, |
1245 | GNUNET_YES)); | 1290 | GNUNET_YES)); |
1246 | 1291 | ||
1247 | ti_download_dispatcher_task = | 1292 | ti_download_dispatcher_task = |
1248 | GNUNET_SCHEDULER_add_now (&task_download_dispatcher, | 1293 | GNUNET_SCHEDULER_add_now (&task_download_dispatcher, NULL); |
1249 | NULL); | ||
1250 | } | 1294 | } |
1251 | 1295 | ||
1252 | 1296 | ||
@@ -1259,8 +1303,7 @@ handler_advertisement (const char *uri) | |||
1259 | * successfully obtained, #GNUNET_SYSERR if not. | 1303 | * successfully obtained, #GNUNET_SYSERR if not. |
1260 | */ | 1304 | */ |
1261 | static void | 1305 | static void |
1262 | primary_task (void *cls, | 1306 | primary_task (void *cls, int success) |
1263 | int success) | ||
1264 | { | 1307 | { |
1265 | if (NULL != ti_check_download) | 1308 | if (NULL != ti_check_download) |
1266 | { | 1309 | { |
@@ -1288,8 +1331,7 @@ stat_timeout_task (void *cls) | |||
1288 | { | 1331 | { |
1289 | GNUNET_STATISTICS_get_cancel (sget); | 1332 | GNUNET_STATISTICS_get_cancel (sget); |
1290 | sget = NULL; | 1333 | sget = NULL; |
1291 | ti_check_download = GNUNET_SCHEDULER_add_now (&task_check, | 1334 | ti_check_download = GNUNET_SCHEDULER_add_now (&task_check, NULL); |
1292 | NULL); | ||
1293 | } | 1335 | } |
1294 | 1336 | ||
1295 | 1337 | ||
@@ -1337,22 +1379,25 @@ load_hostlist_file () | |||
1337 | struct GNUNET_BIO_ReadHandle *rh; | 1379 | struct GNUNET_BIO_ReadHandle *rh; |
1338 | 1380 | ||
1339 | uri = NULL; | 1381 | uri = NULL; |
1340 | if (GNUNET_OK != | 1382 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, |
1341 | GNUNET_CONFIGURATION_get_value_filename (cfg, "HOSTLIST", "HOSTLISTFILE", | 1383 | "HOSTLIST", |
1342 | &filename)) | 1384 | "HOSTLISTFILE", |
1385 | &filename)) | ||
1343 | { | 1386 | { |
1344 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, | 1387 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, |
1345 | "hostlist", "HOSTLISTFILE"); | 1388 | "hostlist", |
1389 | "HOSTLISTFILE"); | ||
1346 | return; | 1390 | return; |
1347 | } | 1391 | } |
1348 | 1392 | ||
1349 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1393 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1350 | _("Loading saved hostlist entries from file `%s' \n"), | 1394 | _ ("Loading saved hostlist entries from file `%s' \n"), |
1351 | filename); | 1395 | filename); |
1352 | if (GNUNET_NO == GNUNET_DISK_file_test (filename)) | 1396 | if (GNUNET_NO == GNUNET_DISK_file_test (filename)) |
1353 | { | 1397 | { |
1354 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1398 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1355 | _("Hostlist file `%s' does not exist\n"), filename); | 1399 | _ ("Hostlist file `%s' does not exist\n"), |
1400 | filename); | ||
1356 | GNUNET_free (filename); | 1401 | GNUNET_free (filename); |
1357 | return; | 1402 | return; |
1358 | } | 1403 | } |
@@ -1361,16 +1406,19 @@ load_hostlist_file () | |||
1361 | if (NULL == rh) | 1406 | if (NULL == rh) |
1362 | { | 1407 | { |
1363 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1408 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1364 | _("Could not open file `%s' for reading to load hostlists: %s\n"), | 1409 | _ ( |
1365 | filename, STRERROR (errno)); | 1410 | "Could not open file `%s' for reading to load hostlists: %s\n"), |
1411 | filename, | ||
1412 | strerror (errno)); | ||
1366 | GNUNET_free (filename); | 1413 | GNUNET_free (filename); |
1367 | return; | 1414 | return; |
1368 | } | 1415 | } |
1369 | 1416 | ||
1370 | counter = 0; | 1417 | counter = 0; |
1371 | while ((GNUNET_OK == GNUNET_BIO_read_string (rh, "url", &uri, MAX_URL_LEN)) && | 1418 | while ((GNUNET_OK == GNUNET_BIO_read_string (rh, "url", &uri, MAX_URL_LEN)) && |
1372 | (NULL != uri) && (GNUNET_OK == GNUNET_BIO_read_int32 (rh, ×_used)) | 1419 | (NULL != uri) && |
1373 | && (GNUNET_OK == GNUNET_BIO_read_int64 (rh, &quality)) && | 1420 | (GNUNET_OK == GNUNET_BIO_read_int32 (rh, ×_used)) && |
1421 | (GNUNET_OK == GNUNET_BIO_read_int64 (rh, &quality)) && | ||
1374 | (GNUNET_OK == GNUNET_BIO_read_int64 (rh, &last_used)) && | 1422 | (GNUNET_OK == GNUNET_BIO_read_int64 (rh, &last_used)) && |
1375 | (GNUNET_OK == GNUNET_BIO_read_int64 (rh, &created)) && | 1423 | (GNUNET_OK == GNUNET_BIO_read_int64 (rh, &created)) && |
1376 | (GNUNET_OK == GNUNET_BIO_read_int32 (rh, &hellos_returned))) | 1424 | (GNUNET_OK == GNUNET_BIO_read_int32 (rh, &hellos_returned))) |
@@ -1395,14 +1443,16 @@ load_hostlist_file () | |||
1395 | } | 1443 | } |
1396 | 1444 | ||
1397 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1445 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1398 | _("%u hostlist URIs loaded from file\n"), | 1446 | _ ("%u hostlist URIs loaded from file\n"), |
1399 | counter); | 1447 | counter); |
1400 | GNUNET_STATISTICS_set (stats, | 1448 | GNUNET_STATISTICS_set (stats, |
1401 | gettext_noop ("# hostlist URIs read from file"), | 1449 | gettext_noop ("# hostlist URIs read from file"), |
1402 | counter, GNUNET_YES); | 1450 | counter, |
1451 | GNUNET_YES); | ||
1403 | GNUNET_STATISTICS_set (stats, | 1452 | GNUNET_STATISTICS_set (stats, |
1404 | gettext_noop ("# advertised hostlist URIs"), | 1453 | gettext_noop ("# advertised hostlist URIs"), |
1405 | linked_list_size, GNUNET_NO); | 1454 | linked_list_size, |
1455 | GNUNET_NO); | ||
1406 | 1456 | ||
1407 | GNUNET_free_non_null (uri); | 1457 | GNUNET_free_non_null (uri); |
1408 | emsg = NULL; | 1458 | emsg = NULL; |
@@ -1427,12 +1477,14 @@ save_hostlist_file (int shutdown) | |||
1427 | int ok; | 1477 | int ok; |
1428 | uint32_t counter; | 1478 | uint32_t counter; |
1429 | 1479 | ||
1430 | if (GNUNET_OK != | 1480 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, |
1431 | GNUNET_CONFIGURATION_get_value_filename (cfg, "HOSTLIST", "HOSTLISTFILE", | 1481 | "HOSTLIST", |
1432 | &filename)) | 1482 | "HOSTLISTFILE", |
1483 | &filename)) | ||
1433 | { | 1484 | { |
1434 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, | 1485 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_WARNING, |
1435 | "hostlist", "HOSTLISTFILE"); | 1486 | "hostlist", |
1487 | "HOSTLISTFILE"); | ||
1436 | return; | 1488 | return; |
1437 | } | 1489 | } |
1438 | if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename)) | 1490 | if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename)) |
@@ -1444,15 +1496,17 @@ save_hostlist_file (int shutdown) | |||
1444 | if (NULL == wh) | 1496 | if (NULL == wh) |
1445 | { | 1497 | { |
1446 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 1498 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1447 | _("Could not open file `%s' for writing to save hostlists: %s\n"), | 1499 | _ ( |
1500 | "Could not open file `%s' for writing to save hostlists: %s\n"), | ||
1448 | filename, | 1501 | filename, |
1449 | STRERROR (errno)); | 1502 | strerror (errno)); |
1450 | GNUNET_free (filename); | 1503 | GNUNET_free (filename); |
1451 | return; | 1504 | return; |
1452 | } | 1505 | } |
1453 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1506 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1454 | _("Writing %u hostlist URIs to `%s'\n"), | 1507 | _ ("Writing %u hostlist URIs to `%s'\n"), |
1455 | linked_list_size, filename); | 1508 | linked_list_size, |
1509 | filename); | ||
1456 | /* add code to write hostlists to file using bio */ | 1510 | /* add code to write hostlists to file using bio */ |
1457 | ok = GNUNET_YES; | 1511 | ok = GNUNET_YES; |
1458 | counter = 0; | 1512 | counter = 0; |
@@ -1475,7 +1529,8 @@ save_hostlist_file (int shutdown) | |||
1475 | (GNUNET_OK != GNUNET_BIO_write_int32 (wh, pos->hello_count))) | 1529 | (GNUNET_OK != GNUNET_BIO_write_int32 (wh, pos->hello_count))) |
1476 | { | 1530 | { |
1477 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 1531 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1478 | _("Error writing hostlist URIs to file `%s'\n"), filename); | 1532 | _ ("Error writing hostlist URIs to file `%s'\n"), |
1533 | filename); | ||
1479 | ok = GNUNET_NO; | 1534 | ok = GNUNET_NO; |
1480 | } | 1535 | } |
1481 | } | 1536 | } |
@@ -1488,11 +1543,13 @@ save_hostlist_file (int shutdown) | |||
1488 | } | 1543 | } |
1489 | GNUNET_STATISTICS_set (stats, | 1544 | GNUNET_STATISTICS_set (stats, |
1490 | gettext_noop ("# hostlist URIs written to file"), | 1545 | gettext_noop ("# hostlist URIs written to file"), |
1491 | counter, GNUNET_YES); | 1546 | counter, |
1547 | GNUNET_YES); | ||
1492 | 1548 | ||
1493 | if (GNUNET_OK != GNUNET_BIO_write_close (wh)) | 1549 | if (GNUNET_OK != GNUNET_BIO_write_close (wh)) |
1494 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 1550 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1495 | _("Error writing hostlist URIs to file `%s'\n"), filename); | 1551 | _ ("Error writing hostlist URIs to file `%s'\n"), |
1552 | filename); | ||
1496 | GNUNET_free (filename); | 1553 | GNUNET_free (filename); |
1497 | } | 1554 | } |
1498 | 1555 | ||
@@ -1532,47 +1589,38 @@ GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
1532 | /* Read proxy configuration */ | 1589 | /* Read proxy configuration */ |
1533 | pi = GNUNET_PEERINFO_connect (c); | 1590 | pi = GNUNET_PEERINFO_connect (c); |
1534 | if (GNUNET_OK == | 1591 | if (GNUNET_OK == |
1535 | GNUNET_CONFIGURATION_get_value_string (cfg, | 1592 | GNUNET_CONFIGURATION_get_value_string (cfg, "HOSTLIST", "PROXY", &proxy)) |
1536 | "HOSTLIST", | ||
1537 | "PROXY", | ||
1538 | &proxy)) | ||
1539 | { | 1593 | { |
1540 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1594 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found proxy host: `%s'\n", proxy); |
1541 | "Found proxy host: `%s'\n", | ||
1542 | proxy); | ||
1543 | /* proxy username */ | 1595 | /* proxy username */ |
1544 | if (GNUNET_OK == | 1596 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, |
1545 | GNUNET_CONFIGURATION_get_value_string (cfg, | 1597 | "HOSTLIST", |
1546 | "HOSTLIST", | 1598 | "PROXY_USERNAME", |
1547 | "PROXY_USERNAME", | 1599 | &proxy_username)) |
1548 | &proxy_username)) | ||
1549 | { | 1600 | { |
1550 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1601 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1551 | "Found proxy username name: `%s'\n", | 1602 | "Found proxy username name: `%s'\n", |
1552 | proxy_username); | 1603 | proxy_username); |
1553 | } | 1604 | } |
1554 | 1605 | ||
1555 | /* proxy password */ | 1606 | /* proxy password */ |
1556 | if (GNUNET_OK == | 1607 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, |
1557 | GNUNET_CONFIGURATION_get_value_string (cfg, | 1608 | "HOSTLIST", |
1558 | "HOSTLIST", | 1609 | "PROXY_PASSWORD", |
1559 | "PROXY_PASSWORD", | 1610 | &proxy_password)) |
1560 | &proxy_password)) | ||
1561 | { | 1611 | { |
1562 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1612 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1563 | "Found proxy password name: `%s'\n", | 1613 | "Found proxy password name: `%s'\n", |
1564 | proxy_password); | 1614 | proxy_password); |
1565 | } | 1615 | } |
1566 | 1616 | ||
1567 | /* proxy type */ | 1617 | /* proxy type */ |
1568 | if (GNUNET_OK == | 1618 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, |
1569 | GNUNET_CONFIGURATION_get_value_string (cfg, | 1619 | "HOSTLIST", |
1570 | "HOSTLIST", | 1620 | "PROXY_TYPE", |
1571 | "PROXY_TYPE", | 1621 | &proxytype_str)) |
1572 | &proxytype_str)) | ||
1573 | { | 1622 | { |
1574 | GNUNET_STRINGS_utf8_toupper (proxytype_str, | 1623 | GNUNET_STRINGS_utf8_toupper (proxytype_str, proxytype_str); |
1575 | proxytype_str); | ||
1576 | proxy_type = CURLPROXY_HTTP; | 1624 | proxy_type = CURLPROXY_HTTP; |
1577 | if (0 == strcmp (proxytype_str, "HTTP")) | 1625 | if (0 == strcmp (proxytype_str, "HTTP")) |
1578 | proxy_type = CURLPROXY_HTTP; | 1626 | proxy_type = CURLPROXY_HTTP; |
@@ -1588,9 +1636,11 @@ GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
1588 | proxy_type = CURLPROXY_SOCKS5_HOSTNAME; | 1636 | proxy_type = CURLPROXY_SOCKS5_HOSTNAME; |
1589 | else | 1637 | else |
1590 | { | 1638 | { |
1591 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1639 | GNUNET_log ( |
1592 | _("Invalid proxy type: `%s', disabling proxy! Check configuration!\n"), | 1640 | GNUNET_ERROR_TYPE_ERROR, |
1593 | proxytype_str); | 1641 | _ ( |
1642 | "Invalid proxy type: `%s', disabling proxy! Check configuration!\n"), | ||
1643 | proxytype_str); | ||
1594 | GNUNET_free (proxytype_str); | 1644 | GNUNET_free (proxytype_str); |
1595 | GNUNET_free (proxy); | 1645 | GNUNET_free (proxy); |
1596 | proxy = NULL; | 1646 | proxy = NULL; |
@@ -1618,35 +1668,35 @@ GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
1618 | { | 1668 | { |
1619 | *msgh = &handler_advertisement; | 1669 | *msgh = &handler_advertisement; |
1620 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1670 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1621 | _("Learning is enabled on this peer\n")); | 1671 | _ ("Learning is enabled on this peer\n")); |
1622 | load_hostlist_file (); | 1672 | load_hostlist_file (); |
1623 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1673 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1624 | "Hostlists will be saved to file again in %s\n", | 1674 | "Hostlists will be saved to file again in %s\n", |
1625 | GNUNET_STRINGS_relative_time_to_string (SAVING_INTERVAL, | 1675 | GNUNET_STRINGS_relative_time_to_string (SAVING_INTERVAL, |
1626 | GNUNET_YES)); | 1676 | GNUNET_YES)); |
1627 | ti_saving_task = | 1677 | ti_saving_task = GNUNET_SCHEDULER_add_delayed (SAVING_INTERVAL, |
1628 | GNUNET_SCHEDULER_add_delayed (SAVING_INTERVAL, | 1678 | &task_hostlist_saving, |
1629 | &task_hostlist_saving, | 1679 | NULL); |
1630 | NULL); | ||
1631 | } | 1680 | } |
1632 | else | 1681 | else |
1633 | { | 1682 | { |
1634 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1683 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, |
1635 | _("Learning is not enabled on this peer\n")); | 1684 | _ ("Learning is not enabled on this peer\n")); |
1636 | *msgh = NULL; | 1685 | *msgh = NULL; |
1637 | if (GNUNET_OK == | 1686 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, |
1638 | GNUNET_CONFIGURATION_get_value_filename (cfg, | 1687 | "HOSTLIST", |
1639 | "HOSTLIST", | 1688 | "HOSTLISTFILE", |
1640 | "HOSTLISTFILE", | 1689 | &filename)) |
1641 | &filename)) | ||
1642 | { | 1690 | { |
1643 | if (GNUNET_YES == GNUNET_DISK_file_test (filename)) | 1691 | if (GNUNET_YES == GNUNET_DISK_file_test (filename)) |
1644 | { | 1692 | { |
1645 | result = remove (filename); | 1693 | result = remove (filename); |
1646 | if (0 == result) | 1694 | if (0 == result) |
1647 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1695 | GNUNET_log ( |
1648 | _("Since learning is not enabled on this peer, hostlist file `%s' was removed\n"), | 1696 | GNUNET_ERROR_TYPE_INFO, |
1649 | filename); | 1697 | _ ( |
1698 | "Since learning is not enabled on this peer, hostlist file `%s' was removed\n"), | ||
1699 | filename); | ||
1650 | else | 1700 | else |
1651 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, | 1701 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, |
1652 | "remove", | 1702 | "remove", |
@@ -1657,25 +1707,24 @@ GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
1657 | } | 1707 | } |
1658 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1708 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1659 | "Loading stats value on hostlist download frequency\n"); | 1709 | "Loading stats value on hostlist download frequency\n"); |
1660 | sget = GNUNET_STATISTICS_get (stats, "hostlist", | 1710 | sget = GNUNET_STATISTICS_get (stats, |
1661 | gettext_noop | 1711 | "hostlist", |
1662 | ("# milliseconds between hostlist downloads"), | 1712 | gettext_noop ( |
1713 | "# milliseconds between hostlist downloads"), | ||
1663 | &primary_task, | 1714 | &primary_task, |
1664 | &process_stat, | 1715 | &process_stat, |
1665 | NULL); | 1716 | NULL); |
1666 | if (NULL == sget) | 1717 | if (NULL == sget) |
1667 | { | 1718 | { |
1668 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1719 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1669 | "Statistics request failed, scheduling hostlist download\n"); | 1720 | "Statistics request failed, scheduling hostlist download\n"); |
1670 | ti_check_download = GNUNET_SCHEDULER_add_now (&task_check, | 1721 | ti_check_download = GNUNET_SCHEDULER_add_now (&task_check, NULL); |
1671 | NULL); | ||
1672 | } | 1722 | } |
1673 | else | 1723 | else |
1674 | { | 1724 | { |
1675 | ti_check_download | 1725 | ti_check_download = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, |
1676 | = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, | 1726 | &stat_timeout_task, |
1677 | &stat_timeout_task, | 1727 | NULL); |
1678 | NULL); | ||
1679 | } | 1728 | } |
1680 | return GNUNET_OK; | 1729 | return GNUNET_OK; |
1681 | } | 1730 | } |
@@ -1687,8 +1736,7 @@ GNUNET_HOSTLIST_client_start (const struct GNUNET_CONFIGURATION_Handle *c, | |||
1687 | void | 1736 | void |
1688 | GNUNET_HOSTLIST_client_stop () | 1737 | GNUNET_HOSTLIST_client_stop () |
1689 | { | 1738 | { |
1690 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1739 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist client shutdown\n"); |
1691 | "Hostlist client shutdown\n"); | ||
1692 | if (NULL != sget) | 1740 | if (NULL != sget) |
1693 | { | 1741 | { |
1694 | GNUNET_STATISTICS_get_cancel (sget); | 1742 | GNUNET_STATISTICS_get_cancel (sget); |
@@ -1703,7 +1751,7 @@ GNUNET_HOSTLIST_client_stop () | |||
1703 | ti_saving_task = NULL; | 1751 | ti_saving_task = NULL; |
1704 | } | 1752 | } |
1705 | if (NULL != ti_download_dispatcher_task) | 1753 | if (NULL != ti_download_dispatcher_task) |
1706 | { | 1754 | { |
1707 | GNUNET_SCHEDULER_cancel (ti_download_dispatcher_task); | 1755 | GNUNET_SCHEDULER_cancel (ti_download_dispatcher_task); |
1708 | ti_download_dispatcher_task = NULL; | 1756 | ti_download_dispatcher_task = NULL; |
1709 | } | 1757 | } |
diff --git a/src/mysql/mysql.c b/src/mysql/mysql.c index 652d7e7d8..c78fbeb4b 100644 --- a/src/mysql/mysql.c +++ b/src/mysql/mysql.c | |||
@@ -208,7 +208,7 @@ get_my_cnf_path (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
208 | "mysql", | 208 | "mysql", |
209 | _ ("Could not access file `%s': %s\n"), | 209 | _ ("Could not access file `%s': %s\n"), |
210 | cnffile, | 210 | cnffile, |
211 | STRERROR (errno)); | 211 | strerror (errno)); |
212 | GNUNET_free (cnffile); | 212 | GNUNET_free (cnffile); |
213 | return NULL; | 213 | return NULL; |
214 | } | 214 | } |
diff --git a/src/nat-auto/gnunet-nat-auto_legacy.c b/src/nat-auto/gnunet-nat-auto_legacy.c index 4a24223fd..93b544343 100644 --- a/src/nat-auto/gnunet-nat-auto_legacy.c +++ b/src/nat-auto/gnunet-nat-auto_legacy.c | |||
@@ -28,9 +28,10 @@ | |||
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 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) | 33 | #define NAT_SERVER_TIMEOUT \ |
34 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30) | ||
34 | 35 | ||
35 | /** | 36 | /** |
36 | * Entry we keep for each incoming connection. | 37 | * Entry we keep for each incoming connection. |
@@ -88,7 +89,6 @@ struct ClientActivity | |||
88 | * Handle to overall NAT test. | 89 | * Handle to overall NAT test. |
89 | */ | 90 | */ |
90 | struct GNUNET_NAT_Test *h; | 91 | struct GNUNET_NAT_Test *h; |
91 | |||
92 | }; | 92 | }; |
93 | 93 | ||
94 | 94 | ||
@@ -184,9 +184,7 @@ struct GNUNET_NAT_Test | |||
184 | * @param addrlen actual lenght of the @a addr | 184 | * @param addrlen actual lenght of the @a addr |
185 | */ | 185 | */ |
186 | static void | 186 | static void |
187 | reversal_cb (void *cls, | 187 | reversal_cb (void *cls, const struct sockaddr *addr, socklen_t addrlen) |
188 | const struct sockaddr *addr, | ||
189 | socklen_t addrlen) | ||
190 | { | 188 | { |
191 | struct GNUNET_NAT_Test *h = cls; | 189 | struct GNUNET_NAT_Test *h = cls; |
192 | const struct sockaddr_in *sa; | 190 | const struct sockaddr_in *sa; |
@@ -198,11 +196,10 @@ reversal_cb (void *cls, | |||
198 | { | 196 | { |
199 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 197 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
200 | "Received connection reversal request for wrong port\n"); | 198 | "Received connection reversal request for wrong port\n"); |
201 | return; /* wrong port */ | 199 | return; /* wrong port */ |
202 | } | 200 | } |
203 | /* report success */ | 201 | /* report success */ |
204 | h->report (h->report_cls, | 202 | h->report (h->report_cls, GNUNET_NAT_ERROR_SUCCESS); |
205 | GNUNET_NAT_ERROR_SUCCESS); | ||
206 | } | 203 | } |
207 | 204 | ||
208 | 205 | ||
@@ -220,22 +217,17 @@ do_udp_read (void *cls) | |||
220 | const struct GNUNET_SCHEDULER_TaskContext *tc; | 217 | const struct GNUNET_SCHEDULER_TaskContext *tc; |
221 | 218 | ||
222 | tc = GNUNET_SCHEDULER_get_task_context (); | 219 | tc = GNUNET_SCHEDULER_get_task_context (); |
223 | tst->ltask = | 220 | tst->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
224 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 221 | tst->lsock, |
225 | tst->lsock, | 222 | &do_udp_read, |
226 | &do_udp_read, | 223 | tst); |
227 | tst); | ||
228 | if ((NULL != tc->write_ready) && | 224 | if ((NULL != tc->write_ready) && |
229 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, | 225 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, tst->lsock)) && |
230 | tst->lsock)) && | ||
231 | (sizeof (data) == | 226 | (sizeof (data) == |
232 | GNUNET_NETWORK_socket_recv (tst->lsock, | 227 | GNUNET_NETWORK_socket_recv (tst->lsock, &data, sizeof (data)))) |
233 | &data, | ||
234 | sizeof (data)))) | ||
235 | { | 228 | { |
236 | if (data == tst->data) | 229 | if (data == tst->data) |
237 | tst->report (tst->report_cls, | 230 | tst->report (tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); |
238 | GNUNET_NAT_ERROR_SUCCESS); | ||
239 | else | 231 | else |
240 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 232 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
241 | "Received data mismatches expected value\n"); | 233 | "Received data mismatches expected value\n"); |
@@ -263,20 +255,14 @@ do_read (void *cls) | |||
263 | tc = GNUNET_SCHEDULER_get_task_context (); | 255 | tc = GNUNET_SCHEDULER_get_task_context (); |
264 | na->rtask = NULL; | 256 | na->rtask = NULL; |
265 | tst = na->h; | 257 | tst = na->h; |
266 | GNUNET_CONTAINER_DLL_remove (tst->na_head, | 258 | GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, na); |
267 | tst->na_tail, | ||
268 | na); | ||
269 | if ((NULL != tc->write_ready) && | 259 | if ((NULL != tc->write_ready) && |
270 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, | 260 | (GNUNET_NETWORK_fdset_isset (tc->read_ready, na->sock)) && |
271 | na->sock)) && | ||
272 | (sizeof (data) == | 261 | (sizeof (data) == |
273 | GNUNET_NETWORK_socket_recv (na->sock, | 262 | GNUNET_NETWORK_socket_recv (na->sock, &data, sizeof (data)))) |
274 | &data, | ||
275 | sizeof (data)))) | ||
276 | { | 263 | { |
277 | if (data == tst->data) | 264 | if (data == tst->data) |
278 | tst->report (tst->report_cls, | 265 | tst->report (tst->report_cls, GNUNET_NAT_ERROR_SUCCESS); |
279 | GNUNET_NAT_ERROR_SUCCESS); | ||
280 | else | 266 | else |
281 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 267 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
282 | "Received data does not match expected value\n"); | 268 | "Received data does not match expected value\n"); |
@@ -306,28 +292,22 @@ do_accept (void *cls) | |||
306 | tst->lsock, | 292 | tst->lsock, |
307 | &do_accept, | 293 | &do_accept, |
308 | tst); | 294 | tst); |
309 | s = GNUNET_NETWORK_socket_accept (tst->lsock, | 295 | s = GNUNET_NETWORK_socket_accept (tst->lsock, NULL, NULL); |
310 | NULL, | ||
311 | NULL); | ||
312 | if (NULL == s) | 296 | if (NULL == s) |
313 | { | 297 | { |
314 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, | 298 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "accept"); |
315 | "accept"); | 299 | return; /* odd error */ |
316 | return; /* odd error */ | ||
317 | } | 300 | } |
318 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 301 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
319 | "Got an inbound connection, waiting for data\n"); | 302 | "Got an inbound connection, waiting for data\n"); |
320 | wl = GNUNET_new (struct NatActivity); | 303 | wl = GNUNET_new (struct NatActivity); |
321 | wl->sock = s; | 304 | wl->sock = s; |
322 | wl->h = tst; | 305 | wl->h = tst; |
323 | wl->rtask = | 306 | wl->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
324 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 307 | wl->sock, |
325 | wl->sock, | 308 | &do_read, |
326 | &do_read, | 309 | wl); |
327 | wl); | 310 | GNUNET_CONTAINER_DLL_insert (tst->na_head, tst->na_tail, wl); |
328 | GNUNET_CONTAINER_DLL_insert (tst->na_head, | ||
329 | tst->na_tail, | ||
330 | wl); | ||
331 | } | 311 | } |
332 | 312 | ||
333 | 313 | ||
@@ -339,15 +319,12 @@ do_accept (void *cls) | |||
339 | * @param error error code | 319 | * @param error error code |
340 | */ | 320 | */ |
341 | static void | 321 | static void |
342 | mq_error_handler (void *cls, | 322 | mq_error_handler (void *cls, enum GNUNET_MQ_Error error) |
343 | enum GNUNET_MQ_Error error) | ||
344 | { | 323 | { |
345 | struct ClientActivity *ca = cls; | 324 | struct ClientActivity *ca = cls; |
346 | struct GNUNET_NAT_Test *tst = ca->h; | 325 | struct GNUNET_NAT_Test *tst = ca->h; |
347 | 326 | ||
348 | GNUNET_CONTAINER_DLL_remove (tst->ca_head, | 327 | GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, ca); |
349 | tst->ca_tail, | ||
350 | ca); | ||
351 | GNUNET_MQ_destroy (ca->mq); | 328 | GNUNET_MQ_destroy (ca->mq); |
352 | GNUNET_free (ca); | 329 | GNUNET_free (ca); |
353 | } | 330 | } |
@@ -379,15 +356,13 @@ addr_cb (void *cls, | |||
379 | if (addrlen != sizeof (struct sockaddr_in)) | 356 | if (addrlen != sizeof (struct sockaddr_in)) |
380 | { | 357 | { |
381 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 358 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
382 | "NAT test ignores IPv6 address `%s' returned from NAT library\n", | 359 | "NAT test ignores IPv6 address `%s' returned from NAT library\n", |
383 | GNUNET_a2s (addr, | 360 | GNUNET_a2s (addr, addrlen)); |
384 | addrlen)); | 361 | return; /* ignore IPv6 here */ |
385 | return; /* ignore IPv6 here */ | ||
386 | } | 362 | } |
387 | LOG (GNUNET_ERROR_TYPE_INFO, | 363 | LOG (GNUNET_ERROR_TYPE_INFO, |
388 | "Asking gnunet-nat-server to connect to `%s'\n", | 364 | "Asking gnunet-nat-server to connect to `%s'\n", |
389 | GNUNET_a2s (addr, | 365 | GNUNET_a2s (addr, addrlen)); |
390 | addrlen)); | ||
391 | 366 | ||
392 | ca = GNUNET_new (struct ClientActivity); | 367 | ca = GNUNET_new (struct ClientActivity); |
393 | ca->h = h; | 368 | ca->h = h; |
@@ -400,21 +375,17 @@ addr_cb (void *cls, | |||
400 | { | 375 | { |
401 | GNUNET_free (ca); | 376 | GNUNET_free (ca); |
402 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 377 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
403 | _("Failed to connect to `gnunet-nat-server'\n")); | 378 | _ ("Failed to connect to `gnunet-nat-server'\n")); |
404 | return; | 379 | return; |
405 | } | 380 | } |
406 | GNUNET_CONTAINER_DLL_insert (h->ca_head, | 381 | GNUNET_CONTAINER_DLL_insert (h->ca_head, h->ca_tail, ca); |
407 | h->ca_tail, | ||
408 | ca); | ||
409 | sa = (const struct sockaddr_in *) addr; | 382 | sa = (const struct sockaddr_in *) addr; |
410 | env = GNUNET_MQ_msg (msg, | 383 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAT_TEST); |
411 | GNUNET_MESSAGE_TYPE_NAT_TEST); | ||
412 | msg->dst_ipv4 = sa->sin_addr.s_addr; | 384 | msg->dst_ipv4 = sa->sin_addr.s_addr; |
413 | msg->dport = sa->sin_port; | 385 | msg->dport = sa->sin_port; |
414 | msg->data = h->data; | 386 | msg->data = h->data; |
415 | msg->is_tcp = htonl ((uint32_t) h->is_tcp); | 387 | msg->is_tcp = htonl ((uint32_t) h->is_tcp); |
416 | GNUNET_MQ_send (ca->mq, | 388 | GNUNET_MQ_send (ca->mq, env); |
417 | env); | ||
418 | } | 389 | } |
419 | 390 | ||
420 | 391 | ||
@@ -434,8 +405,8 @@ do_timeout (void *cls) | |||
434 | nh->ttask = NULL; | 405 | nh->ttask = NULL; |
435 | nh->report (nh->report_cls, | 406 | nh->report (nh->report_cls, |
436 | (GNUNET_NAT_ERROR_SUCCESS == nh->status) | 407 | (GNUNET_NAT_ERROR_SUCCESS == nh->status) |
437 | ? GNUNET_NAT_ERROR_TIMEOUT | 408 | ? GNUNET_NAT_ERROR_TIMEOUT |
438 | : nh->status); | 409 | : nh->status); |
439 | } | 410 | } |
440 | 411 | ||
441 | 412 | ||
@@ -465,12 +436,8 @@ GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
465 | { | 436 | { |
466 | struct GNUNET_NAT_Test *nh; | 437 | struct GNUNET_NAT_Test *nh; |
467 | struct sockaddr_in sa; | 438 | struct sockaddr_in sa; |
468 | const struct sockaddr *addrs[] = { | 439 | const struct sockaddr *addrs[] = {(const struct sockaddr *) &sa}; |
469 | (const struct sockaddr *) &sa | 440 | const socklen_t addrlens[] = {sizeof (sa)}; |
470 | }; | ||
471 | const socklen_t addrlens[] = { | ||
472 | sizeof (sa) | ||
473 | }; | ||
474 | 441 | ||
475 | memset (&sa, 0, sizeof (sa)); | 442 | memset (&sa, 0, sizeof (sa)); |
476 | sa.sin_family = AF_INET; | 443 | sa.sin_family = AF_INET; |
@@ -489,69 +456,62 @@ GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
489 | nh->status = GNUNET_NAT_ERROR_SUCCESS; | 456 | nh->status = GNUNET_NAT_ERROR_SUCCESS; |
490 | if (0 == bnd_port) | 457 | if (0 == bnd_port) |
491 | { | 458 | { |
492 | nh->nat | 459 | nh->nat = GNUNET_NAT_register (cfg, |
493 | = GNUNET_NAT_register (cfg, | 460 | is_tcp, |
494 | is_tcp, | 461 | 0, |
495 | 0, | 462 | 0, |
496 | 0, | 463 | NULL, |
497 | NULL, | 464 | NULL, |
498 | NULL, | 465 | &addr_cb, |
499 | &addr_cb, | 466 | &reversal_cb, |
500 | &reversal_cb, | 467 | nh, |
501 | nh, | 468 | NULL); |
502 | NULL); | ||
503 | } | 469 | } |
504 | else | 470 | else |
505 | { | 471 | { |
506 | nh->lsock = | 472 | nh->lsock = |
507 | GNUNET_NETWORK_socket_create (AF_INET, | 473 | GNUNET_NETWORK_socket_create (AF_INET, |
508 | (is_tcp == | 474 | (is_tcp == GNUNET_YES) ? SOCK_STREAM |
509 | GNUNET_YES) ? SOCK_STREAM : SOCK_DGRAM, | 475 | : SOCK_DGRAM, |
510 | 0); | 476 | 0); |
511 | if ((nh->lsock == NULL) || | 477 | if ((nh->lsock == NULL) || |
512 | (GNUNET_OK != | 478 | (GNUNET_OK != GNUNET_NETWORK_socket_bind (nh->lsock, |
513 | GNUNET_NETWORK_socket_bind (nh->lsock, | 479 | (const struct sockaddr *) &sa, |
514 | (const struct sockaddr *) &sa, | 480 | sizeof (sa)))) |
515 | sizeof (sa)))) | ||
516 | { | 481 | { |
517 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 482 | GNUNET_log ( |
518 | _("Failed to create listen socket bound to `%s' for NAT test: %s\n"), | 483 | GNUNET_ERROR_TYPE_ERROR, |
519 | GNUNET_a2s ((const struct sockaddr *) &sa, | 484 | _ ("Failed to create listen socket bound to `%s' for NAT test: %s\n"), |
520 | sizeof (sa)), | 485 | GNUNET_a2s ((const struct sockaddr *) &sa, sizeof (sa)), |
521 | STRERROR (errno)); | 486 | strerror (errno)); |
522 | if (NULL != nh->lsock) | 487 | if (NULL != nh->lsock) |
523 | { | 488 | { |
524 | GNUNET_NETWORK_socket_close (nh->lsock); | 489 | GNUNET_NETWORK_socket_close (nh->lsock); |
525 | nh->lsock = NULL; | 490 | nh->lsock = NULL; |
526 | } | 491 | } |
527 | nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR; | 492 | nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR; |
528 | nh->ttask = GNUNET_SCHEDULER_add_now (&do_timeout, | 493 | nh->ttask = GNUNET_SCHEDULER_add_now (&do_timeout, nh); |
529 | nh); | ||
530 | return nh; | 494 | return nh; |
531 | } | 495 | } |
532 | if (GNUNET_YES == is_tcp) | 496 | if (GNUNET_YES == is_tcp) |
533 | { | 497 | { |
534 | GNUNET_break (GNUNET_OK == | 498 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_listen (nh->lsock, 5)); |
535 | GNUNET_NETWORK_socket_listen (nh->lsock, | 499 | nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
536 | 5)); | 500 | nh->lsock, |
537 | nh->ltask = | 501 | &do_accept, |
538 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 502 | nh); |
539 | nh->lsock, | ||
540 | &do_accept, | ||
541 | nh); | ||
542 | } | 503 | } |
543 | else | 504 | else |
544 | { | 505 | { |
545 | nh->ltask = | 506 | nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, |
546 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 507 | nh->lsock, |
547 | nh->lsock, | 508 | &do_udp_read, |
548 | &do_udp_read, | 509 | nh); |
549 | nh); | ||
550 | } | 510 | } |
551 | LOG (GNUNET_ERROR_TYPE_INFO, | 511 | LOG (GNUNET_ERROR_TYPE_INFO, |
552 | "NAT test listens on port %u (%s)\n", | 512 | "NAT test listens on port %u (%s)\n", |
553 | bnd_port, | 513 | bnd_port, |
554 | (GNUNET_YES == is_tcp) ? "tcp" : "udp"); | 514 | (GNUNET_YES == is_tcp) ? "tcp" : "udp"); |
555 | nh->nat = GNUNET_NAT_register (cfg, | 515 | nh->nat = GNUNET_NAT_register (cfg, |
556 | is_tcp, | 516 | is_tcp, |
557 | adv_port, | 517 | adv_port, |
@@ -565,7 +525,7 @@ GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
565 | if (NULL == nh->nat) | 525 | if (NULL == nh->nat) |
566 | { | 526 | { |
567 | LOG (GNUNET_ERROR_TYPE_INFO, | 527 | LOG (GNUNET_ERROR_TYPE_INFO, |
568 | _("NAT test failed to start NAT library\n")); | 528 | _ ("NAT test failed to start NAT library\n")); |
569 | if (NULL != nh->ltask) | 529 | if (NULL != nh->ltask) |
570 | { | 530 | { |
571 | GNUNET_SCHEDULER_cancel (nh->ltask); | 531 | GNUNET_SCHEDULER_cancel (nh->ltask); |
@@ -577,14 +537,11 @@ GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
577 | nh->lsock = NULL; | 537 | nh->lsock = NULL; |
578 | } | 538 | } |
579 | nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED; | 539 | nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED; |
580 | nh->ttask = GNUNET_SCHEDULER_add_now (&do_timeout, | 540 | nh->ttask = GNUNET_SCHEDULER_add_now (&do_timeout, nh); |
581 | nh); | ||
582 | return nh; | 541 | return nh; |
583 | } | 542 | } |
584 | } | 543 | } |
585 | nh->ttask = GNUNET_SCHEDULER_add_delayed (timeout, | 544 | nh->ttask = GNUNET_SCHEDULER_add_delayed (timeout, &do_timeout, nh); |
586 | &do_timeout, | ||
587 | nh); | ||
588 | return nh; | 545 | return nh; |
589 | } | 546 | } |
590 | 547 | ||
@@ -600,21 +557,16 @@ GNUNET_NAT_test_stop (struct GNUNET_NAT_Test *tst) | |||
600 | struct NatActivity *pos; | 557 | struct NatActivity *pos; |
601 | struct ClientActivity *cpos; | 558 | struct ClientActivity *cpos; |
602 | 559 | ||
603 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 560 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Stopping NAT test\n"); |
604 | "Stopping NAT test\n"); | ||
605 | while (NULL != (cpos = tst->ca_head)) | 561 | while (NULL != (cpos = tst->ca_head)) |
606 | { | 562 | { |
607 | GNUNET_CONTAINER_DLL_remove (tst->ca_head, | 563 | GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, cpos); |
608 | tst->ca_tail, | ||
609 | cpos); | ||
610 | GNUNET_MQ_destroy (cpos->mq); | 564 | GNUNET_MQ_destroy (cpos->mq); |
611 | GNUNET_free (cpos); | 565 | GNUNET_free (cpos); |
612 | } | 566 | } |
613 | while (NULL != (pos = tst->na_head)) | 567 | while (NULL != (pos = tst->na_head)) |
614 | { | 568 | { |
615 | GNUNET_CONTAINER_DLL_remove (tst->na_head, | 569 | GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, pos); |
616 | tst->na_tail, | ||
617 | pos); | ||
618 | GNUNET_SCHEDULER_cancel (pos->rtask); | 570 | GNUNET_SCHEDULER_cancel (pos->rtask); |
619 | GNUNET_NETWORK_socket_close (pos->sock); | 571 | GNUNET_NETWORK_socket_close (pos->sock); |
620 | GNUNET_free (pos); | 572 | GNUNET_free (pos); |
diff --git a/src/transport/gnunet-helper-transport-wlan-dummy.c b/src/transport/gnunet-helper-transport-wlan-dummy.c index c7ed1b903..0adf8f6a5 100644 --- a/src/transport/gnunet-helper-transport-wlan-dummy.c +++ b/src/transport/gnunet-helper-transport-wlan-dummy.c | |||
@@ -104,13 +104,14 @@ send_mac_to_plugin (char *buffer, struct GNUNET_TRANSPORT_WLAN_MacAddress *mac) | |||
104 | struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg; | 104 | struct GNUNET_TRANSPORT_WLAN_HelperControlMessage macmsg; |
105 | 105 | ||
106 | GNUNET_memcpy (&macmsg.mac, | 106 | GNUNET_memcpy (&macmsg.mac, |
107 | (char *) mac, | 107 | (char *) mac, |
108 | sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); | 108 | sizeof (struct GNUNET_TRANSPORT_WLAN_MacAddress)); |
109 | macmsg.hdr.size = htons (sizeof (struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)); | 109 | macmsg.hdr.size = |
110 | htons (sizeof (struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)); | ||
110 | macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL); | 111 | macmsg.hdr.type = htons (GNUNET_MESSAGE_TYPE_WLAN_HELPER_CONTROL); |
111 | GNUNET_memcpy (buffer, | 112 | GNUNET_memcpy (buffer, |
112 | &macmsg, | 113 | &macmsg, |
113 | sizeof (struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)); | 114 | sizeof (struct GNUNET_TRANSPORT_WLAN_HelperControlMessage)); |
114 | return sizeof (struct GNUNET_TRANSPORT_WLAN_HelperControlMessage); | 115 | return sizeof (struct GNUNET_TRANSPORT_WLAN_HelperControlMessage); |
115 | } | 116 | } |
116 | 117 | ||
@@ -126,8 +127,7 @@ send_mac_to_plugin (char *buffer, struct GNUNET_TRANSPORT_WLAN_MacAddress *mac) | |||
126 | * #GNUNET_SYSERR to stop further processing with error | 127 | * #GNUNET_SYSERR to stop further processing with error |
127 | */ | 128 | */ |
128 | static int | 129 | static int |
129 | stdin_send (void *cls, | 130 | stdin_send (void *cls, const struct GNUNET_MessageHeader *hdr) |
130 | const struct GNUNET_MessageHeader *hdr) | ||
131 | { | 131 | { |
132 | struct SendBuffer *write_pout = cls; | 132 | struct SendBuffer *write_pout = cls; |
133 | const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *in; | 133 | const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *in; |
@@ -137,16 +137,19 @@ stdin_send (void *cls, | |||
137 | 137 | ||
138 | sendsize = ntohs (hdr->size); | 138 | sendsize = ntohs (hdr->size); |
139 | in = (const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) hdr; | 139 | in = (const struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) hdr; |
140 | if ( (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs (hdr->type)) || | 140 | if ((GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER != ntohs (hdr->type)) || |
141 | (sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) > sendsize) ) | 141 | (sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage) > sendsize)) |
142 | { | 142 | { |
143 | fprintf (stderr, "%s", "Received malformed message\n"); | 143 | fprintf (stderr, "%s", "Received malformed message\n"); |
144 | exit (1); | 144 | exit (1); |
145 | } | 145 | } |
146 | payload_size = sendsize - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage); | 146 | payload_size = |
147 | if ((payload_size + sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) + write_pout->size) > MAXLINE * 2) | 147 | sendsize - sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage); |
148 | if ((payload_size + | ||
149 | sizeof (struct GNUNET_TRANSPORT_WLAN_RadiotapReceiveMessage) + | ||
150 | write_pout->size) > MAXLINE * 2) | ||
148 | { | 151 | { |
149 | fprintf (stderr, "%s", "Packet too big for buffer\n"); | 152 | fprintf (stderr, "%s", "Packet too big for buffer\n"); |
150 | exit (1); | 153 | exit (1); |
151 | } | 154 | } |
152 | memset (&newheader, 0, sizeof (newheader)); | 155 | memset (&newheader, 0, sizeof (newheader)); |
@@ -154,12 +157,10 @@ stdin_send (void *cls, | |||
154 | newheader.header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER); | 157 | newheader.header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_FROM_HELPER); |
155 | newheader.frame = in->frame; | 158 | newheader.frame = in->frame; |
156 | GNUNET_memcpy (write_pout->buf + write_pout->size, | 159 | GNUNET_memcpy (write_pout->buf + write_pout->size, |
157 | &newheader, | 160 | &newheader, |
158 | sizeof (newheader)); | 161 | sizeof (newheader)); |
159 | write_pout->size += sizeof (newheader); | 162 | write_pout->size += sizeof (newheader); |
160 | GNUNET_memcpy (write_pout->buf + write_pout->size, | 163 | GNUNET_memcpy (write_pout->buf + write_pout->size, &in[1], payload_size); |
161 | &in[1], | ||
162 | payload_size); | ||
163 | write_pout->size += payload_size; | 164 | write_pout->size += payload_size; |
164 | return GNUNET_OK; | 165 | return GNUNET_OK; |
165 | } | 166 | } |
@@ -175,8 +176,7 @@ stdin_send (void *cls, | |||
175 | * #GNUNET_SYSERR to stop further processing with error | 176 | * #GNUNET_SYSERR to stop further processing with error |
176 | */ | 177 | */ |
177 | static int | 178 | static int |
178 | file_in_send (void *cls, | 179 | file_in_send (void *cls, const struct GNUNET_MessageHeader *hdr) |
179 | const struct GNUNET_MessageHeader *hdr) | ||
180 | { | 180 | { |
181 | struct SendBuffer *write_std = cls; | 181 | struct SendBuffer *write_std = cls; |
182 | uint16_t sendsize; | 182 | uint16_t sendsize; |
@@ -224,45 +224,46 @@ main (int argc, char *argv[]) | |||
224 | struct GNUNET_TRANSPORT_WLAN_MacAddress macaddr; | 224 | struct GNUNET_TRANSPORT_WLAN_MacAddress macaddr; |
225 | int first; | 225 | int first; |
226 | 226 | ||
227 | if ( (2 != argc) || | 227 | if ((2 != argc) || |
228 | ((0 != strcmp (argv[1], "1")) && (0 != strcmp (argv[1], "2"))) ) | 228 | ((0 != strcmp (argv[1], "1")) && (0 != strcmp (argv[1], "2")))) |
229 | { | 229 | { |
230 | fprintf (stderr, | 230 | fprintf ( |
231 | "%s", | 231 | stderr, |
232 | "This program must be started with the operating mode (1 or 2) as the only argument.\n"); | 232 | "%s", |
233 | "This program must be started with the operating mode (1 or 2) as the only argument.\n"); | ||
233 | return 1; | 234 | return 1; |
234 | } | 235 | } |
235 | 236 | ||
236 | /* make the fifos if needed */ | 237 | /* make the fifos if needed */ |
237 | umask (0); | 238 | umask (0); |
238 | if ( (GNUNET_OK != GNUNET_DISK_directory_create_for_file (FIFO_FILE1)) || | 239 | if ((GNUNET_OK != GNUNET_DISK_directory_create_for_file (FIFO_FILE1)) || |
239 | (GNUNET_OK != GNUNET_DISK_directory_create_for_file (FIFO_FILE2)) ) | 240 | (GNUNET_OK != GNUNET_DISK_directory_create_for_file (FIFO_FILE2))) |
240 | { | 241 | { |
241 | fprintf (stderr, | 242 | fprintf (stderr, "Failed to create directory for file `%s'\n", FIFO_FILE1); |
242 | "Failed to create directory for file `%s'\n", | ||
243 | FIFO_FILE1); | ||
244 | return 1; | 243 | return 1; |
245 | } | 244 | } |
246 | if (0 == strcmp (argv[1], "1") ) | 245 | if (0 == strcmp (argv[1], "1")) |
247 | { | 246 | { |
248 | if (0 != stat (FIFO_FILE1, &st)) | 247 | if (0 != stat (FIFO_FILE1, &st)) |
249 | { | 248 | { |
250 | erg = mkfifo (FIFO_FILE1, 0666); | 249 | erg = mkfifo (FIFO_FILE1, 0666); |
251 | if ( (0 != erg) && (EEXIST != errno) ) | 250 | if ((0 != erg) && (EEXIST != errno)) |
252 | fprintf (stderr, "Error in mkfifo(%s): %s\n", FIFO_FILE1, | 251 | fprintf (stderr, |
253 | strerror (errno)); | 252 | "Error in mkfifo(%s): %s\n", |
253 | FIFO_FILE1, | ||
254 | strerror (errno)); | ||
254 | } | 255 | } |
255 | } | 256 | } |
256 | else | 257 | else |
257 | { | 258 | { |
258 | if (0 != stat (FIFO_FILE2, &st)) | 259 | if (0 != stat (FIFO_FILE2, &st)) |
259 | { | 260 | { |
260 | GNUNET_break (0 == (erg = mkfifo (FIFO_FILE2, 0666))); | 261 | GNUNET_break (0 == (erg = mkfifo (FIFO_FILE2, 0666))); |
261 | if ( (0 != erg) && (EEXIST != errno) ) | 262 | if ((0 != erg) && (EEXIST != errno)) |
262 | fprintf (stderr, | 263 | fprintf (stderr, |
263 | "Error in mkfifo(%s): %s\n", | 264 | "Error in mkfifo(%s): %s\n", |
264 | FIFO_FILE2, | 265 | FIFO_FILE2, |
265 | strerror (errno)); | 266 | strerror (errno)); |
266 | } | 267 | } |
267 | } | 268 | } |
268 | 269 | ||
@@ -274,7 +275,7 @@ main (int argc, char *argv[]) | |||
274 | { | 275 | { |
275 | fprintf (stderr, | 276 | fprintf (stderr, |
276 | "fopen of read FIFO_FILE1 failed: %s\n", | 277 | "fopen of read FIFO_FILE1 failed: %s\n", |
277 | STRERROR (errno)); | 278 | strerror (errno)); |
278 | goto end; | 279 | goto end; |
279 | } | 280 | } |
280 | if (NULL == (fpout = fopen (FIFO_FILE2, "w"))) | 281 | if (NULL == (fpout = fopen (FIFO_FILE2, "w"))) |
@@ -286,7 +287,7 @@ main (int argc, char *argv[]) | |||
286 | { | 287 | { |
287 | fprintf (stderr, | 288 | fprintf (stderr, |
288 | "fopen of write FIFO_FILE2 failed: %s\n", | 289 | "fopen of write FIFO_FILE2 failed: %s\n", |
289 | STRERROR (errno)); | 290 | strerror (errno)); |
290 | goto end; | 291 | goto end; |
291 | } | 292 | } |
292 | } | 293 | } |
@@ -295,14 +296,14 @@ main (int argc, char *argv[]) | |||
295 | first = 0; | 296 | first = 0; |
296 | if (NULL == (fpout = fopen (FIFO_FILE1, "w"))) | 297 | if (NULL == (fpout = fopen (FIFO_FILE1, "w"))) |
297 | { | 298 | { |
298 | GNUNET_break (0 == mkfifo (FIFO_FILE1, 0666)); | 299 | GNUNET_break (0 == mkfifo (FIFO_FILE1, 0666)); |
299 | fpout = fopen (FIFO_FILE1, "w"); | 300 | fpout = fopen (FIFO_FILE1, "w"); |
300 | } | 301 | } |
301 | if (NULL == fpout) | 302 | if (NULL == fpout) |
302 | { | 303 | { |
303 | fprintf (stderr, | 304 | fprintf (stderr, |
304 | "fopen of write FIFO_FILE1 failed: %s\n", | 305 | "fopen of write FIFO_FILE1 failed: %s\n", |
305 | STRERROR (errno)); | 306 | strerror (errno)); |
306 | goto end; | 307 | goto end; |
307 | } | 308 | } |
308 | fpin = fopen (FIFO_FILE2, "r"); | 309 | fpin = fopen (FIFO_FILE2, "r"); |
@@ -310,7 +311,7 @@ main (int argc, char *argv[]) | |||
310 | { | 311 | { |
311 | fprintf (stderr, | 312 | fprintf (stderr, |
312 | "fopen of read FIFO_FILE2 failed: %s\n", | 313 | "fopen of read FIFO_FILE2 failed: %s\n", |
313 | STRERROR (errno)); | 314 | strerror (errno)); |
314 | goto end; | 315 | goto end; |
315 | } | 316 | } |
316 | } | 317 | } |
@@ -395,21 +396,22 @@ main (int argc, char *argv[]) | |||
395 | continue; | 396 | continue; |
396 | if (0 > retval) | 397 | if (0 > retval) |
397 | { | 398 | { |
398 | fprintf (stderr, "select failed: %s\n", STRERROR (errno)); | 399 | fprintf (stderr, "select failed: %s\n", strerror (errno)); |
399 | closeprog = 1; | 400 | closeprog = 1; |
400 | break; | 401 | break; |
401 | } | 402 | } |
402 | 403 | ||
403 | if (FD_ISSET (STDOUT_FILENO, &wfds)) | 404 | if (FD_ISSET (STDOUT_FILENO, &wfds)) |
404 | { | 405 | { |
405 | ret = | 406 | ret = write (STDOUT_FILENO, |
406 | write (STDOUT_FILENO, write_std.buf + write_std.pos, | 407 | write_std.buf + write_std.pos, |
407 | write_std.size - write_std.pos); | 408 | write_std.size - write_std.pos); |
408 | if (0 > ret) | 409 | if (0 > ret) |
409 | { | 410 | { |
410 | closeprog = 1; | 411 | closeprog = 1; |
411 | fprintf (stderr, "Write ERROR to STDOUT_FILENO: %s\n", | 412 | fprintf (stderr, |
412 | STRERROR (errno)); | 413 | "Write ERROR to STDOUT_FILENO: %s\n", |
414 | strerror (errno)); | ||
413 | break; | 415 | break; |
414 | } | 416 | } |
415 | else | 417 | else |
@@ -426,14 +428,16 @@ main (int argc, char *argv[]) | |||
426 | 428 | ||
427 | if (FD_ISSET (fdpout, &wfds)) | 429 | if (FD_ISSET (fdpout, &wfds)) |
428 | { | 430 | { |
429 | ret = | 431 | ret = write (fdpout, |
430 | write (fdpout, write_pout.buf + write_pout.pos, | 432 | write_pout.buf + write_pout.pos, |
431 | write_pout.size - write_pout.pos); | 433 | write_pout.size - write_pout.pos); |
432 | 434 | ||
433 | if (0 > ret) | 435 | if (0 > ret) |
434 | { | 436 | { |
435 | closeprog = 1; | 437 | closeprog = 1; |
436 | fprintf (stderr, "Write ERROR to fdpout failed: %s\n", STRERROR (errno)); | 438 | fprintf (stderr, |
439 | "Write ERROR to fdpout failed: %s\n", | ||
440 | strerror (errno)); | ||
437 | } | 441 | } |
438 | else | 442 | else |
439 | { | 443 | { |
@@ -454,15 +458,17 @@ main (int argc, char *argv[]) | |||
454 | if (0 > readsize) | 458 | if (0 > readsize) |
455 | { | 459 | { |
456 | closeprog = 1; | 460 | closeprog = 1; |
457 | fprintf (stderr, "Error reading from STDIN_FILENO: %s\n", | 461 | fprintf (stderr, |
458 | STRERROR (errno)); | 462 | "Error reading from STDIN_FILENO: %s\n", |
463 | strerror (errno)); | ||
459 | } | 464 | } |
460 | else if (0 < readsize) | 465 | else if (0 < readsize) |
461 | { | 466 | { |
462 | GNUNET_MST_from_buffer (stdin_mst, | 467 | GNUNET_MST_from_buffer (stdin_mst, |
463 | readbuf, readsize, | 468 | readbuf, |
464 | GNUNET_NO, GNUNET_NO); | 469 | readsize, |
465 | 470 | GNUNET_NO, | |
471 | GNUNET_NO); | ||
466 | } | 472 | } |
467 | else | 473 | else |
468 | { | 474 | { |
@@ -477,14 +483,16 @@ main (int argc, char *argv[]) | |||
477 | if (0 > readsize) | 483 | if (0 > readsize) |
478 | { | 484 | { |
479 | closeprog = 1; | 485 | closeprog = 1; |
480 | fprintf (stderr, "Error reading from fdpin: %s\n", STRERROR (errno)); | 486 | fprintf (stderr, "Error reading from fdpin: %s\n", strerror (errno)); |
481 | break; | 487 | break; |
482 | } | 488 | } |
483 | else if (0 < readsize) | 489 | else if (0 < readsize) |
484 | { | 490 | { |
485 | GNUNET_MST_from_buffer (file_in_mst, | 491 | GNUNET_MST_from_buffer (file_in_mst, |
486 | readbuf, readsize, | 492 | readbuf, |
487 | GNUNET_NO, GNUNET_NO); | 493 | readsize, |
494 | GNUNET_NO, | ||
495 | GNUNET_NO); | ||
488 | } | 496 | } |
489 | else | 497 | else |
490 | { | 498 | { |
diff --git a/src/transport/gnunet-transport-wlan-receiver.c b/src/transport/gnunet-transport-wlan-receiver.c index 04f30a683..9b31377e7 100644 --- a/src/transport/gnunet-transport-wlan-receiver.c +++ b/src/transport/gnunet-transport-wlan-receiver.c | |||
@@ -37,7 +37,7 @@ main (int argc, char *argv[]) | |||
37 | time_t akt; | 37 | time_t akt; |
38 | ssize_t ret; | 38 | ssize_t ret; |
39 | pid_t pid; | 39 | pid_t pid; |
40 | int commpipe[2]; /* This holds the fd for the input & output of the pipe */ | 40 | int commpipe[2]; /* This holds the fd for the input & output of the pipe */ |
41 | 41 | ||
42 | if (2 != argc) | 42 | if (2 != argc) |
43 | { | 43 | { |
@@ -46,34 +46,30 @@ main (int argc, char *argv[]) | |||
46 | fprintf (stderr, | 46 | fprintf (stderr, |
47 | "Usage: %s interface-name\n" | 47 | "Usage: %s interface-name\n" |
48 | "e.g. %s mon0\n", | 48 | "e.g. %s mon0\n", |
49 | argv[0], argv[0]); | 49 | argv[0], |
50 | argv[0]); | ||
50 | return 1; | 51 | return 1; |
51 | } | 52 | } |
52 | 53 | ||
53 | /* Setup communication pipeline first */ | 54 | /* Setup communication pipeline first */ |
54 | if (pipe (commpipe)) | 55 | if (pipe (commpipe)) |
55 | { | 56 | { |
56 | fprintf (stderr, | 57 | fprintf (stderr, "Failed to create pipe: %s\n", strerror (errno)); |
57 | "Failed to create pipe: %s\n", | ||
58 | STRERROR (errno)); | ||
59 | exit (1); | 58 | exit (1); |
60 | } | 59 | } |
61 | 60 | ||
62 | /* Attempt to fork and check for errors */ | 61 | /* Attempt to fork and check for errors */ |
63 | if ((pid = fork ()) == -1) | 62 | if ((pid = fork ()) == -1) |
64 | { | 63 | { |
65 | fprintf (stderr, "Failed to fork: %s\n", | 64 | fprintf (stderr, "Failed to fork: %s\n", strerror (errno)); |
66 | STRERROR (errno)); | ||
67 | exit (1); | 65 | exit (1); |
68 | } | 66 | } |
69 | 67 | ||
70 | if (pid) | 68 | if (pid) |
71 | { | 69 | { |
72 | /* A positive (non-negative) PID indicates the parent process */ | 70 | /* A positive (non-negative) PID indicates the parent process */ |
73 | if (0 != close (commpipe[1])) /* Close unused side of pipe (in side) */ | 71 | if (0 != close (commpipe[1])) /* Close unused side of pipe (in side) */ |
74 | fprintf (stderr, | 72 | fprintf (stderr, "Failed to close fd: %s\n", strerror (errno)); |
75 | "Failed to close fd: %s\n", | ||
76 | strerror (errno)); | ||
77 | start = time (NULL); | 73 | start = time (NULL); |
78 | count = 0; | 74 | count = 0; |
79 | while (1) | 75 | while (1) |
@@ -81,18 +77,18 @@ main (int argc, char *argv[]) | |||
81 | ret = read (commpipe[0], msg_buf, sizeof (msg_buf)); | 77 | ret = read (commpipe[0], msg_buf, sizeof (msg_buf)); |
82 | if (0 > ret) | 78 | if (0 > ret) |
83 | { | 79 | { |
84 | fprintf (stderr, "read failed: %s\n", strerror (errno)); | 80 | fprintf (stderr, "read failed: %s\n", strerror (errno)); |
85 | break; | 81 | break; |
86 | } | 82 | } |
87 | count += ret; | 83 | count += ret; |
88 | akt = time (NULL); | 84 | akt = time (NULL); |
89 | if (akt - start > 30) | 85 | if (akt - start > 30) |
90 | { | 86 | { |
91 | bytes_per_s = count / (akt - start); | 87 | bytes_per_s = count / (akt - start); |
92 | bytes_per_s /= 1024; | 88 | bytes_per_s /= 1024; |
93 | printf ("recv %f kb/s\n", bytes_per_s); | 89 | printf ("recv %f kb/s\n", bytes_per_s); |
94 | start = akt; | 90 | start = akt; |
95 | count = 0; | 91 | count = 0; |
96 | } | 92 | } |
97 | } | 93 | } |
98 | } | 94 | } |
@@ -100,13 +96,15 @@ main (int argc, char *argv[]) | |||
100 | { | 96 | { |
101 | /* A zero PID indicates that this is the child process */ | 97 | /* A zero PID indicates that this is the child process */ |
102 | (void) close (1); | 98 | (void) close (1); |
103 | if (-1 == dup2 (commpipe[1], 1)) /* Replace stdin with the in side of the pipe */ | 99 | if (-1 == |
100 | dup2 (commpipe[1], 1)) /* Replace stdin with the in side of the pipe */ | ||
104 | fprintf (stderr, "dup2 failed: %s\n", strerror (errno)); | 101 | fprintf (stderr, "dup2 failed: %s\n", strerror (errno)); |
105 | (void) close (commpipe[0]); /* Close unused side of pipe (in side) */ | 102 | (void) close (commpipe[0]); /* Close unused side of pipe (in side) */ |
106 | /* Replace the child fork with a new process */ | 103 | /* Replace the child fork with a new process */ |
107 | if (execlp | 104 | if (execlp ("gnunet-helper-transport-wlan", |
108 | ("gnunet-helper-transport-wlan", "gnunet-helper-transport-wlan", | 105 | "gnunet-helper-transport-wlan", |
109 | argv[1], NULL) == -1) | 106 | argv[1], |
107 | NULL) == -1) | ||
110 | { | 108 | { |
111 | fprintf (stderr, "Could not start gnunet-helper-transport-wlan!"); | 109 | fprintf (stderr, "Could not start gnunet-helper-transport-wlan!"); |
112 | _exit (1); | 110 | _exit (1); |
diff --git a/src/transport/gnunet-transport-wlan-sender.c b/src/transport/gnunet-transport-wlan-sender.c index 36d26f8dc..36273f765 100644 --- a/src/transport/gnunet-transport-wlan-sender.c +++ b/src/transport/gnunet-transport-wlan-sender.c | |||
@@ -35,16 +35,16 @@ | |||
35 | #define WLAN_LLC_DSAP_FIELD 0x1f | 35 | #define WLAN_LLC_DSAP_FIELD 0x1f |
36 | #define WLAN_LLC_SSAP_FIELD 0x1f | 36 | #define WLAN_LLC_SSAP_FIELD 0x1f |
37 | 37 | ||
38 | #define IEEE80211_ADDR_LEN 6 /* size of 802.11 address */ | 38 | #define IEEE80211_ADDR_LEN 6 /* size of 802.11 address */ |
39 | 39 | ||
40 | #define IEEE80211_FC0_VERSION_MASK 0x03 | 40 | #define IEEE80211_FC0_VERSION_MASK 0x03 |
41 | #define IEEE80211_FC0_VERSION_SHIFT 0 | 41 | #define IEEE80211_FC0_VERSION_SHIFT 0 |
42 | #define IEEE80211_FC0_VERSION_0 0x00 | 42 | #define IEEE80211_FC0_VERSION_0 0x00 |
43 | #define IEEE80211_FC0_TYPE_MASK 0x0c | 43 | #define IEEE80211_FC0_TYPE_MASK 0x0c |
44 | #define IEEE80211_FC0_TYPE_SHIFT 2 | 44 | #define IEEE80211_FC0_TYPE_SHIFT 2 |
45 | #define IEEE80211_FC0_TYPE_MGT 0x00 | 45 | #define IEEE80211_FC0_TYPE_MGT 0x00 |
46 | #define IEEE80211_FC0_TYPE_CTL 0x04 | 46 | #define IEEE80211_FC0_TYPE_CTL 0x04 |
47 | #define IEEE80211_FC0_TYPE_DATA 0x08 | 47 | #define IEEE80211_FC0_TYPE_DATA 0x08 |
48 | 48 | ||
49 | 49 | ||
50 | /** | 50 | /** |
@@ -55,7 +55,7 @@ | |||
55 | */ | 55 | */ |
56 | static int | 56 | static int |
57 | getRadiotapHeader (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header, | 57 | getRadiotapHeader (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header, |
58 | uint16_t size) | 58 | uint16_t size) |
59 | { | 59 | { |
60 | header->header.size = htons (size); | 60 | header->header.size = htons (size); |
61 | header->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER); | 61 | header->header.type = htons (GNUNET_MESSAGE_TYPE_WLAN_DATA_TO_HELPER); |
@@ -75,8 +75,9 @@ getRadiotapHeader (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *header, | |||
75 | */ | 75 | */ |
76 | static int | 76 | static int |
77 | getWlanHeader (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *Header, | 77 | getWlanHeader (struct GNUNET_TRANSPORT_WLAN_Ieee80211Frame *Header, |
78 | const struct GNUNET_TRANSPORT_WLAN_MacAddress *to_mac_addr, | 78 | const struct GNUNET_TRANSPORT_WLAN_MacAddress *to_mac_addr, |
79 | const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac, unsigned int size) | 79 | const struct GNUNET_TRANSPORT_WLAN_MacAddress *mac, |
80 | unsigned int size) | ||
80 | { | 81 | { |
81 | const int rate = 11000000; | 82 | const int rate = 11000000; |
82 | 83 | ||
@@ -109,21 +110,27 @@ main (int argc, char *argv[]) | |||
109 | int i; | 110 | int i; |
110 | ssize_t ret; | 111 | ssize_t ret; |
111 | pid_t pid; | 112 | pid_t pid; |
112 | int commpipe[2]; /* This holds the fd for the input & output of the pipe */ | 113 | int commpipe[2]; /* This holds the fd for the input & output of the pipe */ |
113 | int macpipe[2]; /* This holds the fd for the input & output of the pipe */ | 114 | int macpipe[2]; /* This holds the fd for the input & output of the pipe */ |
114 | 115 | ||
115 | if (4 != argc) | 116 | if (4 != argc) |
116 | { | 117 | { |
117 | fprintf (stderr, | 118 | fprintf ( |
118 | "This program must be started with the interface and the targets and source mac as argument.\n"); | 119 | stderr, |
120 | "This program must be started with the interface and the targets and source mac as argument.\n"); | ||
119 | fprintf (stderr, | 121 | fprintf (stderr, |
120 | "Usage: interface-name mac-DST mac-SRC\n" | 122 | "Usage: interface-name mac-DST mac-SRC\n" |
121 | "e.g. mon0 11-22-33-44-55-66 12-34-56-78-90-ab\n"); | 123 | "e.g. mon0 11-22-33-44-55-66 12-34-56-78-90-ab\n"); |
122 | return 1; | 124 | return 1; |
123 | } | 125 | } |
124 | if (6 != | 126 | if (6 != SSCANF (argv[2], |
125 | SSCANF (argv[2], "%x-%x-%x-%x-%x-%x", &temp[0], &temp[1], &temp[2], | 127 | "%x-%x-%x-%x-%x-%x", |
126 | &temp[3], &temp[4], &temp[5])) | 128 | &temp[0], |
129 | &temp[1], | ||
130 | &temp[2], | ||
131 | &temp[3], | ||
132 | &temp[4], | ||
133 | &temp[5])) | ||
127 | { | 134 | { |
128 | fprintf (stderr, | 135 | fprintf (stderr, |
129 | "Usage: interface-name mac-DST mac-SRC\n" | 136 | "Usage: interface-name mac-DST mac-SRC\n" |
@@ -132,9 +139,14 @@ main (int argc, char *argv[]) | |||
132 | } | 139 | } |
133 | for (i = 0; i < 6; i++) | 140 | for (i = 0; i < 6; i++) |
134 | outmac.mac[i] = temp[i]; | 141 | outmac.mac[i] = temp[i]; |
135 | if (6 != | 142 | if (6 != SSCANF (argv[3], |
136 | SSCANF (argv[3], "%x-%x-%x-%x-%x-%x", &temp[0], &temp[1], &temp[2], | 143 | "%x-%x-%x-%x-%x-%x", |
137 | &temp[3], &temp[4], &temp[5])) | 144 | &temp[0], |
145 | &temp[1], | ||
146 | &temp[2], | ||
147 | &temp[3], | ||
148 | &temp[4], | ||
149 | &temp[5])) | ||
138 | { | 150 | { |
139 | fprintf (stderr, | 151 | fprintf (stderr, |
140 | "Usage: interface-name mac-DST mac-SRC\n" | 152 | "Usage: interface-name mac-DST mac-SRC\n" |
@@ -148,51 +160,47 @@ main (int argc, char *argv[]) | |||
148 | /* Setup communication pipeline first */ | 160 | /* Setup communication pipeline first */ |
149 | if (pipe (commpipe)) | 161 | if (pipe (commpipe)) |
150 | { | 162 | { |
151 | fprintf (stderr, | 163 | fprintf (stderr, "Failed to create pipe: %s\n", strerror (errno)); |
152 | "Failed to create pipe: %s\n", | ||
153 | STRERROR (errno)); | ||
154 | exit (1); | 164 | exit (1); |
155 | } | 165 | } |
156 | if (pipe (macpipe)) | 166 | if (pipe (macpipe)) |
157 | { | 167 | { |
158 | fprintf (stderr, | 168 | fprintf (stderr, "Failed to create pipe: %s\n", strerror (errno)); |
159 | "Failed to create pipe: %s\n", | ||
160 | STRERROR (errno)); | ||
161 | exit (1); | 169 | exit (1); |
162 | } | 170 | } |
163 | 171 | ||
164 | /* Attempt to fork and check for errors */ | 172 | /* Attempt to fork and check for errors */ |
165 | if ((pid = fork ()) == -1) | 173 | if ((pid = fork ()) == -1) |
166 | { | 174 | { |
167 | fprintf (stderr, "Failed to fork: %s\n", | 175 | fprintf (stderr, "Failed to fork: %s\n", strerror (errno)); |
168 | STRERROR (errno)); | ||
169 | exit (1); | 176 | exit (1); |
170 | } | 177 | } |
171 | memset (msg_buf, 0x42, sizeof (msg_buf)); | 178 | memset (msg_buf, 0x42, sizeof (msg_buf)); |
172 | if (pid) | 179 | if (pid) |
173 | { | 180 | { |
174 | /* A positive (non-negative) PID indicates the parent process */ | 181 | /* A positive (non-negative) PID indicates the parent process */ |
175 | if (0 != close (commpipe[0])) /* Close unused side of pipe (in side) */ | 182 | if (0 != close (commpipe[0])) /* Close unused side of pipe (in side) */ |
176 | fprintf (stderr, | 183 | fprintf (stderr, "Failed to close fd: %s\n", strerror (errno)); |
177 | "Failed to close fd: %s\n", | 184 | setvbuf (stdout, |
178 | strerror (errno)); | 185 | (char *) NULL, |
179 | setvbuf (stdout, (char *) NULL, _IONBF, 0); /* Set non-buffered output on stdout */ | 186 | _IONBF, |
187 | 0); /* Set non-buffered output on stdout */ | ||
180 | 188 | ||
181 | if (0 != close (macpipe[1])) | 189 | if (0 != close (macpipe[1])) |
182 | fprintf (stderr, | 190 | fprintf (stderr, "Failed to close fd: %s\n", strerror (errno)); |
183 | "Failed to close fd: %s\n", | ||
184 | strerror (errno)); | ||
185 | if (sizeof (hcm) != read (macpipe[0], &hcm, sizeof (hcm))) | 191 | if (sizeof (hcm) != read (macpipe[0], &hcm, sizeof (hcm))) |
186 | fprintf (stderr, | 192 | fprintf (stderr, "Failed to read hcm...\n"); |
187 | "Failed to read hcm...\n"); | ||
188 | fprintf (stderr, | 193 | fprintf (stderr, |
189 | "Got MAC %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n", | 194 | "Got MAC %.2X:%.2X:%.2X:%.2X:%.2X:%.2X\n", |
190 | hcm.mac.mac[0], hcm.mac.mac[1], | 195 | hcm.mac.mac[0], |
191 | hcm.mac.mac[2], hcm.mac.mac[3], hcm.mac.mac[4], hcm.mac.mac[5]); | 196 | hcm.mac.mac[1], |
197 | hcm.mac.mac[2], | ||
198 | hcm.mac.mac[3], | ||
199 | hcm.mac.mac[4], | ||
200 | hcm.mac.mac[5]); | ||
192 | radiotap = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) msg_buf; | 201 | radiotap = (struct GNUNET_TRANSPORT_WLAN_RadiotapSendMessage *) msg_buf; |
193 | getRadiotapHeader (radiotap, WLAN_MTU); | 202 | getRadiotapHeader (radiotap, WLAN_MTU); |
194 | getWlanHeader (&radiotap->frame, &outmac, &inmac, | 203 | getWlanHeader (&radiotap->frame, &outmac, &inmac, WLAN_MTU); |
195 | WLAN_MTU); | ||
196 | start = time (NULL); | 204 | start = time (NULL); |
197 | count = 0; | 205 | count = 0; |
198 | while (1) | 206 | while (1) |
@@ -200,18 +208,18 @@ main (int argc, char *argv[]) | |||
200 | ret = write (commpipe[1], msg_buf, WLAN_MTU); | 208 | ret = write (commpipe[1], msg_buf, WLAN_MTU); |
201 | if (0 > ret) | 209 | if (0 > ret) |
202 | { | 210 | { |
203 | fprintf (stderr, "write failed: %s\n", strerror (errno)); | 211 | fprintf (stderr, "write failed: %s\n", strerror (errno)); |
204 | break; | 212 | break; |
205 | } | 213 | } |
206 | count += ret; | 214 | count += ret; |
207 | akt = time (NULL); | 215 | akt = time (NULL); |
208 | if (akt - start > 30) | 216 | if (akt - start > 30) |
209 | { | 217 | { |
210 | bytes_per_s = count / (akt - start); | 218 | bytes_per_s = count / (akt - start); |
211 | bytes_per_s /= 1024; | 219 | bytes_per_s /= 1024; |
212 | printf ("send %f kbytes/s\n", bytes_per_s); | 220 | printf ("send %f kbytes/s\n", bytes_per_s); |
213 | start = akt; | 221 | start = akt; |
214 | count = 0; | 222 | count = 0; |
215 | } | 223 | } |
216 | } | 224 | } |
217 | } | 225 | } |
@@ -220,16 +228,19 @@ main (int argc, char *argv[]) | |||
220 | /* A zero PID indicates that this is the child process */ | 228 | /* A zero PID indicates that this is the child process */ |
221 | (void) close (0); | 229 | (void) close (0); |
222 | (void) close (1); | 230 | (void) close (1); |
223 | if (-1 == dup2 (commpipe[0], 0)) /* Replace stdin with the in side of the pipe */ | 231 | if (-1 == |
232 | dup2 (commpipe[0], 0)) /* Replace stdin with the in side of the pipe */ | ||
224 | fprintf (stderr, "dup2 failed: %s\n", strerror (errno)); | 233 | fprintf (stderr, "dup2 failed: %s\n", strerror (errno)); |
225 | if (-1 == dup2 (macpipe[1], 1)) /* Replace stdout with the out side of the pipe */ | 234 | if (-1 == |
235 | dup2 (macpipe[1], 1)) /* Replace stdout with the out side of the pipe */ | ||
226 | fprintf (stderr, "dup2 failed: %s\n", strerror (errno)); | 236 | fprintf (stderr, "dup2 failed: %s\n", strerror (errno)); |
227 | (void) close (commpipe[1]); /* Close unused side of pipe (out side) */ | 237 | (void) close (commpipe[1]); /* Close unused side of pipe (out side) */ |
228 | (void) close (macpipe[0]); /* Close unused side of pipe (in side) */ | 238 | (void) close (macpipe[0]); /* Close unused side of pipe (in side) */ |
229 | /* Replace the child fork with a new process */ | 239 | /* Replace the child fork with a new process */ |
230 | if (execlp | 240 | if (execlp ("gnunet-helper-transport-wlan", |
231 | ("gnunet-helper-transport-wlan", "gnunet-helper-transport-wlan", | 241 | "gnunet-helper-transport-wlan", |
232 | argv[1], NULL) == -1) | 242 | argv[1], |
243 | NULL) == -1) | ||
233 | { | 244 | { |
234 | fprintf (stderr, "Could not start gnunet-helper-transport-wlan!"); | 245 | fprintf (stderr, "Could not start gnunet-helper-transport-wlan!"); |
235 | _exit (1); | 246 | _exit (1); |