gnunet-service-reclaim.c File Reference

#include "reclaim.h"
#include "gnunet-service-reclaim_tickets.h"
#include "gnunet_util_lib.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_reclaim_lib.h"
#include "gnunet_reclaim_service.h"

Include dependency graph for gnunet-service-reclaim.c:

Go to the source code of this file.

Data Structures
struct	TicketIteration
	A ticket iteration operation. More...
struct	Iterator
	An attribute iteration operation. More...
struct	IdpClient
	An idp client. More...
struct	AttributeDeleteHandle
	Handle for attribute deletion request. More...
struct	AttributeStoreHandle
	Handle for attribute store request. More...
struct	ConsumeTicketOperation
	Handle for ticket consume request. More...
struct	TicketRevocationOperation
	Ticket revocation request handle. More...
struct	TicketIssueOperation
	Ticket issue operation handle. More...

Functions
static void	cleanup_adh (struct AttributeDeleteHandle *adh)
	Cleanup attribute delete handle.
static void	cleanup_as_handle (struct AttributeStoreHandle *ash)
	Cleanup attribute store handle.
static void	cleanup_client (struct IdpClient *idp)
	Cleanup client.
static void	cleanup ()
	Cleanup task.
static void	do_shutdown (void *cls)
	Shutdown task.
static void	send_ticket_result (const struct IdpClient *client, uint32_t r_id, const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_RECLAIM_PresentationList *presentations, uint32_t success)
	Sends a ticket result message to the client.
static void	issue_ticket_result_cb (void *cls, struct GNUNET_RECLAIM_Ticket *ticket, struct GNUNET_RECLAIM_PresentationList *presentations, int32_t success, const char *emsg)
	Issue ticket result.
static int	check_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
	Check issue ticket message.
static void	handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
	Handle ticket issue message.
static void	revoke_result_cb (void *cls, int32_t success)
	Handles revocation result.
static int	check_revoke_ticket_message (void *cls, const struct RevokeTicketMessage *rm)
	Check revocation message format.
static void	handle_revoke_ticket_message (void *cls, const struct RevokeTicketMessage *rm)
	Handle a revocation message to a ticket.
static void	consume_result_cb (void *cls, const struct GNUNET_CRYPTO_BlindablePublicKey *identity, const struct GNUNET_RECLAIM_AttributeList *attrs, const struct GNUNET_RECLAIM_PresentationList *presentations, int32_t success, const char *emsg)
	Handle a ticket consume result.
static int	check_consume_ticket_message (void *cls, const struct ConsumeTicketMessage *cm)
	Check a consume ticket message.
static void	handle_consume_ticket_message (void *cls, const struct ConsumeTicketMessage *cm)
	Handle a consume ticket message.
static void	attr_store_cont (void *cls, enum GNUNET_ErrorCode ec)
	Attribute store result handler.
static void	attr_store_task (void *cls)
	Add a new attribute.
static int	check_attribute_store_message (void *cls, const struct AttributeStoreMessage *sam)
	Check an attribute store message.
static void	handle_attribute_store_message (void *cls, const struct AttributeStoreMessage *sam)
	Handle an attribute store message.
static void	cred_store_cont (void *cls, enum GNUNET_ErrorCode ec)
	Credential store result handler.
static void	cred_error (void *cls)
	Error looking up potential credential.
