Reclaim service

Collaboration diagram for Reclaim service:

Data Structures
struct	GNUNET_RECLAIM_Ticket
	The authorization ticket. More...

Macros
#define	GNUNET_RECLAIM_VERSION   0x00000001
	Version number of the re:claimID API. More...

Typedefs
typedef void(*	GNUNET_RECLAIM_TicketCallback) (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)
	Method called when a token has been issued. More...
typedef void(*	GNUNET_RECLAIM_IssueTicketCallback) (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_RECLAIM_PresentationList *presentations)
	Method called when a token has been issued. More...
typedef void(*	GNUNET_RECLAIM_ContinuationWithStatus) (void *cls, int32_t success, const char *emsg)
	Continuation called to notify client about result of the operation. More...
typedef void(*	GNUNET_RECLAIM_AttributeResult) (void *cls, const struct GNUNET_CRYPTO_PublicKey *identity, const struct GNUNET_RECLAIM_Attribute *attr)
	Callback used to notify the client of attribute results. More...
typedef void(*	GNUNET_RECLAIM_AttributeTicketResult) (void *cls, const struct GNUNET_CRYPTO_PublicKey *identity, const struct GNUNET_RECLAIM_Attribute *attr, const struct GNUNET_RECLAIM_Presentation *presentation)
	Callback used to notify the client of attribute results. More...
typedef void(*	GNUNET_RECLAIM_CredentialResult) (void *cls, const struct GNUNET_CRYPTO_PublicKey *identity, const struct GNUNET_RECLAIM_Credential *credential)
	Callback used to notify the client of credential results. More...

Functions
struct GNUNET_RECLAIM_Handle *	GNUNET_RECLAIM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Connect to the re:claimID service. More...
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. More...
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. More...
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. More...
struct GNUNET_RECLAIM_Operation *	GNUNET_RECLAIM_credential_delete (struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_PrivateKey *pkey, const struct GNUNET_RECLAIM_Credential *cred, GNUNET_RECLAIM_ContinuationWithStatus cont, void *cont_cls)
	Delete a credential. More...
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. More...
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. More...
void	GNUNET_RECLAIM_get_attributes_stop (struct GNUNET_RECLAIM_AttributeIterator *it)
	Stops iteration and releases the handle for further calls. More...
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. More...
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. More...
void	GNUNET_RECLAIM_get_credentials_stop (struct GNUNET_RECLAIM_CredentialIterator *ait)
	Stops iteration and releases the handle for further calls. More...
struct GNUNET_RECLAIM_Operation *	GNUNET_RECLAIM_ticket_issue (struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_PrivateKey *iss, const struct GNUNET_CRYPTO_PublicKey *rp, const struct GNUNET_RECLAIM_AttributeList *attrs, GNUNET_RECLAIM_IssueTicketCallback cb, void *cb_cls)
	Issues a ticket to a relying party. More...
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. More...
struct GNUNET_RECLAIM_Operation *	GNUNET_RECLAIM_ticket_consume (struct GNUNET_RECLAIM_Handle *h, const struct GNUNET_CRYPTO_PrivateKey *identity, const struct GNUNET_RECLAIM_Ticket *ticket, GNUNET_RECLAIM_AttributeTicketResult cb, void *cb_cls)
	Consumes an issued ticket. More...
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 identites (relying parties) More...
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. More...
void	GNUNET_RECLAIM_ticket_iteration_stop (struct GNUNET_RECLAIM_TicketIterator *it)
	Stops iteration and releases the handle for further calls. More...
void	GNUNET_RECLAIM_disconnect (struct GNUNET_RECLAIM_Handle *h)
	Disconnect from identity provider service. More...
void	GNUNET_RECLAIM_cancel (struct GNUNET_RECLAIM_Operation *op)
	Cancel an identity provider operation. More...
size_t	GNUNET_RECLAIM_ticket_serialize_get_size (const struct GNUNET_RECLAIM_Ticket *tkt)
	Get serialized ticket size. More...
enum GNUNET_GenericReturnValue	GNUNET_RECLAIM_read_ticket_from_buffer (const void *buffer, size_t len, struct GNUNET_RECLAIM_Ticket *tkt, size_t *tb_read)
	Deserializes a ticket. More...
ssize_t	GNUNET_RECLAIM_write_ticket_to_buffer (const struct GNUNET_RECLAIM_Ticket *tkt, void *buffer, size_t len)
	Serializes a ticket. More...

Detailed Description

Macro Definition Documentation

GNUNET_RECLAIM_VERSION

#define GNUNET_RECLAIM_VERSION   0x00000001

Version number of the re:claimID API.

Definition at line 52 of file gnunet_reclaim_service.h.

Typedef Documentation

GNUNET_RECLAIM_TicketCallback

typedef void(* GNUNET_RECLAIM_TicketCallback) (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket)

Method called when a token has been issued.

On success returns a ticket that can be given to a relying party in order for it retrieve identity attributes

Parameters

cls	closure
ticket	the ticket

Definition at line 99 of file gnunet_reclaim_service.h.

GNUNET_RECLAIM_IssueTicketCallback

typedef void(* GNUNET_RECLAIM_IssueTicketCallback) (void *cls, const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_RECLAIM_PresentationList *presentations)

Method called when a token has been issued.

On success returns a ticket that can be given to a relying party in order for it retrieve identity attributes

Parameters

cls	closure
ticket	the ticket

Definition at line 111 of file gnunet_reclaim_service.h.

GNUNET_RECLAIM_ContinuationWithStatus

