From 3a85995c4a7a48f7afae1c554e9df3547ca7db3f Mon Sep 17 00:00:00 2001 From: Supriti Singh Date: Mon, 22 Sep 2014 15:12:15 +0000 Subject: - Act malicious API complete - Using multiple trails in PUT/GET --- src/dht/gnunet_dht_profiler.c | 327 +++++++++++++++++++++++++++--------------- 1 file changed, 214 insertions(+), 113 deletions(-) (limited to 'src/dht/gnunet_dht_profiler.c') diff --git a/src/dht/gnunet_dht_profiler.c b/src/dht/gnunet_dht_profiler.c index 5fa4a105d..592e31bfe 100644 --- a/src/dht/gnunet_dht_profiler.c +++ b/src/dht/gnunet_dht_profiler.c @@ -38,21 +38,20 @@ /** * Number of peers which should perform a PUT out of 100 peers */ -#define PUT_PROBABILITY 20 +#define PUT_PROBABILITY 50 #if ENABLE_MALICIOUS /** * Number of peers which should act as malicious peers */ -#define MALICIOUS_PROBABILITY 50 +#define MALICIOUS_PROBABILITY 20 -#endif /** - * Percentage of peers that should act maliciously. - * These peers will never start PUT/GET request. - * n_active and n_malicious should not intersect. + * Context for a peer which should act maliciously. */ -#define MALICIOUS_PEERS 0 +struct MaliciousContext; +#endif + /** * Configuration @@ -69,17 +68,11 @@ static char *hosts_file; */ struct ActiveContext; -/** - * Context for a peer which should act maliciously. - */ -struct MaliciousContext; - /** * Context to hold data of peer */ struct Context { - /** * The testbed peer this context belongs to */ @@ -119,6 +112,11 @@ struct MaliciousContext * Handler to the DHT service */ struct GNUNET_DHT_Handle *dht; + + /** + * Handler to malicious api + */ + struct GNUNET_DHT_ActMaliciousHandle *dht_malicious; }; /** @@ -126,6 +124,32 @@ struct MaliciousContext */ struct Context **malicious_peer_contexts = NULL; +/** + * Context for a peer which should act maliciously. + */ +struct Malicious_Context +{ + /** + * The linked peer context + */ + struct Context *ctx; + + /** + * Handler to the DHT service + */ + struct GNUNET_DHT_Handle *dht; +}; + +/** + * Array of malicious peers. + */ +static struct MaliciousContext *a_mc; + +/** + * Number or malicious peers. + */ +static unsigned int n_malicious; + #endif /** @@ -182,27 +206,8 @@ struct ActiveContext * The number of peers currently doing GET on our data */ uint16_t nrefs; - - /** - * If set this peer will act maliciously. - */ - unsigned int malicious; }; -#if ENABLE_MALICIOUS -struct Malicious_Context -{ - /** - * The linked peer context - */ - struct Context *ctx; - - /** - * Handler to the DHT service - */ - struct GNUNET_DHT_Handle *dht; -}; -#endif /** * An array of contexts. The size of this array should be equal to @a num_peers @@ -214,13 +219,6 @@ static struct Context *a_ctx; */ static struct ActiveContext *a_ac; -#if ENABLE_MALICIOUS -/** - * Array of malicious peers. - */ -static struct MaliciousContext *a_mc; -#endif - /** * The delay between rounds for collecting statistics */ @@ -246,13 +244,6 @@ static struct GNUNET_TIME_Relative timeout; */ static unsigned int num_peers; -#if ENABLE_MALICIOUS -/** - * Number or malicious peers. - */ -static unsigned int n_malicious; -#endif - /** * Number of active peers */ @@ -410,6 +401,11 @@ static enum */ static int in_shutdown = 0; +/** + * Total number of times to check if circle is formed or not. + */ +static unsigned int tries; + /** * Task that collects successor statistics from all the peers. * @param cls @@ -418,6 +414,12 @@ static int in_shutdown = 0; static void collect_stats (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc); +/** + * Connect to DHT services of active peers + */ +static void +start_profiling(); + /** * Shutdown task. Cleanup all resources and operations. * @@ -823,17 +825,11 @@ static void * dht_connect (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg) { n_dht++; + DEBUG("\n Inside dht_connect , n_dht = %u",n_dht); return GNUNET_DHT_connect (cfg, 10); } -/** - * Connect to DHT services of active peers - */ -static void -start_profiling(); - - /** * Adapter function called to destroy a connection to * a service. @@ -872,7 +868,6 @@ dht_disconnect (void *cls, void *op_result) } } - /** * Connect to DHT services of active peers */ @@ -881,7 +876,7 @@ start_profiling() { struct Context *ctx; unsigned int i; - + DEBUG("GNUNET_TESTBED_service_connect \n"); GNUNET_break (GNUNET_YES != in_shutdown); for(i = 0; i < n_active; i++) @@ -900,18 +895,157 @@ start_profiling() } } +#if ENABLE_MALICIOUS +/** + * Count of total number of malicious peers. + */ +static unsigned int count_malicious; + +/** + * Continuation of GNUNET_DHT_act_malicious + * @param cls Malicious context + * @param success #GNUNET_OK if the ACT_MALICIOUS was transmitted, + * #GNUNET_NO on timeout, + * #GNUNET_SYSERR on disconnect from service + * after the ACT_MALICIOUS message was transmitted + * (so we don't know if it was received or not) + */ +static void +act_malicious_cont (void *cls, int success) +{ + struct MaliciousContext *mc = cls; + struct Context *ctx = mc->ctx; + + GNUNET_TESTBED_operation_done (ctx->op); + ctx->op = NULL; + return; +} + + +/** + * Call malicious API for all the malicious peers. + * @param cls the malicious context. + * @param op the operation that has been finished + * @param ca_result the service handle returned from GNUNET_TESTBED_ConnectAdapter() + * @param emsg error message in case the operation has failed; will be NULL if + * operation has executed successfully. + */ +void +dht_set_malicious(void *cls, + struct GNUNET_TESTBED_Operation *op, + void *ca_result, + const char *emsg) +{ + struct MaliciousContext *mc = cls; + struct Context *ctx = mc->ctx; + + GNUNET_assert (NULL != ctx); + GNUNET_assert (NULL != ctx->op); + GNUNET_assert (ctx->op == op); + mc->dht = (struct GNUNET_DHT_Handle *) ca_result; + if (NULL != emsg) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Connection to DHT service failed: %s\n", emsg); + GNUNET_TESTBED_operation_done (ctx->op); /* Calls dht_disconnect_malicious() */ + ctx->op = NULL; + return; + } + mc->dht_malicious = GNUNET_DHT_act_malicious(mc->dht, 1, act_malicious_cont, mc); +} + + +/** + * Adapter function called to destroy a connection to + * a service. + * + * @param cls the active context + * @param op_result service handle returned from the connect adapter + */ +static void +dht_disconnect_malicious (void *cls, void *op_result) +{ + struct MaliciousContext *mc = cls; + count_malicious++; + GNUNET_assert (NULL != mc->dht); + GNUNET_assert (mc->dht == op_result); + GNUNET_DHT_disconnect (mc->dht); + mc->dht = NULL; + mc->ctx->op = NULL; + n_dht--; + + if (0 != n_dht) + return; + + if(n_malicious == count_malicious) + { + DEBUG("\n Call start_profiling()"); + start_profiling(); + } +} + + +/** + * Set the malicious variable in peer malicious context. + */ +static void +set_malicious() +{ + unsigned int i; + DEBUG ("Setting %u peers malicious",n_malicious); + + for(i = 0; i < n_malicious; i++) + { + DEBUG("\n Inside loop , i = %u",i); + struct MaliciousContext *mc = &a_mc[i]; + mc->ctx->op = + GNUNET_TESTBED_service_connect (mc->ctx, + mc->ctx->peer, + "dht", + &dht_set_malicious, mc, + &dht_connect, + &dht_disconnect_malicious, + mc); + } +} + +#endif + + +/** + * Start collecting relevant statistics. If ENABLE_MALICIOUS set, first + * set the malicious peers. If not, then start with PUT operation on active + * peers. + */ +static void +start_func() +{ +#if ENABLE_MALICIOUS + set_malicious(); + return; +#endif + start_profiling(); +} + + +/** + * Remove entry from successor peer hashmap. + * @param cls closure + * @param key current public key + * @param value value in the hash map + * @return #GNUNET_YES if we should continue to iterate, + * #GNUNET_NO if not. + */ static int hashmap_iterate_remove(void *cls, const struct GNUNET_HashCode *key, void *value) { - GNUNET_assert(GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove(successor_peer_hashmap, key, value)); + GNUNET_assert (GNUNET_YES == + GNUNET_CONTAINER_multihashmap_remove(successor_peer_hashmap, key, value)); return GNUNET_YES; } -static unsigned int tries; - /** * Stats callback. Iterate over the hashmap and check if all th peers form * a virtual ring topology. @@ -931,20 +1065,21 @@ successor_stats_cont (void *cls, struct GNUNET_HashCode *key; int count; - /* Don't schedule the task till we are looking for circle here. */ successor_stats_task = GNUNET_SCHEDULER_NO_TASK; GNUNET_TESTBED_operation_done (successor_stats_op); successor_stats_op = NULL; if (0 == max_searches) { - start_profiling(); + start_func(); return; } + + GNUNET_assert (NULL != start_key); start_val = (struct GNUNET_HashCode *) GNUNET_CONTAINER_multihashmap_get(successor_peer_hashmap, start_key); - + val = start_val; for (count = 0; count < num_peers; count++) { @@ -977,16 +1112,13 @@ successor_stats_cont (void *cls, successor_peer_hashmap = GNUNET_CONTAINER_multihashmap_create (num_peers, GNUNET_NO); - //TODO:Check if comparison is correct. if ((start_val == val) && (count == num_peers)) { DEBUG("CIRCLE COMPLETED after %u tries", tries); - //FIXME: FREE HASHMAP. - //FIXME: If circle is done, then check that finger table of all the peers - //are fill atleast O(log N) and then start with the experiments. if(GNUNET_SCHEDULER_NO_TASK == successor_stats_task) - start_profiling(); - + { + start_func(); + } return; } else @@ -995,7 +1127,7 @@ successor_stats_cont (void *cls, { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Maximum tries %u exceeded while checking successor TOTAL TRIES %u" - " cirle formation. Exiting\n", + " circle formation. Exiting\n", max_searches,tries); if (GNUNET_SCHEDULER_NO_TASK != successor_stats_task) { @@ -1003,7 +1135,7 @@ successor_stats_cont (void *cls, } if(GNUNET_SCHEDULER_NO_TASK == successor_stats_task) { - start_profiling(); + start_func(); } return; @@ -1039,7 +1171,7 @@ successor_stats_iterator (void *cls, static const char *key_string = "XDHT"; if (0 == max_searches) return GNUNET_OK; - + if (0 == strncmp (key_string, name, strlen (key_string))) { char *my_id_str; @@ -1062,18 +1194,19 @@ successor_stats_iterator (void *cls, succ_key = GNUNET_new(struct GNUNET_HashCode); GNUNET_CRYPTO_hash (truncated_successor_str, sizeof(truncated_successor_str),succ_key); - + if (0 == flag) { + GNUNET_assert(NULL != my_id_key); start_key = my_id_key; + GNUNET_assert(NULL != start_key); flag = 1; } - /* FIXME: GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE do not free the value - which is replaced, need to free it. */ GNUNET_CONTAINER_multihashmap_put (successor_peer_hashmap, my_id_key, (void *)succ_key, GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE); } + return GNUNET_OK; } @@ -1106,33 +1239,6 @@ collect_stats (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) } -#if ENABLE_MALICIOUS -#if 0 -/** - * Set the malicious variable in peer malicious context. - */ -static void -set_malicious() -{ - unsigned int i; - DEBUG ("Setting %u peers malicious"); - for(i = 0; i < n_malicious; i++) - { - struct MaliciousContext *mc = &a_mc[i]; - mc->ctx->op = - GNUNET_TESTBED_service_connect (ac->ctx, - ac->ctx->peer, - "dht", - &dht_set_malicious, mc, - &dht_connect, - &dht_finish, - mc); - } -} -#endif -#endif - - /** * Callback called when DHT service on the peer is started * @@ -1156,14 +1262,11 @@ service_started (void *cls, DEBUG("Peers Started = %d; num_peers = %d \n", peers_started, num_peers); if (GNUNET_SCHEDULER_NO_TASK == successor_stats_task && peers_started == num_peers) { -#if ENABLE_MALICIOUS - //set_malicious(); -#endif - DEBUG("successor_stats_task \n"); struct Collect_Stat_Context *collect_stat_cls = GNUNET_new(struct Collect_Stat_Context); collect_stat_cls->service_connect_ctx = cls; collect_stat_cls->op = op; + successor_stats_task = GNUNET_SCHEDULER_add_delayed (delay_stats, &collect_stats, collect_stat_cls); @@ -1215,7 +1318,7 @@ test_run (void *cls, #if ENABLE_MALICIOUS - if(PUT_PROBABILITY + MALICIOUS_PEERS > 100) + if(PUT_PROBABILITY + MALICIOUS_PROBABILITY > 100) { DEBUG ("Reduce either number of malicious peer or active peers. "); GNUNET_SCHEDULER_shutdown (); @@ -1224,23 +1327,21 @@ test_run (void *cls, } /* Select the peers which should act maliciously. */ - n_malicious = num_peers * MALICIOUS_PEERS / 100; + n_malicious = num_peers * MALICIOUS_PROBABILITY / 100; - /* Select n_malicious peers and ensure that those are not active peers. - keep all malicious peer at one place, and call act malicious for all - those peers. */ a_mc = GNUNET_malloc (n_malicious * sizeof (struct MaliciousContext)); malicious_peers = 0; - for (cnt = 0; cnt < num_peers && ac_cnt < n_active; cnt++) + for (cnt = 0; cnt < num_peers && malicious_peers < n_malicious; cnt++) { if (GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100) >= MALICIOUS_PROBABILITY) continue; - a_ac[ac_cnt].malicious = 1; - a_mc[ac_cnt].ctx = &a_ctx[cnt]; + a_ctx[cnt].mc = &a_mc[malicious_peers]; + a_mc[malicious_peers].ctx = &a_ctx[cnt]; malicious_peers++; } + n_malicious = malicious_peers; INFO ("Malicious Peers: %u\n",malicious_peers); #endif @@ -1250,7 +1351,7 @@ test_run (void *cls, for (cnt = 0; cnt < num_peers && ac_cnt < n_active; cnt++) { if ((GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 100) >= - PUT_PROBABILITY) || (a_ac[ac_cnt].malicious == 1)) + PUT_PROBABILITY) || (a_ctx[ac_cnt].mc != NULL)) continue; a_ctx[cnt].ac = &a_ac[ac_cnt]; -- cgit v1.2.3