nicer loop structure

2 files changed, 215 insertions, 296 deletions

diff --git a/src/peerstore/gnunet-service-peerstore.c b/src/peerstore/gnunet-service-peerstore.c
index 9bce542b9..ed1c35535 100644
--- a/src/peerstore/gnunet-service-peerstore.c
+++ b/src/peerstore/gnunet-service-peerstore.c
@@ -11,7 +11,7 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
@@ -33,7 +33,7 @@
 /**
  * Interval for expired records cleanup (in seconds)
  */
-#define EXPIRED_RECORDS_CLEANUP_INTERVAL 300    /* 5mins */
+#define EXPIRED_RECORDS_CLEANUP_INTERVAL 300 /* 5mins */
 
 /**
  * Our configuration.
@@ -79,9 +79,7 @@ do_shutdown ()
 {
   if (NULL != db_lib_name)
   {
-    GNUNET_break (NULL ==
-                  GNUNET_PLUGIN_unload (db_lib_name,
-                                        db));
+    GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, db));
     GNUNET_free (db_lib_name);
     db_lib_name = NULL;
   }
@@ -108,15 +106,14 @@ static void
 shutdown_task (void *cls)
 {
   in_shutdown = GNUNET_YES;
-  if (0 == num_clients)      /* Only when no connected clients. */
+  if (0 == num_clients) /* Only when no connected clients. */
     do_shutdown ();
 }
 
 
 /* Forward declaration */
 static void
-expire_records_continuation (void *cls,
-                             int success);
+expire_records_continuation (void *cls, int success);
 
 
 /**
@@ -131,16 +128,16 @@ cleanup_expired_records (void *cls)
   GNUNET_assert (NULL != db);
   ret = db->expire_records (db->cls,
                             GNUNET_TIME_absolute_get (),
-                            &expire_records_continuation,
+                            &expire_records_continuation,
                             NULL);
   if (GNUNET_OK != ret)
   {
     GNUNET_assert (NULL == expire_task);
-    expire_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                                (GNUNET_TIME_UNIT_SECONDS,
-                                                 EXPIRED_RECORDS_CLEANUP_INTERVAL),
-                                                &cleanup_expired_records,
-                                                NULL);
+    expire_task = GNUNET_SCHEDULER_add_delayed (
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                     EXPIRED_RECORDS_CLEANUP_INTERVAL),
+      &cleanup_expired_records,
+      NULL);
   }
 }
 
@@ -152,19 +149,16 @@ cleanup_expired_records (void *cls)
  * @param success count of records deleted or #GNUNET_SYSERR
  */
 static void
-expire_records_continuation (void *cls,
-                             int success)
+expire_records_continuation (void *cls, int success)
 {
   if (success > 0)
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "%d records expired.\n",
-                success);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "%d records expired.\n", success);
   GNUNET_assert (NULL == expire_task);
-  expire_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
-                                              (GNUNET_TIME_UNIT_SECONDS,
-                                               EXPIRED_RECORDS_CLEANUP_INTERVAL),
-                                              &cleanup_expired_records,
-                                              NULL);
+  expire_task = GNUNET_SCHEDULER_add_delayed (
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                   EXPIRED_RECORDS_CLEANUP_INTERVAL),
+    &cleanup_expired_records,
+    NULL);
 }
 
 
@@ -195,15 +189,12 @@ client_connect_cb (void *cls,
  * @return #GNUNET_OK to continue iterating
  */
 static int
-client_disconnect_it (void *cls,
-                      const struct GNUNET_HashCode *key,
-                      void *value)
+client_disconnect_it (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   if (value == cls)
   {
-    GNUNET_CONTAINER_multihashmap_remove (watchers,
-                                          key,
-                                          value);
+    GNUNET_assert (GNUNET_YES ==
+                   GNUNET_CONTAINER_multihashmap_remove (watchers, key, value));
     num_clients++;
   }
   return GNUNET_OK;
@@ -221,15 +212,13 @@ client_disconnect_cb (void *cls,
                       struct GNUNET_SERVICE_Client *client,
                       void *app_cls)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "A client disconnected, cleaning up.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "A client disconnected, cleaning up.\n");
   if (NULL != watchers)
     GNUNET_CONTAINER_multihashmap_iterate (watchers,
                                            &client_disconnect_it,
                                            client);
   num_clients--;
-  if ( (0 == num_clients) &&
-       in_shutdown)
+  if ((0 == num_clients) && in_shutdown)
     do_shutdown ();
 }
 
@@ -255,10 +244,8 @@ record_iterator (void *cls,
     /* No more records */
     struct GNUNET_MessageHeader *endmsg;
 
-    env = GNUNET_MQ_msg (endmsg,
-                         GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END);
-    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (cls_record->client),
-                    env);
+    env = GNUNET_MQ_msg (endmsg, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END);
+    GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (cls_record->client), env);
     if (NULL == emsg)
     {
       GNUNET_SERVICE_client_continue (cls_record->client);
@@ -266,25 +253,23 @@ record_iterator (void *cls,
     else
     {
       GNUNET_break (0);
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Failed to iterate: %s\n",
-                  emsg);
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate: %s\n", emsg);
       GNUNET_SERVICE_client_drop (cls_record->client);
     }
     PEERSTORE_destroy_record (cls_record);
     return;
   }
 
-  env = PEERSTORE_create_record_mq_envelope (record->sub_system,
-                                             &record->peer,
-                                             record->key,
-                                             record->value,
-                                             record->value_size,
-                                             record->expiry,
-                                             0,
-                                             GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD);
-  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (cls_record->client),
-                  env);
+  env = PEERSTORE_create_record_mq_envelope (
+    record->sub_system,
+    &record->peer,
+    record->key,
+    record->value,
+    record->value_size,
+    record->expiry,
+    0,
+    GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (cls_record->client), env);
 }
 
 
@@ -298,26 +283,23 @@ record_iterator (void *cls,
  * @return #GNUNET_YES to continue iterating
  */
 static int
-watch_notifier_it (void *cls,
-                   const struct GNUNET_HashCode *key,
-                   void *value)
+watch_notifier_it (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct GNUNET_PEERSTORE_Record *record = cls;
   struct GNUNET_SERVICE_Client *client = value;
   struct GNUNET_MQ_Envelope *env;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Found a watcher to update.\n");
-  env = PEERSTORE_create_record_mq_envelope (record->sub_system,
-                                             &record->peer,
-                                             record->key,
-                                             record->value,
-                                             record->value_size,
-                                             record->expiry,
-                                             0,
-                                             GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD);
-  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
-                  env);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found a watcher to update.\n");
+  env = PEERSTORE_create_record_mq_envelope (
+    record->sub_system,
+    &record->peer,
+    record->key,
+    record->value,
+    record->value_size,
+    record->expiry,
+    0,
+    GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD);
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
   return GNUNET_YES;
 }
 