static void	cred_add_cb (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Check for existing record before storing credential.
static void	cred_store_task (void *cls)
	Add a new credential.
static int	check_credential_store_message (void *cls, const struct AttributeStoreMessage *sam)
	Check an credential store message.
static void	handle_credential_store_message (void *cls, const struct AttributeStoreMessage *sam)
	Handle a credential store message.
static void	send_delete_response (struct AttributeDeleteHandle *adh, int32_t success)
	Send a deletion success response.
static void	consistency_iter (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Namestore iteration within attribute deletion.
static void	update_tickets (void *cls)
	Recursion prototype for function.
static void	ticket_updated (void *cls, enum GNUNET_ErrorCode ec)
	Callback called when a ticket was updated.
static void	purge_attributes (void *cls)
	Delete all attributes which reference credentials that no longer exist.
static void	offending_attr_delete_cont (void *cls, enum GNUNET_ErrorCode ec)
static void	consistency_iter_fin (void *cls)
	Done collecting affected tickets, start updating.
static void	consistency_iter_err (void *cls)
	Error collecting affected tickets.
static void	start_consistency_update (void *cls)
	Start processing tickets which may still contain reference to deleted attribute.
static void	attr_delete_cont (void *cls, enum GNUNET_ErrorCode ec)
	Attribute deleted callback.
static int	check_attribute_delete_message (void *cls, const struct AttributeDeleteMessage *dam)
	Check attribute delete message format.
static void	handle_attribute_delete_message (void *cls, const struct AttributeDeleteMessage *dam)
	Handle attribute deletion.
static void	cred_delete_cont (void *cls, enum GNUNET_ErrorCode ec)
	Credential deleted callback.
static int	check_credential_delete_message (void *cls, const struct AttributeDeleteMessage *dam)
	Check credential delete message format.
static void	handle_credential_delete_message (void *cls, const struct AttributeDeleteMessage *dam)
	Handle credential deletion.
static void	attr_iter_finished (void *cls)
	Done iterating over attributes.
static void	attr_iter_error (void *cls)
	Error iterating over attributes.
static void	attr_iter_cb (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Got record.
static enum GNUNET_GenericReturnValue	check_iteration_start (void *cls, const struct AttributeIterationStartMessage *ais_msg)
static void	handle_iteration_start (void *cls, const struct AttributeIterationStartMessage *ais_msg)
	Iterate over zone to get attributes.
static void	handle_iteration_stop (void *cls, const struct AttributeIterationStopMessage *ais_msg)
	Handle iteration stop message from client.
static void	handle_iteration_next (void *cls, const struct AttributeIterationNextMessage *ais_msg)
	Client requests next attribute from iterator.
static void	cred_iter_finished (void *cls)
	Done iterating over credentials.
static void	cred_iter_error (void *cls)
	Error iterating over credentials.
static void	cred_iter_cb (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Got record.
static enum GNUNET_GenericReturnValue	check_credential_iteration_start (void *cls, const struct CredentialIterationStartMessage *cis_msg)
static void	handle_credential_iteration_start (void *cls, const struct CredentialIterationStartMessage *ais_msg)
	Iterate over zone to get attributes.
static void	handle_credential_iteration_stop (void *cls, const struct CredentialIterationStopMessage *ais_msg)
	Handle iteration stop message from client.
static void	handle_credential_iteration_next (void *cls, const struct CredentialIterationNextMessage *ais_msg)
	Client requests next credential from iterator.
static void	ticket_iter_cb (void *cls, struct GNUNET_RECLAIM_Ticket *ticket, const char *rp_uri)
static enum GNUNET_GenericReturnValue	check_ticket_iteration_start (void *cls, const struct TicketIterationStartMessage *tis_msg)
static void	handle_ticket_iteration_start (void *cls, const struct TicketIterationStartMessage *tis_msg)
	Client requests a ticket iteration.
static void	handle_ticket_iteration_stop (void *cls, const struct TicketIterationStopMessage *tis_msg)
	Client has had enough tickets.
static void	handle_ticket_iteration_next (void *cls, const struct TicketIterationNextMessage *tis_msg)
	Client requests next result.
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *server)
	Main function that will be run.
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
	Called whenever a client is disconnected.
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	Add a client to our list of active clients.
	GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "reclaim", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(attribute_store_message, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE, struct AttributeStoreMessage, NULL), GNUNET_MQ_hd_var_size(credential_store_message, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_STORE, struct AttributeStoreMessage, NULL), GNUNET_MQ_hd_var_size(attribute_delete_message, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE, struct AttributeDeleteMessage, NULL), GNUNET_MQ_hd_var_size(credential_delete_message, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_DELETE, struct AttributeDeleteMessage, NULL), GNUNET_MQ_hd_var_size(iteration_start, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START, struct AttributeIterationStartMessage, NULL), GNUNET_MQ_hd_fixed_size(iteration_next, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT, struct AttributeIterationNextMessage, NULL), GNUNET_MQ_hd_fixed_size(iteration_stop, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP, struct AttributeIterationStopMessage, NULL), GNUNET_MQ_hd_var_size(credential_iteration_start, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START, struct CredentialIterationStartMessage, NULL), GNUNET_MQ_hd_fixed_size(credential_iteration_next, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_NEXT, struct CredentialIterationNextMessage, NULL), GNUNET_MQ_hd_fixed_size(credential_iteration_stop, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_STOP, struct CredentialIterationStopMessage, NULL), GNUNET_MQ_hd_var_size(issue_ticket_message, GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET, struct IssueTicketMessage, NULL), GNUNET_MQ_hd_var_size(consume_ticket_message, GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET, struct ConsumeTicketMessage, NULL), GNUNET_MQ_hd_var_size(ticket_iteration_start, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START, struct TicketIterationStartMessage, NULL), GNUNET_MQ_hd_fixed_size(ticket_iteration_next, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT, struct TicketIterationNextMessage, NULL), GNUNET_MQ_hd_fixed_size(ticket_iteration_stop, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP, struct TicketIterationStopMessage, NULL), GNUNET_MQ_hd_var_size(revoke_ticket_message, GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET, struct RevokeTicketMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro.

Variables
static struct GNUNET_NAMESTORE_Handle *	nsh
	Namestore handle.
static struct GNUNET_SCHEDULER_Task *	timeout_task
	Timeout task.
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Our configuration.
static struct IdpClient *	client_list_head = NULL
	Client list.
static struct IdpClient *	client_list_tail = NULL
	Client list.

Function Documentation

cleanup_adh()

static void cleanup_adh ( struct AttributeDeleteHandle *  adh )

static

Cleanup attribute delete handle.

Parameters

adh	the attribute to cleanup

Definition at line 486 of file gnunet-service-reclaim.c.

{
  struct TicketRecordsEntry *le;
 
  if (NULL != adh->ns_it)
    GNUNET_NAMESTORE_zone_iteration_stop (adh->ns_it);
  if (NULL != adh->ns_qe)
    GNUNET_NAMESTORE_cancel (adh->ns_qe);
  if (NULL != adh->label)
    GNUNET_free (adh->label);
  if (NULL != adh->claim)
    GNUNET_free (adh->claim);
  if (NULL != adh->credential)
    GNUNET_free (adh->credential);
  if (NULL != adh->existing_credentials)
    GNUNET_RECLAIM_credential_list_destroy (adh->existing_credentials);
  if (NULL != adh->existing_attributes)
    GNUNET_RECLAIM_attribute_list_destroy (adh->existing_attributes);
  while (NULL != (le = adh->tickets_to_update_head))
  {
    GNUNET_CONTAINER_DLL_remove (adh->tickets_to_update_head,
                                 adh->tickets_to_update_tail,
                                 le);
    if (NULL != le->label)
      GNUNET_free (le->label);
    if (NULL != le->data)
      GNUNET_free (le->data);
    GNUNET_free (le);
  }
  GNUNET_free (adh);
}

References AttributeDeleteHandle::claim, AttributeDeleteHandle::credential, TicketRecordsEntry::data, AttributeDeleteHandle::existing_attributes, AttributeDeleteHandle::existing_credentials, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_RECLAIM_attribute_list_destroy(), GNUNET_RECLAIM_credential_list_destroy(), AttributeDeleteHandle::label, TicketRecordsEntry::label, AttributeDeleteHandle::ns_it, AttributeDeleteHandle::ns_qe, AttributeDeleteHandle::tickets_to_update_head, and AttributeDeleteHandle::tickets_to_update_tail.

Referenced by attr_delete_cont(), cleanup_client(), consistency_iter_err(), cred_delete_cont(), offending_attr_delete_cont(), and update_tickets().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_as_handle()

static void cleanup_as_handle ( struct AttributeStoreHandle *  ash )

static

Cleanup attribute store handle.

Parameters

ash	handle to clean up

Definition at line 525 of file gnunet-service-reclaim.c.

{
  if (NULL != ash->ns_qe)
    GNUNET_NAMESTORE_cancel (ash->ns_qe);
  if (NULL != ash->claim)
    GNUNET_free (ash->claim);
  if (NULL != ash->credential)
    GNUNET_free (ash->credential);
  GNUNET_free (ash);
}

References AttributeStoreHandle::claim, AttributeStoreHandle::credential, GNUNET_free, GNUNET_NAMESTORE_cancel(), and AttributeStoreHandle::ns_qe.

Referenced by attr_store_cont(), cleanup_client(), cred_error(), and cred_store_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_client()

static void cleanup_client ( struct IdpClient *  idp )

static

Cleanup client.

Parameters

idp	the client to clean up

Definition at line 543 of file gnunet-service-reclaim.c.

{
  struct Iterator *ai;
  struct TicketIteration *ti;
  struct TicketRevocationOperation *rop;
  struct TicketIssueOperation *iss;
  struct ConsumeTicketOperation *ct;
  struct AttributeStoreHandle *as;
  struct AttributeDeleteHandle *adh;
 
  while (NULL != (iss = idp->issue_op_head))
  {
    GNUNET_CONTAINER_DLL_remove (idp->issue_op_head, idp->issue_op_tail, iss);
    GNUNET_free (iss);
  }
  while (NULL != (ct = idp->consume_op_head))
  {
    GNUNET_CONTAINER_DLL_remove (idp->consume_op_head,
                                 idp->consume_op_tail,
                                 ct);
    if (NULL != ct->ch)
      RECLAIM_TICKETS_consume_cancel (ct->ch);
    GNUNET_free (ct);
  }
  while (NULL != (as = idp->store_op_head))
  {
    GNUNET_CONTAINER_DLL_remove (idp->store_op_head, idp->store_op_tail, as);
    cleanup_as_handle (as);
  }
  while (NULL != (adh = idp->delete_op_head))
  {
    GNUNET_CONTAINER_DLL_remove (idp->delete_op_head, idp->delete_op_tail, adh);
    cleanup_adh (adh);
  }
 
  while (NULL != (ai = idp->attr_iter_head))
  {
    GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai);
    GNUNET_free (ai);
  }
  while (NULL != (ai = idp->cred_iter_head))
  {
    GNUNET_CONTAINER_DLL_remove (idp->cred_iter_head, idp->cred_iter_tail,
                                 ai);
    GNUNET_free (ai);
  }
 
  while (NULL != (rop = idp->revoke_op_head))
  {
    GNUNET_CONTAINER_DLL_remove (idp->revoke_op_head, idp->revoke_op_tail, rop);
    if (NULL != rop->rh)
      RECLAIM_TICKETS_revoke_cancel (rop->rh);
    GNUNET_free (rop);
  }
  while (NULL != (ti = idp->ticket_iter_head))
  {
    GNUNET_CONTAINER_DLL_remove (idp->ticket_iter_head,
                                 idp->ticket_iter_tail,
                                 ti);
    if (NULL != ti->iter)
      RECLAIM_TICKETS_iteration_stop (ti->iter);
    GNUNET_free (ti);
  }
  GNUNET_free (idp);
}

References ai, ConsumeTicketOperation::ch, cleanup_adh(), cleanup_as_handle(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, idp, TicketIteration::iter, RECLAIM_TICKETS_consume_cancel(), RECLAIM_TICKETS_iteration_stop(), RECLAIM_TICKETS_revoke_cancel(), and TicketRevocationOperation::rh.

Referenced by client_disconnect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup()

static void cleanup ( )

static

Cleanup task.

Definition at line 614 of file gnunet-service-reclaim.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
 
  RECLAIM_TICKETS_deinit ();
  if (NULL != timeout_task)
    GNUNET_SCHEDULER_cancel (timeout_task);
  if (NULL != nsh)
    GNUNET_NAMESTORE_disconnect (nsh);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NAMESTORE_disconnect(), GNUNET_SCHEDULER_cancel(), nsh, RECLAIM_TICKETS_deinit(), and timeout_task.

Referenced by cleanup_store_discourse_messages_before(), create_did(), create_did_cb(), create_did_ego_create_cb(), create_did_ego_lockup_cb(), curl_check_hdr(), decrypt_message(), decrypt_new_element(), decrypt_secret_message(), deserialize_download(), deserialize_fi_node(), deserialize_publish_file(), deserialize_search(), deserialize_search_result(), deserialize_unindex_file(), do_shutdown(), encrypt_message(), encrypt_secret_message(), GNUNET_FS_download_sync_(), GNUNET_FS_file_information_sync_(), GNUNET_FS_publish_sync_(), GNUNET_FS_search_result_sync_(), GNUNET_FS_search_sync_(), GNUNET_FS_unindex_sync_(), GNUNET_PQ_extract_result(), GNUNET_PROGRAM_run2(), GNUNET_TESTING_cmd_load_topology_from_file(), GNUNET_TESTING_cmd_load_topology_from_string(), GNUNET_TESTING_command_new_ac(), handle_inline(), iterate_flag_for_cleanup_discourse_message(), main(), main(), main_task(), post_ego_iteration(), print_did_document(), process_dids(), read_download_request(), remove_did_document(), remove_did_document_namestore_cb(), replace_did_document(), resolve_did(), run(), run(), run(), run(), and verify_fair().

Here is the call graph for this function:

Here is the caller graph for this function:

do_shutdown()

static void do_shutdown ( void *  cls )

static

Shutdown task.

Parameters

cls

NULL

Definition at line 632 of file gnunet-service-reclaim.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down...\n");
  cleanup ();
}

References cleanup(), GNUNET_ERROR_TYPE_INFO, and GNUNET_log.

Here is the call graph for this function:

send_ticket_result()

static void send_ticket_result ( const struct IdpClient *  client, uint32_t  r_id, const struct GNUNET_RECLAIM_Ticket *  ticket, const struct GNUNET_RECLAIM_PresentationList *  presentations, uint32_t  success  )

static

Sends a ticket result message to the client.

Parameters

client	the client to send to
r_id	the request message ID to reply to
ticket	the ticket to include (may be NULL)
success	the success status of the request

Definition at line 648 of file gnunet-service-reclaim.c.

{
  struct TicketResultMessage *irm;
  struct GNUNET_MQ_Envelope *env;
  size_t pres_len = 0;
  size_t tkt_len = 0;
  char *buf;
 
  if (NULL != presentations)
  {
    pres_len =
      GNUNET_RECLAIM_presentation_list_serialize_get_size (presentations);
  }
  if (NULL != ticket)
    tkt_len = strlen (ticket->gns_name) + 1;
  env = GNUNET_MQ_msg_extra (irm,
                             pres_len + tkt_len,
                             GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT);
  buf = (char*) &irm[1];
  if (NULL != ticket)
  {
    memcpy (buf, ticket, tkt_len);
    buf += tkt_len;
  }
  // TODO add success member
  irm->id = htonl (r_id);
  irm->tkt_len = htons (tkt_len);
  irm->rp_uri_len = htons (0);
  irm->presentations_len = htons (pres_len);
  if (NULL != presentations)
  {
    GNUNET_RECLAIM_presentation_list_serialize (presentations,
                                                buf);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
  GNUNET_MQ_send (client->mq, env);
}

References env, GNUNET_RECLAIM_Ticket::gns_name, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_RECLAIM_presentation_list_serialize(), GNUNET_RECLAIM_presentation_list_serialize_get_size(), TicketResultMessage::id, IdpClient::mq, TicketResultMessage::presentations_len, TicketResultMessage::rp_uri_len, ticket, and TicketResultMessage::tkt_len.

Referenced by issue_ticket_result_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

issue_ticket_result_cb()

static void issue_ticket_result_cb ( void *  cls, struct GNUNET_RECLAIM_Ticket *  ticket, struct GNUNET_RECLAIM_PresentationList *  presentations, int32_t  success, const char *  emsg  )

static

Issue ticket result.

Parameters

cls	out ticket issue operation handle
ticket	the issued ticket
presentations	newly created credential presentations (NULL on error)
success	issue success status (GNUNET_OK if successful)
emsg	error message (NULL of success is GNUNET_OK)

Definition at line 701 of file gnunet-service-reclaim.c.

{
  struct TicketIssueOperation *tio = cls;
 
  if (GNUNET_OK != success)
  {
    send_ticket_result (tio->client, tio->r_id, NULL, NULL, GNUNET_SYSERR);
    GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head,
                                 tio->client->issue_op_tail,
                                 tio);
    GNUNET_free (tio);
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error issuing ticket: %s\n", emsg);
    return;
  }
  send_ticket_result (tio->client, tio->r_id,
                      ticket, presentations, GNUNET_SYSERR);
  GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head,
                               tio->client->issue_op_tail,
                               tio);
  GNUNET_free (tio);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, send_ticket_result(), ticket, and tio.

Referenced by handle_issue_ticket_message().

Here is the call graph for this function:

Here is the caller graph for this function:

check_issue_ticket_message()

static int check_issue_ticket_message ( void *  cls, const struct IssueTicketMessage *  im  )

static

Check issue ticket message.

Parameters

cls	unused
im	message to check

Returns

GNUNET_OK if message is ok

Definition at line 736 of file gnunet-service-reclaim.c.

{
  uint16_t size;
  size_t attrs_len;
  size_t key_len;
  size_t rp_len;
 
  size = ntohs (im->header.size);
  attrs_len = ntohs (im->attr_len);
  key_len = ntohs (im->key_len);
  rp_len = ntohs (im->rp_uri_len);
  if (size != attrs_len + key_len + rp_len + sizeof(struct
                                                    IssueTicketMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References IssueTicketMessage::attr_len, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, IssueTicketMessage::header, IssueTicketMessage::key_len, IssueTicketMessage::rp_uri_len, GNUNET_MessageHeader::size, and size.

handle_issue_ticket_message()

static void handle_issue_ticket_message ( void *  cls, const struct IssueTicketMessage *  im  )

static

Handle ticket issue message.

Parameters

cls	our client
im	the message

Definition at line 764 of file gnunet-service-reclaim.c.

{
  struct TicketIssueOperation *tio;
  struct IdpClient *idp = cls;
  struct GNUNET_RECLAIM_AttributeList *attrs;
  struct GNUNET_RECLAIM_AttributeListEntry *le;
  struct GNUNET_CRYPTO_BlindablePrivateKey identity;
  const char *rp;
  size_t attrs_len;
  size_t key_len;
  size_t rp_len;
  size_t read;
  char *buf;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ISSUE_TICKET message\n");
  key_len = ntohs (im->key_len);
  buf = (char *) &im[1];
  if ((GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_private_key_from_buffer (buf, key_len,
                                                   &identity, &read)) ||
      (read != key_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read private key\n");
    GNUNET_SERVICE_client_drop (idp->client);
    return;
  }
  buf += read;
  rp_len = ntohs (im->rp_uri_len);
  rp = buf;
  buf += rp_len;
  tio = GNUNET_new (struct TicketIssueOperation);
  attrs_len = ntohs (im->attr_len);
  attrs = GNUNET_RECLAIM_attribute_list_deserialize (buf,
                                                     attrs_len);
  for (le = attrs->list_head; NULL != le; le = le->next)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "List entry: %s\n", le->attribute->name);
 
  tio->r_id = ntohl (im->id);
  tio->client = idp;
  GNUNET_CONTAINER_DLL_insert (idp->issue_op_head, idp->issue_op_tail, tio);
  RECLAIM_TICKETS_issue (&identity,
                         attrs,
                         rp,
                         &issue_ticket_result_cb,
                         tio);
  GNUNET_SERVICE_client_continue (idp->client);
  GNUNET_RECLAIM_attribute_list_destroy (attrs);
}

References IssueTicketMessage::attr_len, GNUNET_RECLAIM_AttributeListEntry::attribute, GNUNET_RECLAIM_Handle::client, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_new, GNUNET_RECLAIM_attribute_list_deserialize(), GNUNET_RECLAIM_attribute_list_destroy(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, IssueTicketMessage::id, identity, idp, issue_ticket_result_cb(), IssueTicketMessage::key_len, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_Attribute::name, GNUNET_RECLAIM_AttributeListEntry::next, RECLAIM_TICKETS_issue(), rp, IssueTicketMessage::rp_uri_len, and tio.

Here is the call graph for this function:

revoke_result_cb()

static void revoke_result_cb ( void *  cls, int32_t  success  )

static

Handles revocation result.

Parameters

cls	our revocation operation handle
success	revocation result (GNUNET_OK if successful)

Definition at line 827 of file gnunet-service-reclaim.c.

{
  struct TicketRevocationOperation *rop = cls;
  struct GNUNET_MQ_Envelope *env;
  struct RevokeTicketResultMessage *trm;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending REVOKE_TICKET_RESULT message\n");
  rop->rh = NULL;
  env = GNUNET_MQ_msg (trm, GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT);
  trm->id = htonl (rop->r_id);
  trm->success = htonl (success);
  GNUNET_MQ_send (rop->client->mq, env);
  GNUNET_CONTAINER_DLL_remove (rop->client->revoke_op_head,
                               rop->client->revoke_op_tail,
                               rop);
  GNUNET_free (rop);
}

References TicketRevocationOperation::client, env, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), RevokeTicketResultMessage::id, IdpClient::mq, TicketRevocationOperation::r_id, IdpClient::revoke_op_head, IdpClient::revoke_op_tail, TicketRevocationOperation::rh, and RevokeTicketResultMessage::success.

Referenced by handle_revoke_ticket_message().

Here is the call graph for this function:

Here is the caller graph for this function:

check_revoke_ticket_message()

static int check_revoke_ticket_message ( void *  cls, const struct RevokeTicketMessage *  rm  )

static

Check revocation message format.

Parameters

cls	unused
rm	the message to check

Returns

GNUNET_OK if message is ok

Definition at line 855 of file gnunet-service-reclaim.c.

{
  uint16_t size;
  size_t key_len;
  size_t tkt_len;
 
  size = ntohs (rm->header.size);
  key_len = ntohs (rm->key_len);
  tkt_len = ntohs (rm->tkt_len);
 
  if (size != sizeof(struct RevokeTicketMessage) + key_len + tkt_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, RevokeTicketMessage::header, RevokeTicketMessage::key_len, GNUNET_MessageHeader::size, size, and RevokeTicketMessage::tkt_len.

handle_revoke_ticket_message()

static void handle_revoke_ticket_message ( void *  cls, const struct RevokeTicketMessage *  rm  )

static

Handle a revocation message to a ticket.

Parameters

cls	our client
rm	the message to handle

Definition at line 881 of file gnunet-service-reclaim.c.

{
  struct TicketRevocationOperation *rop;
  struct IdpClient *idp = cls;
  struct GNUNET_CRYPTO_BlindablePrivateKey identity;
  struct GNUNET_RECLAIM_Ticket *ticket;
  size_t key_len;
  size_t read;
  char *buf;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received REVOKE_TICKET message\n");
  key_len = ntohs (rm->key_len);
  buf = (char *) &rm[1];
  if ((GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_private_key_from_buffer (buf, key_len,
                                                   &identity, &read)) ||
      (read != key_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read private key\n");
    GNUNET_SERVICE_client_drop (idp->client);
    return;
  }
  buf += read;
  ticket = (struct GNUNET_RECLAIM_Ticket *) buf;
  rop = GNUNET_new (struct TicketRevocationOperation);
  rop->r_id = ntohl (rm->id);
  rop->client = idp;
  GNUNET_CONTAINER_DLL_insert (idp->revoke_op_head, idp->revoke_op_tail, rop);
  rop->rh
    = RECLAIM_TICKETS_revoke (ticket, &identity, &revoke_result_cb, rop);
  GNUNET_SERVICE_client_continue (idp->client);
}

References TicketRevocationOperation::client, GNUNET_RECLAIM_Handle::client, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, RevokeTicketMessage::id, identity, idp, RevokeTicketMessage::key_len, TicketRevocationOperation::r_id, RECLAIM_TICKETS_revoke(), revoke_result_cb(), TicketRevocationOperation::rh, and ticket.

Here is the call graph for this function:

consume_result_cb()

static void consume_result_cb ( void *  cls, const struct GNUNET_CRYPTO_BlindablePublicKey *  identity, const struct GNUNET_RECLAIM_AttributeList *  attrs, const struct GNUNET_RECLAIM_PresentationList *  presentations, int32_t  success, const char *  emsg  )

static

Handle a ticket consume result.

Parameters

cls	our consume ticket operation handle
identity	the attribute authority
attrs	the attribute/claim list
success	GNUNET_OK if successful
emsg	error message (NULL if success=GNUNET_OK)

Definition at line 926 of file gnunet-service-reclaim.c.

{
  struct ConsumeTicketOperation *cop = cls;
  struct ConsumeTicketResultMessage *crm;
  struct GNUNET_MQ_Envelope *env;
  char *data_tmp;
  size_t attrs_len = 0;
  size_t pres_len = 0;
  size_t key_len;
  ssize_t written;
 
  if (GNUNET_OK != success)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error consuming ticket: %s\n", emsg);
  }
  attrs_len = GNUNET_RECLAIM_attribute_list_serialize_get_size (attrs);
  pres_len = GNUNET_RECLAIM_presentation_list_serialize_get_size (
    presentations);
  key_len = GNUNET_CRYPTO_public_key_get_length (identity);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending CONSUME_TICKET_RESULT message\n");
  env = GNUNET_MQ_msg_extra (crm,
                             attrs_len + pres_len + key_len,
                             GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT);
  crm->id = htonl (cop->r_id);
  crm->attrs_len = htons (attrs_len);
  crm->presentations_len = htons (pres_len);
  crm->key_len = htons (key_len);
  crm->result = htons (success);
  data_tmp = (char *) &crm[1];
  written = GNUNET_CRYPTO_write_blindable_pk_to_buffer (identity,
                                                        data_tmp,
                                                        key_len);
  GNUNET_assert (0 <= written);
  data_tmp += written;
  GNUNET_RECLAIM_attribute_list_serialize (attrs, data_tmp);
  data_tmp += attrs_len;
  GNUNET_RECLAIM_presentation_list_serialize (presentations, data_tmp);
  GNUNET_MQ_send (cop->client->mq, env);
  GNUNET_CONTAINER_DLL_remove (cop->client->consume_op_head,
                               cop->client->consume_op_tail,
                               cop);
  GNUNET_free (cop);
}

References ConsumeTicketResultMessage::attrs_len, ConsumeTicketOperation::client, IdpClient::consume_op_head, IdpClient::consume_op_tail, env, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CRYPTO_public_key_get_length(), GNUNET_CRYPTO_write_blindable_pk_to_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_OK, GNUNET_RECLAIM_attribute_list_serialize(), GNUNET_RECLAIM_attribute_list_serialize_get_size(), GNUNET_RECLAIM_presentation_list_serialize(), GNUNET_RECLAIM_presentation_list_serialize_get_size(), ConsumeTicketResultMessage::id, identity, ConsumeTicketResultMessage::key_len, IdpClient::mq, ConsumeTicketResultMessage::presentations_len, ConsumeTicketOperation::r_id, and ConsumeTicketResultMessage::result.

Referenced by handle_consume_ticket_message().

Here is the call graph for this function:

Here is the caller graph for this function:

check_consume_ticket_message()

static int check_consume_ticket_message ( void *  cls, const struct ConsumeTicketMessage *  cm  )

static

Check a consume ticket message.

Parameters

cls	unused
cm	the message to handle

Definition at line 984 of file gnunet-service-reclaim.c.

{
  uint16_t size;
  uint16_t tkt_size;
  uint16_t rp_uri_size;
 
  size = ntohs (cm->header.size);
  tkt_size = ntohs (cm->tkt_len);
  rp_uri_size = ntohs (cm->rp_uri_len);
  if (size < sizeof(struct ConsumeTicketMessage) + tkt_size + rp_uri_size)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, ConsumeTicketMessage::header, ConsumeTicketMessage::rp_uri_len, GNUNET_MessageHeader::size, size, and ConsumeTicketMessage::tkt_len.

handle_consume_ticket_message()

static void handle_consume_ticket_message ( void *  cls, const struct ConsumeTicketMessage *  cm  )

static

Handle a consume ticket message.

Parameters

cls	our client handle
cm	the message to handle

Definition at line 1009 of file gnunet-service-reclaim.c.

{
  struct ConsumeTicketOperation *cop;
  struct IdpClient *idp = cls;
  struct GNUNET_RECLAIM_Ticket *ticket;
  char *buf;
  const char *rp_uri;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CONSUME_TICKET message\n");
  buf = (char*) &cm[1];
  ticket = (struct GNUNET_RECLAIM_Ticket *) buf;
  rp_uri = buf + ntohs (cm->tkt_len);
  cop = GNUNET_new (struct ConsumeTicketOperation);
  cop->r_id = ntohl (cm->id);
  cop->client = idp;
  cop->ch
    = RECLAIM_TICKETS_consume (ticket,
                               rp_uri,
                               &consume_result_cb,
                               cop);
  GNUNET_CONTAINER_DLL_insert (idp->consume_op_head, idp->consume_op_tail, cop);
  GNUNET_SERVICE_client_continue (idp->client);
}

References ConsumeTicketOperation::ch, ConsumeTicketOperation::client, GNUNET_RECLAIM_Handle::client, consume_result_cb(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_SERVICE_client_continue(), ConsumeTicketMessage::id, idp, ConsumeTicketOperation::r_id, RECLAIM_TICKETS_consume(), ticket, and ConsumeTicketMessage::tkt_len.

Here is the call graph for this function:

attr_store_cont()

static void attr_store_cont ( void *  cls, enum GNUNET_ErrorCode  ec  )

static

Attribute store result handler.

Parameters

cls	our attribute store handle
success	GNUNET_OK if successful
emsg	error message (NULL if success=GNUNET_OK)

Definition at line 1047 of file gnunet-service-reclaim.c.

{
  struct AttributeStoreHandle *ash = cls;
  struct GNUNET_MQ_Envelope *env;
  struct SuccessResultMessage *acr_msg;
 
  ash->ns_qe = NULL;
  GNUNET_CONTAINER_DLL_remove (ash->client->store_op_head,
                               ash->client->store_op_tail,
                               ash);
 
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to store attribute %s\n",
                GNUNET_ErrorCode_get_hint (ec));
    cleanup_as_handle (ash);
    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
  env = GNUNET_MQ_msg (acr_msg, GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE);
  acr_msg->id = htonl (ash->r_id);
  acr_msg->op_result = htonl (GNUNET_OK);
  GNUNET_MQ_send (ash->client->mq, env);
  cleanup_as_handle (ash);
}

References cleanup_as_handle(), AttributeStoreHandle::client, do_shutdown, env, GNUNET_CONTAINER_DLL_remove, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ErrorCode_get_hint(), GNUNET_log, GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), SuccessResultMessage::id, IdpClient::mq, AttributeStoreHandle::ns_qe, SuccessResultMessage::op_result, AttributeStoreHandle::r_id, IdpClient::store_op_head, and IdpClient::store_op_tail.

Referenced by attr_store_task().

Here is the call graph for this function:

Here is the caller graph for this function:

attr_store_task()

static void attr_store_task ( void *  cls )

static

Add a new attribute.

Parameters

cls	the AttributeStoreHandle

Definition at line 1083 of file gnunet-service-reclaim.c.

{
  struct AttributeStoreHandle *ash = cls;
  struct GNUNET_GNSRECORD_Data rd[1];
  char *buf;
  char *label;
  size_t buf_size;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing attribute\n");
  buf_size = GNUNET_RECLAIM_attribute_serialize_get_size (ash->claim);
  buf = GNUNET_malloc (buf_size);
  // Give the ash a new id if unset
  if (GNUNET_YES == GNUNET_RECLAIM_id_is_zero (&ash->claim->id))
    GNUNET_RECLAIM_id_generate (&ash->claim->id);
  GNUNET_RECLAIM_attribute_serialize (ash->claim, buf);
  label
    = GNUNET_STRINGS_data_to_string_alloc (&ash->claim->id,
                                           sizeof (ash->claim->id));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label);
 
  rd[0].data_size = buf_size;
  rd[0].data = buf;
  rd[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE;
  rd[0].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
  rd[0].expiration_time = ash->exp.rel_value_us;
  ash->ns_qe = GNUNET_NAMESTORE_record_set_store (nsh,
                                                  &ash->identity,
                                                  label,
                                                  1,
                                                  rd,
                                                  &attr_store_cont,
                                                  ash);
  GNUNET_free (buf);
  GNUNET_free (label);
}

References attr_store_cont(), AttributeStoreHandle::claim, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, AttributeStoreHandle::exp, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE, GNUNET_log, GNUNET_malloc, GNUNET_NAMESTORE_record_set_store(), GNUNET_RECLAIM_attribute_serialize(), GNUNET_RECLAIM_attribute_serialize_get_size(), GNUNET_RECLAIM_id_generate, GNUNET_RECLAIM_id_is_zero, GNUNET_STRINGS_data_to_string_alloc(), GNUNET_YES, GNUNET_RECLAIM_Attribute::id, AttributeStoreHandle::identity, AttributeStoreHandle::ns_qe, nsh, rd, GNUNET_GNSRECORD_Data::record_type, and GNUNET_TIME_Relative::rel_value_us.

Referenced by handle_attribute_store_message().

Here is the call graph for this function:

Here is the caller graph for this function:

check_attribute_store_message()

static int check_attribute_store_message ( void *  cls, const struct AttributeStoreMessage *  sam  )

static

Check an attribute store message.

Parameters

cls	unused
sam	the message to check

Definition at line 1127 of file gnunet-service-reclaim.c.

{
  uint16_t size;
 
  size = ntohs (sam->header.size);
  if (size <= sizeof(struct AttributeStoreMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, AttributeStoreMessage::header, GNUNET_MessageHeader::size, and size.

handle_attribute_store_message()

static void handle_attribute_store_message ( void *  cls, const struct AttributeStoreMessage *  sam  )

static

Handle an attribute store message.

Parameters

cls	our client
sam	the message to handle

Definition at line 1149 of file gnunet-service-reclaim.c.

{
  struct AttributeStoreHandle *ash;
  struct IdpClient *idp = cls;
  struct GNUNET_CRYPTO_BlindablePrivateKey identity;
  size_t data_len;
  size_t key_len;
  size_t read;
  char *buf;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_STORE message\n");
 
  data_len = ntohs (sam->attr_len);
  key_len = ntohs (sam->key_len);
  buf = (char *) &sam[1];
  if ((GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_private_key_from_buffer (buf, key_len,
                                                   &identity, &read)) ||
      (read != key_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read private key\n");
    GNUNET_SERVICE_client_drop (idp->client);
    return;
  }
  buf += read;
  ash = GNUNET_new (struct AttributeStoreHandle);
  GNUNET_RECLAIM_attribute_deserialize (buf,
                                        data_len,
                                        &ash->claim);
 
  ash->r_id = ntohl (sam->id);
  ash->identity = identity;
  ash->exp.rel_value_us = GNUNET_ntohll (sam->exp);
  GNUNET_CRYPTO_blindable_key_get_public (&identity, &ash->identity_pkey);
 
  GNUNET_SERVICE_client_continue (idp->client);
  ash->client = idp;
  GNUNET_CONTAINER_DLL_insert (idp->store_op_head, idp->store_op_tail, ash);
  GNUNET_SCHEDULER_add_now (&attr_store_task, ash);
}

References AttributeStoreMessage::attr_len, attr_store_task(), AttributeStoreHandle::claim, AttributeStoreHandle::client, GNUNET_RECLAIM_Handle::client, AttributeStoreHandle::exp, AttributeStoreMessage::exp, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_blindable_key_get_public(), GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_new, GNUNET_ntohll(), GNUNET_RECLAIM_attribute_deserialize(), GNUNET_SCHEDULER_add_now(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, AttributeStoreMessage::id, identity, AttributeStoreHandle::identity, AttributeStoreHandle::identity_pkey, idp, AttributeStoreMessage::key_len, AttributeStoreHandle::r_id, and GNUNET_TIME_Relative::rel_value_us.

Here is the call graph for this function:

cred_store_cont()

static void cred_store_cont ( void *  cls, enum GNUNET_ErrorCode  ec  )

static

Credential store result handler.

Parameters

cls	our attribute store handle
success	GNUNET_OK if successful
emsg	error message (NULL if success=GNUNET_OK)

Definition at line 1201 of file gnunet-service-reclaim.c.

{
  struct AttributeStoreHandle *ash = cls;
  struct GNUNET_MQ_Envelope *env;
  struct SuccessResultMessage *acr_msg;
 
  ash->ns_qe = NULL;
  GNUNET_CONTAINER_DLL_remove (ash->client->store_op_head,
                               ash->client->store_op_tail,
                               ash);
 
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to store credential: %s\n",
                GNUNET_ErrorCode_get_hint (ec));
    cleanup_as_handle (ash);
    GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
  env = GNUNET_MQ_msg (acr_msg, GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE);
  acr_msg->id = htonl (ash->r_id);
  acr_msg->op_result = htonl (GNUNET_OK);
  GNUNET_MQ_send (ash->client->mq, env);
  cleanup_as_handle (ash);
}

References cleanup_as_handle(), AttributeStoreHandle::client, do_shutdown, env, GNUNET_CONTAINER_DLL_remove, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ErrorCode_get_hint(), GNUNET_log, GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), SuccessResultMessage::id, IdpClient::mq, AttributeStoreHandle::ns_qe, SuccessResultMessage::op_result, AttributeStoreHandle::r_id, IdpClient::store_op_head, and IdpClient::store_op_tail.

Referenced by cred_add_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

cred_error()

static void cred_error ( void *  cls )

static

Error looking up potential credential.

Abort.

Parameters

cls	our attribute store handle

Definition at line 1237 of file gnunet-service-reclaim.c.

{
  struct AttributeStoreHandle *ash = cls;
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Failed to check for existing credential.\n");
  cleanup_as_handle (ash);
  GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
  return;
}

References cleanup_as_handle(), do_shutdown, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, and GNUNET_SCHEDULER_add_now().

Referenced by cred_store_task().

Here is the call graph for this function:

Here is the caller graph for this function:

cred_add_cb()

static void cred_add_cb ( void *  cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone, const char *  label, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Check for existing record before storing credential.

Parameters

cls	our attribute store handle
zone	zone we are iterating
label	label of the records
rd_count	record count
rd	records

Definition at line 1258 of file gnunet-service-reclaim.c.

{
  struct AttributeStoreHandle *ash = cls;
  struct GNUNET_GNSRECORD_Data rd_new[1];
  char *buf;
  size_t buf_size;
 
  buf_size = GNUNET_RECLAIM_credential_serialize_get_size (ash->credential);
  buf = GNUNET_malloc (buf_size);
  GNUNET_RECLAIM_credential_serialize (ash->credential, buf);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Storing new credential under `%s'.\n",
              label);
  rd_new[0].data_size = buf_size;
  rd_new[0].data = buf;
  rd_new[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL;
  rd_new[0].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
  rd_new[0].expiration_time = ash->exp.rel_value_us;
  ash->ns_qe = GNUNET_NAMESTORE_record_set_store (nsh,
                                                  &ash->identity,
                                                  label,
                                                  1,
                                                  rd_new,
                                                  &cred_store_cont,
                                                  ash);
  GNUNET_free (buf);
  return;
}

References cred_store_cont(), AttributeStoreHandle::credential, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, AttributeStoreHandle::exp, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL, GNUNET_log, GNUNET_malloc, GNUNET_NAMESTORE_record_set_store(), GNUNET_RECLAIM_credential_serialize(), GNUNET_RECLAIM_credential_serialize_get_size(), AttributeStoreHandle::identity, AttributeStoreHandle::ns_qe, nsh, GNUNET_GNSRECORD_Data::record_type, and GNUNET_TIME_Relative::rel_value_us.

Referenced by cred_store_task().

Here is the call graph for this function:

Here is the caller graph for this function:

cred_store_task()

static void cred_store_task ( void *  cls )

static

Add a new credential.

Parameters

cls	the AttributeStoreHandle

Definition at line 1298 of file gnunet-service-reclaim.c.

{
  struct AttributeStoreHandle *ash = cls;
  char *label;
 
  // Give the ash a new id if unset
  if (GNUNET_YES == GNUNET_RECLAIM_id_is_zero (&ash->credential->id))
    GNUNET_RECLAIM_id_generate (&ash->credential->id);
  label = GNUNET_STRINGS_data_to_string_alloc (&ash->credential->id,
                                               sizeof (ash->credential->id));
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Looking up existing data under label `%s'\n", label);
  ash->ns_qe = GNUNET_NAMESTORE_records_lookup (nsh,
                                                &ash->identity,
                                                label,
                                                &cred_error,
                                                ash,
                                                &cred_add_cb,
                                                ash);
  GNUNET_free (label);
}

References cred_add_cb(), cred_error(), AttributeStoreHandle::credential, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NAMESTORE_records_lookup(), GNUNET_RECLAIM_id_generate, GNUNET_RECLAIM_id_is_zero, GNUNET_STRINGS_data_to_string_alloc(), GNUNET_YES, GNUNET_RECLAIM_Credential::id, AttributeStoreHandle::identity, AttributeStoreHandle::ns_qe, and nsh.

Referenced by handle_credential_store_message().

Here is the call graph for this function:

Here is the caller graph for this function:

check_credential_store_message()

static int check_credential_store_message ( void *  cls, const struct AttributeStoreMessage *  sam  )

static

Check an credential store message.

Parameters

cls	unused
sam	the message to check

Definition at line 1328 of file gnunet-service-reclaim.c.

{
  uint16_t size;
 
  size = ntohs (sam->header.size);
  if (size <= sizeof(struct AttributeStoreMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, AttributeStoreMessage::header, GNUNET_MessageHeader::size, and size.

handle_credential_store_message()

static void handle_credential_store_message ( void *  cls, const struct AttributeStoreMessage *  sam  )

static

Handle a credential store message.

Parameters

cls	our client
sam	the message to handle

Definition at line 1350 of file gnunet-service-reclaim.c.

{
  struct AttributeStoreHandle *ash;
  struct IdpClient *idp = cls;
  struct GNUNET_CRYPTO_BlindablePrivateKey identity;
  size_t data_len;
  size_t key_len;
  size_t read;
  char *buf;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREDENTIAL_STORE message\n");
 
  data_len = ntohs (sam->attr_len);
  key_len = ntohs (sam->key_len);
  buf = (char *) &sam[1];
  if ((GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_private_key_from_buffer (buf, key_len,
                                                   &identity, &read)) ||
      (read != key_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read private key\n");
    GNUNET_SERVICE_client_drop (idp->client);
    return;
  }
  buf += read;
  ash = GNUNET_new (struct AttributeStoreHandle);
  ash->credential = GNUNET_RECLAIM_credential_deserialize (buf,
                                                           data_len);
 
  ash->r_id = ntohl (sam->id);
  ash->identity = identity;
  ash->exp.rel_value_us = GNUNET_ntohll (sam->exp);
  GNUNET_CRYPTO_blindable_key_get_public (&identity, &ash->identity_pkey);
 
  GNUNET_SERVICE_client_continue (idp->client);
  ash->client = idp;
  GNUNET_CONTAINER_DLL_insert (idp->store_op_head, idp->store_op_tail, ash);
  GNUNET_SCHEDULER_add_now (&cred_store_task, ash);
}

References AttributeStoreMessage::attr_len, AttributeStoreHandle::client, GNUNET_RECLAIM_Handle::client, cred_store_task(), AttributeStoreHandle::credential, AttributeStoreHandle::exp, AttributeStoreMessage::exp, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_blindable_key_get_public(), GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_new, GNUNET_ntohll(), GNUNET_RECLAIM_credential_deserialize(), GNUNET_SCHEDULER_add_now(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, AttributeStoreMessage::id, identity, AttributeStoreHandle::identity, AttributeStoreHandle::identity_pkey, idp, AttributeStoreMessage::key_len, AttributeStoreHandle::r_id, and GNUNET_TIME_Relative::rel_value_us.

Here is the call graph for this function:

send_delete_response()

static void send_delete_response ( struct AttributeDeleteHandle *  adh, int32_t  success  )

static

Send a deletion success response.

Parameters

adh	our attribute deletion handle
success	the success status

Definition at line 1400 of file gnunet-service-reclaim.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct SuccessResultMessage *acr_msg;
 
  GNUNET_CONTAINER_DLL_remove (adh->client->delete_op_head,
                               adh->client->delete_op_tail,
                               adh);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
  env = GNUNET_MQ_msg (acr_msg, GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE);
  acr_msg->id = htonl (adh->r_id);
  acr_msg->op_result = htonl (success);
  GNUNET_MQ_send (adh->client->mq, env);
}

References AttributeDeleteHandle::client, IdpClient::delete_op_head, IdpClient::delete_op_tail, env, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE, GNUNET_MQ_msg, GNUNET_MQ_send(), SuccessResultMessage::id, IdpClient::mq, SuccessResultMessage::op_result, and AttributeDeleteHandle::r_id.

Referenced by attr_delete_cont(), consistency_iter_err(), cred_delete_cont(), offending_attr_delete_cont(), and update_tickets().

Here is the call graph for this function:

Here is the caller graph for this function:

consistency_iter()

static void consistency_iter ( void *  cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone, const char *  label, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Namestore iteration within attribute deletion.

We need to reissue tickets with the deleted attribute removed.

Parameters

cls	our attribute deletion handle
zone	the private key of the ticket issuer
label	the label of the record
rd_count	number of records
rd	record data

Definition at line 1428 of file gnunet-service-reclaim.c.

{
  struct AttributeDeleteHandle *adh = cls;
  struct TicketRecordsEntry *le;
  struct GNUNET_RECLAIM_AttributeListEntry *ale;
  struct GNUNET_RECLAIM_CredentialListEntry *cle;
  int is_ticket = GNUNET_NO;
  for (int i = 0; i < rd_count; i++)
  {
    switch (rd[i].record_type)
    {
    case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE:
      ale = GNUNET_new (struct GNUNET_RECLAIM_AttributeListEntry);
      GNUNET_RECLAIM_attribute_deserialize (rd[i].data,
                                            rd[i].data_size,
                                            &ale->attribute);
      GNUNET_CONTAINER_DLL_insert (adh->existing_attributes->list_head,
                                   adh->existing_attributes->list_tail,
                                   ale);
      break;
    case GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL:
      cle = GNUNET_new (struct GNUNET_RECLAIM_CredentialListEntry);
      cle->credential = GNUNET_RECLAIM_credential_deserialize (rd[i].data,
                                                               rd[i].data_size);
      GNUNET_CONTAINER_DLL_insert (adh->existing_credentials->list_head,
                                   adh->existing_credentials->list_tail,
                                   cle);
      break;
    case GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET:
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Ticket to delete found (%s)\n",
                  label);
      is_ticket = GNUNET_YES;
      break;
    default:
      break;
    }
    if (GNUNET_YES == is_ticket)
      break;
  }
  if (GNUNET_YES == is_ticket)
  {
    le = GNUNET_new (struct TicketRecordsEntry);
    le->data_size = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
    le->data = GNUNET_malloc (le->data_size);
    le->rd_count = rd_count;
    le->label = GNUNET_strdup (label);
    GNUNET_GNSRECORD_records_serialize (rd_count, rd, le->data_size, le->data);
    GNUNET_CONTAINER_DLL_insert (adh->tickets_to_update_head,
                                 adh->tickets_to_update_tail,
                                 le);
  }
  GNUNET_NAMESTORE_zone_iterator_next (adh->ns_it, 1);
}

References GNUNET_RECLAIM_AttributeListEntry::attribute, GNUNET_RECLAIM_CredentialListEntry::credential, data, TicketRecordsEntry::data, data_size, TicketRecordsEntry::data_size, AttributeDeleteHandle::existing_attributes, AttributeDeleteHandle::existing_credentials, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE, GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL, GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET, GNUNET_log, GNUNET_malloc, GNUNET_NAMESTORE_zone_iterator_next(), GNUNET_new, GNUNET_NO, GNUNET_RECLAIM_attribute_deserialize(), GNUNET_RECLAIM_credential_deserialize(), GNUNET_strdup, GNUNET_YES, TicketRecordsEntry::label, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_CredentialList::list_head, GNUNET_RECLAIM_AttributeList::list_tail, GNUNET_RECLAIM_CredentialList::list_tail, AttributeDeleteHandle::ns_it, rd, rd_count, TicketRecordsEntry::rd_count, AttributeDeleteHandle::tickets_to_update_head, and AttributeDeleteHandle::tickets_to_update_tail.

Referenced by start_consistency_update().

Here is the call graph for this function:

Here is the caller graph for this function:

update_tickets()

static void update_tickets ( void *  cls )

static

Recursion prototype for function.

Update tickets: Remove shared attribute which has just been deleted.

Parameters

cls	our deletion handle

This method is called recursively until all tickets are processed. Eventually, the updated tickets are stored using `‘update_tickets’'.

Parameters

cls	our attribute deletion handle

Definition at line 1521 of file gnunet-service-reclaim.c.

{
  struct AttributeDeleteHandle *adh = cls;
  struct TicketRecordsEntry *le;
  int j = 0;
  int i = 0;
  struct GNUNET_RECLAIM_AttributeListEntry *ale;
  struct GNUNET_RECLAIM_CredentialListEntry *cle;
  struct GNUNET_RECLAIM_Presentation *presentation;
 
  if (NULL == adh->tickets_to_update_head)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Finished updating tickets, success\n");
    send_delete_response (adh, GNUNET_OK);
    cleanup_adh (adh);
    return;
  }
  le = adh->tickets_to_update_head;
  GNUNET_CONTAINER_DLL_remove (adh->tickets_to_update_head,
                               adh->tickets_to_update_tail,
                               le);
  {
    struct GNUNET_GNSRECORD_Data rd[le->rd_count];
    struct GNUNET_GNSRECORD_Data rd_new[le->rd_count - 1];
    if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize (le->data_size,
                                                           le->data,
                                                           le->rd_count,
                                                           rd))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Unable to deserialize record data!\n");
      send_delete_response (adh, GNUNET_SYSERR);
      cleanup_adh (adh);
      return;
    }
    for (i = 0; i < le->rd_count; i++)
    {
      switch (rd[i].record_type)
      {
      case GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF:
        for (ale = adh->existing_attributes->list_head; NULL != ale; ale =
               ale->next)
        {
          if (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (rd[i].data,
                                                        &ale->attribute->id))
          {
            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                        "Found attribute %s, re-adding...\n",
                        ale->attribute->name);
            rd_new[j] = rd[i];
            j++;
            break; // Found and added
          }
        }
        break;
      case GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION:
        presentation = GNUNET_RECLAIM_presentation_deserialize (rd[i].data,
                                                                rd[i].data_size)
        ;
        for (cle = adh->existing_credentials->list_head; NULL != cle; cle =
               cle->next)
        {
          if (GNUNET_YES == GNUNET_RECLAIM_id_is_equal (
                &presentation->credential_id,
                &cle->credential->id))
          {
            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                        "Found presentation for credential %s, re-adding...\n",
                        cle->credential->name);
            rd_new[j] = rd[i];
            j++;
            break; // Found and added
          }
        }
        GNUNET_free (presentation);
        break;
      case GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET:
        rd_new[j] = rd[i];
        j++;
        break; // Found and added
      default:
        GNUNET_break (0);
      }
    }
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Updating ticket with %d entries (%d before)...\n",
                j, i);
    adh->ns_qe = GNUNET_NAMESTORE_record_set_store (nsh,
                                                    &adh->identity,
                                                    le->label,
                                                    j,
                                                    rd_new,
                                                    &ticket_updated,
                                                    adh);
    GNUNET_free (le->label);
    GNUNET_free (le->data);
    GNUNET_free (le);
  }
}

References GNUNET_RECLAIM_AttributeListEntry::attribute, cleanup_adh(), GNUNET_RECLAIM_CredentialListEntry::credential, GNUNET_RECLAIM_Presentation::credential_id, data, GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, AttributeDeleteHandle::existing_attributes, AttributeDeleteHandle::existing_credentials, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNSRECORD_records_deserialize(), GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF, GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION, GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET, GNUNET_log, GNUNET_NAMESTORE_record_set_store(), GNUNET_OK, GNUNET_RECLAIM_id_is_equal, GNUNET_RECLAIM_presentation_deserialize(), GNUNET_SYSERR, GNUNET_YES, GNUNET_RECLAIM_Attribute::id, GNUNET_RECLAIM_Credential::id, AttributeDeleteHandle::identity, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_CredentialList::list_head, GNUNET_RECLAIM_Attribute::name, GNUNET_RECLAIM_Credential::name, GNUNET_RECLAIM_AttributeListEntry::next, GNUNET_RECLAIM_CredentialListEntry::next, AttributeDeleteHandle::ns_qe, nsh, rd, rd_count, GNUNET_GNSRECORD_Data::record_type, send_delete_response(), ticket_updated(), AttributeDeleteHandle::tickets_to_update_head, and AttributeDeleteHandle::tickets_to_update_tail.

Referenced by purge_attributes(), and ticket_updated().

Here is the call graph for this function:

Here is the caller graph for this function:

ticket_updated()

static void ticket_updated ( void *  cls, enum GNUNET_ErrorCode  ec  )

static

Callback called when a ticket was updated.

Parameters

cls	our attribute deletion handle
success	GNUNET_OK if successful
emsg	error message (NULL if success=GNUNET_OK)

Definition at line 1504 of file gnunet-service-reclaim.c.

{
  struct AttributeDeleteHandle *adh = cls;
 
  adh->ns_qe = NULL;
  GNUNET_SCHEDULER_add_now (&update_tickets, adh);
}

References GNUNET_SCHEDULER_add_now(), AttributeDeleteHandle::ns_qe, and update_tickets().

Referenced by update_tickets().

Here is the call graph for this function:

Here is the caller graph for this function:

purge_attributes()

static void purge_attributes ( void *  cls )

static

Delete all attributes which reference credentials that no longer exist.

Definition at line 1656 of file gnunet-service-reclaim.c.

{
  struct AttributeDeleteHandle *adh = cls;
  struct GNUNET_RECLAIM_AttributeListEntry *ale;
  struct GNUNET_RECLAIM_CredentialListEntry *cle;
  char *label;
 
  for (ale = adh->existing_attributes->list_head; NULL != ale; ale = ale->next)
  {
    if (GNUNET_YES ==
        GNUNET_RECLAIM_id_is_zero (&ale->attribute->credential))
      continue;
 
    for (cle = adh->existing_credentials->list_head;
         NULL != cle; cle = cle->next)
    {
      if (GNUNET_YES !=
          GNUNET_RECLAIM_id_is_equal (&cle->credential->id,
                                      &ale->attribute->credential))
        continue;
      break;
    }
    if (NULL == cle)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Found attribute with missing credential\n");
      break;
    }
  }
  if (NULL == ale)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Attributes consistent, updating tickets.\n");
    GNUNET_SCHEDULER_add_now (&update_tickets, adh);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Attributes inconsistent, deleting offending attribute.\n");
  label = GNUNET_STRINGS_data_to_string_alloc (&ale->attribute->id,
                                               sizeof(ale->attribute->id));
 
  adh->ns_qe = GNUNET_NAMESTORE_record_set_store (nsh,
                                                  &adh->identity,
                                                  label,
                                                  0,
                                                  NULL,
                                                  &offending_attr_delete_cont,
                                                  adh);
  GNUNET_CONTAINER_DLL_remove (adh->existing_attributes->list_head,
                               adh->existing_attributes->list_tail,
                               ale);
  GNUNET_free (ale);
  GNUNET_free (label);
}

References GNUNET_RECLAIM_AttributeListEntry::attribute, GNUNET_RECLAIM_Attribute::credential, GNUNET_RECLAIM_CredentialListEntry::credential, AttributeDeleteHandle::existing_attributes, AttributeDeleteHandle::existing_credentials, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_NAMESTORE_record_set_store(), GNUNET_RECLAIM_id_is_equal, GNUNET_RECLAIM_id_is_zero, GNUNET_SCHEDULER_add_now(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_YES, GNUNET_RECLAIM_Attribute::id, GNUNET_RECLAIM_Credential::id, AttributeDeleteHandle::identity, GNUNET_RECLAIM_AttributeList::list_head, GNUNET_RECLAIM_CredentialList::list_head, GNUNET_RECLAIM_AttributeList::list_tail, GNUNET_RECLAIM_AttributeListEntry::next, GNUNET_RECLAIM_CredentialListEntry::next, AttributeDeleteHandle::ns_qe, nsh, offending_attr_delete_cont(), and update_tickets().

Referenced by consistency_iter_fin(), and offending_attr_delete_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

offending_attr_delete_cont()

static void offending_attr_delete_cont ( void *  cls, enum GNUNET_ErrorCode  ec  )

static

Definition at line 1632 of file gnunet-service-reclaim.c.

{
  struct AttributeDeleteHandle *adh = cls;
 
  adh->ns_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Error deleting attribute %s\n",
                adh->label);
    send_delete_response (adh, GNUNET_SYSERR);
    cleanup_adh (adh);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Continuing consistency check...\n");
  GNUNET_SCHEDULER_add_now (&purge_attributes, adh);
}

References cleanup_adh(), GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, AttributeDeleteHandle::label, AttributeDeleteHandle::ns_qe, purge_attributes(), and send_delete_response().

Referenced by purge_attributes().

Here is the call graph for this function:

Here is the caller graph for this function:

consistency_iter_fin()

static void consistency_iter_fin ( void *  cls )

static

Done collecting affected tickets, start updating.

Parameters

cls	our attribute deletion handle

Definition at line 1718 of file gnunet-service-reclaim.c.

{
  struct AttributeDeleteHandle *adh = cls;
  adh->ns_it = NULL;
  GNUNET_SCHEDULER_add_now (&purge_attributes, adh);
}

References GNUNET_SCHEDULER_add_now(), AttributeDeleteHandle::ns_it, and purge_attributes().

Referenced by start_consistency_update().

Here is the call graph for this function:

Here is the caller graph for this function:

consistency_iter_err()

static void consistency_iter_err ( void *  cls )

static

Error collecting affected tickets.

Abort.

Parameters

cls	our attribute deletion handle

Definition at line 1732 of file gnunet-service-reclaim.c.

{
  struct AttributeDeleteHandle *adh = cls;
 
  adh->ns_it = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Namestore error on consistency check\n");
  send_delete_response (adh, GNUNET_SYSERR);
  cleanup_adh (adh);
}

References cleanup_adh(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SYSERR, AttributeDeleteHandle::ns_it, and send_delete_response().

Referenced by start_consistency_update().

Here is the call graph for this function:

Here is the caller graph for this function:

start_consistency_update()

static void start_consistency_update ( void *  cls )

static

Start processing tickets which may still contain reference to deleted attribute.

Parameters

cls	attribute deletion handle

Definition at line 1751 of file gnunet-service-reclaim.c.

{
  struct AttributeDeleteHandle *adh = cls;
 
  adh->existing_attributes = GNUNET_new (struct GNUNET_RECLAIM_AttributeList);
  adh->existing_credentials = GNUNET_new (struct GNUNET_RECLAIM_CredentialList);
 
  adh->ns_it = GNUNET_NAMESTORE_zone_iteration_start (nsh,
                                                      &adh->identity,
                                                      &consistency_iter_err,
                                                      adh,
                                                      &consistency_iter,
                                                      adh,
                                                      &consistency_iter_fin,
                                                      adh);
}

References consistency_iter(), consistency_iter_err(), consistency_iter_fin(), AttributeDeleteHandle::existing_attributes, AttributeDeleteHandle::existing_credentials, GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_new, AttributeDeleteHandle::identity, AttributeDeleteHandle::ns_it, and nsh.

Referenced by attr_delete_cont(), and cred_delete_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

attr_delete_cont()

static void attr_delete_cont ( void *  cls, enum GNUNET_ErrorCode  ec  )

static

Attribute deleted callback.

Parameters

cls	our handle
success	success status
emsg	error message (NULL if success=GNUNET_OK)

Definition at line 1777 of file gnunet-service-reclaim.c.

{
  struct AttributeDeleteHandle *adh = cls;
 
  adh->ns_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Error deleting attribute %s\n",
                adh->label);
    send_delete_response (adh, GNUNET_SYSERR);
    cleanup_adh (adh);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating tickets...\n");
  GNUNET_SCHEDULER_add_now (&start_consistency_update, adh);
}

References cleanup_adh(), GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, AttributeDeleteHandle::label, AttributeDeleteHandle::ns_qe, send_delete_response(), and start_consistency_update().

Referenced by handle_attribute_delete_message().

Here is the call graph for this function:

Here is the caller graph for this function:

check_attribute_delete_message()

static int check_attribute_delete_message ( void *  cls, const struct AttributeDeleteMessage *  dam  )

static

Check attribute delete message format.

Parameters

cls	unused
dam	message to check

Definition at line 1803 of file gnunet-service-reclaim.c.

{
  uint16_t size;
 
  size = ntohs (dam->header.size);
  if (size <= sizeof(struct AttributeDeleteMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, AttributeDeleteMessage::header, GNUNET_MessageHeader::size, and size.

handle_attribute_delete_message()

static void handle_attribute_delete_message ( void *  cls, const struct AttributeDeleteMessage *  dam  )

static

Handle attribute deletion.

Parameters

cls	our client
dam	deletion message

Definition at line 1825 of file gnunet-service-reclaim.c.

{
  struct AttributeDeleteHandle *adh;
  struct IdpClient *idp = cls;
  struct GNUNET_CRYPTO_BlindablePrivateKey identity;
  size_t data_len;
  size_t key_len;
  size_t read;
  char *buf;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_DELETE message\n");
 
  data_len = ntohs (dam->attr_len);
  key_len = ntohs (dam->key_len);
  buf = (char *) &dam[1];
  if ((GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_private_key_from_buffer (buf, key_len,
                                                   &identity, &read)) ||
      (read != key_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read private key\n");
    GNUNET_SERVICE_client_drop (idp->client);
    return;
  }
  buf += read;
  adh = GNUNET_new (struct AttributeDeleteHandle);
  GNUNET_RECLAIM_attribute_deserialize (buf,
                                        data_len,
                                        &adh->claim);
  adh->credential = NULL;
 
  adh->r_id = ntohl (dam->id);
  adh->identity = identity;
  adh->label
    = GNUNET_STRINGS_data_to_string_alloc (&adh->claim->id,
                                           sizeof(adh->claim->id));
  GNUNET_SERVICE_client_continue (idp->client);
  adh->client = idp;
  GNUNET_CONTAINER_DLL_insert (idp->delete_op_head, idp->delete_op_tail, adh);
  adh->ns_qe = GNUNET_NAMESTORE_record_set_store (nsh,
                                                  &adh->identity,
                                                  adh->label,
                                                  0,
                                                  NULL,
                                                  &attr_delete_cont,
                                                  adh);
}

References attr_delete_cont(), AttributeDeleteMessage::attr_len, AttributeDeleteHandle::claim, AttributeDeleteHandle::client, GNUNET_RECLAIM_Handle::client, AttributeDeleteHandle::credential, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NAMESTORE_record_set_store(), GNUNET_new, GNUNET_RECLAIM_attribute_deserialize(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_SYSERR, GNUNET_RECLAIM_Attribute::id, AttributeDeleteMessage::id, identity, AttributeDeleteHandle::identity, idp, AttributeDeleteMessage::key_len, AttributeDeleteHandle::label, AttributeDeleteHandle::ns_qe, nsh, and AttributeDeleteHandle::r_id.

Here is the call graph for this function:

cred_delete_cont()

static void cred_delete_cont ( void *  cls, enum GNUNET_ErrorCode  ec  )

static

Credential deleted callback.

Parameters

cls	our handle
success	success status
emsg	error message (NULL if success=GNUNET_OK)

Definition at line 1884 of file gnunet-service-reclaim.c.

{
  struct AttributeDeleteHandle *adh = cls;
 
  adh->ns_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Error deleting credential `%s'\n",
                adh->label);
    send_delete_response (adh, GNUNET_SYSERR);
    cleanup_adh (adh);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating tickets...\n");
  GNUNET_SCHEDULER_add_now (&start_consistency_update, adh);
}

References cleanup_adh(), GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SYSERR, AttributeDeleteHandle::label, AttributeDeleteHandle::ns_qe, send_delete_response(), and start_consistency_update().

Referenced by handle_credential_delete_message().

Here is the call graph for this function:

Here is the caller graph for this function:

check_credential_delete_message()

static int check_credential_delete_message ( void *  cls, const struct AttributeDeleteMessage *  dam  )

static

Check credential delete message format.

Parameters

cls	unused
dam	message to check

Definition at line 1910 of file gnunet-service-reclaim.c.

{
  uint16_t size;
 
  size = ntohs (dam->header.size);
  if (size <= sizeof(struct AttributeDeleteMessage))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, AttributeDeleteMessage::header, GNUNET_MessageHeader::size, and size.

handle_credential_delete_message()

static void handle_credential_delete_message ( void *  cls, const struct AttributeDeleteMessage *  dam  )

static

Handle credential deletion.

Parameters

cls	our client
dam	deletion message

Definition at line 1932 of file gnunet-service-reclaim.c.

{
  struct AttributeDeleteHandle *adh;
  struct IdpClient *idp = cls;
  struct GNUNET_CRYPTO_BlindablePrivateKey identity;
  size_t data_len;
  size_t key_len;
  size_t read;
  char *buf;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREDENTIAL_DELETE message\n");
 
  data_len = ntohs (dam->attr_len);
  key_len = ntohs (dam->key_len);
  buf = (char *) &dam[1];
  if ((GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_private_key_from_buffer (buf, key_len,
                                                   &identity, &read)) ||
      (read != key_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read private key\n");
    GNUNET_SERVICE_client_drop (idp->client);
    return;
  }
  buf += read;
  adh = GNUNET_new (struct AttributeDeleteHandle);
  adh->credential = GNUNET_RECLAIM_credential_deserialize (buf,
                                                           data_len);
  adh->claim = NULL;
 
  adh->r_id = ntohl (dam->id);
  adh->identity = identity;
  adh->label
    = GNUNET_STRINGS_data_to_string_alloc (&adh->credential->id,
                                           sizeof(adh->credential->id));
  GNUNET_SERVICE_client_continue (idp->client);
  adh->client = idp;
  GNUNET_CONTAINER_DLL_insert (idp->delete_op_head, idp->delete_op_tail, adh);
  adh->ns_qe = GNUNET_NAMESTORE_record_set_store (nsh,
                                                  &adh->identity,
                                                  adh->label,
                                                  0,
                                                  NULL,
                                                  &cred_delete_cont,
                                                  adh);
}

References AttributeDeleteMessage::attr_len, AttributeDeleteHandle::claim, AttributeDeleteHandle::client, GNUNET_RECLAIM_Handle::client, cred_delete_cont(), AttributeDeleteHandle::credential, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NAMESTORE_record_set_store(), GNUNET_new, GNUNET_RECLAIM_credential_deserialize(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_SYSERR, GNUNET_RECLAIM_Credential::id, AttributeDeleteMessage::id, identity, AttributeDeleteHandle::identity, idp, AttributeDeleteMessage::key_len, AttributeDeleteHandle::label, AttributeDeleteHandle::ns_qe, nsh, and AttributeDeleteHandle::r_id.

Here is the call graph for this function:

attr_iter_finished()

static void attr_iter_finished ( void *  cls )

static

Done iterating over attributes.

Parameters

cls	our iterator handle

Definition at line 1993 of file gnunet-service-reclaim.c.

{
  struct Iterator *ai = cls;
  struct GNUNET_MQ_Envelope *env;
  struct AttributeResultMessage *arm;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ATTRIBUTE_RESULT message\n");
  env = GNUNET_MQ_msg (arm, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT);
  arm->id = htonl (ai->request_id);
  arm->attr_len = htons (0);
  arm->pkey_len = htons (0);
  GNUNET_MQ_send (ai->client->mq, env);
  GNUNET_CONTAINER_DLL_remove (ai->client->attr_iter_head,
                               ai->client->attr_iter_tail,
                               ai);
  GNUNET_free (ai);
}

References ai, AttributeResultMessage::attr_len, env, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), AttributeResultMessage::id, and AttributeResultMessage::pkey_len.

Referenced by attr_iter_error(), and handle_iteration_start().

Here is the call graph for this function:

Here is the caller graph for this function:

attr_iter_error()

static void attr_iter_error ( void *  cls )

static

Error iterating over attributes.

Abort.

Parameters

cls	our attribute iteration handle

Definition at line 2018 of file gnunet-service-reclaim.c.

{
  struct Iterator *ai = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over attributes\n");
  attr_iter_finished (ai);
}

References ai, attr_iter_finished(), GNUNET_ERROR_TYPE_ERROR, and GNUNET_log.

Referenced by handle_iteration_start().

Here is the call graph for this function:

Here is the caller graph for this function:

attr_iter_cb()

static void attr_iter_cb ( void *  cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone, const char *  label, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Got record.

Return if it is an attribute.

Parameters

cls	our attribute iterator
zone	zone we are iterating
label	label of the records
rd_count	record count
rd	records

Definition at line 2037 of file gnunet-service-reclaim.c.

{
  struct Iterator *ai = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_CRYPTO_BlindablePublicKey identity;
  struct AttributeResultMessage *arm;
  char *data_tmp;
  size_t key_len;
  ssize_t written;
 
  if ((rd_count != 1) ||
      (GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE != rd->record_type))
  {
    GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found attribute under: %s\n",
              label);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending ATTRIBUTE_RESULT message\n");
  GNUNET_CRYPTO_blindable_key_get_public (zone, &identity);
  key_len = GNUNET_CRYPTO_public_key_get_length (&identity);
  env = GNUNET_MQ_msg_extra (arm,
                             rd->data_size + key_len,
                             GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT);
  arm->id = htonl (ai->request_id);
  arm->attr_len = htons (rd->data_size);
  data_tmp = (char *) &arm[1];
  arm->pkey_len = htons (key_len);
  written = GNUNET_CRYPTO_write_blindable_pk_to_buffer (&identity,
                                                        data_tmp,
                                                        key_len);
  GNUNET_assert (0 <= written);
  data_tmp += written;
  GNUNET_memcpy (data_tmp, rd->data, rd->data_size);
  GNUNET_MQ_send (ai->client->mq, env);
}

References ai, AttributeResultMessage::attr_len, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, env, GNUNET_assert, GNUNET_CRYPTO_blindable_key_get_public(), GNUNET_CRYPTO_public_key_get_length(), GNUNET_CRYPTO_write_blindable_pk_to_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NAMESTORE_zone_iterator_next(), AttributeResultMessage::id, identity, AttributeResultMessage::pkey_len, rd, rd_count, and GNUNET_GNSRECORD_Data::record_type.

Referenced by handle_iteration_start().

Here is the call graph for this function:

Here is the caller graph for this function:

check_iteration_start()

static enum GNUNET_GenericReturnValue check_iteration_start ( void *  cls, const struct AttributeIterationStartMessage *  ais_msg  )

static

Definition at line 2081 of file gnunet-service-reclaim.c.

{
  uint16_t size;
  size_t key_len;
 
  size = ntohs (ais_msg->header.size);
  key_len = ntohs (ais_msg->key_len);
 
  if (size < key_len + sizeof(*ais_msg))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, AttributeIterationStartMessage::header, AttributeIterationStartMessage::key_len, GNUNET_MessageHeader::size, and size.

handle_iteration_start()

static void handle_iteration_start ( void *  cls, const struct AttributeIterationStartMessage *  ais_msg  )

static

Iterate over zone to get attributes.

Parameters

cls	our client
ais_msg	the iteration message to start

Definition at line 2107 of file gnunet-service-reclaim.c.

{
  struct IdpClient *idp = cls;
  struct Iterator *ai;
  struct GNUNET_CRYPTO_BlindablePrivateKey identity;
  size_t key_len;
  size_t read;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received ATTRIBUTE_ITERATION_START message\n");
  key_len = ntohs (ais_msg->key_len);
  if ((GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_private_key_from_buffer (&ais_msg[1],
                                                   key_len,
                                                   &identity,
                                                   &read)) ||
      (read != key_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read private key.\n");
    GNUNET_SERVICE_client_drop (idp->client);
    return;
  }
  ai = GNUNET_new (struct Iterator);
  ai->request_id = ntohl (ais_msg->id);
  ai->client = idp;
  ai->identity = identity;
 
  GNUNET_CONTAINER_DLL_insert (idp->attr_iter_head, idp->attr_iter_tail, ai);
  ai->ns_it = GNUNET_NAMESTORE_zone_iteration_start (nsh,
                                                     &ai->identity,
                                                     &attr_iter_error,
                                                     ai,
                                                     &attr_iter_cb,
                                                     ai,
                                                     &attr_iter_finished,
                                                     ai);
  GNUNET_SERVICE_client_continue (idp->client);
}

References ai, attr_iter_cb(), attr_iter_error(), attr_iter_finished(), GNUNET_RECLAIM_Handle::client, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, AttributeIterationStartMessage::id, identity, idp, AttributeIterationStartMessage::key_len, and nsh.

Here is the call graph for this function:

handle_iteration_stop()

static void handle_iteration_stop ( void *  cls, const struct AttributeIterationStopMessage *  ais_msg  )

static

Handle iteration stop message from client.

Parameters

cls	the client
ais_msg	the stop message

Definition at line 2156 of file gnunet-service-reclaim.c.

{
  struct IdpClient *idp = cls;
  struct Iterator *ai;
  uint32_t rid;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received `%s' message\n",
              "ATTRIBUTE_ITERATION_STOP");
  rid = ntohl (ais_msg->id);
  for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
    if (ai->request_id == rid)
      break;
  if (NULL == ai)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (idp->client);
    return;
  }
  GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai);
  GNUNET_free (ai);
  GNUNET_SERVICE_client_continue (idp->client);
}

References ai, GNUNET_RECLAIM_Handle::client, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), AttributeIterationStopMessage::id, idp, and GNUNET_TRANSPORT_AddressIdentifier::next.

Here is the call graph for this function:

handle_iteration_next()

static void handle_iteration_next ( void *  cls, const struct AttributeIterationNextMessage *  ais_msg  )

static

Client requests next attribute from iterator.

Parameters

cls	the client
ais_msg	the message

Definition at line 2189 of file gnunet-service-reclaim.c.

{
  struct IdpClient *idp = cls;
  struct Iterator *ai;
  uint32_t rid;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received ATTRIBUTE_ITERATION_NEXT message\n");
  rid = ntohl (ais_msg->id);
  for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
    if (ai->request_id == rid)
      break;
  if (NULL == ai)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (idp->client);
    return;
  }
  GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1);
  GNUNET_SERVICE_client_continue (idp->client);
}

References ai, GNUNET_RECLAIM_Handle::client, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NAMESTORE_zone_iterator_next(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), AttributeIterationNextMessage::id, idp, and GNUNET_TRANSPORT_AddressIdentifier::next.

Here is the call graph for this function:

cred_iter_finished()

static void cred_iter_finished ( void *  cls )

static

Done iterating over credentials.

Parameters

cls	our iterator handle

Definition at line 2224 of file gnunet-service-reclaim.c.

{
  struct Iterator *ai = cls;
  struct GNUNET_MQ_Envelope *env;
  struct CredentialResultMessage *arm;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending CREDENTIAL_RESULT message\n");
  env = GNUNET_MQ_msg (arm, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT);
  arm->id = htonl (ai->request_id);
  arm->credential_len = htons (0);
  arm->key_len = htons (0);
  GNUNET_MQ_send (ai->client->mq, env);
  GNUNET_CONTAINER_DLL_remove (ai->client->cred_iter_head,
                               ai->client->cred_iter_tail,
                               ai);
  GNUNET_free (ai);
}

References ai, CredentialResultMessage::credential_len, env, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), CredentialResultMessage::id, and CredentialResultMessage::key_len.

Referenced by cred_iter_error(), and handle_credential_iteration_start().

Here is the call graph for this function:

Here is the caller graph for this function:

cred_iter_error()

static void cred_iter_error ( void *  cls )

static

Error iterating over credentials.

Abort.

Parameters

cls	our attribute iteration handle

Definition at line 2249 of file gnunet-service-reclaim.c.

{
  struct Iterator *ai = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over credentials\n");
  cred_iter_finished (ai);
}

References ai, cred_iter_finished(), GNUNET_ERROR_TYPE_ERROR, and GNUNET_log.

Referenced by handle_credential_iteration_start().

Here is the call graph for this function:

Here is the caller graph for this function:

cred_iter_cb()

static void cred_iter_cb ( void *  cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone, const char *  label, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Got record.

Return credential.

Parameters

cls	our attribute iterator
zone	zone we are iterating
label	label of the records
rd_count	record count
rd	records

Definition at line 2268 of file gnunet-service-reclaim.c.

{
  struct Iterator *ai = cls;
  struct GNUNET_MQ_Envelope *env;
  struct CredentialResultMessage *arm;
  struct GNUNET_CRYPTO_BlindablePublicKey identity;
  char *data_tmp;
  size_t key_len;
  ssize_t written;
 
  if ((rd_count != 1) ||
      (GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL != rd->record_type))
  {
    GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found credential under: %s\n",
              label);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending CREDENTIAL_RESULT message\n");
  GNUNET_CRYPTO_blindable_key_get_public (zone, &identity);
  key_len = GNUNET_CRYPTO_public_key_get_length (&identity);
  env = GNUNET_MQ_msg_extra (arm,
                             rd->data_size + key_len,
                             GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT);
  arm->id = htonl (ai->request_id);
  arm->credential_len = htons (rd->data_size);
  arm->key_len = htons (key_len);
  data_tmp = (char *) &arm[1];
  written = GNUNET_CRYPTO_write_blindable_pk_to_buffer (&identity,
                                                        data_tmp,
                                                        key_len);
  GNUNET_assert (written >= 0);
  data_tmp += written;
  GNUNET_memcpy (data_tmp, rd->data, rd->data_size);
  GNUNET_MQ_send (ai->client->mq, env);
}

References ai, CredentialResultMessage::credential_len, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, env, GNUNET_assert, GNUNET_CRYPTO_blindable_key_get_public(), GNUNET_CRYPTO_public_key_get_length(), GNUNET_CRYPTO_write_blindable_pk_to_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NAMESTORE_zone_iterator_next(), CredentialResultMessage::id, identity, CredentialResultMessage::key_len, rd, rd_count, and GNUNET_GNSRECORD_Data::record_type.

Referenced by handle_credential_iteration_start().

Here is the call graph for this function:

Here is the caller graph for this function:

check_credential_iteration_start()

static enum GNUNET_GenericReturnValue check_credential_iteration_start ( void *  cls, const struct CredentialIterationStartMessage *  cis_msg  )

static

Definition at line 2312 of file gnunet-service-reclaim.c.

{
  uint16_t size;
  size_t key_len;
 
  size = ntohs (cis_msg->header.size);
  key_len = ntohs (cis_msg->key_len);
 
  if (size < key_len + sizeof(*cis_msg))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, CredentialIterationStartMessage::header, CredentialIterationStartMessage::key_len, GNUNET_MessageHeader::size, and size.

handle_credential_iteration_start()

static void handle_credential_iteration_start ( void *  cls, const struct CredentialIterationStartMessage *  ais_msg  )

static

Iterate over zone to get attributes.

Parameters

cls	our client
ais_msg	the iteration message to start

Definition at line 2338 of file gnunet-service-reclaim.c.

{
  struct IdpClient *idp = cls;
  struct Iterator *ai;
  struct GNUNET_CRYPTO_BlindablePrivateKey identity;
  size_t key_len;
  size_t read;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received CREDENTIAL_ITERATION_START message\n");
  key_len = ntohs (ais_msg->key_len);
  if ((GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_private_key_from_buffer (&ais_msg[1],
                                                   key_len,
                                                   &identity,
                                                   &read)) ||
      (read != key_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read private key.\n");
    GNUNET_SERVICE_client_drop (idp->client);
    return;
  }
  ai = GNUNET_new (struct Iterator);
  ai->request_id = ntohl (ais_msg->id);
  ai->client = idp;
  ai->identity = identity;
 
  GNUNET_CONTAINER_DLL_insert (idp->cred_iter_head, idp->cred_iter_tail,
                               ai);
  ai->ns_it = GNUNET_NAMESTORE_zone_iteration_start (nsh,
                                                     &ai->identity,
                                                     &cred_iter_error,
                                                     ai,
                                                     &cred_iter_cb,
                                                     ai,
                                                     &cred_iter_finished,
                                                     ai);
  GNUNET_SERVICE_client_continue (idp->client);
}

References ai, GNUNET_RECLAIM_Handle::client, cred_iter_cb(), cred_iter_error(), cred_iter_finished(), GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, CredentialIterationStartMessage::id, identity, idp, CredentialIterationStartMessage::key_len, and nsh.

Here is the call graph for this function:

handle_credential_iteration_stop()

static void handle_credential_iteration_stop ( void *  cls, const struct CredentialIterationStopMessage *  ais_msg  )

static

Handle iteration stop message from client.

Parameters

cls	the client
ais_msg	the stop message

Definition at line 2389 of file gnunet-service-reclaim.c.

{
  struct IdpClient *idp = cls;
  struct Iterator *ai;
  uint32_t rid;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received `%s' message\n",
              "CREDENTIAL_ITERATION_STOP");
  rid = ntohl (ais_msg->id);
  for (ai = idp->cred_iter_head; NULL != ai; ai = ai->next)
    if (ai->request_id == rid)
      break;
  if (NULL == ai)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (idp->client);
    return;
  }
  GNUNET_CONTAINER_DLL_remove (idp->cred_iter_head, idp->cred_iter_tail,
                               ai);
  GNUNET_free (ai);
  GNUNET_SERVICE_client_continue (idp->client);
}

References ai, GNUNET_RECLAIM_Handle::client, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), CredentialIterationStopMessage::id, idp, and GNUNET_TRANSPORT_AddressIdentifier::next.

Here is the call graph for this function:

handle_credential_iteration_next()

static void handle_credential_iteration_next ( void *  cls, const struct CredentialIterationNextMessage *  ais_msg  )

static

Client requests next credential from iterator.

Parameters

cls	the client
ais_msg	the message

Definition at line 2424 of file gnunet-service-reclaim.c.

{
  struct IdpClient *idp = cls;
  struct Iterator *ai;
  uint32_t rid;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received CREDENTIAL_ITERATION_NEXT message\n");
  rid = ntohl (ais_msg->id);
  for (ai = idp->cred_iter_head; NULL != ai; ai = ai->next)
    if (ai->request_id == rid)
      break;
  if (NULL == ai)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (idp->client);
    return;
  }
  GNUNET_NAMESTORE_zone_iterator_next (ai->ns_it, 1);
  GNUNET_SERVICE_client_continue (idp->client);
}

References ai, GNUNET_RECLAIM_Handle::client, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NAMESTORE_zone_iterator_next(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), CredentialIterationNextMessage::id, idp, and GNUNET_TRANSPORT_AddressIdentifier::next.

Here is the call graph for this function:

ticket_iter_cb()

static void ticket_iter_cb ( void *  cls, struct GNUNET_RECLAIM_Ticket *  ticket, const char *  rp_uri  )

static

Definition at line 2454 of file gnunet-service-reclaim.c.

{
  struct TicketIteration *ti = cls;
  struct GNUNET_MQ_Envelope *env;
  struct TicketResultMessage *trm;
  size_t tkt_len;
  size_t rp_uri_len;
 
  if (NULL == ticket)
    tkt_len = 0;
  else
    tkt_len = strlen (ticket->gns_name) + 1;
 
  if (NULL == rp_uri)
    rp_uri_len = 0;
  else
    rp_uri_len = strlen (rp_uri) + 1;
  env = GNUNET_MQ_msg_extra (trm,
                             tkt_len + rp_uri_len,
                             GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT);
  if (NULL == ticket)
  {
    /* send empty response to indicate end of list */
    GNUNET_CONTAINER_DLL_remove (ti->client->ticket_iter_head,
                                 ti->client->ticket_iter_tail,
                                 ti);
  }
  else
  {
    memcpy (&trm[1], ticket, tkt_len);
  }
  memcpy ((char*) &trm[1] + tkt_len, rp_uri, rp_uri_len);
  trm->id = htonl (ti->r_id);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
  trm->tkt_len = htons (tkt_len);
  trm->rp_uri_len = htons (rp_uri_len);
  trm->presentations_len = htons (0);
  GNUNET_MQ_send (ti->client->mq, env);
  if (NULL == ticket)
    GNUNET_free (ti);
}

References TicketIteration::client, env, GNUNET_RECLAIM_Ticket::gns_name, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), TicketResultMessage::id, IdpClient::mq, TicketResultMessage::presentations_len, TicketIteration::r_id, TicketResultMessage::rp_uri_len, ticket, IdpClient::ticket_iter_head, IdpClient::ticket_iter_tail, and TicketResultMessage::tkt_len.

Referenced by handle_ticket_iteration_start().

Here is the call graph for this function:

Here is the caller graph for this function:

check_ticket_iteration_start()

static enum GNUNET_GenericReturnValue check_ticket_iteration_start ( void *  cls, const struct TicketIterationStartMessage *  tis_msg  )

static

Definition at line 2499 of file gnunet-service-reclaim.c.

{
  uint16_t size;
  size_t key_len;
 
  size = ntohs (tis_msg->header.size);
  key_len = ntohs (tis_msg->key_len);
 
  if (size < key_len + sizeof(*tis_msg))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, TicketIterationStartMessage::header, TicketIterationStartMessage::key_len, GNUNET_MessageHeader::size, and size.

handle_ticket_iteration_start()

static void handle_ticket_iteration_start ( void *  cls, const struct TicketIterationStartMessage *  tis_msg  )

static

Client requests a ticket iteration.

Parameters

cls	the client
tis_msg	the iteration request message

Definition at line 2525 of file gnunet-service-reclaim.c.

{
  struct GNUNET_CRYPTO_BlindablePrivateKey identity;
  struct IdpClient *client = cls;
  struct TicketIteration *ti;
  size_t key_len;
  size_t read;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received TICKET_ITERATION_START message\n");
  key_len = ntohs (tis_msg->key_len);
  if ((GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_private_key_from_buffer (&tis_msg[1],
                                                   key_len,
                                                   &identity,
                                                   &read)) ||
      (read != key_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to read private key\n");
    GNUNET_SERVICE_client_drop (client->client);
    return;
  }
  ti = GNUNET_new (struct TicketIteration);
  ti->r_id = ntohl (tis_msg->id);
  ti->client = client;
  GNUNET_CONTAINER_DLL_insert (client->ticket_iter_head,
                               client->ticket_iter_tail,
                               ti);
  ti->iter
    = RECLAIM_TICKETS_iteration_start (&identity, &ticket_iter_cb, ti);
  GNUNET_SERVICE_client_continue (client->client);
}

References TicketIteration::client, IdpClient::client, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, TicketIterationStartMessage::id, identity, TicketIteration::iter, TicketIterationStartMessage::key_len, TicketIteration::r_id, RECLAIM_TICKETS_iteration_start(), ticket_iter_cb(), IdpClient::ticket_iter_head, and IdpClient::ticket_iter_tail.

Here is the call graph for this function:

handle_ticket_iteration_stop()

static void handle_ticket_iteration_stop ( void *  cls, const struct TicketIterationStopMessage *  tis_msg  )

static

Client has had enough tickets.

Parameters

cls	the client
tis_msg	the stop message

Definition at line 2569 of file gnunet-service-reclaim.c.

{
  struct IdpClient *client = cls;
  struct TicketIteration *ti;
  uint32_t rid;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received `%s' message\n",
              "TICKET_ITERATION_STOP");
  rid = ntohl (tis_msg->id);
  for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next)
    if (ti->r_id == rid)
      break;
  if (NULL == ti)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (client->client);
    return;
  }
  RECLAIM_TICKETS_iteration_stop (ti->iter);
  GNUNET_CONTAINER_DLL_remove (client->ticket_iter_head,
                               client->ticket_iter_tail,
                               ti);
  GNUNET_free (ti);
  GNUNET_SERVICE_client_continue (client->client);
}

References TicketIteration::client, IdpClient::client, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), TicketIterationStopMessage::id, TicketIteration::iter, TicketIteration::next, TicketIteration::r_id, RECLAIM_TICKETS_iteration_stop(), IdpClient::ticket_iter_head, and IdpClient::ticket_iter_tail.

Here is the call graph for this function:

handle_ticket_iteration_next()

static void handle_ticket_iteration_next ( void *  cls, const struct TicketIterationNextMessage *  tis_msg  )

static

Client requests next result.

Parameters

cls	the client
tis_msg	the message

Definition at line 2605 of file gnunet-service-reclaim.c.

{
  struct IdpClient *client = cls;
  struct TicketIteration *ti;
  uint32_t rid;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received TICKET_ITERATION_NEXT message\n");
  rid = ntohl (tis_msg->id);
  for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next)
    if (ti->r_id == rid)
      break;
  if (NULL == ti)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (client->client);
    return;
  }
  RECLAIM_TICKETS_iteration_next (ti->iter);
  GNUNET_SERVICE_client_continue (client->client);
}

References TicketIteration::client, IdpClient::client, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), TicketIterationNextMessage::id, TicketIteration::iter, TicketIteration::next, TicketIteration::r_id, RECLAIM_TICKETS_iteration_next(), and IdpClient::ticket_iter_head.

Here is the call graph for this function:

run()

static void run ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  c, struct GNUNET_SERVICE_Handle *  server  )

static

Main function that will be run.

Parameters

cls	closure
c	the configuration used
server	the service handle

Definition at line 2637 of file gnunet-service-reclaim.c.

{
  cfg = c;
 
  if (GNUNET_OK != RECLAIM_TICKETS_init (cfg))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unable to initialize TICKETS subsystem.\n");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  // Connect to identity and namestore services
  nsh = GNUNET_NAMESTORE_connect (cfg);
  if (NULL == nsh)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                         "error connecting to namestore");
  }
 
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
}

References cfg, do_shutdown, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_strerror, GNUNET_NAMESTORE_connect(), GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), nsh, and RECLAIM_TICKETS_init().

Here is the call graph for this function:

client_disconnect_cb()

static void client_disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, void *  app_ctx  )

static

Called whenever a client is disconnected.

Parameters

cls	closure
client	identification of the client
app_ctx	client

Definition at line 2670 of file gnunet-service-reclaim.c.

{
  struct IdpClient *idp = app_ctx;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected\n", client);
  GNUNET_CONTAINER_DLL_remove (client_list_head,
                               client_list_tail,
                               idp);
  cleanup_client (idp);
}

References cleanup_client(), IdpClient::client, client_list_head, client_list_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and idp.

Here is the call graph for this function:

client_connect_cb()

static void * client_connect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, struct GNUNET_MQ_Handle *  mq  )

static

Add a client to our list of active clients.

Parameters

cls	NULL
client	client to add
mq	message queue for client

Returns

internal namestore client structure for this client

Definition at line 2693 of file gnunet-service-reclaim.c.

{
  struct IdpClient *idp;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
  idp = GNUNET_new (struct IdpClient);
  idp->client = client;
  idp->mq = mq;
  GNUNET_CONTAINER_DLL_insert (client_list_head,
                               client_list_tail,
                               idp);
  return idp;
}

References IdpClient::client, GNUNET_RECLAIM_Handle::client, client_list_head, client_list_tail, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, idp, mq, and GNUNET_RECLAIM_Handle::mq.

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	GNUNET_OS_project_data_gnunet()	,
		"reclaim"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_var_size(attribute_store_message, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_STORE, struct AttributeStoreMessage, NULL)	,
		GNUNET_MQ_hd_var_size(credential_store_message, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_STORE, struct AttributeStoreMessage, NULL)	,
		GNUNET_MQ_hd_var_size(attribute_delete_message, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_DELETE, struct AttributeDeleteMessage, NULL)	,
		GNUNET_MQ_hd_var_size(credential_delete_message, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_DELETE, struct AttributeDeleteMessage, NULL)	,
		GNUNET_MQ_hd_var_size(iteration_start, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_START, struct AttributeIterationStartMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(iteration_next, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_NEXT, struct AttributeIterationNextMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(iteration_stop, GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_ITERATION_STOP, struct AttributeIterationStopMessage, NULL)	,
		GNUNET_MQ_hd_var_size(credential_iteration_start, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_START, struct CredentialIterationStartMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(credential_iteration_next, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_NEXT, struct CredentialIterationNextMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(credential_iteration_stop, GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_ITERATION_STOP, struct CredentialIterationStopMessage, NULL)	,
		GNUNET_MQ_hd_var_size(issue_ticket_message, GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET, struct IssueTicketMessage, NULL)	,
		GNUNET_MQ_hd_var_size(consume_ticket_message, GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET, struct ConsumeTicketMessage, NULL)	,
		GNUNET_MQ_hd_var_size(ticket_iteration_start, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_START, struct TicketIterationStartMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(ticket_iteration_next, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_NEXT, struct TicketIterationNextMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(ticket_iteration_stop, GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_ITERATION_STOP, struct TicketIterationStopMessage, NULL)	,
		GNUNET_MQ_hd_var_size(revoke_ticket_message, GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET, struct RevokeTicketMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

nsh

struct GNUNET_NAMESTORE_Handle* nsh

static

Namestore handle.

Definition at line 38 of file gnunet-service-reclaim.c.

Referenced by attr_store_task(), cleanup(), cred_add_cb(), cred_store_task(), handle_attribute_delete_message(), handle_credential_delete_message(), handle_credential_iteration_start(), handle_iteration_start(), purge_attributes(), run(), start_consistency_update(), and update_tickets().

timeout_task

struct GNUNET_SCHEDULER_Task* timeout_task

static

Timeout task.

Definition at line 43 of file gnunet-service-reclaim.c.

Referenced by cleanup().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Our configuration.

Definition at line 48 of file gnunet-service-reclaim.c.

Referenced by run().

client_list_head

struct IdpClient* client_list_head = NULL

static

Client list.

Definition at line 472 of file gnunet-service-reclaim.c.

Referenced by client_connect_cb(), and client_disconnect_cb().

client_list_tail

struct IdpClient* client_list_tail = NULL

static

Client list.

Definition at line 477 of file gnunet-service-reclaim.c.

Referenced by client_connect_cb(), and client_disconnect_cb().