typedef void(* GNUNET_RECLAIM_ContinuationWithStatus) (void *cls, int32_t success, const char *emsg)

Continuation called to notify client about result of the operation.

Parameters

cls	The callback closure
success	GNUNET_SYSERR on failure
emsg	NULL on success, otherwise an error message

Definition at line 125 of file gnunet_reclaim_service.h.

GNUNET_RECLAIM_AttributeResult

typedef void(* GNUNET_RECLAIM_AttributeResult) (void *cls, const struct GNUNET_CRYPTO_PublicKey *identity, const struct GNUNET_RECLAIM_Attribute *attr)

Callback used to notify the client of attribute results.

Parameters

cls	The callback closure
identity	The identity authoritative over the attributes
attr	The attribute

Definition at line 136 of file gnunet_reclaim_service.h.

GNUNET_RECLAIM_AttributeTicketResult

typedef void(* GNUNET_RECLAIM_AttributeTicketResult) (void *cls, const struct GNUNET_CRYPTO_PublicKey *identity, const struct GNUNET_RECLAIM_Attribute *attr, const struct GNUNET_RECLAIM_Presentation *presentation)

Callback used to notify the client of attribute results.

Parameters

cls	The callback closure
identity	The identity authoritative over the attributes
attr	The attribute
presentation	The presentation for the credential (may be NULL)

Definition at line 148 of file gnunet_reclaim_service.h.

GNUNET_RECLAIM_CredentialResult

typedef void(* GNUNET_RECLAIM_CredentialResult) (void *cls, const struct GNUNET_CRYPTO_PublicKey *identity, const struct GNUNET_RECLAIM_Credential *credential)

Callback used to notify the client of credential results.

Parameters

cls	The callback closure
identity	The identity authoritative over the attributes
credential	The credential
attributes	the parsed attributes

Definition at line 162 of file gnunet_reclaim_service.h.

Function Documentation

GNUNET_RECLAIM_connect()

struct GNUNET_RECLAIM_Handle* GNUNET_RECLAIM_connect

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Connect to the re:claimID service.

Parameters

cfg	Configuration to contact the re:claimID service.

Returns

handle to communicate with the service

Connect to the re:claimID service.

Parameters

cfg	the configuration to use

Returns

handle to use

Definition at line 1111 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *h;
 
  h = GNUNET_new (struct GNUNET_RECLAIM_Handle);
  h->cfg = cfg;
  reconnect (h);
  if (NULL == h->mq)
  {
    GNUNET_free (h);
    return NULL;
  }
  return h;
}

References cfg, GNUNET_ARM_Handle::cfg, GNUNET_free, GNUNET_new, h, GNUNET_ARM_Handle::mq, and reconnect().

Referenced by REST_openid_init(), REST_reclaim_init(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_store()

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.

If the attribute is already present, it is replaced with the new attribute.

Parameters

h	handle to the reclaim service
pkey	Private key of the identity to add an attribute to
attr	The attribute
exp_interval	The relative expiration interval for the attribute
cont	Continuation to call when done
cont_cls	Closure for cont

Returns

handle Used to to abort the request

Definition at line 1162 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Operation *op;
  struct AttributeStoreMessage *sam;
  size_t attr_len;
  size_t key_len;
  ssize_t written;
  char *buf;
 
  op = GNUNET_new (struct GNUNET_RECLAIM_Operation);
  op->h = h;
  op->as_cb = cont;
  op->cls = cont_cls;
  op->r_id = h->r_id_gen++;
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
  key_len = GNUNET_CRYPTO_private_key_get_length (pkey);
  attr_len = GNUNET_RECLAIM_attribute_serialize_get_size (attr);
  op->env = GNUNET_MQ_msg_extra (sam,
                                 attr_len + key_len,
                                 GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE);
  sam->key_len = htons (key_len);
  buf = (char *) &sam[1];
  written = GNUNET_CRYPTO_write_private_key_to_buffer (pkey, buf, key_len);
  GNUNET_assert (0 < written);
  buf += written;
  sam->id = htonl (op->r_id);
  sam->exp = GNUNET_htonll (exp_interval->rel_value_us);
 
  GNUNET_RECLAIM_attribute_serialize (attr, buf);
 
  sam->attr_len = htons (attr_len);
  if (NULL != h->mq)
    GNUNET_MQ_send_copy (h->mq, op->env);
  return op;
}

References AttributeStoreMessage::attr_len, AttributeStoreMessage::exp, exp_interval, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_htonll(), GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE, GNUNET_MQ_msg_extra, GNUNET_MQ_send_copy(), GNUNET_new, GNUNET_RECLAIM_attribute_serialize(), GNUNET_RECLAIM_attribute_serialize_get_size(), h, GNUNET_ARM_Operation::h, AttributeStoreMessage::id, AttributeStoreMessage::key_len, GNUNET_ARM_Handle::mq, op, pkey, and GNUNET_TIME_Relative::rel_value_us.

Referenced by add_attribute_cont(), and iter_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_store()

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.

If the credential is already present, it is replaced with the new credential.

Parameters

h	handle to the re:claimID service
pkey	private key of the identity
credential	the credential value
exp_interval	the relative expiration interval for the credential
cont	continuation to call when done
cont_cls	closure for cont

Returns

handle to abort the request

