- Act malicious API complete

- Using multiple trails in PUT/GET

1 files changed, 214 insertions, 113 deletions

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
@@ -70,16 +69,10 @@ 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
  */
@@ -411,6 +402,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
  * @param tc
@@ -419,6 +415,12 @@ 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.
  *
  * @param cls NULL
@@ -823,18 +825,12 @@ 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];