enable suspend resume for REST

2 files changed, 234 insertions, 227 deletions

diff --git a/src/identity/plugin_rest_identity.c b/src/identity/plugin_rest_identity.c
index e6537070a..ac1965a75 100644
--- a/src/identity/plugin_rest_identity.c
+++ b/src/identity/plugin_rest_identity.c
@@ -124,7 +124,7 @@ const struct GNUNET_CONFIGURATION_Handle *cfg;
 /**
  * HTTP methods allows for this plugin
  */
-static char* allow_methods;
+static char *allow_methods;
 
 /**
  * @brief struct returned by the initialization function of the plugin
@@ -173,7 +173,7 @@ struct RequestHandle
   /**
    * The data from the REST request
    */
-  const char* data;
+  const char *data;
 
   /**
    * The name to look up
@@ -250,7 +250,6 @@ struct RequestHandle
    * Response code
    */
   int response_code;
-
 };
 
 /**
@@ -264,7 +263,7 @@ cleanup_handle (void *cls)
   struct EgoEntry *ego_entry;
   struct EgoEntry *ego_tmp;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
   if (NULL != handle->timeout_task)
   {
     GNUNET_SCHEDULER_cancel (handle->timeout_task);
@@ -272,25 +271,24 @@ cleanup_handle (void *cls)
   }
 
   if (NULL != handle->url)
-    GNUNET_free(handle->url);
+    GNUNET_free (handle->url);
   if (NULL != handle->emsg)
-    GNUNET_free(handle->emsg);
+    GNUNET_free (handle->emsg);
   if (NULL != handle->name)
     GNUNET_free (handle->name);
   if (NULL != handle->identity_handle)
     GNUNET_IDENTITY_disconnect (handle->identity_handle);
 
-  for (ego_entry = handle->ego_head;
-  NULL != ego_entry;)
+  for (ego_entry = handle->ego_head; NULL != ego_entry;)
   {
     ego_tmp = ego_entry;
     ego_entry = ego_entry->next;
-    GNUNET_free(ego_tmp->identifier);
-    GNUNET_free(ego_tmp->keystring);
-    GNUNET_free(ego_tmp);
+    GNUNET_free (ego_tmp->identifier);
+    GNUNET_free (ego_tmp->keystring);
+    GNUNET_free (ego_tmp);
   }
 
-  GNUNET_free(handle);
+  GNUNET_free (handle);
 }
 
 /**
@@ -303,26 +301,25 @@ do_error (void *cls)
 {
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
-  json_t *json_error = json_object();
+  json_t *json_error = json_object ();
   char *response;
 
   if (NULL == handle->emsg)
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_ERROR_UNKNOWN);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_ERROR_UNKNOWN);
 
-  json_object_set_new(json_error,"error", json_string(handle->emsg));
+  json_object_set_new (json_error, "error", json_string (handle->emsg));
 
   if (0 == handle->response_code)
     handle->response_code = MHD_HTTP_OK;
   response = json_dumps (json_error, 0);
   resp = GNUNET_REST_create_response (response);
   handle->proc (handle->proc_cls, resp, handle->response_code);
-  json_decref(json_error);
-  GNUNET_free(response);
+  json_decref (json_error);
+  GNUNET_free (response);
   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 }
 
 
-
 /**
  * Get EgoEntry from list with either a public key or a name
  * If public key and name are not NULL, it returns the public key result first
@@ -332,29 +329,27 @@ do_error (void *cls)
  * @param name the name of an identity (only one can be NULL)
  * @return EgoEntry or NULL if not found
  */
