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

GNUnet CREDENTIAL REST plugin. More...

#include "platform.h"
#include "gnunet_rest_plugin.h"
#include <gnunet_identity_service.h>
#include <gnunet_gnsrecord_lib.h>
#include <gnunet_namestore_service.h>
#include <gnunet_credential_service.h>
#include <gnunet_rest_lib.h>
#include <gnunet_jsonapi_lib.h>
#include <gnunet_jsonapi_util.h>
#include <jansson.h>
Include dependency graph for plugin_rest_credential.c:

Go to the source code of this file.

Data Structures

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

Macros

#define GNUNET_REST_API_NS_CREDENTIAL   "/credential"
 
#define GNUNET_REST_API_NS_CREDENTIAL_ISSUE   "/credential/issue"
 
#define GNUNET_REST_API_NS_CREDENTIAL_VERIFY   "/credential/verify"
 
#define GNUNET_REST_API_NS_CREDENTIAL_COLLECT   "/credential/collect"
 
#define GNUNET_REST_JSONAPI_CREDENTIAL_EXPIRATION   "expiration"
 
#define GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_KEY   "subject_key"
 
#define GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_EGO   "subject"
 
#define GNUNET_REST_JSONAPI_CREDENTIAL   "credential"
 
#define GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO   "credential"
 
#define GNUNET_REST_JSONAPI_DELEGATIONS   "delegations"
 
#define GNUNET_REST_JSONAPI_CREDENTIAL_ISSUER_ATTR   "attribute"
 
#define GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_ATTR   "credential"
 

Functions

static void cleanup_handle (struct RequestHandle *handle)
 Cleanup lookup handle. More...
 
static void do_error (void *cls)
 
static json_t * attribute_delegation_to_json (struct GNUNET_CREDENTIAL_Delegation *delegation_chain_entry)
 Attribute delegation to JSON. More...
 
static struct GNUNET_CREDENTIAL_Credentialjson_to_credential (json_t *res)
 JSONAPI resource to Credential. More...
 
static json_t * credential_to_json (struct GNUNET_CREDENTIAL_Credential *cred)
 Credential to JSON. More...
 
static void handle_collect_response (void *cls, unsigned int d_count, struct GNUNET_CREDENTIAL_Delegation *delegation_chain, unsigned int c_count, struct GNUNET_CREDENTIAL_Credential *cred)
 
static void subject_ego_lookup (void *cls, const struct GNUNET_IDENTITY_Ego *ego)
 
static void handle_verify_response (void *cls, unsigned int d_count, struct GNUNET_CREDENTIAL_Delegation *delegation_chain, unsigned int c_count, struct GNUNET_CREDENTIAL_Credential *cred)
 
static void collect_cred_cont (struct GNUNET_REST_RequestHandle *conndata_handle, const char *url, void *cls)
 
static void verify_cred_cont (struct GNUNET_REST_RequestHandle *conndata_handle, const char *url, void *cls)
 
void send_cred_response (struct RequestHandle *handle, struct GNUNET_CREDENTIAL_Credential *cred)
 
void get_cred_issuer_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
 
static void issue_cred_cont (struct GNUNET_REST_RequestHandle *conndata_handle, const char *url, void *cls)
 
