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 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...
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_Handle *	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...

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

cls	Handle to clean up

Definition at line 261 of file plugin_rest_identity.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(), 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

cls	the struct RequestHandle

Definition at line 289 of file plugin_rest_identity.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(), 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

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 325 of file plugin_rest_identity.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()

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

Definition at line 361 of file plugin_rest_identity.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_IDENTITY_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_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

handle	the struct RequestHandle
ego_entry	the struct EgoEntry for the response

Definition at line 423 of file plugin_rest_identity.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_IDENTITY_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_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_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 472 of file plugin_rest_identity.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.

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

Definition at line 510 of file plugin_rest_identity.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.

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

{
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;
  int response_code;
 
  handle->op = NULL;
  handle->ec = ec;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  if (GNUNET_EC_NONE == handle->ec)
    response_code = MHD_HTTP_NO_CONTENT;
  else
    response_code = GNUNET_ErrorCode_get_http_status (ec);
  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_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

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

Definition at line 578 of file plugin_rest_identity.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()

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

Processing edit ego with EgoEntry ego_entry.

Parameters

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

Definition at line 596 of file plugin_rest_identity.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->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, 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_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 680 of file plugin_rest_identity.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.

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

Definition at line 718 of file plugin_rest_identity.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.

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

Definition at line 756 of file plugin_rest_identity.c.

{
  struct RequestHandle *handle = cls;
  json_t *data_js;
  json_error_t err;
  char *egoname;
  char *privkey;
  struct GNUNET_IDENTITY_PrivateKey pk;
  struct GNUNET_IDENTITY_PrivateKey *pk_ptr;
  int json_unpack_state;
  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!}",
                 GNUNET_REST_IDENTITY_PARAM_NAME, &egoname,
                 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;
  }
 
  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_IDENTITY_PrivateKey));
    pk_ptr = &pk;
  }
  else
    pk_ptr = NULL;
  json_decref (data_js);
  handle->op = GNUNET_IDENTITY_create (identity_handle,
                                       handle->name,
                                       pk_ptr,
                                       GNUNET_IDENTITY_TYPE_ECDSA,
                                       &do_finished_create,
                                       handle);
}

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

Definition at line 851 of file plugin_rest_identity.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->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, 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_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 892 of file plugin_rest_identity.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->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, 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.

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

Definition at line 990 of file plugin_rest_identity.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 (cfg,
                              username,
                              ego_sign_data_cb,
                              cls2);
}

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

Definition at line 1047 of file plugin_rest_identity.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.

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.

{
  struct EgoEntry *ego_entry;
  struct GNUNET_IDENTITY_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_IDENTITY_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_IDENTITY_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_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

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 1066 of file plugin_rest_identity.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;
}

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

cls	Config info

Returns

NULL on error, otherwise the plugin context

Definition at line 1221 of file plugin_rest_identity.c.

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

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

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

Returns

always NULL

Definition at line 1257 of file plugin_rest_identity.c.

{
  struct GNUNET_REST_Plugin *api = cls;
  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");
  return NULL;
}

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

Definition at line 119 of file plugin_rest_identity.c.

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

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

Handle to Identity service.

Definition at line 134 of file plugin_rest_identity.c.

Referenced by ego_create(), ego_delete_name(), ego_delete_pubkey(), ego_edit(), libgnunet_plugin_rest_identity_done(), and libgnunet_plugin_rest_identity_init().

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