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

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_IDENTITY_SUBSYSTEM   "/identity/subsystem"
	Identity Subsystem Namespace. 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_SUBSYSTEM   "subsystem"
	Parameter subsystem. 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_ERROR_UNKNOWN   "Unknown Error"
	Error message Unknown Error. More...
#define	GNUNET_REST_IDENTITY_NOT_FOUND   "No identity found"
	Error message No identity found. 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...
static void	ego_get_for_subsystem (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
	Callback for GET Request with subsystem. More...
void	ego_get_subsystem (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
	Handle identity GET request for subsystem. 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, const char *emsg)
	Processing finished. More...
static void	do_finished_create (void *cls, const struct GNUNET_IDENTITY_PrivateKey *pk, const char *emsg)
	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_edit_subsystem (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
	Handle identity subsystem 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...
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 37 of file plugin_rest_identity.c.

Referenced by ego_create(), libgnunet_plugin_rest_identity_init(), and rest_process_request().

GNUNET_REST_API_NS_IDENTITY_PUBKEY

#define GNUNET_REST_API_NS_IDENTITY_PUBKEY   "/identity/pubkey"

Identity Namespace with public key specifier.

Definition at line 42 of file plugin_rest_identity.c.

Referenced by ego_delete_pubkey(), ego_edit_pubkey(), ego_get_pubkey(), and rest_process_request().

GNUNET_REST_API_NS_IDENTITY_NAME

#define GNUNET_REST_API_NS_IDENTITY_NAME   "/identity/name"

Identity Namespace with public key specifier.

Definition at line 47 of file plugin_rest_identity.c.

Referenced by ego_delete_name(), ego_edit_name(), ego_get_name(), and rest_process_request().

GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM

#define GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM   "/identity/subsystem"

Identity Subsystem Namespace.

Definition at line 52 of file plugin_rest_identity.c.

Referenced by ego_edit_subsystem(), ego_get_subsystem(), and rest_process_request().

GNUNET_REST_IDENTITY_PARAM_PUBKEY

#define GNUNET_REST_IDENTITY_PARAM_PUBKEY   "pubkey"

Parameter public key.

Definition at line 57 of file plugin_rest_identity.c.

Referenced by ego_get_all(), ego_get_for_subsystem(), and ego_get_response().

GNUNET_REST_IDENTITY_PARAM_PRIVKEY

#define GNUNET_REST_IDENTITY_PARAM_PRIVKEY   "privkey"

Parameter private key.

Definition at line 62 of file plugin_rest_identity.c.

Referenced by ego_create(), ego_get_all(), and ego_get_response().

GNUNET_REST_IDENTITY_PARAM_SUBSYSTEM

#define GNUNET_REST_IDENTITY_PARAM_SUBSYSTEM   "subsystem"

Parameter subsystem.

Definition at line 67 of file plugin_rest_identity.c.

Referenced by ego_edit_subsystem().

GNUNET_REST_IDENTITY_PARAM_NAME

#define GNUNET_REST_IDENTITY_PARAM_NAME   "name"

Parameter name.

Definition at line 72 of file plugin_rest_identity.c.

Referenced by ego_create(), ego_get_all(), ego_get_for_subsystem(), and ego_get_response().

GNUNET_REST_IDENTITY_PARAM_NEWNAME

#define GNUNET_REST_IDENTITY_PARAM_NEWNAME   "newname"

Parameter new name.

Definition at line 77 of file plugin_rest_identity.c.

Referenced by ego_edit().

GNUNET_REST_IDENTITY_ERROR_UNKNOWN

#define GNUNET_REST_IDENTITY_ERROR_UNKNOWN   "Unknown Error"

Error message Unknown Error.

Definition at line 82 of file plugin_rest_identity.c.

Referenced by do_error().

GNUNET_REST_IDENTITY_NOT_FOUND

#define GNUNET_REST_IDENTITY_NOT_FOUND   "No identity found"

Error message No identity found.

Definition at line 87 of file plugin_rest_identity.c.

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

GNUNET_REST_IDENTITY_MISSING_NAME

#define GNUNET_REST_IDENTITY_MISSING_NAME   "Missing identity name"

Error message Missing identity name.

Definition at line 92 of file plugin_rest_identity.c.

Referenced by ego_delete_name(), ego_edit_name(), ego_edit_subsystem(), and ego_get_name().

GNUNET_REST_IDENTITY_MISSING_PUBKEY

#define GNUNET_REST_IDENTITY_MISSING_PUBKEY   "Missing identity public key"

Error message Missing identity name.

Definition at line 97 of file plugin_rest_identity.c.

Referenced by ego_delete_pubkey(), ego_edit_pubkey(), and ego_get_pubkey().

GNUNET_REST_ERROR_NO_DATA

#define GNUNET_REST_ERROR_NO_DATA   "No data"

Error message No data.

Definition at line 102 of file plugin_rest_identity.c.

Referenced by ego_create(), ego_edit(), and ego_edit_subsystem().

GNUNET_REST_ERROR_DATA_INVALID

#define GNUNET_REST_ERROR_DATA_INVALID   "Data invalid"

Error message Data invalid.

Definition at line 107 of file plugin_rest_identity.c.

Referenced by ego_create(), ego_edit(), and ego_edit_subsystem().

ID_REST_STATE_INIT

#define ID_REST_STATE_INIT   0

State while collecting all egos.

Definition at line 112 of file plugin_rest_identity.c.

Referenced by libgnunet_plugin_rest_identity_init(), and list_ego().

ID_REST_STATE_POST_INIT

#define ID_REST_STATE_POST_INIT   1

Done collecting egos.

Definition at line 117 of file plugin_rest_identity.c.

Referenced by list_ego().

Function Documentation

cleanup_handle()

static void cleanup_handle ( void *  cls )

static

Cleanup lookup handle.

Parameters

handle

Handle to clean up

Definition at line 279 of file plugin_rest_identity.c.

References RequestHandle::emsg, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_cancel(), handle, RequestHandle::name, RequestHandle::timeout_task, and RequestHandle::url.

Referenced by do_error(), do_finished(), ego_create(), ego_edit(), ego_get_all(), ego_get_for_subsystem(), ego_get_response(), libgnunet_plugin_rest_identity_done(), options_cont(), and rest_process_request().

{
  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->emsg)
    GNUNET_free (handle->emsg);
  if (NULL != handle->name)
    GNUNET_free (handle->name);
  GNUNET_CONTAINER_DLL_remove (requests_head,
                               requests_tail,
                               handle);
  GNUNET_free (handle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_error()

static void do_error ( void *  cls )

static

Task run on errors.

Reports an error and cleans up everything.

Parameters

cls	the struct RequestHandle

Definition at line 309 of file plugin_rest_identity.c.

References cleanup_handle(), RequestHandle::emsg, GNUNET_free, GNUNET_REST_create_response(), GNUNET_REST_IDENTITY_ERROR_UNKNOWN, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, RequestHandle::proc, RequestHandle::proc_cls, response, and RequestHandle::response_code.

Referenced by do_finished(), ego_create(), ego_delete_name(), ego_delete_pubkey(), ego_edit(), ego_edit_name(), ego_edit_pubkey(), ego_edit_subsystem(), ego_get_for_subsystem(), ego_get_name(), ego_get_pubkey(), ego_get_subsystem(), and rest_process_request().

{
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;
  json_t *json_error = json_object ();
  char *response;

  if (NULL == handle->emsg)
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_ERROR_UNKNOWN);

  json_object_set_new (json_error, "error", json_string (handle->emsg));

  if (0 == handle->response_code)
    handle->response_code = MHD_HTTP_OK;
  response = json_dumps (json_error, 0);
  resp = GNUNET_REST_create_response (response);
  MHD_add_response_header (resp, "Content-Type", "application/json");
  handle->proc (handle->proc_cls, resp, handle->response_code);
  json_decref (json_error);
  GNUNET_free (response);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}

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 343 of file plugin_rest_identity.c.

References EgoEntry::identifier, EgoEntry::keystring, and EgoEntry::next.

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

{
  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;
}

Here is the caller graph for this function:

ego_get_for_subsystem()

static void ego_get_for_subsystem ( void *  cls, struct GNUNET_IDENTITY_Ego *  ego, void **  ctx, const char *  name  )

static

Callback for GET Request with subsystem.

Parameters

cls	the RequestHandle
ego	the Ego found
ctx	the context
name	the id of the ego

Definition at line 380 of file plugin_rest_identity.c.

References cleanup_handle(), do_error(), RequestHandle::emsg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_IDENTITY_ego_get_public_key(), GNUNET_IDENTITY_public_key_to_string(), GNUNET_log, GNUNET_REST_create_response(), GNUNET_REST_IDENTITY_NOT_FOUND, GNUNET_REST_IDENTITY_PARAM_NAME, GNUNET_REST_IDENTITY_PARAM_PUBKEY, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, RequestHandle::proc, RequestHandle::proc_cls, and RequestHandle::response_code.

Referenced by ego_get_subsystem().

{
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;
  struct GNUNET_IDENTITY_PublicKey public_key;
  json_t *json_root;
  char *result_str;
  char *public_key_string;

  if (NULL == ego)
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }

  GNUNET_IDENTITY_ego_get_public_key (ego, &public_key);
  public_key_string = GNUNET_IDENTITY_public_key_to_string (&public_key);

  // create json with subsystem identity
  json_root = json_object ();
  json_object_set_new (json_root,
                       GNUNET_REST_IDENTITY_PARAM_PUBKEY,
                       json_string (public_key_string));
  json_object_set_new (json_root,
                       GNUNET_REST_IDENTITY_PARAM_NAME,
                       json_string (name));

  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);
  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_free (public_key_string);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ego_get_subsystem()

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

Handle identity GET request for subsystem.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 432 of file plugin_rest_identity.c.

References do_error(), ego_get_for_subsystem(), RequestHandle::emsg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_IDENTITY_get(), GNUNET_log, GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM, GNUNET_REST_IDENTITY_NOT_FOUND, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, RequestHandle::op, RequestHandle::response_code, subsystem, and RequestHandle::url.

Referenced by rest_process_request().

{
  struct RequestHandle *handle = cls;
  char *subsystem;

  if (strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) >= strlen (handle->url))
  {
    handle->emsg = GNUNET_strdup ("Missing subsystem name");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  subsystem = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) + 1];
  // requested default identity of subsystem
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Looking for %s's ego\n", subsystem);

  handle->op = GNUNET_IDENTITY_get (identity_handle,
                                    subsystem,
                                    &ego_get_for_subsystem,
                                    handle);

  if (NULL == handle->op)
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
}