static void options_cont (struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
 
static void rest_credential_process_request (struct GNUNET_REST_RequestHandle *conndata_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
 
void * libgnunet_plugin_rest_credential_init (void *cls)
 Entry point for the plugin. More...
 
void * libgnunet_plugin_rest_credential_done (void *cls)
 Exit point from the plugin. More...
 

Variables

const struct GNUNET_CONFIGURATION_Handlecfg
 Handle to our configuration. More...
 

Detailed Description

GNUnet CREDENTIAL REST plugin.

Author
Martin Schanzenbach

Definition in file plugin_rest_credential.c.

Macro Definition Documentation

◆ GNUNET_REST_API_NS_CREDENTIAL

#define GNUNET_REST_API_NS_CREDENTIAL   "/credential"

◆ GNUNET_REST_API_NS_CREDENTIAL_ISSUE

#define GNUNET_REST_API_NS_CREDENTIAL_ISSUE   "/credential/issue"

Definition at line 40 of file plugin_rest_credential.c.

Referenced by rest_credential_process_request().

◆ GNUNET_REST_API_NS_CREDENTIAL_VERIFY

#define GNUNET_REST_API_NS_CREDENTIAL_VERIFY   "/credential/verify"

Definition at line 42 of file plugin_rest_credential.c.

Referenced by rest_credential_process_request().

◆ GNUNET_REST_API_NS_CREDENTIAL_COLLECT

#define GNUNET_REST_API_NS_CREDENTIAL_COLLECT   "/credential/collect"

Definition at line 44 of file plugin_rest_credential.c.

Referenced by rest_credential_process_request().

◆ GNUNET_REST_JSONAPI_CREDENTIAL_EXPIRATION

#define GNUNET_REST_JSONAPI_CREDENTIAL_EXPIRATION   "expiration"

Definition at line 46 of file plugin_rest_credential.c.

Referenced by get_cred_issuer_cb().

◆ GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_KEY

#define GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_KEY   "subject_key"

Definition at line 48 of file plugin_rest_credential.c.

Referenced by get_cred_issuer_cb(), and verify_cred_cont().

◆ GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_EGO

#define GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_EGO   "subject"

Definition at line 50 of file plugin_rest_credential.c.

Referenced by collect_cred_cont().

◆ GNUNET_REST_JSONAPI_CREDENTIAL

#define GNUNET_REST_JSONAPI_CREDENTIAL   "credential"

◆ GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO

#define GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO   "credential"

◆ GNUNET_REST_JSONAPI_DELEGATIONS

#define GNUNET_REST_JSONAPI_DELEGATIONS   "delegations"

Definition at line 56 of file plugin_rest_credential.c.

Referenced by handle_verify_response().

◆ GNUNET_REST_JSONAPI_CREDENTIAL_ISSUER_ATTR

#define GNUNET_REST_JSONAPI_CREDENTIAL_ISSUER_ATTR   "attribute"

◆ GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_ATTR

#define GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_ATTR   "credential"

Definition at line 60 of file plugin_rest_credential.c.

Function Documentation

◆ cleanup_handle()

static void cleanup_handle ( struct RequestHandle handle)
static

Cleanup lookup handle.

Parameters
handleHandle to clean up

Definition at line 165 of file plugin_rest_credential.c.

References RequestHandle::credential, RequestHandle::ego_lookup, GNUNET_CREDENTIAL_disconnect(), GNUNET_CREDENTIAL_request_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_IDENTITY_cancel(), GNUNET_IDENTITY_disconnect(), GNUNET_IDENTITY_ego_lookup_cancel(), GNUNET_log, GNUNET_SCHEDULER_cancel(), RequestHandle::id_op, RequestHandle::identity, RequestHandle::issuer_attr, RequestHandle::json_root, RequestHandle::subject_attr, RequestHandle::timeout_task, and RequestHandle::verify_request.

Referenced by do_error(), handle_collect_response(), handle_verify_response(), options_cont(), and send_cred_response().

166 {
168  "Cleaning up\n");
169  if (NULL != handle->json_root)
170  json_decref(handle->json_root);
171 
172  if (NULL != handle->issuer_attr)
173  GNUNET_free(handle->issuer_attr);
174  if (NULL != handle->subject_attr)
175  GNUNET_free(handle->subject_attr);
176  if (NULL != handle->verify_request)
178  if (NULL != handle->credential)
180  if (NULL != handle->id_op)
181  GNUNET_IDENTITY_cancel(handle->id_op);
182  if (NULL != handle->ego_lookup)
184  if (NULL != handle->identity)
186  if (NULL != handle->timeout_task)
187  {
189  }
190  GNUNET_free(handle);
191 }
void GNUNET_IDENTITY_cancel(struct GNUNET_IDENTITY_Operation *op)
Cancel an identity operation.
Definition: identity_api.c:816
void GNUNET_IDENTITY_ego_lookup_cancel(struct GNUNET_IDENTITY_EgoLookup *el)
Abort ego lookup attempt.
void GNUNET_CREDENTIAL_request_cancel(struct GNUNET_CREDENTIAL_Request *lr)
Cancel pending verify request.
struct GNUNET_IDENTITY_Operation * id_op
Handle to identity operation.
struct GNUNET_CREDENTIAL_Handle * credential
Handle to Credential service.
void GNUNET_CREDENTIAL_disconnect(struct GNUNET_CREDENTIAL_Handle *handle)
Shutdown connection with the CREDENTIAL service.
struct GNUNET_IDENTITY_Handle * identity
Handle to identity.
struct GNUNET_CREDENTIAL_Request * verify_request
Handle to lookup request.
void GNUNET_IDENTITY_disconnect(struct GNUNET_IDENTITY_Handle *h)
Disconnect from identity service.
Definition: identity_api.c:835
char * subject_attr
The subject attribute.
struct GNUNET_SCHEDULER_Task * timeout_task
ID of a task associated with the resolution process.
char * issuer_attr
The issuer attribute to verify.
#define GNUNET_log(kind,...)
json_t * json_root
The root of the received JSON or NULL.
struct GNUNET_IDENTITY_EgoLookup * ego_lookup
Handle to ego lookup.
#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
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

Definition at line 195 of file plugin_rest_credential.c.

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

Referenced by collect_cred_cont(), get_cred_issuer_cb(), handle_collect_response(), handle_verify_response(), issue_cred_cont(), rest_credential_process_request(), subject_ego_lookup(), and verify_cred_cont().

196 {
197  struct RequestHandle *handle = cls;
198  struct MHD_Response *resp;
199 
200  resp = GNUNET_REST_create_response(NULL);
201  handle->proc(handle->proc_cls, resp, handle->response_code);
202  cleanup_handle(handle);
203 }
GNUNET_REST_ResultProcessor proc
The plugin result processor.
static void cleanup_handle(struct RequestHandle *handle)
Cleanup lookup handle.
void * proc_cls
The closure of the result processor.
The request handle.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
int response_code
HTTP response code.
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:

◆ attribute_delegation_to_json()

static json_t* attribute_delegation_to_json ( struct GNUNET_CREDENTIAL_Delegation delegation_chain_entry)
static

Attribute delegation to JSON.

Parameters
delegation_chain_entrythe DSE
Returns
JSON, NULL if failed

Definition at line 212 of file plugin_rest_credential.c.

References GNUNET_CRYPTO_ecdsa_public_key_to_string(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_CREDENTIAL_Delegation::issuer_attribute, GNUNET_CREDENTIAL_Delegation::issuer_key, GNUNET_CREDENTIAL_Delegation::subject_attribute, GNUNET_CREDENTIAL_Delegation::subject_attribute_len, and GNUNET_CREDENTIAL_Delegation::subject_key.

Referenced by handle_verify_response().

213 {
214  char *subject;
215  char *issuer;
216  json_t *attr_obj;
217 
218  issuer = GNUNET_CRYPTO_ecdsa_public_key_to_string(&delegation_chain_entry->issuer_key);
219  if (NULL == issuer)
220  {
222  "Issuer in delegation malformed\n");
223  return NULL;
224  }
225  subject = GNUNET_CRYPTO_ecdsa_public_key_to_string(&delegation_chain_entry->subject_key);
226  if (NULL == subject)
227  {
229  "Subject in credential malformed\n");
230  GNUNET_free(issuer);
231  return NULL;
232  }
233  attr_obj = json_object();
234 
235  json_object_set_new(attr_obj, "issuer", json_string(issuer));
236  json_object_set_new(attr_obj, "issuer_attribute",
237  json_string(delegation_chain_entry->issuer_attribute));
238 
239  json_object_set_new(attr_obj, "subject", json_string(subject));
240  if (0 < delegation_chain_entry->subject_attribute_len)
241  {
242  json_object_set_new(attr_obj, "subject_attribute",
243  json_string(delegation_chain_entry->subject_attribute));
244  }
245  GNUNET_free(issuer);
246  GNUNET_free(subject);
247  return attr_obj;
248 }
uint32_t subject_attribute_len
Length of the attribute.
const char * subject_attribute
The attribute.
const char * issuer_attribute
The attribute.
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
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
Public key of the subject this attribute was delegated to.
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
The issuer of the delegation.
#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:

◆ json_to_credential()

static struct GNUNET_CREDENTIAL_Credential* json_to_credential ( json_t *  res)
static

JSONAPI resource to Credential.

Parameters
resthe JSONAPI resource
Returns
the resulting credential, NULL if failed

Definition at line 257 of file plugin_rest_credential.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_CREDENTIAL_Credential::expiration, GNUNET_CRYPTO_ecdsa_public_key_from_string(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_STRINGS_base64_decode(), GNUNET_CREDENTIAL_Credential::issuer_attribute, GNUNET_CREDENTIAL_Credential::issuer_attribute_len, GNUNET_CREDENTIAL_Credential::issuer_key, GNUNET_CREDENTIAL_Credential::signature, and GNUNET_CREDENTIAL_Credential::subject_key.

Referenced by verify_cred_cont().

258 {
259  struct GNUNET_CREDENTIAL_Credential *cred;
260  json_t *tmp;
261  const char *attribute;
262  const char *signature;
263  char *sig;
264 
265  tmp = json_object_get(res, "attribute");
266  if (0 == json_is_string(tmp))
267  {
268  return NULL;
269  }
270  attribute = json_string_value(tmp);
271  cred = GNUNET_malloc(sizeof(struct GNUNET_CREDENTIAL_Credential)
272  + strlen(attribute));
273  cred->issuer_attribute = attribute;
274  cred->issuer_attribute_len = strlen(attribute);
275  tmp = json_object_get(res, "issuer");
276  if (0 == json_is_string(tmp))
277  {
278  GNUNET_free(cred);
279  return NULL;
280  }
281 
282  GNUNET_CRYPTO_ecdsa_public_key_from_string(json_string_value(tmp),
283  strlen(json_string_value(tmp)),
284  &cred->issuer_key);
285  tmp = json_object_get(res, "subject");
286  if (0 == json_is_string(tmp))
287  {
288  GNUNET_free(cred);
289  return NULL;
290  }
291  GNUNET_CRYPTO_ecdsa_public_key_from_string(json_string_value(tmp),
292  strlen(json_string_value(tmp)),
293  &cred->subject_key);
294 
295  tmp = json_object_get(res, "signature");
296  if (0 == json_is_string(tmp))
297  {
298  GNUNET_free(cred);
299  return NULL;
300  }
301  signature = json_string_value(tmp);
303  strlen(signature),
304  (char**)&sig);
305  GNUNET_memcpy(&cred->signature,
306  sig,
307  sizeof(struct GNUNET_CRYPTO_EcdsaSignature));
308  GNUNET_free(sig);
309 
310  tmp = json_object_get(res, "expiration");
311  if (0 == json_is_integer(tmp))
312  {
313  GNUNET_free(cred);
314  return NULL;
315  }
316  cred->expiration.abs_value_us = json_integer_value(tmp);
317  return cred;
318 }
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
Public key of the subject this credential was issued to.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
The issuer of the credential.
uint64_t abs_value_us
The actual value.
an ECC signature using ECDSA
struct GNUNET_CRYPTO_EcdsaSignature signature
Signature of this credential.
static int res
size_t GNUNET_STRINGS_base64_decode(const char *data, size_t len, void **output)
Decode from Base64.
Definition: strings.c:1920
struct GNUNET_TIME_Absolute expiration
Expiration of this credential.
const char * issuer_attribute
The attribute.
int GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:468
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
uint32_t issuer_attribute_len
Length of the attribute.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ credential_to_json()

