api to interact with the reclaim service More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_reclaim_lib.h"
#include "gnunet_reclaim_service.h"
#include "reclaim.h"

Include dependency graph for reclaim_api.c:

Data Structures
struct	GNUNET_RECLAIM_Operation
	Handle for an operation with the service. More...

struct	GNUNET_RECLAIM_TicketIterator
	Handle for a ticket iterator operation. More...

struct	GNUNET_RECLAIM_AttributeIterator
	Handle for a attribute iterator operation. More...

struct	GNUNET_RECLAIM_CredentialIterator
	Handle for a credential iterator operation. More...

struct	GNUNET_RECLAIM_Handle
	Handle to the service. More...

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

Functions
static void	reconnect (struct GNUNET_RECLAIM_Handle *h)
	Try again to connect to the service.

static void	reconnect_task (void *cls)
	Reconnect.

static void	force_reconnect (struct GNUNET_RECLAIM_Handle *handle)
	Disconnect from service and then reconnect.

static void	free_it (struct GNUNET_RECLAIM_AttributeIterator *it)
	Free it.

static void	free_ait (struct GNUNET_RECLAIM_CredentialIterator *ait)
	Free it.

static void	free_op (struct GNUNET_RECLAIM_Operation *op)
	Free op.

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 void	handle_success_response (void cls, const struct SuccessResultMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE.

static int	check_consume_ticket_result (void cls, const struct ConsumeTicketResultMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT.

static void	handle_consume_ticket_result (void cls, const struct ConsumeTicketResultMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT.

static int	check_attribute_result (void cls, const struct AttributeResultMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT.

static void	handle_attribute_result (void cls, const struct AttributeResultMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT.

static int	check_credential_result (void cls, const struct CredentialResultMessage msg)
	Handle an incoming message of type #GNUNET_MESSAGE_TYPE_RECLAIM_credential_RESULT.

static void	handle_credential_result (void cls, const struct CredentialResultMessage msg)
	Handle an incoming message of type #GNUNET_MESSAGE_TYPE_RECLAIM_credential_RESULT.

static int	check_ticket_result (void cls, const struct TicketResultMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT.

static void	handle_ticket_result (void cls, const struct TicketResultMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT.

static void	handle_revoke_ticket_result (void cls, const struct RevokeTicketResultMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT.

struct GNUNET_RECLAIM_Handle *	GNUNET_RECLAIM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Connect to the reclaim service.

void	GNUNET_RECLAIM_cancel (struct GNUNET_RECLAIM_Operation *op)
	Cancel an identity provider operation.

void	GNUNET_RECLAIM_disconnect (struct GNUNET_RECLAIM_Handle *h)
	Disconnect from service.

struct GNUNET_RECLAIM_Operation *	GNUNET_RECLAIM_attribute_store (struct GNUNET_RECLAIM_Handle h, const struct GNUNET_CRYPTO_PrivateKey pkey, const struct GNUNET_RECLAIM_Attribute attr, const struct GNUNET_TIME_Relative exp_interval, GNUNET_RECLAIM_ContinuationWithStatus cont, void *cont_cls)
	Store an attribute.

struct GNUNET_RECLAIM_Operation *	GNUNET_RECLAIM_attribute_delete (struct GNUNET_RECLAIM_Handle h, const struct GNUNET_CRYPTO_PrivateKey pkey, const struct GNUNET_RECLAIM_Attribute attr, GNUNET_RECLAIM_ContinuationWithStatus cont, void cont_cls)
	Delete an attribute.

struct GNUNET_RECLAIM_Operation *	GNUNET_RECLAIM_credential_store (struct GNUNET_RECLAIM_Handle h, const struct GNUNET_CRYPTO_PrivateKey pkey, const struct GNUNET_RECLAIM_Credential credential, const struct GNUNET_TIME_Relative exp_interval, GNUNET_RECLAIM_ContinuationWithStatus cont, void *cont_cls)
	Store a credential.

struct GNUNET_RECLAIM_Operation *	GNUNET_RECLAIM_credential_delete (struct GNUNET_RECLAIM_Handle h, const struct GNUNET_CRYPTO_PrivateKey pkey, const struct GNUNET_RECLAIM_Credential attr, GNUNET_RECLAIM_ContinuationWithStatus cont, void cont_cls)
	Delete a credential.

struct GNUNET_RECLAIM_AttributeIterator *	GNUNET_RECLAIM_get_attributes_start (struct GNUNET_RECLAIM_Handle h, const struct GNUNET_CRYPTO_PrivateKey identity, GNUNET_SCHEDULER_TaskCallback error_cb, void error_cb_cls, GNUNET_RECLAIM_AttributeResult proc, void proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
	List all attributes for a local identity.

void	GNUNET_RECLAIM_get_attributes_next (struct GNUNET_RECLAIM_AttributeIterator *it)
	Calls the record processor specified in GNUNET_RECLAIM_get_attributes_start for the next record.

void	GNUNET_RECLAIM_get_attributes_stop (struct GNUNET_RECLAIM_AttributeIterator *it)
	Stops iteration and releases the handle for further calls.

struct GNUNET_RECLAIM_CredentialIterator *	GNUNET_RECLAIM_get_credentials_start (struct GNUNET_RECLAIM_Handle h, const struct GNUNET_CRYPTO_PrivateKey identity, GNUNET_SCHEDULER_TaskCallback error_cb, void error_cb_cls, GNUNET_RECLAIM_CredentialResult proc, void proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
	List all credentials for a local identity.

void	GNUNET_RECLAIM_get_credentials_next (struct GNUNET_RECLAIM_CredentialIterator *ait)
	Calls the record processor specified in GNUNET_RECLAIM_get_credentials_start for the next record.

void	GNUNET_RECLAIM_get_credentials_stop (struct GNUNET_RECLAIM_CredentialIterator *ait)
	Stops iteration and releases the handle for further calls.

struct GNUNET_RECLAIM_Operation *	GNUNET_RECLAIM_ticket_issue (struct GNUNET_RECLAIM_Handle h, const struct GNUNET_CRYPTO_PrivateKey iss, const char rp, const struct GNUNET_RECLAIM_AttributeList attrs, GNUNET_RECLAIM_IssueTicketCallback cb, void *cb_cls)
	Issues a ticket to a relying party.

struct GNUNET_RECLAIM_Operation *	GNUNET_RECLAIM_ticket_consume (struct GNUNET_RECLAIM_Handle h, const struct GNUNET_RECLAIM_Ticket ticket, const char rp_uri, GNUNET_RECLAIM_AttributeTicketResult cb, void cb_cls)
	Consumes an issued ticket.

struct GNUNET_RECLAIM_TicketIterator *	GNUNET_RECLAIM_ticket_iteration_start (struct GNUNET_RECLAIM_Handle h, const struct GNUNET_CRYPTO_PrivateKey identity, GNUNET_SCHEDULER_TaskCallback error_cb, void error_cb_cls, GNUNET_RECLAIM_TicketCallback proc, void proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
	Lists all tickets that have been issued to remote identities (relying parties)

void	GNUNET_RECLAIM_ticket_iteration_next (struct GNUNET_RECLAIM_TicketIterator *it)
	Calls the ticket processor specified in GNUNET_RECLAIM_ticket_iteration_start for the next record.

void	GNUNET_RECLAIM_ticket_iteration_stop (struct GNUNET_RECLAIM_TicketIterator *it)
	Stops iteration and releases the handle for further calls.

struct GNUNET_RECLAIM_Operation *	GNUNET_RECLAIM_ticket_revoke (struct GNUNET_RECLAIM_Handle h, const struct GNUNET_CRYPTO_PrivateKey identity, const struct GNUNET_RECLAIM_Ticket ticket, GNUNET_RECLAIM_ContinuationWithStatus cb, void cb_cls)
	Revoked an issued ticket.

Detailed Description

api to interact with the reclaim service

Author: Martin Schanzenbach

Definition in file reclaim_api.c.

Macro Definition Documentation

◆ LOG

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

Definition at line 33 of file reclaim_api.c.

Function Documentation

◆ reconnect()

static void reconnect ( struct GNUNET_RECLAIM_Handle * h )

static

Try again to connect to the service.

Parameters

h	handle to the reclaim service.

Definition at line 1069 of file reclaim_api.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_fixed_size (success_response,
                             GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE,
                             struct SuccessResultMessage,
                             h),
    GNUNET_MQ_hd_var_size (attribute_result,
                           GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT,
                           struct AttributeResultMessage,
                           h),
    GNUNET_MQ_hd_var_size (credential_result,
                           GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT,
                           struct CredentialResultMessage,
                           h),
    GNUNET_MQ_hd_var_size (ticket_result,
                           GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT,
                           struct TicketResultMessage,
                           h),
    GNUNET_MQ_hd_var_size (consume_ticket_result,
                           GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT,
                           struct ConsumeTicketResultMessage,
                           h),
    GNUNET_MQ_hd_fixed_size (revoke_ticket_result,
                             GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT,
                             struct RevokeTicketResultMessage,
                             h),
    GNUNET_MQ_handler_end () };
  struct GNUNET_RECLAIM_Operation *op;
 
  GNUNET_assert (NULL == h->mq);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to reclaim service.\n");
 
  h->mq =
    GNUNET_CLIENT_connect (h->cfg, "reclaim", handlers, &mq_error_handler, h);
  if (NULL == h->mq)
    return;
  for (op = h->op_head; NULL != op; op = op->next)
    GNUNET_MQ_send_copy (h->mq, op->env);
}

References GNUNET_ARM_Handle::cfg, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT, GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT, GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT, GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_send_copy(), h, handlers, LOG, GNUNET_ARM_Handle::mq, mq_error_handler(), GNUNET_ARM_Operation::next, and op.

Here is the call graph for this function:

◆ reconnect_task()

static void reconnect_task ( void * cls )

static

Reconnect.

Parameters

cls	the handle

Definition at line 419 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_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_RECLAIM_Handle * handle )

static

Disconnect from service and then reconnect.

Parameters

handle our service

Definition at line 434 of file reclaim_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 handle_attribute_result(), handle_credential_result(), and mq_error_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_it()

static void free_it ( struct GNUNET_RECLAIM_AttributeIterator * it )

static

Free it.

Parameters

it	entry to free

Definition at line 453 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *h = it->h;
 
  GNUNET_CONTAINER_DLL_remove (h->it_head, h->it_tail, it);
  if (NULL != it->env)
    GNUNET_MQ_discard (it->env);
  GNUNET_free (it);
}

References GNUNET_RECLAIM_AttributeIterator::env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_discard(), h, and GNUNET_RECLAIM_AttributeIterator::h.

Referenced by GNUNET_RECLAIM_get_attributes_stop(), and handle_attribute_result().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_ait()

static void free_ait ( struct GNUNET_RECLAIM_CredentialIterator * ait )

static

Free it.

Parameters

ait	entry to free

Definition at line 470 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *h = ait->h;
 
  GNUNET_CONTAINER_DLL_remove (h->ait_head, h->ait_tail, ait);
  if (NULL != ait->env)
    GNUNET_MQ_discard (ait->env);
  GNUNET_free (ait);
}

References GNUNET_RECLAIM_CredentialIterator::env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_discard(), h, and GNUNET_RECLAIM_CredentialIterator::h.

Referenced by GNUNET_RECLAIM_get_credentials_stop(), and handle_credential_result().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_op()

static void free_op ( struct GNUNET_RECLAIM_Operation * op )

static

Free op.

Parameters

op	the operation to free

Definition at line 487 of file reclaim_api.c.

{
  if (NULL == op)
    return;
  if (NULL != op->env)
    GNUNET_MQ_discard (op->env);
  GNUNET_free (op);
}

References GNUNET_free, GNUNET_MQ_discard(), and op.

Referenced by GNUNET_RECLAIM_cancel(), handle_attribute_result(), handle_consume_ticket_result(), handle_credential_result(), handle_revoke_ticket_result(), handle_success_response(), and handle_ticket_result().

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_GNS_Handle *`
error	error code

Definition at line 506 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_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:

◆ handle_success_response()

static void handle_success_response	(	void *	cls,
		const struct SuccessResultMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE.

Parameters

cls
msg	the message we received

Definition at line 522 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *h = cls;
  struct GNUNET_RECLAIM_Operation *op;
  uint32_t r_id = ntohl (msg->id);
  int res;
  const char *emsg;
 
  for (op = h->op_head; NULL != op; op = op->next)
    if (op->r_id == r_id)
      break;
  if (NULL == op)
    return;
 
  res = ntohl (msg->op_result);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received SUCCESS_RESPONSE with result %d\n",
       res);
 
  /* TODO: add actual error message to response... */
  if (GNUNET_SYSERR == res)
    emsg = _ ("failed to store record\n");
  else
    emsg = NULL;
  if (NULL != op->as_cb)
    op->as_cb (op->cls, res, emsg);
  GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
  free_op (op);
}

References _, free_op(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_SYSERR, h, LOG, msg, GNUNET_ARM_Operation::next, op, GNUNET_RECLAIM_Operation::r_id, and res.

Here is the call graph for this function:

◆ check_consume_ticket_result()

static int check_consume_ticket_result	(	void *	cls,
		const struct ConsumeTicketResultMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT.

Parameters

cls
msg	the message we received

Returns: GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 562 of file reclaim_api.c.

{
  size_t msg_len;
  size_t attrs_len;
  size_t pl_len;
  size_t key_len;
 
  msg_len = ntohs (msg->header.size);
  attrs_len = ntohs (msg->attrs_len);
  key_len = ntohs (msg->key_len);
  pl_len = ntohs (msg->presentations_len);
  if (msg_len != sizeof(*msg) + attrs_len + pl_len + key_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, and GNUNET_MessageHeader::size.

◆ handle_consume_ticket_result()

static void handle_consume_ticket_result	(	void *	cls,
		const struct ConsumeTicketResultMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT.

Parameters

cls
msg	the message we received

Definition at line 591 of file reclaim_api.c.

{
  struct GNUNET_CRYPTO_PublicKey identity;
  struct GNUNET_RECLAIM_Handle *h = cls;
  struct GNUNET_RECLAIM_Operation *op;
  size_t attrs_len;
  size_t pl_len;
  size_t key_len;
  size_t read;
  uint32_t r_id = ntohl (msg->id);
  char *read_ptr;
 
  attrs_len = ntohs (msg->attrs_len);
  key_len = ntohs (msg->key_len);
  pl_len = ntohs (msg->presentations_len);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing ticket result.\n");
 
 
  for (op = h->op_head; NULL != op; op = op->next)
    if (op->r_id == r_id)
      break;
  if (NULL == op)
    return;
 
  {
    struct GNUNET_RECLAIM_AttributeList *attrs;
    struct GNUNET_RECLAIM_AttributeListEntry *le;
    struct GNUNET_RECLAIM_PresentationList *pl;
    struct GNUNET_RECLAIM_PresentationListEntry *ple;
    read_ptr = (char *) &msg[1];
    GNUNET_assert (GNUNET_SYSERR !=
                   GNUNET_CRYPTO_read_public_key_from_buffer (read_ptr,
                                                              key_len,
                                                              &identity,
                                                              &read));
    read_ptr += read;
    attrs =
      GNUNET_RECLAIM_attribute_list_deserialize (read_ptr, attrs_len);
    read_ptr += attrs_len;
    pl = GNUNET_RECLAIM_presentation_list_deserialize (read_ptr, pl_len);
    if (NULL != op->atr_cb)
    {
      if (NULL == attrs)
      {
        op->atr_cb (op->cls, &identity, NULL, NULL);
      }
      else
      {
        for (le = attrs->list_head; NULL != le; le = le->next)
        {
          if (GNUNET_NO ==
              GNUNET_RECLAIM_id_is_zero (&le->attribute->credential))
          {
            for (ple = pl->list_head; NULL != ple; ple = ple->next)
            {
              if (GNUNET_YES ==
                  GNUNET_RECLAIM_id_is_equal (&le->attribute->credential,
                                              &ple->presentation->credential_id)
                  )
              {
                op->atr_cb (op->cls, &identity,
                            le->attribute, ple->presentation);
                break;
              }
 
            }
          }
          else     // No credentials
          {
            op->atr_cb (op->cls, &identity,
                        le->attribute, NULL);
          }
        }
      }
      op->atr_cb (op->cls, NULL, NULL, NULL);
    }
    if (NULL != attrs)
      GNUNET_RECLAIM_attribute_list_destroy (attrs);
    if (NULL != pl)
      GNUNET_RECLAIM_presentation_list_destroy (pl);
    GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
    free_op (op);
    return;
  }
  GNUNET_assert (0);
}

References GNUNET_RECLAIM_AttributeListEntry::attribute, GNUNET_RECLAIM_Attribute::credential, GNUNET_RECLAIM_Presentation::credential_id, free_op(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CRYPTO_read_public_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_RECLAIM_attribute_list_deserialize(), GNUNET_RECLAIM_attribute_list_destroy(), GNUNET_RECLAIM_id_is_equal, GNUNET_RECLAIM_id_is_zero, GNUNET_RECLAIM_presentation_list_deserialize(), GNUNET_RECLAIM_presentation_list_destroy(), GNUNET_SYSERR, GNUNET_YES, h, identity, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_PresentationList::list_head, msg, GNUNET_RECLAIM_AttributeListEntry::next, GNUNET_RECLAIM_PresentationListEntry::next, GNUNET_ARM_Operation::next, op, GNUNET_RECLAIM_PresentationListEntry::presentation, and GNUNET_RECLAIM_Operation::r_id.

Here is the call graph for this function:

◆ check_attribute_result()

static int check_attribute_result	(	void *	cls,
		const struct AttributeResultMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT.

Parameters

cls
msg	the message we received

Returns: GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 689 of file reclaim_api.c.

{
  size_t msg_len;
  size_t attr_len;
  size_t key_len;
 
  msg_len = ntohs (msg->header.size);
  attr_len = ntohs (msg->attr_len);
  key_len = ntohs (msg->pkey_len);
  if (msg_len != sizeof(*msg) + attr_len + key_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, and GNUNET_MessageHeader::size.

◆ handle_attribute_result()

static void handle_attribute_result	(	void *	cls,
		const struct AttributeResultMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT.

Parameters

cls
msg	the message we received

Definition at line 715 of file reclaim_api.c.

{
  static struct GNUNET_CRYPTO_PublicKey identity;
  struct GNUNET_RECLAIM_Handle *h = cls;
  struct GNUNET_RECLAIM_AttributeIterator *it;
  struct GNUNET_RECLAIM_Operation *op;
  size_t attr_len;
  size_t key_len;
  size_t read;
  uint32_t r_id = ntohl (msg->id);
  char *buf;
 
  attr_len = ntohs (msg->attr_len);
  key_len = ntohs (msg->pkey_len);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing attribute result.\n");
 
  for (it = h->it_head; NULL != it; it = it->next)
    if (it->r_id == r_id)
      break;
  for (op = h->op_head; NULL != op; op = op->next)
    if (op->r_id == r_id)
      break;
  if ((NULL == it) && (NULL == op))
    return;
 
  buf = (char *) &msg[1];
  if (0 == key_len)
  {
    if ((NULL == it) && (NULL == op))
    {
      GNUNET_break (0);
      force_reconnect (h);
      return;
    }
    if (NULL != it)
    {
      if (NULL != it->finish_cb)
        it->finish_cb (it->finish_cb_cls);
      free_it (it);
    }
    if (NULL != op)
    {
      if (NULL != op->ar_cb)
        op->ar_cb (op->cls, NULL, NULL);
      GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
      free_op (op);
    }
    return;
  }
 
  {
    struct GNUNET_RECLAIM_Attribute *attr;
    GNUNET_assert (GNUNET_SYSERR !=
                   GNUNET_CRYPTO_read_public_key_from_buffer (buf,
                                                              key_len,
                                                              &identity,
                                                              &read));
    buf += read;
    GNUNET_RECLAIM_attribute_deserialize (buf, attr_len, &attr);
    if (NULL != it)
    {
      if (NULL != it->proc)
        it->proc (it->proc_cls, &identity, attr);
    }
    else if (NULL != op)
    {
      if (NULL != op->ar_cb)
        op->ar_cb (op->cls, &identity, attr);
    }
    GNUNET_free (attr);
    return;
  }
  GNUNET_assert (0);
}

References GNUNET_RECLAIM_AttributeIterator::finish_cb, GNUNET_RECLAIM_AttributeIterator::finish_cb_cls, force_reconnect(), free_it(), free_op(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CRYPTO_read_public_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_RECLAIM_attribute_deserialize(), GNUNET_SYSERR, h, identity, LOG, msg, GNUNET_ARM_Operation::next, GNUNET_RECLAIM_AttributeIterator::next, op, GNUNET_RECLAIM_AttributeIterator::proc, GNUNET_RECLAIM_AttributeIterator::proc_cls, GNUNET_RECLAIM_Operation::r_id, and GNUNET_RECLAIM_AttributeIterator::r_id.

Here is the call graph for this function:

◆ check_credential_result()

static int check_credential_result	(	void *	cls,
		const struct CredentialResultMessage *	msg
	)

static

Handle an incoming message of type #GNUNET_MESSAGE_TYPE_RECLAIM_credential_RESULT.

Parameters

cls
msg	the message we received

Returns: GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 800 of file reclaim_api.c.

{
  size_t msg_len;
  size_t cred_len;
  size_t key_len;
 
  msg_len = ntohs (msg->header.size);
  cred_len = ntohs (msg->credential_len);
  key_len = ntohs (msg->key_len);
  if (msg_len != sizeof(*msg) + cred_len + key_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, and GNUNET_MessageHeader::size.

◆ handle_credential_result()

static void handle_credential_result	(	void *	cls,
		const struct CredentialResultMessage *	msg
	)

static

Handle an incoming message of type #GNUNET_MESSAGE_TYPE_RECLAIM_credential_RESULT.

Parameters

cls
msg	the message we received

Definition at line 826 of file reclaim_api.c.

{
  struct GNUNET_CRYPTO_PublicKey identity;
  struct GNUNET_RECLAIM_Handle *h = cls;
  struct GNUNET_RECLAIM_CredentialIterator *it;
  struct GNUNET_RECLAIM_Operation *op;
  size_t att_len;
  size_t key_len;
  size_t read;
  uint32_t r_id = ntohl (msg->id);
  char *buf;
 
  key_len = ntohs (msg->key_len);
  att_len = ntohs (msg->credential_len);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing credential result.\n");
 
 
  for (it = h->ait_head; NULL != it; it = it->next)
    if (it->r_id == r_id)
      break;
  for (op = h->op_head; NULL != op; op = op->next)
    if (op->r_id == r_id)
      break;
  if ((NULL == it) && (NULL == op))
    return;
 
  buf = (char *) &msg[1];
  if (0 < key_len)
  {
    GNUNET_assert (GNUNET_SYSERR !=
                   GNUNET_CRYPTO_read_public_key_from_buffer (buf,
                                                              key_len,
                                                              &identity,
                                                              &read));
    buf += read;
  }
  if (0 == key_len)
  {
    if ((NULL == it) && (NULL == op))
    {
      GNUNET_break (0);
      force_reconnect (h);
      return;
    }
    if (NULL != it)
    {
      if (NULL != it->finish_cb)
        it->finish_cb (it->finish_cb_cls);
      free_ait (it);
    }
    if (NULL != op)
    {
      if (NULL != op->at_cb)
        op->at_cb (op->cls, NULL, NULL);
      GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
      free_op (op);
    }
    return;
  }
 
  {
    struct GNUNET_RECLAIM_Credential *att;
    att = GNUNET_RECLAIM_credential_deserialize (buf, att_len);
 
    if (NULL != it)
    {
      if (NULL != it->proc)
        it->proc (it->proc_cls, &identity, att);
    }
    else if (NULL != op)
    {
      if (NULL != op->at_cb)
        op->at_cb (op->cls, &identity, att);
    }
    GNUNET_free (att);
    return;
  }
  GNUNET_assert (0);
}

References GNUNET_RECLAIM_CredentialIterator::finish_cb, GNUNET_RECLAIM_CredentialIterator::finish_cb_cls, force_reconnect(), free_ait(), free_op(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CRYPTO_read_public_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_RECLAIM_credential_deserialize(), GNUNET_SYSERR, h, identity, LOG, msg, GNUNET_ARM_Operation::next, GNUNET_RECLAIM_CredentialIterator::next, op, GNUNET_RECLAIM_CredentialIterator::proc, GNUNET_RECLAIM_CredentialIterator::proc_cls, GNUNET_RECLAIM_Operation::r_id, and GNUNET_RECLAIM_CredentialIterator::r_id.

Here is the call graph for this function:

◆ check_ticket_result()

static int check_ticket_result	(	void *	cls,
		const struct TicketResultMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT.

Parameters

cls
msg	the message we received

Returns: GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 917 of file reclaim_api.c.

{
  size_t msg_len;
  size_t pres_len;
  size_t tkt_len;
  size_t rp_uri_len;
 
  msg_len = ntohs (msg->header.size);
  pres_len = ntohs (msg->presentations_len);
  tkt_len = ntohs (msg->tkt_len);
  rp_uri_len = ntohs (msg->rp_uri_len);
  if (msg_len != sizeof(*msg) + pres_len + tkt_len + rp_uri_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, msg, and GNUNET_MessageHeader::size.

◆ handle_ticket_result()

static void handle_ticket_result	(	void *	cls,
		const struct TicketResultMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT.

Parameters

cls
msg	the message we received

Definition at line 945 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *handle = cls;
  struct GNUNET_RECLAIM_Operation *op;
  struct GNUNET_RECLAIM_TicketIterator *it;
  struct GNUNET_RECLAIM_PresentationList *presentation;
  uint32_t r_id = ntohl (msg->id);
  struct GNUNET_RECLAIM_Ticket *ticket = NULL;
  size_t pres_len;
  size_t tkt_len;
  size_t rp_uri_len;
  size_t tb_read = 0;
  char *buf;
  char *rp_uri = NULL;
 
  tkt_len = ntohs (msg->tkt_len);
  rp_uri_len = ntohs (msg->rp_uri_len);
  pres_len = ntohs (msg->presentations_len);
  for (op = handle->op_head; NULL != op; op = op->next)
    if (op->r_id == r_id)
      break;
  for (it = handle->ticket_it_head; NULL != it; it = it->next)
    if (it->r_id == r_id)
      break;
  if ((NULL == op) && (NULL == it))
    return;
  buf = (char*) &msg[1];
  if (0 < tkt_len)
  {
    ticket = (struct GNUNET_RECLAIM_Ticket*) buf;
    buf += tkt_len;
    tb_read += tkt_len;
  }
  if (0 < rp_uri_len)
    rp_uri = buf;
  if (NULL != op)
  {
    if (0 < pres_len)
      presentation = GNUNET_RECLAIM_presentation_list_deserialize (
        buf,
        pres_len);
    GNUNET_CONTAINER_DLL_remove (handle->op_head, handle->op_tail, op);
    if (0 == tb_read)
    {
      if (NULL != op->ti_cb)
        op->ti_cb (op->cls, NULL, NULL);
    }
    else
    {
      if (NULL != op->ti_cb)
        op->ti_cb (op->cls,
                   ticket,
                   (0 < pres_len) ? presentation : NULL);
    }
    if (0 < pres_len)
      GNUNET_RECLAIM_presentation_list_destroy (presentation);
    free_op (op);
    return;
  }
  else if (NULL != it)
  {
    if (0 == tkt_len)
    {
      GNUNET_CONTAINER_DLL_remove (handle->ticket_it_head,
                                   handle->ticket_it_tail,
                                   it);
      it->finish_cb (it->finish_cb_cls);
      GNUNET_free (it);
    }
    else
    {
      if (NULL != it->tr_cb)
        it->tr_cb (it->cls, ticket, rp_uri);
    }
    return;
  }
  GNUNET_break (0);
}

References GNUNET_RECLAIM_TicketIterator::cls, GNUNET_RECLAIM_TicketIterator::finish_cb, GNUNET_RECLAIM_TicketIterator::finish_cb_cls, free_op(), GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_RECLAIM_presentation_list_deserialize(), GNUNET_RECLAIM_presentation_list_destroy(), handle, msg, GNUNET_ARM_Operation::next, GNUNET_RECLAIM_TicketIterator::next, op, GNUNET_RECLAIM_TicketIterator::r_id, ticket, and GNUNET_RECLAIM_TicketIterator::tr_cb.

Here is the call graph for this function:

◆ handle_revoke_ticket_result()

static void handle_revoke_ticket_result	(	void *	cls,
		const struct RevokeTicketResultMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT.

Parameters

cls
msg	the message we received

Definition at line 1033 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *h = cls;
  struct GNUNET_RECLAIM_Operation *op;
  uint32_t r_id = ntohl (msg->id);
  int32_t success;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Processing revocation result.\n");
 
 
  for (op = h->op_head; NULL != op; op = op->next)
    if (op->r_id == r_id)
      break;
  if (NULL == op)
    return;
  success = ntohl (msg->success);
  {
    if (NULL != op->rvk_cb)
    {
      op->rvk_cb (op->cls, success, NULL);
    }
    GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
    free_op (op);
    return;
  }
  GNUNET_assert (0);
}

References free_op(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, h, LOG, msg, GNUNET_ARM_Operation::next, op, and GNUNET_RECLAIM_Operation::r_id.

Here is the call graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOG

Function Documentation

◆ reconnect()

◆ reconnect_task()

◆ force_reconnect()

◆ free_it()

◆ free_ait()

◆ free_op()

◆ mq_error_handler()

◆ handle_success_response()

◆ check_consume_ticket_result()

◆ handle_consume_ticket_result()

◆ check_attribute_result()

◆ handle_attribute_result()

◆ check_credential_result()

◆ handle_credential_result()

◆ check_ticket_result()

◆ handle_ticket_result()

◆ handle_revoke_ticket_result()