GNUnet  0.10.x
Data Structures | Macros | Functions | Variables
plugin_rest_reclaim.c File Reference

GNUnet reclaim REST plugin. More...

#include "platform.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_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"
Include dependency graph for plugin_rest_reclaim.c:

Go to the source code of this file.

Data Structures

struct  Plugin
 Handle for a plugin. More...
 
struct  EgoEntry
 The ego list. More...
 
struct  RequestHandle
 The request handle. More...
 

Macros

#define GNUNET_REST_API_NS_RECLAIM   "/reclaim"
 REST root namespace. More...
 
#define GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES   "/reclaim/attributes"
 Attribute namespace. More...
 
#define GNUNET_REST_API_NS_IDENTITY_TICKETS   "/reclaim/tickets"
 Ticket namespace. More...
 
#define GNUNET_REST_API_NS_IDENTITY_REVOKE   "/reclaim/revoke"
 Revoke namespace. More...
 
#define GNUNET_REST_API_NS_IDENTITY_CONSUME   "/reclaim/consume"
 Revoke namespace. More...
 
#define ID_REST_STATE_INIT   0
 State while collecting all egos. More...
 
#define ID_REST_STATE_POST_INIT   1
 Done collecting egos. More...
 

Functions

static void cleanup_handle (struct RequestHandle *handle)
 Cleanup lookup handle. More...
 
static void cleanup_handle_delayed (void *cls)
 
static void do_error (void *cls)
 Task run on error, sends error message. More...
 
static void do_timeout (void *cls)
 Task run on timeout, sends error message. More...
 
static void collect_error_cb (void *cls)
 
static void finished_cont (void *cls, int32_t success, const char *emsg)
 
static void return_response (void *cls)
 Return attributes for identity. More...
 
static void collect_finished_cb (void *cls)
 