-struct EgoEntry*
-get_egoentry(struct RequestHandle *handle, char* pubkey, char *name)
+struct EgoEntry *
+get_egoentry (struct RequestHandle *handle, char *pubkey, char *name)
 {
   struct EgoEntry *ego_entry;
   if (NULL != pubkey)
   {
-    for (ego_entry = handle->ego_head;
-        NULL != ego_entry;
-        ego_entry = ego_entry->next)
+    for (ego_entry = handle->ego_head; NULL != ego_entry;
+         ego_entry = ego_entry->next)
     {
       if (0 != strcasecmp (pubkey, ego_entry->keystring))
-        continue;
+        continue;
       return ego_entry;
     }
   }
   if (NULL != name)
   {
-    for (ego_entry = handle->ego_head;
-        NULL != ego_entry;
-        ego_entry = ego_entry->next)
+    for (ego_entry = handle->ego_head; NULL != ego_entry;
+         ego_entry = ego_entry->next)
     {
       if (0 != strcasecmp (name, ego_entry->identifier))
-        continue;
+        continue;
       return ego_entry;
     }
   }
@@ -372,9 +367,9 @@ get_egoentry(struct RequestHandle *handle, char* pubkey, char *name)
  */
 static void
 ego_get_for_subsystem (void *cls,
-                       struct GNUNET_IDENTITY_Ego *ego,
-                       void **ctx,
-                       const char *name)
+                       struct GNUNET_IDENTITY_Ego *ego,
+                       void **ctx,
+                       const char *name)
 {
   struct RequestHandle *handle = cls;
   struct MHD_Response *resp;
@@ -383,34 +378,34 @@ ego_get_for_subsystem (void *cls,
   char *result_str;
   char *public_key_string;
 
-  if(NULL == ego)
+  if (NULL == ego)
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
 
-  GNUNET_IDENTITY_ego_get_public_key(ego,&public_key);
-  public_key_string = GNUNET_CRYPTO_ecdsa_public_key_to_string(&public_key);
+  GNUNET_IDENTITY_ego_get_public_key (ego, &public_key);
+  public_key_string = GNUNET_CRYPTO_ecdsa_public_key_to_string (&public_key);
 
   // create json with subsystem identity
   json_root = json_object ();
   json_object_set_new (json_root,
-                       GNUNET_REST_IDENTITY_PARAM_PUBKEY,
-                       json_string(public_key_string));
+                       GNUNET_REST_IDENTITY_PARAM_PUBKEY,
+                       json_string (public_key_string));
   json_object_set_new (json_root,
-                       GNUNET_REST_IDENTITY_PARAM_NAME,
-                       json_string(name));
+                       GNUNET_REST_IDENTITY_PARAM_NAME,
+                       json_string (name));
 
   result_str = json_dumps (json_root, 0);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
   resp = GNUNET_REST_create_response (result_str);
 
   json_decref (json_root);
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
-  GNUNET_free(result_str);
-  GNUNET_free(public_key_string);
+  GNUNET_free (result_str);
+  GNUNET_free (public_key_string);
   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 }
 
@@ -423,32 +418,31 @@ ego_get_for_subsystem (void *cls,
  */
 void
 ego_get_subsystem (struct GNUNET_REST_RequestHandle *con_handle,
-                   const char* url,
-                   void *cls)
+                   const char *url,
+                   void *cls)
 {
   struct RequestHandle *handle = cls;
   char *subsystem;
 
   if (strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) >= strlen (handle->url))
   {
-    handle->emsg = GNUNET_strdup("Missing subsystem name");
+    handle->emsg = GNUNET_strdup ("Missing subsystem name");
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  subsystem = &handle->url[strlen (
-      GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) + 1];
+  subsystem = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) + 1];
   //requested default identity of subsystem
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Looking for %s's ego\n", subsystem);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looking for %s's ego\n", subsystem);
 
   handle->op = GNUNET_IDENTITY_get (handle->identity_handle,
-                                    subsystem,
-                                    &ego_get_for_subsystem,
-                                    handle);
+                                    subsystem,
+                                    &ego_get_for_subsystem,
+                                    handle);
 
   if (NULL == handle->op)
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -464,8 +458,8 @@ ego_get_subsystem (struct GNUNET_REST_RequestHandle *con_handle,
  */
 void
 ego_get_all (struct GNUNET_REST_RequestHandle *con_handle,
-             const char* url,
-             void *cls)
+             const char *url,
+             void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
@@ -476,27 +470,27 @@ ego_get_all (struct GNUNET_REST_RequestHandle *con_handle,
 
   json_root = json_array ();
   //Return ego/egos
-  for (ego_entry = handle->ego_head;
-  NULL != ego_entry; ego_entry = ego_entry->next)
+  for (ego_entry = handle->ego_head; NULL != ego_entry;
+       ego_entry = ego_entry->next)
   {
     json_ego = json_object ();
     json_object_set_new (json_ego,
-                         GNUNET_REST_IDENTITY_PARAM_PUBKEY,
-                         json_string (ego_entry->keystring));
+                         GNUNET_REST_IDENTITY_PARAM_PUBKEY,
+                         json_string (ego_entry->keystring));
     json_object_set_new (json_ego,
-                         GNUNET_REST_IDENTITY_PARAM_NAME,
-                         json_string (ego_entry->identifier));
+                         GNUNET_REST_IDENTITY_PARAM_NAME,
+                         json_string (ego_entry->identifier));
     json_array_append (json_root, json_ego);
     json_decref (json_ego);
   }
 
   result_str = json_dumps (json_root, 0);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
   resp = GNUNET_REST_create_response (result_str);
 
   json_decref (json_root);
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
-  GNUNET_free(result_str);
+  GNUNET_free (result_str);
   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 }
 