Definition at line 1247 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Operation *op;
  struct AttributeStoreMessage *sam;
  size_t attr_len;
  size_t key_len;
  ssize_t written;
  char *buf;
 
  op = GNUNET_new (struct GNUNET_RECLAIM_Operation);
  op->h = h;
  op->as_cb = cont;
  op->cls = cont_cls;
  op->r_id = h->r_id_gen++;
  key_len = GNUNET_CRYPTO_private_key_get_length (pkey);
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
  attr_len = GNUNET_RECLAIM_credential_serialize_get_size (credential);
  op->env = GNUNET_MQ_msg_extra (sam,
                                 attr_len + key_len,
                                 GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_STORE);
  sam->key_len = htons (key_len);
  buf = (char *) &sam[1];
  written = GNUNET_CRYPTO_write_private_key_to_buffer (pkey, buf, key_len);
  GNUNET_assert (0 <= written);
  buf += written;
  sam->id = htonl (op->r_id);
  sam->exp = GNUNET_htonll (exp_interval->rel_value_us);
 
  GNUNET_RECLAIM_credential_serialize (credential, buf);
 
  sam->attr_len = htons (attr_len);
  if (NULL != h->mq)
    GNUNET_MQ_send_copy (h->mq, op->env);
  return op;
}

References AttributeStoreMessage::attr_len, credential, AttributeStoreMessage::exp, exp_interval, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_htonll(), GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_STORE, GNUNET_MQ_msg_extra, GNUNET_MQ_send_copy(), GNUNET_new, GNUNET_RECLAIM_credential_serialize(), GNUNET_RECLAIM_credential_serialize_get_size(), h, GNUNET_ARM_Operation::h, AttributeStoreMessage::id, AttributeStoreMessage::key_len, GNUNET_ARM_Handle::mq, op, pkey, and GNUNET_TIME_Relative::rel_value_us.

Referenced by add_credential_cont(), and cred_iter_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_attribute_delete()

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.

Tickets used to share this attribute are updated accordingly.

Parameters

h	handle to the re:claimID service
pkey	Private key of the identity to add an attribute to
attr	The attribute
cont	Continuation to call when done
cont_cls	Closure for cont

Returns

handle Used to to abort the request

Definition at line 1206 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Operation *op;
  struct AttributeDeleteMessage *dam;
  size_t attr_len;
  size_t key_len;
  ssize_t written;
  char *buf;
 
  op = GNUNET_new (struct GNUNET_RECLAIM_Operation);
  op->h = h;
  op->as_cb = cont;
  op->cls = cont_cls;
  op->r_id = h->r_id_gen++;
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
  key_len = GNUNET_CRYPTO_private_key_get_length (pkey);
  attr_len = GNUNET_RECLAIM_attribute_serialize_get_size (attr);
  op->env = GNUNET_MQ_msg_extra (dam,
                                 attr_len + key_len,
                                 GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE);
  dam->key_len = htons (key_len);
  buf = (char *) &dam[1];
  written = GNUNET_CRYPTO_write_private_key_to_buffer (pkey, buf, key_len);
  GNUNET_assert (0 < written);
  buf += written;
  dam->id = htonl (op->r_id);
  GNUNET_RECLAIM_attribute_serialize (attr, buf);
 
  dam->attr_len = htons (attr_len);
  if (NULL != h->mq)
    GNUNET_MQ_send_copy (h->mq, op->env);
  return op;
}

References AttributeDeleteMessage::attr_len, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE, GNUNET_MQ_msg_extra, GNUNET_MQ_send_copy(), GNUNET_new, GNUNET_RECLAIM_attribute_serialize(), GNUNET_RECLAIM_attribute_serialize_get_size(), h, GNUNET_ARM_Operation::h, AttributeDeleteMessage::id, AttributeDeleteMessage::key_len, GNUNET_ARM_Handle::mq, op, and pkey.

Referenced by delete_attribute_cont(), and iter_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_credential_delete()

struct GNUNET_RECLAIM_Operation* GNUNET_RECLAIM_credential_delete	(	struct GNUNET_RECLAIM_Handle *	h,
		const struct GNUNET_CRYPTO_PrivateKey *	pkey,
		const struct GNUNET_RECLAIM_Credential *	cred,
		GNUNET_RECLAIM_ContinuationWithStatus	cont,
		void *	cont_cls
	)

Delete a credential.

Tickets used to share a presentation of this credential are updated accordingly.

Parameters

h	handle to the re:claimID service
pkey	Private key of the identity to add an attribute to
cred	The credential
cont	Continuation to call when done
cont_cls	Closure for cont

Returns

handle Used to to abort the request

Definition at line 1291 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Operation *op;
  struct AttributeDeleteMessage *dam;
  size_t attr_len;
  size_t key_len;
  ssize_t written;
  char *buf;
 
  op = GNUNET_new (struct GNUNET_RECLAIM_Operation);
  op->h = h;
  op->as_cb = cont;
  op->cls = cont_cls;
  op->r_id = h->r_id_gen++;
  key_len = GNUNET_CRYPTO_private_key_get_length (pkey);
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
  attr_len = GNUNET_RECLAIM_credential_serialize_get_size (attr);
  op->env = GNUNET_MQ_msg_extra (dam,
                                 attr_len + key_len,
                                 GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_DELETE);
  dam->key_len = htons (key_len);
  buf = (char *) &dam[1];
  written = GNUNET_CRYPTO_write_private_key_to_buffer (pkey, buf, key_len);
  GNUNET_assert (0 <= written);
  buf += written;
  dam->id = htonl (op->r_id);
  GNUNET_RECLAIM_credential_serialize (attr, buf);
 
  dam->attr_len = htons (attr_len);
  if (NULL != h->mq)
    GNUNET_MQ_send_copy (h->mq, op->env);
  return op;
}

