[GNUnet-SVN] r29711 - gnunet/src/testbed

[gnunet]

Author: harsha
Date: 2013-09-30 14:55:03 +0200 (Mon, 30 Sep 2013)
New Revision: 29711

Modified:
   gnunet/src/testbed/gnunet-service-testbed_barriers.c
   gnunet/src/testbed/gnunet-service-testbed_links.c
   gnunet/src/testbed/gnunet-service-testbed_links.h
   gnunet/src/testbed/testbed_api_hosts.c
Log:
- fix misc. memleaks


Modified: gnunet/src/testbed/gnunet-service-testbed_barriers.c
===================================================================
--- gnunet/src/testbed/gnunet-service-testbed_barriers.c        2013-09-30 
12:17:46 UTC (rev 29710)
+++ gnunet/src/testbed/gnunet-service-testbed_barriers.c        2013-09-30 
12:55:03 UTC (rev 29711)
@@ -330,7 +330,10 @@
   struct MessageQueue *mq;
   
   if (NULL != ctx->client)
+  {
+    GNUNET_SERVER_client_set_user_context_ (ctx->client, NULL, 0);
     GNUNET_SERVER_client_drop (ctx->client);
+  } 
   if (NULL != ctx->tx)
     GNUNET_SERVER_notify_transmit_ready_cancel (ctx->tx);
   if (NULL != (mq = ctx->mq_head))
@@ -482,11 +485,11 @@
   (void) memcpy (name, msg->name, name_len);
   LOG_DEBUG ("Received BARRIER_WAIT for barrier `%s'\n", name);
   GNUNET_CRYPTO_hash (name, name_len, &key);
