GNUnet  0.19.2
plugin_rest_identity.c File Reference

GNUnet Identity REST plugin. More...

#include "platform.h"
#include "gnunet_rest_plugin.h"
#include "gnunet_identity_service.h"
#include "gnunet_rest_lib.h"
#include "identity.h"
#include "gnunet_util_lib.h"
#include "microhttpd.h"
#include <jansson.h>
Include dependency graph for plugin_rest_identity.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...
 
struct  ego_sign_data_cls
 

Macros

#define GNUNET_REST_API_NS_IDENTITY   "/identity"
 Identity Namespace. More...
 
#define GNUNET_REST_API_NS_IDENTITY_PUBKEY   "/identity/pubkey"
 Identity Namespace with public key specifier. More...
 
#define GNUNET_REST_API_NS_IDENTITY_NAME   "/identity/name"
 Identity Namespace with public key specifier. More...
 
#define GNUNET_REST_API_NS_SIGN   "/sign"
 Identity Namespace with sign specifier. More...
 
#define GNUNET_REST_IDENTITY_PARAM_PUBKEY   "pubkey"
 Parameter public key. More...
 
#define GNUNET_REST_IDENTITY_PARAM_PRIVKEY   "privkey"
 Parameter private key. More...
 
#define GNUNET_REST_IDENTITY_PARAM_NAME   "name"
 Parameter name. More...
 
#define GNUNET_REST_IDENTITY_PARAM_NEWNAME   "newname"
 Parameter new name. More...
 
#define GNUNET_REST_IDENTITY_MISSING_NAME   "Missing identity name"
 Error message Missing identity name. More...
 
#define GNUNET_REST_IDENTITY_MISSING_PUBKEY   "Missing identity public key"
 Error message Missing identity name. More...
 
#define GNUNET_REST_ERROR_NO_DATA   "No data"
 Error message No data. More...
 
#define GNUNET_REST_ERROR_DATA_INVALID   "Data invalid"
 Error message Data invalid. 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 (void *cls)
 Cleanup lookup handle. More...
 
static void do_error (void *cls)
 Task run on errors. More...
 
struct EgoEntryget_egoentry (struct RequestHandle *handle, char *pubkey, char *name)
 Get EgoEntry from list with either a public key or a name If public key and name are not NULL, it returns the public key result first. More...
 