References AttributeDeleteMessage::attr_len, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_DELETE, GNUNET_MQ_msg_extra, GNUNET_MQ_send_copy(), GNUNET_new, GNUNET_RECLAIM_credential_serialize(), GNUNET_RECLAIM_credential_serialize_get_size(), h, GNUNET_ARM_Operation::h, AttributeDeleteMessage::id, AttributeDeleteMessage::key_len, GNUNET_ARM_Handle::mq, op, and pkey.

Referenced by delete_credential_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_get_attributes_start()

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.

This MUST lock the struct GNUNET_RECLAIM_Handle for any other calls than GNUNET_RECLAIM_get_attributes_next() and GNUNET_RECLAIM_get_attributes_stop. proc will be called once immediately, and then again after GNUNET_RECLAIM_get_attributes_next() is invoked.

On error (disconnect), error_cb will be invoked. On normal completion, finish_cb proc will be invoked.

Parameters

h	Handle to the re:claimID service
identity	Identity to iterate over
error_cb	Function to call on error (i.e. disconnect), the handle is afterwards invalid
error_cb_cls	Closure for error_cb
proc	Function to call on each attribute
proc_cls	Closure for proc
finish_cb	Function to call on completion the handle is afterwards invalid
finish_cb_cls	Closure for finish_cb

Returns

an iterator Handle to use for iteration

Definition at line 1332 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_AttributeIterator *it;
  struct GNUNET_MQ_Envelope *env;
  struct AttributeIterationStartMessage *msg;
  uint32_t rid;
  size_t key_len;
 
  rid = h->r_id_gen++;
  it = GNUNET_new (struct GNUNET_RECLAIM_AttributeIterator);
  it->h = h;
  it->error_cb = error_cb;
  it->error_cb_cls = error_cb_cls;
  it->finish_cb = finish_cb;
  it->finish_cb_cls = finish_cb_cls;
  it->proc = proc;
  it->proc_cls = proc_cls;
  it->r_id = rid;
  it->identity = *identity;
  key_len = GNUNET_CRYPTO_private_key_get_length (identity);
  GNUNET_CONTAINER_DLL_insert_tail (h->it_head, h->it_tail, it);
  env =
    GNUNET_MQ_msg_extra (msg,
                         key_len,
                         GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START);
  msg->id = htonl (rid);
  msg->key_len = htons (key_len);
  GNUNET_CRYPTO_write_private_key_to_buffer (identity, &msg[1], key_len);
  if (NULL == h->mq)
    it->env = env;
  else
    GNUNET_MQ_send (h->mq, env);
  return it;
}

References env, GNUNET_RECLAIM_AttributeIterator::env, error_cb(), GNUNET_RECLAIM_AttributeIterator::error_cb, GNUNET_RECLAIM_AttributeIterator::error_cb_cls, GNUNET_RECLAIM_AttributeIterator::finish_cb, GNUNET_RECLAIM_AttributeIterator::finish_cb_cls, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, h, GNUNET_RECLAIM_AttributeIterator::h, identity, GNUNET_RECLAIM_AttributeIterator::identity, AttributeIterationStartMessage::key_len, GNUNET_ARM_Handle::mq, msg, GNUNET_RECLAIM_AttributeIterator::proc, GNUNET_RECLAIM_AttributeIterator::proc_cls, and GNUNET_RECLAIM_AttributeIterator::r_id.

Referenced by code_redirect(), cred_iter_finished(), and list_attribute_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_get_attributes_next()

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.

Parameters

it	The iterator

Definition at line 1377 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *h = it->h;
  struct AttributeIterationNextMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  env =
    GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT);
  msg->id = htonl (it->r_id);
  GNUNET_MQ_send (h->mq, env);
}

References env, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT, GNUNET_MQ_msg, GNUNET_MQ_send(), h, GNUNET_RECLAIM_AttributeIterator::h, GNUNET_ARM_Handle::mq, msg, and GNUNET_RECLAIM_AttributeIterator::r_id.

Referenced by attr_collect(), iter_cb(), and oidc_attr_collect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_get_attributes_stop()

void GNUNET_RECLAIM_get_attributes_stop

(

struct GNUNET_RECLAIM_AttributeIterator *

it

)

Stops iteration and releases the handle for further calls.

Must be called on any iteration that has not yet completed prior to calling GNUNET_RECLAIM_disconnect.

Parameters

it	the iterator

Definition at line 1391 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *h = it->h;
  struct GNUNET_MQ_Envelope *env;
  struct AttributeIterationStopMessage *msg;
 
  if (NULL != h->mq)
  {
    env =
      GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP);
    msg->id = htonl (it->r_id);
    GNUNET_MQ_send (h->mq, env);
  }
  free_it (it);
}

References env, free_it(), GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP, GNUNET_MQ_msg, GNUNET_MQ_send(), h, GNUNET_RECLAIM_AttributeIterator::h, GNUNET_ARM_Handle::mq, msg, and GNUNET_RECLAIM_AttributeIterator::r_id.

Referenced by cleanup_handle(), and do_cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_get_credentials_start()

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.

This MUST lock the struct GNUNET_RECLAIM_Handle for any other calls than GNUNET_RECLAIM_get_credentials_next() and GNUNET_RECLAIM_get_credentials_stop. proc will be called once immediately, and then again after GNUNET_RECLAIM_get_credentials_next() is invoked.

On error (disconnect), error_cb will be invoked. On normal completion, finish_cb proc will be invoked.

Parameters