@@ -516,19 +510,19 @@ ego_get_response (struct RequestHandle *handle, struct EgoEntry *ego_entry)
 
   json_ego = json_object ();
   json_object_set_new (json_ego,
-                       GNUNET_REST_IDENTITY_PARAM_PUBKEY,
-                       json_string (ego_entry->keystring));
+                       GNUNET_REST_IDENTITY_PARAM_PUBKEY,
+                       json_string (ego_entry->keystring));
   json_object_set_new (json_ego,
-                       GNUNET_REST_IDENTITY_PARAM_NAME,
-                       json_string (ego_entry->identifier));
+                       GNUNET_REST_IDENTITY_PARAM_NAME,
+                       json_string (ego_entry->identifier));
 
   result_str = json_dumps (json_ego, 0);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
   resp = GNUNET_REST_create_response (result_str);
   handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
 
   json_decref (json_ego);
-  GNUNET_free(result_str);
+  GNUNET_free (result_str);
   GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
 }
 
@@ -542,8 +536,8 @@ ego_get_response (struct RequestHandle *handle, struct EgoEntry *ego_entry)
  */
 void
 ego_get_pubkey (struct GNUNET_REST_RequestHandle *con_handle,
-                const char* url,
-                void *cls)
+                const char *url,
+                void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
@@ -554,22 +548,22 @@ ego_get_pubkey (struct GNUNET_REST_RequestHandle *con_handle,
   if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_PUBKEY);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_PUBKEY);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY)+1];
-  ego_entry = get_egoentry(handle, keystring, NULL);
+  keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) + 1];
+  ego_entry = get_egoentry (handle, keystring, NULL);
 
   if (NULL == ego_entry)
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
 
-  ego_get_response(handle, ego_entry);
+  ego_get_response (handle, ego_entry);
 }
 
 /**
@@ -581,8 +575,8 @@ ego_get_pubkey (struct GNUNET_REST_RequestHandle *con_handle,
  */
 void
 ego_get_name (struct GNUNET_REST_RequestHandle *con_handle,
-              const char* url,
-              void *cls)
+              const char *url,
+              void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
@@ -593,22 +587,22 @@ ego_get_name (struct GNUNET_REST_RequestHandle *con_handle,
   if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_NAME);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_NAME);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  egoname = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME)+1];
-  ego_entry = get_egoentry(handle, NULL, egoname);
+  egoname = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
+  ego_entry = get_egoentry (handle, NULL, egoname);
 
   if (NULL == ego_entry)
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
 
-  ego_get_response(handle, ego_entry);
+  ego_get_response (handle, ego_entry);
 }
 
 
@@ -627,7 +621,7 @@ do_finished (void *cls, const char *emsg)
   handle->op = NULL;
   if (NULL != emsg)
   {
-    handle->emsg = GNUNET_strdup(emsg);
+    handle->emsg = GNUNET_strdup (emsg);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -650,14 +644,13 @@ do_finished (void *cls, const char *emsg)
  */
 static void
 do_finished_create (void *cls,
-                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk,
-                    const char *emsg)
+                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk,
+                    const char *emsg)
 {
   struct RequestHandle *handle = cls;
 
   (void) pk;
-  do_finished (handle,
-               emsg);
+  do_finished (handle, emsg);
 }
 
 