void ego_get_all (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity GET request - responds with all identities. More...
 
void ego_get_response (struct RequestHandle *handle, struct EgoEntry *ego_entry)
 Responds with the ego_entry identity. More...
 
void ego_get_pubkey (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity GET request with a public key. More...
 
void ego_get_name (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity GET request with a name. More...
 
static void do_finished (void *cls, enum GNUNET_ErrorCode ec)
 Processing finished. More...
 
static void do_finished_create (void *cls, const struct GNUNET_IDENTITY_PrivateKey *pk, enum GNUNET_ErrorCode ec)
 Processing finished, when creating an ego. More...
 
void ego_edit (struct RequestHandle *handle, struct EgoEntry *ego_entry)
 Processing edit ego with EgoEntry ego_entry. More...
 
void ego_edit_pubkey (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity PUT request with public key. More...
 
void ego_edit_name (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity PUT request with name. More...
 
void ego_create (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity POST request. More...
 
void ego_delete_pubkey (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity DELETE request with public key. More...
 
void ego_delete_name (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity DELETE request with name. More...
 
void ego_sign_data_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego)
 
void ego_sign_data (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 list_ego (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *identifier)
 
static enum GNUNET_GenericReturnValue rest_process_request (struct GNUNET_REST_RequestHandle *rest_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
 Function processing the REST call. More...
 
void * libgnunet_plugin_rest_identity_init (void *cls)
 Entry point for the plugin. More...
 
void * libgnunet_plugin_rest_identity_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...
 
static struct EgoEntryego_head
 Ego list. More...
 
static struct EgoEntryego_tail
 Ego list. More...
 
static int state
 The processing state. More...
 
static struct GNUNET_IDENTITY_Handleidentity_handle
 Handle to Identity service. More...
 
static struct RequestHandlerequests_head
 DLL. More...
 
static struct RequestHandlerequests_tail
 DLL. More...
 

Detailed Description

GNUnet Identity REST plugin.

Author
Martin Schanzenbach
Philippe Buschmann

Definition in file plugin_rest_identity.c.

Macro Definition Documentation

◆ GNUNET_REST_API_NS_IDENTITY

#define GNUNET_REST_API_NS_IDENTITY   "/identity"

Identity Namespace.

Definition at line 39 of file plugin_rest_identity.c.

◆ GNUNET_REST_API_NS_IDENTITY_PUBKEY

#define GNUNET_REST_API_NS_IDENTITY_PUBKEY   "/identity/pubkey"

Identity Namespace with public key specifier.

Definition at line 44 of file plugin_rest_identity.c.

◆ GNUNET_REST_API_NS_IDENTITY_NAME

#define GNUNET_REST_API_NS_IDENTITY_NAME   "/identity/name"

Identity Namespace with public key specifier.

Definition at line 49 of file plugin_rest_identity.c.

◆ GNUNET_REST_API_NS_SIGN

#define GNUNET_REST_API_NS_SIGN   "/sign"

Identity Namespace with sign specifier.

Definition at line 54 of file plugin_rest_identity.c.

◆ GNUNET_REST_IDENTITY_PARAM_PUBKEY

#define GNUNET_REST_IDENTITY_PARAM_PUBKEY   "pubkey"

Parameter public key.

Definition at line 59 of file plugin_rest_identity.c.

◆ GNUNET_REST_IDENTITY_PARAM_PRIVKEY

#define GNUNET_REST_IDENTITY_PARAM_PRIVKEY   "privkey"

Parameter private key.

Definition at line 64 of file plugin_rest_identity.c.

◆ GNUNET_REST_IDENTITY_PARAM_NAME

#define GNUNET_REST_IDENTITY_PARAM_NAME   "name"

Parameter name.

Definition at line 69 of file plugin_rest_identity.c.

◆ GNUNET_REST_IDENTITY_PARAM_NEWNAME

#define GNUNET_REST_IDENTITY_PARAM_NEWNAME   "newname"

Parameter new name.

Definition at line 74 of file plugin_rest_identity.c.

◆ GNUNET_REST_IDENTITY_MISSING_NAME

#define GNUNET_REST_IDENTITY_MISSING_NAME   "Missing identity name"

Error message Missing identity name.

Definition at line 79 of file plugin_rest_identity.c.

◆ GNUNET_REST_IDENTITY_MISSING_PUBKEY

#define GNUNET_REST_IDENTITY_MISSING_PUBKEY   "Missing identity public key"

Error message Missing identity name.

Definition at line 84 of file plugin_rest_identity.c.

◆ GNUNET_REST_ERROR_NO_DATA

#define GNUNET_REST_ERROR_NO_DATA   "No data"

Error message No data.

Definition at line 89 of file plugin_rest_identity.c.

◆ GNUNET_REST_ERROR_DATA_INVALID

#define GNUNET_REST_ERROR_DATA_INVALID   "Data invalid"

Error message Data invalid.

Definition at line 94 of file plugin_rest_identity.c.

◆ ID_REST_STATE_INIT

#define ID_REST_STATE_INIT   0

State while collecting all egos.

Definition at line 99 of file plugin_rest_identity.c.

◆ ID_REST_STATE_POST_INIT

#define ID_REST_STATE_POST_INIT   1

Done collecting egos.

Definition at line 104 of file plugin_rest_identity.c.

Function Documentation

◆ cleanup_handle()

static void cleanup_handle ( void *  cls)
static

Cleanup lookup handle.

Parameters
clsHandle to clean up

Definition at line 261 of file plugin_rest_identity.c.

262 {
263  struct RequestHandle *handle = cls;
264 
265  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
266  if (NULL != handle->timeout_task)
267  {
268  GNUNET_SCHEDULER_cancel (handle->timeout_task);
269  handle->timeout_task = NULL;
270  }
271 
272  if (NULL != handle->url)
273  GNUNET_free (handle->url);
274  if (NULL != handle->name)
275  GNUNET_free (handle->name);
278  handle);
280 }
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_DEBUG
#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:944
static struct RequestHandle * requests_head
DLL.
static struct RequestHandle * requests_tail
DLL.
The request handle.

References GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_cancel(), handle, requests_head, and requests_tail.

Referenced by do_error(), do_finished(), ego_get_all(), ego_get_response(), ego_sign_data_cb(), libgnunet_plugin_rest_identity_done(), and options_cont().

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 errors.

Reports an error and cleans up everything.

Parameters
clsthe struct RequestHandle

Definition at line 289 of file plugin_rest_identity.c.

290 {
291  struct RequestHandle *handle = cls;
292  struct MHD_Response *resp;
293  json_t *json_error = json_object ();
294  char *response;
295  int response_code;
296 
297  json_object_set_new (json_error, "error",
298  json_string (GNUNET_ErrorCode_get_hint (handle->ec)));
299  json_object_set_new (json_error, "error_code", json_integer (handle->ec));
300  response_code = GNUNET_ErrorCode_get_http_status (handle->ec);
301  if (0 == response_code)
302  response_code = MHD_HTTP_OK;
303  response = json_dumps (json_error, 0);
305  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
306  "Content-Type",
307  "application/json"));
308  handle->proc (handle->proc_cls, resp, response_code);
309  json_decref (json_error);
312 }
const char * GNUNET_ErrorCode_get_hint(enum GNUNET_ErrorCode ec)
Returns a hint for a given error code.
unsigned int GNUNET_ErrorCode_get_http_status(enum GNUNET_ErrorCode ec)
Return HTTP status for a given error code.
static struct MHD_Response * response
Our canonical response.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:44
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:1268
@ MHD_HTTP_OK
OK [RFC7231, Section 6.3.1].
static void cleanup_handle(void *cls)
Cleanup lookup handle.

References cleanup_handle(), GNUNET_assert, GNUNET_ErrorCode_get_hint(), GNUNET_ErrorCode_get_http_status(), GNUNET_free, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), handle, MHD_HTTP_OK, and response.

Referenced by do_finished(), ego_create(), ego_delete_name(), ego_delete_pubkey(), ego_edit(), ego_edit_name(), ego_edit_pubkey(), ego_get_name(), ego_get_pubkey(), ego_sign_data(), and ego_sign_data_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_egoentry()

struct EgoEntry* get_egoentry ( struct RequestHandle handle,
char *  pubkey,
char *  name 
)

Get EgoEntry from list with either a public key or a name If public key and name are not NULL, it returns the public key result first.

Parameters
handlethe RequestHandle
pubkeythe public key of an identity (only one can be NULL)
namethe name of an identity (only one can be NULL)
Returns
EgoEntry or NULL if not found

Definition at line 325 of file plugin_rest_identity.c.

326 {
327  struct EgoEntry *ego_entry;
328 
329  if (NULL != pubkey)
330  {
331  for (ego_entry = ego_head; NULL != ego_entry;
332  ego_entry = ego_entry->next)
333  {
334  if (0 != strcasecmp (pubkey, ego_entry->keystring))
335  continue;
336  return ego_entry;
337  }
338  }
339  if (NULL != name)
340  {
341  for (ego_entry = ego_head; NULL != ego_entry;
342  ego_entry = ego_entry->next)
343  {
344  if (0 != strcasecmp (name, ego_entry->identifier))
345  continue;
346  return ego_entry;
347  }
348  }
349  return NULL;
350 }
static struct GNUNET_IDENTITY_PublicKey pubkey
Public key of the zone to look in.
const char * name
static struct EgoEntry * ego_head
Ego list.
The ego list.
char * identifier
Ego Identifier.
char * keystring
Public key string.
struct EgoEntry * next
DLL.

References ego_head, EgoEntry::identifier, EgoEntry::keystring, name, EgoEntry::next, and pubkey.

Referenced by ego_delete_name(), ego_delete_pubkey(), ego_edit_name(), ego_edit_pubkey(), ego_get_name(), and ego_get_pubkey().

Here is the caller graph for this function:

◆ ego_get_all()

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

Handle identity GET request - responds with all identities.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 361 of file plugin_rest_identity.c.

364 {
365  struct RequestHandle *handle = cls;
366  struct EgoEntry *ego_entry;
367  struct MHD_Response *resp;
368  struct GNUNET_HashCode key;
369  json_t *json_root;
370  json_t *json_ego;
371  char *result_str;
372  char *privkey_str;
373 
374  json_root = json_array ();
375  // Return ego/egos
376  for (ego_entry = ego_head; NULL != ego_entry;
377  ego_entry = ego_entry->next)
378  {
379  json_ego = json_object ();
380  json_object_set_new (json_ego,
382  json_string (ego_entry->keystring));
383  GNUNET_CRYPTO_hash ("private", strlen ("private"), &key);
384  if (GNUNET_YES ==
386  handle->rest_handle->url_param_map, &key))
387  {
390  json_object_set_new (json_ego,
392  json_string (privkey_str));
393  GNUNET_free (privkey_str);
394  }
395 
396  json_object_set_new (json_ego,
398  json_string (ego_entry->identifier));
399  json_array_append (json_root, json_ego);
400  json_decref (json_ego);
401  }
402 
403  result_str = json_dumps (json_root, 0);
404  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
405  resp = GNUNET_REST_create_response (result_str);
406  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
407  "Content-Type",
408  "application/json"));
409  json_decref (json_root);
410  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
411  GNUNET_free (result_str);
413 }
struct GNUNET_HashCode key
The key used in the DHT.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL).
const struct GNUNET_IDENTITY_PrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:560
char * GNUNET_IDENTITY_private_key_to_string(const struct GNUNET_IDENTITY_PrivateKey *key)
Creates a (Base32) string representation of the private key.
@ GNUNET_YES
#define GNUNET_REST_IDENTITY_PARAM_NAME
Parameter name.
#define GNUNET_REST_IDENTITY_PARAM_PRIVKEY
Parameter private key.
#define GNUNET_REST_IDENTITY_PARAM_PUBKEY
Parameter public key.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
A 512-bit hashcode.

References cleanup_handle(), EgoEntry::ego, ego_head, GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_private_key_to_string(), GNUNET_log, GNUNET_REST_create_response(), GNUNET_REST_IDENTITY_PARAM_NAME, GNUNET_REST_IDENTITY_PARAM_PRIVKEY, GNUNET_REST_IDENTITY_PARAM_PUBKEY, GNUNET_SCHEDULER_add_now(), GNUNET_YES, handle, EgoEntry::identifier, key, EgoEntry::keystring, MHD_HTTP_OK, and EgoEntry::next.

Here is the call graph for this function:

◆ ego_get_response()

void ego_get_response ( struct RequestHandle handle,
struct EgoEntry ego_entry 
)

Responds with the ego_entry identity.

Parameters
handlethe struct RequestHandle
ego_entrythe struct EgoEntry for the response

Definition at line 423 of file plugin_rest_identity.c.

424 {
425  struct MHD_Response *resp;
426  struct GNUNET_HashCode key;
427  json_t *json_ego;
428  char *result_str;
429  char *privkey_str;
430 
431  json_ego = json_object ();
432  json_object_set_new (json_ego,
434  json_string (ego_entry->keystring));
435  json_object_set_new (json_ego,
437  json_string (ego_entry->identifier));
438  GNUNET_CRYPTO_hash ("private", strlen ("private"), &key);
439  if (GNUNET_YES ==
441  handle->rest_handle->url_param_map, &key))
442  {
445  json_object_set_new (json_ego,
447  json_string (privkey_str));
448  GNUNET_free (privkey_str);
449  }
450 
451  result_str = json_dumps (json_ego, 0);
452  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
453  resp = GNUNET_REST_create_response (result_str);
454  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
455  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
456  "Content-Type",
457  "application/json"));
458  json_decref (json_ego);
459  GNUNET_free (result_str);
461 }

References cleanup_handle(), EgoEntry::ego, GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_private_key_to_string(), GNUNET_log, GNUNET_REST_create_response(), GNUNET_REST_IDENTITY_PARAM_NAME, GNUNET_REST_IDENTITY_PARAM_PRIVKEY, GNUNET_REST_IDENTITY_PARAM_PUBKEY, GNUNET_SCHEDULER_add_now(), GNUNET_YES, handle, EgoEntry::identifier, key, EgoEntry::keystring, and MHD_HTTP_OK.

Referenced by ego_get_name(), and ego_get_pubkey().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_get_pubkey()

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

Handle identity GET request with a public key.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 472 of file plugin_rest_identity.c.

475 {
476  struct RequestHandle *handle = cls;
477  struct EgoEntry *ego_entry;
478  char *keystring;
479 
480  keystring = NULL;
481 
482  if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
483  {
486  return;
487  }
489  ego_entry = get_egoentry (handle, keystring, NULL);
490 
491  if (NULL == ego_entry)
492  {
495  return;
496  }
497 
498  ego_get_response (handle, ego_entry);
499 }
@ GNUNET_EC_IDENTITY_NOT_FOUND
Ego not found.
struct EgoEntry * get_egoentry(struct RequestHandle *handle, char *pubkey, char *name)
Get EgoEntry from list with either a public key or a name If public key and name are not NULL,...
void ego_get_response(struct RequestHandle *handle, struct EgoEntry *ego_entry)
Responds with the ego_entry identity.
#define GNUNET_REST_API_NS_IDENTITY_PUBKEY
Identity Namespace with public key specifier.
static void do_error(void *cls)
Task run on errors.

