GNUnet  0.11.x
Data Structures | Macros | Enumerations | Functions | Variables
plugin_rest_namestore.c File Reference

GNUnet Namestore REST plugin. More...

#include "platform.h"
#include "gnunet_rest_plugin.h"
#include "gnunet_gns_service.h"
#include "gnunet_namestore_service.h"
#include "gnunet_identity_service.h"
#include "gnunet_rest_lib.h"
#include "gnunet_json_lib.h"
#include "microhttpd.h"
#include <jansson.h>
Include dependency graph for plugin_rest_namestore.c:

Go to the source code of this file.

Data Structures

struct  Plugin
 Handle for a plugin. More...
 
struct  EgoEntry
 The ego list. More...
 
struct  RequestHandle
 The request handle. More...
 

Macros

#define GNUNET_REST_API_NS_NAMESTORE   "/namestore"
 Namestore Namespace. More...
 
#define GNUNET_REST_NAMESTORE_ERROR_UNKNOWN   "Unknown Error"
 Error message Unknown Error. More...
 
#define GNUNET_REST_IDENTITY_NOT_FOUND   "No identity found"
 Error message No identity found. More...
 
#define GNUNET_REST_NAMESTORE_FAILED   "Namestore action failed"
 Error message Failed request. More...
 
#define GNUNET_REST_NAMESTORE_INVALID_DATA   "Data invalid"
 Error message invalid data. More...
 
#define GNUNET_REST_NAMESTORE_NO_DATA   "No data"
 Error message No data. More...
 
#define ID_REST_STATE_INIT   0
 State while collecting all egos. More...
 
#define ID_REST_STATE_POST_INIT   1
 Done collecting egos. More...
 

Enumerations

enum  UpdateStrategy { UPDATE_STRATEGY_REPLACE, UPDATE_STRATEGY_APPEND }
 

Functions

static void cleanup_handle (void *cls)
 Cleanup lookup handle. More...
 
static void do_error (void *cls)
 Task run on errors. More...
 
struct EgoEntryget_egoentry_namestore (struct RequestHandle *handle, char *name)
 Get EgoEntry from list with either a public key or a name If public key and name are not NULL, it returns the public key result first. More...
 
static void namestore_iteration_error (void *cls)
 Does internal server error when iteration failed. More...
 
static void create_finished (void *cls, int32_t success, const char *emsg)
 Create finished callback. More...
 
static void del_finished (void *cls, int32_t success, const char *emsg)
 Delete finished callback. More...
 
static void namestore_list_finished (void *cls)
 Iteration over all results finished, build final response. More...
 
