GNUnet  0.10.x
Data Structures | Macros | Functions | Variables
plugin_rest_identity.c File Reference

GNUnet Identity REST plugin. More...

#include "platform.h"
#include "gnunet_rest_plugin.h"
#include "gnunet_identity_service.h"
#include "gnunet_rest_lib.h"
#include "microhttpd.h"
#include <jansson.h>
Include dependency graph for plugin_rest_identity.c:

Go to the source code of this file.

Data Structures

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

Macros

#define GNUNET_REST_API_NS_IDENTITY   "/identity"
 Identity Namespace. More...
 
#define GNUNET_REST_API_NS_IDENTITY_ALL   "/identity/all"
 Identity Namespace with public key specifier. More...
 
#define GNUNET_REST_API_NS_IDENTITY_PUBKEY   "/identity/pubkey"
 Identity Namespace with public key specifier. More...
 
#define GNUNET_REST_API_NS_IDENTITY_NAME   "/identity/name"
 Identity Namespace with public key specifier. More...
 
#define GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM   "/identity/subsystem"
 Identity Subsystem Namespace. More...
 
#define GNUNET_REST_IDENTITY_PARAM_PUBKEY   "pubkey"
 Parameter public key. More...
 
#define GNUNET_REST_IDENTITY_PARAM_SUBSYSTEM   "subsystem"
 Parameter subsystem. More...
 
#define GNUNET_REST_IDENTITY_PARAM_NAME   "name"
 Parameter name. More...
 
#define GNUNET_REST_IDENTITY_PARAM_NEWNAME   "newname"
 Parameter new name. More...
 
#define GNUNET_REST_IDENTITY_ERROR_UNKNOWN   "Unknown Error"
 Error message Unknown Error. More...
 
#define GNUNET_REST_IDENTITY_NOT_FOUND   "No identity found"
 Error message No identity found. More...
 
#define GNUNET_REST_IDENTITY_MISSING_NAME   "Missing identity name"
 Error message Missing identity name. More...
 
#define GNUNET_REST_IDENTITY_MISSING_PUBKEY   "Missing identity public key"
 Error message Missing identity name. More...
 
#define GNUNET_REST_ERROR_NO_DATA   "No data"
 Error message No data. More...
 
#define GNUNET_REST_ERROR_DATA_INVALID   "Data invalid"
 Error message Data invalid. More...
 
#define ID_REST_STATE_INIT   0
 State while collecting all egos. More...
 
#define ID_REST_STATE_POST_INIT   1
 Done collecting egos. More...
 

Functions

static void cleanup_handle (void *cls)
 Cleanup lookup handle. More...
 
static void do_error (void *cls)
 Task run on errors. More...
 
struct EgoEntryget_egoentry (struct RequestHandle *handle, char *pubkey, char *name)
 Get EgoEntry from list with either a public key or a name If public key and name are not NULL, it returns the public key result first. More...
 