References do_error(), ego_get_response(), get_egoentry(), GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_REST_API_NS_IDENTITY_PUBKEY, GNUNET_SCHEDULER_add_now(), handle, and EgoEntry::keystring.

Here is the call graph for this function:

◆ ego_get_name()

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

Handle identity GET request with a name.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 510 of file plugin_rest_identity.c.

513 {
514  struct RequestHandle *handle = cls;
515  struct EgoEntry *ego_entry;
516  char *egoname;
517 
518  egoname = NULL;
519 
520  if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
521  {
524  return;
525  }
526  egoname = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
527  ego_entry = get_egoentry (handle, NULL, egoname);
528 
529  if (NULL == ego_entry)
530  {
533  return;
534  }
535 
536  ego_get_response (handle, ego_entry);
537 }
static char * egoname
Ego Attribut String.
Definition: gnunet-did.c:96
#define GNUNET_REST_API_NS_IDENTITY_NAME
Identity Namespace with public key specifier.

References do_error(), ego_get_response(), egoname, get_egoentry(), GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_REST_API_NS_IDENTITY_NAME, GNUNET_SCHEDULER_add_now(), and handle.

Here is the call graph for this function:

◆ do_finished()

static void do_finished ( void *  cls,
enum GNUNET_ErrorCode  ec 
)
static

Processing finished.

Parameters
clsrequest handle
ecerror code

Definition at line 547 of file plugin_rest_identity.c.

548 {
549  struct RequestHandle *handle = cls;
550  struct MHD_Response *resp;
551  int response_code;
552 
553  handle->op = NULL;
554  handle->ec = ec;
555  if (GNUNET_EC_NONE != ec)
556  {
558  return;
559  }
560  if (GNUNET_EC_NONE == handle->ec)
561  response_code = MHD_HTTP_NO_CONTENT;
562  else
563  response_code = GNUNET_ErrorCode_get_http_status (ec);
564  resp = GNUNET_REST_create_response (NULL);
565  handle->proc (handle->proc_cls, resp, response_code);
567 }
@ GNUNET_EC_NONE
No error (success).
@ MHD_HTTP_NO_CONTENT
No Content [RFC7231, Section 6.3.5].

References cleanup_handle(), do_error(), GNUNET_EC_NONE, GNUNET_ErrorCode_get_http_status(), GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), handle, and MHD_HTTP_NO_CONTENT.

Referenced by do_finished_create(), ego_delete_name(), ego_delete_pubkey(), and ego_edit().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_finished_create()

static void do_finished_create ( void *  cls,
const struct GNUNET_IDENTITY_PrivateKey pk,
enum GNUNET_ErrorCode  ec 
)
static

Processing finished, when creating an ego.

Parameters
clsrequest handle
pkprivate key of the ego, or NULL on error
ecerror code

Definition at line 578 of file plugin_rest_identity.c.

581 {
582  struct RequestHandle *handle = cls;
583 
584  (void) pk;
585  do_finished (handle, ec);
586 }
struct GNUNET_IDENTITY_PrivateKey pk
Private key from command line option, or NULL.
static void do_finished(void *cls, enum GNUNET_ErrorCode ec)
Processing finished.
enum GNUNET_ErrorCode ec
Error code.

References do_finished(), RequestHandle::ec, handle, and pk.

Referenced by ego_create().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_edit()

void ego_edit ( struct RequestHandle handle,
struct EgoEntry ego_entry 
)

Processing edit ego with EgoEntry ego_entry.

Parameters
handlethe struct RequestHandle
ego_entrythe struct EgoEntry we want to edit

Definition at line 596 of file plugin_rest_identity.c.

597 {
598  json_t *data_js;
599  json_error_t err;
600  char *newname;
601  char term_data[handle->data_size + 1];
602  int json_state;
603 
604  // if no data
605  if (0 >= handle->data_size)
606  {
609  return;
610  }
611  // if not json
612  term_data[handle->data_size] = '\0';
613  GNUNET_memcpy (term_data, handle->data, handle->data_size);
614  data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
615 
616  if (NULL == data_js)
617  {
620  return;
621  }
622 
623  newname = NULL;
624  // NEW NAME
625  json_state = 0;
626  json_state = json_unpack (data_js,
627  "{s:s!}",
629  &newname);
630  // Change name with pubkey or name identifier
631  if (0 != json_state)
632  {
635  json_decref (data_js);
636  return;
637  }
638 
639  if (NULL == newname)
640  {
643  json_decref (data_js);
644  return;
645  }
646 
647  if (0 >= strlen (newname))
648  {
651  json_decref (data_js);
652  return;
653  }
654 
656  ego_entry->identifier,
657  newname,
658  &do_finished,
659  handle);
660  if (NULL == handle->op)
661  {
664  json_decref (data_js);
665  return;
666  }
667  json_decref (data_js);
668  return;
669 }
@ GNUNET_EC_UNKNOWN
Unknown and unspecified error.
@ GNUNET_EC_IDENTITY_INVALID
The given ego is invalid or malformed.
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_rename(struct GNUNET_IDENTITY_Handle *h, const char *old_name, const char *new_name, GNUNET_IDENTITY_Continuation cb, void *cb_cls)
Renames an existing identity.
Definition: identity_api.c:646
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_REST_IDENTITY_PARAM_NEWNAME
Parameter new name.
static struct GNUNET_IDENTITY_Handle * identity_handle
Handle to Identity service.

