peerstore: indentation

1 files changed, 167 insertions, 170 deletions

diff --git a/src/peerstore/gnunet-service-peerstore.c b/src/peerstore/gnunet-service-peerstore.c
index c93d2cc95..c674d3c11 100644
--- a/src/peerstore/gnunet-service-peerstore.c
+++ b/src/peerstore/gnunet-service-peerstore.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     (C) 
+     (C)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
@@ -53,7 +53,7 @@ struct ClientEntry
 /**
  * Interval for expired records cleanup (in seconds)
  */
-#define EXPIRED_RECORDS_CLEANUP_INTERVAL 300 /* 5mins */
+#define EXPIRED_RECORDS_CLEANUP_INTERVAL 300    /* 5mins */
 
 /**
  * Our configuration.
@@ -98,27 +98,29 @@ int in_shutdown;
 /**
  * Perform the actual shutdown operations
  */
-void do_shutdown ()
+void
+do_shutdown ()
 {
-  if(NULL != db_lib_name)
+  if (NULL != db_lib_name)
   {
     GNUNET_break (NULL == GNUNET_PLUGIN_unload (db_lib_name, db));
     GNUNET_free (db_lib_name);
     db_lib_name = NULL;
   }
-  if(NULL != nc)
+  if (NULL != nc)
   {
-    GNUNET_SERVER_notification_context_destroy(nc);
+    GNUNET_SERVER_notification_context_destroy (nc);
     nc = NULL;
   }
-  if(NULL != watchers)
+  if (NULL != watchers)
   {
-    GNUNET_CONTAINER_multihashmap_destroy(watchers);
+    GNUNET_CONTAINER_multihashmap_destroy (watchers);
     watchers = NULL;
   }
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_SCHEDULER_shutdown ();
 }
 
+
 /**
  * Task run during shutdown.
  *
@@ -126,34 +128,36 @@ void do_shutdown ()
  * @param tc unused
  */
 static void
-shutdown_task (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   in_shutdown = GNUNET_YES;
-  if (NULL == client_head) /* Only when no connected clients. */
+  if (NULL == client_head)      /* Only when no connected clients. */
     do_shutdown ();
 }
 
+
 /**
  * Deletes any expired records from storage
  */
 static void
-cleanup_expired_records(void *cls,
-    const struct GNUNET_SCHEDULER_TaskContext *tc)
+cleanup_expired_records (void *cls,
+                         const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   int deleted;
 
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
-  GNUNET_assert(NULL != db);
-  deleted = db->expire_records(db->cls, GNUNET_TIME_absolute_get());
+  GNUNET_assert (NULL != db);
+  deleted = db->expire_records (db->cls, GNUNET_TIME_absolute_get ());
   if (deleted > 0)
-    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "%d records expired.\n", deleted);
-  GNUNET_SCHEDULER_add_delayed(
-      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, EXPIRED_RECORDS_CLEANUP_INTERVAL),
-      &cleanup_expired_records, NULL);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "%d records expired.\n", deleted);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                (GNUNET_TIME_UNIT_SECONDS,
+                                 EXPIRED_RECORDS_CLEANUP_INTERVAL),
+                                &cleanup_expired_records, NULL);
 }
 
+
 /**
  * Search for a disconnected client and remove it
  *
@@ -162,15 +166,15 @@ cleanup_expired_records(void *cls,
  * @param value the watcher client, a 'struct GNUNET_SERVER_Client *'
  * @return #GNUNET_OK to continue iterating
  */
-static int client_disconnect_it(void *cls,
-    const struct GNUNET_HashCode *key,
-    void *value)
+static int
+client_disconnect_it (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
-  if(cls == value)
-    GNUNET_CONTAINER_multihashmap_remove(watchers, key, value);
+  if (cls == value)
+    GNUNET_CONTAINER_multihashmap_remove (watchers, key, value);
   return GNUNET_OK;
 }
 
+
 /**
  * A client disconnected.  Remove all of its data structure entries.
  *
@@ -178,16 +182,14 @@ static int client_disconnect_it(void *cls,
  * @param client identification of the client
  */
 static void
