plugin_rest_namestore.c File Reference

GNUnet Namestore REST plugin. More...

#include "platform.h"
#include "gnunet_error_codes.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_API_NS_NAMESTORE_IMPORT   "/namestore/import"
	Namestore import API namespace. 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, enum GNUNET_ErrorCode ec)
static void	del_finished (void *cls, enum GNUNET_ErrorCode ec)
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, struct GNUNET_TIME_Absolute expiry)
	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)
static void	bulk_tx_commit_cb (void *cls, enum GNUNET_ErrorCode ec)
static void	import_next_cb (void *cls, enum GNUNET_ErrorCode ec)
static void	bulk_tx_start (void *cls, enum GNUNET_ErrorCode ec)
void	namestore_import (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
	Handle namestore POST import. More...
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 41 of file plugin_rest_namestore.c.

GNUNET_REST_API_NS_NAMESTORE_IMPORT

#define GNUNET_REST_API_NS_NAMESTORE_IMPORT   "/namestore/import"

Namestore import API namespace.

Definition at line 46 of file plugin_rest_namestore.c.

ID_REST_STATE_INIT

#define ID_REST_STATE_INIT   0

State while collecting all egos.

Definition at line 51 of file plugin_rest_namestore.c.

ID_REST_STATE_POST_INIT

#define ID_REST_STATE_POST_INIT   1

Done collecting egos.

Definition at line 56 of file plugin_rest_namestore.c.

Enumeration Type Documentation

UpdateStrategy

enum UpdateStrategy

Enumerator
UPDATE_STRATEGY_REPLACE
UPDATE_STRATEGY_APPEND

Definition at line 132 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

cls	Handle to clean up

Definition at line 282 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
  if (NULL != handle->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (handle->timeout_task);
    handle->timeout_task = NULL;
  }
  if (NULL != handle->record_name)
    GNUNET_free (handle->record_name);
  if (NULL != handle->url)
    GNUNET_free (handle->url);
  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->nc)
    GNUNET_NAMESTORE_disconnect (handle->nc);
  if (NULL != handle->resp_object)
  {
    json_decref (handle->resp_object);
  }
  GNUNET_CONTAINER_DLL_remove (requests_head,
                               requests_tail,
                               handle);
  GNUNET_free (handle);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_free_nz, GNUNET_log, GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_disconnect(), GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_SCHEDULER_cancel(), handle, requests_head, and requests_tail.

Referenced by bulk_tx_commit_cb(), create_finished(), del_finished(), do_error(), namestore_list_finished(), and options_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

do_error()

static void do_error ( void *  cls )

static

Task run on errors.

Reports an error and cleans up everything.

Parameters

cls	the struct RequestHandle

Definition at line 330 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;
  json_t *json_error = json_object ();
  char *response;
  const char* emsg;
  int response_code;
 
  emsg = GNUNET_ErrorCode_get_hint (handle->ec);
  json_object_set_new (json_error, "error", json_string (emsg));
  json_object_set_new (json_error, "error_code", json_integer (handle->ec));
  response_code = GNUNET_ErrorCode_get_http_status (handle->ec);
  if (0 == response_code)
    response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
  response = json_dumps (json_error, 0);
  resp = GNUNET_REST_create_response (response);
  GNUNET_assert (MHD_YES ==
                 MHD_add_response_header (resp, "Content-Type",
                                          "application/json"));
  handle->proc (handle->proc_cls, resp, response_code);
  json_decref (json_error);
  GNUNET_free (response);
  cleanup_handle (handle);
}

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

Referenced by bulk_tx_commit_cb(), bulk_tx_start(), create_finished(), del_finished(), import_next_cb(), libgnunet_plugin_rest_namestore_done(), namestore_add_or_update(), namestore_delete(), namestore_get(), namestore_import(), namestore_iteration_error(), namestore_list_finished(), ns_get_lookup_cb(), ns_lookup_cb(), and ns_lookup_error_cb().

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 367 of file plugin_rest_namestore.c.

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

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

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

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 397 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
 
  handle->ec = GNUNET_EC_NAMESTORE_ITERATION_FAILED;
  GNUNET_SCHEDULER_add_now (&do_error, handle);
  return;
}

References do_error(), GNUNET_EC_NAMESTORE_ITERATION_FAILED, GNUNET_SCHEDULER_add_now(), and handle.

Referenced by namestore_get().

Here is the call graph for this function:

Here is the caller graph for this function:

create_finished()

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

static

Definition at line 408 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;
 
  handle->ns_qe = NULL;
  handle->ec = ec;
  if (GNUNET_EC_NONE != ec)
  {
    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);
}

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