References do_error(), do_finished(), RequestHandle::ego_entry, GNUNET_EC_IDENTITY_INVALID, GNUNET_EC_UNKNOWN, GNUNET_IDENTITY_rename(), GNUNET_memcpy, GNUNET_REST_IDENTITY_PARAM_NEWNAME, GNUNET_SCHEDULER_add_now(), handle, EgoEntry::identifier, and identity_handle.

Referenced by ego_edit_name(), and ego_edit_pubkey().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_edit_pubkey()

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

Handle identity PUT request with public key.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 680 of file plugin_rest_identity.c.

683 {
684  struct RequestHandle *handle = cls;
685  struct EgoEntry *ego_entry;
686  char *keystring;
687 
688  keystring = NULL;
689 
690  if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
691  {
694  return;
695  }
697  ego_entry = get_egoentry (handle, keystring, NULL);
698 
699  if (NULL == ego_entry)
700  {
703  return;
704  }
705 
706  ego_edit (handle, ego_entry);
707 }
void ego_edit(struct RequestHandle *handle, struct EgoEntry *ego_entry)
Processing edit ego with EgoEntry ego_entry.

References do_error(), ego_edit(), get_egoentry(), GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_REST_API_NS_IDENTITY_PUBKEY, GNUNET_SCHEDULER_add_now(), handle, and EgoEntry::keystring.

Here is the call graph for this function:

◆ ego_edit_name()

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

Handle identity PUT request with name.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 718 of file plugin_rest_identity.c.

721 {
722  struct RequestHandle *handle = cls;
723  struct EgoEntry *ego_entry;
724  char *name;
725 
726  name = NULL;
727 
728  if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
729  {
732  return;
733  }
734  name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
735  ego_entry = get_egoentry (handle, NULL, name);
736 
737  if (NULL == ego_entry)
738  {
741  return;
742  }
743 
744  ego_edit (handle, ego_entry);
745 }

References do_error(), ego_edit(), get_egoentry(), GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_REST_API_NS_IDENTITY_NAME, GNUNET_SCHEDULER_add_now(), handle, and name.

Here is the call graph for this function:

◆ ego_create()

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

Handle identity POST request.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 756 of file plugin_rest_identity.c.

759 {
760  struct RequestHandle *handle = cls;
761  json_t *data_js;
762  json_error_t err;
763  char *egoname;
764  char *privkey;
766  struct GNUNET_IDENTITY_PrivateKey *pk_ptr;
767  int json_unpack_state;
768  char term_data[handle->data_size + 1];
769 
770  if (strlen (GNUNET_REST_API_NS_IDENTITY) != strlen (handle->url))
771  {
773  return;
774  }
775 
776  if (0 >= handle->data_size)
777  {
780  return;
781  }
782  term_data[handle->data_size] = '\0';
783  GNUNET_memcpy (term_data, handle->data, handle->data_size);
784  data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
785  if (NULL == data_js)
786  {
789  json_decref (data_js);
790  return;
791  }
792  json_unpack_state = 0;
793  privkey = NULL;
794  json_unpack_state =
795  json_unpack (data_js, "{s:s, s?:s!}",
798  if (0 != json_unpack_state)
799  {
802  json_decref (data_js);
803  return;
804  }
805 
806  if (NULL == egoname)
807  {
810  json_decref (data_js);
811  return;
812  }
813  if (0 >= strlen (egoname))
814  {
816  json_decref (data_js);
818  return;
819  }
821  handle->name = GNUNET_strdup (egoname);
822  if (NULL != privkey)
823  {
825  strlen (privkey),
826  &pk,
827  sizeof(struct
829  pk_ptr = &pk;
830  }
831  else
832  pk_ptr = NULL;
833  json_decref (data_js);
835  handle->name,
836  pk_ptr,
839  handle);
840 }
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_create(struct GNUNET_IDENTITY_Handle *h, const char *name, const struct GNUNET_IDENTITY_PrivateKey *privkey, enum GNUNET_IDENTITY_KeyType ktype, GNUNET_IDENTITY_CreateContinuation cont, void *cont_cls)
Create a new ego with the given name.
Definition: identity_api.c:586
@ GNUNET_IDENTITY_TYPE_ECDSA
The identity type.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
enum GNUNET_GenericReturnValue 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:788
enum GNUNET_GenericReturnValue GNUNET_STRINGS_utf8_tolower(const char *input, char *output)
Convert the utf-8 input string to lower case.
Definition: strings.c:449
#define GNUNET_REST_API_NS_IDENTITY
Identity Namespace.
static void do_finished_create(void *cls, const struct GNUNET_IDENTITY_PrivateKey *pk, enum GNUNET_ErrorCode ec)
Processing finished, when creating an ego.
A private key for an identity as per LSD0001.

References do_error(), do_finished_create(), egoname, GNUNET_EC_IDENTITY_INVALID, GNUNET_IDENTITY_create(), GNUNET_IDENTITY_TYPE_ECDSA, GNUNET_memcpy, GNUNET_REST_API_NS_IDENTITY, GNUNET_REST_IDENTITY_PARAM_NAME, GNUNET_REST_IDENTITY_PARAM_PRIVKEY, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_STRINGS_string_to_data(), GNUNET_STRINGS_utf8_tolower(), handle, identity_handle, and pk.

Here is the call graph for this function:

◆ ego_delete_pubkey()

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

Handle identity DELETE request with public key.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 851 of file plugin_rest_identity.c.

854 {
855  struct RequestHandle *handle = cls;
856  struct EgoEntry *ego_entry;
857  char *keystring;
858 
859  keystring = NULL;
860 
861  if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
862  {
865  return;
866  }
868  ego_entry = get_egoentry (handle, keystring, NULL);
869 
870  if (NULL == ego_entry)
871  {
874  return;
875  }
876 
878  ego_entry->identifier,
879  &do_finished,
880  handle);
881 }
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_delete(struct GNUNET_IDENTITY_Handle *h, const char *name, GNUNET_IDENTITY_Continuation cb, void *cb_cls)
Delete an existing identity.
Definition: identity_api.c:699

