namestore_plugin.c File Reference

#include "platform.h"
#include "gnunet_error_codes.h"
#include "gnunet_rest_plugin.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 "namestore_plugin.h"

Include dependency graph for namestore_plugin.c:

Go to the source code of this file.

Data Structures
struct	Plugin
	Handle for a plugin. More...
struct	EgoEntry
	The default namestore ego. 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...
static 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_CRYPTO_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_CRYPTO_PrivateKey *zone, const char *label, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
static 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_CRYPTO_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
static void	import_next_cb (void *cls, enum GNUNET_ErrorCode ec)
static void	bulk_tx_start (struct RequestHandle *handle)
static void	namestore_import (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
	Handle namestore POST import. More...
static void	namestore_add_or_update (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
	Handle namestore POST/PUT request. More...
static void	namestore_update (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
	Handle namestore PUT request. More...
static void	namestore_add (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
	Handle namestore POST request. More...
static 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)
enum GNUNET_GenericReturnValue	REST_namestore_process_request (void *plugin, struct GNUNET_REST_RequestHandle *rest_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
	Function processing the REST call. More...
void *	REST_namestore_init (const struct GNUNET_CONFIGURATION_Handle *c)
	Entry point for the plugin. More...
void	REST_namestore_done (struct GNUNET_REST_Plugin *api)
	Exit point from the plugin. More...

Variables
const struct GNUNET_CONFIGURATION_Handle *	ns_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...

Macro Definition Documentation

GNUNET_REST_API_NS_NAMESTORE

#define GNUNET_REST_API_NS_NAMESTORE   "/namestore"

Namestore namespace.

Definition at line 41 of file namestore_plugin.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 namestore_plugin.c.

ID_REST_STATE_INIT

#define ID_REST_STATE_INIT   0

State while collecting all egos.

Definition at line 51 of file namestore_plugin.c.

ID_REST_STATE_POST_INIT

#define ID_REST_STATE_POST_INIT   1

Done collecting egos.

Definition at line 56 of file namestore_plugin.c.

Enumeration Type Documentation

UpdateStrategy

enum UpdateStrategy

Enumerator
UPDATE_STRATEGY_REPLACE
UPDATE_STRATEGY_APPEND

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

{
  struct RequestHandle *handle = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
  if (NULL != handle->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (handle->timeout_task);
    handle->timeout_task = NULL;
  }
  if (NULL != handle->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 create_finished(), del_finished(), do_error(), import_next_cb(), namestore_list_finished(), options_cont(), and REST_namestore_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

do_error()

static void do_error ( void *  cls )

static

Task run on errors.

Reports an error and cleans up everything.

Parameters

cls	the struct RequestHandle

Definition at line 330 of file namestore_plugin.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_start(), create_finished(), del_finished(), import_next_cb(), namestore_add_or_update(), namestore_delete(), namestore_get(), namestore_import(), namestore_iteration_error(), namestore_list_finished(), ns_get_lookup_cb(), ns_lookup_cb(), ns_lookup_error_cb(), REST_namestore_done(), and REST_namestore_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

get_egoentry_namestore()

static struct EgoEntry * get_egoentry_namestore ( struct RequestHandle *  handle, char *  name  )

static

Get EgoEntry from list with either a public key or a name If public key and name are not NULL, it returns the public key result first.

Parameters

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

Returns

EgoEntry or NULL if not found

Definition at line 367 of file namestore_plugin.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 namestore_plugin.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 namestore_plugin.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 namestore_plugin.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 namestore_plugin.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_CRYPTO_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 namestore_plugin.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 namestore_plugin.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_CRYPTO_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 namestore_plugin.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()

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

static

Handle namestore GET request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 586 of file namestore_plugin.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.

Referenced by REST_namestore_process_request().

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_CRYPTO_PrivateKey *  zone, const char *  label, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Definition at line 694 of file namestore_plugin.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_record_set_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_record_set_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:

import_next_cb()

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

static

Definition at line 729 of file namestore_plugin.c.

{
  struct RequestHandle *handle = cls;
  unsigned int remaining;
 
  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;
  }
  remaining = handle->rd_set_count - handle->rd_set_pos;
  if (0 == remaining)
  {
    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);
    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_store (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 cleanup_handle(), do_error(), RequestHandle::ec, GNUNET_EC_NAMESTORE_UNKNOWN, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NAMESTORE_records_store(), GNUNET_REST_create_response(), GNUNET_SCHEDULER_add_now(), handle, import_next_cb(), and MHD_HTTP_NO_CONTENT.

Referenced by bulk_tx_start(), and import_next_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

bulk_tx_start()

static void bulk_tx_start ( struct RequestHandle *  handle )

static

Definition at line 786 of file namestore_plugin.c.

{
  json_t *data_js;
  json_error_t err;
  char term_data[handle->rest_handle->data_size + 1];
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Transaction started...\n");
  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);
  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_store (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(), GNUNET_EC_NAMESTORE_NO_RECORDS_GIVEN, GNUNET_EC_NAMESTORE_RECORD_DATA_INVALID, GNUNET_EC_NAMESTORE_UNKNOWN, 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_store(), 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()

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

static

Handle namestore POST import.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 883 of file namestore_plugin.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 (ns_cfg);
  if (NULL == handle->nc)
  {
    handle->ec = GNUNET_EC_NAMESTORE_UNKNOWN;
    GNUNET_SCHEDULER_add_now (&do_error, handle);
    return;
  }
  bulk_tx_start (handle);
}

References bulk_tx_start(), 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_REST_API_NS_NAMESTORE_IMPORT, GNUNET_SCHEDULER_add_now(), handle, and ns_cfg.

Referenced by REST_namestore_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_add_or_update()

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

static

Handle namestore POST/PUT request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

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

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

static

Handle namestore PUT request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 1020 of file namestore_plugin.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.

Referenced by REST_namestore_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_add()

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

static

Handle namestore POST request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 1038 of file namestore_plugin.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.

Referenced by REST_namestore_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

namestore_delete()

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

static

Handle namestore DELETE request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 1056 of file namestore_plugin.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_record_set_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_record_set_store(), GNUNET_REST_API_NS_NAMESTORE, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, EgoEntry::identifier, and ns_handle.

Referenced by REST_namestore_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

options_cont()

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

static

Respond to OPTIONS request.

Parameters

con_handle	the connection handle
url	the url
cls	the RequestHandle

Definition at line 1118 of file namestore_plugin.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.

Referenced by REST_namestore_process_request().

Here is the call graph for this function:

Here is the caller graph for this function:

list_ego()

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

static

Definition at line 1138 of file namestore_plugin.c.

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

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

Referenced by REST_namestore_init().

Here is the call graph for this function:

Here is the caller graph for this function:

REST_namestore_process_request()

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

Function processing the REST call.

Parameters

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

Returns

GNUNET_OK if request accepted

Definition at line 1231 of file namestore_plugin.c.

{
  struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
  struct GNUNET_REST_RequestHandlerError err;
  static const struct GNUNET_REST_RequestHandler handlers[] =
  { { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_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;
}

References cleanup_handle(), do_error(), GNUNET_CONTAINER_DLL_insert, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_REST_API_NS_NAMESTORE, GNUNET_REST_API_NS_NAMESTORE_IMPORT, GNUNET_REST_handle_request(), GNUNET_REST_HANDLER_END, GNUNET_SCHEDULER_add_delayed(), GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, handle, handlers, namestore_add(), namestore_delete(), namestore_get(), namestore_import(), namestore_update(), options_cont(), GNUNET_REST_RequestHandler::proc, requests_head, requests_tail, and GNUNET_REST_RequestHandle::url.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

REST_namestore_init()

void * REST_namestore_init

(

const struct GNUNET_CONFIGURATION_Handle *

c

)

Entry point for the plugin.

Parameters

cls	Config info

Returns

NULL on error, otherwise the plugin context

Definition at line 1284 of file namestore_plugin.c.

{
  static struct Plugin plugin;
  struct GNUNET_REST_Plugin *api;
 
  ns_cfg = c;
  if (NULL != plugin.cfg)
    return NULL;   /* can only initialize once! */
  memset (&plugin, 0, sizeof(struct Plugin));
  plugin.cfg = c;
  api = GNUNET_new (struct GNUNET_REST_Plugin);
  api->cls = &plugin;
  api->name = GNUNET_REST_API_NS_NAMESTORE;
  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 (ns_cfg);
  identity_handle = GNUNET_IDENTITY_connect (ns_cfg, &list_ego, NULL);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ (
                "Namestore REST API initialized\n"));
  return api;
}

References _, allow_methods, GNUNET_REST_Plugin::cls, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_IDENTITY_connect(), GNUNET_log, GNUNET_NAMESTORE_connect(), GNUNET_new, GNUNET_REST_API_NS_NAMESTORE, ID_REST_STATE_INIT, identity_handle, list_ego(), GNUNET_REST_Plugin::name, ns_cfg, ns_handle, plugin, and state.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

REST_namestore_done()

void REST_namestore_done

(

struct GNUNET_REST_Plugin *

api

)

Exit point from the plugin.

Parameters

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

Returns

always NULL

Definition at line 1321 of file namestore_plugin.c.

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

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

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

ns_cfg

const struct GNUNET_CONFIGURATION_Handle* ns_cfg

The configuration handle.

Definition at line 60 of file namestore_plugin.c.

Referenced by namestore_import(), and REST_namestore_init().

allow_methods

char* allow_methods

static

HTTP methods allows for this plugin.

Definition at line 65 of file namestore_plugin.c.

Referenced by options_cont(), REST_namestore_done(), and REST_namestore_init().

ego_head

struct EgoEntry* ego_head

static

Ego list.

Definition at line 70 of file namestore_plugin.c.

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

ego_tail

struct EgoEntry* ego_tail

static

Ego list.

Definition at line 75 of file namestore_plugin.c.

Referenced by list_ego().

state

int state

static

The processing state.

Definition at line 80 of file namestore_plugin.c.

Referenced by list_ego(), and REST_namestore_init().

ns_handle

struct GNUNET_NAMESTORE_Handle* ns_handle

static

Handle to NAMESTORE.

Definition at line 85 of file namestore_plugin.c.

Referenced by namestore_add_or_update(), namestore_delete(), namestore_get(), ns_lookup_cb(), REST_namestore_done(), and REST_namestore_init().

identity_handle

struct GNUNET_IDENTITY_Handle* identity_handle

static

Handle to Identity service.

Definition at line 90 of file namestore_plugin.c.

Referenced by REST_namestore_done(), and REST_namestore_init().

requests_head

struct RequestHandle* requests_head

static

DLL.

Definition at line 269 of file namestore_plugin.c.

Referenced by cleanup_handle(), REST_namestore_done(), and REST_namestore_process_request().

requests_tail

struct RequestHandle* requests_tail

static

DLL.

Definition at line 274 of file namestore_plugin.c.

Referenced by cleanup_handle(), and REST_namestore_process_request().