static json_t* credential_to_json ( struct GNUNET_CREDENTIAL_Credential cred)
static

Credential to JSON.

Parameters
credthe credential
Returns
the resulting json, NULL if failed

Definition at line 328 of file plugin_rest_credential.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_CREDENTIAL_Credential::expiration, GNUNET_CRYPTO_ecdsa_public_key_to_string(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_STRINGS_base64_encode(), GNUNET_CREDENTIAL_Credential::issuer_attribute, GNUNET_CREDENTIAL_Credential::issuer_attribute_len, GNUNET_CREDENTIAL_Credential::issuer_key, GNUNET_CREDENTIAL_Credential::signature, and GNUNET_CREDENTIAL_Credential::subject_key.

Referenced by handle_collect_response(), and handle_verify_response().

329 {
330  char *issuer;
331  char *subject;
332  char *signature;
333  char attribute[cred->issuer_attribute_len + 1];
334  json_t *cred_obj;
335 
337  if (NULL == issuer)
338  {
340  "Issuer in credential malformed\n");
341  return NULL;
342  }
344  if (NULL == subject)
345  {
347  "Subject in credential malformed\n");
348  GNUNET_free(issuer);
349  return NULL;
350  }
352  sizeof(struct GNUNET_CRYPTO_EcdsaSignature),
353  &signature);
354  GNUNET_memcpy(attribute,
355  cred->issuer_attribute,
356  cred->issuer_attribute_len);
357  attribute[cred->issuer_attribute_len] = '\0';
358  cred_obj = json_object();
359  json_object_set_new(cred_obj, "issuer", json_string(issuer));
360  json_object_set_new(cred_obj, "subject", json_string(subject));
361  json_object_set_new(cred_obj, "attribute", json_string(attribute));
362  json_object_set_new(cred_obj, "signature", json_string(signature));
363  json_object_set_new(cred_obj, "expiration", json_integer(cred->expiration.abs_value_us));
364  GNUNET_free(issuer);
365  GNUNET_free(subject);
366  GNUNET_free(signature);
367  return cred_obj;
368 }
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
Public key of the subject this credential was issued to.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
The issuer of the credential.
uint64_t abs_value_us
The actual value.
an ECC signature using ECDSA
struct GNUNET_CRYPTO_EcdsaSignature signature
Signature of this credential.
size_t GNUNET_STRINGS_base64_encode(const void *in, size_t len, char **output)
Encode into Base64.
Definition: strings.c:1856
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
struct GNUNET_TIME_Absolute expiration
Expiration of this credential.
const char * issuer_attribute
The attribute.
#define GNUNET_log(kind,...)
#define GNUNET_free(ptr)
Wrapper around free.
uint32_t issuer_attribute_len
Length of the attribute.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_collect_response()

static void handle_collect_response ( void *  cls,
unsigned int  d_count,
struct GNUNET_CREDENTIAL_Delegation delegation_chain,
unsigned int  c_count,
struct GNUNET_CREDENTIAL_Credential cred 
)
static

Definition at line 371 of file plugin_rest_credential.c.

References cleanup_handle(), credential_to_json(), do_error(), GNUNET_asprintf(), GNUNET_CRYPTO_ecdsa_public_key_to_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_REST_create_response(), GNUNET_REST_JSONAPI_CREDENTIAL, GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO, GNUNET_SCHEDULER_add_now(), handle, id, RequestHandle::issuer_attr, RequestHandle::issuer_key, RequestHandle::proc, RequestHandle::proc_cls, RequestHandle::response_code, result, and RequestHandle::verify_request.

Referenced by subject_ego_lookup().

376 {
377  struct RequestHandle *handle = cls;
378  struct MHD_Response *resp;
379  struct GNUNET_JSONAPI_Document *json_document;
380  struct GNUNET_JSONAPI_Resource *json_resource;
381  json_t *cred_obj;
382  json_t *cred_array;
383  char *result;
384  char *issuer;
385  char *id;
386  uint32_t i;
387 
388  handle->verify_request = NULL;
389  if (NULL == cred)
390  {
392  "Verify failed.\n");
393  handle->response_code = MHD_HTTP_NOT_FOUND;
395  return;
396  }
398  if (NULL == issuer)
399  {
401  "Issuer in delegation malformed\n");
402  return;
403  }
404  GNUNET_asprintf(&id,
405  "%s.%s",
406  issuer,
407  handle->issuer_attr);
408  GNUNET_free(issuer);
409  json_document = GNUNET_JSONAPI_document_new();
410  json_resource = GNUNET_JSONAPI_resource_new(GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO,
411  id);
412  GNUNET_free(id);
413  cred_array = json_array();
414  for (i = 0; i < c_count; i++)
415  {
416  cred_obj = credential_to_json(&cred[i]);
417  json_array_append_new(cred_array, cred_obj);
418  }
419  GNUNET_JSONAPI_resource_add_attr(json_resource,
421  cred_array);
422  GNUNET_JSONAPI_document_resource_add(json_document, json_resource);
423  GNUNET_JSONAPI_document_serialize(json_document, &result);
425  "Result %s\n",
426  result);
427  json_decref(cred_array);
428  GNUNET_JSONAPI_document_delete(json_document);
429  resp = GNUNET_REST_create_response(result);
430  GNUNET_free(result);
431  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
432  cleanup_handle(handle);
433 }
GNUNET_REST_ResultProcessor proc
The plugin result processor.
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
static void cleanup_handle(struct RequestHandle *handle)
Cleanup lookup handle.
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
The public key of the issuer.
void * proc_cls
The closure of the result processor.
The request handle.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
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
struct GNUNET_CREDENTIAL_Request * verify_request
Handle to lookup request.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static int result
Global testing status.
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
static json_t * credential_to_json(struct GNUNET_CREDENTIAL_Credential *cred)
Credential to JSON.
#define GNUNET_REST_JSONAPI_CREDENTIAL
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
char * issuer_attr
The issuer attribute to verify.
#define GNUNET_log(kind,...)
static void do_error(void *cls)
#define GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ subject_ego_lookup()

static void subject_ego_lookup ( void *  cls,
const struct GNUNET_IDENTITY_Ego ego 
)
static

Definition at line 436 of file plugin_rest_credential.c.

References RequestHandle::credential, do_error(), RequestHandle::ego_lookup, GNUNET_CREDENTIAL_collect(), GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_SCHEDULER_add_now(), handle, handle_collect_response(), RequestHandle::issuer_attr, RequestHandle::issuer_key, and RequestHandle::verify_request.

Referenced by collect_cred_cont().

438 {
439  struct RequestHandle *handle = cls;
440  const struct GNUNET_CRYPTO_EcdsaPrivateKey *sub_key;
441 
442  handle->ego_lookup = NULL;
443 
444  if (NULL == ego)
445  {
447  "Subject not found\n");
449  return;
450  }
453  &handle->issuer_key,
454  handle->issuer_attr,
455  sub_key,
457  handle);
458 }
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:553
Private ECC key encoded for transmission.
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
The public key of the issuer.
struct GNUNET_CREDENTIAL_Handle * credential
Handle to Credential service.
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
struct GNUNET_CREDENTIAL_Request * verify_request
Handle to lookup request.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
struct GNUNET_CREDENTIAL_Request * GNUNET_CREDENTIAL_collect(struct GNUNET_CREDENTIAL_Handle *handle, const struct GNUNET_CRYPTO_EcdsaPublicKey *issuer_key, const char *issuer_attribute, const struct GNUNET_CRYPTO_EcdsaPrivateKey *subject_key, GNUNET_CREDENTIAL_CredentialResultProcessor proc, void *proc_cls)
Performs attribute collection.
char * issuer_attr
The issuer attribute to verify.
#define GNUNET_log(kind,...)
static void do_error(void *cls)
struct GNUNET_IDENTITY_EgoLookup * ego_lookup
Handle to ego lookup.
static void handle_collect_response(void *cls, unsigned int d_count, struct GNUNET_CREDENTIAL_Delegation *delegation_chain, unsigned int c_count, struct GNUNET_CREDENTIAL_Credential *cred)
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_verify_response()

static void handle_verify_response ( void *  cls,
unsigned int  d_count,
struct GNUNET_CREDENTIAL_Delegation delegation_chain,
unsigned int  c_count,
struct GNUNET_CREDENTIAL_Credential cred 
)
static

Definition at line 463 of file plugin_rest_credential.c.

References attribute_delegation_to_json(), cleanup_handle(), credential_to_json(), do_error(), GNUNET_asprintf(), GNUNET_CRYPTO_ecdsa_public_key_to_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_REST_create_response(), GNUNET_REST_JSONAPI_CREDENTIAL, GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO, GNUNET_REST_JSONAPI_DELEGATIONS, GNUNET_SCHEDULER_add_now(), handle, id, RequestHandle::issuer_attr, RequestHandle::issuer_key, RequestHandle::proc, RequestHandle::proc_cls, RequestHandle::response_code, result, and RequestHandle::verify_request.

Referenced by verify_cred_cont().

468 {
469  struct RequestHandle *handle = cls;
470  struct MHD_Response *resp;
471  struct GNUNET_JSONAPI_Document *json_document;
472  struct GNUNET_JSONAPI_Resource *json_resource;
473  json_t *cred_obj;
474  json_t *attr_obj;
475  json_t *cred_array;
476  json_t *attr_array;
477  char *result;
478  char *issuer;
479  char *id;
480  uint32_t i;
481 
482  handle->verify_request = NULL;
483  if (NULL == cred)
484  {
486  "Verify failed.\n");
487  handle->response_code = MHD_HTTP_NOT_FOUND;
489  return;
490  }
492  if (NULL == issuer)
493  {
495  "Issuer in delegation malformed\n");
496  return;
497  }
498  GNUNET_asprintf(&id,
499  "%s.%s",
500  issuer,
501  handle->issuer_attr);
502  GNUNET_free(issuer);
503  json_document = GNUNET_JSONAPI_document_new();
504  json_resource = GNUNET_JSONAPI_resource_new(GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO,
505  id);
506  GNUNET_free(id);
507  attr_array = json_array();
508  for (i = 0; i < d_count; i++)
509  {
510  attr_obj = attribute_delegation_to_json(&delegation_chain[i]);
511  json_array_append_new(attr_array, attr_obj);
512  }
513  cred_array = json_array();
514  for (i = 0; i < c_count; i++)
515  {
516  cred_obj = credential_to_json(&cred[i]);
517  json_array_append_new(cred_array, cred_obj);
518  }
519  GNUNET_JSONAPI_resource_add_attr(json_resource,
521  cred_array);
522  GNUNET_JSONAPI_resource_add_attr(json_resource,
524  attr_array);
525  GNUNET_JSONAPI_document_resource_add(json_document, json_resource);
526  GNUNET_JSONAPI_document_serialize(json_document, &result);
528  "Result %s\n",
529  result);
530  json_decref(attr_array);
531  json_decref(cred_array);
532  GNUNET_JSONAPI_document_delete(json_document);
533  resp = GNUNET_REST_create_response(result);
534  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
535  GNUNET_free(result);
536  cleanup_handle(handle);
537 }
GNUNET_REST_ResultProcessor proc
The plugin result processor.
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
static void cleanup_handle(struct RequestHandle *handle)
Cleanup lookup handle.
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
The public key of the issuer.
void * proc_cls
The closure of the result processor.
The request handle.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
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
struct GNUNET_CREDENTIAL_Request * verify_request
Handle to lookup request.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static int result
Global testing status.
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
static json_t * credential_to_json(struct GNUNET_CREDENTIAL_Credential *cred)
Credential to JSON.
#define GNUNET_REST_JSONAPI_CREDENTIAL
struct MHD_Response * GNUNET_REST_create_response(const char *data)
Create REST MHD response.
Definition: rest.c:56
char * issuer_attr
The issuer attribute to verify.
#define GNUNET_log(kind,...)
static void do_error(void *cls)
#define GNUNET_REST_JSONAPI_DELEGATIONS
static json_t * attribute_delegation_to_json(struct GNUNET_CREDENTIAL_Delegation *delegation_chain_entry)
Attribute delegation to JSON.
#define GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ collect_cred_cont()

static void collect_cred_cont ( struct GNUNET_REST_RequestHandle conndata_handle,
const char *  url,
void *  cls 
)
static

Definition at line 540 of file plugin_rest_credential.c.

References RequestHandle::credential, do_error(), RequestHandle::ego_lookup, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CREDENTIAL_connect(), GNUNET_CRYPTO_ecdsa_public_key_from_string(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_IDENTITY_ego_lookup(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_REST_JSONAPI_CREDENTIAL_ISSUER_ATTR, GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_EGO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, RequestHandle::issuer_attr, RequestHandle::issuer_key, subject_ego_lookup(), RequestHandle::timeout, RequestHandle::timeout_task, and GNUNET_REST_RequestHandle::url_param_map.

Referenced by rest_credential_process_request().

543 {
544  struct RequestHandle *handle = cls;
545  struct GNUNET_HashCode key;
546  char *tmp;
547  char *entity_attr;
548 
550  "Connecting...\n");
553  &do_error, handle);
555  "Connected\n");
556  if (NULL == handle->credential)
557  {
559  "Connecting to CREDENTIAL failed\n");
561  return;
562  }
565  &key);
566  if (GNUNET_NO ==
568  &key))
569  {
571  "Missing issuer attribute\n");
573  return;
574  }
575  tmp = GNUNET_CONTAINER_multihashmap_get(conndata_handle->url_param_map,
576  &key);
577  entity_attr = GNUNET_strdup(tmp);
578  tmp = strtok(entity_attr, ".");
579  if (NULL == tmp)
580  {
582  "Malformed issuer or attribute\n");
583  GNUNET_free(entity_attr);
585  return;
586  }
587  if (GNUNET_OK !=
589  strlen(tmp),
590  &handle->issuer_key))
591  {
593  "Malformed issuer key\n");
594  GNUNET_free(entity_attr);
596  return;
597  }
598  tmp = strtok(NULL, "."); //Issuer attribute
599  if (NULL == tmp)
600  {
602  "Malformed attribute\n");
603  GNUNET_free(entity_attr);
605  return;
606  }
607  handle->issuer_attr = GNUNET_strdup(tmp);
608  GNUNET_free(entity_attr);
609 
612  &key);
613  if (GNUNET_NO ==
615  &key))
616  {
618  "Missing subject\n");
620  return;
621  }
622  tmp = GNUNET_CONTAINER_multihashmap_get(conndata_handle->url_param_map,
623  &key);
624  if (NULL == tmp)
625  {
627  "Malformed subject\n");
629  return;
630  }
632  tmp,
634  handle);
635 }
#define GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_EGO
#define GNUNET_REST_JSONAPI_CREDENTIAL_ISSUER_ATTR
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
The public key of the issuer.
struct GNUNET_CREDENTIAL_Handle * credential
Handle to Credential service.
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_.
const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our configuration.
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.
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
struct GNUNET_CONTAINER_MultiHashMap * url_param_map
Map of url parameters.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
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
struct GNUNET_TIME_Relative timeout
Timeout.
struct GNUNET_CREDENTIAL_Handle * GNUNET_CREDENTIAL_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the connection with the CREDENTIAL service.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
A 512-bit hashcode.
struct GNUNET_HashCode key
The key used in the DHT.
static void subject_ego_lookup(void *cls, const struct GNUNET_IDENTITY_Ego *ego)
struct GNUNET_IDENTITY_EgoLookup * GNUNET_IDENTITY_ego_lookup(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, GNUNET_IDENTITY_EgoCallback cb, void *cb_cls)
Lookup an ego by name.
int GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:468
struct GNUNET_SCHEDULER_Task * timeout_task
ID of a task associated with the resolution process.
char * issuer_attr
The issuer attribute to verify.
#define GNUNET_log(kind,...)
static void do_error(void *cls)
struct GNUNET_IDENTITY_EgoLookup * ego_lookup
Handle to ego lookup.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ verify_cred_cont()

static void verify_cred_cont ( struct GNUNET_REST_RequestHandle conndata_handle,
const char *  url,
void *  cls 
)
static

Definition at line 640 of file plugin_rest_credential.c.

References RequestHandle::credential, GNUNET_REST_RequestHandle::data, GNUNET_REST_RequestHandle::data_size, do_error(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CREDENTIAL_connect(), GNUNET_CREDENTIAL_verify(), GNUNET_CRYPTO_ecdsa_public_key_from_string(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_JSON_parse(), GNUNET_JSON_spec_end(), GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_REST_JSONAPI_CREDENTIAL, GNUNET_REST_JSONAPI_CREDENTIAL_ISSUER_ATTR, GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_KEY, GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_strdup, handle, handle_verify_response(), RequestHandle::issuer_attr, GNUNET_CREDENTIAL_Credential::issuer_attribute, RequestHandle::issuer_key, json_to_credential(), res, RequestHandle::rest_handle, RequestHandle::subject_key, RequestHandle::timeout, RequestHandle::timeout_task, GNUNET_REST_RequestHandle::url_param_map, and RequestHandle::verify_request.

Referenced by rest_credential_process_request().

643 {
644  struct RequestHandle *handle = cls;
645  struct GNUNET_HashCode key;
646  struct GNUNET_JSONAPI_Document *json_obj;
647  struct GNUNET_JSONAPI_Resource *res;
648  struct GNUNET_CREDENTIAL_Credential *cred;
649  char *tmp;
650  char *entity_attr;
651  int i;
652  uint32_t credential_count;
653  uint32_t resource_count;
654  json_t *cred_json;
655  json_t *data_js;
656  json_error_t err;
657 
659  "Connecting...\n");
662  &do_error, handle);
664  "Connected\n");
665  if (NULL == handle->credential)
666  {
668  "Connecting to CREDENTIAL failed\n");
670  return;
671  }
674  &key);
675  if (GNUNET_NO ==
677  &key))
678  {
680  "Missing issuer attribute\n");
682  return;
683  }
684  tmp = GNUNET_CONTAINER_multihashmap_get(conndata_handle->url_param_map,
685  &key);
686  entity_attr = GNUNET_strdup(tmp);
687  tmp = strtok(entity_attr, ".");
688  if (NULL == tmp)
689  {
691  "Malformed issuer or attribute\n");
692  GNUNET_free(entity_attr);
694  return;
695  }
696  if (GNUNET_OK !=
698  strlen(tmp),
699  &handle->issuer_key))
700  {
702  "Malformed issuer key\n");
703  GNUNET_free(entity_attr);
705  return;
706  }
707  tmp = strtok(NULL, "."); //Issuer attribute
708  if (NULL == tmp)
709  {
711  "Malformed attribute\n");
712  GNUNET_free(entity_attr);
714  return;
715  }
716  handle->issuer_attr = GNUNET_strdup(tmp);
717  GNUNET_free(entity_attr);
718 
721  &key);
722  if (GNUNET_NO ==
724  &key))
725  {
727  "Missing subject key\n");
729  return;
730  }
731  tmp = GNUNET_CONTAINER_multihashmap_get(conndata_handle->url_param_map,
732  &key);
733  if (NULL == tmp)
734  {
736  "Malformed subject\n");
738  return;
739  }
740  if (GNUNET_OK !=
742  strlen(tmp),
743  &handle->subject_key))
744  {
746  "Malformed subject key\n");
748  return;
749  }
750 
751  if (0 >= handle->rest_handle->data_size)
752  {
754  "Missing credentials\n");
756  return;
757  }
758 
759  struct GNUNET_JSON_Specification docspec[] = {
760  GNUNET_JSON_spec_jsonapi_document(&json_obj),
762  };
763  char term_data[handle->rest_handle->data_size + 1];
764  term_data[handle->rest_handle->data_size] = '\0';
765  credential_count = 0;
766  GNUNET_memcpy(term_data,
767  handle->rest_handle->data,
768  handle->rest_handle->data_size);
769  data_js = json_loads(term_data,
770  JSON_DECODE_ANY,
771  &err);
772  GNUNET_assert(GNUNET_OK == GNUNET_JSON_parse(data_js, docspec,
773  NULL, NULL));
774  json_decref(data_js);
775  if (NULL == json_obj)
776  {
778  "Unable to parse JSONAPI Object from %s\n",
779  term_data);
781  return;
782  }
783 
784  resource_count = GNUNET_JSONAPI_document_resource_count(json_obj);
785  GNUNET_assert(1 == resource_count);
786  res = (GNUNET_JSONAPI_document_get_resource(json_obj, 0));
787  if (GNUNET_NO == GNUNET_JSONAPI_resource_check_type(res,
789  {
791  "Resource not a credential!\n");
793  "Unable to parse JSONAPI Object from %s\n",
794  term_data);
795  GNUNET_JSONAPI_document_delete(json_obj);
797  return;
798  }
799  cred_json = GNUNET_JSONAPI_resource_read_attr(res,
801 
802  GNUNET_assert(json_is_array(cred_json));
803 
804  credential_count = json_array_size(cred_json);
805 
806  struct GNUNET_CREDENTIAL_Credential credentials[credential_count];
807  for (i = 0; i < credential_count; i++)
808  {
809  cred = json_to_credential(json_array_get(cred_json, i));
810  if (NULL == cred)
811  {
813  "Unable to parse credential!\n");
814  continue;
815  }
816  GNUNET_memcpy(&credentials[i],
817  cred,
818  sizeof(struct GNUNET_CREDENTIAL_Credential));
819  credentials[i].issuer_attribute = GNUNET_strdup(cred->issuer_attribute);
820  GNUNET_free(cred);
821  }
822  GNUNET_JSONAPI_document_delete(json_obj);
824  &handle->issuer_key,
825  handle->issuer_attr,
826  &handle->subject_key,
827  credential_count,
828  credentials,
830  handle);
831  for (i = 0; i < credential_count; i++)
832  GNUNET_free((char*)credentials[i].issuer_attribute);
833 }
size_t data_size
The POST data size.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_CREDENTIAL_Credential * json_to_credential(json_t *res)
JSONAPI resource to Credential.
static void handle_verify_response(void *cls, unsigned int d_count, struct GNUNET_CREDENTIAL_Delegation *delegation_chain, unsigned int c_count, struct GNUNET_CREDENTIAL_Credential *cred)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_REST_JSONAPI_CREDENTIAL_ISSUER_ATTR
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
The public key of the subject.
Entry in parser specification for GNUNET_JSON_parse().
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
The public key of the issuer.
struct GNUNET_CREDENTIAL_Handle * credential
Handle to Credential service.
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_.
const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our configuration.
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.
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
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
struct GNUNET_CONTAINER_MultiHashMap * url_param_map
Map of url parameters.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
#define GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_KEY
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
struct GNUNET_CREDENTIAL_Request * verify_request
Handle to lookup request.
struct GNUNET_TIME_Relative timeout
Timeout.
struct GNUNET_CREDENTIAL_Handle * GNUNET_CREDENTIAL_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the connection with the CREDENTIAL service.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
struct GNUNET_REST_RequestHandle * rest_handle
Handle to rest request.
A 512-bit hashcode.
static int res
const char * data
The POST data.
struct GNUNET_HashCode key
The key used in the DHT.
const char * issuer_attribute
The attribute.
int GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:468
#define GNUNET_REST_JSONAPI_CREDENTIAL
struct GNUNET_SCHEDULER_Task * timeout_task
ID of a task associated with the resolution process.
char * issuer_attr
The issuer attribute to verify.
#define GNUNET_log(kind,...)
static void do_error(void *cls)
#define GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO
struct GNUNET_JSON_Specification GNUNET_JSON_spec_end(void)
End of a parser specification.
Definition: json_helper.c:35
struct GNUNET_CREDENTIAL_Request * GNUNET_CREDENTIAL_verify(struct GNUNET_CREDENTIAL_Handle *handle, const struct GNUNET_CRYPTO_EcdsaPublicKey *issuer_key, const char *issuer_attribute, const struct GNUNET_CRYPTO_EcdsaPublicKey *subject_key, uint32_t credential_count, const struct GNUNET_CREDENTIAL_Credential *credentials, GNUNET_CREDENTIAL_CredentialResultProcessor proc, void *proc_cls)
Performs attribute verification.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ send_cred_response()

void send_cred_response ( struct RequestHandle handle,
struct GNUNET_CREDENTIAL_Credential cred 
)

Definition at line 836 of file plugin_rest_credential.c.

References cleanup_handle(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CRYPTO_ecdsa_public_key_to_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_REST_create_response(), GNUNET_REST_JSONAPI_CREDENTIAL, GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO, GNUNET_STRINGS_base64_encode(), id, GNUNET_CREDENTIAL_Credential::issuer_key, RequestHandle::proc, RequestHandle::proc_cls, and result.

Referenced by get_cred_issuer_cb().

838 {
839  struct MHD_Response *resp;
840  struct GNUNET_JSONAPI_Document *json_document;
841  struct GNUNET_JSONAPI_Resource *json_resource;
842  json_t *cred_obj;
843  char *result;
844  char *issuer;
845  char *subject;
846  char *signature;
847  char *id;
848 
849  GNUNET_assert(NULL != cred);
851  if (NULL == issuer)
852  {
854  "Subject malformed\n");
855  GNUNET_free(issuer);
856  return;
857  }
858  GNUNET_asprintf(&id,
859  "%s.%s",
860  issuer,
861  (char*)&cred[1]);
863  if (NULL == subject)
864  {
866  "Subject malformed\n");
867  GNUNET_free(id);
868  GNUNET_free(issuer);
869  return;
870  }
872  sizeof(struct GNUNET_CRYPTO_EcdsaSignature),
873  &signature);
874  json_document = GNUNET_JSONAPI_document_new();
875  json_resource = GNUNET_JSONAPI_resource_new(GNUNET_REST_JSONAPI_CREDENTIAL_TYPEINFO,
876  id);
877  GNUNET_free(id);
878  cred_obj = json_object();
879  json_object_set_new(cred_obj, "issuer", json_string(issuer));
880  json_object_set_new(cred_obj, "subject", json_string(subject));
881  json_object_set_new(cred_obj, "expiration", json_integer(cred->expiration.abs_value_us));
882  json_object_set_new(cred_obj, "signature", json_string(signature));
883  GNUNET_JSONAPI_resource_add_attr(json_resource,
885  cred_obj);
886  GNUNET_JSONAPI_document_resource_add(json_document, json_resource);
887  GNUNET_JSONAPI_document_serialize(json_document, &result);
889  "Result %s\n",
890  result);
891  json_decref(cred_obj);
892  GNUNET_JSONAPI_document_delete(json_document);
893  resp = GNUNET_REST_create_response(result);
894  handle->proc(handle->proc_cls, resp, MHD_HTTP_OK);
895  GNUNET_free(result);
896  GNUNET_free(signature);
897  GNUNET_free(issuer);
898  GNUNET_free(subject);
899  cleanup_handle(handle);
900 }
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
Public key of the subject this credential was issued to.
GNUNET_REST_ResultProcessor proc
The plugin result processor.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
static void cleanup_handle(struct RequestHandle *handle)
Cleanup lookup handle.
struct GNUNET_CRYPTO_EcdsaPublicKey issuer_key
The issuer of the credential.
void * proc_cls
The closure of the result processor.
uint64_t abs_value_us
The actual value.
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
an ECC signature using ECDSA
struct GNUNET_CRYPTO_EcdsaSignature signature
Signature of this credential.
static int result
Global testing status.
size_t GNUNET_STRINGS_base64_encode(const void *in, size_t len, char **output)
Encode into Base64.
Definition: strings.c:1856
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
struct GNUNET_TIME_Absolute expiration
Expiration of this credential.
#define GNUNET_REST_JSONAPI_CREDENTIAL
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_JSONAPI_CREDENTIAL_TYPEINFO
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_cred_issuer_cb()

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