-handle_client_disconnect (void *cls,
-                          struct GNUNET_SERVER_Client
-                          * client)
+handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
 {
   struct ClientEntry *ce;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "A client disconnected, cleaning up.\n");
-  if(NULL != watchers)
-    GNUNET_CONTAINER_multihashmap_iterate(watchers,
-        &client_disconnect_it, client);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "A client disconnected, cleaning up.\n");
+  if (NULL != watchers)
+    GNUNET_CONTAINER_multihashmap_iterate (watchers, &client_disconnect_it,
+                                           client);
   ce = client_head;
   while (ce != NULL)
   {
@@ -203,6 +205,7 @@ handle_client_disconnect (void *cls,
     do_shutdown ();
 }
 
+
 /**
  * Function called by for each matching record.
  *
@@ -212,28 +215,24 @@ handle_client_disconnect (void *cls,
  * @return #GNUNET_YES to continue iteration
  */
 static int
-record_iterator (void *cls,
-                 struct GNUNET_PEERSTORE_Record *record,
-                 char *emsg)
+record_iterator (void *cls, struct GNUNET_PEERSTORE_Record *record, char *emsg)
 {
   struct GNUNET_SERVER_Client *client = cls;
   struct StoreRecordMessage *srm;
 
   srm =
-      PEERSTORE_create_record_message(record->sub_system,
-                                      record->peer,
-                                      record->key,
-                                      record->value,
-                                      record->value_size,
-                                      record->expiry,
-                                      GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD);
+      PEERSTORE_create_record_message (record->sub_system, record->peer,
+                                       record->key, record->value,
+                                       record->value_size, record->expiry,
+                                       GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_RECORD);
   GNUNET_SERVER_notification_context_unicast (nc, client,
-                                              (struct GNUNET_MessageHeader *)srm,
-                                              GNUNET_NO);
-  GNUNET_free(srm);
+                                              (struct GNUNET_MessageHeader *)
+                                              srm, GNUNET_NO);
+  GNUNET_free (srm);
   return GNUNET_YES;
 }
 
+
 /**
  * Iterator over all watcher clients
  * to notify them of a new record
@@ -243,44 +242,43 @@ record_iterator (void *cls,
  * @param value the watcher client, a 'struct GNUNET_SERVER_Client *'
  * @return #GNUNET_YES to continue iterating
  */
-static int watch_notifier_it(void *cls,
-    const struct GNUNET_HashCode *key,
-    void *value)
+static int
+watch_notifier_it (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct GNUNET_PEERSTORE_Record *record = cls;
   struct GNUNET_SERVER_Client *client = value;
   struct StoreRecordMessage *srm;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Found a watcher to update.\n");
-  srm = PEERSTORE_create_record_message(record->sub_system,
-      record->peer,
-      record->key,
-      record->value,
-      record->value_size,
-      record->expiry,
-      GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD);
-  GNUNET_SERVER_notification_context_unicast(nc, client,
-      (const struct GNUNET_MessageHeader *)srm, GNUNET_NO);
-  GNUNET_free(srm);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found a watcher to update.\n");
+  srm =
+      PEERSTORE_create_record_message (record->sub_system, record->peer,
+                                       record->key, record->value,
+                                       record->value_size, record->expiry,
+                                       GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_RECORD);
+  GNUNET_SERVER_notification_context_unicast (nc, client,
+                                              (const struct GNUNET_MessageHeader
+                                               *) srm, GNUNET_NO);
+  GNUNET_free (srm);
   return GNUNET_YES;
 }
 
+
 /**
  * Given a new record, notifies watchers
  *
  * @param record changed record to update watchers with
  */
-static void watch_notifier (struct GNUNET_PEERSTORE_Record *record)
+static void
+watch_notifier (struct GNUNET_PEERSTORE_Record *record)
 {
   struct GNUNET_HashCode keyhash;
 
-  PEERSTORE_hash_key(record->sub_system,
-      record->peer,
-      record->key,
-      &keyhash);
-  GNUNET_CONTAINER_multihashmap_get_multiple(watchers, &keyhash, &watch_notifier_it, record);
+  PEERSTORE_hash_key (record->sub_system, record->peer, record->key, &keyhash);
+  GNUNET_CONTAINER_multihashmap_get_multiple (watchers, &keyhash,
+                                              &watch_notifier_it, record);
 }
 