static void ego_get_for_subsystem (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
 Callback for GET Request with subsystem. More...
 
void ego_get_subsystem (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity GET request for subsystem. More...
 
void ego_get_all (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity GET request - responds with all identities. More...
 
void ego_get_response (struct RequestHandle *handle, struct EgoEntry *ego_entry)
 Responds with the ego_entry identity. More...
 
void ego_get_pubkey (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity GET request with a public key. More...
 
void ego_get_name (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity GET request with a name. More...
 
static void do_finished (void *cls, const char *emsg)
 Processing finished. More...
 
static void do_finished_create (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk, const char *emsg)
 Processing finished, when creating an ego. More...
 
void ego_edit (struct RequestHandle *handle, struct EgoEntry *ego_entry)
 Processing edit ego with EgoEntry ego_entry. More...
 
void ego_edit_pubkey (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity PUT request with public key. More...
 
void ego_edit_name (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity PUT request with name. More...
 
void ego_edit_subsystem (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity subsystem PUT request with name. More...
 
void ego_create (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity POST request. More...
 
void ego_delete_pubkey (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity DELETE request with public key. More...
 
void ego_delete_name (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Handle identity DELETE request with name. More...
 
static void options_cont (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 Respond to OPTIONS request. More...
 
static void init_cont (struct RequestHandle *handle)
 Handle rest request. More...
 
static void init_egos (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *identifier)
 If listing is enabled, prints information about the egos. 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_identity_init (void *cls)
 Entry point for the plugin. More...
 
void * libgnunet_plugin_rest_identity_done (void *cls)
 Exit point from the plugin. More...
 

Variables

const struct GNUNET_CONFIGURATION_Handlecfg
 The configuration handle. More...
 
static char * allow_methods
 HTTP methods allows for this plugin. More...
 

Detailed Description

GNUnet Identity REST plugin.

Author
Martin Schanzenbach
Philippe Buschmann

Definition in file plugin_rest_identity.c.

Macro Definition Documentation

◆ GNUNET_REST_API_NS_IDENTITY

#define GNUNET_REST_API_NS_IDENTITY   "/identity"

Identity Namespace.

Definition at line 37 of file plugin_rest_identity.c.

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

◆ GNUNET_REST_API_NS_IDENTITY_ALL

#define GNUNET_REST_API_NS_IDENTITY_ALL   "/identity/all"

Identity Namespace with public key specifier.

Definition at line 42 of file plugin_rest_identity.c.

Referenced by init_cont().

◆ GNUNET_REST_API_NS_IDENTITY_PUBKEY

#define GNUNET_REST_API_NS_IDENTITY_PUBKEY   "/identity/pubkey"

Identity Namespace with public key specifier.

Definition at line 47 of file plugin_rest_identity.c.

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

◆ GNUNET_REST_API_NS_IDENTITY_NAME

#define GNUNET_REST_API_NS_IDENTITY_NAME   "/identity/name"

Identity Namespace with public key specifier.

Definition at line 52 of file plugin_rest_identity.c.

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

◆ GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM

#define GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM   "/identity/subsystem"

Identity Subsystem Namespace.

Definition at line 57 of file plugin_rest_identity.c.

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

◆ GNUNET_REST_IDENTITY_PARAM_PUBKEY

#define GNUNET_REST_IDENTITY_PARAM_PUBKEY   "pubkey"

Parameter public key.

Definition at line 62 of file plugin_rest_identity.c.

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

◆ GNUNET_REST_IDENTITY_PARAM_SUBSYSTEM

#define GNUNET_REST_IDENTITY_PARAM_SUBSYSTEM   "subsystem"

Parameter subsystem.

Definition at line 67 of file plugin_rest_identity.c.

Referenced by ego_edit_subsystem().

◆ GNUNET_REST_IDENTITY_PARAM_NAME

#define GNUNET_REST_IDENTITY_PARAM_NAME   "name"

Parameter name.

Definition at line 72 of file plugin_rest_identity.c.

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

◆ GNUNET_REST_IDENTITY_PARAM_NEWNAME

#define GNUNET_REST_IDENTITY_PARAM_NEWNAME   "newname"

Parameter new name.

Definition at line 77 of file plugin_rest_identity.c.

Referenced by ego_edit().

◆ GNUNET_REST_IDENTITY_ERROR_UNKNOWN

#define GNUNET_REST_IDENTITY_ERROR_UNKNOWN   "Unknown Error"

Error message Unknown Error.

Definition at line 82 of file plugin_rest_identity.c.

Referenced by do_error().

◆ GNUNET_REST_IDENTITY_NOT_FOUND

#define GNUNET_REST_IDENTITY_NOT_FOUND   "No identity found"

◆ GNUNET_REST_IDENTITY_MISSING_NAME

#define GNUNET_REST_IDENTITY_MISSING_NAME   "Missing identity name"

Error message Missing identity name.

Definition at line 92 of file plugin_rest_identity.c.

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

◆ GNUNET_REST_IDENTITY_MISSING_PUBKEY

#define GNUNET_REST_IDENTITY_MISSING_PUBKEY   "Missing identity public key"

Error message Missing identity name.

Definition at line 97 of file plugin_rest_identity.c.

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

◆ GNUNET_REST_ERROR_NO_DATA

#define GNUNET_REST_ERROR_NO_DATA   "No data"

Error message No data.

Definition at line 102 of file plugin_rest_identity.c.

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

◆ GNUNET_REST_ERROR_DATA_INVALID

#define GNUNET_REST_ERROR_DATA_INVALID   "Data invalid"

Error message Data invalid.

Definition at line 107 of file plugin_rest_identity.c.

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

◆ ID_REST_STATE_INIT

#define ID_REST_STATE_INIT   0

State while collecting all egos.

Definition at line 112 of file plugin_rest_identity.c.

Referenced by init_egos().

◆ ID_REST_STATE_POST_INIT

#define ID_REST_STATE_POST_INIT   1

Done collecting egos.

Definition at line 117 of file plugin_rest_identity.c.

Referenced by init_egos().

Function Documentation

◆ cleanup_handle()

static void cleanup_handle ( void *  cls)
static

Cleanup lookup handle.

Parameters
handleHandle to clean up

Definition at line 257 of file plugin_rest_identity.c.

References RequestHandle::ego_head, RequestHandle::emsg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_IDENTITY_disconnect(), GNUNET_log, GNUNET_SCHEDULER_cancel(), handle, EgoEntry::identifier, RequestHandle::identity_handle, EgoEntry::keystring, RequestHandle::name, EgoEntry::next, RequestHandle::timeout_task, and RequestHandle::url.

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

258 {
259  struct RequestHandle *handle = cls;
260  struct EgoEntry *ego_entry;
261  struct EgoEntry *ego_tmp;
262 
263  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
264  if (NULL != handle->timeout_task)
265  {
267  handle->timeout_task = NULL;
268  }
269 
270  if (NULL != handle->url)
271  GNUNET_free(handle->url);
272  if (NULL != handle->emsg)
273  GNUNET_free(handle->emsg);
274  if (NULL != handle->name)
275  GNUNET_free(handle->name);
276  if (NULL != handle->identity_handle)
278 
279  for (ego_entry = handle->ego_head; NULL != ego_entry;)
280  {
281  ego_tmp = ego_entry;
282  ego_entry = ego_entry->next;
283  GNUNET_free(ego_tmp->identifier);
284  GNUNET_free(ego_tmp->keystring);
285  GNUNET_free(ego_tmp);
286  }
287 
288  GNUNET_free(handle);
289 }
The request handle.
The ego list.
char * name
Name to look up.
char * emsg
Error response message.
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:835
char * keystring
Public key string.
char * identifier
Ego Identifier.
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 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:956
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 297 of file plugin_rest_identity.c.

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

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

298 {
299  struct RequestHandle *handle = cls;
300  struct MHD_Response *resp;
301  json_t *json_error = json_object();
302  char *response;
303 
304  if (NULL == handle->emsg)
306 
307  json_object_set_new(json_error, "error", json_string(handle->emsg));
308 
309  if (0 == handle->response_code)
310  handle->response_code = MHD_HTTP_OK;
311  response = json_dumps(json_error, 0);
312  resp = GNUNET_REST_create_response(response);
313  handle->proc(handle->proc_cls, resp, handle->response_code);
314  json_decref(json_error);
315  GNUNET_free(response);
317 }
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.
#define GNUNET_REST_IDENTITY_ERROR_UNKNOWN
Error message Unknown Error.
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:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
HTTP 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:56
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()

struct EgoEntry* get_egoentry ( struct RequestHandle handle,
char *  pubkey,
char *  name 
)

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

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

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

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

331 {
332  struct EgoEntry *ego_entry;
333 
334  if (NULL != pubkey)
335  {
336  for (ego_entry = handle->ego_head; NULL != ego_entry;
337  ego_entry = ego_entry->next)
338  {
339  if (0 != strcasecmp(pubkey, ego_entry->keystring))
340  continue;
341  return ego_entry;
342  }
343  }
344  if (NULL != name)
345  {
346  for (ego_entry = handle->ego_head; NULL != ego_entry;
347  ego_entry = ego_entry->next)
348  {
349  if (0 != strcasecmp(name, ego_entry->identifier))
350  continue;
351  return ego_entry;
352  }
353  }
354  return NULL;
355 }
static struct GNUNET_CRYPTO_EcdsaPublicKey pubkey
Public key of the zone to look in.
The ego list.
char * keystring
Public key string.
const char * name
char * identifier
Ego Identifier.
struct EgoEntry * ego_head
Ego list.
struct EgoEntry * next
DLL.
Here is the caller graph for this function:

◆ ego_get_for_subsystem()

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

Callback for GET Request with subsystem.

Parameters
clsthe RequestHandle
egothe Ego found
ctxthe context
namethe id of the ego

Definition at line 367 of file plugin_rest_identity.c.

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

Referenced by ego_get_subsystem().

371 {
372  struct RequestHandle *handle = cls;
373  struct MHD_Response *resp;
374  struct GNUNET_CRYPTO_EcdsaPublicKey public_key;
375  json_t *json_root;
376  char *result_str;
377  char *public_key_string;
378 
379  if (NULL == ego)
380  {
381  handle->response_code = MHD_HTTP_NOT_FOUND;
384  return;
385  }
386 
387  GNUNET_IDENTITY_ego_get_public_key(ego, &public_key);
388  public_key_string = GNUNET_CRYPTO_ecdsa_public_key_to_string(&public_key);
389 
390  // create json with subsystem identity
391  json_root = json_object();
392  json_object_set_new(json_root,
394  json_string(public_key_string));
395  json_object_set_new(json_root,
397  json_string(name));
398 
399  result_str = json_dumps(json_root, 0);
400  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
401  resp = GNUNET_REST_create_response(result_str);
402 
403  json_decref(json_root);
404  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
405  GNUNET_free(result_str);
406  GNUNET_free(public_key_string);
408 }
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:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
HTTP response code.
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:334
const char * name
void GNUNET_IDENTITY_ego_get_public_key(const struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_CRYPTO_EcdsaPublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:566
static void cleanup_handle(void *cls)
Cleanup lookup handle.
#define GNUNET_REST_IDENTITY_PARAM_PUBKEY
Parameter public key.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
#define GNUNET_log(kind,...)
static void do_error(void *cls)
Task run on errors.
#define GNUNET_REST_IDENTITY_PARAM_NAME
Parameter name.
#define GNUNET_free(ptr)
Wrapper around free.
#define GNUNET_REST_IDENTITY_NOT_FOUND
Error message No identity found.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_get_subsystem()

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

Handle identity GET request for subsystem.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 418 of file plugin_rest_identity.c.

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

Referenced by init_cont().

421 {
422  struct RequestHandle *handle = cls;
423  char *subsystem;
424 
425  if (strlen(GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) >= strlen(handle->url))
426  {
427  handle->emsg = GNUNET_strdup("Missing subsystem name");
429  return;
430  }
431  subsystem = &handle->url[strlen(GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) + 1];
432  //requested default identity of subsystem
433  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Looking for %s's ego\n", subsystem);
434 
435  handle->op = GNUNET_IDENTITY_get(handle->identity_handle,
436  subsystem,
438  handle);
439 
440  if (NULL == handle->op)
441  {
442  handle->response_code = MHD_HTTP_NOT_FOUND;
445  return;
446  }
447 }
static char * subsystem
Set to subsystem that we&#39;re going to get stats for (or NULL for all).
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_get(struct GNUNET_IDENTITY_Handle *h, const char *service_name, GNUNET_IDENTITY_Callback cb, void *cb_cls)
Obtain the identity that is currently preferred/default for a service.
Definition: identity_api.c:584
#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:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
#define GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM
Identity Subsystem Namespace.
int response_code
HTTP response code.
static void ego_get_for_subsystem(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
Callback for GET Request with subsystem.
#define GNUNET_log(kind,...)
static void do_error(void *cls)
Task run on errors.
struct GNUNET_IDENTITY_Handle * identity_handle
Handle to Identity service.
struct GNUNET_IDENTITY_Operation * op
IDENTITY Operation.
#define GNUNET_REST_IDENTITY_NOT_FOUND
Error message No identity found.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_get_all()

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

Handle identity GET request - responds with all identities.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 458 of file plugin_rest_identity.c.

References cleanup_handle(), RequestHandle::ego_head, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_REST_create_response(), GNUNET_REST_IDENTITY_PARAM_NAME, GNUNET_REST_IDENTITY_PARAM_PUBKEY, GNUNET_SCHEDULER_add_now(), handle, EgoEntry::identifier, EgoEntry::keystring, EgoEntry::next, RequestHandle::proc, and RequestHandle::proc_cls.

Referenced by init_cont().

461 {
462  struct RequestHandle *handle = cls;
463  struct EgoEntry *ego_entry;
464  struct MHD_Response *resp;
465  json_t *json_root;
466  json_t *json_ego;
467  char *result_str;
468 
469  json_root = json_array();
470  //Return ego/egos
471  for (ego_entry = handle->ego_head; NULL != ego_entry;
472  ego_entry = ego_entry->next)
473  {
474  json_ego = json_object();
475  json_object_set_new(json_ego,
477  json_string(ego_entry->keystring));
478  json_object_set_new(json_ego,
480  json_string(ego_entry->identifier));
481  json_array_append(json_root, json_ego);
482  json_decref(json_ego);
483  }
484 
485  result_str = json_dumps(json_root, 0);
486  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
487  resp = GNUNET_REST_create_response(result_str);
488 
489  json_decref(json_root);
490  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
491  GNUNET_free(result_str);
493 }
GNUNET_REST_ResultProcessor proc
The plugin result processor.
void * proc_cls
The closure of the result processor.
The request handle.
The ego list.
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:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
char * keystring
Public key string.
static void cleanup_handle(void *cls)
Cleanup lookup handle.
#define GNUNET_REST_IDENTITY_PARAM_PUBKEY
Parameter public key.
char * identifier
Ego Identifier.
struct EgoEntry * ego_head
Ego list.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
#define GNUNET_log(kind,...)
#define GNUNET_REST_IDENTITY_PARAM_NAME
Parameter name.
struct EgoEntry * next
DLL.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_get_response()

void ego_get_response ( struct RequestHandle handle,
struct EgoEntry ego_entry 
)

Responds with the ego_entry identity.

Parameters
handlethe struct RequestHandle
ego_entrythe struct EgoEntry for the response

Definition at line 503 of file plugin_rest_identity.c.

References cleanup_handle(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_REST_create_response(), GNUNET_REST_IDENTITY_PARAM_NAME, GNUNET_REST_IDENTITY_PARAM_PUBKEY, GNUNET_SCHEDULER_add_now(), EgoEntry::identifier, EgoEntry::keystring, RequestHandle::proc, and RequestHandle::proc_cls.

Referenced by ego_get_name(), and ego_get_pubkey().

504 {
505  struct MHD_Response *resp;
506  json_t *json_ego;
507  char *result_str;
508 
509  json_ego = json_object();
510  json_object_set_new(json_ego,
512  json_string(ego_entry->keystring));
513  json_object_set_new(json_ego,
515  json_string(ego_entry->identifier));
516 
517  result_str = json_dumps(json_ego, 0);
518  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Result %s\n", result_str);
519  resp = GNUNET_REST_create_response(result_str);
520  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
521 
522  json_decref(json_ego);
523  GNUNET_free(result_str);
525 }
GNUNET_REST_ResultProcessor proc
The plugin result processor.
void * proc_cls
The closure of the result processor.
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:1264
char * keystring
Public key string.
static void cleanup_handle(void *cls)
Cleanup lookup handle.
#define GNUNET_REST_IDENTITY_PARAM_PUBKEY
Parameter public key.
char * identifier
Ego Identifier.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
#define GNUNET_log(kind,...)
#define GNUNET_REST_IDENTITY_PARAM_NAME
Parameter name.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_get_pubkey()

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

Handle identity GET request with a public key.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 536 of file plugin_rest_identity.c.

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

Referenced by init_cont().

539 {
540  struct RequestHandle *handle = cls;
541  struct EgoEntry *ego_entry;
542  char *keystring;
543 
544  keystring = NULL;
545 
546  if (strlen(GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen(handle->url))
547  {
548  handle->response_code = MHD_HTTP_NOT_FOUND;
551  return;
552  }
553  keystring = &handle->url[strlen(GNUNET_REST_API_NS_IDENTITY_PUBKEY) + 1];
554  ego_entry = get_egoentry(handle, keystring, NULL);
555 
556  if (NULL == ego_entry)
557  {
558  handle->response_code = MHD_HTTP_NOT_FOUND;
561  return;
562  }
563 
564  ego_get_response(handle, ego_entry);
565 }
struct EgoEntry * get_egoentry(struct RequestHandle *handle, char *pubkey, char *name)
Get EgoEntry from list with either a public key or a name If public key and name are not NULL...
#define GNUNET_REST_API_NS_IDENTITY_PUBKEY
Identity Namespace with public key specifier.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
The ego list.
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:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
HTTP response code.
char * keystring
Public key string.
void ego_get_response(struct RequestHandle *handle, struct EgoEntry *ego_entry)
Responds with the ego_entry identity.
#define GNUNET_REST_IDENTITY_MISSING_PUBKEY
Error message Missing identity name.
static void do_error(void *cls)
Task run on errors.
#define GNUNET_REST_IDENTITY_NOT_FOUND
Error message No identity found.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_get_name()

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

Handle identity GET request with a name.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 575 of file plugin_rest_identity.c.

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

Referenced by init_cont().

578 {
579  struct RequestHandle *handle = cls;
580  struct EgoEntry *ego_entry;
581  char *egoname;
582 
583  egoname = NULL;
584 
585  if (strlen(GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen(handle->url))
586  {
587  handle->response_code = MHD_HTTP_NOT_FOUND;
590  return;
591  }
592  egoname = &handle->url[strlen(GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
593  ego_entry = get_egoentry(handle, NULL, egoname);
594 
595  if (NULL == ego_entry)
596  {
597  handle->response_code = MHD_HTTP_NOT_FOUND;
600  return;
601  }
602 
603  ego_get_response(handle, ego_entry);
604 }
#define GNUNET_REST_API_NS_IDENTITY_NAME
Identity Namespace with public key specifier.
struct EgoEntry * get_egoentry(struct RequestHandle *handle, char *pubkey, char *name)
Get EgoEntry from list with either a public key or a name If public key and name are not NULL...
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
The ego list.
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:1264
#define GNUNET_REST_IDENTITY_MISSING_NAME
Error message Missing identity name.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
HTTP response code.
void ego_get_response(struct RequestHandle *handle, struct EgoEntry *ego_entry)
Responds with the ego_entry identity.
static void do_error(void *cls)
Task run on errors.
#define GNUNET_REST_IDENTITY_NOT_FOUND
Error message No identity found.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_finished()

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

Processing finished.

Parameters
clsrequest handle
emsgerror message

Definition at line 614 of file plugin_rest_identity.c.

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

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

615 {
616  struct RequestHandle *handle = cls;
617  struct MHD_Response *resp;
618 
619  handle->op = NULL;
620  if (NULL != emsg)
621  {
622  handle->emsg = GNUNET_strdup(emsg);
624  return;
625  }
626  if (0 == handle->response_code)
627  {
628  handle->response_code = MHD_HTTP_NO_CONTENT;
629  }
630  resp = GNUNET_REST_create_response(NULL);
631  handle->proc(handle->proc_cls, resp, handle->response_code);
633 }
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:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
HTTP 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:56
static void do_error(void *cls)
Task run on errors.
struct GNUNET_IDENTITY_Operation * op
IDENTITY Operation.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_finished_create()

static void do_finished_create ( void *  cls,
const struct GNUNET_CRYPTO_EcdsaPrivateKey pk,
const char *  emsg 
)
static

Processing finished, when creating an ego.

Parameters
clsrequest handle
privatekey of the ego, or NULL on error
emsgerror message

Definition at line 644 of file plugin_rest_identity.c.

References do_finished(), and handle.

Referenced by ego_create().

647 {
648  struct RequestHandle *handle = cls;
649 
650  (void)pk;
651  do_finished(handle, emsg);
652 }
static void do_finished(void *cls, const char *emsg)
Processing finished.
The request handle.
char * emsg
Error response message.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_edit()

void ego_edit ( struct RequestHandle handle,
struct EgoEntry ego_entry 
)

Processing edit ego with EgoEntry ego_entry.

Parameters
handlethe struct RequestHandle
ego_entrythe struct EgoEntry we want to edit

Definition at line 662 of file plugin_rest_identity.c.

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

Referenced by ego_edit_name(), and ego_edit_pubkey().

663 {
664  struct EgoEntry *ego_entry_tmp;
665  struct MHD_Response *resp;
666  json_t *data_js;
667  json_error_t err;
668  char *newname;
669  char term_data[handle->data_size + 1];
670  int json_state;
671 
672  //if no data
673  if (0 >= handle->data_size)
674  {
677  return;
678  }
679  //if not json
680  term_data[handle->data_size] = '\0';
681  GNUNET_memcpy(term_data, handle->data, handle->data_size);
682  data_js = json_loads(term_data, JSON_DECODE_ANY, &err);
683 
684  if (NULL == data_js)
685  {
688  return;
689  }
690 
691  newname = NULL;
692  //NEW NAME
693  json_state = 0;
694  json_state = json_unpack(data_js,
695  "{s:s!}",
697  &newname);
698  //Change name with pubkey or name identifier
699  if (0 != json_state)
700  {
703  json_decref(data_js);
704  return;
705  }
706 
707  if (NULL == newname)
708  {
711  json_decref(data_js);
712  return;
713  }
714 
715  if (0 >= strlen(newname))
716  {
719  json_decref(data_js);
720  return;
721  }
722 
723  ego_entry_tmp = get_egoentry(handle, NULL, newname);
724  if (NULL != ego_entry_tmp)
725  {
726  //Ego with same name not allowed (even if its the ego we change)
727  resp = GNUNET_REST_create_response(NULL);
728  handle->proc(handle->proc_cls, resp, MHD_HTTP_CONFLICT);
730  json_decref(data_js);
731  return;
732  }
733  handle->op = GNUNET_IDENTITY_rename(handle->identity_handle,
734  ego_entry->identifier,
735  newname,
736  &do_finished,
737  handle);
738  if (NULL == handle->op)
739  {
740  handle->emsg = GNUNET_strdup("Rename failed");
742  json_decref(data_js);
743  return;
744  }
745  json_decref(data_js);
746  return;
747 }
#define GNUNET_REST_ERROR_NO_DATA
Error message No data.
GNUNET_REST_ResultProcessor proc
The plugin result processor.
struct EgoEntry * get_egoentry(struct RequestHandle *handle, char *pubkey, char *name)
Get EgoEntry from list with either a public key or a name If public key and name are not NULL...
size_t data_size
the length of the REST data
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static void do_finished(void *cls, const char *emsg)
Processing finished.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void * proc_cls
The closure of the result processor.
The ego list.
#define GNUNET_REST_ERROR_DATA_INVALID
Error message Data invalid.
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:1264
static void cleanup_handle(void *cls)
Cleanup lookup handle.
char * identifier
Ego Identifier.
#define GNUNET_REST_IDENTITY_PARAM_NEWNAME
Parameter new name.
const char * data
The data from the REST request.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
static void do_error(void *cls)
Task run on errors.
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_rename(struct GNUNET_IDENTITY_Handle *h, const char *old_name, const char *new_name, GNUNET_IDENTITY_Continuation cb, void *cb_cls)
Renames an existing identity.
Definition: identity_api.c:722
struct GNUNET_IDENTITY_Handle * identity_handle
Handle to Identity service.
struct GNUNET_IDENTITY_Operation * op
IDENTITY Operation.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_edit_pubkey()

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

Handle identity PUT request with public key.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 758 of file plugin_rest_identity.c.

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

Referenced by init_cont().

761 {
762  struct RequestHandle *handle = cls;
763  struct EgoEntry *ego_entry;
764  char *keystring;
765 
766  keystring = NULL;
767 
768  if (strlen(GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen(handle->url))
769  {
770  handle->response_code = MHD_HTTP_NOT_FOUND;
773  return;
774  }
775  keystring = &handle->url[strlen(GNUNET_REST_API_NS_IDENTITY_PUBKEY) + 1];
776  ego_entry = get_egoentry(handle, keystring, NULL);
777 
778  if (NULL == ego_entry)
779  {
780  handle->response_code = MHD_HTTP_NOT_FOUND;
783  return;
784  }
785 
786  ego_edit(handle, ego_entry);
787 }
struct EgoEntry * get_egoentry(struct RequestHandle *handle, char *pubkey, char *name)
Get EgoEntry from list with either a public key or a name If public key and name are not NULL...
#define GNUNET_REST_API_NS_IDENTITY_PUBKEY
Identity Namespace with public key specifier.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
The ego list.
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:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
void ego_edit(struct RequestHandle *handle, struct EgoEntry *ego_entry)
Processing edit ego with EgoEntry ego_entry.
int response_code
HTTP response code.
char * keystring
Public key string.
#define GNUNET_REST_IDENTITY_MISSING_PUBKEY
Error message Missing identity name.
static void do_error(void *cls)
Task run on errors.
#define GNUNET_REST_IDENTITY_NOT_FOUND
Error message No identity found.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_edit_name()

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

Handle identity PUT request with name.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 797 of file plugin_rest_identity.c.

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

Referenced by init_cont().

800 {
801  struct RequestHandle *handle = cls;
802  struct EgoEntry *ego_entry;
803  char *name;
804 
805  name = NULL;
806 
807  if (strlen(GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen(handle->url))
808  {
809  handle->response_code = MHD_HTTP_NOT_FOUND;
812  return;
813  }
814  name = &handle->url[strlen(GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
815  ego_entry = get_egoentry(handle, NULL, name);
816 
817  if (NULL == ego_entry)
818  {
819  handle->response_code = MHD_HTTP_NOT_FOUND;
822  return;
823  }
824 
825  ego_edit(handle, ego_entry);
826 }
#define GNUNET_REST_API_NS_IDENTITY_NAME
Identity Namespace with public key specifier.
struct EgoEntry * get_egoentry(struct RequestHandle *handle, char *pubkey, char *name)
Get EgoEntry from list with either a public key or a name If public key and name are not NULL...
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
The ego list.
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:1264
#define GNUNET_REST_IDENTITY_MISSING_NAME
Error message Missing identity name.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
void ego_edit(struct RequestHandle *handle, struct EgoEntry *ego_entry)
Processing edit ego with EgoEntry ego_entry.
int response_code
HTTP response code.
const char * name
static void do_error(void *cls)
Task run on errors.
#define GNUNET_REST_IDENTITY_NOT_FOUND
Error message No identity found.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_edit_subsystem()

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

Handle identity subsystem PUT request with name.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 836 of file plugin_rest_identity.c.

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

Referenced by init_cont().

839 {
840  struct RequestHandle *handle = cls;
841  struct EgoEntry *ego_entry;
842  json_t *data_js;
843  json_error_t err;
844  char *newsubsys;
845  char *name;
846  char term_data[handle->data_size + 1];
847  int json_state;
848 
849  name = NULL;
850 
851  if (strlen(GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) >= strlen(handle->url))
852  {
853  handle->response_code = MHD_HTTP_NOT_FOUND;
856  return;
857  }
858  name = &handle->url[strlen(GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM) + 1];
859  ego_entry = get_egoentry(handle, NULL, name);
860 
861  if (NULL == ego_entry)
862  {
863  handle->response_code = MHD_HTTP_NOT_FOUND;
866  return;
867  }
868 
869  //if no data
870  if (0 >= handle->data_size)
871  {
874  return;
875  }
876  //if not json
877  term_data[handle->data_size] = '\0';
878  GNUNET_memcpy(term_data, handle->data, handle->data_size);
879  data_js = json_loads(term_data, JSON_DECODE_ANY, &err);
880 
881  if (NULL == data_js)
882  {
885  return;
886  }
887 
888  newsubsys = NULL;
889  //SUBSYSTEM
890  json_state = 0;
891  json_state = json_unpack(data_js,
892  "{s:s!}",
894  &newsubsys);
895  //Change subsystem with pubkey or name identifier
896  if (0 != json_state)
897  {
900  json_decref(data_js);
901  return;
902  }
903 
904  if (NULL == newsubsys)
905  {
908  json_decref(data_js);
909  return;
910  }
911 
912  if (0 >= strlen(newsubsys))
913  {
916  json_decref(data_js);
917  return;
918  }
919 
920  handle->response_code = MHD_HTTP_NO_CONTENT;
921  handle->op = GNUNET_IDENTITY_set(handle->identity_handle,
922  newsubsys,
923  ego_entry->ego,
924  &do_finished,
925  handle);
926  if (NULL == handle->op)
927  {
928  handle->emsg = GNUNET_strdup("Setting subsystem failed");
930  return;
931  }
932  json_decref(data_js);
933  return;
934 }
#define GNUNET_REST_IDENTITY_PARAM_SUBSYSTEM
Parameter subsystem.
#define GNUNET_REST_ERROR_NO_DATA
Error message No data.
struct EgoEntry * get_egoentry(struct RequestHandle *handle, char *pubkey, char *name)
Get EgoEntry from list with either a public key or a name If public key and name are not NULL...
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_set(struct GNUNET_IDENTITY_Handle *h, const char *service_name, struct GNUNET_IDENTITY_Ego *ego, GNUNET_IDENTITY_Continuation cont, void *cont_cls)
Set the preferred/default identity for a service.
Definition: identity_api.c:629
size_t data_size
the length of the REST data
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static void do_finished(void *cls, const char *emsg)
Processing finished.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
The ego list.
struct GNUNET_IDENTITY_Ego * ego
The Ego.
#define GNUNET_REST_ERROR_DATA_INVALID
Error message Data invalid.
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:1264
#define GNUNET_REST_IDENTITY_MISSING_NAME
Error message Missing identity name.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
#define GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM
Identity Subsystem Namespace.
int response_code
HTTP response code.
const char * name
const char * data
The data from the REST request.
static void do_error(void *cls)
Task run on errors.
struct GNUNET_IDENTITY_Handle * identity_handle
Handle to Identity service.
struct GNUNET_IDENTITY_Operation * op
IDENTITY Operation.
#define GNUNET_REST_IDENTITY_NOT_FOUND
Error message No identity found.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_create()

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

Handle identity POST request.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 944 of file plugin_rest_identity.c.

References cleanup_handle(), RequestHandle::data, RequestHandle::data_size, do_error(), do_finished_create(), RequestHandle::ego_head, RequestHandle::emsg, GNUNET_IDENTITY_create(), GNUNET_memcpy, GNUNET_REST_API_NS_IDENTITY, GNUNET_REST_create_response(), GNUNET_REST_ERROR_DATA_INVALID, GNUNET_REST_ERROR_NO_DATA, GNUNET_REST_IDENTITY_PARAM_NAME, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), handle, EgoEntry::identifier, RequestHandle::identity_handle, RequestHandle::name, EgoEntry::next, RequestHandle::op, RequestHandle::proc, RequestHandle::proc_cls, RequestHandle::response_code, and RequestHandle::url.

Referenced by init_cont().

947 {
948  struct RequestHandle *handle = cls;
949  struct EgoEntry *ego_entry;
950  struct MHD_Response *resp;
951  json_t *data_js;
952  json_error_t err;
953  char *egoname;
954  int json_unpack_state;
955  char term_data[handle->data_size + 1];
956 
957  if (strlen(GNUNET_REST_API_NS_IDENTITY) != strlen(handle->url))
958  {
960  return;
961  }
962 
963  if (0 >= handle->data_size)
964  {
967  return;
968  }
969  term_data[handle->data_size] = '\0';
970  GNUNET_memcpy(term_data, handle->data, handle->data_size);
971  data_js = json_loads(term_data, JSON_DECODE_ANY, &err);
972  if (NULL == data_js)
973  {
976  json_decref(data_js);
977  return;
978  }
979  json_unpack_state = 0;
980  json_unpack_state =
981  json_unpack(data_js, "{s:s!}", GNUNET_REST_IDENTITY_PARAM_NAME, &egoname);
982  if (0 != json_unpack_state)
983  {
986  json_decref(data_js);
987  return;
988  }
989 
990  if (NULL == egoname)
991  {
994  json_decref(data_js);
995  return;
996  }
997  if (0 >= strlen(egoname))
998  {
999  json_decref(data_js);
1002  return;
1003  }
1004  GNUNET_STRINGS_utf8_tolower(egoname, egoname);
1005  for (ego_entry = handle->ego_head; NULL != ego_entry;
1006  ego_entry = ego_entry->next)
1007  {
1008  if (0 == strcasecmp(egoname, ego_entry->identifier))
1009  {
1010  resp = GNUNET_REST_create_response(NULL);
1011  handle->proc(handle->proc_cls, resp, MHD_HTTP_CONFLICT);
1013  json_decref(data_js);
1014  return;
1015  }
1016  }
1017  handle->name = GNUNET_strdup(egoname);
1018  json_decref(data_js);
1019  handle->response_code = MHD_HTTP_CREATED;
1020  handle->op = GNUNET_IDENTITY_create(handle->identity_handle,
1021  handle->name,
1023  handle);
1024 }
#define GNUNET_REST_ERROR_NO_DATA
Error message No data.
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_create(struct GNUNET_IDENTITY_Handle *h, const char *name, GNUNET_IDENTITY_CreateContinuation cont, void *cont_cls)
Create a new identity with the given name.
Definition: identity_api.c:675
GNUNET_REST_ResultProcessor proc
The plugin result processor.
static void do_finished_create(void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *pk, const char *emsg)
Processing finished, when creating an ego.
size_t data_size
the length of the REST data
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void * proc_cls
The closure of the result processor.
The request handle.
The ego list.
#define GNUNET_REST_ERROR_DATA_INVALID
Error message Data invalid.
char * name
Name to look up.
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:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
HTTP response code.
static void cleanup_handle(void *cls)
Cleanup lookup handle.
char * identifier
Ego Identifier.
struct EgoEntry * ego_head
Ego list.
const char * data
The data from the REST request.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
#define GNUNET_REST_API_NS_IDENTITY
Identity Namespace.
static void do_error(void *cls)
Task run on errors.
#define GNUNET_REST_IDENTITY_PARAM_NAME
Parameter name.
struct EgoEntry * next
DLL.
struct GNUNET_IDENTITY_Handle * identity_handle
Handle to Identity service.
struct GNUNET_IDENTITY_Operation * op
IDENTITY Operation.
void GNUNET_STRINGS_utf8_tolower(const char *input, char *output)
Convert the utf-8 input string to lower case.
Definition: strings.c:552
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_delete_pubkey()

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

Handle identity DELETE request with public key.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 1034 of file plugin_rest_identity.c.

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

Referenced by init_cont().

1037 {
1038  struct RequestHandle *handle = cls;
1039  struct EgoEntry *ego_entry;
1040  char *keystring;
1041 
1042  keystring = NULL;
1043 
1044  if (strlen(GNUNET_REST_API_NS_IDENTITY_PUBKEY) >= strlen(handle->url))
1045  {
1046  handle->response_code = MHD_HTTP_NOT_FOUND;
1049  return;
1050  }
1051  keystring = &handle->url[strlen(GNUNET_REST_API_NS_IDENTITY_PUBKEY) + 1];
1052  ego_entry = get_egoentry(handle, keystring, NULL);
1053 
1054  if (NULL == ego_entry)
1055  {
1056  handle->response_code = MHD_HTTP_NOT_FOUND;
1059  return;
1060  }
1061 
1062  handle->response_code = MHD_HTTP_NO_CONTENT;
1063  handle->op = GNUNET_IDENTITY_delete(handle->identity_handle,
1064  ego_entry->identifier,
1065  &do_finished,
1066  handle);
1067 }
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_delete(struct GNUNET_IDENTITY_Handle *h, const char *name, GNUNET_IDENTITY_Continuation cb, void *cb_cls)
Delete an existing identity.
Definition: identity_api.c:775
struct EgoEntry * get_egoentry(struct RequestHandle *handle, char *pubkey, char *name)
Get EgoEntry from list with either a public key or a name If public key and name are not NULL...
static void do_finished(void *cls, const char *emsg)
Processing finished.
#define GNUNET_REST_API_NS_IDENTITY_PUBKEY
Identity Namespace with public key specifier.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
The ego list.
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:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
HTTP response code.
char * keystring
Public key string.
char * identifier
Ego Identifier.
#define GNUNET_REST_IDENTITY_MISSING_PUBKEY
Error message Missing identity name.
static void do_error(void *cls)
Task run on errors.
struct GNUNET_IDENTITY_Handle * identity_handle
Handle to Identity service.
struct GNUNET_IDENTITY_Operation * op
IDENTITY Operation.
#define GNUNET_REST_IDENTITY_NOT_FOUND
Error message No identity found.
char * url
The url.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ ego_delete_name()

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

Handle identity DELETE request with name.

Parameters
con_handlethe connection handle
urlthe url
clsthe RequestHandle

Definition at line 1078 of file plugin_rest_identity.c.

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

Referenced by init_cont().

1081 {
1082  struct RequestHandle *handle = cls;
1083  struct EgoEntry *ego_entry;
1084  char *name;
1085 
1086  name = NULL;
1087 
1088  if (strlen(GNUNET_REST_API_NS_IDENTITY_NAME) >= strlen(handle->url))
1089  {
1090  handle->response_code = MHD_HTTP_NOT_FOUND;
1093  return;
1094  }
1095  name = &handle->url[strlen(GNUNET_REST_API_NS_IDENTITY_NAME) + 1];
1096  ego_entry = get_egoentry(handle, NULL, name);
1097 
1098  if (NULL == ego_entry)
1099  {
1100  handle->response_code = MHD_HTTP_NOT_FOUND;
1103  return;
1104  }
1105 
1106  handle->response_code = MHD_HTTP_NO_CONTENT;
1107  handle->op = GNUNET_IDENTITY_delete(handle->identity_handle,
1108  ego_entry->identifier,
1109  &do_finished,
1110  handle);
1111 }
struct GNUNET_IDENTITY_Operation * GNUNET_IDENTITY_delete(struct GNUNET_IDENTITY_Handle *h, const char *name, GNUNET_IDENTITY_Continuation cb, void *cb_cls)
Delete an existing identity.
Definition: identity_api.c:775
#define GNUNET_REST_API_NS_IDENTITY_NAME
Identity Namespace with public key specifier.
struct EgoEntry * get_egoentry(struct RequestHandle *handle, char *pubkey, char *name)
Get EgoEntry from list with either a public key or a name If public key and name are not NULL...
static void do_finished(void *cls, const char *emsg)
Processing finished.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
The request handle.
The ego list.
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:1264
#define GNUNET_REST_IDENTITY_MISSING_NAME
Error message Missing identity name.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
HTTP response code.
const char * name
char * identifier
Ego Identifier.
static void do_error(void *cls)
Task run on errors.
struct GNUNET_IDENTITY_Handle * identity_handle
Handle to Identity service.
struct GNUNET_IDENTITY_Operation * op
IDENTITY Operation.
#define GNUNET_REST_IDENTITY_NOT_FOUND
Error message No identity found.
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 1122 of file plugin_rest_identity.c.

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

Referenced by init_cont().

1125 {
1126  struct MHD_Response *resp;
1127  struct RequestHandle *handle = cls;
1128 
1129  //For now, independent of path return all options
1130  resp = GNUNET_REST_create_response(NULL);
1131  MHD_add_response_header(resp, "Access-Control-Allow-Methods", allow_methods);
1132  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
1134  return;
1135 }
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:1264
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static void cleanup_handle(void *cls)
Cleanup lookup handle.
static char * allow_methods
HTTP methods allows for this plugin.
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
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 1143 of file plugin_rest_identity.c.

References do_error(), ego_create(), ego_delete_name(), ego_delete_pubkey(), ego_edit_name(), ego_edit_pubkey(), ego_edit_subsystem(), ego_get_all(), ego_get_name(), ego_get_pubkey(), ego_get_subsystem(), GNUNET_REST_RequestHandlerError::error_code, GNUNET_NO, GNUNET_REST_API_NS_IDENTITY, GNUNET_REST_API_NS_IDENTITY_ALL, GNUNET_REST_API_NS_IDENTITY_NAME, GNUNET_REST_API_NS_IDENTITY_PUBKEY, GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM, GNUNET_REST_handle_request(), GNUNET_REST_HANDLER_END, GNUNET_SCHEDULER_add_now(), options_cont(), RequestHandle::response_code, and RequestHandle::rest_handle.

Referenced by init_egos().

1144 {
1146  static const struct GNUNET_REST_RequestHandler handlers[] =
1147  { { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_ALL, &ego_get_all },
1148  { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_PUBKEY, &ego_get_pubkey },
1149  { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_get_name },
1150  { MHD_HTTP_METHOD_GET,
1152  &ego_get_subsystem },
1153  { MHD_HTTP_METHOD_PUT,
1155  &ego_edit_pubkey },
1156  { MHD_HTTP_METHOD_PUT, GNUNET_REST_API_NS_IDENTITY_NAME, &ego_edit_name },
1157  { MHD_HTTP_METHOD_PUT,
1159  &ego_edit_subsystem },
1160  { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_IDENTITY, &ego_create },
1161  { MHD_HTTP_METHOD_DELETE,
1163  &ego_delete_pubkey },
1164  { MHD_HTTP_METHOD_DELETE,
1166  &ego_delete_name },
1167  { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_IDENTITY, &options_cont },
1169 
1170  if (GNUNET_NO ==
1171  GNUNET_REST_handle_request(handle->rest_handle, handlers, &err, handle))
1172  {
1173  handle->response_code = err.error_code;
1175  }
1176 }
void ego_edit_name(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity PUT request with name.
#define GNUNET_REST_API_NS_IDENTITY_ALL
Identity Namespace with public key specifier.
#define GNUNET_REST_API_NS_IDENTITY_NAME
Identity Namespace with public key specifier.
void ego_delete_name(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity DELETE request with name.
void ego_get_subsystem(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity GET request for subsystem.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_REST_API_NS_IDENTITY_PUBKEY
Identity Namespace with public key specifier.
void ego_delete_pubkey(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity DELETE request with public key.
#define GNUNET_REST_HANDLER_END
static void options_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Respond to OPTIONS 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:1264
#define GNUNET_REST_API_NS_IDENTITY_SUBSYSTEM
Identity Subsystem Namespace.
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:75
struct GNUNET_REST_RequestHandle * rest_handle
Handle to rest request.
int response_code
HTTP response code.
void ego_get_all(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity GET request - responds with all identities.
void ego_get_name(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity GET request with a name.
void ego_edit_pubkey(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity PUT request with public key.
#define GNUNET_REST_API_NS_IDENTITY
Identity Namespace.
static void do_error(void *cls)
Task run on errors.
void ego_create(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity POST request.
void ego_edit_subsystem(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity subsystem PUT request with name.
void ego_get_pubkey(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
Handle identity GET request with a public key.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ init_egos()

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

If listing is enabled, prints information about the egos.

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)
identifieridentifier 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 1212 of file plugin_rest_identity.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().

1216 {
1217  struct RequestHandle *handle = cls;
1218  struct EgoEntry *ego_entry;
1220 
1221  if ((NULL == ego) && (ID_REST_STATE_INIT == handle->state))
1222  {
1223  handle->state = ID_REST_STATE_POST_INIT;
1224  init_cont(handle);
1225  return;
1226  }
1227  if (ID_REST_STATE_INIT == handle->state)
1228  {
1229  ego_entry = GNUNET_new(struct EgoEntry);
1232  ego_entry->ego = ego;
1233  GNUNET_asprintf(&ego_entry->identifier, "%s", identifier);
1235  handle->ego_tail,
1236  ego_entry);
1237  }
1238 }
#define ID_REST_STATE_POST_INIT
Done collecting egos.
static struct GNUNET_CRYPTO_EddsaPrivateKey * pk
Private key of this peer.
struct EgoEntry * ego_tail
Ego list.
static void init_cont(struct RequestHandle *handle)
Handle rest request.
#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:334
char * keystring
Public key string.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
void GNUNET_IDENTITY_ego_get_public_key(const struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_CRYPTO_EcdsaPublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:566
char * identifier
Ego Identifier.
struct EgoEntry * ego_head
Ego list.
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
#define ID_REST_STATE_INIT
State while collecting all egos.
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 1252 of file plugin_rest_identity.c.

References GNUNET_REST_RequestHandle::data, RequestHandle::data, GNUNET_REST_RequestHandle::data_size, RequestHandle::data_size, do_error(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_IDENTITY_connect(), GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_REL, handle, RequestHandle::identity_handle, init_egos(), RequestHandle::proc, RequestHandle::proc_cls, RequestHandle::response_code, RequestHandle::rest_handle, RequestHandle::timeout, RequestHandle::timeout_task, GNUNET_REST_RequestHandle::url, and RequestHandle::url.

Referenced by libgnunet_plugin_rest_identity_init().

1255 {
1256  struct RequestHandle *handle = GNUNET_new(struct RequestHandle);
1257 
1258  handle->response_code = 0;
1260  handle->proc_cls = proc_cls;
1261  handle->proc = proc;
1262  handle->rest_handle = rest_handle;
1263  handle->data = rest_handle->data;
1264  handle->data_size = rest_handle->data_size;
1265 
1266  handle->url = GNUNET_strdup(rest_handle->url);
1267  if (handle->url[strlen(handle->url) - 1] == '/')
1268  handle->url[strlen(handle->url) - 1] = '\0';
1269  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting...\n");
1270 
1272 
1273  handle->timeout_task =
1274  GNUNET_SCHEDULER_add_delayed(handle->timeout, &do_error, handle);
1275 
1276  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connected\n");
1277 }
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:525
static void init_egos(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *identifier)
If listing is enabled, prints information about the egos.
size_t data_size
The POST data size.
GNUNET_REST_ResultProcessor proc
The plugin result processor.
size_t data_size
the length of the REST data
#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:1237
const char * url
The url as string.
struct GNUNET_TIME_Relative timeout
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
Handle to rest request.
int response_code
HTTP response code.
const char * data
The POST data.
const char * data
The data from the REST request.
struct GNUNET_SCHEDULER_Task * timeout_task
ID of a task associated with the resolution process.
#define GNUNET_log(kind,...)
static void do_error(void *cls)
Task run on errors.
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
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_identity_init()

void* libgnunet_plugin_rest_identity_init ( void *  cls)

Entry point for the plugin.

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

Definition at line 1286 of file plugin_rest_identity.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_IDENTITY, GNUNET_REST_Plugin::name, plugin, GNUNET_REST_Plugin::process_request, and rest_process_request().

1287 {
1288  static struct Plugin plugin;
1289  struct GNUNET_REST_Plugin *api;
1290 
1291  cfg = cls;
1292  if (NULL != plugin.cfg)
1293  return NULL; /* can only initialize once! */
1294  memset(&plugin, 0, sizeof(struct Plugin));
1295  plugin.cfg = cfg;
1296  api = GNUNET_new(struct GNUNET_REST_Plugin);
1297  api->cls = &plugin;
1301  "%s, %s, %s, %s, %s",
1302  MHD_HTTP_METHOD_GET,
1303  MHD_HTTP_METHOD_POST,
1304  MHD_HTTP_METHOD_PUT,
1305  MHD_HTTP_METHOD_DELETE,
1306  MHD_HTTP_METHOD_OPTIONS);
1307 
1308  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, _("Identity REST API initialized\n"));
1309  return api;
1310 }
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.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
char * name
Plugin name.
static void rest_process_request(struct GNUNET_REST_RequestHandle *rest_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
Function processing the REST call.
static char * allow_methods
HTTP methods allows for this plugin.
Handle for a plugin.
Definition: block.c:37
#define GNUNET_log(kind,...)
#define GNUNET_REST_API_NS_IDENTITY
Identity Namespace.
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration handle.
Here is the call graph for this function:

◆ libgnunet_plugin_rest_identity_done()

void* libgnunet_plugin_rest_identity_done ( void *  cls)

Exit point from the plugin.

Parameters
clsthe plugin context (as returned by "init")
Returns
always NULL

Definition at line 1319 of file plugin_rest_identity.c.

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

1320 {
1321  struct GNUNET_REST_Plugin *api = cls;
1322  struct Plugin *plugin = api->cls;
1323 
1324  plugin->cfg = NULL;
1325 
1327  GNUNET_free(api);
1328  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Identity REST plugin is finished\n");
1329  return NULL;
1330 }
void * cls
The closure of the plugin.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
struct returned by the initialization function of the plugin
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
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 122 of file plugin_rest_identity.c.

◆ allow_methods

char* allow_methods
static

HTTP methods allows for this plugin.

Definition at line 127 of file plugin_rest_identity.c.

Referenced by libgnunet_plugin_rest_identity_done(), libgnunet_plugin_rest_identity_init(), and options_cont().