@@ -681,18 +674,18 @@ ego_edit (struct RequestHandle *handle, struct EgoEntry *ego_entry)
   //if no data
   if (0 >= handle->data_size)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_NO_DATA);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
   //if not json
   term_data[handle->data_size] = '\0';
-  GNUNET_memcpy(term_data, handle->data, handle->data_size);
-  data_js = json_loads (term_data,JSON_DECODE_ANY,&err);
+  GNUNET_memcpy (term_data, handle->data, handle->data_size);
+  data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
 
   if (NULL == data_js)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_NO_DATA);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -700,15 +693,15 @@ ego_edit (struct RequestHandle *handle, struct EgoEntry *ego_entry)
   newname = NULL;
   //NEW NAME
   json_state = 0;
-  json_state = json_unpack(data_js,
-                           "{s:s!}",
-                           GNUNET_REST_IDENTITY_PARAM_NEWNAME,
-                           &newname);
+  json_state = json_unpack (data_js,
+                            "{s:s!}",
+                            GNUNET_REST_IDENTITY_PARAM_NEWNAME,
+                            &newname);
   //Change name with pubkey or name identifier
   if (0 != json_state)
   {
 
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
@@ -716,7 +709,7 @@ ego_edit (struct RequestHandle *handle, struct EgoEntry *ego_entry)
 
   if (NULL == newname)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
@@ -724,7 +717,7 @@ ego_edit (struct RequestHandle *handle, struct EgoEntry *ego_entry)
 
   if (0 >= strlen (newname))
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
@@ -741,20 +734,19 @@ ego_edit (struct RequestHandle *handle, struct EgoEntry *ego_entry)
     return;
   }
   handle->op = GNUNET_IDENTITY_rename (handle->identity_handle,
-                                       ego_entry->identifier,
-                                       newname,
-                                       &do_finished,
-                                       handle);
+                                       ego_entry->identifier,
+                                       newname,
+                                       &do_finished,
+                                       handle);
   if (NULL == handle->op)
   {
-    handle->emsg = GNUNET_strdup("Rename failed");
+    handle->emsg = GNUNET_strdup ("Rename failed");
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
   }
   json_decref (data_js);
   return;
-
 }
 
 
@@ -767,8 +759,8 @@ ego_edit (struct RequestHandle *handle, struct EgoEntry *ego_entry)
  */
 void
 ego_edit_pubkey (struct GNUNET_REST_RequestHandle *con_handle,
-                 const char* url,
-                 void *cls)
+                 const char *url,
+                 void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
@@ -779,22 +771,22 @@ ego_edit_pubkey (struct GNUNET_REST_RequestHandle *con_handle,
   if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_PUBKEY);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_PUBKEY);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY)+1];
-  ego_entry = get_egoentry(handle, keystring, NULL);
+  keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) + 1];
+  ego_entry = get_egoentry (handle, keystring, NULL);
 
   if (NULL == ego_entry)
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
 
-  ego_edit(handle,ego_entry);
+  ego_edit (handle, ego_entry);
 }
 
 /**
@@ -806,8 +798,8 @@ ego_edit_pubkey (struct GNUNET_REST_RequestHandle *con_handle,
  */
 void
 ego_edit_name (struct GNUNET_REST_RequestHandle *con_handle,
-               const char* url,
-               void *cls)
+               const char *url,
+               void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
@@ -818,22 +810,22 @@ ego_edit_name (struct GNUNET_REST_RequestHandle *con_handle,
   if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_NAME);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_NAME);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME)+1];
-  ego_entry = get_egoentry(handle, NULL, name);
+  name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
+  ego_entry = get_egoentry (handle, NULL, name);
 
   if (NULL == ego_entry)
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
 