References do_error(), do_finished(), get_egoentry(), GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_IDENTITY_delete(), GNUNET_REST_API_NS_IDENTITY_PUBKEY, GNUNET_SCHEDULER_add_now(), handle, EgoEntry::identifier, identity_handle, and EgoEntry::keystring.

Here is the call graph for this function:

◆ ego_delete_name()

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

Handle identity DELETE request with name.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 892 of file plugin_rest_identity.c.

895 {
896  struct RequestHandle *handle = cls;
897  struct EgoEntry *ego_entry;
898  char *name;
899 
900  name = NULL;
901 
902  if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
903  {
906  return;
907  }
908  name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
909  ego_entry = get_egoentry (handle, NULL, name);
910 
911  if (NULL == ego_entry)
912  {
915  return;
916  }
917 
919  ego_entry->identifier,
920  &do_finished,
921  handle);
922 }

References do_error(), do_finished(), get_egoentry(), GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_IDENTITY_delete(), GNUNET_REST_API_NS_IDENTITY_NAME, GNUNET_SCHEDULER_add_now(), handle, EgoEntry::identifier, identity_handle, and name.

Here is the call graph for this function:

◆ ego_sign_data_cb()

void ego_sign_data_cb ( void *  cls,
struct GNUNET_IDENTITY_Ego ego 
)

Definition at line 931 of file plugin_rest_identity.c.

932 {
933  struct RequestHandle *handle = ((struct ego_sign_data_cls *) cls)->handle;
934  unsigned char *data
935  = (unsigned char *) ((struct ego_sign_data_cls *) cls)->data; // data is url decoded
936  struct MHD_Response *resp;
937  struct GNUNET_CRYPTO_EddsaSignature sig;
938  char *sig_str;
939  char *result;
940 
941  if (ego == NULL)
942  {
945  return;
946  }
947 
948  if (ntohl (ego->pk.type) != GNUNET_IDENTITY_TYPE_EDDSA)
949  {
952  return;
953  }
954 
956  (void *) data,
957  strlen ( (char*) data),
958  &sig))
959  {
962  return;
963  }
964 
966  sizeof (struct GNUNET_CRYPTO_EddsaSignature),
967  &sig_str);
968 
970  "{\"signature\": \"%s\"}",
971  sig_str);
972 
974  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
975 
976  free (data);
977  free (sig_str);
978  free (result);
979  free (cls);
981 }
uint32_t data
The data value.
static int result
Global testing status.
@ GNUNET_IDENTITY_TYPE_EDDSA
EDDSA identity.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_sign_raw(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, void *data, size_t size, struct GNUNET_CRYPTO_EddsaSignature *sig)
Definition: crypto_ecc.c:598
@ GNUNET_OK
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
size_t GNUNET_STRINGS_base64url_encode(const void *in, size_t len, char **output)
Encode into Base64url.
Definition: strings.c:1656
an ECC signature using EdDSA.
struct GNUNET_IDENTITY_PrivateKey pk
The identity key pair.
Definition: identity.h:51
uint32_t type
Type of public key.
struct GNUNET_CRYPTO_EddsaPrivateKey eddsa_key
AN EdDSA identtiy key.

References cleanup_handle(), data, do_error(), GNUNET_IDENTITY_PrivateKey::eddsa_key, GNUNET_asprintf(), GNUNET_CRYPTO_eddsa_sign_raw(), GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_EC_UNKNOWN, GNUNET_IDENTITY_TYPE_EDDSA, GNUNET_OK, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_base64url_encode(), handle, MHD_HTTP_OK, GNUNET_IDENTITY_Ego::pk, result, and GNUNET_IDENTITY_PrivateKey::type.

Referenced by ego_sign_data().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_sign_data()

void ego_sign_data ( struct GNUNET_REST_RequestHandle con_handle,
const char *  url,
void *  cls 
)
Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 990 of file plugin_rest_identity.c.

993 {
994  // TODO: replace with precompiler #define
995  const char *username_key = "user";
996  const char *data_key = "data";
997 
998  struct RequestHandle *handle = cls;
999  struct GNUNET_HashCode cache_key_username;
1000  struct GNUNET_HashCode cache_key_data;
1001  char *username;
1002  char *data;
1003 
1004  struct ego_sign_data_cls *cls2;
1005 
1006  GNUNET_CRYPTO_hash (username_key, strlen (username_key), &cache_key_username);
1007  GNUNET_CRYPTO_hash (data_key, strlen (data_key), &cache_key_data);
1008 
1010  handle->rest_handle->url_param_map,
1011  &cache_key_username)) ||
1013  handle->rest_handle->url_param_map,
1014  &cache_key_data)))
1015  {
1016  handle->ec = GNUNET_EC_UNKNOWN;
1018  return;
1019  }
1020 
1021  username = (char *) GNUNET_CONTAINER_multihashmap_get (
1022  handle->rest_handle->url_param_map,
1023  &cache_key_username);
1024 
1026  handle->rest_handle->url_param_map,
1027  &cache_key_data);
1028 
1029  cls2 = malloc (sizeof(struct ego_sign_data_cls));
1030  cls2->data = (void *) GNUNET_strdup (data);
1031  cls2->handle = handle;
1032 
1034  username,
1036  cls2);
1037 }
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
struct GNUNET_IDENTITY_EgoLookup * GNUNET_IDENTITY_ego_lookup(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, GNUNET_IDENTITY_EgoCallback cb, void *cb_cls)
Lookup an ego by name.
@ GNUNET_NO
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
void ego_sign_data_cb(void *cls, struct GNUNET_IDENTITY_Ego *ego)
struct RequestHandle * handle

References cfg, ego_sign_data_cls::data, data, do_error(), ego_sign_data_cb(), GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CRYPTO_hash(), GNUNET_EC_UNKNOWN, GNUNET_IDENTITY_ego_lookup(), GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, and ego_sign_data_cls::handle.

Here is the call 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 1047 of file plugin_rest_identity.c.

1050 {
1051  struct MHD_Response *resp;
1052  struct RequestHandle *handle = cls;
1053 
1054  // For now, independent of path return all options
1055  resp = GNUNET_REST_create_response (NULL);
1056  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
1057  "Access-Control-Allow-Methods",
1058  allow_methods));
1059  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
1061  return;
1062 }
static char * allow_methods
HTTP methods allows for this plugin.

References allow_methods, cleanup_handle(), GNUNET_assert, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), handle, and MHD_HTTP_OK.

Here is the call graph for this function:

◆ list_ego()

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

Definition at line 1066 of file plugin_rest_identity.c.

1070 {
1071  struct EgoEntry *ego_entry;
1073 
1074  if ((NULL == ego) && (ID_REST_STATE_INIT == state))
1075  {
1077  return;
1078  }
1079  if (NULL == ego)
1080  {
1082  "Called with NULL ego\n");
1083  return;
1084  }
1085  if (ID_REST_STATE_INIT == state)
1086  {
1087  ego_entry = GNUNET_new (struct EgoEntry);
1090  ego_entry->ego = ego;
1091  ego_entry->identifier = GNUNET_strdup (identifier);
1093  ego_tail,
1094  ego_entry);
1095  }
1096  /* Ego renamed or added */
1097  if (identifier != NULL)
1098  {
1099  for (ego_entry = ego_head; NULL != ego_entry;
1100  ego_entry = ego_entry->next)
1101  {
1102  if (ego_entry->ego == ego)
1103  {
1104  /* Rename */
1105  GNUNET_free (ego_entry->identifier);
1106  ego_entry->identifier = GNUNET_strdup (identifier);
1107  break;
1108  }
1109  }
1110  if (NULL == ego_entry)
1111  {
1112  /* Add */
1113  ego_entry = GNUNET_new (struct EgoEntry);
1116  ego_entry->ego = ego;
1117  ego_entry->identifier = GNUNET_strdup (identifier);
1119  ego_tail,
1120  ego_entry);
1121  }
1122  }
1123  else
1124  {
1125  /* Delete */
1126  for (ego_entry = ego_head; NULL != ego_entry;
1127  ego_entry = ego_entry->next)
1128  {
1129  if (ego_entry->ego == ego)
1130  break;
1131  }
1132  if (NULL == ego_entry)
1133  return; /* Not found */
1134 
1136  ego_tail,
1137  ego_entry);
1138  GNUNET_free (ego_entry->identifier);
1139  GNUNET_free (ego_entry->keystring);
1140  GNUNET_free (ego_entry);
1141  return;
1142  }
1143 
1144 }
#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(struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_IDENTITY_PublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:573
char * GNUNET_IDENTITY_public_key_to_string(const struct GNUNET_IDENTITY_PublicKey *key)
Creates a (Base32) string representation of the public key.
@ GNUNET_ERROR_TYPE_WARNING
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct EgoEntry * ego_tail
Ego list.
#define ID_REST_STATE_INIT
State while collecting all egos.
static int state
The processing state.
#define ID_REST_STATE_POST_INIT
Done collecting egos.
An identity key as per LSD0001.

References EgoEntry::ego, ego_head, ego_tail, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_IDENTITY_ego_get_public_key(), GNUNET_IDENTITY_public_key_to_string(), GNUNET_log, GNUNET_new, GNUNET_strdup, ID_REST_STATE_INIT, ID_REST_STATE_POST_INIT, EgoEntry::identifier, EgoEntry::keystring, EgoEntry::next, pk, and state.

Referenced by libgnunet_plugin_rest_identity_init().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ rest_process_request()

static enum GNUNET_GenericReturnValue rest_process_request ( struct GNUNET_REST_RequestHandle rest_handle,
GNUNET_REST_ResultProcessor  proc,
void *  proc_cls 
)
static

Function processing the REST call.

Parameters
methodHTTP method
urlURL of the HTTP request
databody of the HTTP request (optional)
data_sizelength of the body
proccallback function for the result
proc_clsclosure for callback function
Returns
GNUNET_OK if request accepted

Definition at line 1066 of file plugin_rest_identity.c.

