along with this program. If not, see <http://www.gnu.org/licenses/>.
SPDX-License-Identifier: AGPL3.0-or-later
- */
+ */
/**
* @author Martin Schanzenbach
* @author Philippe Buschmann
struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *claim_tmp;
struct EgoEntry *ego_entry;
struct EgoEntry *ego_tmp;
+
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
if (NULL != handle->resp_object)
json_decref (handle->resp_object);
GNUNET_free (handle->url);
if (NULL != handle->emsg)
GNUNET_free (handle->emsg);
- 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 (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);
- }
GNUNET_free (handle);
}
+
static void
cleanup_handle_delayed (void *cls)
{
char *json_error;
GNUNET_asprintf (&json_error, "{ \"error\" : \"%s\" }", handle->emsg);
- if (0 == handle->response_code) {
+ if (0 == handle->response_code)
+ {
handle->response_code = MHD_HTTP_BAD_REQUEST;
}
resp = GNUNET_REST_create_response (json_error);
do_error (handle);
}
+
static void
finished_cont (void *cls, int32_t success, const char *emsg)
{
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;
}
cleanup_handle (handle);
}
+
static void
collect_finished_cb (void *cls)
{
struct RequestHandle *handle = cls;
+
// Done
handle->attr_it = NULL;
handle->ticket_it = NULL;
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);
- 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);
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);
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);
GNUNET_free (tmp);
*/
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;
struct EgoEntry *ego_entry;
char *identity;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Getting tickets for %s.\n",
+ 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;
break;
handle->resp_object = json_array ();
- if (NULL == ego_entry) {
+ if (NULL == ego_entry)
+ {
// Done
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
GNUNET_SCHEDULER_add_now (&return_response, handle);
}
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;
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 ()};
+ struct GNUNET_JSON_Specification attrspec[] =
+ { GNUNET_RECLAIM_JSON_spec_claim (&attribute), GNUNET_JSON_spec_end () };
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding an attribute for %s.\n",
+ 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;
if (0 == strcmp (identity, ego_entry->identifier))
break;
- if (NULL == ego_entry) {
+ 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);
GNUNET_assert (GNUNET_OK ==
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;
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);
}
*
*/
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;
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);
- 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, "name", json_string (attr->name));
type = GNUNET_RECLAIM_ATTRIBUTE_number_to_typename (attr->type);
json_object_set_new (attr_obj, "type", json_string (type));
- id_str = GNUNET_STRINGS_data_to_string_alloc (&attr->id, sizeof (uint64_t));
+ 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);
*/
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;
struct EgoEntry *ego_entry;
char *identity;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Getting attributes for %s.\n",
+ 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;
handle->resp_object = json_array ();
- if (NULL == ego_entry) {
+ if (NULL == ego_entry)
+ {
// Done
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
GNUNET_SCHEDULER_add_now (&return_response, handle);
}
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);
}
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;
}
*/
static void
delete_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;
char *id;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleting attributes.\n");
- 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;
strdup (handle->url + strlen (GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) + 1);
identity = strtok (identity_id_str, "/");
id = strtok (NULL, "/");
- if ((NULL == identity) || (NULL == id)) {
+ if ((NULL == identity) || (NULL == id))
+ {
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Malformed request.\n");
GNUNET_free (identity_id_str);
GNUNET_SCHEDULER_add_now (&do_error, handle);
if (0 == strcmp (identity, ego_entry->identifier))
break;
handle->resp_object = json_array ();
- if (NULL == ego_entry) {
+ if (NULL == ego_entry)
+ {
// Done
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
GNUNET_free (identity_id_str);
}
priv_key = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
handle->idp = GNUNET_RECLAIM_connect (cfg);
- memset (&attr, 0, sizeof (struct GNUNET_RECLAIM_ATTRIBUTE_Claim));
- GNUNET_STRINGS_string_to_data (id, strlen (id), &attr.id, sizeof (uint64_t));
+ memset (&attr, 0, sizeof(struct GNUNET_RECLAIM_ATTRIBUTE_Claim));
+ GNUNET_STRINGS_string_to_data (id, strlen (id), &attr.id, sizeof(uint64_t));
attr.name = "";
- handle->idp_op = GNUNET_RECLAIM_attribute_delete (
- handle->idp, priv_key, &attr, &delete_finished_cb, handle);
+ handle->idp_op = GNUNET_RECLAIM_attribute_delete (handle->idp,
+ priv_key,
+ &attr,
+ &delete_finished_cb,
+ handle);
GNUNET_free (identity_id_str);
}
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_RECLAIM_Ticket *ticket = NULL;
struct GNUNET_CRYPTO_EcdsaPublicKey tmp_pk;
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 ()};
+ struct GNUNET_JSON_Specification tktspec[] =
+ { 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);
- GNUNET_assert (GNUNET_OK ==
- 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",
- term_data);
+ if ((NULL == data_json) ||
+ (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);
+ if (NULL != data_json)
+ json_decref (data_json);
return;
}
- if (GNUNET_OK != GNUNET_JSON_parse (data_json, tktspec, NULL, NULL)) {
- handle->emsg = GNUNET_strdup ("Not a ticket!\n");
+ json_decref (data_json);
+ 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);
- GNUNET_JSON_parse_free (tktspec);
- json_decref (data_json);
return;
}
for (ego_entry = handle->ego_head; NULL != ego_entry;
- ego_entry = ego_entry->next) {
+ 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)))
+ if (0 == memcmp (&ticket->identity,
+ &tmp_pk,
+ sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
break;
}
- if (NULL == ego_entry) {
+ 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,
+ val_str = GNUNET_RECLAIM_ATTRIBUTE_value_to_string (attr->type,
+ attr->data,
attr->data_size);
- if (NULL == val_str) {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to parse value for: %s\n",
+ if (NULL == val_str)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Failed to parse value for: %s\n",
attr->name);
return;
}
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;
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 ()};
+ struct GNUNET_JSON_Specification tktspec[] =
+ { 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) {
+ 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);
return;
}
for (ego_entry = handle->ego_head; NULL != ego_entry;
- ego_entry = ego_entry->next) {
+ 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)))
+ if (0 == memcmp (&ticket->audience,
+ &tmp_pk,
+ sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
break;
}
- if (NULL == ego_entry) {
+ 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);
}
* @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;
return;
}
+
/**
* Handle rest request
*
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_DELETE, GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
- &delete_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)) {
+ 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_DELETE,
+ GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES,
+ &delete_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);
}
}
+
/**
* If listing is enabled, prints information about the egos.
*
* 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;
}
- if (ID_REST_STATE_INIT == handle->state) {
+ 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->ego = ego;
ego_entry->identifier = GNUNET_strdup (identifier);
- GNUNET_CONTAINER_DLL_insert_tail (handle->ego_head, handle->ego_tail,
+ 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)
+ GNUNET_REST_ResultProcessor proc,
+ void *proc_cls)
{
struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
+
handle->response_code = 0;
handle->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
handle->proc_cls = proc_cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
}
+
/**
* Entry point for the plugin.
*
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->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"));
{
struct GNUNET_REST_Plugin *api = cls;
struct Plugin *plugin = api->cls;
+
plugin->cfg = NULL;
GNUNET_free_non_null (allow_methods);
return NULL;
}
+
/* end of plugin_rest_reclaim.c */
projects / oweals / gnunet.git / blobdiff