[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] [gnunet] branch master updated: enable suspend resume for R
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] [gnunet] branch master updated: enable suspend resume for REST |
|
Date: |
Mon, 15 Jul 2019 14:20:48 +0200 |
This is an automated email from the git hooks/post-receive script.
martin-schanzenbach pushed a commit to branch master
in repository gnunet.
The following commit(s) were added to refs/heads/master by this push:
new febfb2408 enable suspend resume for REST
febfb2408 is described below
commit febfb2408227b432e0455f62590cda628323437a
Author: Schanzenbach, Martin <address@hidden>
AuthorDate: Mon Jul 15 14:19:38 2019 +0200
enable suspend resume for REST
---
src/identity/plugin_rest_identity.c | 455 ++++++++++++++++++------------------
src/rest/gnunet-rest-server.c | 6 +-
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,
--
To stop receiving notification emails like this one, please contact
address@hidden.
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] [gnunet] branch master updated: enable suspend resume for REST,
gnunet <=