Here is the call graph for this function:

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 472 of file plugin_rest_identity.c.

References cleanup_handle(), EgoEntry::ego, 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, EgoEntry::keystring, EgoEntry::next, RequestHandle::proc, RequestHandle::proc_cls, RequestHandle::rest_handle, and GNUNET_REST_RequestHandle::url_param_map.

Referenced by rest_process_request().

{
  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);
  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);
}

Here is the call graph for this function:

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

References cleanup_handle(), EgoEntry::ego, 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, EgoEntry::identifier, EgoEntry::keystring, RequestHandle::proc, RequestHandle::proc_cls, RequestHandle::rest_handle, and GNUNET_REST_RequestHandle::url_param_map.

Referenced by ego_get_name(), and ego_get_pubkey().

{
  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);
  MHD_add_response_header (resp, "Content-Type", "application/json");
  json_decref (json_ego);
  GNUNET_free (result_str);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}

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 579 of file plugin_rest_identity.c.

References do_error(), ego_get_response(), RequestHandle::emsg, get_egoentry(), GNUNET_REST_API_NS_IDENTITY_PUBKEY, GNUNET_REST_IDENTITY_MISSING_PUBKEY, GNUNET_REST_IDENTITY_NOT_FOUND, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, EgoEntry::keystring, RequestHandle::response_code, and RequestHandle::url.

Referenced by rest_process_request().

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *keystring;

  keystring = NULL;

  if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_PUBKEY);
    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->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }

  ego_get_response (handle, ego_entry);
}

Here is the call graph for this function:

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

References do_error(), ego_get_response(), RequestHandle::emsg, get_egoentry(), GNUNET_REST_API_NS_IDENTITY_NAME, GNUNET_REST_IDENTITY_MISSING_NAME, GNUNET_REST_IDENTITY_NOT_FOUND, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, RequestHandle::response_code, and RequestHandle::url.

Referenced by rest_process_request().

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *egoname;

  egoname = NULL;

  if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_NAME);
    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->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }

  ego_get_response (handle, ego_entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_finished()

static void do_finished ( void *  cls, const char *  emsg  )

static

Processing finished.

Parameters

cls	request handle
emsg	error message

Definition at line 658 of file plugin_rest_identity.c.

References cleanup_handle(), do_error(), RequestHandle::emsg, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, RequestHandle::op, RequestHandle::proc, RequestHandle::proc_cls, and RequestHandle::response_code.

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

{
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;

  handle->op = NULL;
  if (NULL != emsg)
  {
    handle->emsg = GNUNET_strdup (emsg);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  if (0 == handle->response_code)
  {
    handle->response_code = MHD_HTTP_NO_CONTENT;
  }
  resp = GNUNET_REST_create_response (NULL);
  handle->proc (handle->proc_cls, resp, handle->response_code);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}

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, const char *  emsg  )

static

Processing finished, when creating an ego.

Parameters

cls	request handle
private	key of the ego, or NULL on error
emsg	error message

Definition at line 688 of file plugin_rest_identity.c.

References do_finished(), and handle.

Referenced by ego_create().

{
  struct RequestHandle *handle = cls;

  (void) pk;
  do_finished (handle, emsg);
}

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 706 of file plugin_rest_identity.c.

References cleanup_handle(), RequestHandle::data, RequestHandle::data_size, do_error(), do_finished(), RequestHandle::emsg, get_egoentry(), GNUNET_IDENTITY_rename(), GNUNET_memcpy, GNUNET_REST_create_response(), GNUNET_REST_ERROR_DATA_INVALID, GNUNET_REST_ERROR_NO_DATA, GNUNET_REST_IDENTITY_PARAM_NEWNAME, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, EgoEntry::identifier, RequestHandle::op, RequestHandle::proc, and RequestHandle::proc_cls.

Referenced by ego_edit_name(), and ego_edit_pubkey().

{
  struct EgoEntry *ego_entry_tmp;
  struct MHD_Response *resp;
  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->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
    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->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
    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->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }

  if (NULL == newname)
  {
    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }

  if (0 >= strlen (newname))
  {
    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }

  ego_entry_tmp = get_egoentry (handle, NULL, newname);
  if (NULL != ego_entry_tmp)
  {
    // Ego with same name not allowed (even if its the ego we change)
    resp = GNUNET_REST_create_response (NULL);
    handle->proc (handle->proc_cls, resp, MHD_HTTP_CONFLICT);
    GNUNET_SCHEDULER_add_now (&cleanup_handle, 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->emsg = GNUNET_strdup ("Rename failed");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
  json_decref (data_js);
  return;
}

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 802 of file plugin_rest_identity.c.

References do_error(), ego_edit(), RequestHandle::emsg, get_egoentry(), GNUNET_REST_API_NS_IDENTITY_PUBKEY, GNUNET_REST_IDENTITY_MISSING_PUBKEY, GNUNET_REST_IDENTITY_NOT_FOUND, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, EgoEntry::keystring, RequestHandle::response_code, and RequestHandle::url.

Referenced by rest_process_request().

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *keystring;

  keystring = NULL;

  if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_PUBKEY);
    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->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }

  ego_edit (handle, ego_entry);
}