h	Handle to the re:claimID service
identity	Identity to iterate over
error_cb	Function to call on error (i.e. disconnect), the handle is afterwards invalid
error_cb_cls	Closure for error_cb
proc	Function to call on each credential
proc_cls	Closure for proc
finish_cb	Function to call on completion the handle is afterwards invalid
finish_cb_cls	Closure for finish_cb

Returns

an iterator Handle to use for iteration

Definition at line 1409 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_CredentialIterator *ait;
  struct GNUNET_MQ_Envelope *env;
  struct CredentialIterationStartMessage *msg;
  uint32_t rid;
  size_t key_len;
 
  rid = h->r_id_gen++;
  ait = GNUNET_new (struct GNUNET_RECLAIM_CredentialIterator);
  ait->h = h;
  ait->error_cb = error_cb;
  ait->error_cb_cls = error_cb_cls;
  ait->finish_cb = finish_cb;
  ait->finish_cb_cls = finish_cb_cls;
  ait->proc = proc;
  ait->proc_cls = proc_cls;
  ait->r_id = rid;
  ait->identity = *identity;
  key_len = GNUNET_CRYPTO_private_key_get_length (identity);
  GNUNET_CONTAINER_DLL_insert_tail (h->ait_head, h->ait_tail, ait);
  env =
    GNUNET_MQ_msg_extra (msg,
                         key_len,
                         GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START);
  msg->id = htonl (rid);
  msg->key_len = htons (key_len);
  GNUNET_CRYPTO_write_private_key_to_buffer (identity, &msg[1], key_len);
  if (NULL == h->mq)
    ait->env = env;
  else
    GNUNET_MQ_send (h->mq, env);
  return ait;
}

References env, GNUNET_RECLAIM_CredentialIterator::env, error_cb(), GNUNET_RECLAIM_CredentialIterator::error_cb, GNUNET_RECLAIM_CredentialIterator::error_cb_cls, GNUNET_RECLAIM_CredentialIterator::finish_cb, GNUNET_RECLAIM_CredentialIterator::finish_cb_cls, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, h, GNUNET_RECLAIM_CredentialIterator::h, identity, GNUNET_RECLAIM_CredentialIterator::identity, CredentialIterationStartMessage::key_len, GNUNET_ARM_Handle::mq, msg, GNUNET_RECLAIM_CredentialIterator::proc, GNUNET_RECLAIM_CredentialIterator::proc_cls, and GNUNET_RECLAIM_CredentialIterator::r_id.

Referenced by list_credential_cont(), oidc_attr_collect_finished_cb(), and start_process().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_get_credentials_next()

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.

Parameters

ait	the iterator

Definition at line 1454 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *h = ait->h;
  struct CredentialIterationNextMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  env =
    GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_NEXT);
  msg->id = htonl (ait->r_id);
  GNUNET_MQ_send (h->mq, env);
}

References env, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_NEXT, GNUNET_MQ_msg, GNUNET_MQ_send(), h, GNUNET_RECLAIM_CredentialIterator::h, GNUNET_ARM_Handle::mq, msg, and GNUNET_RECLAIM_CredentialIterator::r_id.

Referenced by cred_collect(), cred_iter_cb(), and oidc_cred_collect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_get_credentials_stop()

void GNUNET_RECLAIM_get_credentials_stop

(

struct GNUNET_RECLAIM_CredentialIterator *

ait

)

Stops iteration and releases the handle for further calls.

Must be called on any iteration that has not yet completed prior to calling GNUNET_RECLAIM_disconnect.

Parameters

ait	the iterator

Definition at line 1469 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *h = ait->h;
  struct GNUNET_MQ_Envelope *env;
  struct CredentialIterationStopMessage *msg;
 
  if (NULL != h->mq)
  {
    env =
      GNUNET_MQ_msg (msg,
                     GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_STOP);
    msg->id = htonl (ait->r_id);
    GNUNET_MQ_send (h->mq, env);
  }
  free_ait (ait);
}

References env, free_ait(), GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_STOP, GNUNET_MQ_msg, GNUNET_MQ_send(), h, GNUNET_RECLAIM_CredentialIterator::h, GNUNET_ARM_Handle::mq, msg, and GNUNET_RECLAIM_CredentialIterator::r_id.

Referenced by cleanup_handle(), and do_cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_ticket_issue()

struct GNUNET_RECLAIM_Operation* GNUNET_RECLAIM_ticket_issue	(	struct GNUNET_RECLAIM_Handle *	h,
		const struct GNUNET_CRYPTO_PrivateKey *	iss,
		const struct GNUNET_CRYPTO_PublicKey *	rp,
		const struct GNUNET_RECLAIM_AttributeList *	attrs,
		GNUNET_RECLAIM_IssueTicketCallback	cb,
		void *	cb_cls
	)

Issues a ticket to a relying party.

The identity may use GNUNET_RECLAIM_ticket_consume to consume the ticket and retrieve the attributes specified in the attribute list.

Parameters

h	the identity provider to use
iss	the issuing identity (= the user)
rp	the subject of the ticket (= the relying party)
attrs	the attributes that the relying party is given access to
cb	the callback
cb_cls	the callback closure

Returns

handle to abort the operation

