#include "platform.h"
#include "gnunet_rest_plugin.h"
#include "gnunet_identity_service.h"
#include "gnunet_rest_lib.h"
#include "../../service/identity/identity.h"
#include "gnunet_util_lib.h"
#include "microhttpd.h"
#include <jansson.h>
#include "identity_plugin.h"

Include dependency graph for identity_plugin.c:

Data Structures
struct	Plugin
	Handle for a plugin. More...

struct	EgoEntry
	The default namestore ego. 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_TYPE "type"
	Parameter type. 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...

static 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. More...

static void	ego_get_all (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	Handle identity GET request - responds with all identities. More...

static void	ego_get_response (struct RequestHandle handle, struct EgoEntry ego_entry)
	Responds with the ego_entry identity. More...

static void	ego_get_pubkey (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	Handle identity GET request with a public key. More...

static 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_CRYPTO_PrivateKey pk, enum GNUNET_ErrorCode ec)
	Processing finished, when creating an ego. More...

static void	ego_edit (struct RequestHandle handle, struct EgoEntry ego_entry)
	Processing edit ego with EgoEntry ego_entry. More...

static void	ego_edit_pubkey (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	Handle identity PUT request with public key. More...

static void	ego_edit_name (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	Handle identity PUT request with name. More...

static void	ego_create (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	Handle identity POST request. More...

static void	ego_delete_pubkey (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	Handle identity DELETE request with public key. More...

static void	ego_delete_name (struct GNUNET_REST_RequestHandle con_handle, const char url, void *cls)
	Handle identity DELETE request with name. More...

static void	ego_sign_data_cb (void cls, struct GNUNET_IDENTITY_Ego ego)

static 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)

enum GNUNET_GenericReturnValue	REST_identity_process_request (void plugin, struct GNUNET_REST_RequestHandle rest_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
	Function processing the REST call. More...

void *	REST_identity_init (const struct GNUNET_CONFIGURATION_Handle *c)
	Entry point for the plugin. More...

void	REST_identity_done (struct GNUNET_REST_Plugin *api)
	Exit point from the plugin. More...

Variables
const struct GNUNET_CONFIGURATION_Handle *	id_cfg
	The configuration handle. More...

static char *	allow_methods
	HTTP methods allows for this plugin. More...

static struct EgoEntry *	ego_head
	Ego list. More...

static struct EgoEntry *	ego_tail
	Ego list. More...

static int	state
	The processing state. More...

static struct GNUNET_IDENTITY_Handle *	identity_handle
	Handle to Identity service. More...

static struct RequestHandle *	requests_head
	DLL. More...

static struct RequestHandle *	requests_tail
	DLL. More...

Macro Definition Documentation

◆ GNUNET_REST_API_NS_IDENTITY

#define GNUNET_REST_API_NS_IDENTITY "/identity"

Identity Namespace.

Definition at line 40 of file identity_plugin.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 45 of file identity_plugin.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 50 of file identity_plugin.c.

◆ GNUNET_REST_API_NS_SIGN

#define GNUNET_REST_API_NS_SIGN "/sign"

Identity Namespace with sign specifier.

Definition at line 55 of file identity_plugin.c.

◆ GNUNET_REST_IDENTITY_PARAM_PUBKEY

#define GNUNET_REST_IDENTITY_PARAM_PUBKEY "pubkey"

Parameter public key.

Definition at line 60 of file identity_plugin.c.

◆ GNUNET_REST_IDENTITY_PARAM_PRIVKEY

#define GNUNET_REST_IDENTITY_PARAM_PRIVKEY "privkey"

Parameter private key.

Definition at line 65 of file identity_plugin.c.

◆ GNUNET_REST_IDENTITY_PARAM_NAME

#define GNUNET_REST_IDENTITY_PARAM_NAME "name"

Parameter name.

Definition at line 70 of file identity_plugin.c.

◆ GNUNET_REST_IDENTITY_PARAM_TYPE

#define GNUNET_REST_IDENTITY_PARAM_TYPE "type"

Parameter type.

Definition at line 75 of file identity_plugin.c.

◆ GNUNET_REST_IDENTITY_PARAM_NEWNAME

#define GNUNET_REST_IDENTITY_PARAM_NEWNAME "newname"

Parameter new name.

Definition at line 80 of file identity_plugin.c.

◆ GNUNET_REST_IDENTITY_MISSING_NAME

#define GNUNET_REST_IDENTITY_MISSING_NAME "Missing identity name"

Error message Missing identity name.

Definition at line 85 of file identity_plugin.c.

◆ GNUNET_REST_IDENTITY_MISSING_PUBKEY

#define GNUNET_REST_IDENTITY_MISSING_PUBKEY "Missing identity public key"

Error message Missing identity name.

Definition at line 90 of file identity_plugin.c.

◆ GNUNET_REST_ERROR_NO_DATA

#define GNUNET_REST_ERROR_NO_DATA "No data"

Error message No data.

Definition at line 95 of file identity_plugin.c.

◆ GNUNET_REST_ERROR_DATA_INVALID

#define GNUNET_REST_ERROR_DATA_INVALID "Data invalid"

Error message Data invalid.

Definition at line 100 of file identity_plugin.c.

◆ ID_REST_STATE_INIT

#define ID_REST_STATE_INIT 0

State while collecting all egos.

Definition at line 105 of file identity_plugin.c.

◆ ID_REST_STATE_POST_INIT

#define ID_REST_STATE_POST_INIT 1

Done collecting egos.

Definition at line 110 of file identity_plugin.c.

Function Documentation

◆ cleanup_handle()

static void cleanup_handle ( void * cls )

static

Cleanup lookup handle.

Parameters

cls	Handle to clean up

Definition at line 274 of file identity_plugin.c.

{
  struct RequestHandle *handle = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
  if (NULL != handle->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (handle->timeout_task);
    handle->timeout_task = NULL;
  }
 
  if (NULL != handle->url)
    GNUNET_free (handle->url);
  if (NULL != handle->name)
    GNUNET_free (handle->name);
  GNUNET_CONTAINER_DLL_remove (requests_head,
                               requests_tail,
                               handle);
  GNUNET_free (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(), options_cont(), REST_identity_done(), and REST_identity_process_request().

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

cls	the `struct RequestHandle`

Definition at line 302 of file identity_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;
  json_t *json_error = json_object ();
  char *response;
  int response_code;
 
  json_object_set_new (json_error, "error",
                       json_string (GNUNET_ErrorCode_get_hint (handle->ec)));
  json_object_set_new (json_error, "error_code", json_integer (handle->ec));
  response_code = GNUNET_ErrorCode_get_http_status (handle->ec);
  if (0 == response_code)
    response_code = MHD_HTTP_OK;
  response = json_dumps (json_error, 0);
  resp = GNUNET_REST_create_response (response);
  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
                                                    "Content-Type",
                                                    "application/json"));
  handle->proc (handle->proc_cls, resp, response_code);
  json_decref (json_error);
  GNUNET_free (response);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, 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(), ego_sign_data_cb(), and REST_identity_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_egoentry()

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

static

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

handle	the RequestHandle
pubkey	the public key of an identity (only one can be NULL)
name	the name of an identity (only one can be NULL)

Returns: EgoEntry or NULL if not found

Definition at line 338 of file identity_plugin.c.

{
  struct EgoEntry *ego_entry;
 
  if (NULL != pubkey)
  {
    for (ego_entry = ego_head; NULL != ego_entry;
         ego_entry = ego_entry->next)
    {
      if (0 != strcasecmp (pubkey, ego_entry->keystring))
        continue;
      return ego_entry;
    }
  }
  if (NULL != name)
  {
    for (ego_entry = ego_head; NULL != ego_entry;
         ego_entry = ego_entry->next)
    {
      if (0 != strcasecmp (name, ego_entry->identifier))
        continue;
      return ego_entry;
    }
  }
  return NULL;
}

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()

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

static

Handle identity GET request - responds with all identities.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 374 of file identity_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  struct MHD_Response *resp;
  struct GNUNET_HashCode key;
  json_t *json_root;
  json_t *json_ego;
  char *result_str;
  char *privkey_str;
 
  json_root = json_array ();
  // Return ego/egos
  for (ego_entry = ego_head; NULL != ego_entry;
       ego_entry = ego_entry->next)
  {
    json_ego = json_object ();
    json_object_set_new (json_ego,
                         GNUNET_REST_IDENTITY_PARAM_PUBKEY,
                         json_string (ego_entry->keystring));
    GNUNET_CRYPTO_hash ("private", strlen ("private"), &key);
    if (GNUNET_YES ==
        GNUNET_CONTAINER_multihashmap_contains (
          handle->rest_handle->url_param_map, &key))
    {
      privkey_str = GNUNET_CRYPTO_private_key_to_string (
        GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego));
      json_object_set_new (json_ego,
                           GNUNET_REST_IDENTITY_PARAM_PRIVKEY,
                           json_string (privkey_str));
      GNUNET_free (privkey_str);
    }
 
    json_object_set_new (json_ego,
                         GNUNET_REST_IDENTITY_PARAM_NAME,
                         json_string (ego_entry->identifier));
    json_array_append (json_root, json_ego);
    json_decref (json_ego);
  }
 
  result_str = json_dumps (json_root, 0);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
  resp = GNUNET_REST_create_response (result_str);
  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
                                                    "Content-Type",
                                                    "application/json"));
  json_decref (json_root);
  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
  GNUNET_free (result_str);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}

References cleanup_handle(), EgoEntry::ego, ego_head, GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_private_key_to_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_IDENTITY_ego_get_private_key(), 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.

Referenced by REST_identity_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ego_get_response()

static void ego_get_response	(	struct RequestHandle *	handle,
		struct EgoEntry *	ego_entry
	)

static

Responds with the ego_entry identity.

Parameters

handle	the struct RequestHandle
ego_entry	the struct EgoEntry for the response

Definition at line 436 of file identity_plugin.c.

{
  struct MHD_Response *resp;
  struct GNUNET_HashCode key;
  json_t *json_ego;
  char *result_str;
  char *privkey_str;
 
  json_ego = json_object ();
  json_object_set_new (json_ego,
                       GNUNET_REST_IDENTITY_PARAM_PUBKEY,
                       json_string (ego_entry->keystring));
  json_object_set_new (json_ego,
                       GNUNET_REST_IDENTITY_PARAM_NAME,
                       json_string (ego_entry->identifier));
  GNUNET_CRYPTO_hash ("private", strlen ("private"), &key);
  if (GNUNET_YES ==
      GNUNET_CONTAINER_multihashmap_contains (
        handle->rest_handle->url_param_map, &key))
  {
    privkey_str = GNUNET_CRYPTO_private_key_to_string (
      GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego));
    json_object_set_new (json_ego,
                         GNUNET_REST_IDENTITY_PARAM_PRIVKEY,
                         json_string (privkey_str));
    GNUNET_free (privkey_str);
  }
 
  result_str = json_dumps (json_ego, 0);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
  resp = GNUNET_REST_create_response (result_str);
  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
                                                    "Content-Type",
                                                    "application/json"));
  json_decref (json_ego);
  GNUNET_free (result_str);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}