@@ -332,10 +314,7 @@ watch_notifier (struct GNUNET_PEERSTORE_Record *record)
 {
   struct GNUNET_HashCode keyhash;
 
-  PEERSTORE_hash_key (record->sub_system,
-                      &record->peer,
-                      record->key,
-                      &keyhash);
+  PEERSTORE_hash_key (record->sub_system, &record->peer, record->key, &keyhash);
   GNUNET_CONTAINER_multihashmap_get_multiple (watchers,
                                               &keyhash,
                                               &watch_notifier_it,
@@ -350,17 +329,13 @@ watch_notifier (struct GNUNET_PEERSTORE_Record *record)
  * @param hm the actual message
  */
 static void
-handle_watch_cancel (void *cls,
-                     const struct StoreKeyHashMessage *hm)
+handle_watch_cancel (void *cls, const struct StoreKeyHashMessage *hm)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received a watch cancel request.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received a watch cancel request.\n");
   if (GNUNET_OK !=
-      GNUNET_CONTAINER_multihashmap_remove (watchers,
-                                            &hm->keyhash,
-                                            client))
+      GNUNET_CONTAINER_multihashmap_remove (watchers, &hm->keyhash, client))
   {
     GNUNET_break (0);
     GNUNET_SERVICE_client_drop (client);
@@ -378,13 +353,11 @@ handle_watch_cancel (void *cls,
  * @param hm the actual message
  */
 static void
-handle_watch (void *cls,
-              const struct StoreKeyHashMessage *hm)
+handle_watch (void *cls, const struct StoreKeyHashMessage *hm)
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received a watch request.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received a watch request.\n");
   num_clients--; /* do not count watchers */
   GNUNET_SERVICE_client_mark_monitor (client);
   GNUNET_CONTAINER_multihashmap_put (watchers,
@@ -403,8 +376,7 @@ handle_watch (void *cls,
  * @return #GNUNET_OK if @a srm is well-formed
  */
 static int
-check_iterate (void *cls,
-               const struct StoreRecordMessage *srm)
+check_iterate (void *cls, const struct StoreRecordMessage *srm)
 {
   struct GNUNET_PEERSTORE_Record *record;
 
@@ -432,8 +404,7 @@ check_iterate (void *cls,
  * @param srm the actual message
  */
 static void
-handle_iterate (void *cls,
-                const struct StoreRecordMessage *srm)
+handle_iterate (void *cls, const struct StoreRecordMessage *srm)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct GNUNET_PEERSTORE_Record *record;
@@ -467,8 +438,7 @@ handle_iterate (void *cls,
  * @param success result
  */
 static void
-store_record_continuation (void *cls,
-                           int success)
+store_record_continuation (void *cls, int success)
 {
   struct GNUNET_PEERSTORE_Record *record = cls;
 
@@ -494,8 +464,7 @@ store_record_continuation (void *cls,
  * @return #GNUNET_OK if @a srm is well-formed
  */
 static int
-check_store (void *cls,
-              const struct StoreRecordMessage *srm)
+check_store (void *cls, const struct StoreRecordMessage *srm)
 {
   struct GNUNET_PEERSTORE_Record *record;
 
@@ -505,8 +474,7 @@ check_store (void *cls,
     GNUNET_break (0);
     return GNUNET_SYSERR;
   }
-  if ( (NULL == record->sub_system) ||
-       (NULL == record->key) )
+  if ((NULL == record->sub_system) || (NULL == record->key))
   {
     GNUNET_break (0);
     PEERSTORE_destroy_record (record);
@@ -524,31 +492,30 @@ check_store (void *cls,
  * @param srm the actual message
  */
 static void
-handle_store (void *cls,
-              const struct StoreRecordMessage *srm)
+handle_store (void *cls, const struct StoreRecordMessage *srm)
 {
   struct GNUNET_SERVICE_Client *client = cls;
   struct GNUNET_PEERSTORE_Record *record;
 
   record = PEERSTORE_parse_record_message (srm);
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Received a store request. Sub system `%s' Peer `%s Key `%s' Options: %u.\n",
-              record->sub_system,
-              GNUNET_i2s (&record->peer),
-              record->key,
-              (uint32_t) ntohl (srm->options));
+  GNUNET_log (
+    GNUNET_ERROR_TYPE_INFO,
+    "Received a store request. Sub system `%s' Peer `%s Key `%s' Options: %u.\n",
+    record->sub_system,
+    GNUNET_i2s (&record->peer),
+    record->key,
+    (uint32_t) ntohl (srm->options));
   record->client = client;
-  if (GNUNET_OK !=
-      db->store_record (db->cls,
-                        record->sub_system,
-                        &record->peer,
-                        record->key,
-                        record->value,
-                        record->value_size,
-                        record->expiry,
-                        ntohl (srm->options),
-                        &store_record_continuation,
-                        record))
+  if (GNUNET_OK != db->store_record (db->cls,
+                                     record->sub_system,
+                                     &record->peer,
+                                     record->key,
+                                     record->value,
+                                     record->value_size,
+                                     record->expiry,
+                                     ntohl (srm->options),
+                                     &store_record_continuation,
+                                     record))
   {
     GNUNET_break (0);
     PEERSTORE_destroy_record (record);
@@ -574,11 +541,10 @@ run (void *cls,
 
   in_shutdown = GNUNET_NO;
   cfg = c;
-  if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string (cfg,
-                                             "peerstore",
-                                             "DATABASE",
-                                             &database))
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                          "peerstore",
+                                                          "DATABASE",
+                                                          &database))
   {
     GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                                "peerstore",
@@ -586,56 +552,50 @@ run (void *cls,
     GNUNET_SCHEDULER_shutdown ();
     return;
   }
-  GNUNET_asprintf (&db_lib_name,
-                   "libgnunet_plugin_peerstore_%s",
-                   database);
-  db = GNUNET_PLUGIN_load (db_lib_name,
-                           (void *) cfg);
+  GNUNET_asprintf (&db_lib_name, "libgnunet_plugin_peerstore_%s", database);
+  db = GNUNET_PLUGIN_load (db_lib_name, (void *) cfg);
   GNUNET_free (database);
   if (NULL == db)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Could not load database backend `%s'\n"),
-                db_lib_name);
+                _ ("Could not load database backend `%s'\n"),
+                db_lib_name);
     GNUNET_SCHEDULER_shutdown ();
     return;
   }
-  watchers = GNUNET_CONTAINER_multihashmap_create (10,
-                                                   GNUNET_NO);
-  expire_task = GNUNET_SCHEDULER_add_now (&cleanup_expired_records,
-                                          NULL);
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
-                                 NULL);
+  watchers = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
+  expire_task = GNUNET_SCHEDULER_add_now (&cleanup_expired_records, NULL);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
 }
 
 
 /**
  * Define "main" method using service macro.
  */
-GNUNET_SERVICE_MAIN
-("peerstore",
- GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN,
- &run,
- &client_connect_cb,
- &client_disconnect_cb,
- NULL,
- GNUNET_MQ_hd_var_size (store,
-                        GNUNET_MESSAGE_TYPE_PEERSTORE_STORE,
-                        struct StoreRecordMessage,
-                        NULL),
- GNUNET_MQ_hd_var_size (iterate,
-                        GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE,
-                        struct StoreRecordMessage,
-                        NULL),
- GNUNET_MQ_hd_fixed_size (watch,
-                          GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH,
-                          struct StoreKeyHashMessage,
-                          NULL),
- GNUNET_MQ_hd_fixed_size (watch_cancel,
-                          GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL,
-                          struct StoreKeyHashMessage,
-                          NULL),
- GNUNET_MQ_handler_end ());
+GNUNET_SERVICE_MAIN (
+  "peerstore",
+  GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN,
+  &run,
+  &client_connect_cb,
+  &client_disconnect_cb,
+  NULL,
+  GNUNET_MQ_hd_var_size (store,
+                         GNUNET_MESSAGE_TYPE_PEERSTORE_STORE,
+                         struct StoreRecordMessage,
+                         NULL),
+  GNUNET_MQ_hd_var_size (iterate,
+                         GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE,
+                         struct StoreRecordMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (watch,
+                           GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH,
+                           struct StoreKeyHashMessage,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (watch_cancel,
+                           GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL,
+                           struct StoreKeyHashMessage,
+                           NULL),
+  GNUNET_MQ_handler_end ());
 
 
 /* end of gnunet-service-peerstore.c */
diff --git a/src/peerstore/peerstore_api.c b/src/peerstore/peerstore_api.c
index 02f3e287a..64bc3ae72 100644
--- a/src/peerstore/peerstore_api.c
+++ b/src/peerstore/peerstore_api.c
@@ -28,7 +28,7 @@
 #include "peerstore.h"
 #include "peerstore_common.h"
 
-#define LOG(kind,...) GNUNET_log_from (kind, "peerstore-api",__VA_ARGS__)
+#define LOG(kind, ...) GNUNET_log_from (kind, "peerstore-api", __VA_ARGS__)
 
 /******************************************************************************/
 /************************      DATA STRUCTURES     ****************************/
@@ -89,7 +89,6 @@ struct GNUNET_PEERSTORE_Handle
    * Are we in the process of disconnecting but need to sync first?
    */
   int disconnecting;
-
 };
 
 /**
@@ -156,7 +155,6 @@ struct GNUNET_PEERSTORE_StoreContext
    * Options for the store operation.
    */
   enum GNUNET_PEERSTORE_StoreOption options;
-
 };
 
 /**
@@ -208,7 +206,6 @@ struct GNUNET_PEERSTORE_IterateContext
    * #GNUNET_YES if we are currently processing records.
    */
   int iterating;
-
 };
 
 /**
@@ -245,7 +242,6 @@ struct GNUNET_PEERSTORE_WatchContext
    * Hash of the combined key
    */
   struct GNUNET_HashCode keyhash;
-
 };
 
 /******************************************************************************/
@@ -271,8 +267,7 @@ disconnect (struct GNUNET_PEERSTORE_Handle *h)
 {
   struct GNUNET_PEERSTORE_IterateContext *next;
 
-  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head;
-       NULL != ic;
+  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
        ic = next)
   {
     next = ic->next;
@@ -285,9 +280,7 @@ disconnect (struct GNUNET_PEERSTORE_Handle *h)
       icb_cls = ic->callback_cls;
       GNUNET_PEERSTORE_iterate_cancel (ic);
       if (NULL != icb)
-        icb (icb_cls,
-             NULL,
-             "Iteration canceled due to reconnection");
+        icb (icb_cls, NULL, "Iteration canceled due to reconnection");
     }
   }
 
@@ -312,17 +305,13 @@ disconnect_and_schedule_reconnect (struct GNUNET_PEERSTORE_Handle *h)
   disconnect (h);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Scheduling task to reconnect to PEERSTORE service in %s.\n",
-       GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay,
-                                               GNUNET_YES));
+       GNUNET_STRINGS_relative_time_to_string (h->reconnect_delay, GNUNET_YES));
   h->reconnect_task =
-      GNUNET_SCHEDULER_add_delayed (h->reconnect_delay,
-                                    &reconnect,
-                                    h);
+    GNUNET_SCHEDULER_add_delayed (h->reconnect_delay, &reconnect, h);
   h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
 }
 
 
-
 /**
  * Callback after MQ envelope is sent
  *
@@ -352,8 +341,7 @@ store_request_sent (void *cls)
  * Function called when we had trouble talking to the service.
  */
 static void
-handle_client_error (void *cls,
-                     enum GNUNET_MQ_Error error)
+handle_client_error (void *cls, enum GNUNET_MQ_Error error)
 {
   struct GNUNET_PEERSTORE_Handle *h = cls;
 
@@ -373,9 +361,7 @@ handle_client_error (void *cls,
  * @return #GNUNET_YES (continue to iterate)
  */
 static int
-rewatch_it (void *cls,
-            const struct GNUNET_HashCode *key,
-            void *value)
+rewatch_it (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct GNUNET_PEERSTORE_Handle *h = cls;
   struct GNUNET_PEERSTORE_WatchContext *wc = value;
@@ -398,9 +384,7 @@ rewatch_it (void *cls,
  * @return #GNUNET_YES to continue iteration
  */
 static int
-destroy_watch (void *cls,
-               const struct GNUNET_HashCode *key,
-               void *value)
+destroy_watch (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct GNUNET_PEERSTORE_WatchContext *wc = value;
 
@@ -461,8 +445,7 @@ GNUNET_PEERSTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param sync_first send any pending STORE requests before disconnecting
  */
 void
-GNUNET_PEERSTORE_disconnect (struct GNUNET_PEERSTORE_Handle *h,
-                             int sync_first)
+GNUNET_PEERSTORE_disconnect (struct GNUNET_PEERSTORE_Handle *h, int sync_first)
 {
   struct GNUNET_PEERSTORE_IterateContext *ic;
   struct GNUNET_PEERSTORE_StoreContext *sc;
@@ -515,8 +498,7 @@ GNUNET_PEERSTORE_store_cancel (struct GNUNET_PEERSTORE_StoreContext *sc)
   GNUNET_free (sc->value);
   GNUNET_free (sc->key);
   GNUNET_free (sc);
-  if ( (GNUNET_YES == h->disconnecting) &&
-       (NULL == h->store_head) )
+  if ((GNUNET_YES == h->disconnecting) && (NULL == h->store_head))
     final_disconnect (h);
 }
 
@@ -542,7 +524,8 @@ GNUNET_PEERSTORE_store (struct GNUNET_PEERSTORE_Handle *h,
                         const char *sub_system,
                         const struct GNUNET_PeerIdentity *peer,
                         const char *key,
-                        const void *value, size_t size,
+                        const void *value,
+                        size_t size,
                         struct GNUNET_TIME_Absolute expiry,
                         enum GNUNET_PEERSTORE_StoreOption options,
                         GNUNET_PEERSTORE_Continuation cont,
@@ -553,10 +536,19 @@ GNUNET_PEERSTORE_store (struct GNUNET_PEERSTORE_Handle *h,
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Storing value (size: %lu) for subsytem `%s', peer `%s', key `%s'\n",
-       size, sub_system, GNUNET_i2s (peer), key);
-  ev = PEERSTORE_create_record_mq_envelope (sub_system, peer, key, value, size,
-                                            expiry, options,
-                                            GNUNET_MESSAGE_TYPE_PEERSTORE_STORE);
+       size,
+       sub_system,
+       GNUNET_i2s (peer),
+       key);
+  ev =
+    PEERSTORE_create_record_mq_envelope (sub_system,
+                                         peer,
+                                         key,
+                                         value,
+                                         size,
+                                         expiry,
+                                         options,
+                                         GNUNET_MESSAGE_TYPE_PEERSTORE_STORE);
   sc = GNUNET_new (struct GNUNET_PEERSTORE_StoreContext);
 
   sc->sub_system = GNUNET_strdup (sub_system);
@@ -574,7 +566,6 @@ GNUNET_PEERSTORE_store (struct GNUNET_PEERSTORE_Handle *h,
   GNUNET_MQ_notify_sent (ev, &store_request_sent, sc);
   GNUNET_MQ_send (h->mq, ev);
   return sc;
-
 }
 
 
@@ -590,8 +581,7 @@ GNUNET_PEERSTORE_store (struct GNUNET_PEERSTORE_Handle *h,
  * @param msg message received
  */
 static void
-handle_iterate_end (void *cls,
-                    const struct GNUNET_MessageHeader *msg)
+handle_iterate_end (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_PEERSTORE_Handle *h = cls;
   struct GNUNET_PEERSTORE_IterateContext *ic;
@@ -602,7 +592,7 @@ handle_iterate_end (void *cls,
   if (NULL == ic)
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
-         _("Unexpected iteration response, this should not happen.\n"));
+         _ ("Unexpected iteration response, this should not happen.\n"));
     disconnect_and_schedule_reconnect (h);
     return;
   }
@@ -611,9 +601,7 @@ handle_iterate_end (void *cls,
   ic->iterating = GNUNET_NO;
   GNUNET_PEERSTORE_iterate_cancel (ic);
   if (NULL != callback)
-    callback (callback_cls,
-              NULL,
-              NULL);
+    callback (callback_cls, NULL, NULL);
   h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
 }
 
@@ -626,8 +614,7 @@ handle_iterate_end (void *cls,
  * @param msg message received
  */
 static int
-check_iterate_result (void *cls,
-                      const struct StoreRecordMessage *msg)
+check_iterate_result (void *cls, const struct StoreRecordMessage *msg)
 {
   /* we defer validation to #handle_iterate_result */
   return GNUNET_OK;
@@ -641,8 +628,7 @@ check_iterate_result (void *cls,
  * @param msg message received
  */
 static void
-handle_iterate_result (void *cls,
-                       const struct StoreRecordMessage *msg)
+handle_iterate_result (void *cls, const struct StoreRecordMessage *msg)
 {
   struct GNUNET_PEERSTORE_Handle *h = cls;
   struct GNUNET_PEERSTORE_IterateContext *ic;
@@ -654,7 +640,7 @@ handle_iterate_result (void *cls,
   if (NULL == ic)
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
-         _("Unexpected iteration response, this should not happen.\n"));
+         _ ("Unexpected iteration response, this should not happen.\n"));
     disconnect_and_schedule_reconnect (h);
     return;
   }
@@ -668,13 +654,11 @@ handle_iterate_result (void *cls,
   {
     callback (callback_cls,
               NULL,
-              _("Received a malformed response from service."));
+              _ ("Received a malformed response from service."));
   }
   else
   {
-    callback (callback_cls,
-              record,
-              NULL);
+    callback (callback_cls, record, NULL);
     PEERSTORE_destroy_record (record);
   }
 }
@@ -691,9 +675,7 @@ GNUNET_PEERSTORE_iterate_cancel (struct GNUNET_PEERSTORE_IterateContext *ic)
 {
   if (GNUNET_NO == ic->iterating)
   {
-    GNUNET_CONTAINER_DLL_remove (ic->h->iterate_head,
-                                 ic->h->iterate_tail,
-                                 ic);
+    GNUNET_CONTAINER_DLL_remove (ic->h->iterate_head, ic->h->iterate_tail, ic);
     GNUNET_free (ic->sub_system);
     GNUNET_free_non_null (ic->key);
     GNUNET_free (ic);
@@ -725,13 +707,15 @@ GNUNET_PEERSTORE_iterate (struct GNUNET_PEERSTORE_Handle *h,
   struct GNUNET_MQ_Envelope *ev;
   struct GNUNET_PEERSTORE_IterateContext *ic;
 
-  ev = PEERSTORE_create_record_mq_envelope (sub_system,
-                                            peer,
-                                            key,
-                                            NULL, 0,
-                                            GNUNET_TIME_UNIT_FOREVER_ABS,
-                                            0,
-                                            GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE);
+  ev =
+    PEERSTORE_create_record_mq_envelope (sub_system,
+                                         peer,
+                                         key,
+                                         NULL,
+                                         0,
+                                         GNUNET_TIME_UNIT_FOREVER_ABS,
+                                         0,
+                                         GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE);
   ic = GNUNET_new (struct GNUNET_PEERSTORE_IterateContext);
   ic->callback = callback;
   ic->callback_cls = callback_cls;
@@ -741,9 +725,7 @@ GNUNET_PEERSTORE_iterate (struct GNUNET_PEERSTORE_Handle *h,
     ic->peer = *peer;
   if (NULL != key)
     ic->key = GNUNET_strdup (key);
-  GNUNET_CONTAINER_DLL_insert_tail (h->iterate_head,
-                                    h->iterate_tail,
-                                    ic);
+  GNUNET_CONTAINER_DLL_insert_tail (h->iterate_head, h->iterate_tail, ic);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Sending an iterate request for sub system `%s'\n",
        sub_system);
@@ -763,8 +745,7 @@ GNUNET_PEERSTORE_iterate (struct GNUNET_PEERSTORE_Handle *h,
  * @param msg message received
  */
 static int
-check_watch_record (void *cls,
-                    const struct StoreRecordMessage *msg)
+check_watch_record (void *cls, const struct StoreRecordMessage *msg)
 {
   /* we defer validation to #handle_watch_result */
   return GNUNET_OK;
@@ -778,41 +759,33 @@ check_watch_record (void *cls,
  * @param msg message received
  */
 static void
-handle_watch_record (void *cls,
-                     const struct StoreRecordMessage *msg)
+handle_watch_record (void *cls, const struct StoreRecordMessage *msg)
 {
   struct GNUNET_PEERSTORE_Handle *h = cls;
   struct GNUNET_PEERSTORE_Record *record;
   struct GNUNET_HashCode keyhash;
   struct GNUNET_PEERSTORE_WatchContext *wc;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Received a watch record from service.\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received a watch record from service.\n");
   record = PEERSTORE_parse_record_message (msg);
   if (NULL == record)
   {
     disconnect_and_schedule_reconnect (h);
     return;
   }
-  PEERSTORE_hash_key (record->sub_system,
-                      &record->peer,
-                      record->key,
-                      &keyhash);
+  PEERSTORE_hash_key (record->sub_system, &record->peer, record->key, &keyhash);
   // FIXME: what if there are multiple watches for the same key?
-  wc = GNUNET_CONTAINER_multihashmap_get (h->watches,
-                                          &keyhash);
+  wc = GNUNET_CONTAINER_multihashmap_get (h->watches, &keyhash);
   if (NULL == wc)
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
-         _("Received a watch result for a non existing watch.\n"));
+         _ ("Received a watch result for a non existing watch.\n"));
     PEERSTORE_destroy_record (record);
     disconnect_and_schedule_reconnect (h);
     return;
   }
   if (NULL != wc->callback)
-    wc->callback (wc->callback_cls,
-                  record,
-                  NULL);
+    wc->callback (wc->callback_cls, record, NULL);
   h->reconnect_delay = GNUNET_TIME_UNIT_ZERO;
   PEERSTORE_destroy_record (record);
 }
@@ -827,26 +800,24 @@ static void
 reconnect (void *cls)
 {
   struct GNUNET_PEERSTORE_Handle *h = cls;
-  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
-    GNUNET_MQ_hd_fixed_size (iterate_end,
-                             GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END,
-                             struct GNUNET_MessageHeader,
-                             h),
-    GNUNET_MQ_hd_var_size (iterate_result,
-                           GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD,
-                           struct StoreRecordMessage,
-                           h),
-    GNUNET_MQ_hd_var_size (watch_record,
-                           GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD,
-                           struct StoreRecordMessage,
-                           h),
-    GNUNET_MQ_handler_end ()
-  };
+  struct GNUNET_MQ_MessageHandler mq_handlers[] =
+    {GNUNET_MQ_hd_fixed_size (iterate_end,
+                              GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END,
+                              struct GNUNET_MessageHeader,
+                              h),
+     GNUNET_MQ_hd_var_size (iterate_result,
+                            GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD,
+                            struct StoreRecordMessage,
+                            h),
+     GNUNET_MQ_hd_var_size (watch_record,
+                            GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD,
+                            struct StoreRecordMessage,
+                            h),
+     GNUNET_MQ_handler_end ()};
   struct GNUNET_MQ_Envelope *ev;
 
   h->reconnect_task = NULL;
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Reconnecting...\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting...\n");
   h->mq = GNUNET_CLIENT_connect (h->cfg,
                                  "peerstore",
                                  mq_handlers,
@@ -857,39 +828,35 @@ reconnect (void *cls)
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Resending pending requests after reconnect.\n");
   if (NULL != h->watches)
-    GNUNET_CONTAINER_multihashmap_iterate (h->watches,
-                                           &rewatch_it,
-                                           h);
-  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head;
-       NULL != ic;
+    GNUNET_CONTAINER_multihashmap_iterate (h->watches, &rewatch_it, h);
+  for (struct GNUNET_PEERSTORE_IterateContext *ic = h->iterate_head; NULL != ic;
        ic = ic->next)
   {
-    ev = PEERSTORE_create_record_mq_envelope (ic->sub_system,
-                                              &ic->peer,
-                                              ic->key,
-                                              NULL, 0,
-                                              GNUNET_TIME_UNIT_FOREVER_ABS,
-                                              0,
-                                              GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE);
+    ev =
+      PEERSTORE_create_record_mq_envelope (ic->sub_system,
+                                           &ic->peer,
+                                           ic->key,
+                                           NULL,
+                                           0,
+                                           GNUNET_TIME_UNIT_FOREVER_ABS,
+                                           0,
+                                           GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE);
     GNUNET_MQ_send (h->mq, ev);
   }
-  for (struct GNUNET_PEERSTORE_StoreContext *sc = h->store_head;
-       NULL != sc;
+  for (struct GNUNET_PEERSTORE_StoreContext *sc = h->store_head; NULL != sc;
        sc = sc->next)
   {
-    ev = PEERSTORE_create_record_mq_envelope (sc->sub_system,
-                                              &sc->peer,
-                                              sc->key,
-                                              sc->value,
-                                              sc->size,
-                                              sc->expiry,
-                                              sc->options,
-                                              GNUNET_MESSAGE_TYPE_PEERSTORE_STORE);
-    GNUNET_MQ_notify_sent (ev,
-                           &store_request_sent,
-                           sc);
-    GNUNET_MQ_send (h->mq,
-                    ev);
+    ev =
+      PEERSTORE_create_record_mq_envelope (sc->sub_system,
+                                           &sc->peer,
+                                           sc->key,
+                                           sc->value,
+                                           sc->size,
+                                           sc->expiry,
+                                           sc->options,
+                                           GNUNET_MESSAGE_TYPE_PEERSTORE_STORE);
+    GNUNET_MQ_notify_sent (ev, &store_request_sent, sc);
+    GNUNET_MQ_send (h->mq, ev);
   }
 }
 
@@ -906,15 +873,13 @@ GNUNET_PEERSTORE_watch_cancel (struct GNUNET_PEERSTORE_WatchContext *wc)
   struct GNUNET_MQ_Envelope *ev;
   struct StoreKeyHashMessage *hm;
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Canceling watch.\n");
-  ev = GNUNET_MQ_msg (hm,
-                      GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Canceling watch.\n");
+  ev = GNUNET_MQ_msg (hm, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL);
   hm->keyhash = wc->keyhash;
   GNUNET_MQ_send (h->mq, ev);
-  GNUNET_CONTAINER_multihashmap_remove (h->watches,
-                                        &wc->keyhash,
-                                        wc);
+  GNUNET_assert (
+    GNUNET_YES ==
+    GNUNET_CONTAINER_multihashmap_remove (h->watches, &wc->keyhash, wc));
   GNUNET_free (wc);
 }
 
@@ -943,32 +908,26 @@ GNUNET_PEERSTORE_watch (struct GNUNET_PEERSTORE_Handle *h,
   struct StoreKeyHashMessage *hm;
   struct GNUNET_PEERSTORE_WatchContext *wc;
 
-  ev = GNUNET_MQ_msg (hm,
-                      GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH);
-  PEERSTORE_hash_key (sub_system,
-                      peer,
-                      key,
-                      &hm->keyhash);
+  ev = GNUNET_MQ_msg (hm, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH);
+  PEERSTORE_hash_key (sub_system, peer, key, &hm->keyhash);
   wc = GNUNET_new (struct GNUNET_PEERSTORE_WatchContext);
   wc->callback = callback;
   wc->callback_cls = callback_cls;
   wc->h = h;
   wc->keyhash = hm->keyhash;
   if (NULL == h->watches)
-    h->watches = GNUNET_CONTAINER_multihashmap_create (5,
-                                                       GNUNET_NO);
-  GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_put (h->watches,
-                                                    &wc->keyhash,
-                                                    wc,
-                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+    h->watches = GNUNET_CONTAINER_multihashmap_create (5, GNUNET_NO);
+  GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (
+                                h->watches,
+                                &wc->keyhash,
+                                wc,
+                                GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Sending a watch request for subsystem `%s', peer `%s', key `%s'.\n",
        sub_system,
        GNUNET_i2s (peer),
        key);
-  GNUNET_MQ_send (h->mq,
-                  ev);
+  GNUNET_MQ_send (h->mq, ev);
   return wc;
 }