Definition at line 1489 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Operation *op;
  struct IssueTicketMessage *tim;
  size_t attr_len;
  size_t key_len;
  size_t rpk_len;
  ssize_t written;
  char *buf;
 
  op = GNUNET_new (struct GNUNET_RECLAIM_Operation);
  op->h = h;
  op->ti_cb = cb;
  op->cls = cb_cls;
  op->r_id = h->r_id_gen++;
  key_len = GNUNET_CRYPTO_private_key_get_length (iss);
  rpk_len = GNUNET_CRYPTO_public_key_get_length (rp);
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
  attr_len = GNUNET_RECLAIM_attribute_list_serialize_get_size (attrs);
  op->env = GNUNET_MQ_msg_extra (tim,
                                 attr_len + key_len + rpk_len,
                                 GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET);
  tim->key_len = htons (key_len);
  tim->pkey_len = htons (rpk_len);
  buf = (char *) &tim[1];
  written = GNUNET_CRYPTO_write_private_key_to_buffer (iss, buf, key_len);
  GNUNET_assert (0 <= written);
  buf += written;
  written = GNUNET_CRYPTO_write_public_key_to_buffer (rp, buf, rpk_len);
  GNUNET_assert (0 <= written);
  buf += written;
  tim->id = htonl (op->r_id);
 
  GNUNET_RECLAIM_attribute_list_serialize (attrs, buf);
  tim->attr_len = htons (attr_len);
  if (NULL != h->mq)
    GNUNET_MQ_send_copy (h->mq, op->env);
  return op;
}

References IssueTicketMessage::attr_len, GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_public_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_CRYPTO_write_public_key_to_buffer(), GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET, GNUNET_MQ_msg_extra, GNUNET_MQ_send_copy(), GNUNET_new, GNUNET_RECLAIM_attribute_list_serialize(), GNUNET_RECLAIM_attribute_list_serialize_get_size(), h, GNUNET_ARM_Operation::h, IssueTicketMessage::id, IssueTicketMessage::key_len, GNUNET_ARM_Handle::mq, op, IssueTicketMessage::pkey_len, and rp.

Referenced by iter_finished(), and oidc_cred_collect_finished_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_ticket_revoke()

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.

The relying party will be unable to retrieve attributes. Other issued tickets remain unaffected. This includes tickets issued to other relying parties as well as to other tickets issued to the audience specified in this ticket.

Parameters

h	the identity provider to use
identity	the issuing identity
ticket	the ticket to revoke
cb	the callback
cb_cls	the callback closure

Returns

handle to abort the operation

Definition at line 1692 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Operation *op;
  struct RevokeTicketMessage *msg;
  uint32_t rid;
  size_t key_len;
  size_t tkt_len;
  ssize_t written;
  char *buf;
 
  rid = h->r_id_gen++;
  op = GNUNET_new (struct GNUNET_RECLAIM_Operation);
  op->h = h;
  op->rvk_cb = cb;
  op->cls = cb_cls;
  op->r_id = rid;
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
  key_len = GNUNET_CRYPTO_private_key_get_length (identity);
  tkt_len = GNUNET_RECLAIM_ticket_serialize_get_size (ticket);
  op->env = GNUNET_MQ_msg_extra (msg,
                                 key_len + tkt_len,
                                 GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET);
  msg->id = htonl (rid);
  msg->key_len = htons (key_len);
  msg->tkt_len = htons (tkt_len);
  buf = (char*) &msg[1];
  written = GNUNET_CRYPTO_write_private_key_to_buffer (identity,
                                                         buf,
                                                         key_len);
  GNUNET_assert (0 <= written);
  buf += written;
  GNUNET_RECLAIM_write_ticket_to_buffer (ticket,
                                         buf,
                                         tkt_len);
  if (NULL != h->mq)
  {
    GNUNET_MQ_send (h->mq, op->env);
    op->env = NULL;
  }
  return op;
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_RECLAIM_ticket_serialize_get_size(), GNUNET_RECLAIM_write_ticket_to_buffer(), h, GNUNET_ARM_Operation::h, identity, RevokeTicketMessage::key_len, GNUNET_ARM_Handle::mq, msg, op, ticket, and RevokeTicketMessage::tkt_len.

Referenced by iter_finished(), and revoke_ticket_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_ticket_consume()

struct GNUNET_RECLAIM_Operation* GNUNET_RECLAIM_ticket_consume	(	struct GNUNET_RECLAIM_Handle *	h,
		const struct GNUNET_CRYPTO_PrivateKey *	identity,
		const struct GNUNET_RECLAIM_Ticket *	ticket,
		GNUNET_RECLAIM_AttributeTicketResult	cb,
		void *	cb_cls
	)

Consumes an issued ticket.

The ticket is used to retrieve identity information from the issuer

Parameters

h	the identity provider to use
identity	the identity that is the subject of the issued ticket (the relying party)
ticket	the issued ticket to consume
cb	the callback to call
cb_cls	the callback closure

Returns

handle to abort the operation

The ticket is persisted and used to retrieve identity information from the issuer

Parameters

h	the reclaim to use
identity	the identity that is the subject of the issued ticket (the relying party)
ticket	the issued ticket to consume
cb	the callback to call
cb_cls	the callback closure

Returns

handle to abort the operation

Definition at line 1549 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Operation *op;
  struct ConsumeTicketMessage *ctm;
  size_t key_len;
  size_t tkt_len;
  char *buf;
 
  op = GNUNET_new (struct GNUNET_RECLAIM_Operation);
  op->h = h;
  op->atr_cb = cb;
  op->cls = cb_cls;
  op->r_id = h->r_id_gen++;
  key_len = GNUNET_CRYPTO_private_key_get_length (identity);
  tkt_len = GNUNET_RECLAIM_ticket_serialize_get_size (ticket);
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, op);
  op->env = GNUNET_MQ_msg_extra (ctm,
                                 key_len + tkt_len,
                                 GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET);
  ctm->key_len = htons (key_len);
  buf = (char*) &ctm[1];
  GNUNET_CRYPTO_write_private_key_to_buffer (identity, buf, key_len);
  buf += key_len;
  ctm->tkt_len = htons (tkt_len);
  GNUNET_RECLAIM_write_ticket_to_buffer (ticket, buf, tkt_len);
  ctm->id = htonl (op->r_id);
  if (NULL != h->mq)
    GNUNET_MQ_send_copy (h->mq, op->env);
  else
    reconnect (h);
  return op;
}

References GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET, GNUNET_MQ_msg_extra, GNUNET_MQ_send_copy(), GNUNET_new, GNUNET_RECLAIM_ticket_serialize_get_size(), GNUNET_RECLAIM_write_ticket_to_buffer(), h, GNUNET_ARM_Operation::h, ConsumeTicketMessage::id, identity, ConsumeTicketMessage::key_len, GNUNET_ARM_Handle::mq, op, reconnect(), ticket, and ConsumeTicketMessage::tkt_len.

Referenced by consume_ticket_cont(), iter_finished(), and userinfo_endpoint().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_ticket_iteration_start()

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 identites (relying parties)

Parameters

h	the identity provider to use
identity	the issuing identity
error_cb	function to call on error (i.e. disconnect), the handle is afterwards invalid
error_cb_cls	closure for error_cb
proc	function to call on each ticket; it will be called repeatedly with a value (if available)
proc_cls	closure for proc
finish_cb	function to call on completion the handle is afterwards invalid
finish_cb_cls	closure for finish_cb

Returns

an iterator handle to use for iteration

Definition at line 1589 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_TicketIterator *it;
  struct GNUNET_MQ_Envelope *env;
  struct TicketIterationStartMessage *msg;
  uint32_t rid;
  size_t key_len;
 
  rid = h->r_id_gen++;
  it = GNUNET_new (struct GNUNET_RECLAIM_TicketIterator);
  it->h = h;
  it->error_cb = error_cb;
  it->error_cb_cls = error_cb_cls;
  it->finish_cb = finish_cb;
  it->finish_cb_cls = finish_cb_cls;
  it->tr_cb = proc;
  it->cls = proc_cls;
  it->r_id = rid;
 
  key_len = GNUNET_CRYPTO_private_key_get_length (identity);
  GNUNET_CONTAINER_DLL_insert_tail (h->ticket_it_head, h->ticket_it_tail, it);
  env = GNUNET_MQ_msg_extra (msg,
                             key_len,
                             GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START);
  msg->id = htonl (rid);
  msg->key_len = htons (key_len);
  GNUNET_CRYPTO_write_private_key_to_buffer (identity,
                                               &msg[1],
                                               key_len);
  if (NULL == h->mq)
    it->env = env;
  else
    GNUNET_MQ_send (h->mq, env);
  return it;
}

References GNUNET_RECLAIM_TicketIterator::cls, env, GNUNET_RECLAIM_TicketIterator::env, error_cb(), GNUNET_RECLAIM_TicketIterator::error_cb, GNUNET_RECLAIM_TicketIterator::error_cb_cls, GNUNET_RECLAIM_TicketIterator::finish_cb, GNUNET_RECLAIM_TicketIterator::finish_cb_cls, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_private_key_get_length(), GNUNET_CRYPTO_write_private_key_to_buffer(), GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, h, GNUNET_RECLAIM_TicketIterator::h, identity, TicketIterationStartMessage::key_len, GNUNET_ARM_Handle::mq, msg, GNUNET_RECLAIM_TicketIterator::r_id, and GNUNET_RECLAIM_TicketIterator::tr_cb.

Referenced by list_tickets_cont(), and start_process().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_ticket_iteration_next()

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.

Parameters

it	the iterator

Definition at line 1641 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *h = it->h;
  struct TicketIterationNextMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT);
  msg->id = htonl (it->r_id);
  GNUNET_MQ_send (h->mq, env);
}

References env, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT, GNUNET_MQ_msg, GNUNET_MQ_send(), h, GNUNET_RECLAIM_TicketIterator::h, GNUNET_ARM_Handle::mq, msg, and GNUNET_RECLAIM_TicketIterator::r_id.

Referenced by ticket_collect(), and ticket_iter().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_ticket_iteration_stop()

void GNUNET_RECLAIM_ticket_iteration_stop

(

struct GNUNET_RECLAIM_TicketIterator *

it

)

Stops iteration and releases the handle for further calls.

Must be called on any iteration that has not yet completed prior to calling GNUNET_RECLAIM_disconnect.

Parameters

it	the iterator

Definition at line 1661 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *h = it->h;
  struct GNUNET_MQ_Envelope *env;
  struct TicketIterationStopMessage *msg;
 
  if (NULL != h->mq)
  {
    env =
      GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP);
    msg->id = htonl (it->r_id);
    GNUNET_MQ_send (h->mq, env);
  }
  GNUNET_free (it);
}

References env, GNUNET_free, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP, GNUNET_MQ_msg, GNUNET_MQ_send(), h, GNUNET_RECLAIM_TicketIterator::h, GNUNET_ARM_Handle::mq, msg, and GNUNET_RECLAIM_TicketIterator::r_id.

Referenced by cleanup_handle(), and do_cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_disconnect()

void GNUNET_RECLAIM_disconnect

(

struct GNUNET_RECLAIM_Handle *

h

)

Disconnect from identity provider service.

Parameters

h	identity provider service to disconnect