+
 /**
  * Handle a watch cancel request from client
  *
@@ -288,18 +286,19 @@ static void watch_notifier (struct GNUNET_PEERSTORE_Record *record)
  * @param client identification of the client
  * @param message the actual message
  */
-static void handle_watch_cancel (void *cls,
-    struct GNUNET_SERVER_Client *client,
-    const struct GNUNET_MessageHeader *message)
+static void
+handle_watch_cancel (void *cls, struct GNUNET_SERVER_Client *client,
+                     const struct GNUNET_MessageHeader *message)
 {
   struct StoreKeyHashMessage *hm;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received a watch cancel request.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received a watch cancel request.\n");
   hm = (struct StoreKeyHashMessage *) message;
-  GNUNET_CONTAINER_multihashmap_remove(watchers, &hm->keyhash, client);
-  GNUNET_SERVER_receive_done(client, GNUNET_OK);
+  GNUNET_CONTAINER_multihashmap_remove (watchers, &hm->keyhash, client);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
+
 /**
  * Handle a watch request from client
  *
@@ -307,21 +306,22 @@ static void handle_watch_cancel (void *cls,
  * @param client identification of the client
  * @param message the actual message
  */
-static void handle_watch (void *cls,
-    struct GNUNET_SERVER_Client *client,
-    const struct GNUNET_MessageHeader *message)
+static void
+handle_watch (void *cls, struct GNUNET_SERVER_Client *client,
+              const struct GNUNET_MessageHeader *message)
 {
   struct StoreKeyHashMessage *hm;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received a watch request.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received a watch request.\n");
   hm = (struct StoreKeyHashMessage *) message;
-  GNUNET_SERVER_client_mark_monitor(client);
-  GNUNET_SERVER_notification_context_add(nc, client);
-  GNUNET_CONTAINER_multihashmap_put(watchers, &hm->keyhash,
-     client, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-  GNUNET_SERVER_receive_done(client, GNUNET_OK);
+  GNUNET_SERVER_client_mark_monitor (client);
+  GNUNET_SERVER_notification_context_add (nc, client);
+  GNUNET_CONTAINER_multihashmap_put (watchers, &hm->keyhash, client,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
 }
 
+
 /**
  * Handle an iterate request from client
  *
@@ -329,55 +329,54 @@ static void handle_watch (void *cls,
  * @param client identification of the client
  * @param message the actual message
  */
-static void handle_iterate (void *cls,
-    struct GNUNET_SERVER_Client *client,
-    const struct GNUNET_MessageHeader *message)
+static void
+handle_iterate (void *cls, struct GNUNET_SERVER_Client *client,
+                const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_PEERSTORE_Record *record;
   struct GNUNET_MessageHeader *endmsg;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Received an iterate request.\n");
-  record = PEERSTORE_parse_record_message(message);
-  if(NULL == record)
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received an iterate request.\n");
+  record = PEERSTORE_parse_record_message (message);
+  if (NULL == record)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Malformed iterate request.\n"));
-    GNUNET_SERVER_receive_done(client, GNUNET_SYSERR);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Malformed iterate request.\n"));
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
     return;
   }
-  if(NULL == record->sub_system)
+  if (NULL == record->sub_system)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-        _("Sub system not supplied in client iterate request.\n"));
-    GNUNET_SERVER_receive_done(client, GNUNET_SYSERR);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Sub system not supplied in client iterate request.\n"));
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
     return;
   }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Iterate request: ss `%s', peer `%s', key `%s'\n",
-             record->sub_system,
-             (NULL == record->peer) ? "NULL" : GNUNET_i2s(record->peer),
-             (NULL == record->key) ? "NULL" : record->key);
-  GNUNET_SERVER_notification_context_add(nc, client);
-  if(GNUNET_OK == db->iterate_records(db->cls,
-                                      record->sub_system,
-                                      record->peer,
-                                      record->key,
-                                      &record_iterator,
-                                      client))
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Iterate request: ss `%s', peer `%s', key `%s'\n",
+              record->sub_system,
+              (NULL == record->peer) ? "NULL" : GNUNET_i2s (record->peer),
+              (NULL == record->key) ? "NULL" : record->key);
+  GNUNET_SERVER_notification_context_add (nc, client);
+  if (GNUNET_OK ==
+      db->iterate_records (db->cls, record->sub_system, record->peer,
+                           record->key, &record_iterator, client))
   {
-    endmsg = GNUNET_new(struct GNUNET_MessageHeader);
-    endmsg->size = htons(sizeof(struct GNUNET_MessageHeader));
-    endmsg->type = htons(GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END);
-    GNUNET_SERVER_notification_context_unicast(nc, client, endmsg, GNUNET_NO);
-    GNUNET_free(endmsg);
-    GNUNET_SERVER_receive_done(client, GNUNET_OK);
+    endmsg = GNUNET_new (struct GNUNET_MessageHeader);
+
+    endmsg->size = htons (sizeof (struct GNUNET_MessageHeader));
+    endmsg->type = htons (GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE_END);
+    GNUNET_SERVER_notification_context_unicast (nc, client, endmsg, GNUNET_NO);
+    GNUNET_free (endmsg);
+    GNUNET_SERVER_receive_done (client, GNUNET_OK);
   }
   else
   {
-    GNUNET_SERVER_receive_done(client, GNUNET_SYSERR);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
   }