1162 {
1163  struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
1165  static const struct GNUNET_REST_RequestHandler handlers[] =
1166  { { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_PUBKEY,
1167  &ego_get_pubkey },
1168  { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_get_name },
1169  { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY, &ego_get_all },
1170  { MHD_HTTP_METHOD_PUT,
1172  &ego_edit_pubkey },
1173  { MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_edit_name },
1174  { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY, &ego_create },
1175  { MHD_HTTP_METHOD_DELETE,
1177  &ego_delete_pubkey },
1178  { MHD_HTTP_METHOD_DELETE,
1180  &ego_delete_name },
1181  { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_IDENTITY, &options_cont },
1182  { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_SIGN, &ego_sign_data},
1184 
1185 
1187  handle->proc_cls = proc_cls;
1188  handle->proc = proc;
1189  handle->rest_handle = rest_handle;
1190  handle->data = rest_handle->data;
1191  handle->data_size = rest_handle->data_size;
1192 
1193  handle->url = GNUNET_strdup (rest_handle->url);
1194  if (handle->url[strlen (handle->url) - 1] == '/')
1195  handle->url[strlen (handle->url) - 1] = '\0';
1196  handle->timeout_task =
1199  requests_tail,
1200  handle);
1201  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
1202  if (GNUNET_NO ==
1203  GNUNET_REST_handle_request (handle->rest_handle, handlers, &err, handle))
1204  {
1206  return GNUNET_NO;
1207  }
1208 
1209  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
1210  return GNUNET_YES;
1211 }
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
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:64
#define GNUNET_REST_HANDLER_END
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:1241
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
void ego_get_pubkey(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity GET request with a public key.
void ego_sign_data(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
void ego_get_all(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity GET request - responds with all identities.
void ego_delete_pubkey(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity DELETE request with public key.
void ego_edit_name(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity PUT request with name.
static void options_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Respond to OPTIONS request.
#define GNUNET_REST_API_NS_SIGN
Identity Namespace with sign specifier.
void ego_delete_name(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity DELETE request with name.
void ego_get_name(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity GET request with a name.
void ego_edit_pubkey(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity PUT request with public key.
void ego_create(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity POST request.
const char * data
The POST data.
const char * url
The url as string.
size_t data_size
The POST data size.
void(* proc)(struct GNUNET_REST_RequestHandle *handle, const char *url, void *cls)
Namespace to handle.

Referenced by libgnunet_plugin_rest_identity_init().

Here is the caller graph for this function:

◆ libgnunet_plugin_rest_identity_init()

void* libgnunet_plugin_rest_identity_init ( void *  cls)

Entry point for the plugin.

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

Definition at line 1221 of file plugin_rest_identity.c.

1222 {
1223  static struct Plugin plugin;
1224  struct GNUNET_REST_Plugin *api;
1225 
1226  cfg = cls;
1227  if (NULL != plugin.cfg)
1228  return NULL; /* can only initialize once! */
1229  memset (&plugin, 0, sizeof(struct Plugin));
1230  plugin.cfg = cfg;
1231  api = GNUNET_new (struct GNUNET_REST_Plugin);
1232  api->cls = &plugin;
1236  "%s, %s, %s, %s, %s",
1237  MHD_HTTP_METHOD_GET,
1238  MHD_HTTP_METHOD_POST,
1239  MHD_HTTP_METHOD_PUT,
1240  MHD_HTTP_METHOD_DELETE,
1241  MHD_HTTP_METHOD_OPTIONS);
1244 
1245  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Identity REST API initialized\n"));
1246  return api;
1247 }
struct TestcasePlugin * plugin
The process handle to the testbed service.
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:531
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
static enum GNUNET_GenericReturnValue rest_process_request(struct GNUNET_REST_RequestHandle *rest_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
Function processing the REST call.
static void list_ego(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *identifier)
struct returned by the initialization function of the plugin
char * name
Plugin name.
void * cls
The closure of the plugin.
enum GNUNET_GenericReturnValue(* process_request)(struct GNUNET_REST_RequestHandle *handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
Function to process a REST call.
Handle for a plugin.
Definition: block.c:38

References _, allow_methods, cfg, GNUNET_REST_Plugin::cls, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_IDENTITY_connect(), GNUNET_log, GNUNET_new, GNUNET_REST_API_NS_IDENTITY, ID_REST_STATE_INIT, identity_handle, list_ego(), GNUNET_REST_Plugin::name, plugin, GNUNET_REST_Plugin::process_request, rest_process_request(), and state.

Here is the call graph for this function:

◆ libgnunet_plugin_rest_identity_done()

void* libgnunet_plugin_rest_identity_done ( void *  cls)

Exit point from the plugin.

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

Definition at line 1257 of file plugin_rest_identity.c.

1258 {
1259  struct GNUNET_REST_Plugin *api = cls;
1260  struct Plugin *plugin = api->cls;
1261  struct EgoEntry *ego_entry;
1262  struct EgoEntry *ego_tmp;
1263 
1264  plugin->cfg = NULL;
1265  while (NULL != requests_head)
1267  if (NULL != identity_handle)
1269 
1270  for (ego_entry = ego_head; NULL != ego_entry;)
1271  {
1272  ego_tmp = ego_entry;
1273  ego_entry = ego_entry->next;
1274  GNUNET_free (ego_tmp->identifier);
1275  GNUNET_free (ego_tmp->keystring);
1276  GNUNET_free (ego_tmp);
1277  }
1278 
1280  GNUNET_free (api);
1281  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Identity REST plugin is finished\n");
1282  return NULL;
1283 }
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:757
void * cls
Closure for all of the callbacks.
struct GNUNET_BLOCK_PluginFunctions * api
Plugin API.
Definition: block.c:47

References allow_methods, Plugin::api, cleanup_handle(), GNUNET_BLOCK_PluginFunctions::cls, GNUNET_REST_Plugin::cls, ego_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_IDENTITY_disconnect(), GNUNET_log, EgoEntry::identifier, identity_handle, EgoEntry::keystring, EgoEntry::next, plugin, and requests_head.

Here is the call graph for this function:

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

The configuration handle.

Handle to our configuration.

Definition at line 109 of file plugin_rest_identity.c.

Referenced by ego_sign_data(), and libgnunet_plugin_rest_identity_init().

◆ allow_methods

char* allow_methods
static

HTTP methods allows for this plugin.

Definition at line 114 of file plugin_rest_identity.c.

Referenced by libgnunet_plugin_rest_identity_done(), libgnunet_plugin_rest_identity_init(), and options_cont().

◆ ego_head

struct EgoEntry* ego_head
static

◆ ego_tail

struct EgoEntry* ego_tail
static

Ego list.

Definition at line 124 of file plugin_rest_identity.c.

Referenced by list_ego().

◆ state

int state
static

The processing state.

Definition at line 129 of file plugin_rest_identity.c.

Referenced by libgnunet_plugin_rest_identity_init(), and list_ego().

◆ identity_handle

struct GNUNET_IDENTITY_Handle* identity_handle
static

◆ requests_head

struct RequestHandle* requests_head
static

DLL.

Definition at line 249 of file plugin_rest_identity.c.

Referenced by cleanup_handle(), and libgnunet_plugin_rest_identity_done().

◆ requests_tail

struct RequestHandle* requests_tail
static

DLL.

Definition at line 254 of file plugin_rest_identity.c.

Referenced by cleanup_handle().