Referenced by ns_lookup_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

del_finished()

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

static

Definition at line 427 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
 
  handle->ns_qe = NULL;
  handle->ec = ec;
  if (GNUNET_EC_NONE != ec)
  {
    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);
}

References cleanup_handle(), do_error(), RequestHandle::ec, GNUNET_EC_NONE, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), handle, and MHD_HTTP_NO_CONTENT.

Referenced by namestore_delete().

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 452 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
  char *result_str;
  struct MHD_Response *resp;
 
  handle->list_it = NULL;
 
  if (NULL == handle->resp_object)
  {
    handle->ec = GNUNET_EC_NAMESTORE_ZONE_EMPTY;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  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);
  GNUNET_assert (MHD_YES ==
                 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);
}

References cleanup_handle(), do_error(), GNUNET_assert, GNUNET_EC_NAMESTORE_ZONE_EMPTY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), handle, and MHD_HTTP_OK.

Referenced by namestore_get(), and ns_get_lookup_cb().

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, struct GNUNET_TIME_Absolute  expiry  )

static

Create a response with requested records.

Parameters

handle

the RequestHandle

skip

Only add if not empty

Definition at line 484 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
  struct GNUNET_GNSRECORD_Data rd_filtered[rd_len];
  json_t *record_obj;
  int i = 0;
  int j = 0;
 
  if (rd_len == 0)
  {
    GNUNET_NAMESTORE_zone_iterator_next (handle->list_it, 1);
    return;
  }
 
  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)
  {
    if (NULL == handle->resp_object)
      handle->resp_object = json_array ();
    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);
}

References GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_JSON_from_gnsrecord(), GNUNET_GNSRECORD_TYPE_ANY, GNUNET_NAMESTORE_zone_iterator_next(), handle, rd, and GNUNET_GNSRECORD_Data::record_type.

Referenced by namestore_get().

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 533 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
 
  handle->ec = GNUNET_EC_NAMESTORE_LOOKUP_ERROR;
  GNUNET_SCHEDULER_add_now (&do_error, handle);
}

References do_error(), GNUNET_EC_NAMESTORE_LOOKUP_ERROR, GNUNET_SCHEDULER_add_now(), and handle.

Referenced by namestore_add_or_update(), and namestore_get().

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

Return 404 if no set was found

Definition at line 543 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
  struct GNUNET_GNSRECORD_Data rd_filtered[rd_len];
  int i = 0;
  int j = 0;
 
  handle->ns_qe = NULL;
  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)
  {
    handle->ec = GNUNET_EC_NAMESTORE_RECORD_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  handle->resp_object = GNUNET_GNSRECORD_JSON_from_gnsrecord (label,
                                                              rd_filtered,
                                                              j);
  GNUNET_SCHEDULER_add_now (&namestore_list_finished, handle);
}

References GNUNET_GNSRECORD_Data::data, do_error(), GNUNET_EC_NAMESTORE_RECORD_NOT_FOUND, GNUNET_GNSRECORD_JSON_from_gnsrecord(), GNUNET_GNSRECORD_TYPE_ANY, GNUNET_SCHEDULER_add_now(), handle, namestore_list_finished(), rd, and GNUNET_GNSRECORD_Data::record_type.