-  PEERSTORE_destroy_record(record);
+  PEERSTORE_destroy_record (record);
 }
 
+
 /**
  * Handle a store request from client
  *
@@ -385,54 +384,51 @@ static void handle_iterate (void *cls,
  * @param client identification of the client
  * @param message the actual message
  */
-static void handle_store (void *cls,
-    struct GNUNET_SERVER_Client *client,
-    const struct GNUNET_MessageHeader *message)
+static void
+handle_store (void *cls, struct GNUNET_SERVER_Client *client,
+              const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_PEERSTORE_Record *record;
   struct StoreRecordMessage *srm;
 
-  record = PEERSTORE_parse_record_message(message);
-  if(NULL == record)
+  record = PEERSTORE_parse_record_message (message);
+  if (NULL == record)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Malformed store request from client\n"));
-    GNUNET_SERVER_receive_done(client, GNUNET_SYSERR);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Malformed store request from client\n"));
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
     return;
   }
-  srm = (struct StoreRecordMessage *)message;
-  if(NULL == record->sub_system
-      || NULL == record->peer
-      || NULL == record->key)
+  srm = (struct StoreRecordMessage *) message;
+  if (NULL == record->sub_system || NULL == record->peer || NULL == record->key)
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Full key not supplied in client store request\n"));
-    PEERSTORE_destroy_record(record);
-    GNUNET_SERVER_receive_done(client, GNUNET_SYSERR);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Full key not supplied in client store request\n"));
+    PEERSTORE_destroy_record (record);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
     return;
   }
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Received a store request (size: %lu) for sub system `%s', peer `%s', key `%s'\n",
-      record->value_size,
-      record->sub_system,
-      GNUNET_i2s (record->peer),
-      record->key);
-  if(GNUNET_OK != db->store_record(db->cls,
-      record->sub_system,
-      record->peer,
-      record->key,
-      record->value,
-      record->value_size,
-      *record->expiry,
-      srm->options))
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Received a store request (size: %lu) for sub system `%s', peer `%s', key `%s'\n",
+              record->value_size, record->sub_system, GNUNET_i2s (record->peer),
+              record->key);
+  if (GNUNET_OK !=
+      db->store_record (db->cls, record->sub_system, record->peer, record->key,
+                        record->value, record->value_size, *record->expiry,
+                        srm->options))
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Failed to store requested value, sqlite database error."));
-    PEERSTORE_destroy_record(record);
-    GNUNET_SERVER_receive_done(client, GNUNET_SYSERR);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to store requested value, sqlite database error."));
+    PEERSTORE_destroy_record (record);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
     return;
   }
