plugin_rest_namestore.c File Reference

GNUnet Namestore REST plugin. More...

#include "platform.h"
#include "gnunet_rest_plugin.h"
#include "gnunet_gns_service.h"
#include "gnunet_namestore_service.h"
#include "gnunet_identity_service.h"
#include "gnunet_rest_lib.h"
#include "gnunet_gnsrecord_json_lib.h"
#include "microhttpd.h"
#include <jansson.h>

Include dependency graph for plugin_rest_namestore.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_NAMESTORE   "/namestore"
	Namestore Namespace. More...
#define	GNUNET_REST_NAMESTORE_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_NAMESTORE_FAILED   "Namestore action failed"
	Error message Failed request. More...
#define	GNUNET_REST_NAMESTORE_INVALID_DATA   "Data invalid"
	Error message invalid data. More...
#define	GNUNET_REST_NAMESTORE_NO_DATA   "No data"
	Error message No data. More...
#define	ID_REST_STATE_INIT   0
	State while collecting all egos. More...
#define	ID_REST_STATE_POST_INIT   1
	Done collecting egos. More...

Enumerations
enum	UpdateStrategy { UPDATE_STRATEGY_REPLACE, UPDATE_STRATEGY_APPEND }

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_namestore (struct RequestHandle *handle, 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	namestore_iteration_error (void *cls)
	Does internal server error when iteration failed. More...
static void	create_finished (void *cls, int32_t success, const char *emsg)
	Create finished callback. More...
static void	del_finished (void *cls, int32_t success, const char *emsg)
	Delete finished callback. More...
static void	namestore_list_finished (void *cls)
	Iteration over all results finished, build final response. More...
static void	namestore_list_iteration (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
	Create a response with requested records. More...
static void	ns_lookup_error_cb (void *cls)
	Handle lookup error. More...
static void	ns_get_lookup_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
void	namestore_get (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
	Handle namestore GET request. More...
static void	ns_lookup_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
void	namestore_add_or_update (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
	Handle namestore POST/PUT request. More...
void	namestore_update (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
	Handle namestore PUT request. More...
void	namestore_add (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
	Handle namestore POST request. More...
void	namestore_delete (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
	Handle namestore DELETE request. 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_namestore_init (void *cls)
	Entry point for the plugin. More...
void *	libgnunet_plugin_rest_namestore_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_NAMESTORE_Handle *	ns_handle
	Handle to NAMESTORE. 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 Namestore REST plugin.

Author

Martin Schanzenbach

Philippe Buschmann

Definition in file plugin_rest_namestore.c.

Macro Definition Documentation

GNUNET_REST_API_NS_NAMESTORE

#define GNUNET_REST_API_NS_NAMESTORE   "/namestore"

Namestore Namespace.

Definition at line 40 of file plugin_rest_namestore.c.

Referenced by libgnunet_plugin_rest_namestore_init(), namestore_add_or_update(), namestore_delete(), namestore_get(), and rest_process_request().

GNUNET_REST_NAMESTORE_ERROR_UNKNOWN

#define GNUNET_REST_NAMESTORE_ERROR_UNKNOWN   "Unknown Error"

Error message Unknown Error.

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

Referenced by namestore_add_or_update(), namestore_delete(), and namestore_get().

GNUNET_REST_NAMESTORE_FAILED

#define GNUNET_REST_NAMESTORE_FAILED   "Namestore action failed"

Error message Failed request.

Definition at line 56 of file plugin_rest_namestore.c.

Referenced by namestore_add_or_update(), namestore_delete(), namestore_get(), namestore_iteration_error(), ns_lookup_cb(), and ns_lookup_error_cb().

GNUNET_REST_NAMESTORE_INVALID_DATA

#define GNUNET_REST_NAMESTORE_INVALID_DATA   "Data invalid"

Error message invalid data.

Definition at line 61 of file plugin_rest_namestore.c.

Referenced by namestore_add_or_update().

GNUNET_REST_NAMESTORE_NO_DATA

#define GNUNET_REST_NAMESTORE_NO_DATA   "No data"

Error message No data.

Definition at line 66 of file plugin_rest_namestore.c.

Referenced by namestore_add_or_update().

ID_REST_STATE_INIT

#define ID_REST_STATE_INIT   0

State while collecting all egos.

Definition at line 71 of file plugin_rest_namestore.c.

Referenced by libgnunet_plugin_rest_namestore_init(), and list_ego().

ID_REST_STATE_POST_INIT

#define ID_REST_STATE_POST_INIT   1

Done collecting egos.

Definition at line 76 of file plugin_rest_namestore.c.

Referenced by list_ego().

Enumeration Type Documentation

UpdateStrategy

enum UpdateStrategy

Enumerator
UPDATE_STRATEGY_REPLACE
UPDATE_STRATEGY_APPEND

Definition at line 152 of file plugin_rest_namestore.c.

{
  UPDATE_STRATEGY_REPLACE,
  UPDATE_STRATEGY_APPEND
};

Function Documentation

cleanup_handle()

static void cleanup_handle ( void *  cls )

static

Cleanup lookup handle.

Parameters

handle

Handle to clean up

Definition at line 286 of file plugin_rest_namestore.c.

References GNUNET_GNSRECORD_Data::data, RequestHandle::emsg, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_free_nz, GNUNET_log, GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_SCHEDULER_cancel(), handle, RequestHandle::list_it, RequestHandle::ns_qe, RequestHandle::rd, RequestHandle::rd_count, RequestHandle::record_name, RequestHandle::resp_object, RequestHandle::timeout_task, and RequestHandle::url.

Referenced by create_finished(), del_finished(), do_error(), namestore_list_finished(), 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->record_name)
    GNUNET_free (handle->record_name);
  if (NULL != handle->url)
    GNUNET_free (handle->url);
  if (NULL != handle->emsg)
    GNUNET_free (handle->emsg);
  if (NULL != handle->rd)
  {
    for (int i = 0; i < handle->rd_count; i++)
    {
      if (NULL != handle->rd[i].data)
        GNUNET_free_nz ((void *) handle->rd[i].data);
    }
    GNUNET_free (handle->rd);
  }
  if (NULL != handle->timeout_task)
    GNUNET_SCHEDULER_cancel (handle->timeout_task);
  if (NULL != handle->list_it)
    GNUNET_NAMESTORE_zone_iteration_stop (handle->list_it);
  if (NULL != handle->ns_qe)
    GNUNET_NAMESTORE_cancel (handle->ns_qe);

  if (NULL != handle->resp_object)
  {
    json_decref (handle->resp_object);
  }
  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 335 of file plugin_rest_namestore.c.

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

Referenced by create_finished(), del_finished(), libgnunet_plugin_rest_namestore_done(), namestore_add_or_update(), namestore_delete(), namestore_get(), namestore_iteration_error(), ns_lookup_cb(), ns_lookup_error_cb(), 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_NAMESTORE_ERROR_UNKNOWN);

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

  if (0 == handle->response_code)
    handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
  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);
  cleanup_handle (handle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_egoentry_namestore()

struct EgoEntry* get_egoentry_namestore	(	struct RequestHandle *	handle,
		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 369 of file plugin_rest_namestore.c.

References GNUNET_free, GNUNET_strdup, EgoEntry::identifier, and EgoEntry::next.

Referenced by namestore_add_or_update(), namestore_delete(), and namestore_get().

{
  struct EgoEntry *ego_entry;
  char *copy = GNUNET_strdup (name);
  char *tmp;

  if (NULL == name)
    return NULL;
  tmp = strtok (copy, "/");
  if (NULL == tmp)
    return NULL;
  for (ego_entry = ego_head; NULL != ego_entry;
       ego_entry = ego_entry->next)
  {
    if (0 != strcasecmp (tmp, ego_entry->identifier))
      continue;
    GNUNET_free (copy);
    return ego_entry;
  }
  GNUNET_free (copy);
  return NULL;
}

Here is the caller graph for this function:

namestore_iteration_error()

static void namestore_iteration_error ( void *  cls )

static

Does internal server error when iteration failed.

Parameters

cls	the struct RequestHandle

Definition at line 399 of file plugin_rest_namestore.c.

References do_error(), RequestHandle::emsg, GNUNET_REST_NAMESTORE_FAILED, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, and handle.

Referenced by namestore_get().

{
  struct RequestHandle *handle = cls;

  handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
  GNUNET_SCHEDULER_add_now (&do_error, handle);
  return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_finished()

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

static

Create finished callback.

Parameters

cls	the struct RequestHandle
success	the success indicating integer, GNUNET_OK on success
emsg	the error message (can be NULL)

Definition at line 417 of file plugin_rest_namestore.c.

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

Referenced by ns_lookup_cb().

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

  handle->ns_qe = NULL;
  if (GNUNET_YES != success)
  {
    if (NULL != emsg)
    {
      handle->emsg = GNUNET_strdup (emsg);
      GNUNET_SCHEDULER_add_now (&do_error, handle);
      return;
    }
    handle->emsg = GNUNET_strdup ("Error storing records");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  resp = GNUNET_REST_create_response (NULL);
  handle->proc (handle->proc_cls, resp, MHD_HTTP_NO_CONTENT);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

del_finished()

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

static

Delete finished callback.

Parameters

cls	the struct RequestHandle
success	the success indicating integer, GNUNET_OK on success
emsg	the error message (can be NULL)

Definition at line 449 of file plugin_rest_namestore.c.

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

Referenced by namestore_delete().

{
  struct RequestHandle *handle = cls;

  handle->ns_qe = NULL;
  if (GNUNET_NO == success)
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup ("No record found");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  if (GNUNET_SYSERR == success)
  {
    if (NULL != emsg)
    {
      handle->emsg = GNUNET_strdup (emsg);
      GNUNET_SCHEDULER_add_now (&do_error, handle);
      return;
    }
    handle->emsg = GNUNET_strdup ("Deleting record failed");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  handle->proc (handle->proc_cls,
                GNUNET_REST_create_response (NULL),
                MHD_HTTP_NO_CONTENT);
  GNUNET_SCHEDULER_add_now (&cleanup_handle, handle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_list_finished()

static void namestore_list_finished ( void *  cls )

static

Iteration over all results finished, build final response.

Parameters

cls	the struct RequestHandle

Definition at line 487 of file plugin_rest_namestore.c.

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

Referenced by namestore_get(), and ns_get_lookup_cb().

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

  handle->list_it = NULL;

  if (NULL == handle->resp_object)
    handle->resp_object = json_array ();

  result_str = json_dumps (handle->resp_object, 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");
  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:

namestore_list_iteration()

static void namestore_list_iteration ( void *  cls, const struct GNUNET_IDENTITY_PrivateKey *  zone_key, const char *  rname, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Create a response with requested records.

Parameters

handle

the RequestHandle

Only add if not empty

Definition at line 514 of file plugin_rest_namestore.c.

References GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_JSON_from_gnsrecord(), GNUNET_GNSRECORD_TYPE_ANY, GNUNET_NAMESTORE_zone_iterator_next(), handle, RequestHandle::list_it, RequestHandle::record_type, GNUNET_GNSRECORD_Data::record_type, and RequestHandle::resp_object.

Referenced by namestore_get().

{
  struct RequestHandle *handle = cls;
  struct GNUNET_GNSRECORD_Data rd_filtered[rd_len];
  json_t *record_obj;
  int i = 0;
  int j = 0;

  if (NULL == handle->resp_object)
    handle->resp_object = json_array ();
  for (i = 0; i < rd_len; i++)
  {
    if ((GNUNET_GNSRECORD_TYPE_ANY != handle->record_type) &&
        (rd[i].record_type != handle->record_type))
      continue; /* Apply filter */
    rd_filtered[j] = rd[i];
    rd_filtered[j].data = rd[i].data;
    j++;
  }
  if (j > 0)
  {
    record_obj = GNUNET_GNSRECORD_JSON_from_gnsrecord (rname,
                                                       rd_filtered,
                                                       j);
    json_array_append_new (handle->resp_object, record_obj);
  }
  GNUNET_NAMESTORE_zone_iterator_next (handle->list_it, 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ns_lookup_error_cb()

static void ns_lookup_error_cb ( void *  cls )

static

Handle lookup error.

Parameters

cls	the request handle

Definition at line 555 of file plugin_rest_namestore.c.

References do_error(), RequestHandle::emsg, GNUNET_REST_NAMESTORE_FAILED, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, and handle.

Referenced by namestore_add_or_update(), and namestore_get().

{
  struct RequestHandle *handle = cls;

  handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
  GNUNET_SCHEDULER_add_now (&do_error, handle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ns_get_lookup_cb()

static void ns_get_lookup_cb ( void *  cls, const struct GNUNET_IDENTITY_PrivateKey *  zone, const char *  label, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Only add if not empty

Definition at line 565 of file plugin_rest_namestore.c.

References GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_JSON_from_gnsrecord(), GNUNET_GNSRECORD_TYPE_ANY, GNUNET_SCHEDULER_add_now(), handle, namestore_list_finished(), RequestHandle::ns_qe, RequestHandle::record_type, GNUNET_GNSRECORD_Data::record_type, and RequestHandle::resp_object.

Referenced by namestore_get().

{
  struct RequestHandle *handle = cls;
  struct GNUNET_GNSRECORD_Data rd_filtered[rd_len];
  json_t *record_obj;
  int i = 0;
  int j = 0;

  handle->ns_qe = NULL;
  if (NULL == handle->resp_object)
    handle->resp_object = json_array ();
  for (i = 0; i < rd_len; i++)
  {
    if ((GNUNET_GNSRECORD_TYPE_ANY != handle->record_type) &&
        (rd[i].record_type != handle->record_type))
      continue; /* Apply filter */
    rd_filtered[j] = rd[i];
    rd_filtered[j].data = rd[i].data;
    j++;
  }
  if (j > 0)
  {
    record_obj = GNUNET_GNSRECORD_JSON_from_gnsrecord (label,
                                                       rd_filtered,
                                                       j);
    json_array_append_new (handle->resp_object, record_obj);
  }
  GNUNET_SCHEDULER_add_now (&namestore_list_finished, handle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_get()

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

Handle namestore GET request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 609 of file plugin_rest_namestore.c.

References do_error(), EgoEntry::ego, RequestHandle::emsg, get_egoentry_namestore(), GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CRYPTO_hash(), GNUNET_GNSRECORD_TYPE_ANY, GNUNET_GNSRECORD_typename_to_number(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_NAMESTORE_records_lookup(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_NO, GNUNET_REST_API_NS_NAMESTORE, GNUNET_REST_IDENTITY_NOT_FOUND, GNUNET_REST_NAMESTORE_FAILED, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, EgoEntry::identifier, RequestHandle::list_it, namestore_iteration_error(), namestore_list_finished(), namestore_list_iteration(), ns_get_lookup_cb(), ns_lookup_error_cb(), RequestHandle::ns_qe, RequestHandle::record_name, RequestHandle::record_type, RequestHandle::response_code, RequestHandle::url, GNUNET_REST_RequestHandle::url_param_map, and RequestHandle::zone_pkey.

Referenced by rest_process_request().

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  struct GNUNET_HashCode key;
  char *egoname;
  char *labelname;
  char *typename;

  egoname = NULL;
  ego_entry = NULL;

  // set zone to name if given
  if (strlen (GNUNET_REST_API_NS_NAMESTORE) + 1  >= strlen (handle->url))
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
  ego_entry = get_egoentry_namestore (handle, 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;
  }
  handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);

  GNUNET_CRYPTO_hash ("record_type", strlen ("record_type"), &key);
  if (GNUNET_NO ==
      GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map, &key))
  {
    handle->record_type = GNUNET_GNSRECORD_TYPE_ANY;
  }
  else
  {
    typename = GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map,
                                                  &key);
    handle->record_type = GNUNET_GNSRECORD_typename_to_number (typename);
  }
  labelname = &egoname[strlen (ego_entry->identifier)];
  // set zone to name if given
  if (1 >= strlen (labelname))
  {
    handle->list_it =
      GNUNET_NAMESTORE_zone_iteration_start (ns_handle,
                                             handle->zone_pkey,
                                             &namestore_iteration_error,
                                             handle,
                                             &namestore_list_iteration,
                                             handle,
                                             &namestore_list_finished,
                                             handle);
    if (NULL == handle->list_it)
    {
      handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
      GNUNET_SCHEDULER_add_now (&do_error, handle);
      return;
    }
    return;
  }
  handle->record_name = GNUNET_strdup (labelname + 1);
  handle->ns_qe = GNUNET_NAMESTORE_records_lookup (ns_handle,
                                                   handle->zone_pkey,
                                                   handle->record_name,
                                                   &ns_lookup_error_cb,
                                                   handle,
                                                   &ns_get_lookup_cb,
                                                   handle);
  if (NULL == handle->ns_qe)
  {
    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ns_lookup_cb()

static void ns_lookup_cb ( void *  cls, const struct GNUNET_IDENTITY_PrivateKey *  zone, const char *  label, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Definition at line 693 of file plugin_rest_namestore.c.

References create_finished(), do_error(), GNUNET_NAMESTORE_records_store(), GNUNET_REST_NAMESTORE_FAILED, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, and UPDATE_STRATEGY_APPEND.

Referenced by namestore_add_or_update().

{
  struct RequestHandle *handle = cls;
  struct GNUNET_GNSRECORD_Data rd_new[rd_count + handle->rd_count];
  int i = 0;
  int j = 0;

  if (UPDATE_STRATEGY_APPEND == handle->update_strategy)
  {
    for (i = 0; i < rd_count; i++)
      rd_new[i] = rd[i];
  }
  for (j = 0; j < handle->rd_count; j++)
    rd_new[i + j] = handle->rd[j];
  handle->ns_qe = GNUNET_NAMESTORE_records_store (ns_handle,
                                                  handle->zone_pkey,
                                                  handle->record_name,
                                                  i + j,
                                                  rd_new,
                                                  &create_finished,
                                                  handle);
  if (NULL == handle->ns_qe)
  {
    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_add_or_update()

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

Handle namestore POST/PUT request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 735 of file plugin_rest_namestore.c.

References GNUNET_REST_RequestHandle::data, GNUNET_REST_RequestHandle::data_size, do_error(), EgoEntry::ego, RequestHandle::emsg, get_egoentry_namestore(), GNUNET_GNSRECORD_JSON_spec_gnsrecord(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_JSON_parse(), GNUNET_JSON_parse_free(), GNUNET_JSON_spec_end(), GNUNET_memcpy, GNUNET_NAMESTORE_records_lookup(), GNUNET_OK, GNUNET_REST_API_NS_NAMESTORE, GNUNET_REST_IDENTITY_NOT_FOUND, GNUNET_REST_NAMESTORE_FAILED, GNUNET_REST_NAMESTORE_INVALID_DATA, GNUNET_REST_NAMESTORE_NO_DATA, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, ns_lookup_cb(), ns_lookup_error_cb(), RequestHandle::ns_qe, RequestHandle::rd, RequestHandle::rd_count, RequestHandle::record_name, RequestHandle::response_code, RequestHandle::rest_handle, RequestHandle::url, and RequestHandle::zone_pkey.

Referenced by namestore_add(), and namestore_update().

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *egoname;
  json_t *data_js;
  json_error_t err;

  char term_data[handle->rest_handle->data_size + 1];

  if (0 >= handle->rest_handle->data_size)
  {
    handle->response_code = MHD_HTTP_BAD_REQUEST;
    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_NO_DATA);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  term_data[handle->rest_handle->data_size] = '\0';
  GNUNET_memcpy (term_data,
                 handle->rest_handle->data,
                 handle->rest_handle->data_size);
  data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
  struct GNUNET_JSON_Specification gnsspec[] =
  { GNUNET_GNSRECORD_JSON_spec_gnsrecord (&handle->rd, &handle->rd_count,
                                &handle->record_name),
    GNUNET_JSON_spec_end () };
  if (GNUNET_OK != GNUNET_JSON_parse (data_js, gnsspec, NULL, NULL))
  {
    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_INVALID_DATA);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
  GNUNET_JSON_parse_free (gnsspec);
  if (0 >= strlen (handle->record_name))
  {
    handle->response_code = MHD_HTTP_BAD_REQUEST;
    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_INVALID_DATA);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
  json_decref (data_js);

  egoname = NULL;
  ego_entry = NULL;

  // set zone to name if given
  if (strlen (GNUNET_REST_API_NS_NAMESTORE) + 1 >= strlen (handle->url))
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
  ego_entry = get_egoentry_namestore (handle, 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;
  }
  handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
  handle->ns_qe = GNUNET_NAMESTORE_records_lookup (ns_handle,
                                                   handle->zone_pkey,
                                                   handle->record_name,
                                                   &ns_lookup_error_cb,
                                                   handle,
                                                   &ns_lookup_cb,
                                                   handle);
  if (NULL == handle->ns_qe)
  {
    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_update()

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

Handle namestore PUT request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 827 of file plugin_rest_namestore.c.

References handle, namestore_add_or_update(), RequestHandle::update_strategy, and UPDATE_STRATEGY_REPLACE.

Referenced by rest_process_request().

{
  struct RequestHandle *handle = cls;
  handle->update_strategy = UPDATE_STRATEGY_REPLACE;
  namestore_add_or_update (con_handle, url, cls);
}

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_add()

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

Handle namestore POST request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 845 of file plugin_rest_namestore.c.

References handle, namestore_add_or_update(), RequestHandle::update_strategy, and UPDATE_STRATEGY_APPEND.

Referenced by rest_process_request().

{
  struct RequestHandle *handle = cls;
  handle->update_strategy = UPDATE_STRATEGY_APPEND;
  namestore_add_or_update (con_handle, url, cls);
}

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_delete()

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

Handle namestore DELETE request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 863 of file plugin_rest_namestore.c.

References del_finished(), do_error(), EgoEntry::ego, RequestHandle::emsg, get_egoentry_namestore(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_NAMESTORE_records_store(), GNUNET_REST_API_NS_NAMESTORE, GNUNET_REST_IDENTITY_NOT_FOUND, GNUNET_REST_NAMESTORE_FAILED, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, EgoEntry::identifier, RequestHandle::ns_qe, RequestHandle::record_name, RequestHandle::response_code, RequestHandle::url, and RequestHandle::zone_pkey.

Referenced by rest_process_request().

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

  egoname = NULL;
  ego_entry = NULL;

  // set zone to name if given
  if (strlen (GNUNET_REST_API_NS_NAMESTORE) + 1 >= strlen (handle->url))
  {
    handle->response_code = MHD_HTTP_NOT_FOUND;
    handle->emsg = GNUNET_strdup (GNUNET_REST_IDENTITY_NOT_FOUND);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
  ego_entry = get_egoentry_namestore (handle, 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;
  }
  handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
  labelname = &egoname[strlen (ego_entry->identifier)];
  // set zone to name if given
  if (1 >= strlen (labelname))
  {
    /* label is only "/" */
    handle->response_code = MHD_HTTP_BAD_REQUEST;
    handle->emsg = GNUNET_strdup ("Label missing");
    GNUNET_SCHEDULER_add_now (&do_error, handle);
  }

  handle->record_name = GNUNET_strdup (labelname + 1);
  handle->ns_qe = GNUNET_NAMESTORE_records_store (ns_handle,
                                                  handle->zone_pkey,
                                                  handle->record_name,
                                                  0,
                                                  NULL,
                                                  &del_finished,
                                                  handle);
  if (NULL == handle->ns_qe)
  {
    handle->emsg = GNUNET_strdup (GNUNET_REST_NAMESTORE_FAILED);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
}

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 928 of file plugin_rest_namestore.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;

  // 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 945 of file plugin_rest_namestore.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_namestore_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 1032 of file plugin_rest_namestore.c.

References cleanup_handle(), do_error(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_REST_API_NS_NAMESTORE, GNUNET_REST_handle_request(), GNUNET_REST_HANDLER_END, GNUNET_SCHEDULER_add_delayed(), GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, handle, namestore_add(), namestore_delete(), namestore_get(), namestore_update(), 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, RequestHandle::url, and RequestHandle::zone_pkey.

Referenced by libgnunet_plugin_rest_namestore_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_NAMESTORE, &namestore_get },
    { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_NAMESTORE, &namestore_add },
    { MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_NAMESTORE, &namestore_update },
    { MHD_HTTP_METHOD_DELETE, GNUNET_REST_API_NS_NAMESTORE, &namestore_delete },
    { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_NAMESTORE, &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->zone_pkey = NULL;
  handle->timeout_task =
    GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_error, handle);
  handle->url = GNUNET_strdup (rest_handle->url);
  if (handle->url[strlen (handle->url) - 1] == '/')
    handle->url[strlen (handle->url) - 1] = '\0';
  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_namestore_init()

void* libgnunet_plugin_rest_namestore_init

(

void *

cls

)

Entry point for the plugin.

Parameters

cls	Config info

Returns

NULL on error, otherwise the plugin context

Definition at line 1080 of file plugin_rest_namestore.c.

References _, allow_methods, Plugin::api, Plugin::cfg, GNUNET_REST_Plugin::cls, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_IDENTITY_connect(), GNUNET_log, GNUNET_NAMESTORE_connect(), GNUNET_new, GNUNET_REST_API_NS_NAMESTORE, 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_NAMESTORE;
  api->process_request = &rest_process_request;
  state = ID_REST_STATE_INIT;
  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);
  ns_handle = GNUNET_NAMESTORE_connect (cfg);
  identity_handle = GNUNET_IDENTITY_connect (cfg, &list_ego, NULL);

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Namestore REST API initialized\n"));
  return api;
}

Here is the call graph for this function:

libgnunet_plugin_rest_namestore_done()

void* libgnunet_plugin_rest_namestore_done

(

void *

cls

)

Exit point from the plugin.

Parameters

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

Returns

always NULL

Definition at line 1117 of file plugin_rest_namestore.c.

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

{
  struct GNUNET_REST_Plugin *api = cls;
  struct Plugin *plugin = api->cls;
  struct RequestHandle *request;
  struct EgoEntry *ego_entry;
  struct EgoEntry *ego_tmp;

  plugin->cfg = NULL;
  while (NULL != (request = requests_head))
    do_error (request);
  if (NULL != identity_handle)
    GNUNET_IDENTITY_disconnect (identity_handle);
  if (NULL != ns_handle)
    GNUNET_NAMESTORE_disconnect (ns_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, "Namestore 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 80 of file plugin_rest_namestore.c.

allow_methods

char* allow_methods

static

HTTP methods allows for this plugin.

Definition at line 85 of file plugin_rest_namestore.c.

Referenced by libgnunet_plugin_rest_namestore_done(), libgnunet_plugin_rest_namestore_init(), and options_cont().

ego_head

struct EgoEntry* ego_head

static

Ego list.

Definition at line 90 of file plugin_rest_namestore.c.

ego_tail

struct EgoEntry* ego_tail

static

Ego list.

Definition at line 95 of file plugin_rest_namestore.c.

state

int state

static

The processing state.

Definition at line 100 of file plugin_rest_namestore.c.

Referenced by libgnunet_plugin_rest_namestore_init(), and list_ego().

ns_handle

struct GNUNET_NAMESTORE_Handle* ns_handle

static

Handle to NAMESTORE.

Definition at line 105 of file plugin_rest_namestore.c.

identity_handle

struct GNUNET_IDENTITY_Handle* identity_handle

static

Handle to Identity service.

Definition at line 110 of file plugin_rest_namestore.c.

requests_head

struct RequestHandle* requests_head

static

DLL.

Definition at line 273 of file plugin_rest_namestore.c.

requests_tail

struct RequestHandle* requests_tail

static

DLL.

Definition at line 278 of file plugin_rest_namestore.c.