static void ticket_collect (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
 Collect all attributes for an ego. More...
 
static void list_tickets_cont (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 List tickets for identity request. More...
 
static void add_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 
static void attr_collect (void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
 Collect all attributes for an ego. More...
 
static void list_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 List attributes for identity request. More...
 
static void delete_finished_cb (void *cls, int32_t success, const char *emsg)
 
static void delete_attribute_cont (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 List attributes for identity request. More...
 
static void revoke_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 
static void consume_cont (void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
 
static void consume_ticket_cont (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 
static void options_cont (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Respond to OPTIONS request. More...
 
static void init_cont (struct RequestHandle *handle)
 Handle rest request. More...
 
static void list_ego (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *identifier)
 If listing is enabled, prints information about the egos. More...
 
static void rest_identity_process_request (struct GNUNET_REST_RequestHandle *rest_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
 
void * libgnunet_plugin_rest_reclaim_init (void *cls)
 Entry point for the plugin. More...
 
void * libgnunet_plugin_rest_reclaim_done (void *cls)
 Exit point from the plugin. More...
 

Variables

const struct GNUNET_CONFIGURATION_Handlecfg
 The configuration handle. More...
 
static char * allow_methods
 HTTP methods allows for this plugin. More...
 

Detailed Description

GNUnet reclaim REST plugin.

Author
Martin Schanzenbach
Philippe Buschmann

Definition in file plugin_rest_reclaim.c.

Macro Definition Documentation

◆ GNUNET_REST_API_NS_RECLAIM

#define GNUNET_REST_API_NS_RECLAIM   "/reclaim"

REST root namespace.

Definition at line 44 of file plugin_rest_reclaim.c.

Referenced by init_cont(), and libgnunet_plugin_rest_reclaim_init().

◆ GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES

#define GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES   "/reclaim/attributes"

◆ GNUNET_REST_API_NS_IDENTITY_TICKETS

#define GNUNET_REST_API_NS_IDENTITY_TICKETS   "/reclaim/tickets"

Ticket namespace.

Definition at line 54 of file plugin_rest_reclaim.c.

Referenced by init_cont(), and list_tickets_cont().

◆ GNUNET_REST_API_NS_IDENTITY_REVOKE

#define GNUNET_REST_API_NS_IDENTITY_REVOKE   "/reclaim/revoke"

Revoke namespace.

Definition at line 59 of file plugin_rest_reclaim.c.

Referenced by init_cont().

◆ GNUNET_REST_API_NS_IDENTITY_CONSUME

#define GNUNET_REST_API_NS_IDENTITY_CONSUME   "/reclaim/consume"

Revoke namespace.

Definition at line 64 of file plugin_rest_reclaim.c.

Referenced by init_cont().

◆ ID_REST_STATE_INIT

#define ID_REST_STATE_INIT   0

State while collecting all egos.

Definition at line 69 of file plugin_rest_reclaim.c.

Referenced by list_ego(), and rest_identity_process_request().

◆ ID_REST_STATE_POST_INIT

#define ID_REST_STATE_POST_INIT   1

Done collecting egos.

Definition at line 74 of file plugin_rest_reclaim.c.

Referenced by list_ego().

Function Documentation

◆ cleanup_handle()

static void cleanup_handle ( struct RequestHandle handle)
static

Cleanup lookup handle.

Parameters
handleHandle to clean up

Definition at line 241 of file plugin_rest_reclaim.c.

References RequestHandle::attr_it, RequestHandle::attr_list, GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry::claim, RequestHandle::ego_head, RequestHandle::emsg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_IDENTITY_disconnect(), GNUNET_log, GNUNET_RECLAIM_disconnect(), GNUNET_RECLAIM_get_attributes_stop(), GNUNET_RECLAIM_ticket_iteration_stop(), GNUNET_SCHEDULER_cancel(), EgoEntry::identifier, RequestHandle::identity_handle, RequestHandle::idp, EgoEntry::keystring, GNUNET_RECLAIM_ATTRIBUTE_ClaimList::list_head, GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry::next, EgoEntry::next, RequestHandle::resp_object, RequestHandle::ticket_it, RequestHandle::timeout_task, and RequestHandle::url.

Referenced by cleanup_handle_delayed(), options_cont(), and return_response().

242 {
243  struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *claim_entry;
244  struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry *claim_tmp;
245  struct EgoEntry *ego_entry;
246  struct EgoEntry *ego_tmp;
247 
248  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
249  if (NULL != handle->resp_object)
250  json_decref(handle->resp_object);
251  if (NULL != handle->timeout_task)
253  if (NULL != handle->identity_handle)
255  if (NULL != handle->attr_it)
257  if (NULL != handle->ticket_it)
259  if (NULL != handle->idp)
261  if (NULL != handle->url)
262  GNUNET_free(handle->url);
263  if (NULL != handle->emsg)
264  GNUNET_free(handle->emsg);
265  if (NULL != handle->attr_list)
266  {
267  for (claim_entry = handle->attr_list->list_head; NULL != claim_entry;)
268  {
269  claim_tmp = claim_entry;
270  claim_entry = claim_entry->next;
271  GNUNET_free(claim_tmp->claim);
272  GNUNET_free(claim_tmp);
273  }
274  GNUNET_free(handle->attr_list);
275  }
276  for (ego_entry = handle->ego_head; NULL != ego_entry;)
277  {
278  ego_tmp = ego_entry;
279  ego_entry = ego_entry->next;
280  GNUNET_free(ego_tmp->identifier);
281  GNUNET_free(ego_tmp->keystring);
282  GNUNET_free(ego_tmp);
283  }
284  GNUNET_free(handle);
285 }
struct GNUNET_RECLAIM_ATTRIBUTE_Claim * claim
The attribute claim.
struct GNUNET_RECLAIM_AttributeIterator * attr_it
Attribute iterator.
void GNUNET_RECLAIM_disconnect(struct GNUNET_RECLAIM_Handle *h)
Disconnect from identity provider service.
Definition: reclaim_api.c:814
void GNUNET_RECLAIM_ticket_iteration_stop(struct GNUNET_RECLAIM_TicketIterator *it)
Stops iteration and releases the handle for further calls.
Definition: reclaim_api.c:1203
The ego list.
json_t * resp_object
Response object.
char * emsg
Error response message.
struct GNUNET_RECLAIM_TicketIterator * ticket_it
Ticket iterator.
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:835
char * keystring
Public key string.
struct GNUNET_RECLAIM_Handle * idp
Identity Provider.
struct GNUNET_RECLAIM_ATTRIBUTE_ClaimList * attr_list
Attribute claim list.
char * identifier
Ego Identifier.
struct EgoEntry * ego_head
Ego list.
void GNUNET_RECLAIM_get_attributes_stop(struct GNUNET_RECLAIM_AttributeIterator *it)
Stops iteration and releases the handle for further calls.
Definition: reclaim_api.c:1015
struct GNUNET_SCHEDULER_Task * timeout_task
ID of a task associated with the resolution process.
#define GNUNET_log(kind,...)
struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry * next
DLL.
struct GNUNET_RECLAIM_ATTRIBUTE_ClaimListEntry * list_head
List head.
struct EgoEntry * next
DLL.
struct GNUNET_IDENTITY_Handle * identity_handle
Handle to Identity service.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ cleanup_handle_delayed()

static void cleanup_handle_delayed ( void *  cls)
static

Definition at line 288 of file plugin_rest_reclaim.c.

References cleanup_handle().

Referenced by delete_finished_cb(), do_error(), and finished_cont().

289 {
290  cleanup_handle(cls);
291 }
static void cleanup_handle(struct RequestHandle *handle)
Cleanup lookup handle.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_error()

static void do_error ( void *  cls)
static

Task run on error, sends error message.

Cleans up everything.

Parameters
clsthe struct RequestHandle

Definition at line 300 of file plugin_rest_reclaim.c.

References cleanup_handle_delayed(), RequestHandle::emsg, GNUNET_asprintf(), GNUNET_free, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), handle, RequestHandle::proc, RequestHandle::proc_cls, and RequestHandle::response_code.

Referenced by add_attribute_cont(), collect_error_cb(), consume_ticket_cont(), delete_attribute_cont(), delete_finished_cb(), do_timeout(), finished_cont(), init_cont(), list_attribute_cont(), list_tickets_cont(), and revoke_ticket_cont().

301 {
302  struct RequestHandle *handle = cls;
303  struct MHD_Response *resp;
304  char *json_error;
305 
306  GNUNET_asprintf(&json_error, "{ \"error\" : \"%s\" }", handle->emsg);
307  if (0 == handle->response_code)
308  {
309  handle->response_code = MHD_HTTP_BAD_REQUEST;
310  }
311  resp = GNUNET_REST_create_response(json_error);
312  MHD_add_response_header(resp, "Content-Type", "application/json");
313  handle->proc(handle->proc_cls, resp, handle->response_code);
315  GNUNET_free(json_error);
316 }
static void cleanup_handle_delayed(void *cls)
GNUNET_REST_ResultProcessor proc
The plugin result processor.
void * proc_cls
The closure of the result processor.
The request handle.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
char * emsg
Error response message.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
HTTP response code.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_timeout()

static void do_timeout ( void *  cls)
static

Task run on timeout, sends error message.

Cleans up everything.

Parameters
clsthe struct RequestHandle

Definition at line 325 of file plugin_rest_reclaim.c.

References do_error(), handle, and RequestHandle::timeout_task.

Referenced by rest_identity_process_request().

326 {
327  struct RequestHandle *handle = cls;
328 
329  handle->timeout_task = NULL;
330  do_error(handle);
331 }
The request handle.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void do_error(void *cls)
Task run on error, sends error message.
struct GNUNET_SCHEDULER_Task * timeout_task
ID of a task associated with the resolution process.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ collect_error_cb()

static void collect_error_cb ( void *  cls)
static

Definition at line 335 of file plugin_rest_reclaim.c.

References do_error(), and handle.

Referenced by list_attribute_cont(), and list_tickets_cont().

336 {
337  struct RequestHandle *handle = cls;
338 
339  do_error(handle);
340 }
The request handle.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void do_error(void *cls)
Task run on error, sends error message.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ finished_cont()

static void finished_cont ( void *  cls,
int32_t  success,
const char *  emsg 
)
static

Definition at line 343 of file plugin_rest_reclaim.c.

References cleanup_handle_delayed(), do_error(), GNUNET_OK, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), handle, RequestHandle::proc, and RequestHandle::proc_cls.

Referenced by add_attribute_cont(), and revoke_ticket_cont().

344 {
345  struct RequestHandle *handle = cls;
346  struct MHD_Response *resp;
347 
348  resp = GNUNET_REST_create_response(emsg);
349  if (GNUNET_OK != success)
350  {
352  return;
353  }
354  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
356 }
static void cleanup_handle_delayed(void *cls)
GNUNET_REST_ResultProcessor proc
The plugin result processor.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
void * proc_cls
The closure of the result processor.
The request handle.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void do_error(void *cls)
Task run on error, sends error message.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
Here is the call graph for this function:
Here is the caller graph for this function:

◆ return_response()

static void return_response ( void *  cls)
static

Return attributes for identity.

Parameters
clsthe request handle

Definition at line 365 of file plugin_rest_reclaim.c.

References cleanup_handle(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_REST_create_response(), handle, RequestHandle::proc, RequestHandle::proc_cls, and RequestHandle::resp_object.

Referenced by collect_finished_cb(), consume_cont(), delete_attribute_cont(), list_attribute_cont(), and list_tickets_cont().

366 {
367  char *result_str;
368  struct RequestHandle *handle = cls;
369  struct MHD_Response *resp;
370 
371  result_str = json_dumps(handle->resp_object, 0);
372  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
373  resp = GNUNET_REST_create_response(result_str);
374  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
375  GNUNET_free(result_str);
376  cleanup_handle(handle);
377 }
GNUNET_REST_ResultProcessor proc
The plugin result processor.
void * proc_cls
The closure of the result processor.
The request handle.
json_t * resp_object
Response object.
static void cleanup_handle(struct RequestHandle *handle)
Cleanup lookup handle.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
#define GNUNET_log(kind,...)
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ collect_finished_cb()

static void collect_finished_cb ( void *  cls)
static

Definition at line 380 of file plugin_rest_reclaim.c.

References RequestHandle::attr_it, GNUNET_SCHEDULER_add_now(), handle, return_response(), and RequestHandle::ticket_it.

Referenced by list_attribute_cont(), and list_tickets_cont().

381 {
382  struct RequestHandle *handle = cls;
383 
384  // Done
385  handle->attr_it = NULL;
386  handle->ticket_it = NULL;
388 }
struct GNUNET_RECLAIM_AttributeIterator * attr_it
Attribute iterator.
The request handle.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
struct GNUNET_RECLAIM_TicketIterator * ticket_it
Ticket iterator.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void return_response(void *cls)
Return attributes for identity.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ticket_collect()

static void ticket_collect ( void *  cls,
const struct GNUNET_RECLAIM_Ticket ticket 
)
static

Collect all attributes for an ego.

Definition at line 396 of file plugin_rest_reclaim.c.

References GNUNET_RECLAIM_Ticket::audience, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_RECLAIM_ticket_iteration_next(), GNUNET_STRINGS_data_to_string_alloc(), handle, GNUNET_RECLAIM_Ticket::identity, RequestHandle::resp_object, GNUNET_RECLAIM_Ticket::rnd, RequestHandle::ticket_it, and value.

Referenced by list_tickets_cont().

397 {
398  json_t *json_resource;
399  struct RequestHandle *handle = cls;
400  json_t *value;
401  char *tmp;
402 
403  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Adding ticket\n");
404  tmp = GNUNET_STRINGS_data_to_string_alloc(&ticket->rnd, sizeof(uint64_t));
405  json_resource = json_object();
406  GNUNET_free(tmp);
407  json_array_append(handle->resp_object, json_resource);
408 
409  tmp =
411  sizeof(struct
413  value = json_string(tmp);
414  json_object_set_new(json_resource, "issuer", value);
415  GNUNET_free(tmp);
416  tmp =
418  sizeof(struct
420  value = json_string(tmp);
421  json_object_set_new(json_resource, "audience", value);
422  GNUNET_free(tmp);
423  tmp = GNUNET_STRINGS_data_to_string_alloc(&ticket->rnd, sizeof(uint64_t));
424  value = json_string(tmp);
425  json_object_set_new(json_resource, "rnd", value);
426  GNUNET_free(tmp);
428 }
void GNUNET_RECLAIM_ticket_iteration_next(struct GNUNET_RECLAIM_TicketIterator *it)
Calls the ticket processor specified in GNUNET_RECLAIM_ticket_iteration_start for the next record...
Definition: reclaim_api.c:1183
The request handle.
json_t * resp_object
Response object.
static char * value
Value of the record to add/remove.
struct GNUNET_RECLAIM_TicketIterator * ticket_it
Ticket iterator.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
struct GNUNET_CRYPTO_EcdsaPublicKey identity
The ticket issuer (= the user)
uint64_t rnd
The ticket random (NBO)
struct GNUNET_CRYPTO_EcdsaPublicKey audience
The ticket audience (= relying party)
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
#define GNUNET_log(kind,...)
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:921
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ list_tickets_cont()

static void list_tickets_cont ( struct GNUNET_REST_RequestHandle con_handle,
const char *  url,
void *  cls 
)
static

List tickets for identity request.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 439 of file plugin_rest_reclaim.c.

References collect_error_cb(), collect_finished_cb(), do_error(), EgoEntry::ego, RequestHandle::ego_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_RECLAIM_connect(), GNUNET_RECLAIM_ticket_iteration_start(), GNUNET_REST_API_NS_IDENTITY_TICKETS, GNUNET_SCHEDULER_add_now(), handle, EgoEntry::identifier, identity, RequestHandle::idp, EgoEntry::next, RequestHandle::resp_object, return_response(), ticket_collect(), RequestHandle::ticket_it, and RequestHandle::url.

Referenced by init_cont().

442 {
443  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
444  struct RequestHandle *handle = cls;
445  struct EgoEntry *ego_entry;
446  char *identity;
447 
449  "Getting tickets for %s.\n",
450  handle->url);
451  if (strlen(GNUNET_REST_API_NS_IDENTITY_TICKETS) >= strlen(handle->url))
452  {
453  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
455  return;
456  }
457  identity = handle->url + strlen(GNUNET_REST_API_NS_IDENTITY_TICKETS) + 1;
458 
459  for (ego_entry = handle->ego_head; NULL != ego_entry;
460  ego_entry = ego_entry->next)
461  if (0 == strcmp(identity, ego_entry->identifier))
462  break;
463  handle->resp_object = json_array();
464 
465  if (NULL == ego_entry)
466  {
467  // Done
468  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
470  return;
471  }
472  priv_key = GNUNET_IDENTITY_ego_get_private_key(ego_entry->ego);
473  handle->idp = GNUNET_RECLAIM_connect(cfg);
474  handle->ticket_it =
476  priv_key,
478  handle,
480  handle,
482  handle);
483 }
struct GNUNET_RECLAIM_TicketIterator * GNUNET_RECLAIM_ticket_iteration_start(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_RECLAIM_TicketCallback proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
Lists all tickets that have been issued to remote identites (relying parties)
Definition: reclaim_api.c:1139
static void collect_error_cb(void *cls)
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:553
Private ECC key encoded for transmission.
static void collect_finished_cb(void *cls)
The request handle.
The ego list.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
json_t * resp_object
Response object.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
struct GNUNET_RECLAIM_TicketIterator * ticket_it
Ticket iterator.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
static void ticket_collect(void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
Collect all attributes for an ego.
static void return_response(void *cls)
Return attributes for identity.
struct GNUNET_RECLAIM_Handle * idp
Identity Provider.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static void do_error(void *cls)
Task run on error, sends error message.
char * identifier
Ego Identifier.
struct EgoEntry * ego_head
Ego list.
#define GNUNET_log(kind,...)
struct GNUNET_RECLAIM_Handle * GNUNET_RECLAIM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the re:claimID service.
Definition: reclaim_api.c:774
struct EgoEntry * next
DLL.
#define GNUNET_REST_API_NS_IDENTITY_TICKETS
Ticket namespace.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ add_attribute_cont()

static void add_attribute_cont ( struct GNUNET_REST_RequestHandle con_handle,
const char *  url,
void *  cls 
)
static

New ID for attribute

Definition at line 487 of file plugin_rest_reclaim.c.

References GNUNET_REST_RequestHandle::data, GNUNET_REST_RequestHandle::data_size, do_error(), EgoEntry::ego, RequestHandle::ego_head, finished_cont(), GNUNET_assert, GNUNET_CRYPTO_QUALITY_STRONG, GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_JSON_parse(), GNUNET_JSON_parse_free(), GNUNET_JSON_spec_end(), GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_RECLAIM_attribute_store(), GNUNET_RECLAIM_connect(), GNUNET_RECLAIM_JSON_spec_claim(), GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, GNUNET_SCHEDULER_add_now(), GNUNET_TIME_UNIT_HOURS, handle, GNUNET_RECLAIM_ATTRIBUTE_Claim::id, EgoEntry::identifier, identity, RequestHandle::idp, RequestHandle::idp_op, EgoEntry::next, RequestHandle::rest_handle, and RequestHandle::url.

Referenced by init_cont().

490 {
491  const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
492  const char *identity;
493  struct RequestHandle *handle = cls;
494  struct EgoEntry *ego_entry;
495  struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attribute;
496  struct GNUNET_TIME_Relative exp;
497  char term_data[handle->rest_handle->data_size + 1];
498  json_t *data_json;
499  json_error_t err;
500  struct GNUNET_JSON_Specification attrspec[] =
502 
504  "Adding an attribute for %s.\n",
505  handle->url);
506  if (strlen(GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >= strlen(handle->url))
507  {
508  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
510  return;
511  }
512  identity = handle->url + strlen(GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) + 1;
513 
514  for (ego_entry = handle->ego_head; NULL != ego_entry;
515  ego_entry = ego_entry->next)
516  if (0 == strcmp(identity, ego_entry->identifier))
517  break;
518 
519  if (NULL == ego_entry)
520  {
521  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Identity unknown (%s)\n", identity);
522  return;
523  }
524  identity_priv = GNUNET_IDENTITY_ego_get_private_key(ego_entry->ego);
525 
526  if (0 >= handle->rest_handle->data_size)
527  {
529  return;
530  }
531 
532  term_data[handle->rest_handle->data_size] = '\0';
533  GNUNET_memcpy(term_data,
534  handle->rest_handle->data,
535  handle->rest_handle->data_size);
536  data_json = json_loads(term_data, JSON_DECODE_ANY, &err);
538  GNUNET_JSON_parse(data_json, attrspec, NULL, NULL));
539  json_decref(data_json);
540  if (NULL == attribute)
541  {
543  "Unable to parse attribute from %s\n",
544  term_data);
546  return;
547  }
551  if (0 == attribute->id)
552  attribute->id =
554  handle->idp = GNUNET_RECLAIM_connect(cfg);
556  handle->idp_op = GNUNET_RECLAIM_attribute_store(handle->idp,
557  identity_priv,
558  attribute,
559  &exp,
560  &finished_cont,
561  handle);
562  GNUNET_JSON_parse_free(attrspec);
563 }
#define GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES
Attribute namespace.
#define GNUNET_TIME_UNIT_HOURS
One hour.
struct GNUNET_RECLAIM_Operation * GNUNET_RECLAIM_attribute_store(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr, const struct GNUNET_TIME_Relative *exp_interval, GNUNET_RECLAIM_ContinuationWithStatus cont, void *cont_cls)
Store an attribute.
Definition: reclaim_api.c:844
size_t data_size
The POST data size.
uint64_t GNUNET_CRYPTO_random_u64(enum GNUNET_CRYPTO_Quality mode, uint64_t max)
Random on unsigned 64-bit values.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_JSON_parse_free(struct GNUNET_JSON_Specification *spec)
Frees all elements allocated during a GNUNET_JSON_parse() operation.
Definition: json.c:100
static void finished_cont(void *cls, int32_t success, const char *emsg)
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:553
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Entry in parser specification for GNUNET_JSON_parse().
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Private ECC key encoded for transmission.
The request handle.
The ego list.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
int GNUNET_JSON_parse(const json_t *root, struct GNUNET_JSON_Specification *spec, const char **error_json_name, unsigned int *error_line)
Navigate and parse data in a JSON tree.
Definition: json.c:45
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
struct GNUNET_REST_RequestHandle * rest_handle
Handle to rest request.
const char * data
The POST data.
struct GNUNET_RECLAIM_Handle * idp
Identity Provider.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static void do_error(void *cls)
Task run on error, sends error message.
char * identifier
Ego Identifier.
struct GNUNET_JSON_Specification GNUNET_RECLAIM_JSON_spec_claim(struct GNUNET_RECLAIM_ATTRIBUTE_Claim **attr)
JSON Specification for Reclaim claims.
Definition: json_reclaim.c:131
struct EgoEntry * ego_head
Ego list.
#define GNUNET_log(kind,...)
struct GNUNET_RECLAIM_Operation * idp_op
Idp Operation.
struct GNUNET_JSON_Specification GNUNET_JSON_spec_end(void)
End of a parser specification.
Definition: json_helper.c:35
struct GNUNET_RECLAIM_Handle * GNUNET_RECLAIM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the re:claimID service.
Definition: reclaim_api.c:774
struct EgoEntry * next
DLL.
Time for relative time used by GNUnet, in microseconds.
High-quality operations are desired.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ attr_collect()

static void attr_collect ( void *  cls,
const struct GNUNET_CRYPTO_EcdsaPublicKey identity,
const struct GNUNET_RECLAIM_ATTRIBUTE_Claim attr 
)
static

Collect all attributes for an ego.

Definition at line 571 of file plugin_rest_reclaim.c.

References RequestHandle::attr_it, GNUNET_RECLAIM_ATTRIBUTE_Claim::data, GNUNET_RECLAIM_ATTRIBUTE_Claim::data_size, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_RECLAIM_ATTRIBUTE_number_to_typename(), GNUNET_RECLAIM_ATTRIBUTE_value_to_string(), GNUNET_RECLAIM_get_attributes_next(), GNUNET_STRINGS_data_to_string_alloc(), handle, GNUNET_RECLAIM_ATTRIBUTE_Claim::id, GNUNET_RECLAIM_ATTRIBUTE_Claim::name, RequestHandle::resp_object, GNUNET_RECLAIM_ATTRIBUTE_Claim::type, and type.

Referenced by list_attribute_cont().

574 {
575  struct RequestHandle *handle = cls;
576  json_t *attr_obj;
577  const char *type;
578  char *tmp_value;
579  char *id_str;
580 
581  if ((NULL == attr->name) || (NULL == attr->data))
582  {
584  return;
585  }
586 
587  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n", attr->name);
588 
590  attr->data,
591  attr->data_size);
592 
593  attr_obj = json_object();
594  json_object_set_new(attr_obj, "value", json_string(tmp_value));
595  json_object_set_new(attr_obj, "name", json_string(attr->name));
597  json_object_set_new(attr_obj, "type", json_string(type));
598  id_str = GNUNET_STRINGS_data_to_string_alloc(&attr->id, sizeof(uint64_t));
599  json_object_set_new(attr_obj, "id", json_string(id_str));
600  json_array_append(handle->resp_object, attr_obj);
601  json_decref(attr_obj);
602  GNUNET_free(tmp_value);
604 }
const char * name
The name of the attribute.
char * GNUNET_RECLAIM_ATTRIBUTE_value_to_string(uint32_t type, const void *data, size_t data_size)
Convert the &#39;claim&#39; of an attribute to a string.
size_t data_size
Number of bytes in data.
struct GNUNET_RECLAIM_AttributeIterator * attr_it
Attribute iterator.
void GNUNET_RECLAIM_get_attributes_next(struct GNUNET_RECLAIM_AttributeIterator *it)
Calls the record processor specified in GNUNET_RECLAIM_get_attributes_start for the next record...
Definition: reclaim_api.c:994
The request handle.
const void * data
Binary value stored as attribute value.
json_t * resp_object
Response object.
const char * GNUNET_RECLAIM_ATTRIBUTE_number_to_typename(uint32_t type)
Convert a type number to the corresponding type string.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
#define GNUNET_log(kind,...)
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:921
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ list_attribute_cont()

static void list_attribute_cont ( struct GNUNET_REST_RequestHandle con_handle,
const char *  url,
void *  cls 
)
static

List attributes for identity request.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 615 of file plugin_rest_reclaim.c.

References attr_collect(), RequestHandle::attr_it, collect_error_cb(), collect_finished_cb(), do_error(), EgoEntry::ego, RequestHandle::ego_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_RECLAIM_connect(), GNUNET_RECLAIM_get_attributes_start(), GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, GNUNET_SCHEDULER_add_now(), handle, EgoEntry::identifier, identity, RequestHandle::idp, EgoEntry::next, RequestHandle::resp_object, return_response(), and RequestHandle::url.

Referenced by init_cont().

618 {
619  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
620  struct RequestHandle *handle = cls;
621  struct EgoEntry *ego_entry;
622  char *identity;
623 
625  "Getting attributes for %s.\n",
626  handle->url);
627  if (strlen(GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >= strlen(handle->url))
628  {
629  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
631  return;
632  }
633  identity = handle->url + strlen(GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) + 1;
634 
635  for (ego_entry = handle->ego_head; NULL != ego_entry;
636  ego_entry = ego_entry->next)
637  if (0 == strcmp(identity, ego_entry->identifier))
638  break;
639  handle->resp_object = json_array();
640 
641 
642  if (NULL == ego_entry)
643  {
644  // Done
645  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
647  return;
648  }
649  priv_key = GNUNET_IDENTITY_ego_get_private_key(ego_entry->ego);
650  handle->idp = GNUNET_RECLAIM_connect(cfg);
652  priv_key,
654  handle,
655  &attr_collect,
656  handle,
658  handle);
659 }
#define GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES
Attribute namespace.
static void attr_collect(void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
Collect all attributes for an ego.
struct GNUNET_RECLAIM_AttributeIterator * GNUNET_RECLAIM_get_attributes_start(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_RECLAIM_AttributeResult proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
List all attributes for a local identity.
Definition: reclaim_api.c:948
static void collect_error_cb(void *cls)
struct GNUNET_RECLAIM_AttributeIterator * attr_it
Attribute iterator.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:553
Private ECC key encoded for transmission.
static void collect_finished_cb(void *cls)
The request handle.
The ego list.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
json_t * resp_object
Response object.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
static void return_response(void *cls)
Return attributes for identity.
struct GNUNET_RECLAIM_Handle * idp
Identity Provider.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static void do_error(void *cls)
Task run on error, sends error message.
char * identifier
Ego Identifier.
struct EgoEntry * ego_head
Ego list.
#define GNUNET_log(kind,...)
struct GNUNET_RECLAIM_Handle * GNUNET_RECLAIM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the re:claimID service.
Definition: reclaim_api.c:774
struct EgoEntry * next
DLL.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ delete_finished_cb()

static void delete_finished_cb ( void *  cls,
int32_t  success,
const char *  emsg 
)
static

Definition at line 663 of file plugin_rest_reclaim.c.

References cleanup_handle_delayed(), do_error(), GNUNET_OK, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), handle, RequestHandle::proc, and RequestHandle::proc_cls.

Referenced by delete_attribute_cont().

664 {
665  struct RequestHandle *handle = cls;
666  struct MHD_Response *resp;
667 
668  resp = GNUNET_REST_create_response(emsg);
669  if (GNUNET_OK != success)
670  {
672  return;
673  }
674  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
676 }
static void cleanup_handle_delayed(void *cls)
GNUNET_REST_ResultProcessor proc
The plugin result processor.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
void * proc_cls
The closure of the result processor.
The request handle.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void do_error(void *cls)
Task run on error, sends error message.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
Here is the call graph for this function:
Here is the caller graph for this function:

◆ delete_attribute_cont()

static void delete_attribute_cont ( struct GNUNET_REST_RequestHandle con_handle,
const char *  url,
void *  cls 
)
static

List attributes for identity request.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 687 of file plugin_rest_reclaim.c.

References delete_finished_cb(), do_error(), EgoEntry::ego, RequestHandle::ego_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_RECLAIM_attribute_delete(), GNUNET_RECLAIM_connect(), GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_string_to_data(), handle, GNUNET_RECLAIM_ATTRIBUTE_Claim::id, id, EgoEntry::identifier, identity, RequestHandle::idp, RequestHandle::idp_op, GNUNET_RECLAIM_ATTRIBUTE_Claim::name, EgoEntry::next, RequestHandle::resp_object, return_response(), and RequestHandle::url.

Referenced by init_cont().

690 {
691  const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv_key;
692  struct RequestHandle *handle = cls;
693  struct GNUNET_RECLAIM_ATTRIBUTE_Claim attr;
694  struct EgoEntry *ego_entry;
695  char *identity_id_str;
696  char *identity;
697  char *id;
698 
699  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Deleting attributes.\n");
700  if (strlen(GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) >= strlen(handle->url))
701  {
702  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "No identity given.\n");
704  return;
705  }
706  identity_id_str =
707  strdup(handle->url + strlen(GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES) + 1);
708  identity = strtok(identity_id_str, "/");
709  id = strtok(NULL, "/");
710  if ((NULL == identity) || (NULL == id))
711  {
712  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Malformed request.\n");
713  GNUNET_free(identity_id_str);
715  return;
716  }
717 
718  for (ego_entry = handle->ego_head; NULL != ego_entry;
719  ego_entry = ego_entry->next)
720  if (0 == strcmp(identity, ego_entry->identifier))
721  break;
722  handle->resp_object = json_array();
723  if (NULL == ego_entry)
724  {
725  // Done
726  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Ego %s not found.\n", identity);
727  GNUNET_free(identity_id_str);
729  return;
730  }
731  priv_key = GNUNET_IDENTITY_ego_get_private_key(ego_entry->ego);
732  handle->idp = GNUNET_RECLAIM_connect(cfg);
733  memset(&attr, 0, sizeof(struct GNUNET_RECLAIM_ATTRIBUTE_Claim));
734  GNUNET_STRINGS_string_to_data(id, strlen(id), &attr.id, sizeof(uint64_t));
735  attr.name = "";
736  handle->idp_op = GNUNET_RECLAIM_attribute_delete(handle->idp,
737  priv_key,
738  &attr,
740  handle);
741  GNUNET_free(identity_id_str);
742 }
#define GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES
Attribute namespace.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:553
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
Private ECC key encoded for transmission.
The request handle.
The ego list.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
json_t * resp_object
Response object.
struct GNUNET_RECLAIM_Operation * GNUNET_RECLAIM_attribute_delete(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr, GNUNET_RECLAIM_ContinuationWithStatus cont, void *cont_cls)
Delete an attribute.
Definition: reclaim_api.c:891
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
static void return_response(void *cls)
Return attributes for identity.
struct GNUNET_RECLAIM_Handle * idp
Identity Provider.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static void delete_finished_cb(void *cls, int32_t success, const char *emsg)
static void do_error(void *cls)
Task run on error, sends error message.
char * identifier
Ego Identifier.
struct EgoEntry * ego_head
Ego list.
#define GNUNET_log(kind,...)
struct GNUNET_RECLAIM_Operation * idp_op
Idp Operation.
struct GNUNET_RECLAIM_Handle * GNUNET_RECLAIM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the re:claimID service.
Definition: reclaim_api.c:774
struct EgoEntry * next
DLL.
int GNUNET_STRINGS_string_to_data(const char *enc, size_t enclen, void *out, size_t out_size)
Convert CrockfordBase32 encoding back to data.
Definition: strings.c:953
#define GNUNET_free(ptr)
Wrapper around free.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ revoke_ticket_cont()

static void revoke_ticket_cont ( struct GNUNET_REST_RequestHandle con_handle,
const char *  url,
void *  cls 
)
static

Definition at line 746 of file plugin_rest_reclaim.c.

References GNUNET_REST_RequestHandle::data, GNUNET_REST_RequestHandle::data_size, do_error(), EgoEntry::ego, RequestHandle::ego_head, RequestHandle::emsg, finished_cont(), GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_ego_get_public_key(), GNUNET_JSON_parse(), GNUNET_JSON_parse_free(), GNUNET_JSON_spec_end(), GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_RECLAIM_connect(), GNUNET_RECLAIM_JSON_spec_ticket(), GNUNET_RECLAIM_ticket_revoke(), GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, GNUNET_RECLAIM_Ticket::identity, RequestHandle::idp, RequestHandle::idp_op, EgoEntry::next, RequestHandle::rest_handle, and ticket.

Referenced by init_cont().

749 {
750  const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
751  struct RequestHandle *handle = cls;
752  struct EgoEntry *ego_entry;
753  struct GNUNET_RECLAIM_Ticket *ticket = NULL;
754  struct GNUNET_CRYPTO_EcdsaPublicKey tmp_pk;
755  char term_data[handle->rest_handle->data_size + 1];
756  json_t *data_json;
757  json_error_t err;
758  struct GNUNET_JSON_Specification tktspec[] =
760 
761  if (0 >= handle->rest_handle->data_size)
762  {
764  return;
765  }
766 
767  term_data[handle->rest_handle->data_size] = '\0';
768  GNUNET_memcpy(term_data,
769  handle->rest_handle->data,
770  handle->rest_handle->data_size);
771  data_json = json_loads(term_data, JSON_DECODE_ANY, &err);
772  if ((NULL == data_json) ||
773  (GNUNET_OK != GNUNET_JSON_parse(data_json, tktspec, NULL, NULL)))
774  {
775  handle->emsg = GNUNET_strdup("Not a ticket!\n");
777  GNUNET_JSON_parse_free(tktspec);
778  if (NULL != data_json)
779  json_decref(data_json);
780  return;
781  }
782  json_decref(data_json);
783  if (NULL == ticket)
784  {
786  "Unable to parse ticket from %s\n",
787  term_data);
789  return;
790  }
791 
792  for (ego_entry = handle->ego_head; NULL != ego_entry;
793  ego_entry = ego_entry->next)
794  {
795  GNUNET_IDENTITY_ego_get_public_key(ego_entry->ego, &tmp_pk);
796  if (0 == memcmp(&ticket->identity,
797  &tmp_pk,
798  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
799  break;
800  }
801  if (NULL == ego_entry)
802  {
803  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Identity unknown\n");
804  GNUNET_JSON_parse_free(tktspec);
805  return;
806  }
807  identity_priv = GNUNET_IDENTITY_ego_get_private_key(ego_entry->ego);
808 
809  handle->idp = GNUNET_RECLAIM_connect(cfg);
810  handle->idp_op = GNUNET_RECLAIM_ticket_revoke(handle->idp,
811  identity_priv,
812  ticket,
813  &finished_cont,
814  handle);
815  GNUNET_JSON_parse_free(tktspec);
816 }
The authorization ticket.
size_t data_size
The POST data size.
void GNUNET_JSON_parse_free(struct GNUNET_JSON_Specification *spec)
Frees all elements allocated during a GNUNET_JSON_parse() operation.
Definition: json.c:100
static void finished_cont(void *cls, int32_t success, const char *emsg)
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:553
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Entry in parser specification for GNUNET_JSON_parse().
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Private ECC key encoded for transmission.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
The ego list.
static struct GNUNET_RECLAIM_Ticket ticket
Ticket to consume.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
struct GNUNET_RECLAIM_Operation * GNUNET_RECLAIM_ticket_revoke(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, const struct GNUNET_RECLAIM_Ticket *ticket, GNUNET_RECLAIM_ContinuationWithStatus cb, void *cb_cls)
Revoked an issued ticket.
Definition: reclaim_api.c:1234
char * emsg
Error response message.
int GNUNET_JSON_parse(const json_t *root, struct GNUNET_JSON_Specification *spec, const char **error_json_name, unsigned int *error_line)
Navigate and parse data in a JSON tree.
Definition: json.c:45
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
struct GNUNET_REST_RequestHandle * rest_handle
Handle to rest request.
const char * data
The POST data.
struct GNUNET_CRYPTO_EcdsaPublicKey identity
The ticket issuer (= the user)
struct GNUNET_RECLAIM_Handle * idp
Identity Provider.
void GNUNET_IDENTITY_ego_get_public_key(const struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_CRYPTO_EcdsaPublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:566
static void do_error(void *cls)
Task run on error, sends error message.
struct EgoEntry * ego_head
Ego list.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
#define GNUNET_log(kind,...)
struct GNUNET_RECLAIM_Operation * idp_op
Idp Operation.
struct GNUNET_JSON_Specification GNUNET_JSON_spec_end(void)
End of a parser specification.
Definition: json_helper.c:35
struct GNUNET_RECLAIM_Handle * GNUNET_RECLAIM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the re:claimID service.
Definition: reclaim_api.c:774
struct EgoEntry * next
DLL.
struct GNUNET_JSON_Specification GNUNET_RECLAIM_JSON_spec_ticket(struct GNUNET_RECLAIM_Ticket **ticket)
JSON Specification for Reclaim tickets.
Definition: json_reclaim.c:247
Here is the call graph for this function:
Here is the caller graph for this function:

◆ consume_cont()

static void consume_cont ( void *  cls,
const struct GNUNET_CRYPTO_EcdsaPublicKey identity,
const struct GNUNET_RECLAIM_ATTRIBUTE_Claim attr 
)
static

Definition at line 819 of file plugin_rest_reclaim.c.

References GNUNET_RECLAIM_ATTRIBUTE_Claim::data, GNUNET_RECLAIM_ATTRIBUTE_Claim::data_size, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_RECLAIM_ATTRIBUTE_value_to_string(), GNUNET_SCHEDULER_add_now(), handle, GNUNET_RECLAIM_ATTRIBUTE_Claim::name, RequestHandle::resp_object, return_response(), GNUNET_RECLAIM_ATTRIBUTE_Claim::type, and value.

Referenced by consume_ticket_cont().

822 {
823  struct RequestHandle *handle = cls;
824  char *val_str;
825  json_t *value;
826 
827  if (NULL == identity)
828  {
830  return;
831  }
832 
833  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Adding attribute: %s\n", attr->name);
835  attr->data,
836  attr->data_size);
837  if (NULL == val_str)
838  {
840  "Failed to parse value for: %s\n",
841  attr->name);
842  return;
843  }
844  value = json_string(val_str);
845  json_object_set_new(handle->resp_object, attr->name, value);
846  json_decref(value);
847  GNUNET_free(val_str);
848 }
const char * name
The name of the attribute.
char * GNUNET_RECLAIM_ATTRIBUTE_value_to_string(uint32_t type, const void *data, size_t data_size)
Convert the &#39;claim&#39; of an attribute to a string.
size_t data_size
Number of bytes in data.
The request handle.
const void * data
Binary value stored as attribute value.
json_t * resp_object
Response object.
static char * value
Value of the record to add/remove.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void return_response(void *cls)
Return attributes for identity.
#define GNUNET_log(kind,...)
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ consume_ticket_cont()

static void consume_ticket_cont ( struct GNUNET_REST_RequestHandle con_handle,
const char *  url,
void *  cls 
)
static

Definition at line 851 of file plugin_rest_reclaim.c.

References GNUNET_RECLAIM_Ticket::audience, consume_cont(), GNUNET_REST_RequestHandle::data, GNUNET_REST_RequestHandle::data_size, do_error(), EgoEntry::ego, RequestHandle::ego_head, RequestHandle::emsg, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_ego_get_public_key(), GNUNET_JSON_parse(), GNUNET_JSON_parse_free(), GNUNET_JSON_spec_end(), GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_RECLAIM_connect(), GNUNET_RECLAIM_JSON_spec_ticket(), GNUNET_RECLAIM_ticket_consume(), GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, RequestHandle::idp, RequestHandle::idp_op, EgoEntry::next, RequestHandle::resp_object, RequestHandle::rest_handle, and ticket.

Referenced by init_cont().

854 {
855  const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity_priv;
856  struct RequestHandle *handle = cls;
857  struct EgoEntry *ego_entry;
859  struct GNUNET_CRYPTO_EcdsaPublicKey tmp_pk;
860  char term_data[handle->rest_handle->data_size + 1];
861  json_t *data_json;
862  json_error_t err;
863  struct GNUNET_JSON_Specification tktspec[] =
865 
866  if (0 >= handle->rest_handle->data_size)
867  {
869  return;
870  }
871 
872  term_data[handle->rest_handle->data_size] = '\0';
873  GNUNET_memcpy(term_data,
874  handle->rest_handle->data,
875  handle->rest_handle->data_size);
876  data_json = json_loads(term_data, JSON_DECODE_ANY, &err);
877  if (NULL == data_json)
878  {
880  "Unable to parse JSON Object from %s\n",
881  term_data);
883  return;
884  }
885  if (GNUNET_OK != GNUNET_JSON_parse(data_json, tktspec, NULL, NULL))
886  {
887  handle->emsg = GNUNET_strdup("Not a ticket!\n");
889  GNUNET_JSON_parse_free(tktspec);
890  json_decref(data_json);
891  return;
892  }
893  for (ego_entry = handle->ego_head; NULL != ego_entry;
894  ego_entry = ego_entry->next)
895  {
896  GNUNET_IDENTITY_ego_get_public_key(ego_entry->ego, &tmp_pk);
897  if (0 == memcmp(&ticket->audience,
898  &tmp_pk,
899  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
900  break;
901  }
902  if (NULL == ego_entry)
903  {
904  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Identity unknown\n");
905  GNUNET_JSON_parse_free(tktspec);
906  return;
907  }
908  identity_priv = GNUNET_IDENTITY_ego_get_private_key(ego_entry->ego);
909  handle->resp_object = json_object();
910  handle->idp = GNUNET_RECLAIM_connect(cfg);
911  handle->idp_op = GNUNET_RECLAIM_ticket_consume(handle->idp,
912  identity_priv,
913  ticket,
914  &consume_cont,
915  handle);
916  GNUNET_JSON_parse_free(tktspec);
917 }
The authorization ticket.
size_t data_size
The POST data size.
void GNUNET_JSON_parse_free(struct GNUNET_JSON_Specification *spec)
Frees all elements allocated during a GNUNET_JSON_parse() operation.
Definition: json.c:100
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:553
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Entry in parser specification for GNUNET_JSON_parse().
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Private ECC key encoded for transmission.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static void consume_cont(void *cls, const struct GNUNET_CRYPTO_EcdsaPublicKey *identity, const struct GNUNET_RECLAIM_ATTRIBUTE_Claim *attr)
The request handle.
The ego list.
static struct GNUNET_RECLAIM_Ticket ticket
Ticket to consume.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
json_t * resp_object
Response object.
char * emsg
Error response message.
int GNUNET_JSON_parse(const json_t *root, struct GNUNET_JSON_Specification *spec, const char **error_json_name, unsigned int *error_line)
Navigate and parse data in a JSON tree.
Definition: json.c:45
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
struct GNUNET_REST_RequestHandle * rest_handle
Handle to rest request.
const char * data
The POST data.
struct GNUNET_RECLAIM_Handle * idp
Identity Provider.
void GNUNET_IDENTITY_ego_get_public_key(const struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_CRYPTO_EcdsaPublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:566
static void do_error(void *cls)
Task run on error, sends error message.
struct EgoEntry * ego_head
Ego list.
struct GNUNET_CRYPTO_EcdsaPublicKey audience
The ticket audience (= relying party)
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
#define GNUNET_log(kind,...)
struct GNUNET_RECLAIM_Operation * idp_op
Idp Operation.
struct GNUNET_RECLAIM_Operation * GNUNET_RECLAIM_ticket_consume(struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *identity, const struct GNUNET_RECLAIM_Ticket *ticket, GNUNET_RECLAIM_AttributeResult cb, void *cb_cls)
Consumes an issued ticket.
Definition: reclaim_api.c:1095
struct GNUNET_JSON_Specification GNUNET_JSON_spec_end(void)
End of a parser specification.
Definition: json_helper.c:35
struct GNUNET_RECLAIM_Handle * GNUNET_RECLAIM_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the re:claimID service.
Definition: reclaim_api.c:774
struct EgoEntry * next
DLL.
struct GNUNET_JSON_Specification GNUNET_RECLAIM_JSON_spec_ticket(struct GNUNET_RECLAIM_Ticket **ticket)
JSON Specification for Reclaim tickets.
Definition: json_reclaim.c:247
Here is the call graph for this function:
Here is the caller graph for this function:

◆ options_cont()

static void options_cont ( struct GNUNET_REST_RequestHandle con_handle,
const char *  url,
void *  cls 
)
static

Respond to OPTIONS request.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 928 of file plugin_rest_reclaim.c.

References allow_methods, cleanup_handle(), GNUNET_REST_create_response(), handle, RequestHandle::proc, and RequestHandle::proc_cls.

Referenced by init_cont().

931 {
932  struct MHD_Response *resp;
933  struct RequestHandle *handle = cls;
934 
935  // For now, independent of path return all options
936  resp = GNUNET_REST_create_response(NULL);
937  MHD_add_response_header(resp, "Access-Control-Allow-Methods", allow_methods);
938  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
939  cleanup_handle(handle);
940  return;
941 }
GNUNET_REST_ResultProcessor proc
The plugin result processor.
void * proc_cls
The closure of the result processor.
The request handle.
static char * allow_methods
HTTP methods allows for this plugin.
static void cleanup_handle(struct RequestHandle *handle)
Cleanup lookup handle.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
Here is the call graph for this function:
Here is the caller graph for this function:

◆ init_cont()

static void init_cont ( struct RequestHandle handle)
static

Handle rest request.

Parameters
handlethe request handle

Definition at line 949 of file plugin_rest_reclaim.c.

References add_attribute_cont(), consume_ticket_cont(), delete_attribute_cont(), do_error(), GNUNET_REST_RequestHandlerError::error_code, GNUNET_NO, GNUNET_REST_API_NS_IDENTITY_CONSUME, GNUNET_REST_API_NS_IDENTITY_REVOKE, GNUNET_REST_API_NS_IDENTITY_TICKETS, GNUNET_REST_API_NS_RECLAIM, GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES, GNUNET_REST_handle_request(), GNUNET_REST_HANDLER_END, GNUNET_SCHEDULER_add_now(), list_attribute_cont(), list_tickets_cont(), options_cont(), RequestHandle::response_code, RequestHandle::rest_handle, and revoke_ticket_cont().

Referenced by list_ego().

950 {
952  static const struct GNUNET_REST_RequestHandler handlers[] =
953  { { MHD_HTTP_METHOD_GET,
956  { MHD_HTTP_METHOD_POST,
959  { MHD_HTTP_METHOD_DELETE,
962  { MHD_HTTP_METHOD_GET,
965  { MHD_HTTP_METHOD_POST,
968  { MHD_HTTP_METHOD_POST,
971  { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_RECLAIM, &options_cont },
973 
974  if (GNUNET_NO ==
975  GNUNET_REST_handle_request(handle->rest_handle, handlers, &err, handle))
976  {
977  handle->response_code = err.error_code;
979  }
980 }
static void list_attribute_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
List attributes for identity request.
#define GNUNET_REST_API_NS_RECLAIM_ATTRIBUTES
Attribute namespace.
static void consume_ticket_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
static void add_attribute_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
#define GNUNET_REST_API_NS_IDENTITY_CONSUME
Revoke namespace.
#define GNUNET_NO
Definition: gnunet_common.h:78
static void options_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Respond to OPTIONS request.
#define GNUNET_REST_HANDLER_END
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
static void list_tickets_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
List tickets for identity request.
int GNUNET_REST_handle_request(struct GNUNET_REST_RequestHandle *conn, const struct GNUNET_REST_RequestHandler *handlers, struct GNUNET_REST_RequestHandlerError *err, void *cls)
Definition: rest.c:75
struct GNUNET_REST_RequestHandle * rest_handle
Handle to rest request.
int response_code
HTTP response code.
#define GNUNET_REST_API_NS_RECLAIM
REST root namespace.
static void delete_attribute_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
List attributes for identity request.
#define GNUNET_REST_API_NS_IDENTITY_REVOKE
Revoke namespace.
static void do_error(void *cls)
Task run on error, sends error message.
static void revoke_ticket_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
#define GNUNET_REST_API_NS_IDENTITY_TICKETS
Ticket namespace.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ list_ego()

static void list_ego ( void *  cls,
struct GNUNET_IDENTITY_Ego ego,
void **  ctx,
const char *  identifier 
)
static

If listing is enabled, prints information about the egos.

This function is initially called for all egos and then again whenever a ego's identifier changes or if it is deleted. At the end of the initial pass over all egos, the function is once called with 'NULL' for 'ego'. That does NOT mean that the callback won't be invoked in the future or that there was an error.

When used with 'GNUNET_IDENTITY_create' or 'GNUNET_IDENTITY_get', this function is only called ONCE, and 'NULL' being passed in 'ego' does indicate an error (i.e. name is taken or no default value is known). If 'ego' is non-NULL and if '*ctx' is set in those callbacks, the value WILL be passed to a subsequent call to the identity callback of 'GNUNET_IDENTITY_connect' (if that one was not NULL).

When an identity is renamed, this function is called with the (known) ego but the NEW identifier.

When an identity is deleted, this function is called with the (known) ego and "NULL" for the 'identifier'. In this case, the 'ego' is henceforth invalid (and the 'ctx' should also be cleaned up).

Parameters
clsclosure
egoego handle
ctxcontext for application to store data for this ego (during the lifetime of this process, initially NULL)
identifieridentifier assigned by the user for this ego, NULL if the user just deleted the ego and it must thus no longer be used

Definition at line 1016 of file plugin_rest_reclaim.c.

References EgoEntry::ego, RequestHandle::ego_head, RequestHandle::ego_tail, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_ecdsa_public_key_to_string(), GNUNET_IDENTITY_ego_get_public_key(), GNUNET_new, GNUNET_strdup, handle, ID_REST_STATE_INIT, ID_REST_STATE_POST_INIT, EgoEntry::identifier, init_cont(), EgoEntry::keystring, and RequestHandle::state.

Referenced by rest_identity_process_request().

1020 {
1021  struct RequestHandle *handle = cls;
1022  struct EgoEntry *ego_entry;
1024 
1025  if ((NULL == ego) && (ID_REST_STATE_INIT == handle->state))
1026  {
1027  handle->state = ID_REST_STATE_POST_INIT;
1028  init_cont(handle);
1029  return;
1030  }
1031  if (ID_REST_STATE_INIT == handle->state)
1032  {
1033  ego_entry = GNUNET_new(struct EgoEntry);
1036  ego_entry->ego = ego;
1037  ego_entry->identifier = GNUNET_strdup(identifier);
1039  handle->ego_tail,
1040  ego_entry);
1041  }
1042 }
static struct GNUNET_CRYPTO_EddsaPrivateKey * pk
Private key of this peer.
struct EgoEntry * ego_tail
Ego list.
static void init_cont(struct RequestHandle *handle)
Handle rest request.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
The ego list.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
#define ID_REST_STATE_INIT
State while collecting all egos.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
#define ID_REST_STATE_POST_INIT
Done collecting egos.
int state
The processing state.
char * GNUNET_CRYPTO_ecdsa_public_key_to_string(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a public key to a string.
Definition: crypto_ecc.c:334
char * keystring
Public key string.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
void GNUNET_IDENTITY_ego_get_public_key(const struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_CRYPTO_EcdsaPublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:566
char * identifier
Ego Identifier.
struct EgoEntry * ego_head
Ego list.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
Here is the call graph for this function:
Here is the caller graph for this function:

◆ rest_identity_process_request()

static void rest_identity_process_request ( struct GNUNET_REST_RequestHandle rest_handle,
GNUNET_REST_ResultProcessor  proc,
void *  proc_cls 
)
static

Definition at line 1045 of file plugin_rest_reclaim.c.

References do_timeout(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_IDENTITY_connect(), GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_REL, handle, ID_REST_STATE_INIT, RequestHandle::identity_handle, list_ego(), RequestHandle::proc, RequestHandle::proc_cls, RequestHandle::response_code, RequestHandle::rest_handle, RequestHandle::state, RequestHandle::timeout, RequestHandle::timeout_task, GNUNET_REST_RequestHandle::url, and RequestHandle::url.

Referenced by libgnunet_plugin_rest_reclaim_init().

1048 {
1049  struct RequestHandle *handle = GNUNET_new(struct RequestHandle);
1050 
1051  handle->response_code = 0;
1053  handle->proc_cls = proc_cls;
1054  handle->proc = proc;
1055  handle->state = ID_REST_STATE_INIT;
1056  handle->rest_handle = rest_handle;
1057 
1058  handle->url = GNUNET_strdup(rest_handle->url);
1059  if (handle->url[strlen(handle->url) - 1] == '/')
1060  handle->url[strlen(handle->url) - 1] = '\0';
1061  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
1062  handle->identity_handle = GNUNET_IDENTITY_connect(cfg, &list_ego, handle);
1063  handle->timeout_task =
1064  GNUNET_SCHEDULER_add_delayed(handle->timeout, &do_timeout, handle);
1065  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
1066 }
struct GNUNET_IDENTITY_Handle * GNUNET_IDENTITY_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Connect to the identity service.
Definition: identity_api.c:525
static void list_ego(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *identifier)
If listing is enabled, prints information about the egos.
GNUNET_REST_ResultProcessor proc
The plugin result processor.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void * proc_cls
The closure of the result processor.
The request handle.
#define ID_REST_STATE_INIT
State while collecting all egos.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1237
const char * url
The url as string.
struct GNUNET_TIME_Relative timeout
Timeout.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
struct GNUNET_REST_RequestHandle * rest_handle
Handle to rest request.
int response_code
HTTP response code.
int state
The processing state.
struct GNUNET_SCHEDULER_Task * timeout_task
ID of a task associated with the resolution process.
static void do_timeout(void *cls)
Task run on timeout, sends error message.
#define GNUNET_log(kind,...)
struct GNUNET_IDENTITY_Handle * identity_handle
Handle to Identity service.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ libgnunet_plugin_rest_reclaim_init()

void* libgnunet_plugin_rest_reclaim_init ( void *  cls)

Entry point for the plugin.

Parameters
clsConfig info
Returns
NULL on error, otherwise the plugin context

Definition at line 1075 of file plugin_rest_reclaim.c.

References _, allow_methods, Plugin::api, Plugin::cfg, GNUNET_REST_Plugin::cls, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_REST_API_NS_RECLAIM, GNUNET_REST_Plugin::name, plugin, GNUNET_REST_Plugin::process_request, and rest_identity_process_request().

1076 {
1077  static struct Plugin plugin;
1078  struct GNUNET_REST_Plugin *api;
1079 
1080  cfg = cls;
1081  if (NULL != plugin.cfg)
1082  return NULL; /* can only initialize once! */
1083  memset(&plugin, 0, sizeof(struct Plugin));
1084  plugin.cfg = cfg;
1085  api = GNUNET_new(struct GNUNET_REST_Plugin);
1086  api->cls = &plugin;
1090  "%s, %s, %s, %s, %s",
1091  MHD_HTTP_METHOD_GET,
1092  MHD_HTTP_METHOD_POST,
1093  MHD_HTTP_METHOD_PUT,
1094  MHD_HTTP_METHOD_DELETE,
1095  MHD_HTTP_METHOD_OPTIONS);
1096 
1098  _("Identity Provider REST API initialized\n"));
1099  return api;
1100 }
void * cls
The closure of the plugin.
struct returned by the initialization function of the plugin
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void(* process_request)(struct GNUNET_REST_RequestHandle *handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
Function to process a REST call.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
static void rest_identity_process_request(struct GNUNET_REST_RequestHandle *rest_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static char * allow_methods
HTTP methods allows for this plugin.
char * name
Plugin name.
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
#define GNUNET_REST_API_NS_RECLAIM
REST root namespace.
Handle for a plugin.
Definition: block.c:37
#define GNUNET_log(kind,...)
Here is the call graph for this function:

◆ libgnunet_plugin_rest_reclaim_done()

void* libgnunet_plugin_rest_reclaim_done ( void *  cls)

Exit point from the plugin.

Parameters
clsthe plugin context (as returned by "init")
Returns
always NULL

Definition at line 1110 of file plugin_rest_reclaim.c.

References allow_methods, Plugin::api, Plugin::cfg, GNUNET_REST_Plugin::cls, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_free_non_null, GNUNET_log, and plugin.

1111 {
1112  struct GNUNET_REST_Plugin *api = cls;
1113  struct Plugin *plugin = api->cls;
1114 
1115  plugin->cfg = NULL;
1116 
1118  GNUNET_free(api);
1120  "Identity Provider REST plugin is finished\n");
1121  return NULL;
1122 }
void * cls
The closure of the plugin.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
struct returned by the initialization function of the plugin
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
static char * allow_methods
HTTP methods allows for this plugin.
Handle for a plugin.
Definition: block.c:37
#define GNUNET_log(kind,...)
#define GNUNET_free(ptr)
Wrapper around free.

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

The configuration handle.

Handle to our configuration.

Definition at line 79 of file plugin_rest_reclaim.c.

◆ allow_methods

char* allow_methods
static

HTTP methods allows for this plugin.

Definition at line 84 of file plugin_rest_reclaim.c.

Referenced by libgnunet_plugin_rest_reclaim_done(), libgnunet_plugin_rest_reclaim_init(), and options_cont().