References cleanup_handle(), EgoEntry::ego, GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_private_key_to_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_IDENTITY_ego_get_private_key(), 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()

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

static

Handle identity GET request with a public key.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 485 of file identity_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *keystring;
 
  keystring = NULL;
 
  if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) + 1];
  ego_entry = get_egoentry (handle, keystring, NULL);
 
  if (NULL == ego_entry)
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  ego_get_response (handle, ego_entry);
}

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.

Referenced by REST_identity_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ego_get_name()

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

static

Handle identity GET request with a name.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 523 of file identity_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *egoname;
 
  egoname = NULL;
 
  if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  egoname = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
  ego_entry = get_egoentry (handle, NULL, egoname);
 
  if (NULL == ego_entry)
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  ego_get_response (handle, ego_entry);
}

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.

Referenced by REST_identity_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_finished()

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

static

Processing finished.

Parameters

cls	request handle
ec	error code

Definition at line 560 of file identity_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;
  int response_code;
 
  handle->op = NULL;
  handle->ec = ec;
  if (GNUNET_EC_NONE != handle->ec)
  {
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  if (0 != handle->success_code)
    response_code = handle->success_code;
  else
    response_code = MHD_HTTP_OK;
 
  resp = GNUNET_REST_create_response (NULL);
  handle->proc (handle->proc_cls, resp, response_code);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}

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

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_CRYPTO_PrivateKey *	pk,
		enum GNUNET_ErrorCode	ec
	)