Here is the call graph for this function:

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

References do_error(), ego_edit(), RequestHandle::emsg, get_egoentry(), GNUNET_REST_API_NS_IDENTITY_NAME, GNUNET_REST_IDENTITY_MISSING_NAME, GNUNET_REST_IDENTITY_NOT_FOUND, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, Plugin::name, RequestHandle::response_code, and RequestHandle::url.

Referenced by rest_process_request().

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *name;

  name = NULL;

  if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_NAME);
    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->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }

  ego_edit (handle, ego_entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ego_edit_subsystem()

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

Handle identity subsystem PUT request with name.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 882 of file plugin_rest_identity.c.

References RequestHandle::data, RequestHandle::data_size, do_error(), do_finished(), EgoEntry::ego, RequestHandle::emsg, get_egoentry(), GNUNET_IDENTITY_set(), GNUNET_memcpy, GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM, GNUNET_REST_ERROR_DATA_INVALID, GNUNET_REST_ERROR_NO_DATA, GNUNET_REST_IDENTITY_MISSING_NAME, GNUNET_REST_IDENTITY_NOT_FOUND, GNUNET_REST_IDENTITY_PARAM_SUBSYSTEM, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, Plugin::name, RequestHandle::op, RequestHandle::response_code, and RequestHandle::url.

Referenced by rest_process_request().

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  json_t *data_js;
  json_error_t err;
  char *newsubsys;
  char *name;
  char term_data[handle->data_size + 1];
  int json_state;

  name = NULL;

  if (strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) >= strlen (handle->url))
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_NAME);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  name = &handle->url[strlen (GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) + 1];
  ego_entry = get_egoentry (handle, NULL, name);

  if (NULL == ego_entry)
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }

  // if no data
  if (0 >= handle->data_size)
  {
    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
    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->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }

  newsubsys = NULL;
  // SUBSYSTEM
  json_state = 0;
  json_state = json_unpack (data_js,
                            "{s:s!}",
                            GNUNET_REST_IDENTITY_PARAM_SUBSYSTEM,
                            &newsubsys);
  // Change subsystem with pubkey or name identifier
  if (0 != json_state)
  {
    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }

  if (NULL == newsubsys)
  {
    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }

  if (0 >= strlen (newsubsys))
  {
    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }

  handle->response_code = MHD_HTTP_NO_CONTENT;
  handle->op = GNUNET_IDENTITY_set (identity_handle,
                                    newsubsys,
                                    ego_entry->ego,
                                    &do_finished,
                                    handle);
  if (NULL == handle->op)
  {
    handle->emsg = GNUNET_strdup ("Setting subsystem failed");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  json_decref (data_js);
  return;
}