static void namestore_list_iteration (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
 Create a response with requested records. More...
 
static void ns_lookup_error_cb (void *cls)
 Handle lookup error. More...
 
static void ns_get_lookup_cb (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *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_CRYPTO_EcdsaPrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 
void namestore_add_or_update (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle namestore POST/PUT request. More...
 
void namestore_update (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle namestore PUT request. More...
 
void namestore_add (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle namestore POST request. More...
 
void namestore_delete (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle namestore DELETE request. More...
 
static void options_cont (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Respond to OPTIONS request. More...
 
static void init_cont (struct RequestHandle *handle)
 Handle rest request. More...
 
static void id_connect_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
 This function is initially called for all egos and then again whenever a ego's identifier changes or if it is deleted. More...
 
static void 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_Handlecfg
 The configuration handle. More...
 
static char * allow_methods
 HTTP methods allows for this plugin. 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"

◆ GNUNET_REST_NAMESTORE_ERROR_UNKNOWN

#define GNUNET_REST_NAMESTORE_ERROR_UNKNOWN   "Unknown Error"

Error message Unknown Error.

Definition at line 45 of file plugin_rest_namestore.c.

Referenced by do_error().

◆ GNUNET_REST_IDENTITY_NOT_FOUND

#define GNUNET_REST_IDENTITY_NOT_FOUND   "No identity found"

Error message No identity found.

Definition at line 50 of file plugin_rest_namestore.c.

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

◆ GNUNET_REST_NAMESTORE_FAILED

#define GNUNET_REST_NAMESTORE_FAILED   "Namestore action failed"

◆ GNUNET_REST_NAMESTORE_INVALID_DATA

#define GNUNET_REST_NAMESTORE_INVALID_DATA   "Data invalid"

Error message invalid data.

Definition at line 61 of file plugin_rest_namestore.c.

Referenced by namestore_add_or_update().

◆ GNUNET_REST_NAMESTORE_NO_DATA

#define GNUNET_REST_NAMESTORE_NO_DATA   "No data"

Error message No data.

Definition at line 66 of file plugin_rest_namestore.c.

Referenced by namestore_add_or_update().

◆ ID_REST_STATE_INIT

#define ID_REST_STATE_INIT   0

State while collecting all egos.

Definition at line 71 of file plugin_rest_namestore.c.

Referenced by id_connect_cb().

◆ ID_REST_STATE_POST_INIT

#define ID_REST_STATE_POST_INIT   1

Done collecting egos.

Definition at line 76 of file plugin_rest_namestore.c.

Referenced by id_connect_cb().

Enumeration Type Documentation

◆ UpdateStrategy

Enumerator
UPDATE_STRATEGY_REPLACE 
UPDATE_STRATEGY_APPEND 

Definition at line 127 of file plugin_rest_namestore.c.

Function Documentation

◆ cleanup_handle()

static void cleanup_handle ( void *  cls)
static

Cleanup lookup handle.

Parameters
handleHandle to clean up

Definition at line 264 of file plugin_rest_namestore.c.

References GNUNET_GNSRECORD_Data::data, RequestHandle::ego_head, RequestHandle::emsg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_free_nz, GNUNET_IDENTITY_disconnect(), GNUNET_log, GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_disconnect(), GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_SCHEDULER_cancel(), handle, EgoEntry::identifier, RequestHandle::identity_handle, EgoEntry::keystring, RequestHandle::list_it, EgoEntry::next, RequestHandle::ns_handle, RequestHandle::ns_qe, RequestHandle::rd, RequestHandle::rd_count, RequestHandle::record_name, RequestHandle::resp_object, RequestHandle::timeout_task, and RequestHandle::url.

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

265 {
266  struct RequestHandle *handle = cls;
267  struct EgoEntry *ego_entry;
268  struct EgoEntry *ego_tmp;
269 
270  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
271  if (NULL != handle->timeout_task)
272  {
274  handle->timeout_task = NULL;
275  }
276  if (NULL != handle->record_name)
277  GNUNET_free (handle->record_name);
278  if (NULL != handle->url)
279  GNUNET_free (handle->url);
280  if (NULL != handle->emsg)
281  GNUNET_free (handle->emsg);
282  if (NULL != handle->rd)
283  {
284  for (int i = 0; i < handle->rd_count; i++)
285  {
286  if (NULL != handle->rd[i].data)
287  GNUNET_free_nz ((void *) handle->rd[i].data);
288  }
289  GNUNET_free (handle->rd);
290  }
291  if (NULL != handle->timeout_task)
293  if (NULL != handle->list_it)
295  if (NULL != handle->ns_qe)
296  GNUNET_NAMESTORE_cancel (handle->ns_qe);
297  if (NULL != handle->identity_handle)
299  if (NULL != handle->ns_handle)
300  {
302  }
303 
304  for (ego_entry = handle->ego_head; NULL != ego_entry;)
305  {
306  ego_tmp = ego_entry;
307  ego_entry = ego_entry->next;
308  GNUNET_free (ego_tmp->identifier);
309  GNUNET_free (ego_tmp->keystring);
310  GNUNET_free (ego_tmp);
311  }
312 
313  if (NULL != handle->resp_object)
314  {
315  json_decref (handle->resp_object);
316  }
317 
318  GNUNET_free (handle);
319 }
The request handle.
void GNUNET_NAMESTORE_cancel(struct GNUNET_NAMESTORE_QueueEntry *qe)
Cancel a namestore operation.
The ego list.
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
struct GNUNET_NAMESTORE_ZoneIterator * list_it
Handle to NAMESTORE it.
char * record_name
Records to store.
json_t * resp_object
Response object.
const void * data
Binary value stored in the DNS record.
char * emsg
Error response message.
unsigned int rd_count
Number of records in rd.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:884
void GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it)
Stops iteration and releases the namestore handle for further calls.
char * keystring
Public key string.
#define GNUNET_free_nz(ptr)
Wrapper around free.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
NAMESTORE Operation.
char * identifier
Ego Identifier.
struct GNUNET_NAMESTORE_Handle * ns_handle
Handle to NAMESTORE.
struct EgoEntry * ego_head
Ego list.
struct GNUNET_SCHEDULER_Task * timeout_task
ID of a task associated with the resolution process.
#define GNUNET_log(kind,...)
struct GNUNET_GNSRECORD_Data * rd
Records to store.
struct EgoEntry * next
DLL.
struct GNUNET_IDENTITY_Handle * identity_handle
Handle to Identity service.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
char * url
The url.
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
clsthe struct RequestHandle

Definition at line 328 of file plugin_rest_namestore.c.

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

Referenced by create_finished(), del_finished(), init_cont(), namestore_add_or_update(), namestore_delete(), namestore_get(), namestore_iteration_error(), ns_lookup_cb(), ns_lookup_error_cb(), and rest_process_request().

329 {
330  struct RequestHandle *handle = cls;
331  struct MHD_Response *resp;
332  json_t *json_error = json_object ();
333  char *response;
334 
335  if (NULL == handle->emsg)
337 
338  json_object_set_new (json_error, "error", json_string (handle->emsg));
339 
340  if (0 == handle->response_code)
341  handle->response_code = MHD_HTTP_INTERNAL_SERVER_ERROR;
342  response = json_dumps (json_error, 0);
343  resp = GNUNET_REST_create_response (response);
344  MHD_add_response_header (resp, "Content-Type", "application/json");
345  handle->proc (handle->proc_cls, resp, handle->response_code);
346  json_decref (json_error);
347  GNUNET_free (response);
349 }
#define GNUNET_REST_NAMESTORE_ERROR_UNKNOWN
Error message Unknown Error.
GNUNET_REST_ResultProcessor proc
The plugin result processor.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void * proc_cls
The closure of the result processor.
The request handle.
char * emsg
Error response message.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
Response code.
static void cleanup_handle(void *cls)
Cleanup lookup handle.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:57
static struct MHD_Response * response
Our canonical response.
#define GNUNET_free(ptr)
Wrapper around free.
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
handlethe RequestHandle
pubkeythe public key of an identity (only one can be NULL)
namethe name of an identity (only one can be NULL)
Returns
EgoEntry or NULL if not found

Definition at line 362 of file plugin_rest_namestore.c.

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

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

363 {
364  struct EgoEntry *ego_entry;
365  char *copy = GNUNET_strdup (name);
366  char *tmp;
367 
368  if (NULL == name)
369  return NULL;
370  tmp = strtok (copy, "/");
371  for (ego_entry = handle->ego_head; NULL != ego_entry;
372  ego_entry = ego_entry->next)
373  {
374  if (0 != strcasecmp (tmp, ego_entry->identifier))
375  continue;
376  GNUNET_free (copy);
377  return ego_entry;
378  }
379  GNUNET_free (copy);
380  return NULL;
381 }
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The ego list.
char * identifier
Ego Identifier.
struct EgoEntry * ego_head
Ego list.
const char * name
struct EgoEntry * next
DLL.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsthe struct RequestHandle

Definition at line 390 of file plugin_rest_namestore.c.

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

Referenced by namestore_get().

391 {
392  struct RequestHandle *handle = cls;
393 
396  return;
397 }
#define GNUNET_REST_NAMESTORE_FAILED
Error message Failed request.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
char * emsg
Error response message.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void do_error(void *cls)
Task run on errors.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ create_finished()

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

Create finished callback.

Parameters
clsthe struct RequestHandle
successthe success indicating integer, GNUNET_OK on success
emsgthe error message (can be NULL)

Definition at line 408 of file plugin_rest_namestore.c.

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

Referenced by ns_lookup_cb().

409 {
410  struct RequestHandle *handle = cls;
411  struct MHD_Response *resp;
412 
413  handle->ns_qe = NULL;
414  if (GNUNET_YES != success)
415  {
416  if (NULL != emsg)
417  {
418  handle->emsg = GNUNET_strdup (emsg);
420  return;
421  }
422  handle->emsg = GNUNET_strdup ("Error storing records");
424  return;
425  }
426  resp = GNUNET_REST_create_response (NULL);
427  handle->proc (handle->proc_cls, resp, MHD_HTTP_NO_CONTENT);
429 }
GNUNET_REST_ResultProcessor proc
The plugin result processor.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void * proc_cls
The closure of the result processor.
The request handle.
char * emsg
Error response message.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void cleanup_handle(void *cls)
Cleanup lookup handle.
static void do_error(void *cls)
Task run on errors.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
NAMESTORE Operation.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:57
Here is the call graph for this function:
Here is the caller graph for this function:

◆ del_finished()

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

Delete finished callback.

Parameters
clsthe struct RequestHandle
successthe success indicating integer, GNUNET_OK on success
emsgthe error message (can be NULL)

Definition at line 440 of file plugin_rest_namestore.c.

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

Referenced by namestore_delete().

441 {
442  struct RequestHandle *handle = cls;
443 
444  handle->ns_qe = NULL;
445  if (GNUNET_NO == success)
446  {
447  handle->response_code = MHD_HTTP_NOT_FOUND;
448  handle->emsg = GNUNET_strdup ("No record found");
450  return;
451  }
452  if (GNUNET_SYSERR == success)
453  {
454  if (NULL != emsg)
455  {
456  handle->emsg = GNUNET_strdup (emsg);
458  return;
459  }
460  handle->emsg = GNUNET_strdup ("Deleting record failed");
462  return;
463  }
464  handle->proc (handle->proc_cls,
466  MHD_HTTP_NO_CONTENT);
468 }
GNUNET_REST_ResultProcessor proc
The plugin result processor.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void * proc_cls
The closure of the result processor.
The request handle.
char * emsg
Error response message.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
Response code.
static void cleanup_handle(void *cls)
Cleanup lookup handle.
static void do_error(void *cls)
Task run on errors.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
NAMESTORE Operation.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:57
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
clsthe struct RequestHandle

Definition at line 478 of file plugin_rest_namestore.c.

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

Referenced by namestore_get(), and ns_get_lookup_cb().

479 {
480  struct RequestHandle *handle = cls;
481  char *result_str;
482  struct MHD_Response *resp;
483 
484  handle->list_it = NULL;
485 
486  if (NULL == handle->resp_object)
487  handle->resp_object = json_array ();
488 
489  result_str = json_dumps (handle->resp_object, 0);
490  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
491  resp = GNUNET_REST_create_response (result_str);
492  MHD_add_response_header (resp, "Content-Type", "application/json");
493  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
494  GNUNET_free (result_str);
496 }
GNUNET_REST_ResultProcessor proc
The plugin result processor.
void * proc_cls
The closure of the result processor.
The request handle.
struct GNUNET_NAMESTORE_ZoneIterator * list_it
Handle to NAMESTORE it.
json_t * resp_object
Response object.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void cleanup_handle(void *cls)
Cleanup lookup handle.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:57
#define GNUNET_log(kind,...)
#define GNUNET_free(ptr)
Wrapper around free.
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_EcdsaPrivateKey zone_key,
const char *  rname,
unsigned int  rd_len,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Create a response with requested records.

Parameters
handlethe RequestHandle

Only add if not empty

Definition at line 505 of file plugin_rest_namestore.c.

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

Referenced by namestore_get().

510 {
511  struct RequestHandle *handle = cls;
512  struct GNUNET_GNSRECORD_Data rd_filtered[rd_len];
513  json_t *record_obj;
514  int i = 0;
515  int j = 0;
516 
517  if (NULL == handle->resp_object)
518  handle->resp_object = json_array ();
519  for (i = 0; i < rd_len; i++)
520  {
521  if ((GNUNET_GNSRECORD_TYPE_ANY != handle->record_type) &&
522  (rd[i].record_type != handle->record_type))
523  continue; /* Apply filter */
524  rd_filtered[j] = rd[i];
525  rd_filtered[j].data = rd[i].data;
526  j++;
527  }
529  if (j > 0)
530  {
531  record_obj = GNUNET_JSON_from_gnsrecord (rname,
532  rd_filtered,
533  j);
534  json_array_append_new (handle->resp_object, record_obj);
535  }
537 }
int record_type
Record type to look up.
#define GNUNET_GNSRECORD_TYPE_ANY
Record type indicating any record/&#39;*&#39;.
void GNUNET_NAMESTORE_zone_iterator_next(struct GNUNET_NAMESTORE_ZoneIterator *it, uint64_t limit)
Calls the record processor specified in GNUNET_NAMESTORE_zone_iteration_start for the next record...
The request handle.
struct GNUNET_NAMESTORE_ZoneIterator * list_it
Handle to NAMESTORE it.
json_t * resp_object
Response object.
const void * data
Binary value stored in the DNS record.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
json_t * GNUNET_JSON_from_gnsrecord(const char *rname, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count)
Convert Gns record to JSON.
uint32_t record_type
Type of the GNS/DNS record.
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
clsthe request handle

Definition at line 545 of file plugin_rest_namestore.c.

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

Referenced by namestore_add_or_update(), and namestore_get().

546 {
547  struct RequestHandle *handle = cls;
548 
551 }
#define GNUNET_REST_NAMESTORE_FAILED
Error message Failed request.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
char * emsg
Error response message.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void do_error(void *cls)
Task run on errors.
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_EcdsaPrivateKey zone,
const char *  label,
unsigned int  rd_len,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Only add if not empty

Definition at line 555 of file plugin_rest_namestore.c.

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

Referenced by namestore_get().

560 {
561  struct RequestHandle *handle = cls;
562  struct GNUNET_GNSRECORD_Data rd_filtered[rd_len];
563  json_t *record_obj;
564  int i = 0;
565  int j = 0;
566 
567  handle->ns_qe = NULL;
568  if (NULL == handle->resp_object)
569  handle->resp_object = json_array ();
570  for (i = 0; i < rd_len; i++)
571  {
572  if ((GNUNET_GNSRECORD_TYPE_ANY != handle->record_type) &&
573  (rd[i].record_type != handle->record_type))
574  continue; /* Apply filter */
575  rd_filtered[j] = rd[i];
576  rd_filtered[j].data = rd[i].data;
577  j++;
578  }
580  if (j > 0)
581  {
582  record_obj = GNUNET_JSON_from_gnsrecord (label,
583  rd_filtered,
584  j);
585  json_array_append_new (handle->resp_object, record_obj);
586  }
588 }
int record_type
Record type to look up.
#define GNUNET_GNSRECORD_TYPE_ANY
Record type indicating any record/&#39;*&#39;.
The request handle.
json_t * resp_object
Response object.
const void * data
Binary value stored in the DNS record.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void namestore_list_finished(void *cls)
Iteration over all results finished, build final response.
json_t * GNUNET_JSON_from_gnsrecord(const char *rname, const struct GNUNET_GNSRECORD_Data *rd, unsigned int rd_count)
Convert Gns record to JSON.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
NAMESTORE Operation.
uint32_t record_type
Type of the GNS/DNS record.
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_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 601 of file plugin_rest_namestore.c.

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

Referenced by init_cont().

604 {
605  struct RequestHandle *handle = cls;
606  struct EgoEntry *ego_entry;
607  struct GNUNET_HashCode key;
608  char *egoname;
609  char *labelname;
610  char *typename;
611 
612  egoname = NULL;
613  ego_entry = NULL;
614 
615  // set zone to name if given
616  if (strlen (GNUNET_REST_API_NS_NAMESTORE) + 1 >= strlen (handle->url))
617  {
618  handle->response_code = MHD_HTTP_NOT_FOUND;
621  return;
622  }
623  egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
624  ego_entry = get_egoentry_namestore (handle, egoname);
625  if (NULL == ego_entry)
626  {
627  handle->response_code = MHD_HTTP_NOT_FOUND;
630  return;
631  }
632  handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
633 
634  GNUNET_CRYPTO_hash ("record_type", strlen ("record_type"), &key);
635  if (GNUNET_NO ==
637  {
639  }
640  else
641  {
642  typename = GNUNET_CONTAINER_multihashmap_get (con_handle->url_param_map,
643  &key);
645  }
646  labelname = &egoname[strlen (ego_entry->identifier)];
647  // set zone to name if given
648  if (1 >= strlen (labelname))
649  {
650  handle->list_it =
652  handle->zone_pkey,
654  handle,
656  handle,
658  handle);
659  if (NULL == handle->list_it)
660  {
663  return;
664  }
665  return;
666  }
667  handle->record_name = GNUNET_strdup (labelname + 1);
669  handle->zone_pkey,
670  handle->record_name,
672  handle,
674  handle);
675  if (NULL == handle->ns_qe)
676  {
679  return;
680  }
681 }
#define GNUNET_REST_NAMESTORE_FAILED
Error message Failed request.
int record_type
Record type to look up.
static void namestore_iteration_error(void *cls)
Does internal server error when iteration failed.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_lookup(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor rm, void *rm_cls)
Lookup an item in the namestore.
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
Starts a new zone iteration (used to periodically PUT all of our records into our DHT)...
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...
uint32_t GNUNET_GNSRECORD_typename_to_number(const char *dns_typename)
Convert a type name (i.e.
Definition: gnsrecord.c:204
#define GNUNET_GNSRECORD_TYPE_ANY
Record type indicating any record/&#39;*&#39;.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:595
static void ns_lookup_error_cb(void *cls)
Handle lookup error.
int GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL)...
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
static void namestore_list_iteration(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
Create a response with requested records.
The request handle.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
The ego list.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
struct GNUNET_NAMESTORE_ZoneIterator * list_it
Handle to NAMESTORE it.
char * record_name
Records to store.
char * emsg
Error response message.
struct GNUNET_CONTAINER_MultiHashMap * url_param_map
Map of url parameters.
#define GNUNET_REST_IDENTITY_NOT_FOUND
Error message No identity found.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void namestore_list_finished(void *cls)
Iteration over all results finished, build final response.
A 512-bit hashcode.
int response_code
Response code.
struct GNUNET_HashCode key
The key used in the DHT.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * zone_pkey
Private key for the zone.
static void do_error(void *cls)
Task run on errors.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
NAMESTORE Operation.
char * identifier
Ego Identifier.
struct GNUNET_NAMESTORE_Handle * ns_handle
Handle to NAMESTORE.
#define GNUNET_REST_API_NS_NAMESTORE
Namestore Namespace.
static void ns_get_lookup_cb(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
char * url
The url.
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_EcdsaPrivateKey zone,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Definition at line 686 of file plugin_rest_namestore.c.

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

Referenced by namestore_add_or_update().

691 {
692  struct RequestHandle *handle = cls;
693  struct GNUNET_GNSRECORD_Data rd_new[rd_count + handle->rd_count];
694  int i = 0;
695  int j = 0;
696 
698  {
699  for (i = 0; i < rd_count; i++)
700  rd_new[i] = rd[i];
701  }
702  for (j = 0; j < handle->rd_count; j++)
703  rd_new[i + j] = handle->rd[j];
705  handle->zone_pkey,
706  handle->record_name,
707  i + j,
708  rd_new,
710  handle);
711  if (NULL == handle->ns_qe)
712  {
715  return;
716  }
717 }
#define GNUNET_REST_NAMESTORE_FAILED
Error message Failed request.
static void create_finished(void *cls, int32_t success, const char *emsg)
Create finished callback.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the namestore.
char * record_name
Records to store.
char * emsg
Error response message.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
unsigned int rd_count
Number of records in rd.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
enum UpdateStrategy update_strategy
How to update the record set.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * zone_pkey
Private key for the zone.
static void do_error(void *cls)
Task run on errors.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
NAMESTORE Operation.
struct GNUNET_NAMESTORE_Handle * ns_handle
Handle to NAMESTORE.
struct GNUNET_GNSRECORD_Data * rd
Records to store.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ namestore_add_or_update()

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

Handle namestore POST/PUT request.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 728 of file plugin_rest_namestore.c.

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

Referenced by namestore_add(), and namestore_update().

731 {
732  struct RequestHandle *handle = cls;
733  struct EgoEntry *ego_entry;
734  char *egoname;
735  json_t *data_js;
736  json_error_t err;
737 
738  char term_data[handle->rest_handle->data_size + 1];
739 
740  if (0 >= handle->rest_handle->data_size)
741  {
742  handle->response_code = MHD_HTTP_BAD_REQUEST;
745  return;
746  }
747  term_data[handle->rest_handle->data_size] = '\0';
748  GNUNET_memcpy (term_data,
749  handle->rest_handle->data,
750  handle->rest_handle->data_size);
751  data_js = json_loads (term_data, JSON_DECODE_ANY, &err);
752  struct GNUNET_JSON_Specification gnsspec[] =
753  { GNUNET_JSON_spec_gnsrecord (&handle->rd, &handle->rd_count,
754  &handle->record_name),
756  if (GNUNET_OK != GNUNET_JSON_parse (data_js, gnsspec, NULL, NULL))
757  {
760  json_decref (data_js);
761  return;
762  }
763  GNUNET_JSON_parse_free (gnsspec);
764  if (0 >= strlen (handle->record_name))
765  {
766  handle->response_code = MHD_HTTP_BAD_REQUEST;
769  json_decref (data_js);
770  return;
771  }
772  json_decref (data_js);
773 
774  egoname = NULL;
775  ego_entry = NULL;
776 
777  // set zone to name if given
778  if (strlen (GNUNET_REST_API_NS_NAMESTORE) + 1 >= strlen (handle->url))
779  {
780  handle->response_code = MHD_HTTP_NOT_FOUND;
783  return;
784  }
785  egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
786  ego_entry = get_egoentry_namestore (handle, egoname);
787 
788  if (NULL == ego_entry)
789  {
790  handle->response_code = MHD_HTTP_NOT_FOUND;
793  return;
794  }
795  handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
797  handle->zone_pkey,
798  handle->record_name,
800  handle,
801  &ns_lookup_cb,
802  handle);
803  if (NULL == handle->ns_qe)
804  {
807  return;
808  }
809 }
#define GNUNET_REST_NAMESTORE_FAILED
Error message Failed request.
size_t data_size
The POST data size.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_lookup(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor rm, void *rm_cls)
Lookup an item in the 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...
void GNUNET_JSON_parse_free(struct GNUNET_JSON_Specification *spec)
Frees all elements allocated during a GNUNET_JSON_parse() operation.
Definition: json.c:100
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:595
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Entry in parser specification for GNUNET_JSON_parse().
static void ns_lookup_error_cb(void *cls)
Handle lookup error.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
The ego list.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
char * record_name
Records to store.
static void ns_lookup_cb(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
char * emsg
Error response message.
int GNUNET_JSON_parse(const json_t *root, struct GNUNET_JSON_Specification *spec, const char **error_json_name, unsigned int *error_line)
Navigate and parse data in a JSON tree.
Definition: json.c:45
#define GNUNET_REST_IDENTITY_NOT_FOUND
Error message No identity found.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
unsigned int rd_count
Number of records in rd.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
struct GNUNET_REST_RequestHandle * rest_handle
Rest connection.
int response_code
Response code.
#define GNUNET_REST_NAMESTORE_NO_DATA
Error message No data.
const char * data
The POST data.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * zone_pkey
Private key for the zone.
struct GNUNET_JSON_Specification GNUNET_JSON_spec_gnsrecord(struct GNUNET_GNSRECORD_Data **rd, unsigned int *rd_count, char **name)
JSON Specification for GNS Records.
static void do_error(void *cls)
Task run on errors.
#define GNUNET_REST_NAMESTORE_INVALID_DATA
Error message invalid data.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
NAMESTORE Operation.
struct GNUNET_NAMESTORE_Handle * ns_handle
Handle to NAMESTORE.
#define GNUNET_REST_API_NS_NAMESTORE
Namestore Namespace.
struct GNUNET_GNSRECORD_Data * rd
Records to store.
struct GNUNET_JSON_Specification GNUNET_JSON_spec_end(void)
End of a parser specification.
Definition: json_helper.c:35
char * url
The url.
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_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 820 of file plugin_rest_namestore.c.

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

Referenced by init_cont().

823 {
824  struct RequestHandle *handle = cls;
826  namestore_add_or_update (con_handle, url, cls);
827 }
The request handle.
void namestore_add_or_update(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle namestore POST/PUT request.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
enum UpdateStrategy update_strategy
How to update the record set.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ namestore_add()

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

Handle namestore POST request.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 838 of file plugin_rest_namestore.c.

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

Referenced by init_cont().

841 {
842  struct RequestHandle *handle = cls;
844  namestore_add_or_update (con_handle, url, cls);
845 }
The request handle.
void namestore_add_or_update(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle namestore POST/PUT request.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
enum UpdateStrategy update_strategy
How to update the record set.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ namestore_delete()

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

Handle namestore DELETE request.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 856 of file plugin_rest_namestore.c.

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

Referenced by init_cont().

859 {
860  struct RequestHandle *handle = cls;
861  struct EgoEntry *ego_entry;
862  char *egoname;
863  char *labelname;
864 
865  egoname = NULL;
866  ego_entry = NULL;
867 
868  // set zone to name if given
869  if (strlen (GNUNET_REST_API_NS_NAMESTORE) + 1 >= strlen (handle->url))
870  {
871  handle->response_code = MHD_HTTP_NOT_FOUND;
874  return;
875  }
876  egoname = &handle->url[strlen (GNUNET_REST_API_NS_NAMESTORE) + 1];
877  ego_entry = get_egoentry_namestore (handle, egoname);
878  if (NULL == ego_entry)
879  {
880  handle->response_code = MHD_HTTP_NOT_FOUND;
883  return;
884  }
885  handle->zone_pkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
886  labelname = &egoname[strlen (ego_entry->identifier)];
887  // set zone to name if given
888  if (1 >= strlen (labelname))
889  {
890  /* label is only "/" */
891  handle->response_code = MHD_HTTP_BAD_REQUEST;
892  handle->emsg = GNUNET_strdup ("Label missing");
894  }
895 
896  handle->record_name = GNUNET_strdup (labelname + 1);
898  handle->zone_pkey,
899  handle->record_name,
900  0,
901  NULL,
902  &del_finished,
903  handle);
904  if (NULL == handle->ns_qe)
905  {
908  return;
909  }
910 }
#define GNUNET_REST_NAMESTORE_FAILED
Error message Failed request.
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...
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:595
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pkey, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the namestore.
The ego list.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
char * record_name
Records to store.
char * emsg
Error response message.
#define GNUNET_REST_IDENTITY_NOT_FOUND
Error message No identity found.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
Response code.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * zone_pkey
Private key for the zone.
static void do_error(void *cls)
Task run on errors.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
NAMESTORE Operation.
char * identifier
Ego Identifier.
struct GNUNET_NAMESTORE_Handle * ns_handle
Handle to NAMESTORE.
#define GNUNET_REST_API_NS_NAMESTORE
Namestore Namespace.
static void del_finished(void *cls, int32_t success, const char *emsg)
Delete finished callback.
char * url
The url.
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_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 921 of file plugin_rest_namestore.c.

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

Referenced by init_cont().

924 {
925  struct MHD_Response *resp;
926  struct RequestHandle *handle = cls;
927 
928  // independent of path return all options
929  resp = GNUNET_REST_create_response (NULL);
930  MHD_add_response_header (resp, "Access-Control-Allow-Methods", allow_methods);
931  handle->proc (handle->proc_cls, resp, MHD_HTTP_OK);
933  return;
934 }
GNUNET_REST_ResultProcessor proc
The plugin result processor.
void * proc_cls
The closure of the result processor.
The request handle.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static char * allow_methods
HTTP methods allows for this plugin.
static void cleanup_handle(void *cls)
Cleanup lookup handle.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:57
Here is the call graph for this function:
Here is the caller graph for this function:

◆ init_cont()

static void init_cont ( struct RequestHandle handle)
static

Handle rest request.

Parameters
handlethe request handle

Definition at line 943 of file plugin_rest_namestore.c.

References do_error(), GNUNET_REST_RequestHandlerError::error_code, GNUNET_NO, GNUNET_REST_API_NS_NAMESTORE, GNUNET_REST_handle_request(), GNUNET_REST_HANDLER_END, GNUNET_SCHEDULER_add_now(), namestore_add(), namestore_delete(), namestore_get(), namestore_update(), options_cont(), RequestHandle::response_code, and RequestHandle::rest_handle.

Referenced by id_connect_cb().

944 {
946  static const struct GNUNET_REST_RequestHandler handlers[] =
947  { { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_NAMESTORE, &namestore_get },
948  { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_NAMESTORE, &namestore_add },
949  { MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_NAMESTORE, &namestore_update },
950  { MHD_HTTP_METHOD_DELETE, GNUNET_REST_API_NS_NAMESTORE, &namestore_delete },
951  { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_NAMESTORE, &options_cont },
953 
954  if (GNUNET_NO ==
955  GNUNET_REST_handle_request (handle->rest_handle, handlers, &err, handle))
956  {
957  handle->response_code = err.error_code;
959  }
960 }
void namestore_update(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle namestore PUT request.
void namestore_delete(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle namestore DELETE request.
#define GNUNET_REST_HANDLER_END
void namestore_add(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle namestore POST request.
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1296
static void options_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Respond to OPTIONS request.
int GNUNET_REST_handle_request(struct GNUNET_REST_RequestHandle *conn, const struct GNUNET_REST_RequestHandler *handlers, struct GNUNET_REST_RequestHandlerError *err, void *cls)
Definition: rest.c:77
struct GNUNET_REST_RequestHandle * rest_handle
Rest connection.
int response_code
Response code.
static void do_error(void *cls)
Task run on errors.
void namestore_get(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle namestore GET request.
#define GNUNET_REST_API_NS_NAMESTORE
Namestore Namespace.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ id_connect_cb()

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

This function is initially called for all egos and then again whenever a ego's identifier changes or if it is deleted.

At the end of the initial pass over all egos, the function is once called with 'NULL' for 'ego'. That does NOT mean that the callback won't be invoked in the future or that there was an error.

When used with 'GNUNET_IDENTITY_create' or 'GNUNET_IDENTITY_get', this function is only called ONCE, and 'NULL' being passed in 'ego' does indicate an error (i.e. name is taken or no default value is known). If 'ego' is non-NULL and if '*ctx' is set in those callbacks, the value WILL be passed to a subsequent call to the identity callback of 'GNUNET_IDENTITY_connect' (if that one was not NULL).

When an identity is renamed, this function is called with the (known) ego but the NEW identifier.

When an identity is deleted, this function is called with the (known) ego and "NULL" for the 'identifier'. In this case, the 'ego' is henceforth invalid (and the 'ctx' should also be cleaned up).

Parameters
clsclosure
egoego handle
ctxcontext for application to store data for this ego (during the lifetime of this process, initially NULL)
nameidentifier assigned by the user for this ego, NULL if the user just deleted the ego and it must thus no longer be used

Definition at line 995 of file plugin_rest_namestore.c.

References EgoEntry::ego, RequestHandle::ego_head, RequestHandle::ego_tail, GNUNET_asprintf(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_ecdsa_public_key_to_string(), GNUNET_IDENTITY_ego_get_public_key(), GNUNET_new, handle, ID_REST_STATE_INIT, ID_REST_STATE_POST_INIT, EgoEntry::identifier, init_cont(), EgoEntry::keystring, and RequestHandle::state.

Referenced by rest_process_request().

999 {
1000  struct RequestHandle *handle = cls;
1001  struct EgoEntry *ego_entry;
1003 
1004  if ((NULL == ego) && (ID_REST_STATE_INIT == handle->state))
1005  {
1006  handle->state = ID_REST_STATE_POST_INIT;
1007  init_cont (handle);
1008  return;
1009  }
1010  if (ID_REST_STATE_INIT == handle->state)
1011  {
1012  ego_entry = GNUNET_new (struct EgoEntry);
1015  ego_entry->ego = ego;
1016  GNUNET_asprintf (&ego_entry->identifier, "%s", name);
1018  handle->ego_tail,
1019  ego_entry);
1020  }
1021 }
struct EgoEntry * ego_tail
Ego list.
struct GNUNET_CRYPTO_EcdsaPrivateKey pk
Private key from command line option, or NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
The request handle.
The ego list.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int state
The processing state.
char * GNUNET_CRYPTO_ecdsa_public_key_to_string(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a public key to a string.
Definition: crypto_ecc.c:232
char * keystring
Public key string.
#define ID_REST_STATE_INIT
State while collecting all egos.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
char * identifier
Ego Identifier.
#define ID_REST_STATE_POST_INIT
Done collecting egos.
struct EgoEntry * ego_head
Ego list.
const char * name
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
static void init_cont(struct RequestHandle *handle)
Handle rest request.
void GNUNET_IDENTITY_ego_get_public_key(struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_CRYPTO_EcdsaPublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:608
Here is the call graph for this function:
Here is the caller graph for this function:

◆ rest_process_request()

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

Function processing the REST call.

Parameters
methodHTTP method
urlURL of the HTTP request
databody of the HTTP request (optional)
data_sizelength of the body
proccallback function for the result
proc_clsclosure for callback function
Returns
GNUNET_OK if request accepted

Definition at line 1036 of file plugin_rest_namestore.c.

References do_error(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_IDENTITY_connect(), GNUNET_log, GNUNET_NAMESTORE_connect(), GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_REL, handle, id_connect_cb(), RequestHandle::identity_handle, RequestHandle::ns_handle, RequestHandle::proc, RequestHandle::proc_cls, RequestHandle::response_code, RequestHandle::rest_handle, RequestHandle::timeout, RequestHandle::timeout_task, GNUNET_REST_RequestHandle::url, RequestHandle::url, and RequestHandle::zone_pkey.

Referenced by libgnunet_plugin_rest_namestore_init().

1039 {
1040  struct RequestHandle *handle = GNUNET_new (struct RequestHandle);
1041 
1042  handle->response_code = 0;
1044  handle->proc_cls = proc_cls;
1045  handle->proc = proc;
1046  handle->rest_handle = rest_handle;
1047  handle->zone_pkey = NULL;
1048 
1049  handle->url = GNUNET_strdup (rest_handle->url);
1050  if (handle->url[strlen (handle->url) - 1] == '/')
1051  handle->url[strlen (handle->url) - 1] = '\0';
1052  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
1053 
1055  handle->identity_handle =
1057  handle->timeout_task =
1058  GNUNET_SCHEDULER_add_delayed (handle->timeout, &do_error, handle);
1059 
1060  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
1061 }
struct GNUNET_IDENTITY_Handle * GNUNET_IDENTITY_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Connect to the identity service.
Definition: identity_api.c:566
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
GNUNET_REST_ResultProcessor proc
The plugin result processor.
static void id_connect_cb(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
This function is initially called for all egos and then again whenever a ego&#39;s identifier changes or ...
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void * proc_cls
The closure of the result processor.
The request handle.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1269
const char * url
The url as string.
struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_REST_RequestHandle * rest_handle
Rest connection.
int response_code
Response code.
const struct GNUNET_CRYPTO_EcdsaPrivateKey * zone_pkey
Private key for the zone.
static void do_error(void *cls)
Task run on errors.
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
struct GNUNET_NAMESTORE_Handle * ns_handle
Handle to NAMESTORE.
struct GNUNET_SCHEDULER_Task * timeout_task
ID of a task associated with the resolution process.
#define GNUNET_log(kind,...)
struct GNUNET_IDENTITY_Handle * identity_handle
Handle to Identity service.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ libgnunet_plugin_rest_namestore_init()

void* libgnunet_plugin_rest_namestore_init ( void *  cls)

Entry point for the plugin.

Parameters
clsConfig info
Returns
NULL on error, otherwise the plugin context

Definition at line 1071 of file plugin_rest_namestore.c.

References _, allow_methods, Plugin::api, Plugin::cfg, GNUNET_REST_Plugin::cls, GNUNET_asprintf(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_REST_API_NS_NAMESTORE, GNUNET_REST_Plugin::name, plugin, GNUNET_REST_Plugin::process_request, and rest_process_request().

1072 {
1073  static struct Plugin plugin;
1074  struct GNUNET_REST_Plugin *api;
1075 
1076  cfg = cls;
1077  if (NULL != plugin.cfg)
1078  return NULL; /* can only initialize once! */
1079  memset (&plugin, 0, sizeof(struct Plugin));
1080  plugin.cfg = cfg;
1081  api = GNUNET_new (struct GNUNET_REST_Plugin);
1082  api->cls = &plugin;
1086  "%s, %s, %s, %s, %s",
1087  MHD_HTTP_METHOD_GET,
1088  MHD_HTTP_METHOD_POST,
1089  MHD_HTTP_METHOD_PUT,
1090  MHD_HTTP_METHOD_DELETE,
1091  MHD_HTTP_METHOD_OPTIONS);
1092 
1093  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _ ("Namestore REST API initialized\n"));
1094  return api;
1095 }
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
void * cls
The closure of the plugin.
struct returned by the initialization function of the plugin
#define GNUNET_new(type)
Allocate a struct or union of the given type.
void(* process_request)(struct GNUNET_REST_RequestHandle *handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
Function to process a REST call.
static void rest_process_request(struct GNUNET_REST_RequestHandle *rest_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
Function processing the REST call.
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
char * name
Plugin name.
static char * plugin
Solver plugin name as string.
static char * allow_methods
HTTP methods allows for this plugin.
Handle for a plugin.
Definition: block.c:37
#define GNUNET_REST_API_NS_NAMESTORE
Namestore Namespace.
#define GNUNET_log(kind,...)
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
clsthe plugin context (as returned by "init")
Returns
always NULL

Definition at line 1105 of file plugin_rest_namestore.c.

References allow_methods, Plugin::api, Plugin::cfg, GNUNET_REST_Plugin::cls, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, and plugin.

1106 {
1107  struct GNUNET_REST_Plugin *api = cls;
1108  struct Plugin *plugin = api->cls;
1109 
1110  plugin->cfg = NULL;
1111 
1113  GNUNET_free (api);
1114  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Namestore REST plugin is finished\n");
1115  return NULL;
1116 }
void * cls
The closure of the plugin.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
struct returned by the initialization function of the plugin
static char * plugin
Solver plugin name as string.
static char * allow_methods
HTTP methods allows for this plugin.
Handle for a plugin.
Definition: block.c:37
#define GNUNET_log(kind,...)
#define GNUNET_free(ptr)
Wrapper around free.

Variable Documentation

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

The configuration handle.

Handle to our configuration.

Definition at line 80 of file plugin_rest_namestore.c.

◆ allow_methods

char* allow_methods
static

HTTP methods allows for this plugin.

Definition at line 85 of file plugin_rest_namestore.c.

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