Referenced by namestore_get().

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 586 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  struct GNUNET_HashCode key;
  enum GNUNET_GNSRECORD_Filter filter_flags;
  char *egoname;
  char *labelname;
  char *typename;
  char *boolstring;
 
  egoname = NULL;
  ego_entry = NULL;
 
  // set zone to name if given
  if (strlen (GNUNET_REST_API_NS_NAMESTORE) + 1  >= strlen (handle->url))
  {
    handle->ec = GNUNET_EC_NAMESTORE_ZONE_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->ec = GNUNET_EC_NAMESTORE_ZONE_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);
  handle->record_type = GNUNET_GNSRECORD_TYPE_ANY;
  if (GNUNET_YES ==
      GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map, &key))
  {
    typename = GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map,
                                                  &key);
    if (NULL != typename)
      handle->record_type = GNUNET_GNSRECORD_typename_to_number (typename);
  }
  GNUNET_CRYPTO_hash ("omit_private", strlen ("omit_private"), &key);
  filter_flags = GNUNET_GNSRECORD_FILTER_NONE;
  if (GNUNET_YES ==
      GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map, &key))
  {
    boolstring = GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map,
                                                    &key);
    if ((0 == strcmp (boolstring, "1")) ||
        (0 == strcmp (boolstring, "yes")) ||
        (0 == strcmp (boolstring, "true")))
      filter_flags = GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE;
  }
  GNUNET_CRYPTO_hash ("include_maintenance", strlen ("include_maintenance"),
                      &key);
  if (GNUNET_YES ==
      GNUNET_CONTAINER_multihashmap_contains (con_handle->url_param_map, &key))
  {
    boolstring = GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map,
                                                    &key);
    if ((0 == strcmp (boolstring, "1")) ||
        (0 == strcmp (boolstring, "yes")) ||
        (0 == strcmp (boolstring, "true")))
      filter_flags |= GNUNET_GNSRECORD_FILTER_INCLUDE_MAINTENANCE;
  }
  labelname = &egoname[strlen (ego_entry->identifier)];
  if (1 >= strlen (labelname))
  {
    /* Iterate over all records */
    handle->list_it =
      GNUNET_NAMESTORE_zone_iteration_start2 (ns_handle,
                                              handle->zone_pkey,
                                              &namestore_iteration_error,
                                              handle,
                                              &namestore_list_iteration,
                                              handle,
                                              &namestore_list_finished,
                                              handle,
                                              filter_flags);
    if (NULL == handle->list_it)
    {
      handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
      GNUNET_SCHEDULER_add_now (&do_error, handle);
      return;
    }
    return;
  }
  handle->record_name = GNUNET_strdup (labelname + 1);
  handle->ns_qe = GNUNET_NAMESTORE_records_lookup2 (ns_handle,
                                                    handle->zone_pkey,
                                                    handle->record_name,
                                                    &ns_lookup_error_cb,
                                                    handle,
                                                    &ns_get_lookup_cb,
                                                    handle,
                                                    filter_flags);
  if (NULL == handle->ns_qe)
  {
    handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
}

References do_error(), EgoEntry::ego, egoname, get_egoentry_namestore(), GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CRYPTO_hash(), GNUNET_EC_NAMESTORE_UNKNOWN, GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND, GNUNET_GNSRECORD_FILTER_INCLUDE_MAINTENANCE, GNUNET_GNSRECORD_FILTER_NONE, GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE, GNUNET_GNSRECORD_TYPE_ANY, GNUNET_GNSRECORD_typename_to_number(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_NAMESTORE_records_lookup2(), GNUNET_NAMESTORE_zone_iteration_start2(), GNUNET_REST_API_NS_NAMESTORE, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_YES, handle, EgoEntry::identifier, key, namestore_iteration_error(), namestore_list_finished(), namestore_list_iteration(), ns_get_lookup_cb(), ns_handle, ns_lookup_error_cb(), and GNUNET_REST_RequestHandle::url_param_map.

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

{
  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->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
}

References create_finished(), do_error(), GNUNET_EC_NAMESTORE_UNKNOWN, GNUNET_NAMESTORE_records_store(), GNUNET_SCHEDULER_add_now(), handle, ns_handle, rd, rd_count, and UPDATE_STRATEGY_APPEND.

Referenced by namestore_add_or_update().

Here is the call graph for this function:

Here is the caller graph for this function:

bulk_tx_commit_cb()

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

static

Definition at line 729 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
  struct MHD_Response *resp;
 
  handle->ns_qe = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Commit finished (%d)\n", ec);
  handle->ec = ec;
  if (GNUNET_EC_NONE != ec)
  {
    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);
}

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

Referenced by import_next_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

import_next_cb()

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

static

Definition at line 750 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Import finished (%d)\n", ec);
  handle->ns_qe = NULL;
  handle->ec = ec;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  unsigned int remaining = handle->rd_set_count - handle->rd_set_pos;
  if (0 == remaining)
  {
    handle->ns_qe = GNUNET_NAMESTORE_transaction_commit (handle->nc,
                                                         &bulk_tx_commit_cb,
                                                         handle);
    return;
  }
  unsigned int sent_rds = 0;
  // Find the smallest set of records we can send with our message size
  // restriction of 16 bit
  handle->ns_qe = GNUNET_NAMESTORE_records_store2 (handle->nc,
                                                   handle->zone_pkey,
                                                   remaining,
                                                   &handle->ri[handle->
                                                               rd_set_pos],
                                                   &sent_rds,
                                                   &import_next_cb,
                                                   handle);
  if ((NULL == handle->ns_qe) && (0 == sent_rds))
  {
    handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  handle->rd_set_pos += sent_rds;
}

References bulk_tx_commit_cb(), do_error(), RequestHandle::ec, GNUNET_EC_NAMESTORE_UNKNOWN, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NAMESTORE_records_store2(), GNUNET_NAMESTORE_transaction_commit(), GNUNET_SCHEDULER_add_now(), handle, and RequestHandle::rd_set_pos.

Referenced by bulk_tx_start().

Here is the call graph for this function:

Here is the caller graph for this function:

bulk_tx_start()

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

static

Definition at line 792 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
  json_t *data_js;
  json_error_t err;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Transaction started...\n");
  handle->ec = ec;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  if (0 >= handle->rest_handle->data_size)
  {
    handle->ec = GNUNET_EC_NAMESTORE_NO_RECORDS_GIVEN;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  char term_data[handle->rest_handle->data_size + 1];
  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);
  if (NULL == data_js)
  {
    handle->ec = GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID;
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Error parsing data: %s", err.text);
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  if (! json_is_array (data_js))
  {
    handle->ec = GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
  handle->rd_set_count = json_array_size (data_js);
  handle->ri = GNUNET_malloc (handle->rd_set_count
                              * sizeof (struct GNUNET_NAMESTORE_RecordInfo));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got record set of size %d\n", handle->rd_set_count);
  char *albl;
  size_t index;
  json_t *value;
  json_array_foreach (data_js, index, value) {
    {
      struct GNUNET_GNSRECORD_Data *rd;
      struct GNUNET_JSON_Specification gnsspec[] =
      { GNUNET_GNSRECORD_JSON_spec_gnsrecord (&rd,
                                              &handle->ri[index].a_rd_count,
                                              &albl),
        GNUNET_JSON_spec_end () };
      if (GNUNET_OK != GNUNET_JSON_parse (value, gnsspec, NULL, NULL))
      {
        handle->ec = GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID;
        GNUNET_SCHEDULER_add_now (&do_error, handle);
        json_decref (data_js);
        return;
      }
      handle->ri[index].a_rd = rd;
      handle->ri[index].a_label = albl;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Parsed record set for name %s\n",
                  handle->ri[index].a_label);
    }
  }
  // json_decref (data_js);
 
  unsigned int sent_rds = 0;
  // Find the smallest set of records we can send with our message size
  // restriction of 16 bit
  handle->ns_qe = GNUNET_NAMESTORE_records_store2 (handle->nc,
                                                   handle->zone_pkey,
                                                   handle->rd_set_count,
                                                   handle->ri,
                                                   &sent_rds,
                                                   &import_next_cb,
                                                   handle);
  if ((NULL == handle->ns_qe) && (0 == sent_rds))
  {
    handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  handle->rd_set_pos += sent_rds;
}

References do_error(), RequestHandle::ec, GNUNET_EC_NAMESTORE_NO_RECORDS_GIVEN, GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID, GNUNET_EC_NAMESTORE_UNKNOWN, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_GNSRECORD_JSON_spec_gnsrecord(), GNUNET_JSON_parse(), GNUNET_JSON_spec_end(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_NAMESTORE_records_store2(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), handle, import_next_cb(), rd, and value.

Referenced by namestore_import().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_import()

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

Handle namestore POST import.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 893 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = cls;
  struct EgoEntry *ego_entry;
  char *egoname;
 
  // set zone to name if given
  if (strlen (GNUNET_REST_API_NS_NAMESTORE_IMPORT) + 1 >= strlen (
        handle->url))
  {
    handle->ec = GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  ego_entry = NULL;
 
  egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE_IMPORT) + 1];
  ego_entry = get_egoentry_namestore (handle, egoname);
 
  if (NULL == ego_entry)
  {
    handle->ec = GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
 
  // We need a per-client connection for a transactional bulk import
  handle->nc = GNUNET_NAMESTORE_connect (cfg);
  if (NULL == handle->nc)
  {
    handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  handle->ns_qe = GNUNET_NAMESTORE_transaction_begin (handle->nc,
                                                      &bulk_tx_start,
                                                      handle);
}

References bulk_tx_start(), cfg, do_error(), EgoEntry::ego, egoname, get_egoentry_namestore(), GNUNET_EC_NAMESTORE_UNKNOWN, GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_NAMESTORE_connect(), GNUNET_NAMESTORE_transaction_begin(), GNUNET_REST_API_NS_NAMESTORE_IMPORT, GNUNET_SCHEDULER_add_now(), and handle.

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

{
  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->ec = GNUNET_EC_NAMESTORE_NO_RECORDS_GIVEN;
    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->ec = GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    json_decref (data_js);
    return;
  }
  GNUNET_JSON_parse_free (gnsspec);
  if (0 >= strlen (handle->record_name))
  {
    handle->ec = GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID;
    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->ec = GNUNET_EC_NAMESTORE_ZONE_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->ec = GNUNET_EC_NAMESTORE_ZONE_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->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
}

References do_error(), EgoEntry::ego, egoname, get_egoentry_namestore(), GNUNET_EC_NAMESTORE_NO_RECORDS_GIVEN, GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID, GNUNET_EC_NAMESTORE_UNKNOWN, GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND, 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_SCHEDULER_add_now(), handle, ns_handle, ns_lookup_cb(), and ns_lookup_error_cb().

Referenced by namestore_add(), and namestore_update().

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 1031 of file plugin_rest_namestore.c.

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

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

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

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

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

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

{
  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->ec = GNUNET_EC_NAMESTORE_ZONE_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->ec = GNUNET_EC_NAMESTORE_ZONE_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->ec = GNUNET_EC_NAMESTORE_NO_LABEL_GIVEN;
    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->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
}

References del_finished(), do_error(), EgoEntry::ego, egoname, get_egoentry_namestore(), GNUNET_EC_NAMESTORE_NO_LABEL_GIVEN, GNUNET_EC_NAMESTORE_UNKNOWN, GNUNET_EC_NAMESTORE_ZONE_NOT_FOUND, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_NAMESTORE_records_store(), GNUNET_REST_API_NS_NAMESTORE, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, EgoEntry::identifier, and ns_handle.

Here is the call graph for this function:

options_cont()

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

static

Respond to OPTIONS request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 1129 of file plugin_rest_namestore.c.

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

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

Here is the call graph for this function:

list_ego()

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

static

Definition at line 1149 of file plugin_rest_namestore.c.

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

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

Referenced by libgnunet_plugin_rest_namestore_init().

Here is the call graph for this function:

Here is the caller graph for this function:

rest_process_request()

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

static

Function processing the REST call.

Parameters

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

Returns

GNUNET_OK if request accepted

Definition at line 1149 of file plugin_rest_namestore.c.

{
  struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
  struct GNUNET_REST_RequestHandlerError err;
  static const struct GNUNET_REST_RequestHandler handlers[] =
  { { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_NAMESTORE, &namestore_get },
    { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_NAMESTORE_IMPORT,
      &namestore_import },
    { 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->ec = GNUNET_EC_NONE;
  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;
}

Referenced by libgnunet_plugin_rest_namestore_init().

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 1294 of file plugin_rest_namestore.c.

{
  static struct Plugin plugin;
  struct GNUNET_REST_Plugin *api;
 
  cfg = cls;
  if (NULL != plugin.cfg)
    return NULL;   /* can only initialize once! */
  memset (&plugin, 0, sizeof(struct Plugin));
  plugin.cfg = cfg;
  api = GNUNET_new (struct GNUNET_REST_Plugin);
  api->cls = &plugin;
  api->name = GNUNET_REST_API_NS_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;
}

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

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 1332 of file plugin_rest_namestore.c.

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

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

Here is the call graph for this function:

Variable Documentation

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

The configuration handle.

Handle to our configuration.

Definition at line 60 of file plugin_rest_namestore.c.

Referenced by libgnunet_plugin_rest_namestore_init(), and namestore_import().

allow_methods

char* allow_methods

static

HTTP methods allows for this plugin.

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

Referenced by get_egoentry_namestore(), libgnunet_plugin_rest_namestore_done(), and list_ego().

ego_tail

struct EgoEntry* ego_tail

static

Ego list.

Definition at line 75 of file plugin_rest_namestore.c.

Referenced by list_ego().

state

int state

static

The processing state.

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

Referenced by libgnunet_plugin_rest_namestore_done(), libgnunet_plugin_rest_namestore_init(), namestore_add_or_update(), namestore_delete(), namestore_get(), and ns_lookup_cb().

identity_handle

struct GNUNET_IDENTITY_Handle* identity_handle

static

Handle to Identity service.

Definition at line 90 of file plugin_rest_namestore.c.

Referenced by libgnunet_plugin_rest_namestore_done(), and libgnunet_plugin_rest_namestore_init().

requests_head

struct RequestHandle* requests_head

static

DLL.

Definition at line 269 of file plugin_rest_namestore.c.

Referenced by cleanup_handle(), and libgnunet_plugin_rest_namestore_done().

requests_tail

struct RequestHandle* requests_tail

static

DLL.

Definition at line 274 of file plugin_rest_namestore.c.

Referenced by cleanup_handle().