-  GNUNET_SERVER_receive_done(client, GNUNET_OK);
-  watch_notifier(record);
-  PEERSTORE_destroy_record(record);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+  watch_notifier (record);
+  PEERSTORE_destroy_record (record);
 }
 
+
 /**
  * Creates an entry for a new client or returns it if it already exists.
  *
@@ -462,6 +458,7 @@ make_client_entry (struct GNUNET_SERVER_Client *client)
   return ce;
 }
 
+
 /**
  * Callback on a new client connection
  *
@@ -475,6 +472,7 @@ handle_client_connect (void *cls, struct GNUNET_SERVER_Client *client)
   make_client_entry (client);
 }
 
+
 /**
  * Peerstore service runner.
  *
@@ -483,47 +481,48 @@ handle_client_connect (void *cls, struct GNUNET_SERVER_Client *client)
  * @param c configuration to use
  */
 static void
-run (void *cls,
-     struct GNUNET_SERVER_Handle *server,
+run (void *cls, struct GNUNET_SERVER_Handle *server,
      const struct GNUNET_CONFIGURATION_Handle *c)
 {
   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
-      {&handle_store, NULL, GNUNET_MESSAGE_TYPE_PEERSTORE_STORE, 0},
-      {&handle_iterate, NULL, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE, 0},
-      {&handle_watch, NULL, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH, sizeof(struct StoreKeyHashMessage)},
-      {&handle_watch_cancel, NULL, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL, sizeof(struct StoreKeyHashMessage)},
-      {NULL, NULL, 0, 0}
+    {&handle_store, NULL, GNUNET_MESSAGE_TYPE_PEERSTORE_STORE, 0},
+    {&handle_iterate, NULL, GNUNET_MESSAGE_TYPE_PEERSTORE_ITERATE, 0},
+    {&handle_watch, NULL, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH,
+     sizeof (struct StoreKeyHashMessage)},
+    {&handle_watch_cancel, NULL, GNUNET_MESSAGE_TYPE_PEERSTORE_WATCH_CANCEL,
+     sizeof (struct StoreKeyHashMessage)},
+    {NULL, NULL, 0, 0}
   };
   char *database;
 
   in_shutdown = GNUNET_NO;
   cfg = c;
   if (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_string (cfg, "peerstore", "DATABASE",
-                                               &database))
+      GNUNET_CONFIGURATION_get_value_string (cfg, "peerstore", "DATABASE",
+                                             &database))
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("No database backend configured\n"));
 
   else
   {
     GNUNET_asprintf (&db_lib_name, "libgnunet_plugin_peerstore_%s", database);
-    db = GNUNET_PLUGIN_load(db_lib_name, (void *) cfg);
-    GNUNET_free(database);
+    db = GNUNET_PLUGIN_load (db_lib_name, (void *) cfg);
+    GNUNET_free (database);
   }
-  if(NULL == db)
+  if (NULL == db)
   {
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR, _("Could not load database backend `%s'\n"), db_lib_name);
-          GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
-          return;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not load database backend `%s'\n"), db_lib_name);
+    GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
+    return;
   }
   nc = GNUNET_SERVER_notification_context_create (server, 16);
-  watchers = GNUNET_CONTAINER_multihashmap_create(10, GNUNET_NO);
-  GNUNET_SCHEDULER_add_now(&cleanup_expired_records, NULL);
+  watchers = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
+  GNUNET_SCHEDULER_add_now (&cleanup_expired_records, NULL);
   GNUNET_SERVER_add_handlers (server, handlers);
   GNUNET_SERVER_connect_notify (server, &handle_client_connect, NULL);
   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
-  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                &shutdown_task,
-                                NULL);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
+                                NULL);
 }
 
 
@@ -538,11 +537,9 @@ int
 main (int argc, char *const *argv)
 {
   return (GNUNET_OK ==
-          GNUNET_SERVICE_run (argc,
-              argv,
-              "peerstore",
-              GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN,
-              &run, NULL)) ? 0 : 1;
+          GNUNET_SERVICE_run (argc, argv, "peerstore",
+                              GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, &run,
+                              NULL)) ? 0 : 1;
 }
 
 /* end of gnunet-service-peerstore.c */