+  GNUNET_free (name);
   if (NULL == (barrier = GNUNET_CONTAINER_multihashmap_get (barrier_map, 
&key)))
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
-    GNUNET_free (name);
     return;
   }
   client_ctx = GNUNET_SERVER_client_get_user_context (client, struct 
ClientCtx);
@@ -556,12 +559,40 @@
 
 
 /**
+ * Iterator over hash map entries.
+ *
+ * @param cls closure
+ * @param key current key code
+ * @param value value in the hash map
+ * @return #GNUNET_YES if we should continue to
+ *         iterate,
+ *         #GNUNET_NO if not.
+ */
+static int 
+barrier_destroy_iterator (void *cls,
+                          const struct GNUNET_HashCode *key,
+                          void *value)
+{
+  struct Barrier *barrier = value;
+
+  GNUNET_assert (NULL != barrier);
+  cancel_wrappers (barrier);
+  remove_barrier (barrier);
+  return GNUNET_YES;
+}
+
+
+/**
  * Function to stop the barrier service
  */
 void
 GST_barriers_destroy ()
 {
   GNUNET_assert (NULL != barrier_map);
+  GNUNET_assert (GNUNET_SYSERR !=
+                 GNUNET_CONTAINER_multihashmap_iterate (barrier_map,
+                                                        
&barrier_destroy_iterator,
+                                                        NULL));
   GNUNET_CONTAINER_multihashmap_destroy (barrier_map);
   GNUNET_assert (NULL != ctx);
   GNUNET_SERVICE_stop (ctx);

Modified: gnunet/src/testbed/gnunet-service-testbed_links.c
===================================================================
--- gnunet/src/testbed/gnunet-service-testbed_links.c   2013-09-30 12:17:46 UTC 
(rev 29710)
+++ gnunet/src/testbed/gnunet-service-testbed_links.c   2013-09-30 12:55:03 UTC 
(rev 29711)
@@ -420,51 +420,78 @@
 
 
 /**
+ * Kill a #Slave object
+ *
+ * @param slave the #Slave object
+ */
+static void
+kill_slave (struct Slave *slave)
+{
+  struct HostRegistration *hr_entry;
+
+  while (NULL != (hr_entry = slave->hr_dll_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (slave->hr_dll_head, slave->hr_dll_tail,
+                                 hr_entry);
+    GNUNET_free (hr_entry);
+  }
+  if (NULL != slave->rhandle)
+    GNUNET_TESTBED_cancel_registration (slave->rhandle);
+  GNUNET_assert (GNUNET_SYSERR != 
+                 GNUNET_CONTAINER_multihashmap_iterate (slave->reghost_map,
+                                                        reghost_free_iterator,
+                                                        slave));
+  GNUNET_CONTAINER_multihashmap_destroy (slave->reghost_map);
+  if (NULL != slave->controller)
+    GNUNET_TESTBED_controller_disconnect (slave->controller);
+  if (NULL != slave->controller_proc)
+  {
+    LOG_DEBUG ("Stopping a slave\n");
+    GNUNET_TESTBED_controller_kill_ (slave->controller_proc);
+  }
+}
+
+
+/**
+ * Destroy a #Slave object
+ *
+ * @param slave the #Slave object
+ */
+static void
+destroy_slave (struct Slave *slave)
+{
+  if (NULL != slave->controller_proc)
+  {
+    GNUNET_TESTBED_controller_destroy_ (slave->controller_proc);
+    LOG_DEBUG ("Slave stopped\n");
+  }
+  GST_slave_list[slave->host_id] = NULL;
+  GNUNET_free (slave);
+}
+
+
+/**
  * Cleans up the slave list
  */
 void
 GST_slave_list_clear ()
 {
-  struct HostRegistration *hr_entry;
-  struct GNUNET_TESTBED_ControllerProc *cproc;
+  struct Slave *slave;
   unsigned int id;
 
   for (id = 0; id < GST_slave_list_size; id++)
   {
-    if (NULL == GST_slave_list[id])
+    slave = GST_slave_list[id];
+    if (NULL == slave)
       continue;
-    while (NULL != (hr_entry = GST_slave_list[id]->hr_dll_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (GST_slave_list[id]->hr_dll_head,
-                                   GST_slave_list[id]->hr_dll_tail, hr_entry);
-      GNUNET_free (hr_entry);
-    }
-    if (NULL != GST_slave_list[id]->rhandle)
-      GNUNET_TESTBED_cancel_registration (GST_slave_list[id]->rhandle);
-    (void)
-        GNUNET_CONTAINER_multihashmap_iterate (GST_slave_list
-                                               [id]->reghost_map,
-                                               reghost_free_iterator,
-                                               GST_slave_list[id]);
-    GNUNET_CONTAINER_multihashmap_destroy (GST_slave_list[id]->reghost_map);
-    if (NULL != GST_slave_list[id]->controller)
-      GNUNET_TESTBED_controller_disconnect (GST_slave_list[id]->controller);
-    if (NULL != (cproc = GST_slave_list[id]->controller_proc))
-    {
-      LOG_DEBUG ("Stopping a slave\n");
-      GNUNET_TESTBED_controller_kill_ (cproc);
-    }
+    kill_slave (slave);
   }
   for (id = 0; id < GST_slave_list_size; id++)
   {
-    if (NULL == GST_slave_list[id])
+    slave = GST_slave_list[id];
+    if (NULL == slave)
       continue;
-    if (NULL != (cproc = GST_slave_list[id]->controller_proc))
-    {
-      GNUNET_TESTBED_controller_destroy_ (cproc);
-      LOG_DEBUG ("Slave stopped\n");
-    }
-    GNUNET_free (GST_slave_list[id]);
+    destroy_slave (slave);
   }
   GNUNET_free_non_null (GST_slave_list);
   GST_slave_list = NULL;
@@ -723,6 +750,8 @@
   GNUNET_assert (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type);
   lcf = event->op_cls;
   GNUNET_assert (lcf->op == event->op);
+  GNUNET_TESTBED_operation_done (lcf->op);
+  lcf->op = NULL;
   GNUNET_assert (FINISHED == lcf->state);
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != lcf->timeout_task);
   GNUNET_SCHEDULER_cancel (lcf->timeout_task);
@@ -761,8 +790,13 @@
   if (GNUNET_SYSERR == status)
   {
     slave->controller_proc = NULL;
-    GST_slave_list[slave->host_id] = NULL;
-    GNUNET_free (slave);
+    /* Stop all link controller forwarding tasks since we shutdown here anyway
+       and as these tasks they depend on the operation queues which are created
+       through GNUNET_TESTBED_controller_connect() and in kill_slave() we call
+       the destructor function GNUNET_TESTBED_controller_disconnect() */
+    GST_free_lcfq ();
+    kill_slave (slave);
+    destroy_slave (slave);
     slave = NULL;
     LOG (GNUNET_ERROR_TYPE_WARNING, "Unexpected slave shutdown\n");
     GNUNET_SCHEDULER_shutdown ();       /* We too shutdown */
@@ -780,13 +814,12 @@
   {
     send_controller_link_response (lcc->client, lcc->operation_id, NULL,
                                    "Could not connect to delegated 
controller");
-    GNUNET_TESTBED_controller_stop (slave->controller_proc);
-    GST_slave_list[slave->host_id] = NULL;
-    GNUNET_free (slave);
+    kill_slave (slave);
+    destroy_slave (slave);
     slave = NULL;
   }
 
-clean_lcc:
+ clean_lcc:
   if (NULL != lcc)
   {
     if (NULL != lcc->client)
@@ -1317,6 +1350,7 @@
 GST_free_lcfq ()
 {
   struct LCFContextQueue *lcfq;
+  struct LCFContext *lcf;
   
   if (NULL != lcfq_head)
   {
@@ -1329,8 +1363,13 @@
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id);
   for (lcfq = lcfq_head; NULL != lcfq; lcfq = lcfq_head)
   {
-    GNUNET_SERVER_client_drop (lcfq->lcf->client);
-    GNUNET_free (lcfq->lcf);
+    lcf = lcfq->lcf;
+    GNUNET_SERVER_client_drop (lcf->client);
+    if (NULL != lcf->op)
+      GNUNET_TESTBED_operation_done (lcf->op);
+    if (GNUNET_SCHEDULER_NO_TASK != lcf->timeout_task)
+      GNUNET_SCHEDULER_cancel (lcf->timeout_task);
+    GNUNET_free (lcf);
     GNUNET_CONTAINER_DLL_remove (lcfq_head, lcfq_tail, lcfq);
     GNUNET_free (lcfq);
   }

Modified: gnunet/src/testbed/gnunet-service-testbed_links.h
===================================================================
--- gnunet/src/testbed/gnunet-service-testbed_links.h   2013-09-30 12:17:46 UTC 
(rev 29710)
+++ gnunet/src/testbed/gnunet-service-testbed_links.h   2013-09-30 12:55:03 UTC 
(rev 29711)
@@ -74,16 +74,9 @@
   struct GNUNET_CONTAINER_MultiHashMap *reghost_map;
 
   /**
-   * Operation handle for opening a lateral connection to another controller.
-   * Will be NULL if the slave controller is started by this controller
-   */
-  struct GNUNET_TESTBED_Operation *conn_op;
-
-  /**
    * The id of the host this controller is running on
    */
   uint32_t host_id;
-
 };
 
 /**

Modified: gnunet/src/testbed/testbed_api_hosts.c
===================================================================
--- gnunet/src/testbed/testbed_api_hosts.c      2013-09-30 12:17:46 UTC (rev 
29710)
+++ gnunet/src/testbed/testbed_api_hosts.c      2013-09-30 12:55:03 UTC (rev 
29711)
@@ -1008,6 +1008,7 @@
   GNUNET_assert (NULL != cp->shandle);
   cp->shandle = NULL;
   GNUNET_free (cp->msg);
+  cp->msg = NULL;
 }
 
 
@@ -1184,6 +1185,7 @@
     free_argv (cproc->helper_argv);
   cproc->host->controller_started = GNUNET_NO;
   cproc->host->locked = GNUNET_NO;
+  GNUNET_free_non_null (cproc->msg);
   GNUNET_free (cproc);
 }