Here is the call graph for this function:

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

References cleanup_handle(), RequestHandle::data, RequestHandle::data_size, do_error(), do_finished_create(), RequestHandle::emsg, GNUNET_IDENTITY_create(), GNUNET_IDENTITY_TYPE_ECDSA, GNUNET_memcpy, GNUNET_REST_API_NS_IDENTITY, GNUNET_REST_create_response(), GNUNET_REST_ERROR_DATA_INVALID, GNUNET_REST_ERROR_NO_DATA, 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, EgoEntry::identifier, RequestHandle::name, EgoEntry::next, RequestHandle::op, pk, RequestHandle::proc, RequestHandle::proc_cls, RequestHandle::response_code, and RequestHandle::url.

Referenced by rest_process_request().

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  struct MHD_Response *resp;
  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->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
    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->emsg = GNUNET_strdup (GNUNET_REST_ERROR_NO_DATA);
    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->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }

  if (NULL == egoname)
  {
    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
  if (0 >= strlen (egoname))
  {
    json_decref (data_js);
    handle->emsg = GNUNET_strdup (GNUNET_REST_ERROR_DATA_INVALID);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  GNUNET_STRINGS_utf8_tolower (egoname, egoname);
  for (ego_entry = ego_head; NULL != ego_entry;
       ego_entry = ego_entry->next)
  {
    if (0 == strcasecmp (egoname, ego_entry->identifier))
    {
      resp = GNUNET_REST_create_response (NULL);
      handle->proc (handle->proc_cls, resp, MHD_HTTP_CONFLICT);
      GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
      json_decref (data_js);
      return;
    }
  }
  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->response_code = MHD_HTTP_CREATED;
  handle->op = GNUNET_IDENTITY_create (identity_handle,
                                       handle->name,
                                       pk_ptr,
                                       GNUNET_IDENTITY_TYPE_ECDSA,
                                       &do_finished_create,
                                       handle);
}

Here is the call graph for this function:

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

References do_error(), do_finished(), RequestHandle::emsg, get_egoentry(), GNUNET_IDENTITY_delete(), GNUNET_REST_API_NS_IDENTITY_PUBKEY, GNUNET_REST_IDENTITY_MISSING_PUBKEY, GNUNET_REST_IDENTITY_NOT_FOUND, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, EgoEntry::identifier, EgoEntry::keystring, RequestHandle::op, RequestHandle::response_code, and RequestHandle::url.

Referenced by rest_process_request().

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *keystring;

  keystring = NULL;

  if (strlen (GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen (handle->url))
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_PUBKEY);
    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->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }

  handle->response_code = MHD_HTTP_NO_CONTENT;
  handle->op = GNUNET_IDENTITY_delete (identity_handle,
                                       ego_entry->identifier,
                                       &do_finished,
                                       handle);
}