static

Processing finished, when creating an ego.

Parameters

cls	request handle
pk	private key of the ego, or NULL on error
ec	error code

Definition at line 593 of file identity_plugin.c.

{
  struct RequestHandle *handle = cls;
 
  (void) pk;
  do_finished (handle, ec);
}

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()

static void ego_edit	(	struct RequestHandle *	handle,
		struct EgoEntry *	ego_entry
	)

static

Processing edit ego with EgoEntry ego_entry.

Parameters

handle	the struct RequestHandle
ego_entry	the struct EgoEntry we want to edit

Definition at line 611 of file identity_plugin.c.

{
  json_t *data_js;
  json_error_t err;
  char *newname;
  char term_data[handle->data_size + 1];
  int json_state;
 
  // if no data
  if (0 >= handle->data_size)
  {
    handle->ec = GNUNET_EC_IDENTITY_INVALID;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  // if not json
  term_data[handle->data_size] = '\0';
  GNUNET_memcpy (term_data, handle->data, handle->data_size);
  data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
 
  if (NULL == data_js)
  {
    handle->ec = GNUNET_EC_IDENTITY_INVALID;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  newname = NULL;
  // NEW NAME
  json_state = 0;
  json_state = json_unpack (data_js,
                            "{s:s!}",
                            GNUNET_REST_IDENTITY_PARAM_NEWNAME,
                            &newname);
  // Change name with pubkey or name identifier
  if (0 != json_state)
  {
    handle->ec = GNUNET_EC_IDENTITY_INVALID;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
 
  if (NULL == newname)
  {
    handle->ec = GNUNET_EC_IDENTITY_INVALID;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
 
  if (0 >= strlen (newname))
  {
    handle->ec = GNUNET_EC_IDENTITY_INVALID;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
 
  handle->success_code = MHD_HTTP_NO_CONTENT;
  handle->op = GNUNET_IDENTITY_rename (identity_handle,
                                       ego_entry->identifier,
                                       newname,
                                       &do_finished,
                                       handle);
  if (NULL == handle->op)
  {
    handle->ec = GNUNET_EC_UNKNOWN;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
  json_decref (data_js);
  return;
}

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, identity_handle, and MHD_HTTP_NO_CONTENT.

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()

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

static

Handle identity PUT request with public key.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 696 of file identity_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *keystring;
 
  keystring = NULL;
 
  if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) + 1];
  ego_entry = get_egoentry (handle, keystring, NULL);
 
  if (NULL == ego_entry)
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  ego_edit (handle, 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.

Referenced by REST_identity_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ego_edit_name()

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

static

Handle identity PUT request with name.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 734 of file identity_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *name;
 
  name = NULL;
 
  if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
  ego_entry = get_egoentry (handle, NULL, name);
 
  if (NULL == ego_entry)
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  ego_edit (handle, ego_entry);
}

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.

Referenced by REST_identity_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ego_create()

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

static

Handle identity POST request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 772 of file identity_plugin.c.

{
  struct RequestHandle *handle = cls;
  json_t *data_js;
  json_error_t err;
  char *egoname;
  char *egotype;
  char *privkey;
  struct GNUNET_CRYPTO_PrivateKey pk;
  struct GNUNET_CRYPTO_PrivateKey *pk_ptr;
  int json_unpack_state;
  int type;
  char term_data[handle->data_size + 1];
 
  if (strlen (GNUNET_REST_API_NS_IDENTITY) != strlen (handle->url))
  {
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  if (0 >= handle->data_size)
  {
    handle->ec = GNUNET_EC_IDENTITY_INVALID;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  term_data[handle->data_size] = '\0';
  GNUNET_memcpy (term_data, handle->data, handle->data_size);
  data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
  if (NULL == data_js)
  {
    handle->ec = GNUNET_EC_IDENTITY_INVALID;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
  json_unpack_state = 0;
  privkey = NULL;
  json_unpack_state =
    json_unpack (data_js, "{s:s, s?:s, s?:s}",
                 GNUNET_REST_IDENTITY_PARAM_NAME, &egoname,
                 GNUNET_REST_IDENTITY_PARAM_TYPE, &egotype,
                 GNUNET_REST_IDENTITY_PARAM_PRIVKEY, &privkey);
  if (0 != json_unpack_state)
  {
    handle->ec = GNUNET_EC_IDENTITY_INVALID;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
  type = GNUNET_PUBLIC_KEY_TYPE_ECDSA;
  if ((NULL != egotype) && (0 == strcasecmp (egotype, "EDDSA")))
    type = GNUNET_PUBLIC_KEY_TYPE_EDDSA;
  if (NULL == egoname)
  {
    handle->ec = GNUNET_EC_IDENTITY_INVALID;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
  if (0 >= strlen (egoname))
  {
    handle->ec = GNUNET_EC_IDENTITY_INVALID;
    json_decref (data_js);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  GNUNET_STRINGS_utf8_tolower (egoname, egoname);
  handle->name = GNUNET_strdup (egoname);
  if (NULL != privkey)
  {
    GNUNET_STRINGS_string_to_data (privkey,
                                   strlen (privkey),
                                   &pk,
                                   sizeof(struct
                                          GNUNET_CRYPTO_PrivateKey));
    pk_ptr = &pk;
  }
  else
    pk_ptr = NULL;
  json_decref (data_js);
  handle->success_code = MHD_HTTP_CREATED;
  handle->op = GNUNET_IDENTITY_create (identity_handle,
                                       handle->name,
                                       pk_ptr,
                                       type,
                                       &do_finished_create,
                                       handle);
}

References do_error(), do_finished_create(), egoname, GNUNET_EC_IDENTITY_INVALID, GNUNET_IDENTITY_create(), GNUNET_memcpy, GNUNET_PUBLIC_KEY_TYPE_ECDSA, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_REST_API_NS_IDENTITY, GNUNET_REST_IDENTITY_PARAM_NAME, GNUNET_REST_IDENTITY_PARAM_PRIVKEY, GNUNET_REST_IDENTITY_PARAM_TYPE, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_STRINGS_string_to_data(), GNUNET_STRINGS_utf8_tolower(), handle, identity_handle, MHD_HTTP_CREATED, pk, and type.

Referenced by REST_identity_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ego_delete_pubkey()

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

static

Handle identity DELETE request with public key.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 873 of file identity_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *keystring;
 
  keystring = NULL;
 
  if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  keystring = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) + 1];
  ego_entry = get_egoentry (handle, keystring, NULL);
 
  if (NULL == ego_entry)
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  handle->success_code = MHD_HTTP_NO_CONTENT;
  handle->op = GNUNET_IDENTITY_delete (identity_handle,
                                       ego_entry->identifier,
                                       &do_finished,
                                       handle);
}

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, EgoEntry::keystring, and MHD_HTTP_NO_CONTENT.

Referenced by REST_identity_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ego_delete_name()

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

static

Handle identity DELETE request with name.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 915 of file identity_plugin.c.

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *name;
 
  name = NULL;
 
  if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
  ego_entry = get_egoentry (handle, NULL, name);
 
  if (NULL == ego_entry)
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  handle->success_code = MHD_HTTP_NO_CONTENT;
  handle->op = GNUNET_IDENTITY_delete (identity_handle,
                                       ego_entry->identifier,
                                       &do_finished,
                                       handle);
}

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, MHD_HTTP_NO_CONTENT, and name.

Referenced by REST_identity_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ego_sign_data_cb()

static void ego_sign_data_cb	(	void *	cls,
		struct GNUNET_IDENTITY_Ego *	ego
	)

static

Definition at line 956 of file identity_plugin.c.

{
  struct RequestHandle *handle = ((struct ego_sign_data_cls *) cls)->handle;
  unsigned char *data
    = (unsigned char *) ((struct ego_sign_data_cls *) cls)->data; // data is url decoded
  struct MHD_Response *resp;
  struct GNUNET_CRYPTO_EddsaSignature sig;
  char *sig_str;
  char *result;
 
  if (ego == NULL)
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  if (ntohl (ego->pk.type) != GNUNET_PUBLIC_KEY_TYPE_EDDSA)
  {
    handle->ec = GNUNET_EC_IDENTITY_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  if (GNUNET_OK != GNUNET_CRYPTO_eddsa_sign_raw (&(ego->pk.eddsa_key),
                                                 (void *) data,
                                                 strlen ( (char*) data),
                                                 &sig))
  {
    handle->ec = GNUNET_EC_UNKNOWN;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  GNUNET_STRINGS_base64url_encode (&sig,
                                   sizeof (struct GNUNET_CRYPTO_EddsaSignature),
                                   &sig_str);
 
  GNUNET_asprintf (&result,
                   "{\"signature\": \"%s\"}",
                   sig_str);
 
  resp = GNUNET_REST_create_response (result);
  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
 
  free (data);
  free (sig_str);
  free (result);
  free (cls);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}

References cleanup_handle(), data, do_error(), GNUNET_CRYPTO_PrivateKey::eddsa_key, GNUNET_asprintf(), GNUNET_CRYPTO_eddsa_sign_raw(), GNUNET_EC_IDENTITY_NOT_FOUND, GNUNET_EC_UNKNOWN, GNUNET_OK, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_base64url_encode(), handle, MHD_HTTP_OK, GNUNET_IDENTITY_Ego::pk, result, and GNUNET_CRYPTO_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()

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

static

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 1016 of file identity_plugin.c.

{
  // TODO: replace with precompiler #define
  const char *username_key = "user";
  const char *data_key = "data";
 
  struct RequestHandle *handle = cls;
  struct GNUNET_HashCode cache_key_username;
  struct GNUNET_HashCode cache_key_data;
  char *username;
  char *data;
 
  struct ego_sign_data_cls *cls2;
 
  GNUNET_CRYPTO_hash (username_key, strlen (username_key), &cache_key_username);
  GNUNET_CRYPTO_hash (data_key, strlen (data_key), &cache_key_data);
 
  if ((GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (
         handle->rest_handle->url_param_map,
         &cache_key_username)) ||
      (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains (
         handle->rest_handle->url_param_map,
         &cache_key_data)))
  {
    handle->ec = GNUNET_EC_UNKNOWN;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
 
  username = (char *) GNUNET_CONTAINER_multihashmap_get (
    handle->rest_handle->url_param_map,
    &cache_key_username);
 
  data = (char *) GNUNET_CONTAINER_multihashmap_get (
    handle->rest_handle->url_param_map,
    &cache_key_data);
 
  cls2 = malloc (sizeof(struct ego_sign_data_cls));
  cls2->data = (void *) GNUNET_strdup (data);
  cls2->handle = handle;
 
  GNUNET_IDENTITY_ego_lookup (id_cfg,
                              username,
                              ego_sign_data_cb,
                              cls2);
}

References data, ego_sign_data_cls::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, ego_sign_data_cls::handle, and id_cfg.

Referenced by REST_identity_process_request().

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_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 1074 of file identity_plugin.c.

{
  struct MHD_Response *resp;
  struct RequestHandle *handle = cls;
 
  // For now, independent of path return all options
  resp = GNUNET_REST_create_response (NULL);
  GNUNET_assert (MHD_NO != MHD_add_response_header (resp,
                                                    "Access-Control-Allow-Methods",
                                                    allow_methods));
  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
  return;
}

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

Referenced by REST_identity_process_request().

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

Definition at line 1093 of file identity_plugin.c.

{
  struct EgoEntry *ego_entry;
  struct GNUNET_CRYPTO_PublicKey pk;
 
  if ((NULL == ego) && (ID_REST_STATE_INIT == state))
  {
    state = ID_REST_STATE_POST_INIT;
    return;
  }
  if (NULL == ego)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Called with NULL ego\n");
    return;
  }
  if (ID_REST_STATE_INIT == state)
  {
    ego_entry = GNUNET_new (struct EgoEntry);
    GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
    ego_entry->keystring = GNUNET_CRYPTO_public_key_to_string (&pk);
    ego_entry->ego = ego;
    ego_entry->identifier = GNUNET_strdup (identifier);
    GNUNET_CONTAINER_DLL_insert_tail (ego_head,
                                      ego_tail,
                                      ego_entry);
  }
  /* Ego renamed or added */
  if (identifier != NULL)
  {
    for (ego_entry = ego_head; NULL != ego_entry;
         ego_entry = ego_entry->next)
    {
      if (ego_entry->ego == ego)
      {
        /* Rename */
        GNUNET_free (ego_entry->identifier);
        ego_entry->identifier = GNUNET_strdup (identifier);
        break;
      }
    }
    if (NULL == ego_entry)
    {
      /* Add */
      ego_entry = GNUNET_new (struct EgoEntry);
      GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
      ego_entry->keystring = GNUNET_CRYPTO_public_key_to_string (&pk);
      ego_entry->ego = ego;
      ego_entry->identifier = GNUNET_strdup (identifier);
      GNUNET_CONTAINER_DLL_insert_tail (ego_head,
                                        ego_tail,
                                        ego_entry);
    }
  }
  else
  {
    /* Delete */
    for (ego_entry = ego_head; NULL != ego_entry;
         ego_entry = ego_entry->next)
    {
      if (ego_entry->ego == ego)
        break;
    }
    if (NULL == ego_entry)
      return; /* Not found */
 
    GNUNET_CONTAINER_DLL_remove (ego_head,
                                 ego_tail,
                                 ego_entry);
    GNUNET_free (ego_entry->identifier);
    GNUNET_free (ego_entry->keystring);
    GNUNET_free (ego_entry);
    return;
  }
 
}

References EgoEntry::ego, ego_head, ego_tail, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_CRYPTO_public_key_to_string(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_IDENTITY_ego_get_public_key(), 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 REST_identity_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ REST_identity_process_request()

enum GNUNET_GenericReturnValue REST_identity_process_request	(	void *	plugin,
		struct GNUNET_REST_RequestHandle *	rest_handle,
		GNUNET_REST_ResultProcessor	proc,
		void *	proc_cls
	)

Function processing the REST call.

Parameters

method	HTTP method
url	URL of the HTTP request
data	body of the HTTP request (optional)
data_size	length of the body
proc	callback function for the result
proc_cls	closure for callback function

Returns: GNUNET_OK if request accepted

Definition at line 1186 of file identity_plugin.c.

{
  struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
  struct GNUNET_REST_RequestHandlerError err;
  static const struct GNUNET_REST_RequestHandler handlers[] =
  { { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_PUBKEY,
      &ego_get_pubkey },
    { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_get_name },
    { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY, &ego_get_all },
    { MHD_HTTP_METHOD_PUT,
      GNUNET_REST_API_NS_IDENTITY_PUBKEY,
      &ego_edit_pubkey },
    { MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_edit_name },
    { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY, &ego_create },
    { MHD_HTTP_METHOD_DELETE,
      GNUNET_REST_API_NS_IDENTITY_PUBKEY,
      &ego_delete_pubkey },
    { MHD_HTTP_METHOD_DELETE,
      GNUNET_REST_API_NS_IDENTITY_NAME,
      &ego_delete_name },
    { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_IDENTITY, &options_cont },
    { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_SIGN, &ego_sign_data},
    GNUNET_REST_HANDLER_END };
 
 
  handle->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
  handle->proc_cls = proc_cls;
  handle->proc = proc;
  handle->rest_handle = rest_handle;
  handle->data = rest_handle->data;
  handle->data_size = rest_handle->data_size;
 
  handle->url = GNUNET_strdup (rest_handle->url);
  if (handle->url[strlen (handle->url) - 1] == '/')
    handle->url[strlen (handle->url) - 1] = '\0';
  handle->timeout_task =
    GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_error, handle);
  GNUNET_CONTAINER_DLL_insert (requests_head,
                               requests_tail,
                               handle);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
  if (GNUNET_NO ==
      GNUNET_REST_handle_request (handle->rest_handle, handlers, &err, handle))
  {
    cleanup_handle (handle);
    return GNUNET_NO;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
  return GNUNET_YES;
}

References cleanup_handle(), GNUNET_REST_RequestHandle::data, GNUNET_REST_RequestHandle::data_size, do_error(), ego_create(), ego_delete_name(), ego_delete_pubkey(), ego_edit_name(), ego_edit_pubkey(), ego_get_all(), ego_get_name(), ego_get_pubkey(), ego_sign_data(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_REST_API_NS_IDENTITY, GNUNET_REST_API_NS_IDENTITY_NAME, GNUNET_REST_API_NS_IDENTITY_PUBKEY, GNUNET_REST_API_NS_SIGN, GNUNET_REST_handle_request(), GNUNET_REST_HANDLER_END, GNUNET_SCHEDULER_add_delayed(), GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, handle, handlers, options_cont(), GNUNET_REST_RequestHandler::proc, requests_head, requests_tail, and GNUNET_REST_RequestHandle::url.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ REST_identity_init()

void * REST_identity_init ( const struct GNUNET_CONFIGURATION_Handle * c )

Entry point for the plugin.

Parameters

cls	Config info

Returns: NULL on error, otherwise the plugin context

Definition at line 1249 of file identity_plugin.c.

{
  static struct Plugin plugin;
  struct GNUNET_REST_Plugin *api;
 
  id_cfg = c;
  if (NULL != plugin.cfg)
    return NULL; /* can only initialize once! */
  memset (&plugin, 0, sizeof(struct Plugin));
  plugin.cfg = c;
  api = GNUNET_new (struct GNUNET_REST_Plugin);
  api->cls = &plugin;
  api->name = GNUNET_REST_API_NS_IDENTITY;
  GNUNET_asprintf (&allow_methods,
                   "%s, %s, %s, %s, %s",
                   MHD_HTTP_METHOD_GET,
                   MHD_HTTP_METHOD_POST,
                   MHD_HTTP_METHOD_PUT,
                   MHD_HTTP_METHOD_DELETE,
                   MHD_HTTP_METHOD_OPTIONS);
  state = ID_REST_STATE_INIT;
  identity_handle = GNUNET_IDENTITY_connect (id_cfg, &list_ego, NULL);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Identity REST API initialized\n"));
  return api;
}

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

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ REST_identity_done()

void REST_identity_done ( struct GNUNET_REST_Plugin * api )

Exit point from the plugin.

Parameters

cls	the plugin context (as returned by "init")

Returns: always NULL

Definition at line 1284 of file identity_plugin.c.

{
  struct Plugin *plugin = api->cls;
  struct EgoEntry *ego_entry;
  struct EgoEntry *ego_tmp;
 
  plugin->cfg = NULL;
  while (NULL != requests_head)
    cleanup_handle (requests_head);
  if (NULL != identity_handle)
    GNUNET_IDENTITY_disconnect (identity_handle);
 
  for (ego_entry = ego_head; NULL != ego_entry;)
  {
    ego_tmp = ego_entry;
    ego_entry = ego_entry->next;
    GNUNET_free (ego_tmp->identifier);
    GNUNET_free (ego_tmp->keystring);
    GNUNET_free (ego_tmp);
  }
 
  GNUNET_free (allow_methods);
  GNUNET_free (api);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Identity REST plugin is finished\n");
}

References allow_methods, Plugin::api, cleanup_handle(), GNUNET_BLOCK_PluginFunctions::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.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ id_cfg

const struct GNUNET_CONFIGURATION_Handle* id_cfg

The configuration handle.

Definition at line 115 of file identity_plugin.c.

Referenced by ego_sign_data(), and REST_identity_init().

◆ allow_methods

char* allow_methods

static

HTTP methods allows for this plugin.

Definition at line 120 of file identity_plugin.c.

Referenced by options_cont(), REST_identity_done(), and REST_identity_init().

◆ ego_head

struct EgoEntry* ego_head

static

Ego list.

Definition at line 125 of file identity_plugin.c.

Referenced by ego_get_all(), get_egoentry(), list_ego(), and REST_identity_done().

◆ ego_tail

struct EgoEntry* ego_tail

static

Ego list.

Definition at line 130 of file identity_plugin.c.

Referenced by list_ego().

◆ state

int state

static

The processing state.

Definition at line 135 of file identity_plugin.c.

Referenced by list_ego(), and REST_identity_init().

◆ identity_handle

struct GNUNET_IDENTITY_Handle* identity_handle

static

Handle to Identity service.

Definition at line 140 of file identity_plugin.c.

Referenced by ego_create(), ego_delete_name(), ego_delete_pubkey(), ego_edit(), REST_identity_done(), and REST_identity_init().

◆ requests_head

struct RequestHandle* requests_head

static

DLL.

Definition at line 262 of file identity_plugin.c.

Referenced by cleanup_handle(), REST_identity_done(), and REST_identity_process_request().

◆ requests_tail

struct RequestHandle* requests_tail

static

DLL.

Definition at line 267 of file identity_plugin.c.

Referenced by cleanup_handle(), and REST_identity_process_request().

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ GNUNET_REST_API_NS_IDENTITY

◆ GNUNET_REST_API_NS_IDENTITY_PUBKEY

◆ GNUNET_REST_API_NS_IDENTITY_NAME

◆ GNUNET_REST_API_NS_SIGN

◆ GNUNET_REST_IDENTITY_PARAM_PUBKEY

◆ GNUNET_REST_IDENTITY_PARAM_PRIVKEY

◆ GNUNET_REST_IDENTITY_PARAM_NAME

◆ GNUNET_REST_IDENTITY_PARAM_TYPE

◆ GNUNET_REST_IDENTITY_PARAM_NEWNAME

◆ GNUNET_REST_IDENTITY_MISSING_NAME

◆ GNUNET_REST_IDENTITY_MISSING_PUBKEY

◆ GNUNET_REST_ERROR_NO_DATA

◆ GNUNET_REST_ERROR_DATA_INVALID

◆ ID_REST_STATE_INIT

◆ ID_REST_STATE_POST_INIT

Function Documentation

◆ cleanup_handle()

◆ do_error()

◆ get_egoentry()

◆ ego_get_all()

◆ ego_get_response()

◆ ego_get_pubkey()

◆ ego_get_name()

◆ do_finished()

◆ do_finished_create()

◆ ego_edit()

◆ ego_edit_pubkey()

◆ ego_edit_name()

◆ ego_create()

◆ ego_delete_pubkey()

◆ ego_delete_name()

◆ ego_sign_data_cb()

◆ ego_sign_data()

◆ options_cont()

◆ list_ego()

◆ REST_identity_process_request()

◆ REST_identity_init()

◆ REST_identity_done()

Variable Documentation

◆ id_cfg

◆ allow_methods

◆ ego_head

◆ ego_tail

◆ state

◆ identity_handle

◆ requests_head

◆ requests_tail