diff options
author | Nathan S. Evans <evans@in.tum.de> | 2011-02-25 13:42:53 +0000 |
---|---|---|
committer | Nathan S. Evans <evans@in.tum.de> | 2011-02-25 13:42:53 +0000 |
commit | da83c63750a50d4cc94f76a4f7e11f49a3d4748b (patch) | |
tree | 16c85798af1b38b385898dc0be9da3d37dfe177b /src/dht | |
parent | 5232542d7ed273d800445ac8ebf7774c28513865 (diff) | |
download | gnunet-da83c63750a50d4cc94f76a4f7e11f49a3d4748b.tar.gz gnunet-da83c63750a50d4cc94f76a4f7e11f49a3d4748b.zip |
gauger api changes (:
Diffstat (limited to 'src/dht')
-rw-r--r-- | src/dht/gnunet-dht-driver.c | 2490 |
1 files changed, 1480 insertions, 1010 deletions
diff --git a/src/dht/gnunet-dht-driver.c b/src/dht/gnunet-dht-driver.c index 636f02dcb..a2dc68001 100644 --- a/src/dht/gnunet-dht-driver.c +++ b/src/dht/gnunet-dht-driver.c | |||
@@ -1,22 +1,22 @@ | |||
1 | /* | 1 | /* |
2 | This file is part of GNUnet. | 2 | This file is part of GNUnet. |
3 | (C) 2009 Christian Grothoff (and other contributing authors) | 3 | (C) 2009 Christian Grothoff (and other contributing authors) |
4 | 4 | ||
5 | GNUnet is free software; you can redistribute it and/or modify | 5 | GNUnet is free software; you can redistribute it and/or modify |
6 | it under the terms of the GNU General Public License as published | 6 | it under the terms of the GNU General Public License as published |
7 | by the Free Software Foundation; either version 3, or (at your | 7 | by the Free Software Foundation; either version 3, or (at your |
8 | option) any later version. | 8 | option) any later version. |
9 | 9 | ||
10 | GNUnet is distributed in the hope that it will be useful, but | 10 | GNUnet is distributed in the hope that it will be useful, but |
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | General Public License for more details. | 13 | General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU General Public License | 15 | You should have received a copy of the GNU General Public License |
16 | along with GNUnet; see the file COPYING. If not, write to the | 16 | along with GNUnet; see the file COPYING. If not, write to the |
17 | Free Software Foundation, Inc., 59 Temple Place - Suite 330, | 17 | Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
18 | Boston, MA 02111-1307, USA. | 18 | Boston, MA 02111-1307, USA. |
19 | */ | 19 | */ |
20 | /** | 20 | /** |
21 | * @file dht/gnunet-dht-driver.c | 21 | * @file dht/gnunet-dht-driver.c |
22 | * @brief Driver for setting up a group of gnunet peers and | 22 | * @brief Driver for setting up a group of gnunet peers and |
@@ -273,7 +273,6 @@ struct TopologyIteratorContext | |||
273 | struct GNUNET_TIME_Relative timeout; | 273 | struct GNUNET_TIME_Relative timeout; |
274 | }; | 274 | }; |
275 | 275 | ||
276 | |||
277 | struct PeerCount | 276 | struct PeerCount |
278 | { | 277 | { |
279 | /** Node in the heap */ | 278 | /** Node in the heap */ |
@@ -367,8 +366,6 @@ enum DHT_ROUND_TYPES | |||
367 | DHT_ROUND_CHURN | 366 | DHT_ROUND_CHURN |
368 | }; | 367 | }; |
369 | 368 | ||
370 | |||
371 | |||
372 | /* Globals */ | 369 | /* Globals */ |
373 | 370 | ||
374 | /** | 371 | /** |
@@ -501,6 +498,12 @@ static unsigned long long malicious_putters; | |||
501 | static unsigned long long round_delay; | 498 | static unsigned long long round_delay; |
502 | 499 | ||
503 | /** | 500 | /** |
501 | * The identifier for this trial (if we have one) | ||
502 | * for external data collection. | ||
503 | */ | ||
504 | static unsigned long long trial_to_run; | ||
505 | |||
506 | /** | ||
504 | * How many malicious droppers to seed in the network. | 507 | * How many malicious droppers to seed in the network. |
505 | */ | 508 | */ |
506 | static unsigned long long malicious_droppers; | 509 | static unsigned long long malicious_droppers; |
@@ -645,7 +648,6 @@ static unsigned long long peers_left; | |||
645 | */ | 648 | */ |
646 | static struct GNUNET_TESTING_PeerGroup *pg; | 649 | static struct GNUNET_TESTING_PeerGroup *pg; |
647 | 650 | ||
648 | |||
649 | /** | 651 | /** |
650 | * Global config handle. | 652 | * Global config handle. |
651 | */ | 653 | */ |
@@ -710,7 +712,13 @@ static unsigned long long outstanding_malicious; | |||
710 | /** | 712 | /** |
711 | * How many set malicious peers are done? | 713 | * How many set malicious peers are done? |
712 | */ | 714 | */ |
713 | static unsigned long long malicious_completed; | 715 | static unsigned int malicious_completed; |
716 | |||
717 | /** | ||
718 | * For gauger logging, what specific identifier (svn revision) | ||
719 | * should be used? | ||
720 | */ | ||
721 | static unsigned long long revision; | ||
714 | 722 | ||
715 | /** | 723 | /** |
716 | * Global used to count how many connections we have currently | 724 | * Global used to count how many connections we have currently |
@@ -749,11 +757,14 @@ static char *blacklist_transports; | |||
749 | 757 | ||
750 | static enum GNUNET_TESTING_Topology topology; | 758 | static enum GNUNET_TESTING_Topology topology; |
751 | 759 | ||
752 | static enum GNUNET_TESTING_Topology blacklist_topology = GNUNET_TESTING_TOPOLOGY_NONE; /* Don't do any blacklisting */ | 760 | static enum GNUNET_TESTING_Topology blacklist_topology = |
761 | GNUNET_TESTING_TOPOLOGY_NONE; /* Don't do any blacklisting */ | ||
753 | 762 | ||
754 | static enum GNUNET_TESTING_Topology connect_topology = GNUNET_TESTING_TOPOLOGY_NONE; /* NONE actually means connect all allowed peers */ | 763 | static enum GNUNET_TESTING_Topology connect_topology = |
764 | GNUNET_TESTING_TOPOLOGY_NONE; /* NONE actually means connect all allowed peers */ | ||
755 | 765 | ||
756 | static enum GNUNET_TESTING_TopologyOption connect_topology_option = GNUNET_TESTING_TOPOLOGY_OPTION_ALL; | 766 | static enum GNUNET_TESTING_TopologyOption connect_topology_option = |
767 | GNUNET_TESTING_TOPOLOGY_OPTION_ALL; | ||
757 | 768 | ||
758 | static double connect_topology_option_modifier = 0.0; | 769 | static double connect_topology_option_modifier = 0.0; |
759 | 770 | ||
@@ -816,17 +827,18 @@ update_meter(struct ProgressMeter *meter) | |||
816 | { | 827 | { |
817 | if (meter->completed == 0) | 828 | if (meter->completed == 0) |
818 | { | 829 | { |
819 | fprintf(stdout, "%sProgress: [0%%", meter->startup_string); | 830 | fprintf (stdout, "%sProgress: [0%%", meter->startup_string); |
820 | } | 831 | } |
821 | else | 832 | else |
822 | fprintf(stdout, "%d%%", (int)(((float)meter->completed / meter->total) * 100)); | 833 | fprintf (stdout, "%d%%", (int) (((float) meter->completed |
834 | / meter->total) * 100)); | ||
823 | } | 835 | } |
824 | else if (meter->completed % meter->dotnum == 0) | 836 | else if (meter->completed % meter->dotnum == 0) |
825 | fprintf(stdout, "."); | 837 | fprintf (stdout, "."); |
826 | 838 | ||
827 | if (meter->completed + 1 == meter->total) | 839 | if (meter->completed + 1 == meter->total) |
828 | fprintf(stdout, "%d%%]\n", 100); | 840 | fprintf (stdout, "%d%%]\n", 100); |
829 | fflush(stdout); | 841 | fflush (stdout); |
830 | } | 842 | } |
831 | meter->completed++; | 843 | meter->completed++; |
832 | 844 | ||
@@ -868,9 +880,8 @@ free_meter(struct ProgressMeter *meter) | |||
868 | /** | 880 | /** |
869 | * Check whether peers successfully shut down. | 881 | * Check whether peers successfully shut down. |
870 | */ | 882 | */ |
871 | static void | 883 | static void |
872 | shutdown_callback (void *cls, | 884 | shutdown_callback(void *cls, const char *emsg) |
873 | const char *emsg) | ||
874 | { | 885 | { |
875 | if (emsg != NULL) | 886 | if (emsg != NULL) |
876 | { | 887 | { |
@@ -883,14 +894,19 @@ shutdown_callback (void *cls, | |||
883 | * Task to release DHT handles for PUT | 894 | * Task to release DHT handles for PUT |
884 | */ | 895 | */ |
885 | static void | 896 | static void |
886 | put_disconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 897 | put_disconnect_task(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
887 | { | 898 | { |
888 | struct TestPutContext *test_put = cls; | 899 | struct TestPutContext *test_put = cls; |
889 | test_put->disconnect_task = GNUNET_SCHEDULER_NO_TASK; | 900 | test_put->disconnect_task = GNUNET_SCHEDULER_NO_TASK; |
890 | GNUNET_DHT_disconnect(test_put->dht_handle); | 901 | GNUNET_DHT_disconnect (test_put->dht_handle); |
891 | test_put->dht_handle = NULL; | 902 | test_put->dht_handle = NULL; |
892 | if (replicate_same == GNUNET_NO) | 903 | if (replicate_same == GNUNET_NO) |
893 | test_put->daemon = GNUNET_TESTING_daemon_get(pg, GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers)); | 904 | test_put->daemon |
905 | = GNUNET_TESTING_daemon_get ( | ||
906 | pg, | ||
907 | GNUNET_CRYPTO_random_u32 ( | ||
908 | GNUNET_CRYPTO_QUALITY_WEAK, | ||
909 | num_peers)); | ||
894 | } | 910 | } |
895 | 911 | ||
896 | /** | 912 | /** |
@@ -898,30 +914,33 @@ put_disconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
898 | * testcase. | 914 | * testcase. |
899 | */ | 915 | */ |
900 | static void | 916 | static void |
901 | finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 917 | finish_testing(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
902 | { | 918 | { |
903 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Ending test normally!\n", (char *)cls); | 919 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Ending test normally!\n", |
920 | (char *) cls); | ||
904 | GNUNET_assert (pg != NULL); | 921 | GNUNET_assert (pg != NULL); |
905 | struct TestPutContext *test_put = all_puts; | 922 | struct TestPutContext *test_put = all_puts; |
906 | struct TestGetContext *test_get = all_gets; | 923 | struct TestGetContext *test_get = all_gets; |
924 | char *temp_get_string; | ||
925 | char *revision_str; | ||
907 | 926 | ||
908 | while (test_put != NULL) | 927 | while (test_put != NULL) |
909 | { | 928 | { |
910 | if (test_put->disconnect_task != GNUNET_SCHEDULER_NO_TASK) | 929 | if (test_put->disconnect_task != GNUNET_SCHEDULER_NO_TASK) |
911 | GNUNET_SCHEDULER_cancel(test_put->disconnect_task); | 930 | GNUNET_SCHEDULER_cancel (test_put->disconnect_task); |
912 | if (test_put->dht_handle != NULL) | 931 | if (test_put->dht_handle != NULL) |
913 | GNUNET_DHT_disconnect(test_put->dht_handle); | 932 | GNUNET_DHT_disconnect (test_put->dht_handle); |
914 | test_put = test_put->next; | 933 | test_put = test_put->next; |
915 | } | 934 | } |
916 | 935 | ||
917 | while (test_get != NULL) | 936 | while (test_get != NULL) |
918 | { | 937 | { |
919 | if (test_get->disconnect_task != GNUNET_SCHEDULER_NO_TASK) | 938 | if (test_get->disconnect_task != GNUNET_SCHEDULER_NO_TASK) |
920 | GNUNET_SCHEDULER_cancel(test_get->disconnect_task); | 939 | GNUNET_SCHEDULER_cancel (test_get->disconnect_task); |
921 | if (test_get->get_handle != NULL) | 940 | if (test_get->get_handle != NULL) |
922 | GNUNET_DHT_get_stop(test_get->get_handle); | 941 | GNUNET_DHT_get_stop (test_get->get_handle); |
923 | if (test_get->dht_handle != NULL) | 942 | if (test_get->dht_handle != NULL) |
924 | GNUNET_DHT_disconnect(test_get->dht_handle); | 943 | GNUNET_DHT_disconnect (test_get->dht_handle); |
925 | test_get = test_get->next; | 944 | test_get = test_get->next; |
926 | } | 945 | } |
927 | 946 | ||
@@ -929,22 +948,33 @@ finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
929 | 948 | ||
930 | if (dhtlog_handle != NULL) | 949 | if (dhtlog_handle != NULL) |
931 | { | 950 | { |
932 | fprintf(stderr, "Update trial endtime\n"); | 951 | fprintf (stderr, "Update trial endtime\n"); |
933 | dhtlog_handle->update_trial (gets_completed); | 952 | dhtlog_handle->update_trial (cumulative_successful_gets); |
934 | GNUNET_DHTLOG_disconnect(dhtlog_handle); | 953 | GNUNET_DHTLOG_disconnect (dhtlog_handle); |
935 | dhtlog_handle = NULL; | 954 | dhtlog_handle = NULL; |
936 | } | 955 | } |
937 | 956 | ||
938 | if (hostkey_meter != NULL) | 957 | if (hostkey_meter != NULL) |
939 | free_meter(hostkey_meter); | 958 | free_meter (hostkey_meter); |
940 | if (peer_start_meter != NULL) | 959 | if (peer_start_meter != NULL) |
941 | free_meter(peer_start_meter); | 960 | free_meter (peer_start_meter); |
942 | if (peer_connect_meter != NULL) | 961 | if (peer_connect_meter != NULL) |
943 | free_meter(peer_connect_meter); | 962 | free_meter (peer_connect_meter); |
944 | if (put_meter != NULL) | 963 | if (put_meter != NULL) |
945 | free_meter(put_meter); | 964 | free_meter (put_meter); |
946 | if (get_meter != NULL) | 965 | if (get_meter != NULL) |
947 | free_meter(get_meter); | 966 | free_meter (get_meter); |
967 | |||
968 | GNUNET_asprintf (&temp_get_string, | ||
969 | "DHT Successful GETs (trial %d)", trial_to_run); | ||
970 | GNUNET_asprintf (&revision_str, "%llu", revision); | ||
971 | GAUGER_ID("DHT_TESTING", temp_get_string, cumulative_successful_gets / (double)cumulative_num_gets, "percent successful", revision_str); | ||
972 | fprintf ( | ||
973 | stderr, | ||
974 | "Finished trial, had %llu successful gets out of %llu total, %.2f percent succeeded\n", | ||
975 | cumulative_successful_gets, cumulative_num_gets, | ||
976 | cumulative_successful_gets / (double) cumulative_num_gets); | ||
977 | GNUNET_free(temp_get_string); | ||
948 | 978 | ||
949 | ok = 0; | 979 | ok = 0; |
950 | } | 980 | } |
@@ -952,33 +982,39 @@ finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
952 | /** | 982 | /** |
953 | * Callback for iterating over all the peer connections of a peer group. | 983 | * Callback for iterating over all the peer connections of a peer group. |
954 | */ | 984 | */ |
955 | static void | 985 | static void |
956 | log_topology_cb (void *cls, | 986 | log_topology_cb(void *cls, const struct GNUNET_PeerIdentity *first, |
957 | const struct GNUNET_PeerIdentity *first, | 987 | const struct GNUNET_PeerIdentity *second, const char *emsg) |
958 | const struct GNUNET_PeerIdentity *second, | ||
959 | const char *emsg) | ||
960 | { | 988 | { |
961 | struct TopologyIteratorContext *topo_ctx = cls; | 989 | struct TopologyIteratorContext *topo_ctx = cls; |
962 | if ((first != NULL) && (second != NULL)) | 990 | if ((first != NULL) && (second != NULL)) |
963 | { | 991 | { |
964 | if ((topo_ctx->peers_seen != NULL) && (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(topo_ctx->peers_seen, &first->hashPubKey))) | 992 | if ((topo_ctx->peers_seen != NULL) && (GNUNET_NO |
993 | == GNUNET_CONTAINER_multihashmap_contains (topo_ctx->peers_seen, | ||
994 | &first->hashPubKey))) | ||
965 | { | 995 | { |
966 | GNUNET_CONTAINER_multihashmap_put(topo_ctx->peers_seen, &first->hashPubKey, NULL, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); | 996 | GNUNET_CONTAINER_multihashmap_put (topo_ctx->peers_seen, |
997 | &first->hashPubKey, NULL, | ||
998 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); | ||
967 | topo_ctx->total_peers++; | 999 | topo_ctx->total_peers++; |
968 | } | 1000 | } |
969 | topo_ctx->total_connections++; | 1001 | topo_ctx->total_connections++; |
970 | if ((GNUNET_NO == dhtlog_minimal) && (dhtlog_handle != NULL)) | 1002 | if ((GNUNET_NO == dhtlog_minimal) && (dhtlog_handle != NULL)) |
971 | dhtlog_handle->insert_extended_topology(first, second); | 1003 | dhtlog_handle->insert_extended_topology (first, second); |
972 | } | 1004 | } |
973 | else | 1005 | else |
974 | { | 1006 | { |
975 | GNUNET_assert(dhtlog_handle != NULL); | 1007 | GNUNET_assert(dhtlog_handle != NULL); |
976 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Topology iteration (%u/%u) finished (%u connections, %u peers)\n", topo_ctx->current_iteration, topo_ctx->total_iterations, topo_ctx->total_connections, topo_ctx->total_peers); | 1008 | GNUNET_log ( |
977 | dhtlog_handle->update_topology(topo_ctx->total_connections); | 1009 | GNUNET_ERROR_TYPE_WARNING, |
1010 | "Topology iteration (%u/%u) finished (%u connections, %u peers)\n", | ||
1011 | topo_ctx->current_iteration, topo_ctx->total_iterations, | ||
1012 | topo_ctx->total_connections, topo_ctx->total_peers); | ||
1013 | dhtlog_handle->update_topology (topo_ctx->total_connections); | ||
978 | if (topo_ctx->cont != NULL) | 1014 | if (topo_ctx->cont != NULL) |
979 | GNUNET_SCHEDULER_add_now (topo_ctx->cont, topo_ctx->cls); | 1015 | GNUNET_SCHEDULER_add_now (topo_ctx->cont, topo_ctx->cls); |
980 | if (topo_ctx->peers_seen != NULL) | 1016 | if (topo_ctx->peers_seen != NULL) |
981 | GNUNET_CONTAINER_multihashmap_destroy(topo_ctx->peers_seen); | 1017 | GNUNET_CONTAINER_multihashmap_destroy (topo_ctx->peers_seen); |
982 | GNUNET_free(topo_ctx); | 1018 | GNUNET_free(topo_ctx); |
983 | } | 1019 | } |
984 | } | 1020 | } |
@@ -993,30 +1029,38 @@ log_topology_cb (void *cls, | |||
993 | * iterate, | 1029 | * iterate, |
994 | * GNUNET_NO if not. | 1030 | * GNUNET_NO if not. |
995 | */ | 1031 | */ |
996 | static int stats_iterate (void *cls, | 1032 | static int |
997 | const GNUNET_HashCode * key, | 1033 | stats_iterate(void *cls, const GNUNET_HashCode * key, void *value) |
998 | void *value) | ||
999 | { | 1034 | { |
1000 | struct StatisticsIteratorContext *stats_ctx; | 1035 | struct StatisticsIteratorContext *stats_ctx; |
1001 | if (value == NULL) | 1036 | if (value == NULL) |
1002 | return GNUNET_NO; | 1037 | return GNUNET_NO; |
1003 | stats_ctx = value; | 1038 | stats_ctx = value; |
1004 | dhtlog_handle->insert_stat(stats_ctx->peer, stats_ctx->stat_routes, stats_ctx->stat_route_forwards, stats_ctx->stat_results, | 1039 | dhtlog_handle->insert_stat (stats_ctx->peer, stats_ctx->stat_routes, |
1005 | stats_ctx->stat_results_to_client, stats_ctx->stat_result_forwards, stats_ctx->stat_gets, | 1040 | stats_ctx->stat_route_forwards, |
1006 | stats_ctx->stat_puts, stats_ctx->stat_puts_inserted, stats_ctx->stat_find_peer, | 1041 | stats_ctx->stat_results, |
1007 | stats_ctx->stat_find_peer_start, stats_ctx->stat_get_start, stats_ctx->stat_put_start, | 1042 | stats_ctx->stat_results_to_client, |
1008 | stats_ctx->stat_find_peer_reply, stats_ctx->stat_get_reply, stats_ctx->stat_find_peer_answer, | 1043 | stats_ctx->stat_result_forwards, |
1009 | stats_ctx->stat_get_response_start); | 1044 | stats_ctx->stat_gets, stats_ctx->stat_puts, |
1045 | stats_ctx->stat_puts_inserted, | ||
1046 | stats_ctx->stat_find_peer, | ||
1047 | stats_ctx->stat_find_peer_start, | ||
1048 | stats_ctx->stat_get_start, | ||
1049 | stats_ctx->stat_put_start, | ||
1050 | stats_ctx->stat_find_peer_reply, | ||
1051 | stats_ctx->stat_get_reply, | ||
1052 | stats_ctx->stat_find_peer_answer, | ||
1053 | stats_ctx->stat_get_response_start); | ||
1010 | GNUNET_free(stats_ctx); | 1054 | GNUNET_free(stats_ctx); |
1011 | return GNUNET_YES; | 1055 | return GNUNET_YES; |
1012 | } | 1056 | } |
1013 | 1057 | ||
1014 | static void | 1058 | static void |
1015 | stats_finished (void *cls, int result) | 1059 | stats_finished(void *cls, int result) |
1016 | { | 1060 | { |
1017 | fprintf(stderr, "Finished getting all peers statistics, iterating!\n"); | 1061 | fprintf (stderr, "Finished getting all peers statistics, iterating!\n"); |
1018 | GNUNET_CONTAINER_multihashmap_iterate(stats_map, &stats_iterate, NULL); | 1062 | GNUNET_CONTAINER_multihashmap_iterate (stats_map, &stats_iterate, NULL); |
1019 | GNUNET_CONTAINER_multihashmap_destroy(stats_map); | 1063 | GNUNET_CONTAINER_multihashmap_destroy (stats_map); |
1020 | GNUNET_SCHEDULER_add_now (&finish_testing, NULL); | 1064 | GNUNET_SCHEDULER_add_now (&finish_testing, NULL); |
1021 | } | 1065 | } |
1022 | 1066 | ||
@@ -1031,60 +1075,60 @@ stats_finished (void *cls, int result) | |||
1031 | * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not | 1075 | * @param is_persistent GNUNET_YES if the value is persistent, GNUNET_NO if not |
1032 | * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration | 1076 | * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration |
1033 | */ | 1077 | */ |
1034 | static int stats_handle (void *cls, | 1078 | static int |
1035 | const struct GNUNET_PeerIdentity *peer, | 1079 | stats_handle(void *cls, const struct GNUNET_PeerIdentity *peer, |
1036 | const char *subsystem, | 1080 | const char *subsystem, const char *name, uint64_t value, int is_persistent) |
1037 | const char *name, | ||
1038 | uint64_t value, | ||
1039 | int is_persistent) | ||
1040 | { | 1081 | { |
1041 | struct StatisticsIteratorContext *stats_ctx; | 1082 | struct StatisticsIteratorContext *stats_ctx; |
1042 | 1083 | ||
1043 | if (dhtlog_handle != NULL) | 1084 | if (dhtlog_handle != NULL) |
1044 | dhtlog_handle->add_generic_stat(peer, name, subsystem, value); | 1085 | dhtlog_handle->add_generic_stat (peer, name, subsystem, value); |
1045 | if (GNUNET_CONTAINER_multihashmap_contains(stats_map, &peer->hashPubKey)) | 1086 | if (GNUNET_CONTAINER_multihashmap_contains (stats_map, &peer->hashPubKey)) |
1046 | { | 1087 | { |
1047 | stats_ctx = GNUNET_CONTAINER_multihashmap_get(stats_map, &peer->hashPubKey); | 1088 | stats_ctx = GNUNET_CONTAINER_multihashmap_get (stats_map, |
1089 | &peer->hashPubKey); | ||
1048 | } | 1090 | } |
1049 | else | 1091 | else |
1050 | { | 1092 | { |
1051 | stats_ctx = GNUNET_malloc(sizeof(struct StatisticsIteratorContext)); | 1093 | stats_ctx = GNUNET_malloc(sizeof(struct StatisticsIteratorContext)); |
1052 | stats_ctx->peer = peer; | 1094 | stats_ctx->peer = peer; |
1053 | GNUNET_CONTAINER_multihashmap_put(stats_map, &peer->hashPubKey, stats_ctx, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); | 1095 | GNUNET_CONTAINER_multihashmap_put (stats_map, &peer->hashPubKey, |
1096 | stats_ctx, | ||
1097 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); | ||
1054 | } | 1098 | } |
1055 | GNUNET_assert(stats_ctx != NULL); | 1099 | GNUNET_assert(stats_ctx != NULL); |
1056 | 1100 | ||
1057 | if (strcmp(name, STAT_ROUTES) == 0) | 1101 | if (strcmp (name, STAT_ROUTES) == 0) |
1058 | stats_ctx->stat_routes = value; | 1102 | stats_ctx->stat_routes = value; |
1059 | else if (strcmp(name, STAT_ROUTE_FORWARDS) == 0) | 1103 | else if (strcmp (name, STAT_ROUTE_FORWARDS) == 0) |
1060 | stats_ctx->stat_route_forwards = value; | 1104 | stats_ctx->stat_route_forwards = value; |
1061 | else if (strcmp(name, STAT_RESULTS) == 0) | 1105 | else if (strcmp (name, STAT_RESULTS) == 0) |
1062 | stats_ctx->stat_results = value; | 1106 | stats_ctx->stat_results = value; |
1063 | else if (strcmp(name, STAT_RESULTS_TO_CLIENT) == 0) | 1107 | else if (strcmp (name, STAT_RESULTS_TO_CLIENT) == 0) |
1064 | stats_ctx->stat_results_to_client = value; | 1108 | stats_ctx->stat_results_to_client = value; |
1065 | else if (strcmp(name, STAT_RESULT_FORWARDS) == 0) | 1109 | else if (strcmp (name, STAT_RESULT_FORWARDS) == 0) |
1066 | stats_ctx->stat_result_forwards = value; | 1110 | stats_ctx->stat_result_forwards = value; |
1067 | else if (strcmp(name, STAT_GETS) == 0) | 1111 | else if (strcmp (name, STAT_GETS) == 0) |
1068 | stats_ctx->stat_gets = value; | 1112 | stats_ctx->stat_gets = value; |
1069 | else if (strcmp(name, STAT_PUTS) == 0) | 1113 | else if (strcmp (name, STAT_PUTS) == 0) |
1070 | stats_ctx->stat_puts = value; | 1114 | stats_ctx->stat_puts = value; |
1071 | else if (strcmp(name, STAT_PUTS_INSERTED) == 0) | 1115 | else if (strcmp (name, STAT_PUTS_INSERTED) == 0) |
1072 | stats_ctx->stat_puts_inserted = value; | 1116 | stats_ctx->stat_puts_inserted = value; |
1073 | else if (strcmp(name, STAT_FIND_PEER) == 0) | 1117 | else if (strcmp (name, STAT_FIND_PEER) == 0) |
1074 | stats_ctx->stat_find_peer = value; | 1118 | stats_ctx->stat_find_peer = value; |
1075 | else if (strcmp(name, STAT_FIND_PEER_START) == 0) | 1119 | else if (strcmp (name, STAT_FIND_PEER_START) == 0) |
1076 | stats_ctx->stat_find_peer_start = value; | 1120 | stats_ctx->stat_find_peer_start = value; |
1077 | else if (strcmp(name, STAT_GET_START) == 0) | 1121 | else if (strcmp (name, STAT_GET_START) == 0) |
1078 | stats_ctx->stat_get_start = value; | 1122 | stats_ctx->stat_get_start = value; |
1079 | else if (strcmp(name, STAT_PUT_START) == 0) | 1123 | else if (strcmp (name, STAT_PUT_START) == 0) |
1080 | stats_ctx->stat_put_start = value; | 1124 | stats_ctx->stat_put_start = value; |
1081 | else if (strcmp(name, STAT_FIND_PEER_REPLY) == 0) | 1125 | else if (strcmp (name, STAT_FIND_PEER_REPLY) == 0) |
1082 | stats_ctx->stat_find_peer_reply = value; | 1126 | stats_ctx->stat_find_peer_reply = value; |
1083 | else if (strcmp(name, STAT_GET_REPLY) == 0) | 1127 | else if (strcmp (name, STAT_GET_REPLY) == 0) |
1084 | stats_ctx->stat_get_reply = value; | 1128 | stats_ctx->stat_get_reply = value; |
1085 | else if (strcmp(name, STAT_FIND_PEER_ANSWER) == 0) | 1129 | else if (strcmp (name, STAT_FIND_PEER_ANSWER) == 0) |
1086 | stats_ctx->stat_find_peer_answer = value; | 1130 | stats_ctx->stat_find_peer_answer = value; |
1087 | else if (strcmp(name, STAT_GET_RESPONSE_START) == 0) | 1131 | else if (strcmp (name, STAT_GET_RESPONSE_START) == 0) |
1088 | stats_ctx->stat_get_response_start = value; | 1132 | stats_ctx->stat_get_response_start = value; |
1089 | 1133 | ||
1090 | return GNUNET_OK; | 1134 | return GNUNET_OK; |
@@ -1095,37 +1139,37 @@ static int stats_handle (void *cls, | |||
1095 | * dht statistics for safe keeping. | 1139 | * dht statistics for safe keeping. |
1096 | */ | 1140 | */ |
1097 | static void | 1141 | static void |
1098 | log_dht_statistics (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 1142 | log_dht_statistics(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
1099 | { | 1143 | { |
1100 | stats_map = GNUNET_CONTAINER_multihashmap_create(num_peers); | 1144 | stats_map = GNUNET_CONTAINER_multihashmap_create (num_peers); |
1101 | fprintf(stderr, "Starting statistics logging\n"); | 1145 | fprintf (stderr, "Starting statistics logging\n"); |
1102 | GNUNET_TESTING_get_statistics(pg, &stats_finished, &stats_handle, NULL); | 1146 | GNUNET_TESTING_get_statistics (pg, &stats_finished, &stats_handle, NULL); |
1103 | } | 1147 | } |
1104 | 1148 | ||
1105 | |||
1106 | /** | 1149 | /** |
1107 | * Connect to all peers in the peer group and iterate over their | 1150 | * Connect to all peers in the peer group and iterate over their |
1108 | * connections. | 1151 | * connections. |
1109 | */ | 1152 | */ |
1110 | static void | 1153 | static void |
1111 | capture_current_topology (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 1154 | capture_current_topology(void *cls, |
1155 | const struct GNUNET_SCHEDULER_TaskContext * tc) | ||
1112 | { | 1156 | { |
1113 | struct TopologyIteratorContext *topo_ctx = cls; | 1157 | struct TopologyIteratorContext *topo_ctx = cls; |
1114 | dhtlog_handle->insert_topology(0); | 1158 | dhtlog_handle->insert_topology (0); |
1115 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Called capture_current_topology\n"); | 1159 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Called capture_current_topology\n"); |
1116 | GNUNET_TESTING_get_topology (pg, &log_topology_cb, topo_ctx); | 1160 | GNUNET_TESTING_get_topology (pg, &log_topology_cb, topo_ctx); |
1117 | } | 1161 | } |
1118 | 1162 | ||
1119 | |||
1120 | /** | 1163 | /** |
1121 | * Check if the get_handle is being used, if so stop the request. Either | 1164 | * Check if the get_handle is being used, if so stop the request. Either |
1122 | * way, schedule the end_badly_cont function which actually shuts down the | 1165 | * way, schedule the end_badly_cont function which actually shuts down the |
1123 | * test. | 1166 | * test. |
1124 | */ | 1167 | */ |
1125 | static void | 1168 | static void |
1126 | end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 1169 | end_badly(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
1127 | { | 1170 | { |
1128 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failing test with error: `%s'!\n", (char *)cls); | 1171 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failing test with error: `%s'!\n", |
1172 | (char *) cls); | ||
1129 | 1173 | ||
1130 | struct TestPutContext *test_put = all_puts; | 1174 | struct TestPutContext *test_put = all_puts; |
1131 | struct TestGetContext *test_get = all_gets; | 1175 | struct TestGetContext *test_get = all_gets; |
@@ -1133,20 +1177,20 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1133 | while (test_put != NULL) | 1177 | while (test_put != NULL) |
1134 | { | 1178 | { |
1135 | if (test_put->disconnect_task != GNUNET_SCHEDULER_NO_TASK) | 1179 | if (test_put->disconnect_task != GNUNET_SCHEDULER_NO_TASK) |
1136 | GNUNET_SCHEDULER_cancel(test_put->disconnect_task); | 1180 | GNUNET_SCHEDULER_cancel (test_put->disconnect_task); |
1137 | if (test_put->dht_handle != NULL) | 1181 | if (test_put->dht_handle != NULL) |
1138 | GNUNET_DHT_disconnect(test_put->dht_handle); | 1182 | GNUNET_DHT_disconnect (test_put->dht_handle); |
1139 | test_put = test_put->next; | 1183 | test_put = test_put->next; |
1140 | } | 1184 | } |
1141 | 1185 | ||
1142 | while (test_get != NULL) | 1186 | while (test_get != NULL) |
1143 | { | 1187 | { |
1144 | if (test_get->disconnect_task != GNUNET_SCHEDULER_NO_TASK) | 1188 | if (test_get->disconnect_task != GNUNET_SCHEDULER_NO_TASK) |
1145 | GNUNET_SCHEDULER_cancel(test_get->disconnect_task); | 1189 | GNUNET_SCHEDULER_cancel (test_get->disconnect_task); |
1146 | if (test_get->get_handle != NULL) | 1190 | if (test_get->get_handle != NULL) |
1147 | GNUNET_DHT_get_stop(test_get->get_handle); | 1191 | GNUNET_DHT_get_stop (test_get->get_handle); |
1148 | if (test_get->dht_handle != NULL) | 1192 | if (test_get->dht_handle != NULL) |
1149 | GNUNET_DHT_disconnect(test_get->dht_handle); | 1193 | GNUNET_DHT_disconnect (test_get->dht_handle); |
1150 | test_get = test_get->next; | 1194 | test_get = test_get->next; |
1151 | } | 1195 | } |
1152 | 1196 | ||
@@ -1154,22 +1198,22 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1154 | 1198 | ||
1155 | if (dhtlog_handle != NULL) | 1199 | if (dhtlog_handle != NULL) |
1156 | { | 1200 | { |
1157 | fprintf(stderr, "Update trial endtime\n"); | 1201 | fprintf (stderr, "Update trial endtime\n"); |
1158 | dhtlog_handle->update_trial (gets_completed); | 1202 | dhtlog_handle->update_trial (gets_completed); |
1159 | GNUNET_DHTLOG_disconnect(dhtlog_handle); | 1203 | GNUNET_DHTLOG_disconnect (dhtlog_handle); |
1160 | dhtlog_handle = NULL; | 1204 | dhtlog_handle = NULL; |
1161 | } | 1205 | } |
1162 | 1206 | ||
1163 | if (hostkey_meter != NULL) | 1207 | if (hostkey_meter != NULL) |
1164 | free_meter(hostkey_meter); | 1208 | free_meter (hostkey_meter); |
1165 | if (peer_start_meter != NULL) | 1209 | if (peer_start_meter != NULL) |
1166 | free_meter(peer_start_meter); | 1210 | free_meter (peer_start_meter); |
1167 | if (peer_connect_meter != NULL) | 1211 | if (peer_connect_meter != NULL) |
1168 | free_meter(peer_connect_meter); | 1212 | free_meter (peer_connect_meter); |
1169 | if (put_meter != NULL) | 1213 | if (put_meter != NULL) |
1170 | free_meter(put_meter); | 1214 | free_meter (put_meter); |
1171 | if (get_meter != NULL) | 1215 | if (get_meter != NULL) |
1172 | free_meter(get_meter); | 1216 | free_meter (get_meter); |
1173 | 1217 | ||
1174 | ok = 1; | 1218 | ok = 1; |
1175 | } | 1219 | } |
@@ -1178,13 +1222,13 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1178 | * Forward declaration. | 1222 | * Forward declaration. |
1179 | */ | 1223 | */ |
1180 | static void | 1224 | static void |
1181 | do_put (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc); | 1225 | do_put(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc); |
1182 | 1226 | ||
1183 | /** | 1227 | /** |
1184 | * Forward declaration. | 1228 | * Forward declaration. |
1185 | */ | 1229 | */ |
1186 | static void | 1230 | static void |
1187 | do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc); | 1231 | do_get(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc); |
1188 | 1232 | ||
1189 | /** | 1233 | /** |
1190 | * Iterator over hash map entries. | 1234 | * Iterator over hash map entries. |
@@ -1196,13 +1240,13 @@ do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc); | |||
1196 | * iterate, | 1240 | * iterate, |
1197 | * GNUNET_NO if not. | 1241 | * GNUNET_NO if not. |
1198 | */ | 1242 | */ |
1199 | static int remove_peer_count (void *cls, | 1243 | static int |
1200 | const GNUNET_HashCode * key, | 1244 | remove_peer_count(void *cls, const GNUNET_HashCode * key, void *value) |
1201 | void *value) | ||
1202 | { | 1245 | { |
1203 | struct FindPeerContext *find_peer_ctx = cls; | 1246 | struct FindPeerContext *find_peer_ctx = cls; |
1204 | struct PeerCount *peer_count = value; | 1247 | struct PeerCount *peer_count = value; |
1205 | GNUNET_CONTAINER_heap_remove_node(find_peer_ctx->peer_min_heap, peer_count->heap_node); | 1248 | GNUNET_CONTAINER_heap_remove_node (find_peer_ctx->peer_min_heap, |
1249 | peer_count->heap_node); | ||
1206 | GNUNET_free(peer_count); | 1250 | GNUNET_free(peer_count); |
1207 | 1251 | ||
1208 | return GNUNET_YES; | 1252 | return GNUNET_YES; |
@@ -1213,25 +1257,27 @@ static int remove_peer_count (void *cls, | |||
1213 | * connections. | 1257 | * connections. |
1214 | */ | 1258 | */ |
1215 | static void | 1259 | static void |
1216 | count_new_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 1260 | count_new_peers(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
1217 | { | 1261 | { |
1218 | struct FindPeerContext *find_peer_context = cls; | 1262 | struct FindPeerContext *find_peer_context = cls; |
1219 | find_peer_context->previous_peers = find_peer_context->current_peers; | 1263 | find_peer_context->previous_peers = find_peer_context->current_peers; |
1220 | find_peer_context->current_peers = 0; | 1264 | find_peer_context->current_peers = 0; |
1221 | GNUNET_TESTING_get_topology (pg, find_peer_context->count_peers_cb, find_peer_context); | 1265 | GNUNET_TESTING_get_topology (pg, find_peer_context->count_peers_cb, |
1266 | find_peer_context); | ||
1222 | } | 1267 | } |
1223 | 1268 | ||
1224 | static void | 1269 | static void |
1225 | decrement_find_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 1270 | decrement_find_peers(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
1226 | { | 1271 | { |
1227 | struct TestFindPeer *test_find_peer = cls; | 1272 | struct TestFindPeer *test_find_peer = cls; |
1228 | GNUNET_assert(test_find_peer->find_peer_context->outstanding > 0); | 1273 | GNUNET_assert(test_find_peer->find_peer_context->outstanding > 0); |
1229 | test_find_peer->find_peer_context->outstanding--; | 1274 | test_find_peer->find_peer_context->outstanding--; |
1230 | test_find_peer->find_peer_context->total--; | 1275 | test_find_peer->find_peer_context->total--; |
1231 | if (0 == test_find_peer->find_peer_context->total) | 1276 | if (0 == test_find_peer->find_peer_context->total) |
1232 | { | 1277 | { |
1233 | GNUNET_SCHEDULER_add_now(&count_new_peers, test_find_peer->find_peer_context); | 1278 | GNUNET_SCHEDULER_add_now (&count_new_peers, |
1234 | } | 1279 | test_find_peer->find_peer_context); |
1280 | } | ||
1235 | GNUNET_free(test_find_peer); | 1281 | GNUNET_free(test_find_peer); |
1236 | } | 1282 | } |
1237 | 1283 | ||
@@ -1243,86 +1289,111 @@ decrement_find_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1243 | * @param tc context the task is being called with | 1289 | * @param tc context the task is being called with |
1244 | */ | 1290 | */ |
1245 | static void | 1291 | static void |
1246 | handle_find_peer_sent (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 1292 | handle_find_peer_sent(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
1247 | { | 1293 | { |
1248 | struct TestFindPeer *test_find_peer = cls; | 1294 | struct TestFindPeer *test_find_peer = cls; |
1249 | 1295 | ||
1250 | GNUNET_DHT_disconnect(test_find_peer->dht_handle); | 1296 | GNUNET_DHT_disconnect (test_find_peer->dht_handle); |
1251 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_divide(find_peer_delay, 2), &decrement_find_peers, test_find_peer); | 1297 | GNUNET_SCHEDULER_add_delayed ( |
1298 | GNUNET_TIME_relative_divide (find_peer_delay, 2), | ||
1299 | &decrement_find_peers, test_find_peer); | ||
1252 | } | 1300 | } |
1253 | 1301 | ||
1254 | |||
1255 | static void | 1302 | static void |
1256 | send_find_peer_request (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 1303 | send_find_peer_request(void *cls, |
1304 | const struct GNUNET_SCHEDULER_TaskContext * tc) | ||
1257 | { | 1305 | { |
1258 | struct TestFindPeer *test_find_peer = cls; | 1306 | struct TestFindPeer *test_find_peer = cls; |
1259 | 1307 | ||
1260 | if (test_find_peer->find_peer_context->outstanding > max_outstanding_find_peers) | 1308 | if (test_find_peer->find_peer_context->outstanding |
1261 | { | 1309 | > max_outstanding_find_peers) |
1262 | GNUNET_SCHEDULER_add_delayed(find_peer_offset, &send_find_peer_request, test_find_peer); | 1310 | { |
1263 | return; | 1311 | GNUNET_SCHEDULER_add_delayed (find_peer_offset, &send_find_peer_request, |
1264 | } | 1312 | test_find_peer); |
1313 | return; | ||
1314 | } | ||
1265 | 1315 | ||
1266 | test_find_peer->find_peer_context->outstanding++; | 1316 | test_find_peer->find_peer_context->outstanding++; |
1267 | if (GNUNET_TIME_absolute_get_remaining(test_find_peer->find_peer_context->endtime).rel_value == 0) | 1317 | if (GNUNET_TIME_absolute_get_remaining ( |
1268 | { | 1318 | test_find_peer->find_peer_context->endtime).rel_value |
1269 | GNUNET_SCHEDULER_add_now(&decrement_find_peers, test_find_peer); | 1319 | == 0) |
1270 | return; | 1320 | { |
1271 | } | 1321 | GNUNET_SCHEDULER_add_now (&decrement_find_peers, test_find_peer); |
1322 | return; | ||
1323 | } | ||
1272 | 1324 | ||
1273 | test_find_peer->dht_handle = GNUNET_DHT_connect(test_find_peer->daemon->cfg, 1); | 1325 | test_find_peer->dht_handle = GNUNET_DHT_connect (test_find_peer->daemon->cfg, |
1326 | 1); | ||
1274 | GNUNET_assert(test_find_peer->dht_handle != NULL); | 1327 | GNUNET_assert(test_find_peer->dht_handle != NULL); |
1275 | GNUNET_DHT_find_peers (test_find_peer->dht_handle, | 1328 | GNUNET_DHT_find_peers (test_find_peer->dht_handle, &handle_find_peer_sent, |
1276 | &handle_find_peer_sent, test_find_peer); | 1329 | test_find_peer); |
1277 | } | 1330 | } |
1278 | 1331 | ||
1279 | |||
1280 | /** | 1332 | /** |
1281 | * Add a connection to the find_peer_context given. This may | 1333 | * Add a connection to the find_peer_context given. This may |
1282 | * be complete overkill, but allows us to choose the peers with | 1334 | * be complete overkill, but allows us to choose the peers with |
1283 | * the least connections to initiate find peer requests from. | 1335 | * the least connections to initiate find peer requests from. |
1284 | */ | 1336 | */ |
1285 | static void add_new_connection(struct FindPeerContext *find_peer_context, | 1337 | static void |
1286 | const struct GNUNET_PeerIdentity *first, | 1338 | add_new_connection(struct FindPeerContext *find_peer_context, |
1287 | const struct GNUNET_PeerIdentity *second) | 1339 | const struct GNUNET_PeerIdentity *first, |
1340 | const struct GNUNET_PeerIdentity *second) | ||
1288 | { | 1341 | { |
1289 | struct PeerCount *first_count; | 1342 | struct PeerCount *first_count; |
1290 | struct PeerCount *second_count; | 1343 | struct PeerCount *second_count; |
1291 | 1344 | ||
1292 | if (GNUNET_CONTAINER_multihashmap_contains(find_peer_context->peer_hash, &first->hashPubKey)) | 1345 | if (GNUNET_CONTAINER_multihashmap_contains (find_peer_context->peer_hash, |
1293 | { | 1346 | &first->hashPubKey)) |
1294 | first_count = GNUNET_CONTAINER_multihashmap_get(find_peer_context->peer_hash, &first->hashPubKey); | 1347 | { |
1295 | GNUNET_assert(first_count != NULL); | 1348 | first_count |
1296 | first_count->count++; | 1349 | = GNUNET_CONTAINER_multihashmap_get (find_peer_context->peer_hash, |
1297 | GNUNET_CONTAINER_heap_update_cost(find_peer_context->peer_min_heap, first_count->heap_node, first_count->count); | 1350 | &first->hashPubKey); |
1298 | } | 1351 | GNUNET_assert(first_count != NULL); |
1352 | first_count->count++; | ||
1353 | GNUNET_CONTAINER_heap_update_cost (find_peer_context->peer_min_heap, | ||
1354 | first_count->heap_node, | ||
1355 | first_count->count); | ||
1356 | } | ||
1299 | else | 1357 | else |
1300 | { | 1358 | { |
1301 | first_count = GNUNET_malloc(sizeof(struct PeerCount)); | 1359 | first_count = GNUNET_malloc(sizeof(struct PeerCount)); |
1302 | first_count->count = 1; | 1360 | first_count->count = 1; |
1303 | memcpy(&first_count->peer_id, first, sizeof(struct GNUNET_PeerIdentity)); | 1361 | memcpy (&first_count->peer_id, first, sizeof(struct GNUNET_PeerIdentity)); |
1304 | first_count->heap_node = GNUNET_CONTAINER_heap_insert(find_peer_context->peer_min_heap, first_count, first_count->count); | 1362 | first_count->heap_node |
1305 | GNUNET_CONTAINER_multihashmap_put(find_peer_context->peer_hash, &first->hashPubKey, first_count, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); | 1363 | = GNUNET_CONTAINER_heap_insert (find_peer_context->peer_min_heap, |
1306 | } | 1364 | first_count, first_count->count); |
1307 | 1365 | GNUNET_CONTAINER_multihashmap_put (find_peer_context->peer_hash, | |
1308 | if (GNUNET_CONTAINER_multihashmap_contains(find_peer_context->peer_hash, &second->hashPubKey)) | 1366 | &first->hashPubKey, first_count, |
1309 | { | 1367 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); |
1310 | second_count = GNUNET_CONTAINER_multihashmap_get(find_peer_context->peer_hash, &second->hashPubKey); | 1368 | } |
1311 | GNUNET_assert(second_count != NULL); | 1369 | |
1312 | second_count->count++; | 1370 | if (GNUNET_CONTAINER_multihashmap_contains (find_peer_context->peer_hash, |
1313 | GNUNET_CONTAINER_heap_update_cost(find_peer_context->peer_min_heap, second_count->heap_node, second_count->count); | 1371 | &second->hashPubKey)) |
1314 | } | 1372 | { |
1373 | second_count | ||
1374 | = GNUNET_CONTAINER_multihashmap_get (find_peer_context->peer_hash, | ||
1375 | &second->hashPubKey); | ||
1376 | GNUNET_assert(second_count != NULL); | ||
1377 | second_count->count++; | ||
1378 | GNUNET_CONTAINER_heap_update_cost (find_peer_context->peer_min_heap, | ||
1379 | second_count->heap_node, | ||
1380 | second_count->count); | ||
1381 | } | ||
1315 | else | 1382 | else |
1316 | { | 1383 | { |
1317 | second_count = GNUNET_malloc(sizeof(struct PeerCount)); | 1384 | second_count = GNUNET_malloc(sizeof(struct PeerCount)); |
1318 | second_count->count = 1; | 1385 | second_count->count = 1; |
1319 | memcpy(&second_count->peer_id, second, sizeof(struct GNUNET_PeerIdentity)); | 1386 | memcpy (&second_count->peer_id, second, |
1320 | second_count->heap_node = GNUNET_CONTAINER_heap_insert(find_peer_context->peer_min_heap, second_count, second_count->count); | 1387 | sizeof(struct GNUNET_PeerIdentity)); |
1321 | GNUNET_CONTAINER_multihashmap_put(find_peer_context->peer_hash, &second->hashPubKey, second_count, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); | 1388 | second_count->heap_node |
1322 | } | 1389 | = GNUNET_CONTAINER_heap_insert (find_peer_context->peer_min_heap, |
1390 | second_count, second_count->count); | ||
1391 | GNUNET_CONTAINER_multihashmap_put (find_peer_context->peer_hash, | ||
1392 | &second->hashPubKey, second_count, | ||
1393 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); | ||
1394 | } | ||
1323 | } | 1395 | } |
1324 | 1396 | ||
1325 | |||
1326 | /** | 1397 | /** |
1327 | * Iterate over min heap of connections per peer. For any | 1398 | * Iterate over min heap of connections per peer. For any |
1328 | * peer that has 0 connections, attempt to connect them to | 1399 | * peer that has 0 connections, attempt to connect them to |
@@ -1335,10 +1406,9 @@ static void add_new_connection(struct FindPeerContext *find_peer_context, | |||
1335 | * @return GNUNET_YES if we should continue to iterate, | 1406 | * @return GNUNET_YES if we should continue to iterate, |
1336 | * GNUNET_NO if not. | 1407 | * GNUNET_NO if not. |
1337 | */ | 1408 | */ |
1338 | static int iterate_min_heap_peers (void *cls, | 1409 | static int |
1339 | struct GNUNET_CONTAINER_HeapNode *node, | 1410 | iterate_min_heap_peers(void *cls, struct GNUNET_CONTAINER_HeapNode *node, |
1340 | void *element, | 1411 | void *element, GNUNET_CONTAINER_HeapCostType cost) |
1341 | GNUNET_CONTAINER_HeapCostType cost) | ||
1342 | { | 1412 | { |
1343 | struct FindPeerContext *find_peer_context = cls; | 1413 | struct FindPeerContext *find_peer_context = cls; |
1344 | struct PeerCount *peer_count = element; | 1414 | struct PeerCount *peer_count = element; |
@@ -1350,22 +1420,35 @@ static int iterate_min_heap_peers (void *cls, | |||
1350 | d1 = GNUNET_TESTING_daemon_get_by_id (pg, &peer_count->peer_id); | 1420 | d1 = GNUNET_TESTING_daemon_get_by_id (pg, &peer_count->peer_id); |
1351 | GNUNET_assert(d1 != NULL); | 1421 | GNUNET_assert(d1 != NULL); |
1352 | d2 = d1; | 1422 | d2 = d1; |
1353 | while ((d2 == d1) || (GNUNET_YES != GNUNET_TESTING_daemon_running(d2))) | 1423 | while ((d2 == d1) || (GNUNET_YES != GNUNET_TESTING_daemon_running (d2))) |
1354 | { | 1424 | { |
1355 | d2 = GNUNET_TESTING_daemon_get(pg, GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers)); | 1425 | d2 |
1426 | = GNUNET_TESTING_daemon_get ( | ||
1427 | pg, | ||
1428 | GNUNET_CRYPTO_random_u32 ( | ||
1429 | GNUNET_CRYPTO_QUALITY_WEAK, | ||
1430 | num_peers)); | ||
1356 | GNUNET_assert(d2 != NULL); | 1431 | GNUNET_assert(d2 != NULL); |
1357 | } | 1432 | } |
1358 | 1433 | ||
1359 | /** Just try to connect the peers, don't worry about callbacks, etc. **/ | 1434 | /** Just try to connect the peers, don't worry about callbacks, etc. **/ |
1360 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Peer %s has 0 connections. Trying to connect to %s...\n", GNUNET_i2s(&peer_count->peer_id), d2->shortname); | 1435 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1361 | timeout = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, DEFAULT_CONNECT_TIMEOUT); | 1436 | "Peer %s has 0 connections. Trying to connect to %s...\n", |
1362 | if (GNUNET_TIME_relative_to_absolute(timeout).abs_value > find_peer_context->endtime.abs_value) | 1437 | GNUNET_i2s (&peer_count->peer_id), d2->shortname); |
1438 | timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, | ||
1439 | DEFAULT_CONNECT_TIMEOUT); | ||
1440 | if (GNUNET_TIME_relative_to_absolute (timeout).abs_value | ||
1441 | > find_peer_context->endtime.abs_value) | ||
1363 | { | 1442 | { |
1364 | timeout = GNUNET_TIME_absolute_get_remaining(find_peer_context->endtime); | 1443 | timeout |
1444 | = GNUNET_TIME_absolute_get_remaining (find_peer_context->endtime); | ||
1365 | } | 1445 | } |
1366 | GNUNET_TESTING_daemons_connect(d1, d2, timeout, DEFAULT_RECONNECT_ATTEMPTS, GNUNET_YES, NULL, NULL); | 1446 | GNUNET_TESTING_daemons_connect (d1, d2, timeout, |
1447 | DEFAULT_RECONNECT_ATTEMPTS, GNUNET_YES, | ||
1448 | NULL, NULL); | ||
1367 | } | 1449 | } |
1368 | if (GNUNET_TIME_absolute_get_remaining(find_peer_context->endtime).rel_value > 0) | 1450 | if (GNUNET_TIME_absolute_get_remaining (find_peer_context->endtime).rel_value |
1451 | > 0) | ||
1369 | return GNUNET_YES; | 1452 | return GNUNET_YES; |
1370 | else | 1453 | else |
1371 | return GNUNET_NO; | 1454 | return GNUNET_NO; |
@@ -1375,18 +1458,17 @@ static int iterate_min_heap_peers (void *cls, | |||
1375 | * Forward declaration. | 1458 | * Forward declaration. |
1376 | */ | 1459 | */ |
1377 | static void | 1460 | static void |
1378 | schedule_churn_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc); | 1461 | schedule_churn_find_peer_requests(void *cls, |
1462 | const struct GNUNET_SCHEDULER_TaskContext * tc); | ||
1379 | 1463 | ||
1380 | /** | 1464 | /** |
1381 | * Callback for iterating over all the peer connections of a peer group. | 1465 | * Callback for iterating over all the peer connections of a peer group. |
1382 | * Used after we have churned on some peers to find which ones have zero | 1466 | * Used after we have churned on some peers to find which ones have zero |
1383 | * connections so we can make them issue find peer requests. | 1467 | * connections so we can make them issue find peer requests. |
1384 | */ | 1468 | */ |
1385 | static void | 1469 | static void |
1386 | count_peers_churn_cb (void *cls, | 1470 | count_peers_churn_cb(void *cls, const struct GNUNET_PeerIdentity *first, |
1387 | const struct GNUNET_PeerIdentity *first, | 1471 | const struct GNUNET_PeerIdentity *second, const char *emsg) |
1388 | const struct GNUNET_PeerIdentity *second, | ||
1389 | const char *emsg) | ||
1390 | { | 1472 | { |
1391 | struct FindPeerContext *find_peer_context = cls; | 1473 | struct FindPeerContext *find_peer_context = cls; |
1392 | struct TopologyIteratorContext *topo_ctx; | 1474 | struct TopologyIteratorContext *topo_ctx; |
@@ -1394,14 +1476,16 @@ count_peers_churn_cb (void *cls, | |||
1394 | 1476 | ||
1395 | if ((first != NULL) && (second != NULL)) | 1477 | if ((first != NULL) && (second != NULL)) |
1396 | { | 1478 | { |
1397 | add_new_connection(find_peer_context, first, second); | 1479 | add_new_connection (find_peer_context, first, second); |
1398 | find_peer_context->current_peers++; | 1480 | find_peer_context->current_peers++; |
1399 | } | 1481 | } |
1400 | else | 1482 | else |
1401 | { | 1483 | { |
1402 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Peer count finished (%u connections)\n", | 1484 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1403 | find_peer_context->current_peers); | 1485 | "Peer count finished (%u connections)\n", |
1404 | peer_count = GNUNET_CONTAINER_heap_peek(find_peer_context->peer_min_heap); | 1486 | find_peer_context->current_peers); |
1487 | peer_count | ||
1488 | = GNUNET_CONTAINER_heap_peek (find_peer_context->peer_min_heap); | ||
1405 | GNUNET_assert(peer_count != NULL); | 1489 | GNUNET_assert(peer_count != NULL); |
1406 | /* WAIT. When peers are churned they will come back with their peers (at least in peerinfo), because the HOSTS file doesn't likely get removed. CRAP. */ | 1490 | /* WAIT. When peers are churned they will come back with their peers (at least in peerinfo), because the HOSTS file doesn't likely get removed. CRAP. */ |
1407 | /* NO they won't, because we have disabled peerinfo writing to disk (remember?) so we WILL have to give them new connections */ | 1491 | /* NO they won't, because we have disabled peerinfo writing to disk (remember?) so we WILL have to give them new connections */ |
@@ -1450,40 +1534,74 @@ count_peers_churn_cb (void *cls, | |||
1450 | * into the general testing churn options seems like overkill because | 1534 | * into the general testing churn options seems like overkill because |
1451 | * these are very specialized cases. | 1535 | * these are very specialized cases. |
1452 | */ | 1536 | */ |
1453 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Out of %u peers, fewest connections is %d\n", GNUNET_CONTAINER_heap_get_size(find_peer_context->peer_min_heap), peer_count->count); | 1537 | GNUNET_log ( |
1454 | if ((peer_count->count == 0) && (GNUNET_TIME_absolute_get_remaining(find_peer_context->endtime).rel_value > 0)) | 1538 | GNUNET_ERROR_TYPE_WARNING, |
1539 | "Out of %u peers, fewest connections is %d\n", | ||
1540 | GNUNET_CONTAINER_heap_get_size ( | ||
1541 | find_peer_context->peer_min_heap), | ||
1542 | peer_count->count); | ||
1543 | if ((peer_count->count == 0) | ||
1544 | && (GNUNET_TIME_absolute_get_remaining (find_peer_context->endtime).rel_value | ||
1545 | > 0)) | ||
1455 | { | 1546 | { |
1456 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Found peer with no connections, will choose some peer(s) at random to connect to!\n"); | 1547 | GNUNET_log ( |
1457 | GNUNET_CONTAINER_heap_iterate (find_peer_context->peer_min_heap, &iterate_min_heap_peers, find_peer_context); | 1548 | GNUNET_ERROR_TYPE_WARNING, |
1458 | GNUNET_SCHEDULER_add_now(&schedule_churn_find_peer_requests, find_peer_context); | 1549 | "Found peer with no connections, will choose some peer(s) at random to connect to!\n"); |
1550 | GNUNET_CONTAINER_heap_iterate (find_peer_context->peer_min_heap, | ||
1551 | &iterate_min_heap_peers, | ||
1552 | find_peer_context); | ||
1553 | GNUNET_SCHEDULER_add_now (&schedule_churn_find_peer_requests, | ||
1554 | find_peer_context); | ||
1459 | } | 1555 | } |
1460 | else if ((GNUNET_TIME_absolute_get_remaining(find_peer_context->endtime).rel_value > 0) && (find_peer_context->last_sent != 0)) | 1556 | else if ((GNUNET_TIME_absolute_get_remaining (find_peer_context->endtime).rel_value |
1557 | > 0) && (find_peer_context->last_sent != 0)) | ||
1461 | { | 1558 | { |
1462 | GNUNET_SCHEDULER_add_now(&schedule_churn_find_peer_requests, find_peer_context); | 1559 | GNUNET_SCHEDULER_add_now (&schedule_churn_find_peer_requests, |
1560 | find_peer_context); | ||
1463 | } | 1561 | } |
1464 | else | 1562 | else |
1465 | { | 1563 | { |
1466 | GNUNET_CONTAINER_multihashmap_iterate(find_peer_context->peer_hash, &remove_peer_count, find_peer_context); | 1564 | GNUNET_CONTAINER_multihashmap_iterate (find_peer_context->peer_hash, |
1467 | GNUNET_CONTAINER_multihashmap_destroy(find_peer_context->peer_hash); | 1565 | &remove_peer_count, |
1468 | GNUNET_CONTAINER_heap_destroy(find_peer_context->peer_min_heap); | 1566 | find_peer_context); |
1567 | GNUNET_CONTAINER_multihashmap_destroy (find_peer_context->peer_hash); | ||
1568 | GNUNET_CONTAINER_heap_destroy (find_peer_context->peer_min_heap); | ||
1469 | GNUNET_free(find_peer_context); | 1569 | GNUNET_free(find_peer_context); |
1470 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Churn round %u of %llu finished, scheduling next GET round.\n", current_churn_round, churn_rounds); | 1570 | GNUNET_log ( |
1571 | GNUNET_ERROR_TYPE_WARNING, | ||
1572 | "Churn round %u of %llu finished, scheduling next GET round.\n", | ||
1573 | current_churn_round, churn_rounds); | ||
1471 | if (dhtlog_handle != NULL) | 1574 | if (dhtlog_handle != NULL) |
1472 | { | 1575 | { |
1473 | topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext)); | 1576 | topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext)); |
1474 | topo_ctx->cont = &do_get; | 1577 | topo_ctx->cont = &do_get; |
1475 | topo_ctx->cls = all_gets; | 1578 | topo_ctx->cls = all_gets; |
1476 | topo_ctx->timeout = DEFAULT_GET_TIMEOUT; | 1579 | topo_ctx->timeout = DEFAULT_GET_TIMEOUT; |
1477 | topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers); | 1580 | topo_ctx->peers_seen |
1478 | die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT), | 1581 | = GNUNET_CONTAINER_multihashmap_create (num_peers); |
1479 | &end_badly, "from do gets (count_peers_churn_cb)"); | 1582 | die_task |
1480 | GNUNET_SCHEDULER_add_now(&capture_current_topology, topo_ctx); | 1583 | = GNUNET_SCHEDULER_add_delayed ( |
1584 | GNUNET_TIME_relative_add ( | ||
1585 | GNUNET_TIME_relative_add ( | ||
1586 | DEFAULT_GET_TIMEOUT, | ||
1587 | all_get_timeout), | ||
1588 | DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT), | ||
1589 | &end_badly, | ||
1590 | "from do gets (count_peers_churn_cb)"); | ||
1591 | GNUNET_SCHEDULER_add_now (&capture_current_topology, topo_ctx); | ||
1481 | } | 1592 | } |
1482 | else | 1593 | else |
1483 | { | 1594 | { |
1484 | die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT), | 1595 | die_task |
1485 | &end_badly, "from do gets (count_peers_churn_cb)"); | 1596 | = GNUNET_SCHEDULER_add_delayed ( |
1486 | GNUNET_SCHEDULER_add_now(&do_get, all_gets); | 1597 | GNUNET_TIME_relative_add ( |
1598 | GNUNET_TIME_relative_add ( | ||
1599 | DEFAULT_GET_TIMEOUT, | ||
1600 | all_get_timeout), | ||
1601 | DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT), | ||
1602 | &end_badly, | ||
1603 | "from do gets (count_peers_churn_cb)"); | ||
1604 | GNUNET_SCHEDULER_add_now (&do_get, all_gets); | ||
1487 | } | 1605 | } |
1488 | } | 1606 | } |
1489 | } | 1607 | } |
@@ -1495,7 +1613,8 @@ count_peers_churn_cb (void *cls, | |||
1495 | * and the time allowed for each one! | 1613 | * and the time allowed for each one! |
1496 | */ | 1614 | */ |
1497 | static void | 1615 | static void |
1498 | schedule_churn_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 1616 | schedule_churn_find_peer_requests(void *cls, |
1617 | const struct GNUNET_SCHEDULER_TaskContext * tc) | ||
1499 | { | 1618 | { |
1500 | struct FindPeerContext *find_peer_ctx = cls; | 1619 | struct FindPeerContext *find_peer_ctx = cls; |
1501 | struct TestFindPeer *test_find_peer; | 1620 | struct TestFindPeer *test_find_peer; |
@@ -1504,10 +1623,13 @@ schedule_churn_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_Task | |||
1504 | 1623 | ||
1505 | if (find_peer_ctx->previous_peers == 0) /* First time, go slowly */ | 1624 | if (find_peer_ctx->previous_peers == 0) /* First time, go slowly */ |
1506 | find_peer_ctx->total = 1; | 1625 | find_peer_ctx->total = 1; |
1507 | else if (find_peer_ctx->current_peers - find_peer_ctx->previous_peers < MIN_FIND_PEER_CUTOFF) | 1626 | else if (find_peer_ctx->current_peers - find_peer_ctx->previous_peers |
1627 | < MIN_FIND_PEER_CUTOFF) | ||
1508 | find_peer_ctx->total = find_peer_ctx->total / 2; | 1628 | find_peer_ctx->total = find_peer_ctx->total / 2; |
1509 | else if (find_peer_ctx->current_peers - find_peer_ctx->previous_peers > MAX_FIND_PEER_CUTOFF) /* Found LOTS of peers, still go slowly */ | 1629 | else if (find_peer_ctx->current_peers - find_peer_ctx->previous_peers |
1510 | find_peer_ctx->total = find_peer_ctx->last_sent - (find_peer_ctx->last_sent / 4); | 1630 | > MAX_FIND_PEER_CUTOFF) /* Found LOTS of peers, still go slowly */ |
1631 | find_peer_ctx->total = find_peer_ctx->last_sent - (find_peer_ctx->last_sent | ||
1632 | / 4); | ||
1511 | else | 1633 | else |
1512 | find_peer_ctx->total = find_peer_ctx->last_sent * 4; | 1634 | find_peer_ctx->total = find_peer_ctx->last_sent * 4; |
1513 | 1635 | ||
@@ -1515,10 +1637,13 @@ schedule_churn_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_Task | |||
1515 | find_peer_ctx->total = max_outstanding_find_peers; | 1637 | find_peer_ctx->total = max_outstanding_find_peers; |
1516 | 1638 | ||
1517 | find_peer_ctx->last_sent = find_peer_ctx->total; | 1639 | find_peer_ctx->last_sent = find_peer_ctx->total; |
1518 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending %u find peer messages (after churn)\n", find_peer_ctx->total); | 1640 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1641 | "Sending %u find peer messages (after churn)\n", | ||
1642 | find_peer_ctx->total); | ||
1519 | 1643 | ||
1520 | if (find_peer_ctx->total > 0) | 1644 | if (find_peer_ctx->total > 0) |
1521 | find_peer_offset = GNUNET_TIME_relative_divide(find_peer_delay, find_peer_ctx->total); | 1645 | find_peer_offset = GNUNET_TIME_relative_divide (find_peer_delay, |
1646 | find_peer_ctx->total); | ||
1522 | else | 1647 | else |
1523 | { | 1648 | { |
1524 | find_peer_ctx->previous_peers = find_peer_ctx->current_peers; | 1649 | find_peer_ctx->previous_peers = find_peer_ctx->current_peers; |
@@ -1526,38 +1651,54 @@ schedule_churn_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_Task | |||
1526 | GNUNET_TESTING_get_topology (pg, &count_peers_churn_cb, find_peer_ctx); | 1651 | GNUNET_TESTING_get_topology (pg, &count_peers_churn_cb, find_peer_ctx); |
1527 | } | 1652 | } |
1528 | 1653 | ||
1529 | |||
1530 | for (i = 0; i < find_peer_ctx->total; i++) | 1654 | for (i = 0; i < find_peer_ctx->total; i++) |
1531 | { | 1655 | { |
1532 | test_find_peer = GNUNET_malloc(sizeof(struct TestFindPeer)); | 1656 | test_find_peer = GNUNET_malloc(sizeof(struct TestFindPeer)); |
1533 | /* If we have sent requests, choose peers with a low number of connections to send requests from */ | 1657 | /* If we have sent requests, choose peers with a low number of connections to send requests from */ |
1534 | peer_count = GNUNET_CONTAINER_heap_remove_root(find_peer_ctx->peer_min_heap); | 1658 | peer_count |
1659 | = GNUNET_CONTAINER_heap_remove_root (find_peer_ctx->peer_min_heap); | ||
1535 | GNUNET_assert(peer_count != NULL); | 1660 | GNUNET_assert(peer_count != NULL); |
1536 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending find peer request from peer with %u connections\n", peer_count->count); | 1661 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1537 | GNUNET_CONTAINER_multihashmap_remove(find_peer_ctx->peer_hash, &peer_count->peer_id.hashPubKey, peer_count); | 1662 | "Sending find peer request from peer with %u connections\n", |
1538 | test_find_peer->daemon = GNUNET_TESTING_daemon_get_by_id(pg, &peer_count->peer_id); | 1663 | peer_count->count); |
1664 | GNUNET_CONTAINER_multihashmap_remove (find_peer_ctx->peer_hash, | ||
1665 | &peer_count->peer_id.hashPubKey, | ||
1666 | peer_count); | ||
1667 | test_find_peer->daemon | ||
1668 | = GNUNET_TESTING_daemon_get_by_id (pg, &peer_count->peer_id); | ||
1539 | GNUNET_assert(test_find_peer->daemon != NULL); | 1669 | GNUNET_assert(test_find_peer->daemon != NULL); |
1540 | test_find_peer->find_peer_context = find_peer_ctx; | 1670 | test_find_peer->find_peer_context = find_peer_ctx; |
1541 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(find_peer_offset, i), &send_find_peer_request, test_find_peer); | 1671 | GNUNET_SCHEDULER_add_delayed ( |
1672 | GNUNET_TIME_relative_multiply ( | ||
1673 | find_peer_offset, | ||
1674 | i), | ||
1675 | &send_find_peer_request, test_find_peer); | ||
1542 | } | 1676 | } |
1543 | 1677 | ||
1544 | if ((find_peer_ctx->peer_hash == NULL) && (find_peer_ctx->peer_min_heap == NULL)) | 1678 | if ((find_peer_ctx->peer_hash == NULL) && (find_peer_ctx->peer_min_heap |
1679 | == NULL)) | ||
1545 | { | 1680 | { |
1546 | find_peer_ctx->peer_hash = GNUNET_CONTAINER_multihashmap_create(num_peers); | 1681 | find_peer_ctx->peer_hash |
1547 | find_peer_ctx->peer_min_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); | 1682 | = GNUNET_CONTAINER_multihashmap_create (num_peers); |
1683 | find_peer_ctx->peer_min_heap | ||
1684 | = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); | ||
1548 | } | 1685 | } |
1549 | else | 1686 | else |
1550 | { | 1687 | { |
1551 | GNUNET_CONTAINER_multihashmap_iterate(find_peer_ctx->peer_hash, &remove_peer_count, find_peer_ctx); | 1688 | GNUNET_CONTAINER_multihashmap_iterate (find_peer_ctx->peer_hash, |
1552 | GNUNET_CONTAINER_multihashmap_destroy(find_peer_ctx->peer_hash); | 1689 | &remove_peer_count, find_peer_ctx); |
1553 | find_peer_ctx->peer_hash = GNUNET_CONTAINER_multihashmap_create(num_peers); | 1690 | GNUNET_CONTAINER_multihashmap_destroy (find_peer_ctx->peer_hash); |
1691 | find_peer_ctx->peer_hash | ||
1692 | = GNUNET_CONTAINER_multihashmap_create (num_peers); | ||
1554 | } | 1693 | } |
1555 | 1694 | ||
1556 | GNUNET_assert(0 == GNUNET_CONTAINER_multihashmap_size(find_peer_ctx->peer_hash)); | 1695 | GNUNET_assert(0 == GNUNET_CONTAINER_multihashmap_size(find_peer_ctx->peer_hash)); |
1557 | GNUNET_assert(0 == GNUNET_CONTAINER_heap_get_size(find_peer_ctx->peer_min_heap)); | 1696 | GNUNET_assert(0 == GNUNET_CONTAINER_heap_get_size(find_peer_ctx->peer_min_heap)); |
1558 | } | 1697 | } |
1559 | 1698 | ||
1560 | static void schedule_churn_get_topology (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 1699 | static void |
1700 | schedule_churn_get_topology(void *cls, | ||
1701 | const struct GNUNET_SCHEDULER_TaskContext * tc) | ||
1561 | { | 1702 | { |
1562 | struct FindPeerContext *find_peer_context = cls; | 1703 | struct FindPeerContext *find_peer_context = cls; |
1563 | GNUNET_TESTING_get_topology (pg, &count_peers_churn_cb, find_peer_context); | 1704 | GNUNET_TESTING_get_topology (pg, &count_peers_churn_cb, find_peer_context); |
@@ -1569,7 +1710,8 @@ static void schedule_churn_get_topology (void *cls, const struct GNUNET_SCHEDULE | |||
1569 | * @param cls closure unused | 1710 | * @param cls closure unused |
1570 | * @param emsg NULL on success, or a printable error on failure | 1711 | * @param emsg NULL on success, or a printable error on failure |
1571 | */ | 1712 | */ |
1572 | static void churn_complete (void *cls, const char *emsg) | 1713 | static void |
1714 | churn_complete(void *cls, const char *emsg) | ||
1573 | { | 1715 | { |
1574 | struct FindPeerContext *find_peer_context = cls; | 1716 | struct FindPeerContext *find_peer_context = cls; |
1575 | struct PeerCount *peer_count; | 1717 | struct PeerCount *peer_count; |
@@ -1581,8 +1723,9 @@ static void churn_complete (void *cls, const char *emsg) | |||
1581 | 1723 | ||
1582 | if (emsg != NULL) | 1724 | if (emsg != NULL) |
1583 | { | 1725 | { |
1584 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Ending test, churning of peers failed with error `%s'", emsg); | 1726 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1585 | GNUNET_SCHEDULER_add_now(&end_badly, (void *)emsg); | 1727 | "Ending test, churning of peers failed with error `%s'", emsg); |
1728 | GNUNET_SCHEDULER_add_now (&end_badly, (void *) emsg); | ||
1586 | return; | 1729 | return; |
1587 | } | 1730 | } |
1588 | 1731 | ||
@@ -1593,49 +1736,80 @@ static void churn_complete (void *cls, const char *emsg) | |||
1593 | */ | 1736 | */ |
1594 | if (find_peer_context != NULL) | 1737 | if (find_peer_context != NULL) |
1595 | { | 1738 | { |
1596 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "We have churned on some peers, so we must schedule find peer requests for them!\n"); | 1739 | GNUNET_log ( |
1740 | GNUNET_ERROR_TYPE_WARNING, | ||
1741 | "We have churned on some peers, so we must schedule find peer requests for them!\n"); | ||
1597 | count_added = 0; | 1742 | count_added = 0; |
1598 | for (i = 0; i < num_peers; i ++) | 1743 | for (i = 0; i < num_peers; i++) |
1599 | { | 1744 | { |
1600 | temp_daemon = GNUNET_TESTING_daemon_get(pg, i); | 1745 | temp_daemon = GNUNET_TESTING_daemon_get (pg, i); |
1601 | if (GNUNET_YES == GNUNET_TESTING_daemon_running(temp_daemon)) | 1746 | if (GNUNET_YES == GNUNET_TESTING_daemon_running (temp_daemon)) |
1602 | { | 1747 | { |
1603 | peer_count = GNUNET_malloc (sizeof(struct PeerCount)); | 1748 | peer_count = GNUNET_malloc (sizeof(struct PeerCount)); |
1604 | memcpy(&peer_count->peer_id, &temp_daemon->id, sizeof(struct GNUNET_PeerIdentity)); | 1749 | memcpy (&peer_count->peer_id, &temp_daemon->id, |
1750 | sizeof(struct GNUNET_PeerIdentity)); | ||
1605 | GNUNET_assert(peer_count->count == 0); | 1751 | GNUNET_assert(peer_count->count == 0); |
1606 | peer_count->heap_node = GNUNET_CONTAINER_heap_insert(find_peer_context->peer_min_heap, peer_count, peer_count->count); | 1752 | peer_count->heap_node |
1607 | GNUNET_CONTAINER_multihashmap_put(find_peer_context->peer_hash, &temp_daemon->id.hashPubKey, peer_count, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); | 1753 | = GNUNET_CONTAINER_heap_insert ( |
1754 | find_peer_context->peer_min_heap, | ||
1755 | peer_count, peer_count->count); | ||
1756 | GNUNET_CONTAINER_multihashmap_put (find_peer_context->peer_hash, | ||
1757 | &temp_daemon->id.hashPubKey, | ||
1758 | peer_count, | ||
1759 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY); | ||
1608 | count_added++; | 1760 | count_added++; |
1609 | } | 1761 | } |
1610 | } | 1762 | } |
1611 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Added %d peers to heap, total size %d\n", count_added, GNUNET_CONTAINER_heap_get_size(find_peer_context->peer_min_heap)); | 1763 | GNUNET_log ( |
1612 | GNUNET_SCHEDULER_add_delayed(DEFAULT_PEER_DISCONNECT_TIMEOUT, &schedule_churn_get_topology, find_peer_context); | 1764 | GNUNET_ERROR_TYPE_WARNING, |
1765 | "Added %d peers to heap, total size %d\n", | ||
1766 | count_added, | ||
1767 | GNUNET_CONTAINER_heap_get_size ( | ||
1768 | find_peer_context->peer_min_heap)); | ||
1769 | GNUNET_SCHEDULER_add_delayed (DEFAULT_PEER_DISCONNECT_TIMEOUT, | ||
1770 | &schedule_churn_get_topology, | ||
1771 | find_peer_context); | ||
1613 | } | 1772 | } |
1614 | else | 1773 | else |
1615 | { | 1774 | { |
1616 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Only churned off peers, no find peer requests, scheduling more gets (after allowing time for peers to disconnect properly!)...\n"); | 1775 | GNUNET_log ( |
1776 | GNUNET_ERROR_TYPE_WARNING, | ||
1777 | "Only churned off peers, no find peer requests, scheduling more gets (after allowing time for peers to disconnect properly!)...\n"); | ||
1617 | if (dhtlog_handle != NULL) | 1778 | if (dhtlog_handle != NULL) |
1618 | { | 1779 | { |
1619 | topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext)); | 1780 | topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext)); |
1620 | topo_ctx->cont = &do_get; | 1781 | topo_ctx->cont = &do_get; |
1621 | topo_ctx->cls = all_gets; | 1782 | topo_ctx->cls = all_gets; |
1622 | topo_ctx->timeout = DEFAULT_GET_TIMEOUT; | 1783 | topo_ctx->timeout = DEFAULT_GET_TIMEOUT; |
1623 | topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers); | 1784 | topo_ctx->peers_seen |
1624 | calc_timeout = GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout); | 1785 | = GNUNET_CONTAINER_multihashmap_create (num_peers); |
1625 | calc_timeout = GNUNET_TIME_relative_add(calc_timeout, DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT); | 1786 | calc_timeout = GNUNET_TIME_relative_add (DEFAULT_GET_TIMEOUT, |
1626 | calc_timeout = GNUNET_TIME_relative_add(calc_timeout, DEFAULT_PEER_DISCONNECT_TIMEOUT); | 1787 | all_get_timeout); |
1627 | die_task = GNUNET_SCHEDULER_add_delayed (calc_timeout, | 1788 | calc_timeout |
1628 | &end_badly, "from do gets (churn_complete)"); | 1789 | = GNUNET_TIME_relative_add (calc_timeout, |
1629 | GNUNET_SCHEDULER_add_delayed(DEFAULT_PEER_DISCONNECT_TIMEOUT, &capture_current_topology, topo_ctx); | 1790 | DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT); |
1630 | dhtlog_handle->insert_round(DHT_ROUND_GET, rounds_finished); | 1791 | calc_timeout |
1792 | = GNUNET_TIME_relative_add (calc_timeout, | ||
1793 | DEFAULT_PEER_DISCONNECT_TIMEOUT); | ||
1794 | die_task | ||
1795 | = GNUNET_SCHEDULER_add_delayed (calc_timeout, &end_badly, | ||
1796 | "from do gets (churn_complete)"); | ||
1797 | GNUNET_SCHEDULER_add_delayed (DEFAULT_PEER_DISCONNECT_TIMEOUT, | ||
1798 | &capture_current_topology, topo_ctx); | ||
1799 | dhtlog_handle->insert_round (DHT_ROUND_GET, rounds_finished); | ||
1631 | } | 1800 | } |
1632 | else | 1801 | else |
1633 | { | 1802 | { |
1634 | calc_timeout = GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout); | 1803 | calc_timeout = GNUNET_TIME_relative_add (DEFAULT_GET_TIMEOUT, |
1635 | calc_timeout = GNUNET_TIME_relative_add(calc_timeout, DEFAULT_PEER_DISCONNECT_TIMEOUT); | 1804 | all_get_timeout); |
1636 | die_task = GNUNET_SCHEDULER_add_delayed (calc_timeout, | 1805 | calc_timeout |
1637 | &end_badly, "from do gets (churn_complete)"); | 1806 | = GNUNET_TIME_relative_add (calc_timeout, |
1638 | GNUNET_SCHEDULER_add_delayed(DEFAULT_PEER_DISCONNECT_TIMEOUT, &do_get, all_gets); | 1807 | DEFAULT_PEER_DISCONNECT_TIMEOUT); |
1808 | die_task | ||
1809 | = GNUNET_SCHEDULER_add_delayed (calc_timeout, &end_badly, | ||
1810 | "from do gets (churn_complete)"); | ||
1811 | GNUNET_SCHEDULER_add_delayed (DEFAULT_PEER_DISCONNECT_TIMEOUT, | ||
1812 | &do_get, all_gets); | ||
1639 | } | 1813 | } |
1640 | } | 1814 | } |
1641 | } | 1815 | } |
@@ -1650,7 +1824,7 @@ static void churn_complete (void *cls, const char *emsg) | |||
1650 | * @param tc task context (unused) | 1824 | * @param tc task context (unused) |
1651 | */ | 1825 | */ |
1652 | static void | 1826 | static void |
1653 | churn_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 1827 | churn_peers(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
1654 | { | 1828 | { |
1655 | unsigned int count_running; | 1829 | unsigned int count_running; |
1656 | unsigned int churn_up; | 1830 | unsigned int churn_up; |
@@ -1659,28 +1833,34 @@ churn_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1659 | struct FindPeerContext *find_peer_context; | 1833 | struct FindPeerContext *find_peer_context; |
1660 | 1834 | ||
1661 | churn_up = churn_down = 0; | 1835 | churn_up = churn_down = 0; |
1662 | count_running = GNUNET_TESTING_daemons_running(pg); | 1836 | count_running = GNUNET_TESTING_daemons_running (pg); |
1663 | if (count_running > churn_array[current_churn_round]) | 1837 | if (count_running > churn_array[current_churn_round]) |
1664 | churn_down = count_running - churn_array[current_churn_round]; | 1838 | churn_down = count_running - churn_array[current_churn_round]; |
1665 | else if (count_running < churn_array[current_churn_round]) | 1839 | else if (count_running < churn_array[current_churn_round]) |
1666 | churn_up = churn_array[current_churn_round] - count_running; | 1840 | churn_up = churn_array[current_churn_round] - count_running; |
1667 | else | 1841 | else |
1668 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Not churning any peers, topology unchanged.\n"); | 1842 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1843 | "Not churning any peers, topology unchanged.\n"); | ||
1669 | 1844 | ||
1670 | if (churn_up > num_peers - count_running) | 1845 | if (churn_up > num_peers - count_running) |
1671 | { | 1846 | { |
1672 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Churn file specified %u peers (up); only have %u!", churn_array[current_churn_round], num_peers); | 1847 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1848 | "Churn file specified %u peers (up); only have %u!", | ||
1849 | churn_array[current_churn_round], num_peers); | ||
1673 | churn_up = num_peers - count_running; | 1850 | churn_up = num_peers - count_running; |
1674 | } | 1851 | } |
1675 | else if (churn_down > count_running) | 1852 | else if (churn_down > count_running) |
1676 | { | 1853 | { |
1677 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Churn file specified %u peers (down); only have %u!", churn_array[current_churn_round], count_running); | 1854 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1678 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "This will leave NO peers running (mistake in churn configuration?)!"); | 1855 | "Churn file specified %u peers (down); only have %u!", |
1856 | churn_array[current_churn_round], count_running); | ||
1857 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | ||
1858 | "This will leave NO peers running (mistake in churn configuration?)!"); | ||
1679 | churn_down = count_running; | 1859 | churn_down = count_running; |
1680 | } | 1860 | } |
1681 | //timeout = GNUNET_TIME_relative_multiply(seconds_per_peer_start, churn_up > 0 ? churn_up : churn_down); | 1861 | //timeout = GNUNET_TIME_relative_multiply(seconds_per_peer_start, churn_up > 0 ? churn_up : churn_down); |
1682 | //timeout = GNUNET_TIME_relative_multiply (seconds_per_peer_start, churn_up > 0 ? churn_up : churn_down); | 1862 | //timeout = GNUNET_TIME_relative_multiply (seconds_per_peer_start, churn_up > 0 ? churn_up : churn_down); |
1683 | timeout = GNUNET_TIME_relative_multiply(DEFAULT_TIMEOUT, 2); /* FIXME: Lack of intelligent choice here */ | 1863 | timeout = GNUNET_TIME_relative_multiply (DEFAULT_TIMEOUT, 2); /* FIXME: Lack of intelligent choice here */ |
1684 | find_peer_context = NULL; | 1864 | find_peer_context = NULL; |
1685 | if (churn_up > 0) /* Only need to do find peer requests if we turned new peers on */ | 1865 | if (churn_up > 0) /* Only need to do find peer requests if we turned new peers on */ |
1686 | { | 1866 | { |
@@ -1688,13 +1868,19 @@ churn_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1688 | find_peer_context->count_peers_cb = &count_peers_churn_cb; | 1868 | find_peer_context->count_peers_cb = &count_peers_churn_cb; |
1689 | find_peer_context->previous_peers = 0; | 1869 | find_peer_context->previous_peers = 0; |
1690 | find_peer_context->current_peers = 0; | 1870 | find_peer_context->current_peers = 0; |
1691 | find_peer_context->endtime = GNUNET_TIME_relative_to_absolute(timeout); | 1871 | find_peer_context->endtime = GNUNET_TIME_relative_to_absolute (timeout); |
1692 | find_peer_context->peer_hash = GNUNET_CONTAINER_multihashmap_create(num_peers); | 1872 | find_peer_context->peer_hash |
1693 | find_peer_context->peer_min_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); | 1873 | = GNUNET_CONTAINER_multihashmap_create (num_peers); |
1694 | } | 1874 | find_peer_context->peer_min_heap |
1695 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "churn_peers: want %u total, %u running, starting %u, stopping %u\n", | 1875 | = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); |
1696 | churn_array[current_churn_round], count_running, churn_up, churn_down); | 1876 | } |
1697 | GNUNET_TESTING_daemons_churn (pg, churn_down, churn_up, timeout, &churn_complete, find_peer_context); | 1877 | GNUNET_log ( |
1878 | GNUNET_ERROR_TYPE_WARNING, | ||
1879 | "churn_peers: want %u total, %u running, starting %u, stopping %u\n", | ||
1880 | churn_array[current_churn_round], count_running, churn_up, | ||
1881 | churn_down); | ||
1882 | GNUNET_TESTING_daemons_churn (pg, churn_down, churn_up, timeout, | ||
1883 | &churn_complete, find_peer_context); | ||
1698 | current_churn_round++; | 1884 | current_churn_round++; |
1699 | } | 1885 | } |
1700 | 1886 | ||
@@ -1702,7 +1888,7 @@ churn_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1702 | * Task to release DHT handle associated with GET request. | 1888 | * Task to release DHT handle associated with GET request. |
1703 | */ | 1889 | */ |
1704 | static void | 1890 | static void |
1705 | get_stop_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 1891 | get_stop_finished(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
1706 | { | 1892 | { |
1707 | struct TestGetContext *test_get = cls; | 1893 | struct TestGetContext *test_get = cls; |
1708 | struct TopologyIteratorContext *topo_ctx; | 1894 | struct TopologyIteratorContext *topo_ctx; |
@@ -1710,7 +1896,7 @@ get_stop_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1710 | /* The dht_handle may be null if this get was scheduled from a down peer */ | 1896 | /* The dht_handle may be null if this get was scheduled from a down peer */ |
1711 | if (test_get->dht_handle != NULL) | 1897 | if (test_get->dht_handle != NULL) |
1712 | { | 1898 | { |
1713 | GNUNET_DHT_disconnect(test_get->dht_handle); | 1899 | GNUNET_DHT_disconnect (test_get->dht_handle); |
1714 | outstanding_gets--; /* GET is really finished */ | 1900 | outstanding_gets--; /* GET is really finished */ |
1715 | test_get->dht_handle = NULL; | 1901 | test_get->dht_handle = NULL; |
1716 | } | 1902 | } |
@@ -1718,22 +1904,32 @@ get_stop_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1718 | /* Reset the uid (which item to search for) and the daemon (which peer to search from) for later get request iterations */ | 1904 | /* Reset the uid (which item to search for) and the daemon (which peer to search from) for later get request iterations */ |
1719 | if (get_from_same == GNUNET_NO) | 1905 | if (get_from_same == GNUNET_NO) |
1720 | { | 1906 | { |
1721 | test_get->uid = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_puts); | 1907 | test_get->uid = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, |
1722 | test_get->daemon = GNUNET_TESTING_daemon_get(pg, GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers)); | 1908 | num_puts); |
1909 | test_get->daemon | ||
1910 | = GNUNET_TESTING_daemon_get ( | ||
1911 | pg, | ||
1912 | GNUNET_CRYPTO_random_u32 ( | ||
1913 | GNUNET_CRYPTO_QUALITY_WEAK, | ||
1914 | num_peers)); | ||
1723 | } | 1915 | } |
1724 | 1916 | ||
1725 | #if VERBOSE > 1 | 1917 | #if VERBOSE > 1 |
1726 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%d gets succeeded, %d gets failed!\n", gets_completed, gets_failed); | 1918 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%d gets succeeded, %d gets failed!\n", gets_completed, gets_failed); |
1727 | #endif | 1919 | #endif |
1728 | update_meter(get_meter); | 1920 | update_meter (get_meter); |
1729 | if ((gets_completed + gets_failed == num_gets) && (outstanding_gets == 0)) | 1921 | if ((gets_completed + gets_failed == num_gets) && (outstanding_gets == 0)) |
1730 | { | 1922 | { |
1731 | fprintf(stderr, "Canceling die task (get_stop_finished) %llu gets completed, %llu gets failed\n", gets_completed, gets_failed); | 1923 | fprintf ( |
1924 | stderr, | ||
1925 | "Canceling die task (get_stop_finished) %llu gets completed, %llu gets failed\n", | ||
1926 | gets_completed, gets_failed); | ||
1732 | if ((GNUNET_YES == dhtlog_minimal) && (NULL != dhtlog_handle)) | 1927 | if ((GNUNET_YES == dhtlog_minimal) && (NULL != dhtlog_handle)) |
1733 | dhtlog_handle->insert_round_details(DHT_ROUND_GET, rounds_finished, num_gets, gets_completed); | 1928 | dhtlog_handle->insert_round_details (DHT_ROUND_GET, rounds_finished, |
1734 | GNUNET_SCHEDULER_cancel(die_task); | 1929 | num_gets, gets_completed); |
1735 | reset_meter(put_meter); | 1930 | GNUNET_SCHEDULER_cancel (die_task); |
1736 | reset_meter(get_meter); | 1931 | reset_meter (put_meter); |
1932 | reset_meter (get_meter); | ||
1737 | /** | 1933 | /** |
1738 | * Handle all cases: | 1934 | * Handle all cases: |
1739 | * 1) Testing is completely finished, call the topology iteration dealy and die | 1935 | * 1) Testing is completely finished, call the topology iteration dealy and die |
@@ -1746,47 +1942,79 @@ get_stop_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1746 | { | 1942 | { |
1747 | topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext)); | 1943 | topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext)); |
1748 | topo_ctx->cont = &log_dht_statistics; | 1944 | topo_ctx->cont = &log_dht_statistics; |
1749 | topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers); | 1945 | topo_ctx->peers_seen |
1750 | GNUNET_SCHEDULER_add_now(&capture_current_topology, topo_ctx); | 1946 | = GNUNET_CONTAINER_multihashmap_create (num_peers); |
1947 | GNUNET_SCHEDULER_add_now (&capture_current_topology, topo_ctx); | ||
1751 | } | 1948 | } |
1752 | else | 1949 | else |
1753 | GNUNET_SCHEDULER_add_now (&finish_testing, NULL); | 1950 | GNUNET_SCHEDULER_add_now (&finish_testing, NULL); |
1754 | } | 1951 | } |
1755 | else if (current_churn_round < churns_per_round * (rounds_finished + 1)) /* Do next round of churn */ | 1952 | else if (current_churn_round < churns_per_round * (rounds_finished + 1)) /* Do next round of churn */ |
1756 | { | 1953 | { |
1757 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Current churn round %u, real round %u, scheduling next round of churn.\n", current_churn_round, rounds_finished + 1); | 1954 | GNUNET_log ( |
1955 | GNUNET_ERROR_TYPE_WARNING, | ||
1956 | "Current churn round %u, real round %u, scheduling next round of churn.\n", | ||
1957 | current_churn_round, rounds_finished + 1); | ||
1758 | gets_completed = 0; | 1958 | gets_completed = 0; |
1759 | gets_failed = 0; | 1959 | gets_failed = 0; |
1760 | 1960 | ||
1761 | if (dhtlog_handle != NULL) | 1961 | if (dhtlog_handle != NULL) |
1762 | dhtlog_handle->insert_round(DHT_ROUND_CHURN, rounds_finished); | 1962 | dhtlog_handle->insert_round (DHT_ROUND_CHURN, rounds_finished); |
1763 | 1963 | ||
1764 | GNUNET_SCHEDULER_add_now(&churn_peers, NULL); | 1964 | GNUNET_SCHEDULER_add_now (&churn_peers, NULL); |
1765 | } | 1965 | } |
1766 | else if (rounds_finished < total_rounds - 1) /* Start a new complete round */ | 1966 | else if (rounds_finished < total_rounds - 1) /* Start a new complete round */ |
1767 | { | 1967 | { |
1768 | rounds_finished++; | 1968 | rounds_finished++; |
1769 | gets_completed = 0; | 1969 | gets_completed = 0; |
1770 | gets_failed = 0; | 1970 | gets_failed = 0; |
1771 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Round %u of %llu finished, scheduling next round.\n", rounds_finished, total_rounds); | 1971 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
1972 | "Round %u of %llu finished, scheduling next round.\n", | ||
1973 | rounds_finished, total_rounds); | ||
1772 | 1974 | ||
1773 | /** We reset the peer daemon for puts and gets on each disconnect, so all we need to do is start another round! */ | 1975 | /** We reset the peer daemon for puts and gets on each disconnect, so all we need to do is start another round! */ |
1774 | if (GNUNET_YES == in_dht_replication) /* Replication done in DHT, don't redo puts! */ | 1976 | if (GNUNET_YES == in_dht_replication) /* Replication done in DHT, don't redo puts! */ |
1775 | { | 1977 | { |
1776 | if (dhtlog_handle != NULL) | 1978 | if (dhtlog_handle != NULL) |
1777 | dhtlog_handle->insert_round(DHT_ROUND_GET, rounds_finished); | 1979 | dhtlog_handle->insert_round (DHT_ROUND_GET, rounds_finished); |
1778 | 1980 | ||
1779 | die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT), | 1981 | die_task |
1780 | &end_badly, "from do gets (next round)"); | 1982 | = GNUNET_SCHEDULER_add_delayed ( |
1781 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), &do_get, all_gets); | 1983 | GNUNET_TIME_relative_add ( |
1984 | GNUNET_TIME_relative_add ( | ||
1985 | GNUNET_TIME_relative_multiply ( | ||
1986 | GNUNET_TIME_UNIT_SECONDS, | ||
1987 | round_delay), | ||
1988 | all_get_timeout), | ||
1989 | DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT), | ||
1990 | &end_badly, | ||
1991 | "from do gets (next round)"); | ||
1992 | GNUNET_SCHEDULER_add_delayed ( | ||
1993 | GNUNET_TIME_relative_multiply ( | ||
1994 | GNUNET_TIME_UNIT_SECONDS, | ||
1995 | round_delay), | ||
1996 | &do_get, all_gets); | ||
1782 | } | 1997 | } |
1783 | else | 1998 | else |
1784 | { | 1999 | { |
1785 | if (dhtlog_handle != NULL) | 2000 | if (dhtlog_handle != NULL) |
1786 | dhtlog_handle->insert_round(DHT_ROUND_NORMAL, rounds_finished); | 2001 | dhtlog_handle->insert_round (DHT_ROUND_NORMAL, rounds_finished); |
1787 | die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, num_puts * 2)), | 2002 | die_task |
1788 | &end_badly, "from do puts"); | 2003 | = GNUNET_SCHEDULER_add_delayed ( |
1789 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, round_delay), &do_put, all_puts); | 2004 | GNUNET_TIME_relative_add ( |
2005 | GNUNET_TIME_relative_multiply ( | ||
2006 | GNUNET_TIME_UNIT_SECONDS, | ||
2007 | round_delay), | ||
2008 | GNUNET_TIME_relative_multiply ( | ||
2009 | GNUNET_TIME_UNIT_SECONDS, | ||
2010 | num_puts | ||
2011 | * 2)), | ||
2012 | &end_badly, "from do puts"); | ||
2013 | GNUNET_SCHEDULER_add_delayed ( | ||
2014 | GNUNET_TIME_relative_multiply ( | ||
2015 | GNUNET_TIME_UNIT_SECONDS, | ||
2016 | round_delay), | ||
2017 | &do_put, all_puts); | ||
1790 | } | 2018 | } |
1791 | } | 2019 | } |
1792 | } | 2020 | } |
@@ -1796,7 +2024,7 @@ get_stop_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1796 | * Task to release get handle. | 2024 | * Task to release get handle. |
1797 | */ | 2025 | */ |
1798 | static void | 2026 | static void |
1799 | get_stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 2027 | get_stop_task(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
1800 | { | 2028 | { |
1801 | struct TestGetContext *test_get = cls; | 2029 | struct TestGetContext *test_get = cls; |
1802 | 2030 | ||
@@ -1806,7 +2034,7 @@ get_stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1806 | cumulative_successful_gets++; | 2034 | cumulative_successful_gets++; |
1807 | 2035 | ||
1808 | GNUNET_assert(test_get->get_handle != NULL); | 2036 | GNUNET_assert(test_get->get_handle != NULL); |
1809 | GNUNET_DHT_get_stop(test_get->get_handle); | 2037 | GNUNET_DHT_get_stop (test_get->get_handle); |
1810 | test_get->get_handle = NULL; | 2038 | test_get->get_handle = NULL; |
1811 | test_get->disconnect_task = GNUNET_SCHEDULER_NO_TASK; | 2039 | test_get->disconnect_task = GNUNET_SCHEDULER_NO_TASK; |
1812 | GNUNET_SCHEDULER_add_now (&get_stop_finished, test_get); | 2040 | GNUNET_SCHEDULER_add_now (&get_stop_finished, test_get); |
@@ -1826,25 +2054,23 @@ get_stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1826 | * @param size number of bytes in data | 2054 | * @param size number of bytes in data |
1827 | * @param data pointer to the result data | 2055 | * @param data pointer to the result data |
1828 | */ | 2056 | */ |
1829 | static void | 2057 | static void |
1830 | get_result_iterator (void *cls, | 2058 | get_result_iterator(void *cls, struct GNUNET_TIME_Absolute exp, |
1831 | struct GNUNET_TIME_Absolute exp, | 2059 | const GNUNET_HashCode * key, |
1832 | const GNUNET_HashCode * key, | 2060 | const struct GNUNET_PeerIdentity * const *get_path, |
1833 | const struct GNUNET_PeerIdentity * const *get_path, | 2061 | const struct GNUNET_PeerIdentity * const *put_path, |
1834 | const struct GNUNET_PeerIdentity * const *put_path, | 2062 | enum GNUNET_BLOCK_Type type, size_t size, const void *data) |
1835 | enum GNUNET_BLOCK_Type type, | ||
1836 | size_t size, | ||
1837 | const void *data) | ||
1838 | { | 2063 | { |
1839 | struct TestGetContext *test_get = cls; | 2064 | struct TestGetContext *test_get = cls; |
1840 | 2065 | ||
1841 | if (test_get->succeeded == GNUNET_YES) | 2066 | if (test_get->succeeded == GNUNET_YES) |
1842 | return; /* Get has already been successful, probably ending now */ | 2067 | return; /* Get has already been successful, probably ending now */ |
1843 | 2068 | ||
1844 | if (0 != memcmp(&known_keys[test_get->uid], key, sizeof (GNUNET_HashCode))) /* || (0 != memcmp(original_data, data, sizeof(original_data))))*/ | 2069 | if (0 != memcmp (&known_keys[test_get->uid], key, sizeof(GNUNET_HashCode))) /* || (0 != memcmp(original_data, data, sizeof(original_data))))*/ |
1845 | { | 2070 | { |
1846 | gets_completed++; | 2071 | gets_completed++; |
1847 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Key or data is not the same as was inserted!\n"); | 2072 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
2073 | "Key or data is not the same as was inserted!\n"); | ||
1848 | } | 2074 | } |
1849 | else | 2075 | else |
1850 | { | 2076 | { |
@@ -1854,24 +2080,23 @@ get_result_iterator (void *cls, | |||
1854 | #if VERBOSE > 1 | 2080 | #if VERBOSE > 1 |
1855 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received correct GET response!\n"); | 2081 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received correct GET response!\n"); |
1856 | #endif | 2082 | #endif |
1857 | GNUNET_SCHEDULER_cancel(test_get->disconnect_task); | 2083 | GNUNET_SCHEDULER_cancel (test_get->disconnect_task); |
1858 | GNUNET_SCHEDULER_add_continuation(&get_stop_task, test_get, GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 2084 | GNUNET_SCHEDULER_add_continuation (&get_stop_task, test_get, |
2085 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | ||
1859 | } | 2086 | } |
1860 | 2087 | ||
1861 | |||
1862 | |||
1863 | /** | 2088 | /** |
1864 | * Set up some data, and call API PUT function | 2089 | * Set up some data, and call API PUT function |
1865 | */ | 2090 | */ |
1866 | static void | 2091 | static void |
1867 | do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 2092 | do_get(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
1868 | { | 2093 | { |
1869 | struct TestGetContext *test_get = cls; | 2094 | struct TestGetContext *test_get = cls; |
1870 | 2095 | ||
1871 | if (num_gets == 0) | 2096 | if (num_gets == 0) |
1872 | { | 2097 | { |
1873 | GNUNET_SCHEDULER_cancel(die_task); | 2098 | GNUNET_SCHEDULER_cancel (die_task); |
1874 | GNUNET_SCHEDULER_add_now(&finish_testing, NULL); | 2099 | GNUNET_SCHEDULER_add_now (&finish_testing, NULL); |
1875 | } | 2100 | } |
1876 | 2101 | ||
1877 | if (test_get == NULL) | 2102 | if (test_get == NULL) |
@@ -1880,9 +2105,10 @@ do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1880 | /* Set this here in case we are re-running gets */ | 2105 | /* Set this here in case we are re-running gets */ |
1881 | test_get->succeeded = GNUNET_NO; | 2106 | test_get->succeeded = GNUNET_NO; |
1882 | 2107 | ||
1883 | if (GNUNET_YES != GNUNET_TESTING_daemon_running(test_get->daemon)) /* If the peer has been churned off, don't try issuing request from it! */ | 2108 | if (GNUNET_YES != GNUNET_TESTING_daemon_running (test_get->daemon)) /* If the peer has been churned off, don't try issuing request from it! */ |
1884 | { | 2109 | { |
1885 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peer we should issue get request from is down, skipping.\n"); | 2110 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2111 | "Peer we should issue get request from is down, skipping.\n"); | ||
1886 | gets_failed++; | 2112 | gets_failed++; |
1887 | GNUNET_SCHEDULER_add_now (&get_stop_finished, test_get); | 2113 | GNUNET_SCHEDULER_add_now (&get_stop_finished, test_get); |
1888 | GNUNET_SCHEDULER_add_now (&do_get, test_get->next); | 2114 | GNUNET_SCHEDULER_add_now (&do_get, test_get->next); |
@@ -1892,34 +2118,37 @@ do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1892 | /* Check if more gets are outstanding than should be */ | 2118 | /* Check if more gets are outstanding than should be */ |
1893 | if (outstanding_gets > max_outstanding_gets) | 2119 | if (outstanding_gets > max_outstanding_gets) |
1894 | { | 2120 | { |
1895 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 200), &do_get, test_get); | 2121 | GNUNET_SCHEDULER_add_delayed ( |
2122 | GNUNET_TIME_relative_multiply ( | ||
2123 | GNUNET_TIME_UNIT_MILLISECONDS, | ||
2124 | 200), | ||
2125 | &do_get, test_get); | ||
1896 | return; | 2126 | return; |
1897 | } | 2127 | } |
1898 | 2128 | ||
1899 | /* Connect to the first peer's DHT */ | 2129 | /* Connect to the first peer's DHT */ |
1900 | test_get->dht_handle = GNUNET_DHT_connect(test_get->daemon->cfg, 10); | 2130 | test_get->dht_handle = GNUNET_DHT_connect (test_get->daemon->cfg, 10); |
1901 | GNUNET_assert(test_get->dht_handle != NULL); | 2131 | GNUNET_assert(test_get->dht_handle != NULL); |
1902 | outstanding_gets++; | 2132 | outstanding_gets++; |
1903 | 2133 | ||
1904 | cumulative_num_gets++; | 2134 | cumulative_num_gets++; |
1905 | /* Insert the data at the first peer */ | 2135 | /* Insert the data at the first peer */ |
1906 | test_get->get_handle = GNUNET_DHT_get_start(test_get->dht_handle, | 2136 | test_get->get_handle = GNUNET_DHT_get_start (test_get->dht_handle, get_delay, |
1907 | get_delay, | 2137 | GNUNET_BLOCK_TYPE_TEST, |
1908 | GNUNET_BLOCK_TYPE_TEST, | 2138 | &known_keys[test_get->uid], |
1909 | &known_keys[test_get->uid], | 2139 | get_replication, |
1910 | get_replication, | 2140 | GNUNET_DHT_RO_NONE, NULL, 0, |
1911 | GNUNET_DHT_RO_NONE, | 2141 | NULL, 0, &get_result_iterator, |
1912 | NULL, 0, | 2142 | test_get); |
1913 | NULL, 0, | ||
1914 | &get_result_iterator, | ||
1915 | test_get); | ||
1916 | 2143 | ||
1917 | #if VERBOSE > 1 | 2144 | #if VERBOSE > 1 |
1918 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting get for uid %u from peer %s\n", | 2145 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting get for uid %u from peer %s\n", |
1919 | test_get->uid, | 2146 | test_get->uid, |
1920 | test_get->daemon->shortname); | 2147 | test_get->daemon->shortname); |
1921 | #endif | 2148 | #endif |
1922 | test_get->disconnect_task = GNUNET_SCHEDULER_add_delayed(get_timeout, &get_stop_task, test_get); | 2149 | test_get->disconnect_task = GNUNET_SCHEDULER_add_delayed (get_timeout, |
2150 | &get_stop_task, | ||
2151 | test_get); | ||
1923 | 2152 | ||
1924 | /* Schedule the next request in the linked list of get requests */ | 2153 | /* Schedule the next request in the linked list of get requests */ |
1925 | GNUNET_SCHEDULER_add_now (&do_get, test_get->next); | 2154 | GNUNET_SCHEDULER_add_now (&do_get, test_get->next); |
@@ -1930,7 +2159,7 @@ do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1930 | * Schedule the GET request for some time in the future. | 2159 | * Schedule the GET request for some time in the future. |
1931 | */ | 2160 | */ |
1932 | static void | 2161 | static void |
1933 | put_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 2162 | put_finished(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
1934 | { | 2163 | { |
1935 | struct TestPutContext *test_put = cls; | 2164 | struct TestPutContext *test_put = cls; |
1936 | struct TopologyIteratorContext *topo_ctx; | 2165 | struct TopologyIteratorContext *topo_ctx; |
@@ -1938,15 +2167,21 @@ put_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1938 | puts_completed++; | 2167 | puts_completed++; |
1939 | 2168 | ||
1940 | if (tc->reason == GNUNET_SCHEDULER_REASON_TIMEOUT) | 2169 | if (tc->reason == GNUNET_SCHEDULER_REASON_TIMEOUT) |
1941 | fprintf(stderr, "PUT Request failed!\n"); | 2170 | fprintf (stderr, "PUT Request failed!\n"); |
1942 | 2171 | ||
1943 | /* Reset the daemon (which peer to insert at) for later put request iterations */ | 2172 | /* Reset the daemon (which peer to insert at) for later put request iterations */ |
1944 | if (replicate_same == GNUNET_NO) | 2173 | if (replicate_same == GNUNET_NO) |
1945 | test_put->daemon = GNUNET_TESTING_daemon_get(pg, GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers)); | 2174 | test_put->daemon |
1946 | 2175 | = GNUNET_TESTING_daemon_get ( | |
1947 | GNUNET_SCHEDULER_cancel(test_put->disconnect_task); | 2176 | pg, |
1948 | test_put->disconnect_task = GNUNET_SCHEDULER_add_now(&put_disconnect_task, test_put); | 2177 | GNUNET_CRYPTO_random_u32 ( |
1949 | if (GNUNET_YES == update_meter(put_meter)) | 2178 | GNUNET_CRYPTO_QUALITY_WEAK, |
2179 | num_peers)); | ||
2180 | |||
2181 | GNUNET_SCHEDULER_cancel (test_put->disconnect_task); | ||
2182 | test_put->disconnect_task = GNUNET_SCHEDULER_add_now (&put_disconnect_task, | ||
2183 | test_put); | ||
2184 | if (GNUNET_YES == update_meter (put_meter)) | ||
1950 | { | 2185 | { |
1951 | GNUNET_assert(outstanding_puts == 0); | 2186 | GNUNET_assert(outstanding_puts == 0); |
1952 | GNUNET_SCHEDULER_cancel (die_task); | 2187 | GNUNET_SCHEDULER_cancel (die_task); |
@@ -1956,17 +2191,30 @@ put_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1956 | topo_ctx->cont = &do_get; | 2191 | topo_ctx->cont = &do_get; |
1957 | topo_ctx->cls = all_gets; | 2192 | topo_ctx->cls = all_gets; |
1958 | topo_ctx->timeout = DEFAULT_GET_TIMEOUT; | 2193 | topo_ctx->timeout = DEFAULT_GET_TIMEOUT; |
1959 | topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers); | 2194 | topo_ctx->peers_seen |
1960 | die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT), | 2195 | = GNUNET_CONTAINER_multihashmap_create (num_peers); |
1961 | &end_badly, "from do gets (put finished)"); | 2196 | die_task |
1962 | GNUNET_SCHEDULER_add_now(&capture_current_topology, topo_ctx); | 2197 | = GNUNET_SCHEDULER_add_delayed ( |
2198 | GNUNET_TIME_relative_add ( | ||
2199 | GNUNET_TIME_relative_add ( | ||
2200 | DEFAULT_GET_TIMEOUT, | ||
2201 | all_get_timeout), | ||
2202 | DEFAULT_TOPOLOGY_CAPTURE_TIMEOUT), | ||
2203 | &end_badly, | ||
2204 | "from do gets (put finished)"); | ||
2205 | GNUNET_SCHEDULER_add_now (&capture_current_topology, topo_ctx); | ||
1963 | } | 2206 | } |
1964 | else | 2207 | else |
1965 | { | 2208 | { |
1966 | fprintf(stderr, "Scheduling die task (put finished)\n"); | 2209 | fprintf (stderr, "Scheduling die task (put finished)\n"); |
1967 | die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_add(DEFAULT_GET_TIMEOUT, all_get_timeout), | 2210 | die_task |
1968 | &end_badly, "from do gets (put finished)"); | 2211 | = GNUNET_SCHEDULER_add_delayed ( |
1969 | GNUNET_SCHEDULER_add_delayed(DEFAULT_GET_TIMEOUT, &do_get, all_gets); | 2212 | GNUNET_TIME_relative_add ( |
2213 | DEFAULT_GET_TIMEOUT, | ||
2214 | all_get_timeout), | ||
2215 | &end_badly, | ||
2216 | "from do gets (put finished)"); | ||
2217 | GNUNET_SCHEDULER_add_delayed (DEFAULT_GET_TIMEOUT, &do_get, all_gets); | ||
1970 | } | 2218 | } |
1971 | return; | 2219 | return; |
1972 | } | 2220 | } |
@@ -1976,7 +2224,7 @@ put_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1976 | * Set up some data, and call API PUT function | 2224 | * Set up some data, and call API PUT function |
1977 | */ | 2225 | */ |
1978 | static void | 2226 | static void |
1979 | do_put (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 2227 | do_put(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
1980 | { | 2228 | { |
1981 | struct TestPutContext *test_put = cls; | 2229 | struct TestPutContext *test_put = cls; |
1982 | char data[test_data_size]; /* Made up data to store */ | 2230 | char data[test_data_size]; /* Made up data to store */ |
@@ -1986,59 +2234,69 @@ do_put (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
1986 | if (test_put == NULL) | 2234 | if (test_put == NULL) |
1987 | return; /* End of list */ | 2235 | return; /* End of list */ |
1988 | 2236 | ||
1989 | if (GNUNET_YES != GNUNET_TESTING_daemon_running(test_put->daemon)) /* If the peer has been churned off, don't try issuing request from it! */ | 2237 | if (GNUNET_YES != GNUNET_TESTING_daemon_running (test_put->daemon)) /* If the peer has been churned off, don't try issuing request from it! */ |
1990 | { | 2238 | { |
1991 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peer we should issue put request at is down, skipping.\n"); | 2239 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1992 | update_meter(put_meter); | 2240 | "Peer we should issue put request at is down, skipping.\n"); |
2241 | update_meter (put_meter); | ||
1993 | GNUNET_SCHEDULER_add_now (&do_put, test_put->next); | 2242 | GNUNET_SCHEDULER_add_now (&do_put, test_put->next); |
1994 | return; | 2243 | return; |
1995 | } | 2244 | } |
1996 | 2245 | ||
1997 | for (i = 0; i < sizeof(data); i++) | 2246 | for (i = 0; i < sizeof(data); i++) |
1998 | { | 2247 | { |
1999 | memset(&data[i], GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, UINT32_MAX), 1); | 2248 | memset (&data[i], GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, |
2249 | UINT32_MAX), 1); | ||
2000 | } | 2250 | } |
2001 | 2251 | ||
2002 | if (outstanding_puts > max_outstanding_puts) | 2252 | if (outstanding_puts > max_outstanding_puts) |
2003 | { | 2253 | { |
2004 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 200), &do_put, test_put); | 2254 | GNUNET_SCHEDULER_add_delayed ( |
2255 | GNUNET_TIME_relative_multiply ( | ||
2256 | GNUNET_TIME_UNIT_MILLISECONDS, | ||
2257 | 200), | ||
2258 | &do_put, test_put); | ||
2005 | return; | 2259 | return; |
2006 | } | 2260 | } |
2007 | 2261 | ||
2008 | #if VERBOSE > 1 | 2262 | #if VERBOSE > 1 |
2009 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting put for uid %u from peer %s\n", | 2263 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting put for uid %u from peer %s\n", |
2010 | test_put->uid, | 2264 | test_put->uid, |
2011 | test_put->daemon->shortname); | 2265 | test_put->daemon->shortname); |
2012 | #endif | 2266 | #endif |
2013 | test_put->dht_handle = GNUNET_DHT_connect(test_put->daemon->cfg, 10); | 2267 | test_put->dht_handle = GNUNET_DHT_connect (test_put->daemon->cfg, 10); |
2014 | 2268 | ||
2015 | GNUNET_assert(test_put->dht_handle != NULL); | 2269 | GNUNET_assert(test_put->dht_handle != NULL); |
2016 | outstanding_puts++; | 2270 | outstanding_puts++; |
2017 | GNUNET_DHT_put(test_put->dht_handle, | 2271 | GNUNET_DHT_put (test_put->dht_handle, &known_keys[test_put->uid], |
2018 | &known_keys[test_put->uid], | 2272 | put_replication, GNUNET_DHT_RO_NONE, GNUNET_BLOCK_TYPE_TEST, |
2019 | put_replication, | 2273 | sizeof(data), data, GNUNET_TIME_UNIT_FOREVER_ABS, put_delay, |
2020 | GNUNET_DHT_RO_NONE, | 2274 | &put_finished, test_put); |
2021 | GNUNET_BLOCK_TYPE_TEST, | 2275 | test_put->disconnect_task |
2022 | sizeof(data), data, | 2276 | = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_get_forever (), |
2023 | GNUNET_TIME_UNIT_FOREVER_ABS, | 2277 | &put_disconnect_task, test_put); |
2024 | put_delay, | 2278 | rand = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 2); |
2025 | &put_finished, test_put); | 2279 | GNUNET_SCHEDULER_add_delayed ( |
2026 | test_put->disconnect_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_get_forever(), &put_disconnect_task, test_put); | 2280 | GNUNET_TIME_relative_multiply ( |
2027 | rand = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 2); | 2281 | GNUNET_TIME_UNIT_SECONDS, |
2028 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, rand), &do_put, test_put->next); | 2282 | rand), &do_put, |
2283 | test_put->next); | ||
2029 | } | 2284 | } |
2030 | 2285 | ||
2031 | static void | 2286 | static void |
2032 | schedule_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc); | 2287 | schedule_find_peer_requests(void *cls, |
2288 | const struct GNUNET_SCHEDULER_TaskContext * tc); | ||
2033 | 2289 | ||
2034 | static void | 2290 | static void |
2035 | setup_malicious_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc); | 2291 | setup_malicious_peers(void *cls, |
2292 | const struct GNUNET_SCHEDULER_TaskContext * tc); | ||
2036 | 2293 | ||
2037 | /** | 2294 | /** |
2038 | * Given a number of total peers and a bucket size, estimate the number of | 2295 | * Given a number of total peers and a bucket size, estimate the number of |
2039 | * connections in a perfect kademlia topology. | 2296 | * connections in a perfect kademlia topology. |
2040 | */ | 2297 | */ |
2041 | static unsigned int connection_estimate(unsigned int peer_count, unsigned int bucket_size) | 2298 | static unsigned int |
2299 | connection_estimate(unsigned int peer_count, unsigned int bucket_size) | ||
2042 | { | 2300 | { |
2043 | unsigned int i; | 2301 | unsigned int i; |
2044 | unsigned int filled; | 2302 | unsigned int filled; |
@@ -2048,71 +2306,77 @@ static unsigned int connection_estimate(unsigned int peer_count, unsigned int bu | |||
2048 | while (i >= bucket_size) | 2306 | while (i >= bucket_size) |
2049 | { | 2307 | { |
2050 | filled++; | 2308 | filled++; |
2051 | i = i/2; | 2309 | i = i / 2; |
2052 | } | 2310 | } |
2053 | filled++; /* Add one filled bucket to account for one "half full" and some miscellaneous */ | 2311 | filled++; /* Add one filled bucket to account for one "half full" and some miscellaneous */ |
2054 | return filled * bucket_size * peer_count; | 2312 | return filled * bucket_size * peer_count; |
2055 | 2313 | ||
2056 | } | 2314 | } |
2057 | 2315 | ||
2058 | |||
2059 | /** | 2316 | /** |
2060 | * Callback for iterating over all the peer connections of a peer group. | 2317 | * Callback for iterating over all the peer connections of a peer group. |
2061 | */ | 2318 | */ |
2062 | static void | 2319 | static void |
2063 | count_peers_cb (void *cls, | 2320 | count_peers_cb(void *cls, const struct GNUNET_PeerIdentity *first, |
2064 | const struct GNUNET_PeerIdentity *first, | 2321 | const struct GNUNET_PeerIdentity *second, const char *emsg) |
2065 | const struct GNUNET_PeerIdentity *second, | ||
2066 | const char *emsg) | ||
2067 | { | 2322 | { |
2068 | struct FindPeerContext *find_peer_context = cls; | 2323 | struct FindPeerContext *find_peer_context = cls; |
2069 | if ((first != NULL) && (second != NULL)) | 2324 | if ((first != NULL) && (second != NULL)) |
2070 | { | 2325 | { |
2071 | add_new_connection(find_peer_context, first, second); | 2326 | add_new_connection (find_peer_context, first, second); |
2072 | find_peer_context->current_peers++; | 2327 | find_peer_context->current_peers++; |
2073 | } | 2328 | } |
2074 | else | 2329 | else |
2075 | { | 2330 | { |
2076 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Peer count finished (%u connections), %u new peers, connection estimate %u (target %u)\n", | 2331 | GNUNET_log ( |
2077 | find_peer_context->current_peers, | 2332 | GNUNET_ERROR_TYPE_WARNING, |
2078 | find_peer_context->current_peers - find_peer_context->previous_peers, | 2333 | "Peer count finished (%u connections), %u new peers, connection estimate %u (target %u)\n", |
2079 | connection_estimate(num_peers, DEFAULT_BUCKET_SIZE), | 2334 | find_peer_context->current_peers, |
2080 | target_total_connections); | 2335 | find_peer_context->current_peers |
2081 | 2336 | - find_peer_context->previous_peers, | |
2082 | if ((find_peer_context->last_sent < 8) || | 2337 | connection_estimate (num_peers, DEFAULT_BUCKET_SIZE), |
2083 | ((find_peer_context->current_peers < 2 * connection_estimate(num_peers, DEFAULT_BUCKET_SIZE)) && | 2338 | target_total_connections); |
2084 | (GNUNET_TIME_absolute_get_remaining(find_peer_context->endtime).rel_value > 0) && | 2339 | |
2085 | (find_peer_context->current_peers < target_total_connections))) | 2340 | if ((find_peer_context->last_sent < 8) |
2341 | || ((find_peer_context->current_peers < 2 | ||
2342 | * connection_estimate (num_peers, DEFAULT_BUCKET_SIZE)) | ||
2343 | && (GNUNET_TIME_absolute_get_remaining ( | ||
2344 | find_peer_context->endtime).rel_value | ||
2345 | > 0) && (find_peer_context->current_peers | ||
2346 | < target_total_connections))) | ||
2086 | { | 2347 | { |
2087 | GNUNET_SCHEDULER_add_now(&schedule_find_peer_requests, find_peer_context); | 2348 | GNUNET_SCHEDULER_add_now (&schedule_find_peer_requests, |
2349 | find_peer_context); | ||
2088 | } | 2350 | } |
2089 | else | 2351 | else |
2090 | { | 2352 | { |
2091 | GNUNET_CONTAINER_multihashmap_iterate(find_peer_context->peer_hash, &remove_peer_count, find_peer_context); | 2353 | GNUNET_CONTAINER_multihashmap_iterate (find_peer_context->peer_hash, |
2092 | GNUNET_CONTAINER_multihashmap_destroy(find_peer_context->peer_hash); | 2354 | &remove_peer_count, |
2093 | GNUNET_CONTAINER_heap_destroy(find_peer_context->peer_min_heap); | 2355 | find_peer_context); |
2356 | GNUNET_CONTAINER_multihashmap_destroy (find_peer_context->peer_hash); | ||
2357 | GNUNET_CONTAINER_heap_destroy (find_peer_context->peer_min_heap); | ||
2094 | GNUNET_free(find_peer_context); | 2358 | GNUNET_free(find_peer_context); |
2095 | fprintf(stderr, "Not sending any more find peer requests.\n"); | 2359 | fprintf (stderr, "Not sending any more find peer requests.\n"); |
2096 | 2360 | ||
2097 | #if HAVE_MALICIOUS | 2361 | #if HAVE_MALICIOUS |
2098 | if (GNUNET_YES == malicious_after_settle) | 2362 | if (GNUNET_YES == malicious_after_settle) |
2099 | { | 2363 | { |
2100 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "calling setup_malicious_peers\n"); | 2364 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "calling setup_malicious_peers\n"); |
2101 | GNUNET_SCHEDULER_add_now(&setup_malicious_peers, NULL); | 2365 | GNUNET_SCHEDULER_add_now(&setup_malicious_peers, NULL); |
2102 | } | 2366 | } |
2103 | #endif | 2367 | #endif |
2104 | } | 2368 | } |
2105 | } | 2369 | } |
2106 | } | 2370 | } |
2107 | 2371 | ||
2108 | |||
2109 | /** | 2372 | /** |
2110 | * Set up a single find peer request for each peer in the topology. Do this | 2373 | * Set up a single find peer request for each peer in the topology. Do this |
2111 | * until the settle time is over, limited by the number of outstanding requests | 2374 | * until the settle time is over, limited by the number of outstanding requests |
2112 | * and the time allowed for each one! | 2375 | * and the time allowed for each one! |
2113 | */ | 2376 | */ |
2114 | static void | 2377 | static void |
2115 | schedule_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 2378 | schedule_find_peer_requests(void *cls, |
2379 | const struct GNUNET_SCHEDULER_TaskContext * tc) | ||
2116 | { | 2380 | { |
2117 | struct FindPeerContext *find_peer_ctx = cls; | 2381 | struct FindPeerContext *find_peer_ctx = cls; |
2118 | struct TestFindPeer *test_find_peer; | 2382 | struct TestFindPeer *test_find_peer; |
@@ -2122,8 +2386,10 @@ schedule_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContex | |||
2122 | 2386 | ||
2123 | if (find_peer_ctx->previous_peers == 0) /* First time, go slowly */ | 2387 | if (find_peer_ctx->previous_peers == 0) /* First time, go slowly */ |
2124 | find_peer_ctx->total = 1; | 2388 | find_peer_ctx->total = 1; |
2125 | else if (find_peer_ctx->current_peers - find_peer_ctx->previous_peers > MAX_FIND_PEER_CUTOFF) /* Found LOTS of peers, still go slowly */ | 2389 | else if (find_peer_ctx->current_peers - find_peer_ctx->previous_peers |
2126 | find_peer_ctx->total = find_peer_ctx->last_sent - (find_peer_ctx->last_sent / 8); | 2390 | > MAX_FIND_PEER_CUTOFF) /* Found LOTS of peers, still go slowly */ |
2391 | find_peer_ctx->total = find_peer_ctx->last_sent - (find_peer_ctx->last_sent | ||
2392 | / 8); | ||
2127 | else | 2393 | else |
2128 | find_peer_ctx->total = find_peer_ctx->last_sent * 2; | 2394 | find_peer_ctx->total = find_peer_ctx->last_sent * 2; |
2129 | 2395 | ||
@@ -2134,9 +2400,12 @@ schedule_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContex | |||
2134 | find_peer_ctx->total = num_peers; | 2400 | find_peer_ctx->total = num_peers; |
2135 | 2401 | ||
2136 | find_peer_ctx->last_sent = find_peer_ctx->total; | 2402 | find_peer_ctx->last_sent = find_peer_ctx->total; |
2137 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending %u find peer messages (goal at least %u connections)\n", find_peer_ctx->total, target_total_connections); | 2403 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
2404 | "Sending %u find peer messages (goal at least %u connections)\n", | ||
2405 | find_peer_ctx->total, target_total_connections); | ||
2138 | 2406 | ||
2139 | find_peer_offset = GNUNET_TIME_relative_divide(find_peer_delay, find_peer_ctx->total); | 2407 | find_peer_offset = GNUNET_TIME_relative_divide (find_peer_delay, |
2408 | find_peer_ctx->total); | ||
2140 | for (i = 0; i < find_peer_ctx->total; i++) | 2409 | for (i = 0; i < find_peer_ctx->total; i++) |
2141 | { | 2410 | { |
2142 | test_find_peer = GNUNET_malloc(sizeof(struct TestFindPeer)); | 2411 | test_find_peer = GNUNET_malloc(sizeof(struct TestFindPeer)); |
@@ -2156,7 +2425,9 @@ schedule_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContex | |||
2156 | * will be between 0 - 10, second between 10 - 20, etc. | 2425 | * will be between 0 - 10, second between 10 - 20, etc. |
2157 | */ | 2426 | */ |
2158 | random = (num_peers / find_peer_ctx->total) * i; | 2427 | random = (num_peers / find_peer_ctx->total) * i; |
2159 | random = random + GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, (num_peers / find_peer_ctx->total)); | 2428 | random = random |
2429 | + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, | ||
2430 | (num_peers / find_peer_ctx->total)); | ||
2160 | if (random >= num_peers) | 2431 | if (random >= num_peers) |
2161 | { | 2432 | { |
2162 | random = random - num_peers; | 2433 | random = random - num_peers; |
@@ -2164,30 +2435,41 @@ schedule_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContex | |||
2164 | #if REAL_RANDOM | 2435 | #if REAL_RANDOM |
2165 | random = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); | 2436 | random = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); |
2166 | #endif | 2437 | #endif |
2167 | test_find_peer->daemon = GNUNET_TESTING_daemon_get(pg, random); | 2438 | test_find_peer->daemon = GNUNET_TESTING_daemon_get (pg, random); |
2168 | } | 2439 | } |
2169 | else /* If we have sent requests, choose peers with a low number of connections to send requests from */ | 2440 | else /* If we have sent requests, choose peers with a low number of connections to send requests from */ |
2170 | { | 2441 | { |
2171 | peer_count = GNUNET_CONTAINER_heap_remove_root(find_peer_ctx->peer_min_heap); | 2442 | peer_count |
2443 | = GNUNET_CONTAINER_heap_remove_root (find_peer_ctx->peer_min_heap); | ||
2172 | GNUNET_assert(GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove(find_peer_ctx->peer_hash, &peer_count->peer_id.hashPubKey, peer_count)); | 2444 | GNUNET_assert(GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove(find_peer_ctx->peer_hash, &peer_count->peer_id.hashPubKey, peer_count)); |
2173 | test_find_peer->daemon = GNUNET_TESTING_daemon_get_by_id(pg, &peer_count->peer_id); | 2445 | test_find_peer->daemon |
2446 | = GNUNET_TESTING_daemon_get_by_id (pg, &peer_count->peer_id); | ||
2174 | GNUNET_assert(test_find_peer->daemon != NULL); | 2447 | GNUNET_assert(test_find_peer->daemon != NULL); |
2175 | } | 2448 | } |
2176 | 2449 | ||
2177 | test_find_peer->find_peer_context = find_peer_ctx; | 2450 | test_find_peer->find_peer_context = find_peer_ctx; |
2178 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(find_peer_offset, i), &send_find_peer_request, test_find_peer); | 2451 | GNUNET_SCHEDULER_add_delayed ( |
2452 | GNUNET_TIME_relative_multiply ( | ||
2453 | find_peer_offset, | ||
2454 | i), | ||
2455 | &send_find_peer_request, test_find_peer); | ||
2179 | } | 2456 | } |
2180 | 2457 | ||
2181 | if ((find_peer_ctx->peer_hash == NULL) && (find_peer_ctx->peer_min_heap == NULL)) | 2458 | if ((find_peer_ctx->peer_hash == NULL) && (find_peer_ctx->peer_min_heap |
2459 | == NULL)) | ||
2182 | { | 2460 | { |
2183 | find_peer_ctx->peer_hash = GNUNET_CONTAINER_multihashmap_create(num_peers); | 2461 | find_peer_ctx->peer_hash |
2184 | find_peer_ctx->peer_min_heap = GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); | 2462 | = GNUNET_CONTAINER_multihashmap_create (num_peers); |
2463 | find_peer_ctx->peer_min_heap | ||
2464 | = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); | ||
2185 | } | 2465 | } |
2186 | else | 2466 | else |
2187 | { | 2467 | { |
2188 | GNUNET_CONTAINER_multihashmap_iterate(find_peer_ctx->peer_hash, &remove_peer_count, find_peer_ctx); | 2468 | GNUNET_CONTAINER_multihashmap_iterate (find_peer_ctx->peer_hash, |
2189 | GNUNET_CONTAINER_multihashmap_destroy(find_peer_ctx->peer_hash); | 2469 | &remove_peer_count, find_peer_ctx); |
2190 | find_peer_ctx->peer_hash = GNUNET_CONTAINER_multihashmap_create(num_peers); | 2470 | GNUNET_CONTAINER_multihashmap_destroy (find_peer_ctx->peer_hash); |
2471 | find_peer_ctx->peer_hash | ||
2472 | = GNUNET_CONTAINER_multihashmap_create (num_peers); | ||
2191 | } | 2473 | } |
2192 | 2474 | ||
2193 | GNUNET_assert(0 == GNUNET_CONTAINER_multihashmap_size(find_peer_ctx->peer_hash)); | 2475 | GNUNET_assert(0 == GNUNET_CONTAINER_multihashmap_size(find_peer_ctx->peer_hash)); |
@@ -2202,20 +2484,19 @@ schedule_find_peer_requests (void *cls, const struct GNUNET_SCHEDULER_TaskContex | |||
2202 | * @param hash set to uid (extended with zeros) | 2484 | * @param hash set to uid (extended with zeros) |
2203 | */ | 2485 | */ |
2204 | static void | 2486 | static void |
2205 | hash_from_uid (uint32_t uid, GNUNET_HashCode *hash) | 2487 | hash_from_uid(uint32_t uid, GNUNET_HashCode *hash) |
2206 | { | 2488 | { |
2207 | memset (hash, 0, sizeof (GNUNET_HashCode)); | 2489 | memset (hash, 0, sizeof(GNUNET_HashCode)); |
2208 | *((uint32_t *) hash) = uid; | 2490 | *((uint32_t *) hash) = uid; |
2209 | } | 2491 | } |
2210 | 2492 | ||
2211 | |||
2212 | /** | 2493 | /** |
2213 | * Set up all of the put and get operations we want to do | 2494 | * Set up all of the put and get operations we want to do |
2214 | * in the current round. Allocate data structure for each, | 2495 | * in the current round. Allocate data structure for each, |
2215 | * add to list, then schedule the actual PUT operations. | 2496 | * add to list, then schedule the actual PUT operations. |
2216 | */ | 2497 | */ |
2217 | static void | 2498 | static void |
2218 | setup_puts_and_gets (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 2499 | setup_puts_and_gets(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
2219 | { | 2500 | { |
2220 | int i; | 2501 | int i; |
2221 | struct TestPutContext *test_put; | 2502 | struct TestPutContext *test_put; |
@@ -2227,35 +2508,44 @@ setup_puts_and_gets (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
2227 | int remember[num_puts][num_peers]; | 2508 | int remember[num_puts][num_peers]; |
2228 | memset(&remember, 0, sizeof(int) * num_puts * num_peers); | 2509 | memset(&remember, 0, sizeof(int) * num_puts * num_peers); |
2229 | #endif | 2510 | #endif |
2230 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "in setup_puts_and_gets\n"); | 2511 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "in setup_puts_and_gets\n"); |
2231 | known_keys = GNUNET_malloc(sizeof(GNUNET_HashCode) * num_puts); | 2512 | known_keys = GNUNET_malloc(sizeof(GNUNET_HashCode) * num_puts); |
2232 | for (i = 0; i < num_puts; i++) | 2513 | for (i = 0; i < num_puts; i++) |
2233 | { | 2514 | { |
2234 | test_put = GNUNET_malloc(sizeof(struct TestPutContext)); | 2515 | test_put = GNUNET_malloc(sizeof(struct TestPutContext)); |
2235 | test_put->uid = i; | 2516 | test_put->uid = i; |
2236 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &known_keys[i]); | 2517 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, |
2518 | &known_keys[i]); | ||
2237 | /* Set first X bits to match the chosen sybil location if we want to do the sybil attack! */ | 2519 | /* Set first X bits to match the chosen sybil location if we want to do the sybil attack! */ |
2238 | if (GNUNET_YES == malicious_sybil) | 2520 | if (GNUNET_YES == malicious_sybil) |
2239 | { | 2521 | { |
2240 | memcpy(&known_keys[i], &sybil_target, sizeof(GNUNET_HashCode) / 2); | 2522 | memcpy (&known_keys[i], &sybil_target, sizeof(GNUNET_HashCode) / 2); |
2241 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Distance between sybil location and key is %d\n", GNUNET_CRYPTO_hash_matching_bits(&known_keys[i], &sybil_target)); | 2523 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2524 | "Distance between sybil location and key is %d\n", | ||
2525 | GNUNET_CRYPTO_hash_matching_bits (&known_keys[i], | ||
2526 | &sybil_target)); | ||
2242 | } | 2527 | } |
2243 | temp_peer = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); | 2528 | temp_peer = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, |
2244 | test_put->daemon = GNUNET_TESTING_daemon_get(pg, temp_peer); | 2529 | num_peers); |
2530 | test_put->daemon = GNUNET_TESTING_daemon_get (pg, temp_peer); | ||
2245 | /* Don't start PUTs at malicious peers! */ | 2531 | /* Don't start PUTs at malicious peers! */ |
2246 | if (malicious_bloom != NULL) | 2532 | if (malicious_bloom != NULL) |
2247 | { | 2533 | { |
2248 | count = 0; | 2534 | count = 0; |
2249 | hash_from_uid(temp_peer, &uid_hash); | 2535 | hash_from_uid (temp_peer, &uid_hash); |
2250 | while ((GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test(malicious_bloom, &uid_hash)) && (count < num_peers)) | 2536 | while ((GNUNET_YES |
2251 | { | 2537 | == GNUNET_CONTAINER_bloomfilter_test (malicious_bloom, &uid_hash)) |
2252 | temp_peer = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); | 2538 | && (count < num_peers)) |
2253 | hash_from_uid(temp_peer, &uid_hash); | 2539 | { |
2254 | test_put->daemon = GNUNET_TESTING_daemon_get(pg, temp_peer); | 2540 | temp_peer = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, |
2255 | count++; | 2541 | num_peers); |
2256 | } | 2542 | hash_from_uid (temp_peer, &uid_hash); |
2543 | test_put->daemon = GNUNET_TESTING_daemon_get (pg, temp_peer); | ||
2544 | count++; | ||
2545 | } | ||
2257 | if (count == num_peers) | 2546 | if (count == num_peers) |
2258 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Couldn't find peer not in malicious bloom to select!\n"); | 2547 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
2548 | "Couldn't find peer not in malicious bloom to select!\n"); | ||
2259 | } | 2549 | } |
2260 | 2550 | ||
2261 | test_put->next = all_puts; | 2551 | test_put->next = all_puts; |
@@ -2265,36 +2555,47 @@ setup_puts_and_gets (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
2265 | for (i = 0; i < num_gets; i++) | 2555 | for (i = 0; i < num_gets; i++) |
2266 | { | 2556 | { |
2267 | test_get = GNUNET_malloc(sizeof(struct TestGetContext)); | 2557 | test_get = GNUNET_malloc(sizeof(struct TestGetContext)); |
2268 | test_get->uid = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_puts); | 2558 | test_get->uid = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, |
2559 | num_puts); | ||
2269 | #if REMEMBER | 2560 | #if REMEMBER |
2270 | while (remember[test_get->uid][temp_daemon] == 1) | 2561 | while (remember[test_get->uid][temp_daemon] == 1) |
2271 | temp_daemon = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); | 2562 | temp_daemon = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); |
2272 | remember[test_get->uid][temp_daemon] = 1; | 2563 | remember[test_get->uid][temp_daemon] = 1; |
2273 | #endif | 2564 | #endif |
2274 | temp_peer = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); | 2565 | temp_peer = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, |
2275 | test_get->daemon = GNUNET_TESTING_daemon_get(pg, temp_peer); | 2566 | num_peers); |
2567 | test_get->daemon = GNUNET_TESTING_daemon_get (pg, temp_peer); | ||
2276 | /* Don't start GETs at malicious peers! */ | 2568 | /* Don't start GETs at malicious peers! */ |
2277 | if (malicious_bloom != NULL) | 2569 | if (malicious_bloom != NULL) |
2278 | { | 2570 | { |
2279 | hash_from_uid(temp_peer, &uid_hash); | 2571 | hash_from_uid (temp_peer, &uid_hash); |
2280 | count = 0; | 2572 | count = 0; |
2281 | while ((GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test(malicious_bloom, &uid_hash)) && (count < num_peers)) | 2573 | while ((GNUNET_YES |
2282 | { | 2574 | == GNUNET_CONTAINER_bloomfilter_test (malicious_bloom, &uid_hash)) |
2283 | temp_peer = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); | 2575 | && (count < num_peers)) |
2284 | hash_from_uid(temp_peer, &uid_hash); | 2576 | { |
2285 | test_get->daemon = GNUNET_TESTING_daemon_get(pg, temp_peer); | 2577 | temp_peer = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, |
2286 | count++; | 2578 | num_peers); |
2287 | } | 2579 | hash_from_uid (temp_peer, &uid_hash); |
2580 | test_get->daemon = GNUNET_TESTING_daemon_get (pg, temp_peer); | ||
2581 | count++; | ||
2582 | } | ||
2288 | if (count == num_peers) | 2583 | if (count == num_peers) |
2289 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Couldn't find peer not in malicious bloom to select!\n"); | 2584 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
2585 | "Couldn't find peer not in malicious bloom to select!\n"); | ||
2290 | } | 2586 | } |
2291 | test_get->next = all_gets; | 2587 | test_get->next = all_gets; |
2292 | all_gets = test_get; | 2588 | all_gets = test_get; |
2293 | } | 2589 | } |
2294 | 2590 | ||
2295 | /*GNUNET_SCHEDULER_cancel (die_task);*/ | 2591 | /*GNUNET_SCHEDULER_cancel (die_task);*/ |
2296 | die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, num_puts * 2), | 2592 | die_task |
2297 | &end_badly, "from do puts"); | 2593 | = GNUNET_SCHEDULER_add_delayed ( |
2594 | GNUNET_TIME_relative_multiply ( | ||
2595 | GNUNET_TIME_UNIT_SECONDS, | ||
2596 | num_puts | ||
2597 | * 2), | ||
2598 | &end_badly, "from do puts"); | ||
2298 | GNUNET_SCHEDULER_add_now (&do_put, all_puts); | 2599 | GNUNET_SCHEDULER_add_now (&do_put, all_puts); |
2299 | 2600 | ||
2300 | } | 2601 | } |
@@ -2305,13 +2606,14 @@ setup_puts_and_gets (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
2305 | * then call actual insert functions. | 2606 | * then call actual insert functions. |
2306 | */ | 2607 | */ |
2307 | static void | 2608 | static void |
2308 | continue_puts_and_gets (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 2609 | continue_puts_and_gets(void *cls, |
2610 | const struct GNUNET_SCHEDULER_TaskContext * tc) | ||
2309 | { | 2611 | { |
2310 | int i; | 2612 | int i; |
2311 | int max; | 2613 | int max; |
2312 | struct TopologyIteratorContext *topo_ctx; | 2614 | struct TopologyIteratorContext *topo_ctx; |
2313 | struct FindPeerContext *find_peer_context; | 2615 | struct FindPeerContext *find_peer_context; |
2314 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "In continue_puts_and_gets\n"); | 2616 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "In continue_puts_and_gets\n"); |
2315 | if ((dhtlog_handle != NULL) && (GNUNET_NO == dhtlog_minimal)) | 2617 | if ((dhtlog_handle != NULL) && (GNUNET_NO == dhtlog_minimal)) |
2316 | { | 2618 | { |
2317 | if (settle_time >= 180 * 2) | 2619 | if (settle_time >= 180 * 2) |
@@ -2323,21 +2625,38 @@ continue_puts_and_gets (void *cls, const struct GNUNET_SCHEDULER_TaskContext * t | |||
2323 | topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext)); | 2625 | topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext)); |
2324 | topo_ctx->current_iteration = i; | 2626 | topo_ctx->current_iteration = i; |
2325 | topo_ctx->total_iterations = max; | 2627 | topo_ctx->total_iterations = max; |
2326 | topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers); | 2628 | topo_ctx->peers_seen |
2629 | = GNUNET_CONTAINER_multihashmap_create (num_peers); | ||
2327 | //fprintf(stderr, "scheduled topology iteration in %d minutes\n", i); | 2630 | //fprintf(stderr, "scheduled topology iteration in %d minutes\n", i); |
2328 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, i * 3), &capture_current_topology, topo_ctx); | 2631 | GNUNET_SCHEDULER_add_delayed ( |
2632 | GNUNET_TIME_relative_multiply ( | ||
2633 | GNUNET_TIME_UNIT_MINUTES, | ||
2634 | i * 3), | ||
2635 | &capture_current_topology, topo_ctx); | ||
2329 | } | 2636 | } |
2330 | topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext)); | 2637 | topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext)); |
2331 | topo_ctx->cont = &setup_puts_and_gets; | 2638 | topo_ctx->cont = &setup_puts_and_gets; |
2332 | topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers); | 2639 | topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create (num_peers); |
2333 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "setting setup_puts_and_gets for %d seconds in the future\n", settle_time + 10); | 2640 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
2334 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, (settle_time + 10)), &capture_current_topology, topo_ctx); | 2641 | "setting setup_puts_and_gets for %d seconds in the future\n", |
2642 | settle_time + 10); | ||
2643 | GNUNET_SCHEDULER_add_delayed ( | ||
2644 | GNUNET_TIME_relative_multiply ( | ||
2645 | GNUNET_TIME_UNIT_SECONDS, | ||
2646 | (settle_time | ||
2647 | + 10)), | ||
2648 | &capture_current_topology, topo_ctx); | ||
2335 | } | 2649 | } |
2336 | else | 2650 | else |
2337 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, (settle_time + 10)), &setup_puts_and_gets, NULL); | 2651 | GNUNET_SCHEDULER_add_delayed ( |
2652 | GNUNET_TIME_relative_multiply ( | ||
2653 | GNUNET_TIME_UNIT_SECONDS, | ||
2654 | (settle_time | ||
2655 | + 10)), | ||
2656 | &setup_puts_and_gets, NULL); | ||
2338 | 2657 | ||
2339 | if (dhtlog_handle != NULL) | 2658 | if (dhtlog_handle != NULL) |
2340 | dhtlog_handle->insert_round(DHT_ROUND_NORMAL, rounds_finished); | 2659 | dhtlog_handle->insert_round (DHT_ROUND_NORMAL, rounds_finished); |
2341 | 2660 | ||
2342 | #if HAVE_MALICIOUS | 2661 | #if HAVE_MALICIOUS |
2343 | if ((GNUNET_YES != malicious_after_settle) || (settle_time == 0)) | 2662 | if ((GNUNET_YES != malicious_after_settle) || (settle_time == 0)) |
@@ -2348,15 +2667,21 @@ continue_puts_and_gets (void *cls, const struct GNUNET_SCHEDULER_TaskContext * t | |||
2348 | 2667 | ||
2349 | if ((GNUNET_YES == do_find_peer) && (settle_time > 0)) | 2668 | if ((GNUNET_YES == do_find_peer) && (settle_time > 0)) |
2350 | { | 2669 | { |
2351 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Scheduling find peer requests during \"settle\" time.\n"); | 2670 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2671 | "Scheduling find peer requests during \"settle\" time.\n"); | ||
2352 | find_peer_context = GNUNET_malloc(sizeof(struct FindPeerContext)); | 2672 | find_peer_context = GNUNET_malloc(sizeof(struct FindPeerContext)); |
2353 | find_peer_context->count_peers_cb = &count_peers_cb; | 2673 | find_peer_context->count_peers_cb = &count_peers_cb; |
2354 | find_peer_context->endtime = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, settle_time)); | 2674 | find_peer_context->endtime |
2355 | GNUNET_SCHEDULER_add_now(&schedule_find_peer_requests, find_peer_context); | 2675 | = GNUNET_TIME_relative_to_absolute ( |
2676 | GNUNET_TIME_relative_multiply ( | ||
2677 | GNUNET_TIME_UNIT_SECONDS, | ||
2678 | settle_time)); | ||
2679 | GNUNET_SCHEDULER_add_now (&schedule_find_peer_requests, find_peer_context); | ||
2356 | } | 2680 | } |
2357 | else | 2681 | else |
2358 | { | 2682 | { |
2359 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Assuming automatic DHT find peer requests.\n"); | 2683 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2684 | "Assuming automatic DHT find peer requests.\n"); | ||
2360 | } | 2685 | } |
2361 | } | 2686 | } |
2362 | 2687 | ||
@@ -2364,19 +2689,21 @@ continue_puts_and_gets (void *cls, const struct GNUNET_SCHEDULER_TaskContext * t | |||
2364 | * Task to release DHT handles | 2689 | * Task to release DHT handles |
2365 | */ | 2690 | */ |
2366 | static void | 2691 | static void |
2367 | malicious_disconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 2692 | malicious_disconnect_task(void *cls, |
2693 | const struct GNUNET_SCHEDULER_TaskContext * tc) | ||
2368 | { | 2694 | { |
2369 | struct MaliciousContext *ctx = cls; | 2695 | struct MaliciousContext *ctx = cls; |
2370 | outstanding_malicious--; | 2696 | outstanding_malicious--; |
2371 | malicious_completed++; | 2697 | malicious_completed++; |
2372 | ctx->disconnect_task = GNUNET_SCHEDULER_NO_TASK; | 2698 | ctx->disconnect_task = GNUNET_SCHEDULER_NO_TASK; |
2373 | GNUNET_DHT_disconnect(ctx->dht_handle); | 2699 | GNUNET_DHT_disconnect (ctx->dht_handle); |
2374 | ctx->dht_handle = NULL; | 2700 | ctx->dht_handle = NULL; |
2375 | GNUNET_free(ctx); | 2701 | GNUNET_free(ctx); |
2376 | 2702 | ||
2377 | if (malicious_completed == malicious_getters + malicious_putters + malicious_droppers) | 2703 | if (malicious_completed == malicious_getters + malicious_putters |
2704 | + malicious_droppers) | ||
2378 | { | 2705 | { |
2379 | fprintf(stderr, "Finished setting all malicious peers up!\n"); | 2706 | fprintf (stderr, "Finished setting all malicious peers up!\n"); |
2380 | } | 2707 | } |
2381 | 2708 | ||
2382 | } | 2709 | } |
@@ -2385,64 +2712,67 @@ malicious_disconnect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext | |||
2385 | * Task to release DHT handles | 2712 | * Task to release DHT handles |
2386 | */ | 2713 | */ |
2387 | static void | 2714 | static void |
2388 | malicious_done_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 2715 | malicious_done_task(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
2389 | { | 2716 | { |
2390 | struct MaliciousContext *ctx = cls; | 2717 | struct MaliciousContext *ctx = cls; |
2391 | GNUNET_SCHEDULER_cancel(ctx->disconnect_task); | 2718 | GNUNET_SCHEDULER_cancel (ctx->disconnect_task); |
2392 | GNUNET_SCHEDULER_add_now(&malicious_disconnect_task, ctx); | 2719 | GNUNET_SCHEDULER_add_now (&malicious_disconnect_task, ctx); |
2393 | } | 2720 | } |
2394 | 2721 | ||
2395 | /** | 2722 | /** |
2396 | * Set up some data, and call API PUT function | 2723 | * Set up some data, and call API PUT function |
2397 | */ | 2724 | */ |
2398 | static void | 2725 | static void |
2399 | set_malicious (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 2726 | set_malicious(void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
2400 | { | 2727 | { |
2401 | struct MaliciousContext *ctx = cls; | 2728 | struct MaliciousContext *ctx = cls; |
2402 | 2729 | ||
2403 | if (outstanding_malicious > DEFAULT_MAX_OUTSTANDING_GETS) | 2730 | if (outstanding_malicious > DEFAULT_MAX_OUTSTANDING_GETS) |
2404 | { | 2731 | { |
2405 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 100), &set_malicious, ctx); | 2732 | GNUNET_SCHEDULER_add_delayed ( |
2733 | GNUNET_TIME_relative_multiply ( | ||
2734 | GNUNET_TIME_UNIT_MILLISECONDS, | ||
2735 | 100), | ||
2736 | &set_malicious, ctx); | ||
2406 | return; | 2737 | return; |
2407 | } | 2738 | } |
2408 | 2739 | ||
2409 | if (ctx->dht_handle == NULL) | 2740 | if (ctx->dht_handle == NULL) |
2410 | { | 2741 | { |
2411 | ctx->dht_handle = GNUNET_DHT_connect(ctx->daemon->cfg, 1); | 2742 | ctx->dht_handle = GNUNET_DHT_connect (ctx->daemon->cfg, 1); |
2412 | outstanding_malicious++; | 2743 | outstanding_malicious++; |
2413 | } | 2744 | } |
2414 | 2745 | ||
2415 | GNUNET_assert(ctx->dht_handle != NULL); | 2746 | GNUNET_assert(ctx->dht_handle != NULL); |
2416 | 2747 | ||
2417 | |||
2418 | #if VERBOSE > 1 | 2748 | #if VERBOSE > 1 |
2419 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting peer %s malicious type %d\n", | 2749 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting peer %s malicious type %d\n", |
2420 | ctx->daemon->shortname, ctx->malicious_type); | 2750 | ctx->daemon->shortname, ctx->malicious_type); |
2421 | #endif | 2751 | #endif |
2422 | 2752 | ||
2423 | switch (ctx->malicious_type) | 2753 | switch (ctx->malicious_type) |
2424 | { | 2754 | { |
2425 | case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_GET: | 2755 | case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_GET: |
2426 | GNUNET_DHT_set_malicious_getter(ctx->dht_handle, malicious_get_frequency); | 2756 | GNUNET_DHT_set_malicious_getter (ctx->dht_handle, malicious_get_frequency); |
2427 | GNUNET_SCHEDULER_add_now (&malicious_done_task, ctx); | 2757 | GNUNET_SCHEDULER_add_now (&malicious_done_task, ctx); |
2428 | break; | 2758 | break; |
2429 | case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_PUT: | 2759 | case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_PUT: |
2430 | GNUNET_DHT_set_malicious_putter(ctx->dht_handle, malicious_put_frequency); | 2760 | GNUNET_DHT_set_malicious_putter (ctx->dht_handle, malicious_put_frequency); |
2431 | GNUNET_SCHEDULER_add_now (&malicious_done_task, ctx); | 2761 | GNUNET_SCHEDULER_add_now (&malicious_done_task, ctx); |
2432 | break; | 2762 | break; |
2433 | case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_DROP: | 2763 | case GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_DROP: |
2434 | GNUNET_DHT_set_malicious_dropper(ctx->dht_handle); | 2764 | GNUNET_DHT_set_malicious_dropper (ctx->dht_handle); |
2435 | GNUNET_SCHEDULER_add_now (&malicious_done_task, ctx); | 2765 | GNUNET_SCHEDULER_add_now (&malicious_done_task, ctx); |
2436 | break; | 2766 | break; |
2437 | default: | 2767 | default: |
2438 | break; | 2768 | break; |
2439 | } | 2769 | } |
2440 | 2770 | ||
2441 | ctx->disconnect_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_FOREVER_REL, | 2771 | ctx->disconnect_task |
2442 | &malicious_disconnect_task, ctx); | 2772 | = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, |
2773 | &malicious_disconnect_task, ctx); | ||
2443 | } | 2774 | } |
2444 | 2775 | ||
2445 | |||
2446 | #if HAVE_MALICIOUS | 2776 | #if HAVE_MALICIOUS |
2447 | /** | 2777 | /** |
2448 | * Choose the next peer from the peer group to set as malicious. | 2778 | * Choose the next peer from the peer group to set as malicious. |
@@ -2456,56 +2786,56 @@ set_malicious (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
2456 | */ | 2786 | */ |
2457 | static uint32_t | 2787 | static uint32_t |
2458 | choose_next_malicious (struct GNUNET_TESTING_PeerGroup *pg, struct GNUNET_CONTAINER_BloomFilter *bloom) | 2788 | choose_next_malicious (struct GNUNET_TESTING_PeerGroup *pg, struct GNUNET_CONTAINER_BloomFilter *bloom) |
2459 | { | 2789 | { |
2460 | int i; | 2790 | int i; |
2461 | int nearest; | 2791 | int nearest; |
2462 | int bits_match; | 2792 | int bits_match; |
2463 | int curr_distance; | 2793 | int curr_distance; |
2464 | int count; | 2794 | int count; |
2465 | struct GNUNET_TESTING_Daemon *temp_daemon; | 2795 | struct GNUNET_TESTING_Daemon *temp_daemon; |
2466 | GNUNET_HashCode uid_hash; | 2796 | GNUNET_HashCode uid_hash; |
2467 | 2797 | ||
2468 | curr_distance = 0; | 2798 | curr_distance = 0; |
2469 | nearest = 0; | 2799 | nearest = 0; |
2470 | GNUNET_assert (bloom != NULL); | 2800 | GNUNET_assert (bloom != NULL); |
2471 | 2801 | ||
2472 | if (GNUNET_YES == malicious_sybil) | 2802 | if (GNUNET_YES == malicious_sybil) |
2473 | { | 2803 | { |
2474 | for (i = 0; i < num_peers; i++) | 2804 | for (i = 0; i < num_peers; i++) |
2475 | { | 2805 | { |
2476 | temp_daemon = GNUNET_TESTING_daemon_get(pg, i); | 2806 | temp_daemon = GNUNET_TESTING_daemon_get(pg, i); |
2477 | hash_from_uid(i, &uid_hash); | 2807 | hash_from_uid(i, &uid_hash); |
2478 | /* Check if this peer matches the bloomfilter */ | 2808 | /* Check if this peer matches the bloomfilter */ |
2479 | if ((GNUNET_NO == GNUNET_TESTING_daemon_running(temp_daemon)) || (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (bloom, &uid_hash))) | 2809 | if ((GNUNET_NO == GNUNET_TESTING_daemon_running(temp_daemon)) || (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (bloom, &uid_hash))) |
2480 | continue; | 2810 | continue; |
2481 | 2811 | ||
2482 | bits_match = GNUNET_CRYPTO_hash_matching_bits (&temp_daemon->id.hashPubKey, &sybil_target); | 2812 | bits_match = GNUNET_CRYPTO_hash_matching_bits (&temp_daemon->id.hashPubKey, &sybil_target); |
2483 | if (bits_match >= curr_distance) | 2813 | if (bits_match >= curr_distance) |
2484 | { | 2814 | { |
2485 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Found nearer peer %s to %s, old matching bits %d, new %d\n", GNUNET_i2s(&temp_daemon->id), GNUNET_h2s(&sybil_target), curr_distance, bits_match); | 2815 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Found nearer peer %s to %s, old matching bits %d, new %d\n", GNUNET_i2s(&temp_daemon->id), GNUNET_h2s(&sybil_target), curr_distance, bits_match); |
2486 | nearest = i; | 2816 | nearest = i; |
2487 | curr_distance = bits_match; | 2817 | curr_distance = bits_match; |
2488 | } | 2818 | } |
2489 | } | 2819 | } |
2490 | } | 2820 | } |
2491 | else | 2821 | else |
2492 | { | 2822 | { |
2493 | nearest = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); | 2823 | nearest = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); |
2494 | hash_from_uid(nearest, &uid_hash); | 2824 | hash_from_uid(nearest, &uid_hash); |
2495 | count = 0; | 2825 | count = 0; |
2496 | while ((GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (bloom, &uid_hash)) && (count < num_peers)) | 2826 | while ((GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (bloom, &uid_hash)) && (count < num_peers)) |
2497 | { | 2827 | { |
2498 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peer %d already in bloom (tried %d times)\n", nearest, count); | 2828 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Peer %d already in bloom (tried %d times)\n", nearest, count); |
2499 | nearest = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); | 2829 | nearest = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, num_peers); |
2500 | hash_from_uid(nearest, &uid_hash); | 2830 | hash_from_uid(nearest, &uid_hash); |
2501 | count++; | 2831 | count++; |
2502 | } | 2832 | } |
2503 | if (count == num_peers) | 2833 | if (count == num_peers) |
2504 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Tried %d times to find a peer, selecting %d at random!!\n", count, nearest); | 2834 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Tried %d times to find a peer, selecting %d at random!!\n", count, nearest); |
2505 | } | 2835 | } |
2506 | 2836 | ||
2507 | return nearest; | 2837 | return nearest; |
2508 | } | 2838 | } |
2509 | 2839 | ||
2510 | /** | 2840 | /** |
2511 | * Select randomly from set of known peers, | 2841 | * Select randomly from set of known peers, |
@@ -2514,61 +2844,61 @@ choose_next_malicious (struct GNUNET_TESTING_PeerGroup *pg, struct GNUNET_CONTAI | |||
2514 | */ | 2844 | */ |
2515 | static void | 2845 | static void |
2516 | setup_malicious_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 2846 | setup_malicious_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
2517 | { | 2847 | { |
2518 | struct MaliciousContext *ctx; | 2848 | struct MaliciousContext *ctx; |
2519 | int i; | 2849 | int i; |
2520 | uint32_t temp_daemon; | 2850 | uint32_t temp_daemon; |
2521 | GNUNET_HashCode uid_hash; | 2851 | GNUNET_HashCode uid_hash; |
2522 | 2852 | ||
2523 | for (i = 0; i < malicious_getters; i++) | 2853 | for (i = 0; i < malicious_getters; i++) |
2524 | { | 2854 | { |
2525 | ctx = GNUNET_malloc(sizeof(struct MaliciousContext)); | 2855 | ctx = GNUNET_malloc(sizeof(struct MaliciousContext)); |
2526 | temp_daemon = choose_next_malicious(pg, malicious_bloom); | 2856 | temp_daemon = choose_next_malicious(pg, malicious_bloom); |
2527 | ctx->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon); | 2857 | ctx->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon); |
2528 | hash_from_uid(temp_daemon, &uid_hash); | 2858 | hash_from_uid(temp_daemon, &uid_hash); |
2529 | GNUNET_CONTAINER_bloomfilter_add(malicious_bloom, &uid_hash); | 2859 | GNUNET_CONTAINER_bloomfilter_add(malicious_bloom, &uid_hash); |
2530 | ctx->malicious_type = GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_GET; | 2860 | ctx->malicious_type = GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_GET; |
2531 | GNUNET_SCHEDULER_add_now (&set_malicious, ctx); | 2861 | GNUNET_SCHEDULER_add_now (&set_malicious, ctx); |
2532 | 2862 | ||
2533 | } | 2863 | } |
2534 | 2864 | ||
2535 | for (i = 0; i < malicious_putters; i++) | 2865 | for (i = 0; i < malicious_putters; i++) |
2536 | { | 2866 | { |
2537 | ctx = GNUNET_malloc(sizeof(struct MaliciousContext)); | 2867 | ctx = GNUNET_malloc(sizeof(struct MaliciousContext)); |
2538 | temp_daemon = choose_next_malicious(pg, malicious_bloom); | 2868 | temp_daemon = choose_next_malicious(pg, malicious_bloom); |
2539 | ctx->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon); | 2869 | ctx->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon); |
2540 | hash_from_uid(temp_daemon, &uid_hash); | 2870 | hash_from_uid(temp_daemon, &uid_hash); |
2541 | GNUNET_CONTAINER_bloomfilter_add(malicious_bloom, &uid_hash); | 2871 | GNUNET_CONTAINER_bloomfilter_add(malicious_bloom, &uid_hash); |
2542 | ctx->malicious_type = GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_PUT; | 2872 | ctx->malicious_type = GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_PUT; |
2543 | GNUNET_SCHEDULER_add_now (&set_malicious, ctx); | 2873 | GNUNET_SCHEDULER_add_now (&set_malicious, ctx); |
2544 | 2874 | ||
2545 | } | 2875 | } |
2546 | 2876 | ||
2547 | for (i = 0; i < malicious_droppers; i++) | 2877 | for (i = 0; i < malicious_droppers; i++) |
2548 | { | 2878 | { |
2549 | ctx = GNUNET_malloc(sizeof(struct MaliciousContext)); | 2879 | ctx = GNUNET_malloc(sizeof(struct MaliciousContext)); |
2550 | temp_daemon = choose_next_malicious(pg, malicious_bloom); | 2880 | temp_daemon = choose_next_malicious(pg, malicious_bloom); |
2551 | ctx->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon); | 2881 | ctx->daemon = GNUNET_TESTING_daemon_get(pg, temp_daemon); |
2552 | hash_from_uid(temp_daemon, &uid_hash); | 2882 | hash_from_uid(temp_daemon, &uid_hash); |
2553 | GNUNET_CONTAINER_bloomfilter_add(malicious_bloom, &uid_hash); | 2883 | GNUNET_CONTAINER_bloomfilter_add(malicious_bloom, &uid_hash); |
2554 | ctx->malicious_type = GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_DROP; | 2884 | ctx->malicious_type = GNUNET_MESSAGE_TYPE_DHT_MALICIOUS_DROP; |
2555 | GNUNET_SCHEDULER_add_now (&set_malicious, ctx); | 2885 | GNUNET_SCHEDULER_add_now (&set_malicious, ctx); |
2556 | } | 2886 | } |
2557 | } | 2887 | } |
2558 | #endif | 2888 | #endif |
2559 | 2889 | ||
2560 | #if ONLY_TESTING | 2890 | #if ONLY_TESTING |
2561 | /* Forward declaration */ | 2891 | /* Forward declaration */ |
2562 | static void | 2892 | static void |
2563 | topology_callback (void *cls, | 2893 | topology_callback (void *cls, |
2564 | const struct GNUNET_PeerIdentity *first, | 2894 | const struct GNUNET_PeerIdentity *first, |
2565 | const struct GNUNET_PeerIdentity *second, | 2895 | const struct GNUNET_PeerIdentity *second, |
2566 | uint32_t distance, | 2896 | uint32_t distance, |
2567 | const struct GNUNET_CONFIGURATION_Handle *first_cfg, | 2897 | const struct GNUNET_CONFIGURATION_Handle *first_cfg, |
2568 | const struct GNUNET_CONFIGURATION_Handle *second_cfg, | 2898 | const struct GNUNET_CONFIGURATION_Handle *second_cfg, |
2569 | struct GNUNET_TESTING_Daemon *first_daemon, | 2899 | struct GNUNET_TESTING_Daemon *first_daemon, |
2570 | struct GNUNET_TESTING_Daemon *second_daemon, | 2900 | struct GNUNET_TESTING_Daemon *second_daemon, |
2571 | const char *emsg); | 2901 | const char *emsg); |
2572 | 2902 | ||
2573 | /** | 2903 | /** |
2574 | * Retry connecting two specific peers until they connect, | 2904 | * Retry connecting two specific peers until they connect, |
@@ -2578,18 +2908,18 @@ topology_callback (void *cls, | |||
2578 | */ | 2908 | */ |
2579 | static void | 2909 | static void |
2580 | repeat_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | 2910 | repeat_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) |
2581 | { | 2911 | { |
2582 | 2912 | ||
2583 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Repeating connect attempt between %s and %s.\n", repeat_connect_peer1->shortname, repeat_connect_peer2->shortname); | 2913 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Repeating connect attempt between %s and %s.\n", repeat_connect_peer1->shortname, repeat_connect_peer2->shortname); |
2584 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Peer 1 configuration `%s'\n", repeat_connect_peer1->cfgfile); | 2914 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Peer 1 configuration `%s'\n", repeat_connect_peer1->cfgfile); |
2585 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Peer 2 configuration `%s'\n", repeat_connect_peer2->cfgfile); | 2915 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Peer 2 configuration `%s'\n", repeat_connect_peer2->cfgfile); |
2586 | 2916 | ||
2587 | repeat_connect_task = GNUNET_SCHEDULER_NO_TASK; | 2917 | repeat_connect_task = GNUNET_SCHEDULER_NO_TASK; |
2588 | GNUNET_TESTING_daemons_connect(repeat_connect_peer1, | 2918 | GNUNET_TESTING_daemons_connect(repeat_connect_peer1, |
2589 | repeat_connect_peer2, | 2919 | repeat_connect_peer2, |
2590 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60), | 2920 | GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60), |
2591 | 2, &topology_callback, NULL); | 2921 | 2, &topology_callback, NULL); |
2592 | } | 2922 | } |
2593 | #endif | 2923 | #endif |
2594 | 2924 | ||
2595 | /** | 2925 | /** |
@@ -2602,15 +2932,12 @@ repeat_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc) | |||
2602 | * failure (peers failed to connect). | 2932 | * failure (peers failed to connect). |
2603 | */ | 2933 | */ |
2604 | static void | 2934 | static void |
2605 | topology_callback (void *cls, | 2935 | topology_callback(void *cls, const struct GNUNET_PeerIdentity *first, |
2606 | const struct GNUNET_PeerIdentity *first, | 2936 | const struct GNUNET_PeerIdentity *second, uint32_t distance, |
2607 | const struct GNUNET_PeerIdentity *second, | 2937 | const struct GNUNET_CONFIGURATION_Handle *first_cfg, |
2608 | uint32_t distance, | 2938 | const struct GNUNET_CONFIGURATION_Handle *second_cfg, |
2609 | const struct GNUNET_CONFIGURATION_Handle *first_cfg, | 2939 | struct GNUNET_TESTING_Daemon *first_daemon, |
2610 | const struct GNUNET_CONFIGURATION_Handle *second_cfg, | 2940 | struct GNUNET_TESTING_Daemon *second_daemon, const char *emsg) |
2611 | struct GNUNET_TESTING_Daemon *first_daemon, | ||
2612 | struct GNUNET_TESTING_Daemon *second_daemon, | ||
2613 | const char *emsg) | ||
2614 | { | 2941 | { |
2615 | struct TopologyIteratorContext *topo_ctx; | 2942 | struct TopologyIteratorContext *topo_ctx; |
2616 | unsigned long long duration; | 2943 | unsigned long long duration; |
@@ -2621,6 +2948,9 @@ topology_callback (void *cls, | |||
2621 | double conns_per_sec_total; | 2948 | double conns_per_sec_total; |
2622 | double failed_conns_per_sec_recent; | 2949 | double failed_conns_per_sec_recent; |
2623 | double failed_conns_per_sec_total; | 2950 | double failed_conns_per_sec_total; |
2951 | char *temp_conn_string; | ||
2952 | char *temp_conn_failed_string; | ||
2953 | char *revision_str; | ||
2624 | 2954 | ||
2625 | #if ONLY_TESTING | 2955 | #if ONLY_TESTING |
2626 | if (repeat_connect_mode == GNUNET_YES) | 2956 | if (repeat_connect_mode == GNUNET_YES) |
@@ -2637,7 +2967,7 @@ topology_callback (void *cls, | |||
2637 | else /* Repeat peers actually connected! */ | 2967 | else /* Repeat peers actually connected! */ |
2638 | { | 2968 | { |
2639 | if (repeat_connect_task != GNUNET_SCHEDULER_NO_TASK) | 2969 | if (repeat_connect_task != GNUNET_SCHEDULER_NO_TASK) |
2640 | GNUNET_SCHEDULER_cancel(repeat_connect_task); | 2970 | GNUNET_SCHEDULER_cancel(repeat_connect_task); |
2641 | repeat_connect_peer1 = NULL; | 2971 | repeat_connect_peer1 = NULL; |
2642 | repeat_connect_peer2 = NULL; | 2972 | repeat_connect_peer2 = NULL; |
2643 | repeat_connect_mode = GNUNET_NO; | 2973 | repeat_connect_mode = GNUNET_NO; |
@@ -2649,7 +2979,9 @@ topology_callback (void *cls, | |||
2649 | #endif | 2979 | #endif |
2650 | 2980 | ||
2651 | if (GNUNET_TIME_absolute_get_difference (connect_last_time, | 2981 | if (GNUNET_TIME_absolute_get_difference (connect_last_time, |
2652 | GNUNET_TIME_absolute_get()).rel_value > GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, CONN_UPDATE_DURATION).rel_value) | 2982 | GNUNET_TIME_absolute_get ()).rel_value |
2983 | > GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, | ||
2984 | CONN_UPDATE_DURATION).rel_value) | ||
2653 | { | 2985 | { |
2654 | /* Get number of new connections */ | 2986 | /* Get number of new connections */ |
2655 | new_connections = total_connections - previous_connections; | 2987 | new_connections = total_connections - previous_connections; |
@@ -2658,22 +2990,31 @@ topology_callback (void *cls, | |||
2658 | new_failed_connections = failed_connections - previous_failed_connections; | 2990 | new_failed_connections = failed_connections - previous_failed_connections; |
2659 | 2991 | ||
2660 | /* Get duration in seconds */ | 2992 | /* Get duration in seconds */ |
2661 | duration = GNUNET_TIME_absolute_get_difference (connect_last_time, | 2993 | duration |
2662 | GNUNET_TIME_absolute_get()).rel_value / 1000; | 2994 | = GNUNET_TIME_absolute_get_difference (connect_last_time, |
2663 | total_duration = GNUNET_TIME_absolute_get_difference (connect_start_time, | 2995 | GNUNET_TIME_absolute_get ()).rel_value |
2664 | GNUNET_TIME_absolute_get()).rel_value / 1000; | 2996 | / 1000; |
2665 | 2997 | total_duration | |
2666 | failed_conns_per_sec_recent = (double)new_failed_connections / duration; | 2998 | = GNUNET_TIME_absolute_get_difference (connect_start_time, |
2667 | failed_conns_per_sec_total = (double)failed_connections / total_duration; | 2999 | GNUNET_TIME_absolute_get ()).rel_value |
2668 | conns_per_sec_recent = (double)new_connections / duration; | 3000 | / 1000; |
2669 | conns_per_sec_total = (double)total_connections / total_duration; | 3001 | |
2670 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Recent: %.2f/s, Total: %.2f/s, Recent failed: %.2f/s, total failed %.2f/s\n", | 3002 | failed_conns_per_sec_recent = (double) new_failed_connections / duration; |
2671 | conns_per_sec_recent, CONN_UPDATE_DURATION, conns_per_sec_total, | 3003 | failed_conns_per_sec_total = (double) failed_connections / total_duration; |
2672 | failed_conns_per_sec_recent, failed_conns_per_sec_total); | 3004 | conns_per_sec_recent = (double) new_connections / duration; |
2673 | connect_last_time = GNUNET_TIME_absolute_get(); | 3005 | conns_per_sec_total = (double) total_connections / total_duration; |
3006 | GNUNET_log ( | ||
3007 | GNUNET_ERROR_TYPE_WARNING, | ||
3008 | "Recent: %.2f/s, Total: %.2f/s, Recent failed: %.2f/s, total failed %.2f/s\n", | ||
3009 | conns_per_sec_recent, CONN_UPDATE_DURATION, | ||
3010 | conns_per_sec_total, failed_conns_per_sec_recent, | ||
3011 | failed_conns_per_sec_total); | ||
3012 | connect_last_time = GNUNET_TIME_absolute_get (); | ||
2674 | previous_connections = total_connections; | 3013 | previous_connections = total_connections; |
2675 | previous_failed_connections = failed_connections; | 3014 | previous_failed_connections = failed_connections; |
2676 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "have %u total_connections, %u failed\n", total_connections, failed_connections); | 3015 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
3016 | "have %u total_connections, %u failed\n", total_connections, | ||
3017 | failed_connections); | ||
2677 | #if ONLY_TESTING | 3018 | #if ONLY_TESTING |
2678 | /* These conditions likely mean we've entered the death spiral of doom */ | 3019 | /* These conditions likely mean we've entered the death spiral of doom */ |
2679 | if ((total_connections > 20000) && | 3020 | if ((total_connections > 20000) && |
@@ -2698,9 +3039,9 @@ topology_callback (void *cls, | |||
2698 | total_connections++; | 3039 | total_connections++; |
2699 | #if VERBOSE > 1 | 3040 | #if VERBOSE > 1 |
2700 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "connected peer %s to peer %s, distance %u\n", | 3041 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "connected peer %s to peer %s, distance %u\n", |
2701 | first_daemon->shortname, | 3042 | first_daemon->shortname, |
2702 | second_daemon->shortname, | 3043 | second_daemon->shortname, |
2703 | distance); | 3044 | distance); |
2704 | #endif | 3045 | #endif |
2705 | } | 3046 | } |
2706 | else | 3047 | else |
@@ -2708,155 +3049,200 @@ topology_callback (void *cls, | |||
2708 | failed_connections++; | 3049 | failed_connections++; |
2709 | #if VERBOSE | 3050 | #if VERBOSE |
2710 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failed to connect peer %s to peer %s with error :\n%s\n", | 3051 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failed to connect peer %s to peer %s with error :\n%s\n", |
2711 | first_daemon->shortname, | 3052 | first_daemon->shortname, |
2712 | second_daemon->shortname, emsg); | 3053 | second_daemon->shortname, emsg); |
2713 | 3054 | ||
2714 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to connect peer %s to peer %s with error :\n%s\n", | 3055 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to connect peer %s to peer %s with error :\n%s\n", |
2715 | first_daemon->shortname, | 3056 | first_daemon->shortname, |
2716 | second_daemon->shortname, emsg); | 3057 | second_daemon->shortname, emsg); |
2717 | #endif | 3058 | #endif |
2718 | } | 3059 | } |
2719 | 3060 | ||
2720 | #if ONLY_TESTING | 3061 | #if ONLY_TESTING |
2721 | if ((repeat_connect_mode == GNUNET_YES) ) | 3062 | if ((repeat_connect_mode == GNUNET_YES) ) |
2722 | return; | 3063 | return; |
2723 | #endif | 3064 | #endif |
2724 | 3065 | ||
2725 | GNUNET_assert(peer_connect_meter != NULL); | 3066 | GNUNET_assert(peer_connect_meter != NULL); |
2726 | if (GNUNET_YES == update_meter(peer_connect_meter)) | 3067 | if (GNUNET_YES == update_meter (peer_connect_meter)) |
2727 | { | 3068 | { |
2728 | #if VERBOSE | 3069 | #if VERBOSE |
2729 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 3070 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2730 | "Created %d total connections, which is our target number! Starting next phase of testing.\n", | 3071 | "Created %d total connections, which is our target number! Starting next phase of testing.\n", |
2731 | total_connections); | 3072 | total_connections); |
2732 | #endif | 3073 | #endif |
2733 | if (failed_connections > 0) | 3074 | if (failed_connections > 0) |
2734 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "While connecting, had %u failed connections.\n", failed_connections); | 3075 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
3076 | "While connecting, had %u failed connections.\n", | ||
3077 | failed_connections); | ||
2735 | if (dhtlog_handle != NULL) | 3078 | if (dhtlog_handle != NULL) |
2736 | { | 3079 | { |
2737 | dhtlog_handle->update_connections (total_connections); | 3080 | dhtlog_handle->update_connections (total_connections); |
2738 | dhtlog_handle->insert_topology(expected_connections); | 3081 | dhtlog_handle->insert_topology (expected_connections); |
2739 | } | 3082 | } |
2740 | 3083 | ||
2741 | 3084 | total_duration | |
2742 | total_duration = GNUNET_TIME_absolute_get_difference (connect_start_time, | 3085 | = GNUNET_TIME_absolute_get_difference (connect_start_time, |
2743 | GNUNET_TIME_absolute_get()).rel_value / 1000; | 3086 | GNUNET_TIME_absolute_get ()).rel_value |
2744 | failed_conns_per_sec_total = (double)failed_connections / total_duration; | 3087 | / 1000; |
2745 | conns_per_sec_total = (double)total_connections / total_duration; | 3088 | failed_conns_per_sec_total = (double) failed_connections / total_duration; |
2746 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Overall connection info --- Total: %u, Total Failed %u/s\n", | 3089 | conns_per_sec_total = (double) total_connections / total_duration; |
2747 | total_connections, failed_connections); | 3090 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
2748 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Overall connection info --- Total: %.2f/s, Total Failed %.2f/s\n", | 3091 | "Overall connection info --- Total: %u, Total Failed %u/s\n", |
2749 | conns_per_sec_total, failed_conns_per_sec_total); | 3092 | total_connections, failed_connections); |
2750 | /** Comment out until gauger is ready */ | 3093 | GNUNET_log ( |
2751 | /** | 3094 | GNUNET_ERROR_TYPE_WARNING, |
2752 | GNUNET_asprintf(&temp_conn_string, "dht_peer_connection_speed"); | 3095 | "Overall connection info --- Total: %.2f/s, Total Failed %.2f/s\n", |
2753 | GNUNET_asprintf(&temp_failed_conn_string, "dht_peer_failed_connection_speed"); | 3096 | conns_per_sec_total, failed_conns_per_sec_total); |
2754 | 3097 | ||
2755 | GAUGER_COUNTER(temp_conn_string, conns_per_sec_total, trial_to_run, DATE); | 3098 | GNUNET_asprintf (&temp_conn_string, |
2756 | GAUGER_COUNTER(temp_failed_conn_string, failed_conns_per_sec_total, trial_to_run, DATE); | 3099 | "DHT Profiler Connection (trial %d)", |
2757 | 3100 | trial_to_run); | |
3101 | GNUNET_asprintf (&temp_conn_failed_string, | ||
3102 | "DHT Profiler Connection failed (trial %d)", | ||
3103 | trial_to_run); | ||
3104 | GNUNET_asprintf (&revision_str, "%llu", revision); | ||
3105 | GAUGER_ID("DHT_TESTING", temp_conn_string, conns_per_sec_total, "conns/s", revision_str); | ||
3106 | GAUGER_ID("DHT_TESTING", temp_conn_failed_string, failed_conns_per_sec_total, "failed_conns", revision_str); | ||
2758 | GNUNET_free(temp_conn_string); | 3107 | GNUNET_free(temp_conn_string); |
2759 | GNUNET_free(temp_failed_conn_string); | 3108 | GNUNET_free(temp_conn_failed_string); |
2760 | */ | 3109 | GNUNET_asprintf (&temp_conn_string, |
3110 | "DHT Profiler Total Connections (trial %d)", | ||
3111 | trial_to_run); | ||
3112 | GNUNET_asprintf ( | ||
3113 | &temp_conn_failed_string, | ||
3114 | "DHT Profiler Total Connections failed (trial %d)", | ||
3115 | trial_to_run); | ||
3116 | GAUGER_ID("DHT_TESTING", temp_conn_string, total_connections, "conns", revision_str); | ||
3117 | GAUGER_ID("DHT_TESTING", temp_conn_failed_string, failed_connections, "failed conns", revision_str); | ||
3118 | GNUNET_free(temp_conn_string); | ||
3119 | GNUNET_free(temp_conn_failed_string); | ||
3120 | GNUNET_free(revision_str); | ||
2761 | 3121 | ||
2762 | GNUNET_SCHEDULER_cancel (die_task); | 3122 | GNUNET_SCHEDULER_cancel (die_task); |
2763 | 3123 | ||
2764 | if ((GNUNET_YES == dhtlog_minimal) && (NULL != dhtlog_handle)) | 3124 | if ((GNUNET_YES == dhtlog_minimal) && (NULL != dhtlog_handle)) |
2765 | { | 3125 | { |
2766 | topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext)); | 3126 | topo_ctx = GNUNET_malloc(sizeof(struct TopologyIteratorContext)); |
2767 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Setting continue gets and puts as topo_cont\n"); | 3127 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
3128 | "Setting continue gets and puts as topo_cont\n"); | ||
2768 | topo_ctx->cont = &continue_puts_and_gets; | 3129 | topo_ctx->cont = &continue_puts_and_gets; |
2769 | topo_ctx->peers_seen = GNUNET_CONTAINER_multihashmap_create(num_peers); | 3130 | topo_ctx->peers_seen |
2770 | GNUNET_SCHEDULER_add_now(&capture_current_topology, topo_ctx); | 3131 | = GNUNET_CONTAINER_multihashmap_create (num_peers); |
3132 | GNUNET_SCHEDULER_add_now (&capture_current_topology, topo_ctx); | ||
2771 | } | 3133 | } |
2772 | else | 3134 | else |
2773 | { | 3135 | { |
2774 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "For some reason, NOT scheduling final topology capture (settle_time %d, dhtlog_handle %s)!\n", settle_time, dhtlog_handle); | 3136 | GNUNET_log ( |
2775 | GNUNET_SCHEDULER_add_now(&continue_puts_and_gets, NULL); | 3137 | GNUNET_ERROR_TYPE_WARNING, |
3138 | "For some reason, NOT scheduling final topology capture (settle_time %d, dhtlog_handle %s)!\n", | ||
3139 | settle_time, dhtlog_handle); | ||
3140 | GNUNET_SCHEDULER_add_now (&continue_puts_and_gets, NULL); | ||
2776 | } | 3141 | } |
2777 | } | 3142 | } |
2778 | else if (total_connections + failed_connections == expected_connections) | 3143 | else if (total_connections + failed_connections == expected_connections) |
2779 | { | 3144 | { |
2780 | GNUNET_SCHEDULER_cancel (die_task); | 3145 | GNUNET_SCHEDULER_cancel (die_task); |
2781 | die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)"); | 3146 | die_task |
3147 | = GNUNET_SCHEDULER_add_now (&end_badly, | ||
3148 | "from topology_callback (too many failed connections)"); | ||
2782 | } | 3149 | } |
2783 | } | 3150 | } |
2784 | 3151 | ||
2785 | static void | 3152 | static void |
2786 | peers_started_callback (void *cls, | 3153 | peers_started_callback(void *cls, const struct GNUNET_PeerIdentity *id, |
2787 | const struct GNUNET_PeerIdentity *id, | 3154 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
2788 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 3155 | struct GNUNET_TESTING_Daemon *d, const char *emsg) |
2789 | struct GNUNET_TESTING_Daemon *d, const char *emsg) | ||
2790 | { | 3156 | { |
2791 | if (emsg != NULL) | 3157 | if (emsg != NULL) |
2792 | { | 3158 | { |
2793 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to start daemon with error: `%s'\n", | 3159 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2794 | emsg); | 3160 | "Failed to start daemon with error: `%s'\n", emsg); |
2795 | return; | 3161 | return; |
2796 | } | 3162 | } |
2797 | GNUNET_assert (id != NULL); | 3163 | GNUNET_assert (id != NULL); |
2798 | 3164 | ||
2799 | #if VERBOSE > 1 | 3165 | #if VERBOSE > 1 |
2800 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Started daemon %llu out of %llu\n", | 3166 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Started daemon %llu out of %llu\n", |
2801 | (num_peers - peers_left) + 1, num_peers); | 3167 | (num_peers - peers_left) + 1, num_peers); |
2802 | #endif | 3168 | #endif |
2803 | 3169 | ||
2804 | peers_left--; | 3170 | peers_left--; |
2805 | 3171 | ||
2806 | if (GNUNET_YES == update_meter(peer_start_meter)) | 3172 | if (GNUNET_YES == update_meter (peer_start_meter)) |
2807 | { | 3173 | { |
2808 | #if VERBOSE | 3174 | #if VERBOSE |
2809 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 3175 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2810 | "All %d daemons started, now connecting peers!\n", | 3176 | "All %d daemons started, now connecting peers!\n", |
2811 | num_peers); | 3177 | num_peers); |
2812 | #endif | 3178 | #endif |
2813 | GNUNET_SCHEDULER_cancel (die_task); | 3179 | GNUNET_SCHEDULER_cancel (die_task); |
2814 | 3180 | ||
2815 | expected_connections = UINT_MAX; | 3181 | expected_connections = UINT_MAX; |
2816 | if ((pg != NULL) && (peers_left == 0)) | 3182 | if ((pg != NULL) && (peers_left == 0)) |
2817 | { | 3183 | { |
2818 | connect_start_time = GNUNET_TIME_absolute_get(); | 3184 | connect_start_time = GNUNET_TIME_absolute_get (); |
2819 | expected_connections = GNUNET_TESTING_connect_topology(pg, | 3185 | expected_connections |
2820 | connect_topology, connect_topology_option, | 3186 | = GNUNET_TESTING_connect_topology ( |
2821 | connect_topology_option_modifier, | 3187 | pg, |
2822 | connect_timeout, connect_attempts, | 3188 | connect_topology, |
2823 | NULL, NULL); | 3189 | connect_topology_option, |
2824 | 3190 | connect_topology_option_modifier, | |
2825 | peer_connect_meter = create_meter(expected_connections, "Peer connection ", GNUNET_YES); | 3191 | connect_timeout, |
2826 | fprintf(stderr, "Have %d expected connections\n", expected_connections); | 3192 | connect_attempts, NULL, NULL); |
3193 | |||
3194 | peer_connect_meter = create_meter (expected_connections, | ||
3195 | "Peer connection ", GNUNET_YES); | ||
3196 | fprintf (stderr, "Have %d expected connections\n", | ||
3197 | expected_connections); | ||
2827 | } | 3198 | } |
2828 | 3199 | ||
2829 | if (expected_connections == GNUNET_SYSERR) | 3200 | if (expected_connections == GNUNET_SYSERR) |
2830 | { | 3201 | { |
2831 | die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)"); | 3202 | die_task |
3203 | = GNUNET_SCHEDULER_add_now (&end_badly, | ||
3204 | "from connect topology (bad return)"); | ||
2832 | } | 3205 | } |
2833 | 3206 | ||
2834 | die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, DEFAULT_CONNECT_TIMEOUT * expected_connections), | 3207 | die_task |
2835 | &end_badly, "from connect topology (timeout)"); | 3208 | = GNUNET_SCHEDULER_add_delayed ( |
3209 | GNUNET_TIME_relative_multiply ( | ||
3210 | GNUNET_TIME_UNIT_SECONDS, | ||
3211 | DEFAULT_CONNECT_TIMEOUT | ||
3212 | * expected_connections), | ||
3213 | &end_badly, | ||
3214 | "from connect topology (timeout)"); | ||
2836 | 3215 | ||
2837 | ok = 0; | 3216 | ok = 0; |
2838 | } | 3217 | } |
2839 | } | 3218 | } |
2840 | 3219 | ||
2841 | static void | 3220 | static void |
2842 | create_topology () | 3221 | create_topology() |
2843 | { | 3222 | { |
2844 | peers_left = num_peers; /* Reset counter */ | 3223 | peers_left = num_peers; /* Reset counter */ |
2845 | if (GNUNET_TESTING_create_topology (pg, topology, blacklist_topology, blacklist_transports) != GNUNET_SYSERR) | 3224 | if (GNUNET_TESTING_create_topology (pg, topology, blacklist_topology, |
3225 | blacklist_transports) != GNUNET_SYSERR) | ||
2846 | { | 3226 | { |
2847 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 3227 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
2848 | "Topology set up, now starting peers!\n"); | 3228 | "Topology set up, now starting peers!\n"); |
2849 | GNUNET_TESTING_daemons_continue_startup(pg); | 3229 | GNUNET_TESTING_daemons_continue_startup (pg); |
2850 | } | 3230 | } |
2851 | else | 3231 | else |
2852 | { | 3232 | { |
2853 | GNUNET_SCHEDULER_cancel (die_task); | 3233 | GNUNET_SCHEDULER_cancel (die_task); |
2854 | die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from create topology (bad return)"); | 3234 | die_task = GNUNET_SCHEDULER_add_now (&end_badly, |
3235 | "from create topology (bad return)"); | ||
2855 | } | 3236 | } |
2856 | GNUNET_free_non_null(blacklist_transports); | 3237 | GNUNET_free_non_null(blacklist_transports); |
2857 | GNUNET_SCHEDULER_cancel (die_task); | 3238 | GNUNET_SCHEDULER_cancel (die_task); |
2858 | die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(seconds_per_peer_start, num_peers), | 3239 | die_task |
2859 | &end_badly, "from continue startup (timeout)"); | 3240 | = GNUNET_SCHEDULER_add_delayed ( |
3241 | GNUNET_TIME_relative_multiply ( | ||
3242 | seconds_per_peer_start, | ||
3243 | num_peers), | ||
3244 | &end_badly, | ||
3245 | "from continue startup (timeout)"); | ||
2860 | } | 3246 | } |
2861 | 3247 | ||
2862 | /** | 3248 | /** |
@@ -2867,44 +3253,42 @@ create_topology () | |||
2867 | * @param d the daemon handle (pretty useless at this point, remove?) | 3253 | * @param d the daemon handle (pretty useless at this point, remove?) |
2868 | * @param emsg non-null on failure | 3254 | * @param emsg non-null on failure |
2869 | */ | 3255 | */ |
2870 | static void | 3256 | static void |
2871 | hostkey_callback (void *cls, | 3257 | hostkey_callback(void *cls, const struct GNUNET_PeerIdentity *id, |
2872 | const struct GNUNET_PeerIdentity *id, | 3258 | struct GNUNET_TESTING_Daemon *d, const char *emsg) |
2873 | struct GNUNET_TESTING_Daemon *d, | ||
2874 | const char *emsg) | ||
2875 | { | 3259 | { |
2876 | if (emsg != NULL) | 3260 | if (emsg != NULL) |
2877 | { | 3261 | { |
2878 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Hostkey callback received error: %s\n", emsg); | 3262 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
3263 | "Hostkey callback received error: %s\n", emsg); | ||
2879 | } | 3264 | } |
2880 | 3265 | ||
2881 | #if VERBOSE > 1 | 3266 | #if VERBOSE > 1 |
2882 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 3267 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
2883 | "Hostkey (%d/%d) created for peer `%s'\n", | 3268 | "Hostkey (%d/%d) created for peer `%s'\n", |
2884 | num_peers - peers_left, num_peers, GNUNET_i2s(id)); | 3269 | num_peers - peers_left, num_peers, GNUNET_i2s(id)); |
2885 | #endif | 3270 | #endif |
2886 | 3271 | ||
2887 | peers_left--; | 3272 | peers_left--; |
2888 | if (GNUNET_YES == update_meter(hostkey_meter)) | 3273 | if (GNUNET_YES == update_meter (hostkey_meter)) |
2889 | { | 3274 | { |
2890 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 3275 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
2891 | "All %d hostkeys created, now creating topology!\n", | 3276 | "All %d hostkeys created, now creating topology!\n", |
2892 | num_peers); | 3277 | num_peers); |
2893 | GNUNET_SCHEDULER_cancel (die_task); | 3278 | GNUNET_SCHEDULER_cancel (die_task); |
2894 | /* Set up task in case topology creation doesn't finish | 3279 | /* Set up task in case topology creation doesn't finish |
2895 | * within a reasonable amount of time */ | 3280 | * within a reasonable amount of time */ |
2896 | die_task = GNUNET_SCHEDULER_add_delayed (DEFAULT_TOPOLOGY_TIMEOUT, | 3281 | die_task = GNUNET_SCHEDULER_add_delayed (DEFAULT_TOPOLOGY_TIMEOUT, |
2897 | &end_badly, "from create_topology"); | 3282 | &end_badly, |
2898 | GNUNET_SCHEDULER_add_now(&create_topology, NULL); | 3283 | "from create_topology"); |
2899 | ok = 0; | 3284 | GNUNET_SCHEDULER_add_now (&create_topology, NULL); |
2900 | } | 3285 | ok = 0; |
3286 | } | ||
2901 | } | 3287 | } |
2902 | 3288 | ||
2903 | |||
2904 | static void | 3289 | static void |
2905 | run (void *cls, | 3290 | run(void *cls, char * const *args, const char *cfgfile, |
2906 | char *const *args, | 3291 | const struct GNUNET_CONFIGURATION_Handle *cfg) |
2907 | const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
2908 | { | 3292 | { |
2909 | struct stat frstat; | 3293 | struct stat frstat; |
2910 | struct GNUNET_DHTLOG_TrialInfo trial_info; | 3294 | struct GNUNET_DHTLOG_TrialInfo trial_info; |
@@ -2923,7 +3307,6 @@ run (void *cls, | |||
2923 | char *hostfile; | 3307 | char *hostfile; |
2924 | float topology_probability; | 3308 | float topology_probability; |
2925 | unsigned long long temp_config_number; | 3309 | unsigned long long temp_config_number; |
2926 | unsigned long long trial_to_run; | ||
2927 | int stop_closest; | 3310 | int stop_closest; |
2928 | int stop_found; | 3311 | int stop_found; |
2929 | int strict_kademlia; | 3312 | int strict_kademlia; |
@@ -2938,71 +3321,86 @@ run (void *cls, | |||
2938 | 3321 | ||
2939 | config = cfg; | 3322 | config = cfg; |
2940 | rounds_finished = 0; | 3323 | rounds_finished = 0; |
2941 | memset(&trial_info, 0, sizeof(struct GNUNET_DHTLOG_TrialInfo)); | 3324 | memset (&trial_info, 0, sizeof(struct GNUNET_DHTLOG_TrialInfo)); |
2942 | /* Get path from configuration file */ | 3325 | /* Get path from configuration file */ |
2943 | if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string(cfg, "paths", "servicehome", &test_directory)) | 3326 | if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string (cfg, "paths", |
3327 | "servicehome", | ||
3328 | &test_directory)) | ||
2944 | { | 3329 | { |
2945 | ok = 404; | 3330 | ok = 404; |
2946 | return; | 3331 | return; |
2947 | } | 3332 | } |
2948 | 3333 | ||
2949 | /* Get number of peers to start from configuration */ | 3334 | /* Get number of peers to start from configuration */ |
2950 | if (GNUNET_SYSERR == | 3335 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, "testing", |
2951 | GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers", | 3336 | "num_peers", |
2952 | &num_peers)) | 3337 | &num_peers)) |
2953 | { | 3338 | { |
2954 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 3339 | GNUNET_log ( |
2955 | "Number of peers must be specified in section %s option %s\n", "TESTING", "NUM_PEERS"); | 3340 | GNUNET_ERROR_TYPE_WARNING, |
3341 | "Number of peers must be specified in section %s option %s\n", | ||
3342 | "TESTING", "NUM_PEERS"); | ||
2956 | } | 3343 | } |
2957 | GNUNET_assert(num_peers > 0 && num_peers < ULONG_MAX); | 3344 | GNUNET_assert(num_peers > 0 && num_peers < ULONG_MAX); |
2958 | 3345 | ||
2959 | if (GNUNET_OK == | 3346 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "testing", |
2960 | GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "connect_timeout", | 3347 | "connect_timeout", |
2961 | &temp_config_number)) | 3348 | &temp_config_number)) |
2962 | connect_timeout = | 3349 | connect_timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, |
2963 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, temp_config_number); | 3350 | temp_config_number); |
2964 | else | 3351 | else |
2965 | { | 3352 | { |
2966 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n", "testing", "connect_timeout"); | 3353 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n", |
3354 | "testing", "connect_timeout"); | ||
2967 | return; | 3355 | return; |
2968 | } | 3356 | } |
2969 | 3357 | ||
2970 | 3358 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, "testing", | |
2971 | if (GNUNET_OK != | 3359 | "connect_attempts", |
2972 | GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "connect_attempts", | 3360 | &connect_attempts)) |
2973 | &connect_attempts)) | ||
2974 | { | 3361 | { |
2975 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n", "testing", "connect_attempts"); | 3362 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n", |
3363 | "testing", "connect_attempts"); | ||
2976 | return; | 3364 | return; |
2977 | } | 3365 | } |
2978 | 3366 | ||
2979 | if (GNUNET_OK != | 3367 | if (GNUNET_OK |
2980 | GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "max_outstanding_connections", | 3368 | != GNUNET_CONFIGURATION_get_value_number (cfg, "testing", |
2981 | &max_outstanding_connections)) | 3369 | "max_outstanding_connections", |
3370 | &max_outstanding_connections)) | ||
2982 | { | 3371 | { |
2983 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n", "testing", "max_outstanding_connections"); | 3372 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n", |
3373 | "testing", "max_outstanding_connections"); | ||
2984 | return; | 3374 | return; |
2985 | } | 3375 | } |
2986 | 3376 | ||
2987 | if (GNUNET_OK != | 3377 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, "testing", |
2988 | GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "max_concurrent_ssh", | 3378 | "max_concurrent_ssh", |
2989 | &max_concurrent_ssh)) | 3379 | &max_concurrent_ssh)) |
2990 | { | 3380 | { |
2991 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n", "testing", "max_concurrent_ssh"); | 3381 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n", |
3382 | "testing", "max_concurrent_ssh"); | ||
2992 | return; | 3383 | return; |
2993 | } | 3384 | } |
2994 | 3385 | ||
2995 | /** | 3386 | /** |
2996 | * Get DHT specific testing options. | 3387 | * Get DHT specific testing options. |
2997 | */ | 3388 | */ |
2998 | if ((GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht_testing", "mysql_logging")) || | 3389 | if ((GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (cfg, "dht_testing", |
2999 | (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht_testing", "mysql_logging_extended")) || | 3390 | "mysql_logging")) |
3000 | (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht_testing", "mysql_logging_minimal"))) | 3391 | || (GNUNET_YES |
3001 | { | 3392 | == GNUNET_CONFIGURATION_get_value_yesno (cfg, "dht_testing", |
3002 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht_testing", "mysql_logging_minimal")) | 3393 | "mysql_logging_extended")) |
3394 | || (GNUNET_YES | ||
3395 | == GNUNET_CONFIGURATION_get_value_yesno (cfg, "dht_testing", | ||
3396 | "mysql_logging_minimal"))) | ||
3397 | { | ||
3398 | if (GNUNET_YES | ||
3399 | == GNUNET_CONFIGURATION_get_value_yesno (cfg, "dht_testing", | ||
3400 | "mysql_logging_minimal")) | ||
3003 | dhtlog_minimal = GNUNET_YES; | 3401 | dhtlog_minimal = GNUNET_YES; |
3004 | 3402 | ||
3005 | dhtlog_handle = GNUNET_DHTLOG_connect(cfg); | 3403 | dhtlog_handle = GNUNET_DHTLOG_connect (cfg); |
3006 | if (dhtlog_handle == NULL) | 3404 | if (dhtlog_handle == NULL) |
3007 | { | 3405 | { |
3008 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 3406 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
@@ -3012,33 +3410,36 @@ run (void *cls, | |||
3012 | } | 3410 | } |
3013 | } | 3411 | } |
3014 | 3412 | ||
3015 | stop_closest = GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht", "stop_on_closest"); | 3413 | stop_closest = GNUNET_CONFIGURATION_get_value_yesno (cfg, "dht", |
3414 | "stop_on_closest"); | ||
3016 | if (stop_closest == GNUNET_SYSERR) | 3415 | if (stop_closest == GNUNET_SYSERR) |
3017 | stop_closest = GNUNET_NO; | 3416 | stop_closest = GNUNET_NO; |
3018 | 3417 | ||
3019 | stop_found = GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht", "stop_found"); | 3418 | stop_found = GNUNET_CONFIGURATION_get_value_yesno (cfg, "dht", "stop_found"); |
3020 | if (stop_found == GNUNET_SYSERR) | 3419 | if (stop_found == GNUNET_SYSERR) |
3021 | stop_found = GNUNET_NO; | 3420 | stop_found = GNUNET_NO; |
3022 | 3421 | ||
3023 | strict_kademlia = GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht", "strict_kademlia"); | 3422 | strict_kademlia = GNUNET_CONFIGURATION_get_value_yesno (cfg, "dht", |
3423 | "strict_kademlia"); | ||
3024 | if (strict_kademlia == GNUNET_SYSERR) | 3424 | if (strict_kademlia == GNUNET_SYSERR) |
3025 | strict_kademlia = GNUNET_NO; | 3425 | strict_kademlia = GNUNET_NO; |
3026 | 3426 | ||
3027 | if (GNUNET_OK != | 3427 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "dht_testing", |
3028 | GNUNET_CONFIGURATION_get_value_string (cfg, "dht_testing", "comment", | 3428 | "comment", |
3029 | &trialmessage)) | 3429 | &trialmessage)) |
3030 | trialmessage = NULL; | 3430 | trialmessage = NULL; |
3031 | 3431 | ||
3032 | churn_data = NULL; | 3432 | churn_data = NULL; |
3033 | /** Check for a churn file to do churny simulation */ | 3433 | /** Check for a churn file to do churny simulation */ |
3034 | if (GNUNET_OK == | 3434 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (cfg, "dht_testing", |
3035 | GNUNET_CONFIGURATION_get_value_string(cfg, "dht_testing", "churn_file", | 3435 | "churn_file", |
3036 | &churn_filename)) | 3436 | &churn_filename)) |
3037 | { | 3437 | { |
3038 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Reading churn data from %s\n", churn_filename); | 3438 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Reading churn data from %s\n", |
3439 | churn_filename); | ||
3039 | if (GNUNET_OK != GNUNET_DISK_file_test (churn_filename)) | 3440 | if (GNUNET_OK != GNUNET_DISK_file_test (churn_filename)) |
3040 | { | 3441 | { |
3041 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Error reading churn file!\n"); | 3442 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Error reading churn file!\n"); |
3042 | GNUNET_free_non_null(trialmessage); | 3443 | GNUNET_free_non_null(trialmessage); |
3043 | GNUNET_free(churn_filename); | 3444 | GNUNET_free(churn_filename); |
3044 | return; | 3445 | return; |
@@ -3055,11 +3456,13 @@ run (void *cls, | |||
3055 | 3456 | ||
3056 | churn_data = GNUNET_malloc_large (frstat.st_size); | 3457 | churn_data = GNUNET_malloc_large (frstat.st_size); |
3057 | GNUNET_assert(churn_data != NULL); | 3458 | GNUNET_assert(churn_data != NULL); |
3058 | if (frstat.st_size != | 3459 | if (frstat.st_size != GNUNET_DISK_fn_read (churn_filename, churn_data, |
3059 | GNUNET_DISK_fn_read (churn_filename, churn_data, frstat.st_size)) | 3460 | frstat.st_size)) |
3060 | { | 3461 | { |
3061 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 3462 | GNUNET_log ( |
3062 | "Could not read file %s specified for churn, ending test!", churn_filename); | 3463 | GNUNET_ERROR_TYPE_ERROR, |
3464 | "Could not read file %s specified for churn, ending test!", | ||
3465 | churn_filename); | ||
3063 | GNUNET_free (churn_filename); | 3466 | GNUNET_free (churn_filename); |
3064 | GNUNET_free (churn_data); | 3467 | GNUNET_free (churn_data); |
3065 | GNUNET_free_non_null(trialmessage); | 3468 | GNUNET_free_non_null(trialmessage); |
@@ -3077,24 +3480,29 @@ run (void *cls, | |||
3077 | if (((churn_data[count] == '\n')) && (buf != &churn_data[count])) | 3480 | if (((churn_data[count] == '\n')) && (buf != &churn_data[count])) |
3078 | { | 3481 | { |
3079 | churn_data[count] = '\0'; | 3482 | churn_data[count] = '\0'; |
3080 | if (1 != sscanf(buf, "%u", &churn_rounds)) | 3483 | if (1 != sscanf (buf, "%u", &churn_rounds)) |
3081 | { | 3484 | { |
3082 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Failed to read number of rounds from churn file, ending test!\n"); | 3485 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
3486 | "Failed to read number of rounds from churn file, ending test!\n"); | ||
3083 | ret = 4200; | 3487 | ret = 4200; |
3084 | GNUNET_free_non_null(trialmessage); | 3488 | GNUNET_free_non_null(trialmessage); |
3085 | GNUNET_free_non_null(churn_data); | 3489 | GNUNET_free_non_null(churn_data); |
3086 | return; | 3490 | return; |
3087 | } | 3491 | } |
3088 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Read %u rounds from churn file\n", churn_rounds); | 3492 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
3493 | "Read %u rounds from churn file\n", churn_rounds); | ||
3089 | buf = &churn_data[count + 1]; | 3494 | buf = &churn_data[count + 1]; |
3090 | churn_array = GNUNET_malloc(sizeof(unsigned int) * churn_rounds); | 3495 | churn_array = GNUNET_malloc(sizeof(unsigned int) * churn_rounds); |
3091 | break; /* Done with this part */ | 3496 | break; /* Done with this part */ |
3092 | } | 3497 | } |
3093 | } | 3498 | } |
3094 | 3499 | ||
3095 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, "dht_testing", "churns_per_round", &churns_per_round)) | 3500 | if (GNUNET_OK |
3501 | != GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", | ||
3502 | "churns_per_round", | ||
3503 | &churns_per_round)) | ||
3096 | { | 3504 | { |
3097 | churns_per_round = (unsigned long long)churn_rounds; | 3505 | churns_per_round = (unsigned long long) churn_rounds; |
3098 | } | 3506 | } |
3099 | 3507 | ||
3100 | line_number = 0; | 3508 | line_number = 0; |
@@ -3105,15 +3513,18 @@ run (void *cls, | |||
3105 | { | 3513 | { |
3106 | churn_data[count] = '\0'; | 3514 | churn_data[count] = '\0'; |
3107 | 3515 | ||
3108 | ret = sscanf(buf, "%u", &churn_array[line_number]); | 3516 | ret = sscanf (buf, "%u", &churn_array[line_number]); |
3109 | if (1 == ret) | 3517 | if (1 == ret) |
3110 | { | 3518 | { |
3111 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Read %u peers in round %u\n", churn_array[line_number], line_number); | 3519 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
3520 | "Read %u peers in round %u\n", | ||
3521 | churn_array[line_number], line_number); | ||
3112 | line_number++; | 3522 | line_number++; |
3113 | } | 3523 | } |
3114 | else | 3524 | else |
3115 | { | 3525 | { |
3116 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Error reading line `%s' in hostfile\n", buf); | 3526 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
3527 | "Error reading line `%s' in hostfile\n", buf); | ||
3117 | buf = &churn_data[count + 1]; | 3528 | buf = &churn_data[count + 1]; |
3118 | continue; | 3529 | continue; |
3119 | } | 3530 | } |
@@ -3126,9 +3537,9 @@ run (void *cls, | |||
3126 | GNUNET_free_non_null(churn_data); | 3537 | GNUNET_free_non_null(churn_data); |
3127 | 3538 | ||
3128 | /* Check for a hostfile containing user@host:port triples */ | 3539 | /* Check for a hostfile containing user@host:port triples */ |
3129 | if (GNUNET_OK != | 3540 | if (GNUNET_OK |
3130 | GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "hostfile", | 3541 | != GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "hostfile", |
3131 | &hostfile)) | 3542 | &hostfile)) |
3132 | hostfile = NULL; | 3543 | hostfile = NULL; |
3133 | 3544 | ||
3134 | hosts = NULL; | 3545 | hosts = NULL; |
@@ -3137,7 +3548,7 @@ run (void *cls, | |||
3137 | if (hostfile != NULL) | 3548 | if (hostfile != NULL) |
3138 | { | 3549 | { |
3139 | if (GNUNET_OK != GNUNET_DISK_file_test (hostfile)) | 3550 | if (GNUNET_OK != GNUNET_DISK_file_test (hostfile)) |
3140 | GNUNET_DISK_fn_write (hostfile, NULL, 0, GNUNET_DISK_PERM_USER_READ | 3551 | GNUNET_DISK_fn_write (hostfile, NULL, 0, GNUNET_DISK_PERM_USER_READ |
3141 | | GNUNET_DISK_PERM_USER_WRITE); | 3552 | | GNUNET_DISK_PERM_USER_WRITE); |
3142 | if ((0 != STAT (hostfile, &frstat)) || (frstat.st_size == 0)) | 3553 | if ((0 != STAT (hostfile, &frstat)) || (frstat.st_size == 0)) |
3143 | { | 3554 | { |
@@ -3149,159 +3560,180 @@ run (void *cls, | |||
3149 | return; | 3560 | return; |
3150 | } | 3561 | } |
3151 | 3562 | ||
3152 | data = GNUNET_malloc_large (frstat.st_size); | 3563 | data = GNUNET_malloc_large (frstat.st_size); |
3153 | GNUNET_assert(data != NULL); | 3564 | GNUNET_assert(data != NULL); |
3154 | if (frstat.st_size != | 3565 | if (frstat.st_size |
3155 | GNUNET_DISK_fn_read (hostfile, data, frstat.st_size)) | 3566 | != GNUNET_DISK_fn_read (hostfile, data, frstat.st_size)) |
3156 | { | 3567 | { |
3157 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 3568 | GNUNET_log ( |
3158 | "Could not read file %s specified for host list, ending test!", hostfile); | 3569 | GNUNET_ERROR_TYPE_ERROR, |
3159 | GNUNET_free (hostfile); | 3570 | "Could not read file %s specified for host list, ending test!", |
3160 | GNUNET_free (data); | 3571 | hostfile); |
3161 | GNUNET_free_non_null(trialmessage); | 3572 | GNUNET_free (hostfile); |
3162 | return; | 3573 | GNUNET_free (data); |
3163 | } | 3574 | GNUNET_free_non_null(trialmessage); |
3575 | return; | ||
3576 | } | ||
3164 | 3577 | ||
3165 | GNUNET_free_non_null(hostfile); | 3578 | GNUNET_free_non_null(hostfile); |
3166 | 3579 | ||
3167 | buf = data; | 3580 | buf = data; |
3168 | count = 0; | 3581 | count = 0; |
3169 | while (count < frstat.st_size - 1) | 3582 | while (count < frstat.st_size - 1) |
3170 | { | 3583 | { |
3171 | count++; | 3584 | count++; |
3172 | /* if (((data[count] == '\n') || (data[count] == '\0')) && (buf != &data[count]))*/ | 3585 | /* if (((data[count] == '\n') || (data[count] == '\0')) && (buf != &data[count]))*/ |
3173 | if (((data[count] == '\n')) && (buf != &data[count])) | 3586 | if (((data[count] == '\n')) && (buf != &data[count])) |
3174 | { | 3587 | { |
3175 | data[count] = '\0'; | 3588 | data[count] = '\0'; |
3176 | temphost = GNUNET_malloc(sizeof(struct GNUNET_TESTING_Host)); | 3589 | temphost = GNUNET_malloc(sizeof(struct GNUNET_TESTING_Host)); |
3177 | ret = sscanf(buf, "%a[a-zA-Z0-9_]@%a[a-zA-Z0-9.]:%hd", &temphost->username, &temphost->hostname, &temphost->port); | 3590 | ret = sscanf (buf, "%a[a-zA-Z0-9_]@%a[a-zA-Z0-9.]:%hd", |
3178 | if (3 == ret) | 3591 | &temphost->username, &temphost->hostname, |
3179 | { | 3592 | &temphost->port); |
3180 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Successfully read host %s, port %d and user %s from file\n", temphost->hostname, temphost->port, temphost->username); | 3593 | if (3 == ret) |
3181 | } | 3594 | { |
3182 | else | 3595 | GNUNET_log ( |
3183 | { | 3596 | GNUNET_ERROR_TYPE_WARNING, |
3184 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Error reading line `%s' in hostfile\n", buf); | 3597 | "Successfully read host %s, port %d and user %s from file\n", |
3185 | GNUNET_free(temphost); | 3598 | temphost->hostname, temphost->port, |
3186 | buf = &data[count + 1]; | 3599 | temphost->username); |
3187 | continue; | 3600 | } |
3188 | } | 3601 | else |
3189 | /* temphost->hostname = buf; */ | 3602 | { |
3190 | temphost->next = hosts; | 3603 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
3191 | hosts = temphost; | 3604 | "Error reading line `%s' in hostfile\n", buf); |
3605 | GNUNET_free(temphost); | ||
3606 | buf = &data[count + 1]; | ||
3607 | continue; | ||
3608 | } | ||
3609 | /* temphost->hostname = buf; */ | ||
3610 | temphost->next = hosts; | ||
3611 | hosts = temphost; | ||
3612 | buf = &data[count + 1]; | ||
3613 | } | ||
3614 | else if ((data[count] == '\n') || (data[count] == '\0')) | ||
3192 | buf = &data[count + 1]; | 3615 | buf = &data[count + 1]; |
3193 | } | 3616 | } |
3194 | else if ((data[count] == '\n') || (data[count] == '\0')) | ||
3195 | buf = &data[count + 1]; | ||
3196 | } | ||
3197 | } | 3617 | } |
3198 | GNUNET_free_non_null(data); | 3618 | GNUNET_free_non_null(data); |
3199 | if (GNUNET_OK != | 3619 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3200 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "malicious_getters", | 3620 | "malicious_getters", |
3201 | &malicious_getters)) | 3621 | &malicious_getters)) |
3202 | malicious_getters = 0; | 3622 | malicious_getters = 0; |
3203 | 3623 | ||
3204 | if (GNUNET_OK != | 3624 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3205 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "malicious_putters", | 3625 | "malicious_putters", |
3206 | &malicious_putters)) | 3626 | &malicious_putters)) |
3207 | malicious_putters = 0; | 3627 | malicious_putters = 0; |
3208 | 3628 | ||
3209 | if (GNUNET_OK != | 3629 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3210 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "malicious_droppers", | 3630 | "malicious_droppers", |
3211 | &malicious_droppers)) | 3631 | &malicious_droppers)) |
3212 | malicious_droppers = 0; | 3632 | malicious_droppers = 0; |
3213 | 3633 | ||
3214 | if (GNUNET_OK != | 3634 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3215 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "settle_time", | 3635 | "settle_time", |
3216 | &settle_time)) | 3636 | &settle_time)) |
3217 | settle_time = 0; | 3637 | settle_time = 0; |
3218 | 3638 | ||
3219 | if (GNUNET_SYSERR == | 3639 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, |
3220 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "num_puts", | 3640 | "dht_testing", |
3221 | &num_puts)) | 3641 | "num_puts", |
3642 | &num_puts)) | ||
3222 | num_puts = num_peers; | 3643 | num_puts = num_peers; |
3223 | 3644 | ||
3224 | if (GNUNET_SYSERR == | 3645 | if (GNUNET_SYSERR |
3225 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "put_replication", | 3646 | == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3226 | &put_replication)) | 3647 | "put_replication", |
3648 | &put_replication)) | ||
3227 | put_replication = DEFAULT_PUT_REPLICATION; | 3649 | put_replication = DEFAULT_PUT_REPLICATION; |
3228 | 3650 | ||
3229 | if (GNUNET_SYSERR == | 3651 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, |
3230 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "num_gets", | 3652 | "dht_testing", |
3231 | &num_gets)) | 3653 | "num_gets", |
3654 | &num_gets)) | ||
3232 | num_gets = num_peers; | 3655 | num_gets = num_peers; |
3233 | 3656 | ||
3234 | if (GNUNET_SYSERR == | 3657 | if (GNUNET_SYSERR |
3235 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "get_replication", | 3658 | == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3236 | &get_replication)) | 3659 | "get_replication", |
3237 | get_replication = DEFAULT_GET_REPLICATION; | 3660 | &get_replication)) |
3661 | get_replication = DEFAULT_GET_REPLICATION; | ||
3238 | 3662 | ||
3239 | if (GNUNET_OK == | 3663 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3240 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "find_peer_delay", | 3664 | "find_peer_delay", |
3241 | &temp_config_number)) | 3665 | &temp_config_number)) |
3242 | find_peer_delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number); | 3666 | find_peer_delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, |
3667 | temp_config_number); | ||
3243 | else | 3668 | else |
3244 | find_peer_delay = DEFAULT_FIND_PEER_DELAY; | 3669 | find_peer_delay = DEFAULT_FIND_PEER_DELAY; |
3245 | 3670 | ||
3246 | if (GNUNET_OK == | 3671 | if (GNUNET_OK |
3247 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "concurrent_find_peers", | 3672 | == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3248 | &temp_config_number)) | 3673 | "concurrent_find_peers", |
3674 | &temp_config_number)) | ||
3249 | max_outstanding_find_peers = temp_config_number; | 3675 | max_outstanding_find_peers = temp_config_number; |
3250 | else | 3676 | else |
3251 | max_outstanding_find_peers = DEFAULT_MAX_OUTSTANDING_FIND_PEERS; | 3677 | max_outstanding_find_peers = DEFAULT_MAX_OUTSTANDING_FIND_PEERS; |
3252 | 3678 | ||
3253 | if (GNUNET_OK == | 3679 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3254 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "get_timeout", | 3680 | "get_timeout", |
3255 | &temp_config_number)) | 3681 | &temp_config_number)) |
3256 | get_timeout = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number); | 3682 | get_timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, |
3683 | temp_config_number); | ||
3257 | else | 3684 | else |
3258 | get_timeout = DEFAULT_GET_TIMEOUT; | 3685 | get_timeout = DEFAULT_GET_TIMEOUT; |
3259 | 3686 | ||
3260 | if (GNUNET_OK == | 3687 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3261 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "concurrent_puts", | 3688 | "concurrent_puts", |
3262 | &temp_config_number)) | 3689 | &temp_config_number)) |
3263 | max_outstanding_puts = temp_config_number; | 3690 | max_outstanding_puts = temp_config_number; |
3264 | else | 3691 | else |
3265 | max_outstanding_puts = DEFAULT_MAX_OUTSTANDING_PUTS; | 3692 | max_outstanding_puts = DEFAULT_MAX_OUTSTANDING_PUTS; |
3266 | 3693 | ||
3267 | if (GNUNET_OK == | 3694 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3268 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "concurrent_gets", | 3695 | "concurrent_gets", |
3269 | &temp_config_number)) | 3696 | &temp_config_number)) |
3270 | max_outstanding_gets = temp_config_number; | 3697 | max_outstanding_gets = temp_config_number; |
3271 | else | 3698 | else |
3272 | max_outstanding_gets = DEFAULT_MAX_OUTSTANDING_GETS; | 3699 | max_outstanding_gets = DEFAULT_MAX_OUTSTANDING_GETS; |
3273 | 3700 | ||
3274 | if (GNUNET_OK == | 3701 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3275 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "timeout", | 3702 | "timeout", |
3276 | &temp_config_number)) | 3703 | &temp_config_number)) |
3277 | all_get_timeout = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number); | 3704 | all_get_timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, |
3705 | temp_config_number); | ||
3278 | else | 3706 | else |
3279 | all_get_timeout.rel_value = get_timeout.rel_value * num_gets; | 3707 | all_get_timeout.rel_value = get_timeout.rel_value * num_gets; |
3280 | 3708 | ||
3281 | if (GNUNET_OK == | 3709 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3282 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "get_delay", | 3710 | "get_delay", |
3283 | &temp_config_number)) | 3711 | &temp_config_number)) |
3284 | get_delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number); | 3712 | get_delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, |
3713 | temp_config_number); | ||
3285 | else | 3714 | else |
3286 | get_delay = DEFAULT_GET_DELAY; | 3715 | get_delay = DEFAULT_GET_DELAY; |
3287 | 3716 | ||
3288 | if (GNUNET_OK == | 3717 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3289 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "put_delay", | 3718 | "put_delay", |
3290 | &temp_config_number)) | 3719 | &temp_config_number)) |
3291 | put_delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number); | 3720 | put_delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, |
3721 | temp_config_number); | ||
3292 | else | 3722 | else |
3293 | put_delay = DEFAULT_PUT_DELAY; | 3723 | put_delay = DEFAULT_PUT_DELAY; |
3294 | 3724 | ||
3295 | if (GNUNET_OK == | 3725 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3296 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "peer_start_timeout", | 3726 | "peer_start_timeout", |
3297 | &temp_config_number)) | 3727 | &temp_config_number)) |
3298 | seconds_per_peer_start = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number); | 3728 | seconds_per_peer_start |
3729 | = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, | ||
3730 | temp_config_number); | ||
3299 | else | 3731 | else |
3300 | seconds_per_peer_start = DEFAULT_SECONDS_PER_PEER_START; | 3732 | seconds_per_peer_start = DEFAULT_SECONDS_PER_PEER_START; |
3301 | 3733 | ||
3302 | if (GNUNET_OK == | 3734 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3303 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "data_size", | 3735 | "data_size", |
3304 | &temp_config_number)) | 3736 | &temp_config_number)) |
3305 | test_data_size = temp_config_number; | 3737 | test_data_size = temp_config_number; |
3306 | else | 3738 | else |
3307 | test_data_size = DEFAULT_TEST_DATA_SIZE; | 3739 | test_data_size = DEFAULT_TEST_DATA_SIZE; |
@@ -3309,34 +3741,40 @@ run (void *cls, | |||
3309 | /** | 3741 | /** |
3310 | * Get testing related options. | 3742 | * Get testing related options. |
3311 | */ | 3743 | */ |
3312 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "DHT_TESTING", "REPLICATE_SAME")) | 3744 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (cfg, "DHT_TESTING", |
3745 | "REPLICATE_SAME")) | ||
3313 | replicate_same = GNUNET_YES; | 3746 | replicate_same = GNUNET_YES; |
3314 | 3747 | ||
3315 | /** | 3748 | /** |
3316 | * Get testing related options. | 3749 | * Get testing related options. |
3317 | */ | 3750 | */ |
3318 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "DHT_TESTING", "GET_FROM_SAME")) | 3751 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (cfg, "DHT_TESTING", |
3752 | "GET_FROM_SAME")) | ||
3319 | get_from_same = GNUNET_YES; | 3753 | get_from_same = GNUNET_YES; |
3320 | 3754 | ||
3321 | 3755 | if (GNUNET_NO | |
3322 | if (GNUNET_NO == GNUNET_CONFIGURATION_get_value_time (cfg, "DHT_TESTING", | 3756 | == GNUNET_CONFIGURATION_get_value_time (cfg, "DHT_TESTING", |
3323 | "MALICIOUS_GET_FREQUENCY", | 3757 | "MALICIOUS_GET_FREQUENCY", |
3324 | &malicious_get_frequency)) | 3758 | &malicious_get_frequency)) |
3325 | malicious_get_frequency = DEFAULT_MALICIOUS_GET_FREQUENCY; | 3759 | malicious_get_frequency = DEFAULT_MALICIOUS_GET_FREQUENCY; |
3326 | 3760 | ||
3327 | 3761 | if (GNUNET_NO | |
3328 | if (GNUNET_NO == GNUNET_CONFIGURATION_get_value_time (cfg, "DHT_TESTING", | 3762 | == GNUNET_CONFIGURATION_get_value_time (cfg, "DHT_TESTING", |
3329 | "MALICIOUS_PUT_FREQUENCY", | 3763 | "MALICIOUS_PUT_FREQUENCY", |
3330 | &malicious_put_frequency)) | 3764 | &malicious_put_frequency)) |
3331 | malicious_put_frequency = DEFAULT_MALICIOUS_PUT_FREQUENCY; | 3765 | malicious_put_frequency = DEFAULT_MALICIOUS_PUT_FREQUENCY; |
3332 | 3766 | ||
3333 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "DHT_TESTING", "MALICIOUS_AFTER_SETTLE")) | 3767 | if (GNUNET_YES |
3768 | == GNUNET_CONFIGURATION_get_value_yesno (cfg, "DHT_TESTING", | ||
3769 | "MALICIOUS_AFTER_SETTLE")) | ||
3334 | malicious_after_settle = GNUNET_YES; | 3770 | malicious_after_settle = GNUNET_YES; |
3335 | 3771 | ||
3336 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "DHT_TESTING", "MALICIOUS_SYBIL")) | 3772 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (cfg, "DHT_TESTING", |
3773 | "MALICIOUS_SYBIL")) | ||
3337 | { | 3774 | { |
3338 | /* Set up the malicious target at random for this round */ | 3775 | /* Set up the malicious target at random for this round */ |
3339 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, &sybil_target); | 3776 | GNUNET_CRYPTO_hash_create_random (GNUNET_CRYPTO_QUALITY_WEAK, |
3777 | &sybil_target); | ||
3340 | malicious_sybil = GNUNET_YES; | 3778 | malicious_sybil = GNUNET_YES; |
3341 | } | 3779 | } |
3342 | 3780 | ||
@@ -3347,84 +3785,87 @@ run (void *cls, | |||
3347 | while (1 << k < malicious_droppers) | 3785 | while (1 << k < malicious_droppers) |
3348 | k++; | 3786 | k++; |
3349 | if (malicious_droppers > 0) | 3787 | if (malicious_droppers > 0) |
3350 | malicious_bloom = GNUNET_CONTAINER_bloomfilter_init (NULL, 1 << k, DHT_BLOOM_K); | 3788 | malicious_bloom = GNUNET_CONTAINER_bloomfilter_init (NULL, 1 << k, |
3789 | DHT_BLOOM_K); | ||
3351 | 3790 | ||
3352 | /* The normal behavior of the DHT is to do find peer requests | 3791 | /* The normal behavior of the DHT is to do find peer requests |
3353 | * on its own. Only if this is explicitly turned off should | 3792 | * on its own. Only if this is explicitly turned off should |
3354 | * the testing driver issue find peer requests (even though | 3793 | * the testing driver issue find peer requests (even though |
3355 | * this is likely the default when testing). | 3794 | * this is likely the default when testing). |
3356 | */ | 3795 | */ |
3357 | if (GNUNET_NO == | 3796 | if (GNUNET_NO == GNUNET_CONFIGURATION_get_value_yesno (cfg, "dht", |
3358 | GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht", | 3797 | "do_find_peer")) |
3359 | "do_find_peer")) | 3798 | do_find_peer = GNUNET_YES; |
3360 | { | ||
3361 | do_find_peer = GNUNET_YES; | ||
3362 | } | ||
3363 | 3799 | ||
3364 | if (GNUNET_YES == | 3800 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (cfg, "dht", |
3365 | GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht", | 3801 | "republish")) |
3366 | "republish")) | 3802 | in_dht_replication = GNUNET_YES; |
3367 | { | ||
3368 | in_dht_replication = GNUNET_YES; | ||
3369 | } | ||
3370 | 3803 | ||
3371 | if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_number (cfg, "DHT_TESTING", | 3804 | if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_number (cfg, "DHT_TESTING", |
3372 | "TRIAL_TO_RUN", | 3805 | "TRIAL_TO_RUN", |
3373 | &trial_to_run)) | 3806 | &trial_to_run)) |
3374 | { | 3807 | trial_to_run = 0; |
3375 | trial_to_run = 0; | 3808 | |
3376 | } | 3809 | if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_number (cfg, "DHT_TESTING", |
3810 | "REVISION", | ||
3811 | &revision)) | ||
3812 | revision = 0; | ||
3377 | 3813 | ||
3378 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_number (cfg, "DHT_TESTING", | 3814 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_number (cfg, "DHT_TESTING", |
3379 | "FIND_PEER_DELAY", | 3815 | "FIND_PEER_DELAY", |
3380 | &temp_config_number)) | 3816 | &temp_config_number)) |
3381 | { | 3817 | find_peer_delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, |
3382 | find_peer_delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, temp_config_number); | 3818 | temp_config_number); |
3383 | } | ||
3384 | else | 3819 | else |
3385 | find_peer_delay = DEFAULT_FIND_PEER_DELAY; | 3820 | find_peer_delay = DEFAULT_FIND_PEER_DELAY; |
3386 | 3821 | ||
3387 | if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_number(cfg, "DHT_TESTING", "ROUND_DELAY", &round_delay)) | 3822 | if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_number (cfg, "DHT_TESTING", |
3823 | "ROUND_DELAY", | ||
3824 | &round_delay)) | ||
3388 | round_delay = 0; | 3825 | round_delay = 0; |
3389 | 3826 | ||
3390 | if (GNUNET_NO == GNUNET_CONFIGURATION_get_value_number (cfg, "DHT_TESTING", | 3827 | if (GNUNET_NO |
3391 | "OUTSTANDING_FIND_PEERS", | 3828 | == GNUNET_CONFIGURATION_get_value_number (cfg, "DHT_TESTING", |
3392 | &max_outstanding_find_peers)) | 3829 | "OUTSTANDING_FIND_PEERS", |
3393 | max_outstanding_find_peers = DEFAULT_MAX_OUTSTANDING_FIND_PEERS; | 3830 | &max_outstanding_find_peers)) |
3831 | max_outstanding_find_peers = DEFAULT_MAX_OUTSTANDING_FIND_PEERS; | ||
3394 | 3832 | ||
3395 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, "dht", "strict_kademlia")) | 3833 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (cfg, "dht", |
3834 | "strict_kademlia")) | ||
3396 | max_outstanding_find_peers = max_outstanding_find_peers * 1; | 3835 | max_outstanding_find_peers = max_outstanding_find_peers * 1; |
3397 | 3836 | ||
3398 | find_peer_offset = GNUNET_TIME_relative_divide (find_peer_delay, max_outstanding_find_peers); | 3837 | find_peer_offset = GNUNET_TIME_relative_divide (find_peer_delay, |
3838 | max_outstanding_find_peers); | ||
3399 | 3839 | ||
3400 | if (GNUNET_SYSERR == | 3840 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_number (cfg, |
3401 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "num_rounds", | 3841 | "dht_testing", |
3402 | &total_rounds)) | 3842 | "num_rounds", |
3403 | { | 3843 | &total_rounds)) |
3404 | total_rounds = 1; | 3844 | total_rounds = 1; |
3405 | } | ||
3406 | 3845 | ||
3407 | if ((GNUNET_SYSERR == | 3846 | if ((GNUNET_SYSERR |
3408 | GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", "target_total_connections", | 3847 | == GNUNET_CONFIGURATION_get_value_number (cfg, "dht_testing", |
3409 | &target_total_connections)) || | 3848 | "target_total_connections", |
3410 | (target_total_connections == 0)) | 3849 | &target_total_connections)) |
3411 | { | 3850 | || (target_total_connections == 0)) |
3412 | target_total_connections = connection_estimate(num_peers, DEFAULT_BUCKET_SIZE); | 3851 | target_total_connections = connection_estimate (num_peers, |
3413 | } | 3852 | DEFAULT_BUCKET_SIZE); |
3414 | 3853 | ||
3415 | topology_str = NULL; | 3854 | topology_str = NULL; |
3416 | if ((GNUNET_YES == | 3855 | if ((GNUNET_YES == GNUNET_CONFIGURATION_get_value_string (cfg, "testing", |
3417 | GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "topology", | 3856 | "topology", |
3418 | &topology_str)) && (GNUNET_NO == GNUNET_TESTING_topology_get(&topology, topology_str))) | 3857 | &topology_str)) |
3858 | && (GNUNET_NO == GNUNET_TESTING_topology_get (&topology, topology_str))) | ||
3419 | { | 3859 | { |
3420 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 3860 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
3421 | "Invalid topology `%s' given for section %s option %s\n", topology_str, "TESTING", "TOPOLOGY"); | 3861 | "Invalid topology `%s' given for section %s option %s\n", |
3862 | topology_str, "TESTING", "TOPOLOGY"); | ||
3422 | topology = GNUNET_TESTING_TOPOLOGY_CLIQUE; /* Defaults to NONE, so set better default here */ | 3863 | topology = GNUNET_TESTING_TOPOLOGY_CLIQUE; /* Defaults to NONE, so set better default here */ |
3423 | } | 3864 | } |
3424 | 3865 | ||
3425 | if (GNUNET_OK != | 3866 | if (GNUNET_OK |
3426 | GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "percentage", | 3867 | != GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "percentage", |
3427 | &topology_percentage_str)) | 3868 | &topology_percentage_str)) |
3428 | topology_percentage = 0.5; | 3869 | topology_percentage = 0.5; |
3429 | else | 3870 | else |
3430 | { | 3871 | { |
@@ -3432,61 +3873,82 @@ run (void *cls, | |||
3432 | GNUNET_free(topology_percentage_str); | 3873 | GNUNET_free(topology_percentage_str); |
3433 | } | 3874 | } |
3434 | 3875 | ||
3435 | if (GNUNET_OK != | 3876 | if (GNUNET_OK |
3436 | GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "probability", | 3877 | != GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "probability", |
3437 | &topology_probability_str)) | 3878 | &topology_probability_str)) |
3438 | topology_probability = 0.5; | 3879 | topology_probability = 0.5; |
3439 | else | 3880 | else |
3440 | { | 3881 | { |
3441 | topology_probability = atof (topology_probability_str); | 3882 | topology_probability = atof (topology_probability_str); |
3442 | GNUNET_free(topology_probability_str); | 3883 | GNUNET_free(topology_probability_str); |
3443 | } | 3884 | } |
3444 | 3885 | ||
3445 | if ((GNUNET_YES == | 3886 | if ((GNUNET_YES |
3446 | GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "connect_topology", | 3887 | == GNUNET_CONFIGURATION_get_value_string (cfg, "testing", |
3447 | &connect_topology_str)) && (GNUNET_NO == GNUNET_TESTING_topology_get(&connect_topology, connect_topology_str))) | 3888 | "connect_topology", |
3889 | &connect_topology_str)) | ||
3890 | && (GNUNET_NO == GNUNET_TESTING_topology_get (&connect_topology, | ||
3891 | connect_topology_str))) | ||
3448 | { | 3892 | { |
3449 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 3893 | GNUNET_log ( |
3450 | "Invalid connect topology `%s' given for section %s option %s\n", connect_topology_str, "TESTING", "CONNECT_TOPOLOGY"); | 3894 | GNUNET_ERROR_TYPE_WARNING, |
3895 | "Invalid connect topology `%s' given for section %s option %s\n", | ||
3896 | connect_topology_str, "TESTING", "CONNECT_TOPOLOGY"); | ||
3451 | } | 3897 | } |
3452 | GNUNET_free_non_null(connect_topology_str); | 3898 | GNUNET_free_non_null(connect_topology_str); |
3453 | 3899 | ||
3454 | if ((GNUNET_YES == | 3900 | if ((GNUNET_YES |
3455 | GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "connect_topology_option", | 3901 | == GNUNET_CONFIGURATION_get_value_string (cfg, "testing", |
3456 | &connect_topology_option_str)) && (GNUNET_NO == GNUNET_TESTING_topology_option_get(&connect_topology_option, connect_topology_option_str))) | 3902 | "connect_topology_option", |
3457 | { | 3903 | &connect_topology_option_str)) |
3458 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 3904 | && (GNUNET_NO |
3459 | "Invalid connect topology option `%s' given for section %s option %s\n", connect_topology_option_str, "TESTING", "CONNECT_TOPOLOGY_OPTION"); | 3905 | == GNUNET_TESTING_topology_option_get (&connect_topology_option, |
3906 | connect_topology_option_str))) | ||
3907 | { | ||
3908 | GNUNET_log ( | ||
3909 | GNUNET_ERROR_TYPE_WARNING, | ||
3910 | "Invalid connect topology option `%s' given for section %s option %s\n", | ||
3911 | connect_topology_option_str, "TESTING", | ||
3912 | "CONNECT_TOPOLOGY_OPTION"); | ||
3460 | connect_topology_option = GNUNET_TESTING_TOPOLOGY_OPTION_ALL; /* Defaults to NONE, set to ALL */ | 3913 | connect_topology_option = GNUNET_TESTING_TOPOLOGY_OPTION_ALL; /* Defaults to NONE, set to ALL */ |
3461 | } | 3914 | } |
3462 | GNUNET_free_non_null(connect_topology_option_str); | 3915 | GNUNET_free_non_null(connect_topology_option_str); |
3463 | 3916 | ||
3464 | if (GNUNET_YES == | 3917 | if (GNUNET_YES |
3465 | GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "connect_topology_option_modifier", | 3918 | == GNUNET_CONFIGURATION_get_value_string ( |
3466 | &connect_topology_option_modifier_string)) | 3919 | cfg, |
3920 | "testing", | ||
3921 | "connect_topology_option_modifier", | ||
3922 | &connect_topology_option_modifier_string)) | ||
3467 | { | 3923 | { |
3468 | if (sscanf(connect_topology_option_modifier_string, "%lf", &connect_topology_option_modifier) != 1) | 3924 | if (sscanf (connect_topology_option_modifier_string, "%lf", |
3469 | { | 3925 | &connect_topology_option_modifier) != 1) |
3470 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 3926 | { |
3471 | _("Invalid value `%s' for option `%s' in section `%s': expected float\n"), | 3927 | GNUNET_log ( |
3472 | connect_topology_option_modifier_string, | 3928 | GNUNET_ERROR_TYPE_WARNING, |
3473 | "connect_topology_option_modifier", | 3929 | _("Invalid value `%s' for option `%s' in section `%s': expected float\n"), |
3474 | "TESTING"); | 3930 | connect_topology_option_modifier_string, |
3475 | } | 3931 | "connect_topology_option_modifier", "TESTING"); |
3932 | } | ||
3476 | GNUNET_free (connect_topology_option_modifier_string); | 3933 | GNUNET_free (connect_topology_option_modifier_string); |
3477 | } | 3934 | } |
3478 | 3935 | ||
3479 | if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "blacklist_transports", | 3936 | if (GNUNET_YES |
3480 | &blacklist_transports)) | 3937 | != GNUNET_CONFIGURATION_get_value_string (cfg, "testing", |
3938 | "blacklist_transports", | ||
3939 | &blacklist_transports)) | ||
3481 | blacklist_transports = NULL; | 3940 | blacklist_transports = NULL; |
3482 | 3941 | ||
3483 | if ((GNUNET_YES == | 3942 | if ((GNUNET_YES |
3484 | GNUNET_CONFIGURATION_get_value_string(cfg, "testing", "blacklist_topology", | 3943 | == GNUNET_CONFIGURATION_get_value_string (cfg, "testing", |
3485 | &blacklist_topology_str)) && | 3944 | "blacklist_topology", |
3486 | (GNUNET_NO == GNUNET_TESTING_topology_get(&blacklist_topology, blacklist_topology_str))) | 3945 | &blacklist_topology_str)) |
3946 | && (GNUNET_NO == GNUNET_TESTING_topology_get (&blacklist_topology, | ||
3947 | blacklist_topology_str))) | ||
3487 | { | 3948 | { |
3488 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 3949 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
3489 | "Invalid topology `%s' given for section %s option %s\n", topology_str, "TESTING", "BLACKLIST_TOPOLOGY"); | 3950 | "Invalid topology `%s' given for section %s option %s\n", |
3951 | topology_str, "TESTING", "BLACKLIST_TOPOLOGY"); | ||
3490 | } | 3952 | } |
3491 | GNUNET_free_non_null(topology_str); | 3953 | GNUNET_free_non_null(topology_str); |
3492 | GNUNET_free_non_null(blacklist_topology_str); | 3954 | GNUNET_free_non_null(blacklist_topology_str); |
@@ -3494,22 +3956,26 @@ run (void *cls, | |||
3494 | /* Set peers_left so we know when all peers started */ | 3956 | /* Set peers_left so we know when all peers started */ |
3495 | peers_left = num_peers; | 3957 | peers_left = num_peers; |
3496 | 3958 | ||
3497 | |||
3498 | /* Set up a task to end testing if peer start fails */ | 3959 | /* Set up a task to end testing if peer start fails */ |
3499 | die_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(seconds_per_peer_start, num_peers), | 3960 | die_task |
3500 | &end_badly, "didn't generate all hostkeys within allowed startup time!"); | 3961 | = GNUNET_SCHEDULER_add_delayed ( |
3962 | GNUNET_TIME_relative_multiply ( | ||
3963 | seconds_per_peer_start, | ||
3964 | num_peers), | ||
3965 | &end_badly, | ||
3966 | "didn't generate all hostkeys within allowed startup time!"); | ||
3501 | 3967 | ||
3502 | if (dhtlog_handle == NULL) | 3968 | if (dhtlog_handle == NULL) |
3503 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 3969 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "dhtlog_handle is NULL!"); |
3504 | "dhtlog_handle is NULL!"); | ||
3505 | 3970 | ||
3506 | trial_info.other_identifier = (unsigned int)trial_to_run; | 3971 | trial_info.other_identifier = (unsigned int) trial_to_run; |
3507 | trial_info.num_nodes = peers_left; | 3972 | trial_info.num_nodes = peers_left; |
3508 | trial_info.topology = topology; | 3973 | trial_info.topology = topology; |
3509 | trial_info.blacklist_topology = blacklist_topology; | 3974 | trial_info.blacklist_topology = blacklist_topology; |
3510 | trial_info.connect_topology = connect_topology; | 3975 | trial_info.connect_topology = connect_topology; |
3511 | trial_info.connect_topology_option = connect_topology_option; | 3976 | trial_info.connect_topology_option = connect_topology_option; |
3512 | trial_info.connect_topology_option_modifier = connect_topology_option_modifier; | 3977 | trial_info.connect_topology_option_modifier |
3978 | = connect_topology_option_modifier; | ||
3513 | trial_info.topology_percentage = topology_percentage; | 3979 | trial_info.topology_percentage = topology_percentage; |
3514 | trial_info.topology_probability = topology_probability; | 3980 | trial_info.topology_probability = topology_probability; |
3515 | trial_info.puts = num_puts; | 3981 | trial_info.puts = num_puts; |
@@ -3532,24 +3998,27 @@ run (void *cls, | |||
3532 | trial_info.message = ""; | 3998 | trial_info.message = ""; |
3533 | 3999 | ||
3534 | if (dhtlog_handle != NULL) | 4000 | if (dhtlog_handle != NULL) |
3535 | dhtlog_handle->insert_trial(&trial_info); | 4001 | dhtlog_handle->insert_trial (&trial_info); |
3536 | 4002 | ||
3537 | GNUNET_free_non_null(trialmessage); | 4003 | GNUNET_free_non_null(trialmessage); |
3538 | 4004 | ||
3539 | hostkey_meter = create_meter(peers_left, "Hostkeys created ", GNUNET_YES); | 4005 | hostkey_meter = create_meter (peers_left, "Hostkeys created ", GNUNET_YES); |
3540 | peer_start_meter = create_meter(peers_left, "Peers started ", GNUNET_YES); | 4006 | peer_start_meter = create_meter (peers_left, "Peers started ", GNUNET_YES); |
3541 | 4007 | ||
3542 | put_meter = create_meter(num_puts, "Puts completed ", GNUNET_YES); | 4008 | put_meter = create_meter (num_puts, "Puts completed ", GNUNET_YES); |
3543 | get_meter = create_meter(num_gets, "Gets completed ", GNUNET_YES); | 4009 | get_meter = create_meter (num_gets, "Gets completed ", GNUNET_YES); |
3544 | pg = GNUNET_TESTING_daemons_start (cfg, | 4010 | pg |
3545 | peers_left, | 4011 | = GNUNET_TESTING_daemons_start ( |
3546 | max_outstanding_connections, | 4012 | cfg, |
3547 | max_concurrent_ssh, | 4013 | peers_left, |
3548 | GNUNET_TIME_relative_multiply(seconds_per_peer_start, num_peers), | 4014 | max_outstanding_connections, |
3549 | &hostkey_callback, NULL, | 4015 | max_concurrent_ssh, |
3550 | &peers_started_callback, NULL, | 4016 | GNUNET_TIME_relative_multiply ( |
3551 | &topology_callback, NULL, | 4017 | seconds_per_peer_start, |
3552 | hosts); | 4018 | num_peers), |
4019 | &hostkey_callback, NULL, | ||
4020 | &peers_started_callback, NULL, | ||
4021 | &topology_callback, NULL, hosts); | ||
3553 | temphost = hosts; | 4022 | temphost = hosts; |
3554 | while (temphost != NULL) | 4023 | while (temphost != NULL) |
3555 | { | 4024 | { |
@@ -3562,23 +4031,23 @@ run (void *cls, | |||
3562 | } | 4031 | } |
3563 | 4032 | ||
3564 | int | 4033 | int |
3565 | main (int argc, char *argv[]) | 4034 | main(int argc, char *argv[]) |
3566 | { | 4035 | { |
3567 | int ret; | 4036 | int ret; |
3568 | struct GNUNET_GETOPT_CommandLineOption options[] = { | 4037 | struct GNUNET_GETOPT_CommandLineOption options[] = |
3569 | GNUNET_GETOPT_OPTION_END | 4038 | { |
3570 | }; | 4039 | GNUNET_GETOPT_OPTION_END }; |
3571 | 4040 | ||
3572 | ret = GNUNET_PROGRAM_run (argc, | 4041 | ret = GNUNET_PROGRAM_run (argc, argv, "gnunet-dht-driver", "nohelp", options, |
3573 | argv, "gnunet-dht-driver", "nohelp", | 4042 | &run, &ok); |
3574 | options, &run, &ok); | ||
3575 | 4043 | ||
3576 | if (malicious_bloom != NULL) | 4044 | if (malicious_bloom != NULL) |
3577 | GNUNET_CONTAINER_bloomfilter_free (malicious_bloom); | 4045 | GNUNET_CONTAINER_bloomfilter_free (malicious_bloom); |
3578 | 4046 | ||
3579 | if (ret != GNUNET_OK) | 4047 | if (ret != GNUNET_OK) |
3580 | { | 4048 | { |
3581 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "`gnunet-dht-driver': Failed with error code %d\n", ret); | 4049 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
4050 | "`gnunet-dht-driver': Failed with error code %d\n", ret); | ||
3582 | } | 4051 | } |
3583 | 4052 | ||
3584 | /** | 4053 | /** |
@@ -3587,7 +4056,8 @@ main (int argc, char *argv[]) | |||
3587 | */ | 4056 | */ |
3588 | if (GNUNET_DISK_directory_remove (test_directory) != GNUNET_OK) | 4057 | if (GNUNET_DISK_directory_remove (test_directory) != GNUNET_OK) |
3589 | { | 4058 | { |
3590 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Failed to remove testing directory %s\n", test_directory); | 4059 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
4060 | "Failed to remove testing directory %s\n", test_directory); | ||
3591 | } | 4061 | } |
3592 | return ret; | 4062 | return ret; |
3593 | } | 4063 | } |