Here is the call graph for this function:

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

References do_error(), do_finished(), RequestHandle::emsg, get_egoentry(), GNUNET_IDENTITY_delete(), GNUNET_REST_API_NS_IDENTITY_NAME, GNUNET_REST_IDENTITY_MISSING_NAME, GNUNET_REST_IDENTITY_NOT_FOUND, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, EgoEntry::identifier, Plugin::name, RequestHandle::op, RequestHandle::response_code, and RequestHandle::url.

Referenced by rest_process_request().

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *name;

  name = NULL;

  if (strlen (GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen (handle->url))
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_MISSING_NAME);
    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->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }

  handle->response_code = MHD_HTTP_NO_CONTENT;
  handle->op = GNUNET_IDENTITY_delete (identity_handle,
                                       ego_entry->identifier,
                                       &do_finished,
                                       handle);
}

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 1189 of file plugin_rest_identity.c.

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

Referenced by rest_process_request().

{
  struct MHD_Response *resp;
  struct RequestHandle *handle = cls;

  // For now, independent of path return all options
  resp = GNUNET_REST_create_response (NULL);
  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;
}

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 1206 of file plugin_rest_identity.c.

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

Referenced by libgnunet_plugin_rest_identity_init().

{
  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 (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;
  }

}

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 1293 of file plugin_rest_identity.c.

References cleanup_handle(), GNUNET_REST_RequestHandle::data, RequestHandle::data, GNUNET_REST_RequestHandle::data_size, RequestHandle::data_size, do_error(), ego_create(), ego_delete_name(), ego_delete_pubkey(), ego_edit_name(), ego_edit_pubkey(), ego_edit_subsystem(), ego_get_all(), ego_get_name(), ego_get_pubkey(), ego_get_subsystem(), 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_IDENTITY_SUBSYSTEM, GNUNET_REST_handle_request(), GNUNET_REST_HANDLER_END, GNUNET_SCHEDULER_add_delayed(), GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, handle, options_cont(), GNUNET_REST_RequestHandler::proc, RequestHandle::proc, RequestHandle::proc_cls, RequestHandle::response_code, RequestHandle::rest_handle, RequestHandle::timeout, RequestHandle::timeout_task, GNUNET_REST_RequestHandle::url, and RequestHandle::url.

Referenced by libgnunet_plugin_rest_identity_init().

{
  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_SUBSYSTEM,
      &ego_get_subsystem },
    { 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_PUT,
      GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM,
      &ego_edit_subsystem },
    { 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 },
    GNUNET_REST_HANDLER_END };


  handle->response_code = 0;
  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;
}

Here is the call graph for this function:

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 1361 of file plugin_rest_identity.c.

References _, allow_methods, Plugin::api, Plugin::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, list_ego(), GNUNET_REST_Plugin::name, plugin, GNUNET_REST_Plugin::process_request, rest_process_request(), and state.

{
  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;
}

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 1397 of file plugin_rest_identity.c.

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

{
  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;
}

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 122 of file plugin_rest_identity.c.

allow_methods

char* allow_methods

static

HTTP methods allows for this plugin.

Definition at line 127 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 132 of file plugin_rest_identity.c.

ego_tail

struct EgoEntry* ego_tail

static

Ego list.

Definition at line 137 of file plugin_rest_identity.c.

state

int state

static

The processing state.

Definition at line 142 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 147 of file plugin_rest_identity.c.

requests_head

struct RequestHandle* requests_head

static

DLL.

Definition at line 267 of file plugin_rest_identity.c.

requests_tail

struct RequestHandle* requests_tail

static

DLL.

Definition at line 272 of file plugin_rest_identity.c.