-  ego_edit(handle,ego_entry);
+  ego_edit (handle, ego_entry);
 }
 
 /**
@@ -845,8 +837,8 @@ ego_edit_name (struct GNUNET_REST_RequestHandle *con_handle,
  */
 void
 ego_edit_subsystem (struct GNUNET_REST_RequestHandle *con_handle,
-                    const char* url,
-                    void *cls)
+                    const char *url,
+                    void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
@@ -862,17 +854,17 @@ ego_edit_subsystem (struct GNUNET_REST_RequestHandle *con_handle,
   if (strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) >= strlen (handle->url))
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_NAME);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_NAME);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM)+1];
-  ego_entry = get_egoentry(handle, NULL, name);
+  name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) + 1];
+  ego_entry = get_egoentry (handle, NULL, name);
 
   if (NULL == ego_entry)
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -880,18 +872,18 @@ ego_edit_subsystem (struct GNUNET_REST_RequestHandle *con_handle,
   //if no data
   if (0 >= handle->data_size)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_NO_DATA);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
   //if not json
   term_data[handle->data_size] = '\0';
-  GNUNET_memcpy(term_data, handle->data, handle->data_size);
-  data_js = json_loads (term_data,JSON_DECODE_ANY,&err);
+  GNUNET_memcpy (term_data, handle->data, handle->data_size);
+  data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
 
   if (NULL == data_js)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_NO_DATA);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
@@ -899,14 +891,14 @@ ego_edit_subsystem (struct GNUNET_REST_RequestHandle *con_handle,
   newsubsys = NULL;
   //SUBSYSTEM
   json_state = 0;
-  json_state = json_unpack(data_js,
-                           "{s:s!}",
-                           GNUNET_REST_IDENTITY_PARAM_SUBSYSTEM,
-                           &newsubsys);
+  json_state = json_unpack (data_js,
+                            "{s:s!}",
+                            GNUNET_REST_IDENTITY_PARAM_SUBSYSTEM,
+                            &newsubsys);
   //Change subsystem with pubkey or name identifier
   if (0 != json_state)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
@@ -914,7 +906,7 @@ ego_edit_subsystem (struct GNUNET_REST_RequestHandle *con_handle,
 
   if (NULL == newsubsys)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
@@ -922,7 +914,7 @@ ego_edit_subsystem (struct GNUNET_REST_RequestHandle *con_handle,
 
   if (0 >= strlen (newsubsys))
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
@@ -930,19 +922,18 @@ ego_edit_subsystem (struct GNUNET_REST_RequestHandle *con_handle,
 
   handle->response_code = MHD_HTTP_NO_CONTENT;
   handle->op = GNUNET_IDENTITY_set (handle->identity_handle,
-                                    newsubsys,
-                                    ego_entry->ego,
-                                    &do_finished,
-                                    handle);
+                                    newsubsys,
+                                    ego_entry->ego,
+                                    &do_finished,
+                                    handle);
   if (NULL == handle->op)
   {
-    handle->emsg = GNUNET_strdup("Setting subsystem failed");
+    handle->emsg = GNUNET_strdup ("Setting subsystem failed");
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
   json_decref (data_js);
   return;
-
 }
 
 /**
@@ -954,15 +945,15 @@ ego_edit_subsystem (struct GNUNET_REST_RequestHandle *con_handle,
  */
 void
 ego_create (struct GNUNET_REST_RequestHandle *con_handle,
-            const char* url,
-            void *cls)
+            const char *url,
+            void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
   struct MHD_Response *resp;
   json_t *data_js;
   json_error_t err;
-  char* egoname;
+  char *egoname;
   int json_unpack_state;
   char term_data[handle->data_size + 1];
 
@@ -974,30 +965,26 @@ ego_create (struct GNUNET_REST_RequestHandle *con_handle,
 
   if (0 >= handle->data_size)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_NO_DATA);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
   term_data[handle->data_size] = '\0';
-  GNUNET_memcpy(term_data, handle->data, handle->data_size);
-  data_js = json_loads (term_data,
-                        JSON_DECODE_ANY,
-                        &err);
+  GNUNET_memcpy (term_data, handle->data, handle->data_size);
+  data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
   if (NULL == data_js)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_NO_DATA);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
   }
   json_unpack_state = 0;
-  json_unpack_state = json_unpack(data_js,
-                                  "{s:s!}",
-                                  GNUNET_REST_IDENTITY_PARAM_NAME,
-                                  &egoname);
+  json_unpack_state =
+    json_unpack (data_js, "{s:s!}", GNUNET_REST_IDENTITY_PARAM_NAME, &egoname);
   if (0 != json_unpack_state)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
@@ -1005,7 +992,7 @@ ego_create (struct GNUNET_REST_RequestHandle *con_handle,
 
   if (NULL == egoname)
   {
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     json_decref (data_js);
     return;
@@ -1013,13 +1000,13 @@ ego_create (struct GNUNET_REST_RequestHandle *con_handle,
   if (0 >= strlen (egoname))
   {
     json_decref (data_js);
-    handle->emsg = GNUNET_strdup(GNUNET_REST_ERROR_DATA_INVALID);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  GNUNET_STRINGS_utf8_tolower(egoname, egoname);
-  for (ego_entry = handle->ego_head;
-  NULL != ego_entry; ego_entry = ego_entry->next)
+  GNUNET_STRINGS_utf8_tolower (egoname, egoname);
+  for (ego_entry = handle->ego_head; NULL != ego_entry;
+       ego_entry = ego_entry->next)
   {
     if (0 == strcasecmp (egoname, ego_entry->identifier))
     {
@@ -1030,11 +1017,13 @@ ego_create (struct GNUNET_REST_RequestHandle *con_handle,
       return;
     }
   }
-  handle->name = GNUNET_strdup(egoname);
+  handle->name = GNUNET_strdup (egoname);
   json_decref (data_js);
   handle->response_code = MHD_HTTP_CREATED;
-  handle->op = GNUNET_IDENTITY_create (handle->identity_handle, handle->name,
-                                       &do_finished_create, handle);
+  handle->op = GNUNET_IDENTITY_create (handle->identity_handle,
+                                       handle->name,
+                                       &do_finished_create,
+                                       handle);
 }
 
 /**
@@ -1046,8 +1035,8 @@ ego_create (struct GNUNET_REST_RequestHandle *con_handle,
  */
 void
 ego_delete_pubkey (struct GNUNET_REST_RequestHandle *con_handle,
-                   const char* url,
-                   void *cls)
+                   const char *url,
+                   void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
@@ -1058,26 +1047,26 @@ ego_delete_pubkey (struct GNUNET_REST_RequestHandle *con_handle,
   if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_PUBKEY);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_PUBKEY);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY)+1];
-  ego_entry = get_egoentry(handle, keystring, NULL);
+  keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) + 1];
+  ego_entry = get_egoentry (handle, keystring, NULL);
 
   if (NULL == ego_entry)
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
 
   handle->response_code = MHD_HTTP_NO_CONTENT;
   handle->op = GNUNET_IDENTITY_delete (handle->identity_handle,
-                                       ego_entry->identifier,
-                                       &do_finished,
-                                       handle);
+                                       ego_entry->identifier,
+                                       &do_finished,
+                                       handle);
 }
 
 
@@ -1090,8 +1079,8 @@ ego_delete_pubkey (struct GNUNET_REST_RequestHandle *con_handle,
  */
 void
 ego_delete_name (struct GNUNET_REST_RequestHandle *con_handle,
-                   const char* url,
-                   void *cls)
+                 const char *url,
+                 void *cls)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
@@ -1102,26 +1091,26 @@ ego_delete_name (struct GNUNET_REST_RequestHandle *con_handle,
   if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_MISSING_NAME);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_NAME);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
-  name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME)+1];
-  ego_entry = get_egoentry(handle, NULL, name);
+  name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
+  ego_entry = get_egoentry (handle, NULL, name);
 
   if (NULL == ego_entry)
   {
     handle->response_code = MHD_HTTP_NOT_FOUND;
-    handle->emsg = GNUNET_strdup(GNUNET_REST_IDENTITY_NOT_FOUND);
+    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
     GNUNET_SCHEDULER_add_now (&do_error, handle);
     return;
   }
 
   handle->response_code = MHD_HTTP_NO_CONTENT;
   handle->op = GNUNET_IDENTITY_delete (handle->identity_handle,
-                                       ego_entry->identifier,
-                                       &do_finished,
-                                       handle);
+                                       ego_entry->identifier,
+                                       &do_finished,
+                                       handle);
 }
 
 
@@ -1133,8 +1122,9 @@ ego_delete_name (struct GNUNET_REST_RequestHandle *con_handle,
  * @param cls the RequestHandle
  */
 static void
-options_cont (struct GNUNET_REST_RequestHandle *con_handle, const char* url,
-              void *cls)
+options_cont (struct GNUNET_REST_RequestHandle *con_handle,
+              const char *url,
+              void *cls)
 {
   struct MHD_Response *resp;
   struct RequestHandle *handle = cls;
@@ -1156,24 +1146,32 @@ static void
 init_cont (struct RequestHandle *handle)
 {
   struct GNUNET_REST_RequestHandlerError err;
-  static const struct GNUNET_REST_RequestHandler handlers[] = {
-      { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_ALL, &ego_get_all },
-      { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_PUBKEY, &ego_get_pubkey },
-      { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_get_name },
-      { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM, &ego_get_subsystem },
-      { MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_IDENTITY_PUBKEY, &ego_edit_pubkey },
-      { MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_edit_name },
-      { MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM, &ego_edit_subsystem },
-      { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY, &ego_create },
-      { MHD_HTTP_METHOD_DELETE, GNUNET_REST_API_NS_IDENTITY_PUBKEY, &ego_delete_pubkey },
-      { MHD_HTTP_METHOD_DELETE, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_delete_name },
-      { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_IDENTITY, &options_cont },
-      GNUNET_REST_HANDLER_END
-  };
-
-  if (GNUNET_NO
-      == GNUNET_REST_handle_request (handle->rest_handle, handlers, &err,
-                                     handle))
+  static const struct GNUNET_REST_RequestHandler handlers[] =
+    {{MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_ALL, &ego_get_all},
+     {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_PUBKEY, &ego_get_pubkey},
+     {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_get_name},
+     {MHD_HTTP_METHOD_GET,
+      GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM,
+      &ego_get_subsystem},
+     {MHD_HTTP_METHOD_PUT,
+      GNUNET_REST_API_NS_IDENTITY_PUBKEY,
+      &ego_edit_pubkey},
+     {MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_edit_name},
+     {MHD_HTTP_METHOD_PUT,
+      GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM,
+      &ego_edit_subsystem},
+     {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY, &ego_create},
+     {MHD_HTTP_METHOD_DELETE,
+      GNUNET_REST_API_NS_IDENTITY_PUBKEY,
+      &ego_delete_pubkey},
+     {MHD_HTTP_METHOD_DELETE,
+      GNUNET_REST_API_NS_IDENTITY_NAME,
+      &ego_delete_name},
+     {MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_IDENTITY, &options_cont},
+     GNUNET_REST_HANDLER_END};
+
+  if (GNUNET_NO ==
+      GNUNET_REST_handle_request (handle->rest_handle, handlers, &err, handle))
   {
     handle->response_code = err.error_code;
     GNUNET_SCHEDULER_add_now (&do_error, handle);
@@ -1214,8 +1212,10 @@ init_cont (struct RequestHandle *handle)
  *                   must thus no longer be used
  */
 static void
-init_egos (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx,
-           const char *identifier)
+init_egos (void *cls,
+           struct GNUNET_IDENTITY_Ego *ego,
+           void **ctx,
+           const char *identifier)
 {
   struct RequestHandle *handle = cls;
   struct EgoEntry *ego_entry;
@@ -1229,13 +1229,14 @@ init_egos (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx,
   }
   if (ID_REST_STATE_INIT == handle->state)
   {
-    ego_entry = GNUNET_new(struct EgoEntry);
+    ego_entry = GNUNET_new (struct EgoEntry);
     GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
     ego_entry->keystring = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
     ego_entry->ego = ego;
     GNUNET_asprintf (&ego_entry->identifier, "%s", identifier);
-    GNUNET_CONTAINER_DLL_insert_tail(handle->ego_head, handle->ego_tail,
-                                     ego_entry);
+    GNUNET_CONTAINER_DLL_insert_tail (handle->ego_head,
+                                      handle->ego_tail,
+                                      ego_entry);
   }
 }
 
@@ -1252,9 +1253,10 @@ init_egos (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx,
  */
 static void
 rest_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
-                      GNUNET_REST_ResultProcessor proc, void *proc_cls)
+                      GNUNET_REST_ResultProcessor proc,
+                      void *proc_cls)
 {
-  struct RequestHandle *handle = GNUNET_new(struct RequestHandle);
+  struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
 
   handle->response_code = 0;
   handle->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
@@ -1264,17 +1266,17 @@ rest_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
   handle->data = rest_handle->data;
   handle->data_size = rest_handle->data_size;
 
-  handle->url = GNUNET_strdup(rest_handle->url);
+  handle->url = GNUNET_strdup (rest_handle->url);
   if (handle->url[strlen (handle->url) - 1] == '/')
     handle->url[strlen (handle->url) - 1] = '\0';
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
 
   handle->identity_handle = GNUNET_IDENTITY_connect (cfg, &init_egos, handle);
 
-  handle->timeout_task = GNUNET_SCHEDULER_add_delayed (handle->timeout,
-                                                       &do_error, handle);
+  handle->timeout_task =
+    GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_error, handle);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
 }
 
 /**
@@ -1292,20 +1294,21 @@ libgnunet_plugin_rest_identity_init (void *cls)
   cfg = cls;
   if (NULL != plugin.cfg)
     return NULL; /* can only initialize once! */
-  memset (&plugin, 0, sizeof(struct Plugin));
+  memset (&plugin, 0, sizeof (struct Plugin));
   plugin.cfg = cfg;
-  api = GNUNET_new(struct GNUNET_REST_Plugin);
+  api = GNUNET_new (struct GNUNET_REST_Plugin);
   api->cls = &plugin;
   api->name = GNUNET_REST_API_NS_IDENTITY;
   api->process_request = &rest_process_request;
-  GNUNET_asprintf (&allow_methods, "%s, %s, %s, %s, %s",
-                   MHD_HTTP_METHOD_GET,
-                   MHD_HTTP_METHOD_POST,
-                   MHD_HTTP_METHOD_PUT,
-                   MHD_HTTP_METHOD_DELETE,
-                   MHD_HTTP_METHOD_OPTIONS);
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, _("Identity REST API initialized\n"));
+  GNUNET_asprintf (&allow_methods,
+                   "%s, %s, %s, %s, %s",
+                   MHD_HTTP_METHOD_GET,
+                   MHD_HTTP_METHOD_POST,
+                   MHD_HTTP_METHOD_PUT,
+                   MHD_HTTP_METHOD_DELETE,
+                   MHD_HTTP_METHOD_OPTIONS);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Identity REST API initialized\n"));
   return api;
 }
 