Disconnect from identity provider service.

Parameters

h	handle to destroy

Definition at line 1143 of file reclaim_api.c.

{
  GNUNET_assert (NULL != h);
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
  if (NULL != h->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (h->reconnect_task);
    h->reconnect_task = NULL;
  }
  GNUNET_assert (NULL == h->op_head);
  GNUNET_free (h);
}

References GNUNET_assert, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), h, GNUNET_ARM_Handle::mq, and GNUNET_ARM_Handle::reconnect_task.

Referenced by do_cleanup(), REST_openid_done(), and REST_reclaim_done().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_cancel()

void GNUNET_RECLAIM_cancel

(

struct GNUNET_RECLAIM_Operation *

op

)

Cancel an identity provider operation.

Note that the operation MAY still be executed; this merely cancels the continuation; if the request was already transmitted, the service may still choose to complete the operation.

Parameters

op	operation to cancel

Definition at line 1128 of file reclaim_api.c.

{
  struct GNUNET_RECLAIM_Handle *h = op->h;
 
  GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, op);
  free_op (op);
}

References free_op(), GNUNET_CONTAINER_DLL_remove, h, GNUNET_ARM_Operation::h, and op.

Referenced by cleanup_handle(), consume_fail(), and do_cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_ticket_serialize_get_size()

size_t GNUNET_RECLAIM_ticket_serialize_get_size

(

const struct GNUNET_RECLAIM_Ticket *

tkt

)

Get serialized ticket size.

Parameters

tkt	the ticket

Returns

the buffer length requirement for a serialization

Definition at line 1740 of file reclaim_api.c.

{
  size_t size = sizeof (tkt->rnd);
  size += GNUNET_CRYPTO_public_key_get_length (&tkt->identity);
  size += GNUNET_CRYPTO_public_key_get_length (&tkt->audience);
  return size;
}

Referenced by check_ticket_iteration_start(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RECLAIM_ticket_revoke(), issue_ticket(), and send_ticket_result().

Here is the caller graph for this function:

GNUNET_RECLAIM_read_ticket_from_buffer()

enum GNUNET_GenericReturnValue GNUNET_RECLAIM_read_ticket_from_buffer	(	const void *	buffer,
		size_t	len,
		struct GNUNET_RECLAIM_Ticket *	tkt,
		size_t *	tb_read
	)

Deserializes a ticket.

Parameters

buffer	the buffer to read from
len	the length of the buffer
tkt	the ticket to write to (must be allocated)
kb_read	how many bytes were read from buffer

Returns

GNUNET_SYSERR on error

Definition at line 1740 of file reclaim_api.c.

{
  const char *tmp = buffer;
  size_t read = 0;
  size_t left = len;
  if (GNUNET_SYSERR ==
      GNUNET_CRYPTO_read_public_key_from_buffer (tmp,
                                                   left,
                                                   &tkt->identity,
                                                   &read))
    return GNUNET_SYSERR;
  left -= read;
  tmp += read;
  if (GNUNET_SYSERR ==
      GNUNET_CRYPTO_read_public_key_from_buffer (tmp,
                                                   left,
                                                   &tkt->audience,
                                                   &read))
    return GNUNET_SYSERR;
  left -= read;
  tmp += read;
  if (left < sizeof (tkt->rnd))
    return GNUNET_SYSERR;
  memcpy (&tkt->rnd, tmp, sizeof (tkt->rnd));
  *tb_read = tmp - (char*) buffer + sizeof (tkt->rnd);
  return GNUNET_OK;
}

References GNUNET_RECLAIM_Ticket::audience, GNUNET_CRYPTO_public_key_get_length(), GNUNET_RECLAIM_Ticket::identity, GNUNET_RECLAIM_Ticket::rnd, and size.

Referenced by collect_tickets_cb(), filter_tickets_cb(), handle_consume_ticket_message(), handle_revoke_ticket_message(), and handle_ticket_result().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RECLAIM_write_ticket_to_buffer()

ssize_t GNUNET_RECLAIM_write_ticket_to_buffer	(	const struct GNUNET_RECLAIM_Ticket *	tkt,
		void *	buffer,
		size_t	len
	)

Serializes a ticket.

Parameters

tkt	the ticket to serialize
buffer	the buffer to serialize to (must be allocated with sufficient size
len	the length of the buffer

Returns

the number of written bytes or < 0 on error

Definition at line 1783 of file reclaim_api.c.

{
  char *tmp = buffer;
  size_t left = len;
  ssize_t written = 0;
  written = GNUNET_CRYPTO_write_public_key_to_buffer (&tkt->identity,
                                                        buffer,
                                                        left);
  if (0 > written)
    return written;
  left -= written;
  tmp += written;
  written = GNUNET_CRYPTO_write_public_key_to_buffer (&tkt->audience,
                                                        tmp,
                                                        left);
  if (0 > written)
    return written;
  left -= written;
  tmp += written;
  if (left < sizeof (tkt->rnd))
    return -1;
  memcpy (tmp, &tkt->rnd, sizeof (tkt->rnd));
  return tmp - (char*) buffer + sizeof (tkt->rnd);
}

References GNUNET_RECLAIM_Ticket::audience, GNUNET_CRYPTO_write_public_key_to_buffer(), GNUNET_RECLAIM_Ticket::identity, and GNUNET_RECLAIM_Ticket::rnd.

Referenced by check_ticket_iteration_start(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RECLAIM_ticket_revoke(), issue_ticket(), and send_ticket_result().

Here is the call graph for this function:

Here is the caller graph for this function: