abd_api.c File Reference

library to access the ABD service More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_arm_service.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "abd.h"
#include "abd_serialization.h"
#include "gnunet_abd_service.h"
#include "gnunet_identity_service.h"

Include dependency graph for abd_api.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_ABD_Request
	Handle to a verify request. More...
struct	GNUNET_ABD_Handle
	Connection to the ABD service. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "abd-api", __VA_ARGS__)

Functions
static void	reconnect (struct GNUNET_ABD_Handle *handle)
	Reconnect to ABD service.
static void	reconnect_task (void *cls)
	Reconnect to ABD.
static void	force_reconnect (struct GNUNET_ABD_Handle *handle)
	Disconnect from service and then reconnect.
static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.
static int	check_result (void *cls, const struct DelegationChainResultMessage *vr_msg)
	Check validity of message received from the ABD service.
static void	handle_result (void *cls, const struct DelegationChainResultMessage *vr_msg)
	Handler for messages received from the ABD service.
static int	check_intermediate (void *cls, const struct DelegationChainIntermediateMessage *vr_msg)
static void	handle_intermediate (void *cls, const struct DelegationChainIntermediateMessage *vr_msg)
struct GNUNET_ABD_Handle *	GNUNET_ABD_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Initialize the connection with the ABD service.
void	GNUNET_ABD_disconnect (struct GNUNET_ABD_Handle *handle)
	Shutdown connection with the ABD service.
void	GNUNET_ABD_request_cancel (struct GNUNET_ABD_Request *lr)
	Cancel pending verify request.
struct GNUNET_ABD_Request *	GNUNET_ABD_collect (struct GNUNET_ABD_Handle *handle, const struct GNUNET_CRYPTO_BlindablePublicKey *issuer_key, const char *issuer_attribute, const struct GNUNET_CRYPTO_BlindablePrivateKey *subject_key, enum GNUNET_ABD_AlgoDirectionFlags direction, GNUNET_ABD_CredentialResultProcessor proc, void *proc_cls, GNUNET_ABD_IntermediateResultProcessor proc2, void *proc2_cls)
	Performs attribute collection.
struct GNUNET_ABD_Request *	GNUNET_ABD_verify (struct GNUNET_ABD_Handle *handle, const struct GNUNET_CRYPTO_BlindablePublicKey *issuer_key, const char *issuer_attribute, const struct GNUNET_CRYPTO_BlindablePublicKey *subject_key, uint32_t delegate_count, const struct GNUNET_ABD_Delegate *delegates, enum GNUNET_ABD_AlgoDirectionFlags direction, GNUNET_ABD_CredentialResultProcessor proc, void *proc_cls, GNUNET_ABD_IntermediateResultProcessor proc2, void *proc2_cls)
	Performs attribute verification.

Detailed Description

library to access the ABD service

Author

Martin Schanzenbach

Definition in file abd_api.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "abd-api", __VA_ARGS__)

Definition at line 37 of file abd_api.c.

Function Documentation

reconnect()

static void reconnect ( struct GNUNET_ABD_Handle *  handle )

static

Reconnect to ABD service.

Parameters

handle

the handle to the ABD service

Definition at line 315 of file abd_api.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] =
  {GNUNET_MQ_hd_var_size (result,
                          GNUNET_MESSAGE_TYPE_ABD_VERIFY_RESULT,
                          struct DelegationChainResultMessage,
                          handle),
   GNUNET_MQ_hd_var_size (result,
                          GNUNET_MESSAGE_TYPE_ABD_COLLECT_RESULT,
                          struct DelegationChainResultMessage,
                          handle),
   GNUNET_MQ_hd_var_size (intermediate,
                          GNUNET_MESSAGE_TYPE_ABD_INTERMEDIATE_RESULT,
                          struct DelegationChainIntermediateMessage,
                          handle),
   GNUNET_MQ_handler_end ()};
  struct GNUNET_ABD_Request *vr;
 
  GNUNET_assert (NULL == handle->mq);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Trying to connect to ABD\n");
  handle->mq = GNUNET_CLIENT_connect (handle->cfg,
                                      "abd",
                                      handlers,
                                      &mq_error_handler,
                                      handle);
  if (NULL == handle->mq)
    return;
  for (vr = handle->request_head; NULL != vr; vr = vr->next)
    GNUNET_MQ_send_copy (handle->mq, vr->env);
}

References GNUNET_VPN_Handle::cfg, GNUNET_ABD_Request::env, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_ABD_COLLECT_RESULT, GNUNET_MESSAGE_TYPE_ABD_INTERMEDIATE_RESULT, GNUNET_MESSAGE_TYPE_ABD_VERIFY_RESULT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_MQ_send_copy(), handle, handlers, LOG, GNUNET_VPN_Handle::mq, mq_error_handler(), GNUNET_ABD_Request::next, and result.

Here is the call graph for this function:

reconnect_task()

static void reconnect_task ( void *  cls )

static

Reconnect to ABD.

Parameters

cls	the handle

Definition at line 150 of file abd_api.c.

{
  struct GNUNET_ABD_Handle *handle = cls;
 
  handle->reconnect_task = NULL;
  reconnect (handle);
}

References handle, and reconnect().

Referenced by force_reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

force_reconnect()

static void force_reconnect ( struct GNUNET_ABD_Handle *  handle )

static

Disconnect from service and then reconnect.

Parameters

handle

our handle

Definition at line 165 of file abd_api.c.