Definition at line 903 of file plugin_rest_credential.c.

References RequestHandle::credential, do_error(), GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CREDENTIAL_connect(), GNUNET_CREDENTIAL_credential_issue(), GNUNET_CRYPTO_ecdsa_public_key_from_string(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_REST_JSONAPI_CREDENTIAL_EXPIRATION, GNUNET_REST_JSONAPI_CREDENTIAL_ISSUER_ATTR, GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_KEY, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_STRINGS_fancy_time_to_absolute(), GNUNET_STRINGS_fancy_time_to_relative(), GNUNET_TIME_relative_to_absolute(), handle, RequestHandle::id_op, RequestHandle::issuer_attr, issuer_key, RequestHandle::rest_handle, send_cred_response(), RequestHandle::subject_key, and GNUNET_REST_RequestHandle::url_param_map.

Referenced by issue_cred_cont().

907 {
908  struct RequestHandle *handle = cls;
909  struct GNUNET_TIME_Absolute etime_abs;
910  struct GNUNET_TIME_Relative etime_rel;
912  struct GNUNET_HashCode key;
913  struct GNUNET_CREDENTIAL_Credential *cred;
914  char* expiration_str;
915  char* tmp;
916 
917  handle->id_op = NULL;
918 
919  if (NULL == name)
920  {
922  "Issuer not configured!\n");
924  return;
925  }
926 
928  "Connecting to credential service...\n");
931  "Connected\n");
932  if (NULL == handle->credential)
933  {
935  "Connecting to CREDENTIAL failed\n");
937  return;
938  }
941  &key);
942  if (GNUNET_NO ==
944  &key))
945  {
947  "Missing expiration\n");
949  return;
950  }
952  &key);
953  if (NULL == expiration_str)
954  {
956  "Expiration malformed\n");
958  return;
959  }
960 
961  if (GNUNET_OK == GNUNET_STRINGS_fancy_time_to_relative(expiration_str,
962  &etime_rel))
963  {
964  etime_abs = GNUNET_TIME_relative_to_absolute(etime_rel);
965  }
966  else if (GNUNET_OK != GNUNET_STRINGS_fancy_time_to_absolute(expiration_str,
967  &etime_abs))
968  {
970  "Malformed expiration: %s\n", expiration_str);
972  return;
973  }
976  &key);
977  if (GNUNET_NO ==
979  &key))
980  {
982  "Missing issuer attribute\n");
984  return;
985  }
987  (handle->rest_handle->url_param_map,
988  &key));
991  &key);
992  if (GNUNET_NO ==
994  &key))
995  {
997  "Missing subject\n");
999  return;
1000  }
1002  &key);
1003  if (NULL == tmp)
1004  {
1006  "Malformed subject\n");
1008  return;
1009  }
1010  if (GNUNET_OK !=
1012  strlen(tmp),
1013  &handle->subject_key))
1014  {
1016  "Malformed subject key\n");
1018  return;
1019  }
1020  issuer_key = GNUNET_IDENTITY_ego_get_private_key(ego);
1021  cred = GNUNET_CREDENTIAL_credential_issue(issuer_key,
1022  &handle->subject_key,
1023  handle->issuer_attr,
1024  &etime_abs);
1025  if (NULL == cred)
1026  {
1028  "Failed to create credential\n");
1030  return;
1031  }
1032  send_cred_response(handle, cred);
1033 }
#define GNUNET_REST_JSONAPI_CREDENTIAL_EXPIRATION
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition: time.c:246
int GNUNET_STRINGS_fancy_time_to_relative(const char *fancy_time, struct GNUNET_TIME_Relative *rtime)
Convert a given fancy human-readable time to our internal representation.
Definition: strings.c:350
struct GNUNET_IDENTITY_Operation * id_op
Handle to identity operation.
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:553
int GNUNET_STRINGS_fancy_time_to_absolute(const char *fancy_time, struct GNUNET_TIME_Absolute *atime)
Convert a given fancy human-readable time to our internal representation.
Definition: strings.c:401
#define GNUNET_REST_JSONAPI_CREDENTIAL_ISSUER_ATTR
#define GNUNET_NO
Definition: gnunet_common.h:78
struct GNUNET_CRYPTO_EcdsaPublicKey subject_key
The public key of the subject.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Private ECC key encoded for transmission.
struct GNUNET_CREDENTIAL_Handle * credential
Handle to Credential service.
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_.
void send_cred_response(struct RequestHandle *handle, struct GNUNET_CREDENTIAL_Credential *cred)
const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our configuration.
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.
struct GNUNET_CONTAINER_MultiHashMap * url_param_map
Map of url parameters.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
#define GNUNET_REST_JSONAPI_CREDENTIAL_SUBJECT_KEY
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
struct GNUNET_CREDENTIAL_Handle * GNUNET_CREDENTIAL_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Initialize the connection with the CREDENTIAL service.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
struct GNUNET_REST_RequestHandle * rest_handle
Handle to rest request.
A 512-bit hashcode.
struct GNUNET_HashCode key
The key used in the DHT.
const char * name
static char * issuer_key
Issuer pubkey string.
int GNUNET_CRYPTO_ecdsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:468
char * issuer_attr
The issuer attribute to verify.
#define GNUNET_log(kind,...)
struct GNUNET_CREDENTIAL_Credential * GNUNET_CREDENTIAL_credential_issue(const struct GNUNET_CRYPTO_EcdsaPrivateKey *issuer, struct GNUNET_CRYPTO_EcdsaPublicKey *subject, const char *attribute, struct GNUNET_TIME_Absolute *expiration)
Issue an attribute to a subject.
static void do_error(void *cls)
Time for absolute times used by GNUnet, in microseconds.
Time for relative time used by GNUnet, in microseconds.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ issue_cred_cont()

static void issue_cred_cont ( struct GNUNET_REST_RequestHandle conndata_handle,
const char *  url,
void *  cls 
)
static

Definition at line 1037 of file plugin_rest_credential.c.

References do_error(), get_cred_issuer_cb(), GNUNET_IDENTITY_connect(), GNUNET_IDENTITY_get(), GNUNET_SCHEDULER_add_delayed(), handle, RequestHandle::id_op, RequestHandle::identity, RequestHandle::timeout, and RequestHandle::timeout_task.

Referenced by rest_credential_process_request().

1040 {
1041  struct RequestHandle *handle = cls;
1042 
1044  NULL,
1045  NULL);
1046  handle->id_op = GNUNET_IDENTITY_get(handle->identity,
1047  "credential-issuer",
1049  handle);
1051  &do_error,
1052  handle);
1053 }
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
void get_cred_issuer_cb(void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
struct GNUNET_IDENTITY_Operation * id_op
Handle to identity operation.
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
const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our configuration.
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
struct GNUNET_IDENTITY_Handle * identity
Handle to identity.
struct GNUNET_TIME_Relative timeout
Timeout.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
struct GNUNET_SCHEDULER_Task * timeout_task
ID of a task associated with the resolution process.
static void do_error(void *cls)
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

Definition at line 1056 of file plugin_rest_credential.c.

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

Referenced by rest_credential_process_request().

1059 {
1060  struct MHD_Response *resp;
1061  struct RequestHandle *handle = cls;
1062 
1063  //For GNS, independent of path return all options
1064  resp = GNUNET_REST_create_response(NULL);
1065  MHD_add_response_header(resp,
1066  "Access-Control-Allow-Methods",
1067  MHD_HTTP_METHOD_GET);
1068  handle->proc(handle->proc_cls,
1069  resp,
1070  MHD_HTTP_OK);
1071  cleanup_handle(handle);
1072 }
GNUNET_REST_ResultProcessor proc
The plugin result processor.
static void cleanup_handle(struct RequestHandle *handle)
Cleanup lookup handle.
void * proc_cls
The closure of the result processor.
The request handle.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
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:

◆ rest_credential_process_request()

static void rest_credential_process_request ( struct GNUNET_REST_RequestHandle conndata_handle,
GNUNET_REST_ResultProcessor  proc,
void *  proc_cls 
)
static

Definition at line 1076 of file plugin_rest_credential.c.

References collect_cred_cont(), do_error(), GNUNET_REST_RequestHandlerError::error_code, GNUNET_new, GNUNET_NO, GNUNET_REST_API_NS_CREDENTIAL, GNUNET_REST_API_NS_CREDENTIAL_COLLECT, GNUNET_REST_API_NS_CREDENTIAL_ISSUE, GNUNET_REST_API_NS_CREDENTIAL_VERIFY, GNUNET_REST_HANDLER_END, GNUNET_SCHEDULER_add_now(), GNUNET_TIME_UNIT_FOREVER_REL, handle, issue_cred_cont(), options_cont(), RequestHandle::proc, RequestHandle::proc_cls, RequestHandle::response_code, RequestHandle::rest_handle, RequestHandle::timeout, and verify_cred_cont().

Referenced by libgnunet_plugin_rest_credential_init().

1079 {
1080  struct RequestHandle *handle = GNUNET_new(struct RequestHandle);
1082 
1084  handle->proc_cls = proc_cls;
1085  handle->proc = proc;
1086  handle->rest_handle = conndata_handle;
1087 
1088  static const struct GNUNET_REST_RequestHandler handlers[] = {
1089  { MHD_HTTP_METHOD_POST, GNUNET_REST_API_NS_CREDENTIAL_VERIFY, &verify_cred_cont },
1090  { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_CREDENTIAL_COLLECT, &collect_cred_cont },
1091  { MHD_HTTP_METHOD_GET, GNUNET_REST_API_NS_CREDENTIAL_ISSUE, &issue_cred_cont },
1092  { MHD_HTTP_METHOD_OPTIONS, GNUNET_REST_API_NS_CREDENTIAL, &options_cont },
1094  };
1095 
1096  if (GNUNET_NO == GNUNET_JSONAPI_handle_request(conndata_handle,
1097  handlers,
1098  &err,
1099  handle))
1100  {
1101  handle->response_code = err.error_code;
1103  }
1104 }
#define GNUNET_REST_API_NS_CREDENTIAL_COLLECT
#define GNUNET_REST_API_NS_CREDENTIAL_VERIFY
GNUNET_REST_ResultProcessor proc
The plugin result processor.
static void options_cont(struct GNUNET_REST_RequestHandle *con_handle, const char *url, void *cls)
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static void verify_cred_cont(struct GNUNET_REST_RequestHandle *conndata_handle, const char *url, void *cls)
void * proc_cls
The closure of the result processor.
#define GNUNET_REST_HANDLER_END
The request handle.
static void collect_cred_cont(struct GNUNET_REST_RequestHandle *conndata_handle, const char *url, void *cls)
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
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.
static void issue_cred_cont(struct GNUNET_REST_RequestHandle *conndata_handle, const char *url, void *cls)
#define GNUNET_REST_API_NS_CREDENTIAL_ISSUE
static void do_error(void *cls)
#define GNUNET_REST_API_NS_CREDENTIAL
Here is the call graph for this function:
Here is the caller graph for this function:

◆ libgnunet_plugin_rest_credential_init()

void* libgnunet_plugin_rest_credential_init ( void *  cls)

Entry point for the plugin.

Parameters
clsthe "struct GNUNET_NAMESTORE_PluginEnvironment*"
Returns
NULL on error, otherwise the plugin context

Definition at line 1114 of file plugin_rest_credential.c.

References _, Plugin::api, Plugin::cfg, GNUNET_REST_Plugin::cls, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_new, GNUNET_REST_API_NS_CREDENTIAL, GNUNET_REST_Plugin::name, plugin, GNUNET_REST_Plugin::process_request, and rest_credential_process_request().

1115 {
1116  static struct Plugin plugin;
1117 
1118  cfg = cls;
1119  struct GNUNET_REST_Plugin *api;
1120 
1121  if (NULL != plugin.cfg)
1122  return NULL; /* can only initialize once! */
1123  memset(&plugin, 0, sizeof(struct Plugin));
1124  plugin.cfg = cfg;
1125  api = GNUNET_new(struct GNUNET_REST_Plugin);
1126  api->cls = &plugin;
1130  _("GNS REST API initialized\n"));
1131  return api;
1132 }
void * cls
The closure of the plugin.
struct returned by the initialization function of the plugin
static void rest_credential_process_request(struct GNUNET_REST_RequestHandle *conndata_handle, GNUNET_REST_ResultProcessor proc, void *proc_cls)
#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.
const struct GNUNET_CONFIGURATION_Handle * cfg
Handle to our configuration.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
char * name
Plugin name.
Handle for a plugin.
Definition: block.c:37
#define GNUNET_log(kind,...)
#define GNUNET_REST_API_NS_CREDENTIAL
Here is the call graph for this function:

◆ libgnunet_plugin_rest_credential_done()

void* libgnunet_plugin_rest_credential_done ( void *  cls)

Exit point from the plugin.

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

Definition at line 1142 of file plugin_rest_credential.c.

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

1143 {
1144  struct GNUNET_REST_Plugin *api = cls;
1145  struct Plugin *plugin = api->cls;
1146 
1147  plugin->cfg = NULL;
1148  GNUNET_free(api);
1150  "GNS REST plugin is finished\n");
1151  return NULL;
1152 }
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 struct GNUNET_ATS_SolverFunctions * plugin
Our solver.
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

Handle to our configuration.

Definition at line 69 of file plugin_rest_credential.c.