@@ -1322,9 +1325,9 @@ libgnunet_plugin_rest_identity_done (void *cls)
   struct Plugin *plugin = api->cls;
   plugin->cfg = NULL;
 
-  GNUNET_free_non_null(allow_methods);
-  GNUNET_free(api);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Identity REST plugin is finished\n");
+  GNUNET_free_non_null (allow_methods);
+  GNUNET_free (api);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Identity REST plugin is finished\n");
   return NULL;
 }
 
diff --git a/src/rest/gnunet-rest-server.c b/src/rest/gnunet-rest-server.c
index 6b89d19fe..b0b25f308 100644
--- a/src/rest/gnunet-rest-server.c
+++ b/src/rest/gnunet-rest-server.c
@@ -199,6 +199,7 @@ plugin_callback (void *cls, struct MHD_Response *resp, int status)
   struct MhdConnectionHandle *handle = cls;
   handle->status = status;
   handle->response = resp;
+  MHD_resume_connection (handle->con);
   run_mhd_now ();
 }
 
@@ -433,11 +434,14 @@ create_response (void *cls,
     }
     MHD_destroy_post_processor (con_handle->pp);
 
+    //Suspend connection until plugin is done
+    MHD_suspend_connection (con_handle->con);
     con_handle->state = GN_REST_STATE_PROCESSING;
     con_handle->plugin->process_request (rest_conndata_handle,
                                          &plugin_callback,
                                          con_handle);
     *upload_data_size = 0;
+    return MHD_YES;
   }
   if (NULL != con_handle->response)
   {
@@ -979,7 +983,7 @@ run (void *cls,
     return;
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service listens on port %llu\n", port);
-  httpd = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_NO_LISTEN_SOCKET,
+  httpd = MHD_start_daemon (MHD_USE_DEBUG | MHD_USE_NO_LISTEN_SOCKET | MHD_ALLOW_SUSPEND_RESUME,
                             0,
                             NULL,
                             NULL,