[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] [gnunet] branch master updated: RECLAIM/REST: add attribute
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] [gnunet] branch master updated: RECLAIM/REST: add attribute ID to JSON |
|
Date: |
Sun, 14 Apr 2019 15:44:18 +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 1eea290a7 RECLAIM/REST: add attribute ID to JSON
1eea290a7 is described below
commit 1eea290a7aaa845db727773bc7e9f2a0fdc5bebd
Author: Schanzenbach, Martin <address@hidden>
AuthorDate: Sun Apr 14 15:44:08 2019 +0200
RECLAIM/REST: add attribute ID to JSON
---
src/reclaim/json_reclaim.c | 166 ++++++-------
src/reclaim/plugin_rest_reclaim.c | 477 ++++++++++++++------------------------
2 files changed, 241 insertions(+), 402 deletions(-)
diff --git a/src/reclaim/json_reclaim.c b/src/reclaim/json_reclaim.c
index 0fe9150d9..79110490a 100644
--- a/src/reclaim/json_reclaim.c
+++ b/src/reclaim/json_reclaim.c
@@ -24,10 +24,13 @@
* @author Martin Schanzenbach
*/
#include "platform.h"
+
#include "gnunet_util_lib.h"
+
#include "gnunet_json_lib.h"
-#include "gnunet_reclaim_service.h"
#include "gnunet_reclaim_attribute_lib.h"
+#include "gnunet_reclaim_service.h"
+
/**
* Parse given JSON object to a claim
@@ -38,54 +41,48 @@
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
-parse_attr (void *cls,
- json_t *root,
- struct GNUNET_JSON_Specification *spec)
+parse_attr (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr;
- const char* name_str;
- const char* val_str;
- const char* type_str;
+ const char *name_str;
+ const char *val_str;
+ const char *type_str;
+ const char *id_str;
char *data;
int unpack_state;
uint32_t type;
size_t data_size;
- GNUNET_assert(NULL != root);
+ GNUNET_assert (NULL != root);
- if(!json_is_object(root))
- {
+ if (!json_is_object (root)) {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Error json is not array nor object!\n");
return GNUNET_SYSERR;
}
- //interpret single attribute
- unpack_state = json_unpack(root,
- "{s:s, s:s, s:s!}",
- "name", &name_str,
- "type", &type_str,
- "value", &val_str);
- if (0 != unpack_state)
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Error json object has a wrong format!\n");
+ // interpret single attribute
+ unpack_state =
+ json_unpack (root, "{s:s, s:s, s:s, s:s!}", "name", &name_str, "id",
+ &id_str, "type", &type_str, "value", &val_str);
+ if (0 != unpack_state) {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Error json object has a wrong format!\n");
return GNUNET_SYSERR;
}
type = GNUNET_RECLAIM_ATTRIBUTE_typename_to_number (type_str);
- if (GNUNET_SYSERR == (GNUNET_RECLAIM_ATTRIBUTE_string_to_value (type,
- val_str,
-
(void**)&data,
- &data_size)))
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Attribute value invalid!\n");
+ if (GNUNET_SYSERR == (GNUNET_RECLAIM_ATTRIBUTE_string_to_value (
+ type, val_str, (void **)&data, &data_size))) {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Attribute value invalid!\n");
return GNUNET_SYSERR;
}
- attr = GNUNET_RECLAIM_ATTRIBUTE_claim_new (name_str,
- type,
- data,
- data_size);
- *(struct GNUNET_RECLAIM_ATTRIBUTE_Claim **) spec->ptr = attr;
+ attr = GNUNET_RECLAIM_ATTRIBUTE_claim_new (name_str, type, data, data_size);
+ if (0 == strlen (id_str))
+ attr->id = 0;
+ else
+ GNUNET_STRINGS_string_to_data (id_str, strlen (id_str), &attr->id,
+ sizeof (uint64_t));
+
+ *(struct GNUNET_RECLAIM_ATTRIBUTE_Claim **)spec->ptr = attr;
return GNUNET_OK;
}
@@ -99,10 +96,9 @@ static void
clean_attr (void *cls, struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_RECLAIM_ATTRIBUTE_Claim **attr;
- attr = (struct GNUNET_RECLAIM_ATTRIBUTE_Claim **) spec->ptr;
- if (NULL != *attr)
- {
- GNUNET_free(*attr);
+ attr = (struct GNUNET_RECLAIM_ATTRIBUTE_Claim **)spec->ptr;
+ if (NULL != *attr) {
+ GNUNET_free (*attr);
*attr = NULL;
}
}
@@ -116,15 +112,13 @@ clean_attr (void *cls, struct GNUNET_JSON_Specification
*spec)
struct GNUNET_JSON_Specification
GNUNET_RECLAIM_JSON_spec_claim (struct GNUNET_RECLAIM_ATTRIBUTE_Claim **attr)
{
- struct GNUNET_JSON_Specification ret = {
- .parser = &parse_attr,
- .cleaner = &clean_attr,
- .cls = NULL,
- .field = NULL,
- .ptr = attr,
- .ptr_size = 0,
- .size_ptr = NULL
- };
+ struct GNUNET_JSON_Specification ret = {.parser = &parse_attr,
+ .cleaner = &clean_attr,
+ .cls = NULL,
+ .field = NULL,
+ .ptr = attr,
+ .ptr_size = 0,
+ .size_ptr = NULL};
*attr = NULL;
return ret;
}
@@ -137,67 +131,54 @@ GNUNET_RECLAIM_JSON_spec_claim (struct
GNUNET_RECLAIM_ATTRIBUTE_Claim **attr)
* @return #GNUNET_OK upon successful parsing; #GNUNET_SYSERR upon error
*/
static int
-parse_ticket (void *cls,
- json_t *root,
- struct GNUNET_JSON_Specification *spec)
+parse_ticket (void *cls, json_t *root, struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_RECLAIM_Ticket *ticket;
- const char* rnd_str;
- const char* aud_str;
- const char* id_str;
+ const char *rnd_str;
+ const char *aud_str;
+ const char *id_str;
int unpack_state;
- GNUNET_assert(NULL != root);
+ GNUNET_assert (NULL != root);
- if(!json_is_object(root))
- {
+ if (!json_is_object (root)) {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Error json is not array nor object!\n");
return GNUNET_SYSERR;
}
- //interpret single ticket
- unpack_state = json_unpack(root,
- "{s:s, s:s, s:s!}",
- "rnd", &rnd_str,
- "audience", &aud_str,
- "identity", &id_str);
- if (0 != unpack_state)
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Error json object has a wrong format!\n");
+ // interpret single ticket
+ unpack_state = json_unpack (root, "{s:s, s:s, s:s!}", "rnd", &rnd_str,
+ "audience", &aud_str, "identity", &id_str);
+ if (0 != unpack_state) {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Error json object has a wrong format!\n");
return GNUNET_SYSERR;
}
ticket = GNUNET_new (struct GNUNET_RECLAIM_Ticket);
- if (GNUNET_OK != GNUNET_STRINGS_string_to_data (rnd_str,
- strlen (rnd_str),
+ if (GNUNET_OK != GNUNET_STRINGS_string_to_data (rnd_str, strlen (rnd_str),
&ticket->rnd,
- sizeof (uint64_t)))
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,"Rnd invalid\n");
- GNUNET_free(ticket);
+ sizeof (uint64_t))) {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Rnd invalid\n");
+ GNUNET_free (ticket);
return GNUNET_SYSERR;
}
- GNUNET_STRINGS_string_to_data (id_str,
- strlen (id_str),
- &ticket->identity,
+ GNUNET_STRINGS_string_to_data (id_str, strlen (id_str), &ticket->identity,
sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,"Identity invalid\n");
- GNUNET_free(ticket);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Identity invalid\n");
+ GNUNET_free (ticket);
return GNUNET_SYSERR;
}
- GNUNET_STRINGS_string_to_data (aud_str,
- strlen (aud_str),
- &ticket->audience,
+ GNUNET_STRINGS_string_to_data (aud_str, strlen (aud_str), &ticket->audience,
sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,"Audience invalid\n");
- GNUNET_free(ticket);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Audience invalid\n");
+ GNUNET_free (ticket);
return GNUNET_SYSERR;
}
- *(struct GNUNET_RECLAIM_Ticket **) spec->ptr = ticket;
+ *(struct GNUNET_RECLAIM_Ticket **)spec->ptr = ticket;
return GNUNET_OK;
}
@@ -211,10 +192,9 @@ static void
clean_ticket (void *cls, struct GNUNET_JSON_Specification *spec)
{
struct GNUNET_RECLAIM_Ticket **ticket;
- ticket = (struct GNUNET_RECLAIM_Ticket **) spec->ptr;
- if (NULL != *ticket)
- {
- GNUNET_free(*ticket);
+ ticket = (struct GNUNET_RECLAIM_Ticket **)spec->ptr;
+ if (NULL != *ticket) {
+ GNUNET_free (*ticket);
*ticket = NULL;
}
}
@@ -228,15 +208,13 @@ clean_ticket (void *cls, struct GNUNET_JSON_Specification
*spec)
struct GNUNET_JSON_Specification
GNUNET_RECLAIM_JSON_spec_ticket (struct GNUNET_RECLAIM_Ticket **ticket)
{
- struct GNUNET_JSON_Specification ret = {
- .parser = &parse_ticket,
- .cleaner = &clean_ticket,
- .cls = NULL,
- .field = NULL,
- .ptr = ticket,
- .ptr_size = 0,
- .size_ptr = NULL
- };
+ struct GNUNET_JSON_Specification ret = {.parser = &parse_ticket,
+ .cleaner = &clean_ticket,
+ .cls = NULL,
+ .field = NULL,
+ .ptr = ticket,
+ .ptr_size = 0,
+ .size_ptr = NULL};
*ticket = NULL;
return ret;
}
diff --git a/src/reclaim/plugin_rest_reclaim.c
b/src/reclaim/plugin_rest_reclaim.c
index b36ed2bb6..ae46211d5 100644
--- a/src/reclaim/plugin_rest_reclaim.c
+++ b/src/reclaim/plugin_rest_reclaim.c
@@ -11,7 +11,7 @@
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Affero General Public License for more details.
-
+
You should have received a copy of the GNU Affero General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
@@ -24,22 +24,22 @@
* @brief GNUnet reclaim REST plugin
*
*/
-
#include "platform.h"
-#include "gnunet_rest_plugin.h"
-#include "gnunet_identity_service.h"
+
+#include "microhttpd.h"
+#include <inttypes.h>
+#include <jansson.h>
+
#include "gnunet_gns_service.h"
#include "gnunet_gnsrecord_lib.h"
+#include "gnunet_identity_service.h"
#include "gnunet_namestore_service.h"
-#include "gnunet_rest_lib.h"
-#include "microhttpd.h"
-#include <jansson.h>
-#include <inttypes.h>
-#include "gnunet_signatures.h"
#include "gnunet_reclaim_attribute_lib.h"
#include "gnunet_reclaim_service.h"
+#include "gnunet_rest_lib.h"
+#include "gnunet_rest_plugin.h"
+#include "gnunet_signatures.h"
#include "json_reclaim.h"
-
/**
* REST root namespace
*/
@@ -83,7 +83,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
@@ -246,7 +246,6 @@ struct RequestHandle
* Response object
*/
json_t *resp_object;
-
};
/**
@@ -260,8 +259,7 @@ cleanup_handle (struct RequestHandle *handle)
struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *claim_tmp;
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->resp_object)
json_decref (handle->resp_object);
if (NULL != handle->timeout_task)
@@ -280,30 +278,24 @@ cleanup_handle (struct RequestHandle *handle)
GNUNET_free (handle->emsg);
if (NULL != handle->namestore_handle)
GNUNET_NAMESTORE_disconnect (handle->namestore_handle);
- if ( NULL != handle->attr_list )
- {
- for (claim_entry = handle->attr_list->list_head;
- NULL != claim_entry;)
- {
+ if (NULL != handle->attr_list) {
+ for (claim_entry = handle->attr_list->list_head; NULL != claim_entry;) {
claim_tmp = claim_entry;
claim_entry = claim_entry->next;
- GNUNET_free(claim_tmp->claim);
- GNUNET_free(claim_tmp);
+ GNUNET_free (claim_tmp->claim);
+ GNUNET_free (claim_tmp);
}
GNUNET_free (handle->attr_list);
}
- 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);
}
- if (NULL != handle->attr_it)
- {
- GNUNET_free(handle->attr_it);
+ if (NULL != handle->attr_it) {
+ GNUNET_free (handle->attr_it);
}
GNUNET_free (handle);
}
@@ -327,10 +319,8 @@ do_error (void *cls)
struct MHD_Response *resp;
char *json_error;
- GNUNET_asprintf (&json_error, "{ \"error\" : \"%s\" }",
- handle->emsg);
- if ( 0 == handle->response_code )
- {
+ GNUNET_asprintf (&json_error, "{ \"error\" : \"%s\" }", handle->emsg);
+ if (0 == handle->response_code) {
handle->response_code = MHD_HTTP_BAD_REQUEST;
}
resp = GNUNET_REST_create_response (json_error);
@@ -365,16 +355,13 @@ collect_error_cb (void *cls)
}
static void
-finished_cont (void *cls,
- int32_t success,
- const char *emsg)
+finished_cont (void *cls, int32_t success, const char *emsg)
{
struct RequestHandle *handle = cls;
struct MHD_Response *resp;
resp = GNUNET_REST_create_response (emsg);
- if (GNUNET_OK != success)
- {
+ if (GNUNET_OK != success) {
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
@@ -391,7 +378,7 @@ finished_cont (void *cls,
static void
return_response (void *cls)
{
- char* result_str;
+ char *result_str;
struct RequestHandle *handle = cls;
struct MHD_Response *resp;
@@ -407,7 +394,7 @@ static void
collect_finished_cb (void *cls)
{
struct RequestHandle *handle = cls;
- //Done
+ // Done
handle->attr_it = NULL;
handle->ticket_it = NULL;
GNUNET_SCHEDULER_add_now (&return_response, handle);
@@ -419,48 +406,37 @@ collect_finished_cb (void *cls)
*
*/
static void
-ticket_collect (void *cls,
- const struct GNUNET_RECLAIM_Ticket *ticket)
+ticket_collect (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
{
json_t *json_resource;
struct RequestHandle *handle = cls;
json_t *value;
- char* tmp;
+ char *tmp;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding ticket\n");
- tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd,
- sizeof (uint64_t));
+ tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd, sizeof (uint64_t));
json_resource = json_object ();
GNUNET_free (tmp);
- json_array_append (handle->resp_object,
- json_resource);
+ json_array_append (handle->resp_object, json_resource);
- tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->identity,
- sizeof (struct
GNUNET_CRYPTO_EcdsaPublicKey));
+ tmp = GNUNET_STRINGS_data_to_string_alloc (
+ &ticket->identity, sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
value = json_string (tmp);
- json_object_set_new (json_resource,
- "issuer",
- value);
+ json_object_set_new (json_resource, "issuer", value);
GNUNET_free (tmp);
- tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->audience,
- sizeof (struct
GNUNET_CRYPTO_EcdsaPublicKey));
+ tmp = GNUNET_STRINGS_data_to_string_alloc (
+ &ticket->audience, sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey));
value = json_string (tmp);
- json_object_set_new (json_resource,
- "audience",
- value);
+ json_object_set_new (json_resource, "audience", value);
GNUNET_free (tmp);
- tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd,
- sizeof (uint64_t));
+ tmp = GNUNET_STRINGS_data_to_string_alloc (&ticket->rnd, sizeof (uint64_t));
value = json_string (tmp);
- json_object_set_new (json_resource,
- "rnd",
- value);
+ json_object_set_new (json_resource, "rnd", value);
GNUNET_free (tmp);
GNUNET_RECLAIM_ticket_iteration_next (handle->ticket_it);
}
-
/**
* List tickets for identity request
*
@@ -470,8 +446,7 @@ ticket_collect (void *cls,
*/
static void
list_tickets_cont (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url, void *cls)
{
const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
struct RequestHandle *handle = cls;
@@ -480,172 +455,138 @@ list_tickets_cont (struct GNUNET_REST_RequestHandle
*con_handle,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Getting tickets for %s.\n",
handle->url);
- if ( strlen (GNUNET_REST_API_NS_IDENTITY_TICKETS) >=
- strlen (handle->url))
- {
+ if (strlen (GNUNET_REST_API_NS_IDENTITY_TICKETS) >= strlen (handle->url)) {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
identity = handle->url + strlen (GNUNET_REST_API_NS_IDENTITY_TICKETS) + 1;
- for (ego_entry = handle->ego_head;
- NULL != ego_entry;
+ for (ego_entry = handle->ego_head; NULL != ego_entry;
ego_entry = ego_entry->next)
if (0 == strcmp (identity, ego_entry->identifier))
break;
handle->resp_object = json_array ();
- if (NULL == ego_entry)
- {
- //Done
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n",
- identity);
+ if (NULL == ego_entry) {
+ // Done
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
GNUNET_SCHEDULER_add_now (&return_response, handle);
return;
}
priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
handle->idp = GNUNET_RECLAIM_connect (cfg);
- handle->ticket_it = GNUNET_RECLAIM_ticket_iteration_start (handle->idp,
- priv_key,
- &collect_error_cb,
- handle,
- &ticket_collect,
- handle,
-
&collect_finished_cb,
- handle);
+ handle->ticket_it = GNUNET_RECLAIM_ticket_iteration_start (
+ handle->idp, priv_key, &collect_error_cb, handle, &ticket_collect,
handle,
+ &collect_finished_cb, handle);
}
static void
add_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url, void *cls)
{
const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
- const char* identity;
+ const char *identity;
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attribute;
struct GNUNET_TIME_Relative exp;
- char term_data[handle->rest_handle->data_size+1];
+ char term_data[handle->rest_handle->data_size + 1];
json_t *data_json;
json_error_t err;
struct GNUNET_JSON_Specification attrspec[] = {
- GNUNET_RECLAIM_JSON_spec_claim (&attribute),
- GNUNET_JSON_spec_end()
- };
+ GNUNET_RECLAIM_JSON_spec_claim (&attribute), GNUNET_JSON_spec_end ()};
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding an attribute for %s.\n",
handle->url);
- if ( strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >=
- strlen (handle->url))
- {
+ if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >= strlen (handle->url)) {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
identity = handle->url + strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) + 1;
- for (ego_entry = handle->ego_head;
- NULL != ego_entry;
+ for (ego_entry = handle->ego_head; NULL != ego_entry;
ego_entry = ego_entry->next)
if (0 == strcmp (identity, ego_entry->identifier))
break;
- if (NULL == ego_entry)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Identity unknown (%s)\n", identity);
+ if (NULL == ego_entry) {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Identity unknown (%s)\n", identity);
return;
}
identity_priv = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
- if (0 >= handle->rest_handle->data_size)
- {
+ if (0 >= handle->rest_handle->data_size) {
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
term_data[handle->rest_handle->data_size] = '\0';
- GNUNET_memcpy (term_data,
- handle->rest_handle->data,
+ GNUNET_memcpy (term_data, handle->rest_handle->data,
handle->rest_handle->data_size);
- data_json = json_loads (term_data,
- JSON_DECODE_ANY,
- &err);
+ data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
GNUNET_assert (GNUNET_OK ==
- GNUNET_JSON_parse (data_json, attrspec,
- NULL, NULL));
+ GNUNET_JSON_parse (data_json, attrspec, NULL, NULL));
json_decref (data_json);
- if (NULL == attribute)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Unable to parse attribute from %s\n",
+ if (NULL == attribute) {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unable to parse attribute from %s\n",
term_data);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
+ /**
+ * New ID for attribute
+ */
+ attribute->id =
+ GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_STRONG, UINT64_MAX);
handle->idp = GNUNET_RECLAIM_connect (cfg);
exp = GNUNET_TIME_UNIT_HOURS;
- handle->idp_op = GNUNET_RECLAIM_attribute_store (handle->idp,
- identity_priv,
- attribute,
- &exp,
- &finished_cont,
- handle);
+ handle->idp_op = GNUNET_RECLAIM_attribute_store (
+ handle->idp, identity_priv, attribute, &exp, &finished_cont, handle);
GNUNET_JSON_parse_free (attrspec);
}
-
/**
* Collect all attributes for an ego
*
*/
static void
-attr_collect (void *cls,
- const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
+attr_collect (void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
{
struct RequestHandle *handle = cls;
json_t *attr_obj;
- const char* type;
- char* tmp_value;
+ const char *type;
+ char *tmp_value;
+ char *id_str;
- if ((NULL == attr->name) || (NULL == attr->data))
- {
+ if ((NULL == attr->name) || (NULL == attr->data)) {
GNUNET_RECLAIM_get_attributes_next (handle->attr_it);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n",
- attr->name);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n", attr->name);
- tmp_value = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type,
- attr->data,
+ tmp_value = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type, attr->data,
attr->data_size);
attr_obj = json_object ();
- json_object_set_new (attr_obj,
- "value",
- json_string (tmp_value));
- json_object_set_new (attr_obj,
- "name",
- json_string (attr->name));
+ json_object_set_new (attr_obj, "value", json_string (tmp_value));
+ json_object_set_new (attr_obj, "name", json_string (attr->name));
type = GNUNET_RECLAIM_ATTRIBUTE_number_to_typename (attr->type);
- json_object_set_new (attr_obj,
- "type",
- json_string (type));
- json_array_append (handle->resp_object,
- attr_obj);
+ json_object_set_new (attr_obj, "type", json_string (type));
+ id_str = GNUNET_STRINGS_data_to_string_alloc (&attr->id, sizeof (uint64_t));
+ json_object_set_new (attr_obj, "id", json_string (id_str));
+ json_array_append (handle->resp_object, attr_obj);
json_decref (attr_obj);
- GNUNET_free(tmp_value);
+ GNUNET_free (tmp_value);
GNUNET_RECLAIM_get_attributes_next (handle->attr_it);
}
-
/**
* List attributes for identity request
*
@@ -655,8 +596,7 @@ attr_collect (void *cls,
*/
static void
list_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url, void *cls)
{
const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
struct RequestHandle *handle = cls;
@@ -665,91 +605,68 @@ list_attribute_cont (struct GNUNET_REST_RequestHandle
*con_handle,
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Getting attributes for %s.\n",
handle->url);
- if ( strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >=
- strlen (handle->url))
- {
+ if (strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >= strlen (handle->url)) {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
identity = handle->url + strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) + 1;
- for (ego_entry = handle->ego_head;
- NULL != ego_entry;
+ for (ego_entry = handle->ego_head; NULL != ego_entry;
ego_entry = ego_entry->next)
if (0 == strcmp (identity, ego_entry->identifier))
break;
handle->resp_object = json_array ();
- if (NULL == ego_entry)
- {
- //Done
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n",
- identity);
+ if (NULL == ego_entry) {
+ // Done
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
GNUNET_SCHEDULER_add_now (&return_response, handle);
return;
}
priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
handle->idp = GNUNET_RECLAIM_connect (cfg);
- handle->attr_it = GNUNET_RECLAIM_get_attributes_start (handle->idp,
- priv_key,
- &collect_error_cb,
- handle,
- &attr_collect,
- handle,
- &collect_finished_cb,
- handle);
+ handle->attr_it = GNUNET_RECLAIM_get_attributes_start (
+ handle->idp, priv_key, &collect_error_cb, handle, &attr_collect, handle,
+ &collect_finished_cb, handle);
}
static void
revoke_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url, void *cls)
{
const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
struct GNUNET_RECLAIM_Ticket *ticket;
struct GNUNET_CRYPTO_EcdsaPublicKey tmp_pk;
- char term_data[handle->rest_handle->data_size+1];
+ char term_data[handle->rest_handle->data_size + 1];
json_t *data_json;
json_error_t err;
struct GNUNET_JSON_Specification tktspec[] = {
- GNUNET_RECLAIM_JSON_spec_ticket (&ticket),
- GNUNET_JSON_spec_end()
- };
+ GNUNET_RECLAIM_JSON_spec_ticket (&ticket), GNUNET_JSON_spec_end ()};
- if (0 >= handle->rest_handle->data_size)
- {
+ if (0 >= handle->rest_handle->data_size) {
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
term_data[handle->rest_handle->data_size] = '\0';
- GNUNET_memcpy (term_data,
- handle->rest_handle->data,
+ GNUNET_memcpy (term_data, handle->rest_handle->data,
handle->rest_handle->data_size);
- data_json = json_loads (term_data,
- JSON_DECODE_ANY,
- &err);
+ data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
GNUNET_assert (GNUNET_OK ==
- GNUNET_JSON_parse (data_json, tktspec,
- NULL, NULL));
+ GNUNET_JSON_parse (data_json, tktspec, NULL, NULL));
json_decref (data_json);
- if (NULL == ticket)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Unable to parse ticket from %s\n",
+ if (NULL == ticket) {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unable to parse ticket from %s\n",
term_data);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- if (GNUNET_OK != GNUNET_JSON_parse (data_json,
- tktspec,
- NULL, NULL))
- {
+ if (GNUNET_OK != GNUNET_JSON_parse (data_json, tktspec, NULL, NULL)) {
handle->emsg = GNUNET_strdup ("Not a ticket!\n");
GNUNET_SCHEDULER_add_now (&do_error, handle);
GNUNET_JSON_parse_free (tktspec);
@@ -757,149 +674,111 @@ revoke_ticket_cont (struct GNUNET_REST_RequestHandle
*con_handle,
return;
}
- for (ego_entry = handle->ego_head;
- NULL != ego_entry;
- ego_entry = ego_entry->next)
- {
- GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego,
- &tmp_pk);
- if (0 == memcmp (&ticket->identity,
- &tmp_pk,
+ for (ego_entry = handle->ego_head; NULL != ego_entry;
+ ego_entry = ego_entry->next) {
+ GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego, &tmp_pk);
+ if (0 == memcmp (&ticket->identity, &tmp_pk,
sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
break;
}
- if (NULL == ego_entry)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Identity unknown\n");
+ if (NULL == ego_entry) {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Identity unknown\n");
GNUNET_JSON_parse_free (tktspec);
return;
}
identity_priv = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
handle->idp = GNUNET_RECLAIM_connect (cfg);
- handle->idp_op = GNUNET_RECLAIM_ticket_revoke (handle->idp,
- identity_priv,
- ticket,
- &finished_cont,
- handle);
+ handle->idp_op = GNUNET_RECLAIM_ticket_revoke (
+ handle->idp, identity_priv, ticket, &finished_cont, handle);
GNUNET_JSON_parse_free (tktspec);
}
static void
-consume_cont (void *cls,
- const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
+consume_cont (void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity,
const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
{
struct RequestHandle *handle = cls;
char *val_str;
json_t *value;
- if (NULL == identity)
- {
+ if (NULL == identity) {
GNUNET_SCHEDULER_add_now (&return_response, handle);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n",
- attr->name);
- val_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type,
- attr->data,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n", attr->name);
+ val_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type, attr->data,
attr->data_size);
- if (NULL == val_str)
- {
+ if (NULL == val_str) {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to parse value for: %s\n",
attr->name);
return;
}
- value = json_string(val_str);
- json_object_set_new (handle->resp_object,
- attr->name,
- value);
+ value = json_string (val_str);
+ json_object_set_new (handle->resp_object, attr->name, value);
json_decref (value);
GNUNET_free (val_str);
}
static void
consume_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
- void *cls)
+ const char *url, void *cls)
{
const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
struct GNUNET_RECLAIM_Ticket *ticket;
struct GNUNET_CRYPTO_EcdsaPublicKey tmp_pk;
- char term_data[handle->rest_handle->data_size+1];
+ char term_data[handle->rest_handle->data_size + 1];
json_t *data_json;
json_error_t err;
struct GNUNET_JSON_Specification tktspec[] = {
- GNUNET_RECLAIM_JSON_spec_ticket (&ticket),
- GNUNET_JSON_spec_end ()
- };
+ GNUNET_RECLAIM_JSON_spec_ticket (&ticket), GNUNET_JSON_spec_end ()};
- if (0 >= handle->rest_handle->data_size)
- {
+ if (0 >= handle->rest_handle->data_size) {
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
term_data[handle->rest_handle->data_size] = '\0';
- GNUNET_memcpy (term_data,
- handle->rest_handle->data,
+ GNUNET_memcpy (term_data, handle->rest_handle->data,
handle->rest_handle->data_size);
- data_json = json_loads (term_data,
- JSON_DECODE_ANY,
- &err);
- if (NULL == data_json)
- {
+ data_json = json_loads (term_data, JSON_DECODE_ANY, &err);
+ if (NULL == data_json) {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Unable to parse JSON Object from %s\n",
- term_data);
+ "Unable to parse JSON Object from %s\n", term_data);
GNUNET_SCHEDULER_add_now (&do_error, handle);
return;
}
- if (GNUNET_OK != GNUNET_JSON_parse (data_json,
- tktspec,
- NULL, NULL))
- {
+ if (GNUNET_OK != GNUNET_JSON_parse (data_json, tktspec, NULL, NULL)) {
handle->emsg = GNUNET_strdup ("Not a ticket!\n");
GNUNET_SCHEDULER_add_now (&do_error, handle);
- GNUNET_JSON_parse_free(tktspec);
+ GNUNET_JSON_parse_free (tktspec);
json_decref (data_json);
return;
}
- for (ego_entry = handle->ego_head;
- NULL != ego_entry;
- ego_entry = ego_entry->next)
- {
- GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego,
- &tmp_pk);
- if (0 == memcmp (&ticket->audience,
- &tmp_pk,
+ for (ego_entry = handle->ego_head; NULL != ego_entry;
+ ego_entry = ego_entry->next) {
+ GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego, &tmp_pk);
+ if (0 == memcmp (&ticket->audience, &tmp_pk,
sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey)))
break;
}
- if (NULL == ego_entry)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Identity unknown\n");
+ if (NULL == ego_entry) {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Identity unknown\n");
GNUNET_JSON_parse_free (tktspec);
return;
}
identity_priv = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
handle->resp_object = json_object ();
handle->idp = GNUNET_RECLAIM_connect (cfg);
- handle->idp_op = GNUNET_RECLAIM_ticket_consume (handle->idp,
- identity_priv,
- ticket,
- &consume_cont,
- handle);
+ handle->idp_op = GNUNET_RECLAIM_ticket_consume (
+ handle->idp, identity_priv, ticket, &consume_cont, handle);
GNUNET_JSON_parse_free (tktspec);
}
-
/**
* Respond to OPTIONS request
*
@@ -908,18 +787,15 @@ consume_ticket_cont (struct GNUNET_REST_RequestHandle
*con_handle,
* @param cls the RequestHandle
*/
static void
-options_cont (struct GNUNET_REST_RequestHandle *con_handle,
- const char* url,
+options_cont (struct GNUNET_REST_RequestHandle *con_handle, const char *url,
void *cls)
{
struct MHD_Response *resp;
struct RequestHandle *handle = cls;
- //For now, independent of path return all options
+ // For now, independent of path return all options
resp = GNUNET_REST_create_response (NULL);
- MHD_add_response_header (resp,
- "Access-Control-Allow-Methods",
- allow_methods);
+ MHD_add_response_header (resp, "Access-Control-Allow-Methods",
allow_methods);
handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
cleanup_handle (handle);
return;
@@ -935,21 +811,21 @@ 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_RECLAIM_ATTRIBUTES,
&list_attribute_cont},
- {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
&add_attribute_cont},
- {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_TICKETS,
&list_tickets_cont},
- {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY_REVOKE,
&revoke_ticket_cont},
- {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY_CONSUME,
&consume_ticket_cont},
- {MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_RECLAIM,
- &options_cont},
- GNUNET_REST_HANDLER_END
- };
-
- if (GNUNET_NO == GNUNET_REST_handle_request (handle->rest_handle,
- handlers,
- &err,
- handle))
- {
+ {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
+ &list_attribute_cont},
+ {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
+ &add_attribute_cont},
+ {MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_TICKETS,
+ &list_tickets_cont},
+ {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY_REVOKE,
+ &revoke_ticket_cont},
+ {MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY_CONSUME,
+ &consume_ticket_cont},
+ {MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_RECLAIM, &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);
}
@@ -989,17 +865,14 @@ init_cont (struct RequestHandle *handle)
* must thus no longer be used
*/
static void
-list_ego (void *cls,
- struct GNUNET_IDENTITY_Ego *ego,
- void **ctx,
+list_ego (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx,
const char *identifier)
{
struct RequestHandle *handle = cls;
struct EgoEntry *ego_entry;
struct GNUNET_CRYPTO_EcdsaPublicKey pk;
- if ((NULL == ego) && (ID_REST_STATE_INIT == handle->state))
- {
+ if ((NULL == ego) && (ID_REST_STATE_INIT == handle->state)) {
handle->state = ID_REST_STATE_POST_INIT;
init_cont (handle);
return;
@@ -1007,19 +880,17 @@ list_ego (void *cls,
if (ID_REST_STATE_INIT == handle->state) {
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->keystring = GNUNET_CRYPTO_ecdsa_public_key_to_string (&pk);
ego_entry->ego = ego;
ego_entry->identifier = GNUNET_strdup (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);
}
-
}
static void
-rest_identity_process_request(struct GNUNET_REST_RequestHandle *rest_handle,
- GNUNET_REST_ResultProcessor proc,
- void *proc_cls)
+rest_identity_process_request (struct GNUNET_REST_RequestHandle *rest_handle,
+ GNUNET_REST_ResultProcessor proc, void
*proc_cls)
{
struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
handle->response_code = 0;
@@ -1030,20 +901,14 @@ rest_identity_process_request(struct
GNUNET_REST_RequestHandle *rest_handle,
handle->rest_handle = rest_handle;
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");
- handle->identity_handle = GNUNET_IDENTITY_connect (cfg,
- &list_ego,
- handle);
+ if (handle->url[strlen (handle->url) - 1] == '/')
+ handle->url[strlen (handle->url) - 1] = '\0';
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
+ handle->identity_handle = GNUNET_IDENTITY_connect (cfg, &list_ego, handle);
handle->namestore_handle = GNUNET_NAMESTORE_connect (cfg);
handle->timeout_task =
- GNUNET_SCHEDULER_add_delayed (handle->timeout,
- &do_timeout,
- handle);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Connected\n");
+ GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_timeout, handle);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
}
/**
@@ -1060,23 +925,19 @@ libgnunet_plugin_rest_reclaim_init (void *cls)
cfg = cls;
if (NULL != plugin.cfg)
- return NULL; /* can only initialize once! */
+ return NULL; /* can only initialize once! */
memset (&plugin, 0, sizeof (struct Plugin));
plugin.cfg = cfg;
api = GNUNET_new (struct GNUNET_REST_Plugin);
api->cls = &plugin;
api->name = GNUNET_REST_API_NS_RECLAIM;
api->process_request = &rest_identity_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_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 Provider REST API initialized\n"));
+ _ ("Identity Provider REST API initialized\n"));
return api;
}
--
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: RECLAIM/REST: add attribute ID to JSON,
gnunet <=