{
  GNUNET_MQ_destroy (handle->mq);
  handle->mq = NULL;
  handle->reconnect_backoff =
    GNUNET_TIME_STD_BACKOFF (handle->reconnect_backoff);
  handle->reconnect_task =
    GNUNET_SCHEDULER_add_delayed (handle->reconnect_backoff,
                                  &reconnect_task,
                                  handle);
}

References GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, handle, GNUNET_VPN_Handle::mq, and reconnect_task().

Referenced by mq_error_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_error_handler()

static void mq_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters

cls	closure with the struct GNUNET_ABD_Handle *
error	error code

Definition at line 187 of file abd_api.c.

{
  struct GNUNET_ABD_Handle *handle = cls;
 
  force_reconnect (handle);
}

References force_reconnect(), and handle.

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

check_result()

static int check_result ( void *  cls, const struct DelegationChainResultMessage *  vr_msg  )

static

Check validity of message received from the ABD service.

Parameters

cls	the struct GNUNET_ABD_Handle *
vr_msg	the incoming message

Definition at line 202 of file abd_api.c.

{
  // TODO
  return GNUNET_OK;
}

References GNUNET_OK.

handle_result()

static void handle_result ( void *  cls, const struct DelegationChainResultMessage *  vr_msg  )

static

Handler for messages received from the ABD service.

Parameters

cls	the struct GNUNET_ABD_Handle *
vr_msg	the incoming message

Definition at line 216 of file abd_api.c.

{
  struct GNUNET_ABD_Handle *handle = cls;
  uint32_t r_id = ntohl (vr_msg->id);
  struct GNUNET_ABD_Request *vr;
  size_t mlen = ntohs (vr_msg->header.size) - sizeof (*vr_msg);
  uint32_t d_count = ntohl (vr_msg->d_count);
  uint32_t c_count = ntohl (vr_msg->c_count);
  struct GNUNET_ABD_Delegation d_chain[d_count];
  struct GNUNET_ABD_Delegate dels[c_count];
  GNUNET_ABD_CredentialResultProcessor proc;
  void *proc_cls;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received verify reply from ABD service\n");
  for (vr = handle->request_head; NULL != vr; vr = vr->next)
    if (vr->r_id == r_id)
      break;
  if (NULL == vr)
    return;
  proc = vr->verify_proc;
  proc_cls = vr->proc_cls;
  GNUNET_CONTAINER_DLL_remove (handle->request_head, handle->request_tail, vr);
  GNUNET_MQ_discard (vr->env);
  GNUNET_free (vr);
  GNUNET_assert (
    GNUNET_OK ==
    GNUNET_ABD_delegation_chain_deserialize (mlen,
                                             (const char *) &vr_msg[1],
                                             d_count,
                                             d_chain,
                                             c_count,
                                             dels));
  if (GNUNET_NO == ntohl (vr_msg->del_found))
  {
    proc (proc_cls, 0, NULL, 0,
          NULL);
  }
  else
  {
    proc (proc_cls, d_count, d_chain, c_count, dels);
  }
}

References DelegationChainResultMessage::c_count, DelegationChainResultMessage::d_count, DelegationChainResultMessage::del_found, GNUNET_ABD_Request::env, GNUNET_ABD_delegation_chain_deserialize(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_discard(), GNUNET_NO, GNUNET_OK, handle, DelegationChainResultMessage::header, DelegationChainResultMessage::id, LOG, GNUNET_ABD_Request::next, GNUNET_ABD_Request::proc_cls, GNUNET_ABD_Request::r_id, GNUNET_MessageHeader::size, and GNUNET_ABD_Request::verify_proc.

Here is the call graph for this function:

check_intermediate()

static int check_intermediate ( void *  cls, const struct DelegationChainIntermediateMessage *  vr_msg  )

static

Definition at line 262 of file abd_api.c.

{
  // TODO
  return GNUNET_OK;
}

References GNUNET_OK.

handle_intermediate()

static void handle_intermediate ( void *  cls, const struct DelegationChainIntermediateMessage *  vr_msg  )

static

Definition at line 271 of file abd_api.c.

{
  struct GNUNET_ABD_Handle *handle = cls;
  uint32_t r_id = ntohl (vr_msg->id);
  uint32_t size = ntohl (vr_msg->size);
  bool is_bw = ntohs (vr_msg->is_bw);
  struct GNUNET_ABD_Request *vr;
  GNUNET_ABD_IntermediateResultProcessor proc;
  void *proc_cls;
  struct GNUNET_ABD_Delegation *dd;
 
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received intermediate reply from ABD service\n");
 
  for (vr = handle->request_head; NULL != vr; vr = vr->next)
    if (vr->r_id == r_id)
      break;
  if (NULL == vr)
    return;
 
  proc = vr->int_proc;
  proc_cls = vr->proc2_cls;
 
  dd = GNUNET_new (struct GNUNET_ABD_Delegation);
  GNUNET_assert (
    GNUNET_OK ==
    GNUNET_ABD_delegation_chain_deserialize (size,
                                             (const char *) &vr_msg[1],
                                             1,
                                             dd,
                                             0,
                                             NULL));
  proc (proc_cls, dd, is_bw);
}

References GNUNET_ABD_delegation_chain_deserialize(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_OK, handle, DelegationChainIntermediateMessage::id, GNUNET_ABD_Request::int_proc, DelegationChainIntermediateMessage::is_bw, LOG, GNUNET_ABD_Request::next, GNUNET_ABD_Request::proc2_cls, GNUNET_ABD_Request::proc_cls, GNUNET_ABD_Request::r_id, DelegationChainIntermediateMessage::size, and size.

Here is the call graph for this function: