GNUnet  0.20.0
gnunet-service-reclaim.c File Reference

reclaim Service More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet-service-reclaim_tickets.h"
#include "gnunet_constants.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_reclaim_lib.h"
#include "gnunet_reclaim_service.h"
#include "gnunet_signatures.h"
#include "reclaim.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. More...
 
static void cleanup_as_handle (struct AttributeStoreHandle *ash)
 Cleanup attribute store handle. More...
 
static void cleanup_client (struct IdpClient *idp)
 Cleanup client. More...
 
static void cleanup ()
 Cleanup task. More...
 
static void do_shutdown (void *cls)
 Shutdown task. More...
 
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. More...
 
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. More...
 
static int check_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
 Check issue ticket message. More...
 
static void handle_issue_ticket_message (void *cls, const struct IssueTicketMessage *im)
 Handle ticket issue message. More...
 
static void revoke_result_cb (void *cls, int32_t success)
 Handles revocation result. More...
 
static int check_revoke_ticket_message (void *cls, const struct RevokeTicketMessage *im)
 Check revocation message format. More...
 
static void handle_revoke_ticket_message (void *cls, const struct RevokeTicketMessage *rm)
 Handle a revocation message to a ticket. More...
 
static void consume_result_cb (void *cls, const struct GNUNET_IDENTITY_PublicKey *identity, const struct GNUNET_RECLAIM_AttributeList *attrs, const struct GNUNET_RECLAIM_PresentationList *presentations, int32_t success, const char *emsg)
 Handle a ticket consume result. More...
 
static int check_consume_ticket_message (void *cls, const struct ConsumeTicketMessage *cm)
 Check a consume ticket message. More...
 
static void handle_consume_ticket_message (void *cls, const struct ConsumeTicketMessage *cm)
 Handle a consume ticket message. More...
 
static void attr_store_cont (void *cls, enum GNUNET_ErrorCode ec)
 Attribute store result handler. More...
 
static void attr_store_task (void *cls)
 Add a new attribute. More...
 
static int check_attribute_store_message (void *cls, const struct AttributeStoreMessage *sam)
 Check an attribute store message. More...
 
static void handle_attribute_store_message (void *cls, const struct AttributeStoreMessage *sam)
 Handle an attribute store message. More...
 
static void cred_store_cont (void *cls, enum GNUNET_ErrorCode ec)
 Credential store result handler. More...
 
static void cred_error (void *cls)
 Error looking up potential credential. More...
 
static void cred_add_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 Check for existing record before storing credential. More...
 
static void cred_store_task (void *cls)
 Add a new credential. More...
 
static int check_credential_store_message (void *cls, const struct AttributeStoreMessage *sam)
 Check an credential store message. More...
 
static void handle_credential_store_message (void *cls, const struct AttributeStoreMessage *sam)
 Handle a credential store message. More...
 
static void send_delete_response (struct AttributeDeleteHandle *adh, int32_t success)
 Send a deletion success response. More...
 
static void consistency_iter (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 Namestore iteration within attribute deletion. More...
 
static void update_tickets (void *cls)
 Recursion prototype for function. More...
 
static void ticket_updated (void *cls, enum GNUNET_ErrorCode ec)
 Callback called when a ticket was updated. More...
 
static void purge_attributes (void *cls)
 Delete all attributes which reference credentials that no longer exist. More...
 
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. More...
 
static void consistency_iter_err (void *cls)
 Error collecting affected tickets. More...
 
static void start_consistency_update (void *cls)
 Start processing tickets which may still contain reference to deleted attribute. More...
 
static void attr_delete_cont (void *cls, enum GNUNET_ErrorCode ec)
 Attribute deleted callback. More...
 
static int check_attribute_delete_message (void *cls, const struct AttributeDeleteMessage *dam)
 Check attribute delete message format. More...
 
static void handle_attribute_delete_message (void *cls, const struct AttributeDeleteMessage *dam)
 Handle attribute deletion. More...
 
static void cred_delete_cont (void *cls, enum GNUNET_ErrorCode ec)
 Credential deleted callback. More...
 
static int check_credential_delete_message (void *cls, const struct AttributeDeleteMessage *dam)
 Check credential delete message format. More...
 
static void handle_credential_delete_message (void *cls, const struct AttributeDeleteMessage *dam)
 Handle credential deletion. More...
 
static void attr_iter_finished (void *cls)
 Done iterating over attributes. More...
 
static void attr_iter_error (void *cls)
 Error iterating over attributes. More...
 
static void attr_iter_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 Got record. More...
 
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. More...
 
static void handle_iteration_stop (void *cls, const struct AttributeIterationStopMessage *ais_msg)
 Handle iteration stop message from client. More...
 
static void handle_iteration_next (void *cls, const struct AttributeIterationNextMessage *ais_msg)
 Client requests next attribute from iterator. More...
 
static void cred_iter_finished (void *cls)
 Done iterating over credentials. More...
 
static void cred_iter_error (void *cls)
 Error iterating over credentials. More...
 
static void cred_iter_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
 Got record. More...
 
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. More...
 
static void handle_credential_iteration_stop (void *cls, const struct CredentialIterationStopMessage *ais_msg)
 Handle iteration stop message from client. More...
 
static void handle_credential_iteration_next (void *cls, const struct CredentialIterationNextMessage *ais_msg)
 Client requests next credential from iterator. More...
 
static void ticket_iter_cb (void *cls, struct GNUNET_RECLAIM_Ticket *ticket)
 Got a ticket. More...
 
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. More...
 
static void handle_ticket_iteration_stop (void *cls, const struct TicketIterationStopMessage *tis_msg)
 Client has had enough tickets. More...
 
static void handle_ticket_iteration_next (void *cls, const struct TicketIterationNextMessage *tis_msg)
 Client requests next result. More...
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *server)
 Main function that will be run. More...
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
 Called whenever a client is disconnected. More...
 
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. More...
 
 GNUNET_SERVICE_MAIN ("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. More...
 

Variables

static struct GNUNET_NAMESTORE_Handlensh
 Namestore handle. More...
 
static struct GNUNET_SCHEDULER_Tasktimeout_task
 Timeout task. More...
 
static const struct GNUNET_CONFIGURATION_Handlecfg
 Our configuration. More...
 
static struct IdpClientclient_list_head = NULL
 Client list. More...
 
static struct IdpClientclient_list_tail = NULL
 Client list. More...
 

Detailed Description

reclaim Service

Author
Martin Schanzenbach

Definition in file gnunet-service-reclaim.c.

Function Documentation

◆ cleanup_adh()

static void cleanup_adh ( struct AttributeDeleteHandle adh)
static

Cleanup attribute delete handle.

Parameters
adhthe attribute to cleanup

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

490 {
491  struct TicketRecordsEntry *le;
492 
493  if (NULL != adh->ns_it)
495  if (NULL != adh->ns_qe)
497  if (NULL != adh->label)
498  GNUNET_free (adh->label);
499  if (NULL != adh->claim)
500  GNUNET_free (adh->claim);
501  if (NULL != adh->credential)
502  GNUNET_free (adh->credential);
503  if (NULL != adh->existing_credentials)
505  if (NULL != adh->existing_attributes)
507  while (NULL != (le = adh->tickets_to_update_head))
508  {
511  le);
512  if (NULL != le->label)
513  GNUNET_free (le->label);
514  if (NULL != le->data)
515  GNUNET_free (le->data);
516  GNUNET_free (le);
517  }
518  GNUNET_free (adh);
519 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_NAMESTORE_cancel(struct GNUNET_NAMESTORE_QueueEntry *qe)
Cancel a namestore operation.
void GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it)
Stops iteration and releases the namestore handle for further calls.
void GNUNET_RECLAIM_attribute_list_destroy(struct GNUNET_RECLAIM_AttributeList *attrs)
Destroy claim list.
void GNUNET_RECLAIM_credential_list_destroy(struct GNUNET_RECLAIM_CredentialList *credentials)
Destroy credential list.
struct GNUNET_RECLAIM_CredentialList * existing_credentials
Existing credentials.
struct TicketRecordsEntry * tickets_to_update_tail
Tickets to update.
struct GNUNET_RECLAIM_Attribute * claim
The attribute to delete.
char * label
Attribute label.
struct GNUNET_NAMESTORE_ZoneIterator * ns_it
Iterator.
struct GNUNET_RECLAIM_AttributeList * existing_attributes
Existing attributes.
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
QueueEntry.
struct GNUNET_RECLAIM_Credential * credential
The credential to delete.
struct TicketRecordsEntry * tickets_to_update_head
Tickets to update.

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
ashhandle to clean up

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

529 {
530  if (NULL != ash->ns_qe)
532  if (NULL != ash->claim)
533  GNUNET_free (ash->claim);
534  if (NULL != ash->credential)
535  GNUNET_free (ash->credential);
536  GNUNET_free (ash);
537 }
struct GNUNET_NAMESTORE_QueueEntry * ns_qe
QueueEntry.
struct GNUNET_RECLAIM_Credential * credential
The credential to store.
struct GNUNET_RECLAIM_Attribute * claim
The attribute to store.

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
idpthe client to clean up

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

547 {
548  struct Iterator *ai;
549  struct TicketIteration *ti;
550  struct TicketRevocationOperation *rop;
551  struct TicketIssueOperation *iss;
552  struct ConsumeTicketOperation *ct;
553  struct AttributeStoreHandle *as;
554  struct AttributeDeleteHandle *adh;
555 
556  while (NULL != (iss = idp->issue_op_head))
557  {
558  GNUNET_CONTAINER_DLL_remove (idp->issue_op_head, idp->issue_op_tail, iss);
559  GNUNET_free (iss);
560  }
561  while (NULL != (ct = idp->consume_op_head))
562  {
563  GNUNET_CONTAINER_DLL_remove (idp->consume_op_head,
564  idp->consume_op_tail,
565  ct);
566  if (NULL != ct->ch)
568  GNUNET_free (ct);
569  }
570  while (NULL != (as = idp->store_op_head))
571  {
572  GNUNET_CONTAINER_DLL_remove (idp->store_op_head, idp->store_op_tail, as);
573  cleanup_as_handle (as);
574  }
575  while (NULL != (adh = idp->delete_op_head))
576  {
577  GNUNET_CONTAINER_DLL_remove (idp->delete_op_head, idp->delete_op_tail, adh);
578  cleanup_adh (adh);
579  }
580 
581  while (NULL != (ai = idp->attr_iter_head))
582  {
583  GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai);
584  GNUNET_free (ai);
585  }
586  while (NULL != (ai = idp->cred_iter_head))
587  {
588  GNUNET_CONTAINER_DLL_remove (idp->cred_iter_head, idp->cred_iter_tail,
589  ai);
590  GNUNET_free (ai);
591  }
592 
593  while (NULL != (rop = idp->revoke_op_head))
594  {
595  GNUNET_CONTAINER_DLL_remove (idp->revoke_op_head, idp->revoke_op_tail, rop);
596  if (NULL != rop->rh)
598  GNUNET_free (rop);
599  }
600  while (NULL != (ti = idp->ticket_iter_head))
601  {
602  GNUNET_CONTAINER_DLL_remove (idp->ticket_iter_head,
603  idp->ticket_iter_tail,
604  ti);
605  if (NULL != ti->iter)
607  GNUNET_free (ti);
608  }
609  GNUNET_free (idp);
610 }
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
static void cleanup_adh(struct AttributeDeleteHandle *adh)
Cleanup attribute delete handle.
static void cleanup_as_handle(struct AttributeStoreHandle *ash)
Cleanup attribute store handle.
void RECLAIM_TICKETS_iteration_stop(struct RECLAIM_TICKETS_Iterator *iter)
Stop a running ticket iteration.
void RECLAIM_TICKETS_consume_cancel(struct RECLAIM_TICKETS_ConsumeHandle *cth)
Cancel a consume operation.
void RECLAIM_TICKETS_revoke_cancel(struct RECLAIM_TICKETS_RevokeHandle *rh)
Cancel a revocation.
static struct GNUNET_RECLAIM_Handle * idp
Identity Provider.
Handle for attribute deletion request.
Handle for attribute store request.
Handle for ticket consume request.
struct RECLAIM_TICKETS_ConsumeHandle * ch
Ticket consume handle.
An attribute iteration operation.
Ticket issue operation handle.
A ticket iteration operation.
struct RECLAIM_TICKETS_Iterator * iter
The ticket iterator.
Ticket revocation request handle.
struct RECLAIM_TICKETS_RevokeHandle * rh
Revocation handle.

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 617 of file gnunet-service-reclaim.c.

618 {
619  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
620 
622  if (NULL != timeout_task)
624  if (NULL != nsh)
626 }
static struct GNUNET_NAMESTORE_Handle * nsh
Namestore handle.
static struct GNUNET_SCHEDULER_Task * timeout_task
Timeout task.
void RECLAIM_TICKETS_deinit(void)
Close handles and clean up.
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_DEBUG
void GNUNET_NAMESTORE_disconnect(struct GNUNET_NAMESTORE_Handle *h)
Disconnect from the namestore service (and free associated resources).
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975

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

Referenced by do_shutdown().

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
clsNULL

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

636 {
637  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down...\n");
638  cleanup ();
639 }
static void cleanup()
Cleanup task.
@ GNUNET_ERROR_TYPE_INFO

References cleanup(), GNUNET_ERROR_TYPE_INFO, and GNUNET_log.

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

Here is the call graph for this function:
Here is the caller 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
clientthe client to send to
r_idthe request message ID to reply to
ticketthe ticket to include (may be NULL)
successthe success status of the request

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

656 {
657  struct TicketResultMessage *irm;
658  struct GNUNET_MQ_Envelope *env;
659  size_t pres_len = 0;
660  size_t tkt_len = 0;
661  ssize_t written;
662  char *buf;
663 
664  if (NULL != presentations)
665  {
666  pres_len =
668  }
669  if (NULL != ticket)
671  env = GNUNET_MQ_msg_extra (irm,
672  pres_len + tkt_len,
674  buf = (char*) &irm[1];
675  if (NULL != ticket)
676  {
677  irm->tkt_len = htons (tkt_len);
678  written = GNUNET_RECLAIM_write_ticket_to_buffer (ticket, buf, tkt_len);
679  GNUNET_assert (0 <= written);
680  buf += written;
681  }
682  // TODO add success member
683  irm->id = htonl (r_id);
684  irm->presentations_len = htons (pres_len);
685  if (NULL != presentations)
686  {
688  buf);
689  }
690  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
691  GNUNET_MQ_send (client->mq, env);
692 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct GNUNET_RECLAIM_Ticket ticket
Ticket to consume.
static char buf[2048]
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:304
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
#define GNUNET_MESSAGE_TYPE_RECLAIM_TICKET_RESULT
size_t GNUNET_RECLAIM_presentation_list_serialize(const struct GNUNET_RECLAIM_PresentationList *presentations, char *result)
Serialize a presentation list.
size_t GNUNET_RECLAIM_presentation_list_serialize_get_size(const struct GNUNET_RECLAIM_PresentationList *presentations)
Get required size for serialization buffer.
ssize_t GNUNET_RECLAIM_write_ticket_to_buffer(const struct GNUNET_RECLAIM_Ticket *tkt, void *buffer, size_t len)
Serializes a ticket.
Definition: reclaim_api.c:1783
size_t GNUNET_RECLAIM_ticket_serialize_get_size(const struct GNUNET_RECLAIM_Ticket *tkt)
Get serialized ticket size.
Definition: reclaim_api.c:1740
struct GNUNET_MQ_Handle * mq
Message queue for transmission to client.
Ticket result message.
Definition: reclaim.h:492
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:501
uint16_t presentations_len
Length of new presentations created.
Definition: reclaim.h:511
uint16_t tkt_len
Ticket length.
Definition: reclaim.h:506

References buf, env, GNUNET_assert, 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(), GNUNET_RECLAIM_ticket_serialize_get_size(), GNUNET_RECLAIM_write_ticket_to_buffer(), TicketResultMessage::id, IdpClient::mq, TicketResultMessage::presentations_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
clsout ticket issue operation handle
ticketthe issued ticket
presentationsnewly created credential presentations (NULL on error)
successissue success status (GNUNET_OK if successful)
emsgerror message (NULL of success is GNUNET_OK)

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

710 {
711  struct TicketIssueOperation *tio = cls;
712 
713  if (GNUNET_OK != success)
714  {
715  send_ticket_result (tio->client, tio->r_id, NULL, NULL, GNUNET_SYSERR);
716  GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head,
717  tio->client->issue_op_tail,
718  tio);
719  GNUNET_free (tio);
720  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error issuing ticket: %s\n", emsg);
721  return;
722  }
723  send_ticket_result (tio->client, tio->r_id,
724  ticket, presentations, GNUNET_SYSERR);
725  GNUNET_CONTAINER_DLL_remove (tio->client->issue_op_head,
726  tio->client->issue_op_tail,
727  tio);
728  GNUNET_free (tio);
729 }
static struct GNUNET_CADET_ListTunnels * tio
Active tunnel listing operation.
Definition: gnunet-cadet.c:112
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.
@ GNUNET_OK
@ GNUNET_SYSERR
@ GNUNET_ERROR_TYPE_ERROR

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
clsunused
immessage to check
Returns
GNUNET_OK if message is ok

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

741 {
742  uint16_t size;
743  size_t attrs_len;
744  size_t key_len;
745  size_t pkey_len;
746 
747  size = ntohs (im->header.size);
748  attrs_len = ntohs (im->attr_len);
749  key_len = ntohs (im->key_len);
750  pkey_len = ntohs (im->pkey_len);
751  if (size != attrs_len + key_len + pkey_len + sizeof(struct
753  {
754  GNUNET_break (0);
755  return GNUNET_SYSERR;
756  }
757  return GNUNET_OK;
758 }
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
static unsigned int size
Size of the "table".
Definition: peer.c:68
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Ticket issue message.
Definition: reclaim.h:396
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_RECLAIM_ISSUE_TICKET.
Definition: reclaim.h:400
uint16_t pkey_len
The length of the relying party public key.
Definition: reclaim.h:425
uint16_t key_len
The length of the identity private key.
Definition: reclaim.h:420
uint16_t attr_len
length of serialized attribute list
Definition: reclaim.h:415

References IssueTicketMessage::attr_len, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, IssueTicketMessage::header, IssueTicketMessage::key_len, IssueTicketMessage::pkey_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
clsour client
imthe message

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

769 {
770  struct TicketIssueOperation *tio;
771  struct IdpClient *idp = cls;
772  struct GNUNET_RECLAIM_AttributeList *attrs;
776  size_t attrs_len;
777  size_t key_len;
778  size_t pkey_len;
779  size_t read;
780  char *buf;
781 
782  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ISSUE_TICKET message\n");
783  key_len = ntohs (im->key_len);
784  buf = (char *) &im[1];
785  if ((GNUNET_SYSERR ==
787  &identity, &read)) ||
788  (read != key_len))
789  {
791  "Failed to read private key\n");
793  return;
794  }
795  buf += read;
796  pkey_len = ntohs (im->pkey_len);
797  if ((GNUNET_SYSERR ==
799  &rp, &read)) ||
800  (read != pkey_len))
801  {
803  "Failed to read public key\n");
805  return;
806  }
807  buf += read;
809  attrs_len = ntohs (im->attr_len);
811  attrs_len);
812  for (le = attrs->list_head; NULL != le; le = le->next)
814  "List entry: %s\n", le->attribute->name);
815 
816  tio->r_id = ntohl (im->id);
817  tio->client = idp;
818  GNUNET_CONTAINER_DLL_insert (idp->issue_op_head, idp->issue_op_tail, tio);
820  attrs,
821  &rp,
823  tio);
826 }
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static char * rp
Relying party.
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.
void RECLAIM_TICKETS_issue(const struct GNUNET_IDENTITY_PrivateKey *identity, const struct GNUNET_RECLAIM_AttributeList *attrs, const struct GNUNET_IDENTITY_PublicKey *audience, RECLAIM_TICKETS_TicketResult cb, void *cb_cls)
Issue a new reclaim ticket, thereby authorizing the audience to access the set of provided attributes...
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_read_public_key_from_buffer(const void *buffer, size_t len, struct GNUNET_IDENTITY_PublicKey *key, size_t *kb_read)
Reads a GNUNET_IDENTITY_PublicKey from a compact buffer.
Definition: identity_api.c:865
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_read_private_key_from_buffer(const void *buffer, size_t len, struct GNUNET_IDENTITY_PrivateKey *key, size_t *kb_read)
Reads a GNUNET_IDENTITY_PrivateKey from a compact buffer.
Definition: identity_api.c:908
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_RECLAIM_AttributeList * GNUNET_RECLAIM_attribute_list_deserialize(const char *data, size_t data_size)
Deserialize an attribute list.
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2330
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2249
A private key for an identity as per LSD0001.
An identity key as per LSD0001.
struct GNUNET_RECLAIM_Attribute * attribute
The attribute claim.
struct GNUNET_RECLAIM_AttributeListEntry * next
DLL.
A list of GNUNET_RECLAIM_Attribute structures.
struct GNUNET_RECLAIM_AttributeListEntry * list_head
List head.
const char * name
The name of the attribute.
struct GNUNET_CLIENT_Connection * client
Socket (if available).
Definition: reclaim_api.c:326
An idp client.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:405

References IssueTicketMessage::attr_len, GNUNET_RECLAIM_AttributeListEntry::attribute, buf, GNUNET_RECLAIM_Handle::client, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_read_private_key_from_buffer(), GNUNET_IDENTITY_read_public_key_from_buffer(), 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, IssueTicketMessage::pkey_len, RECLAIM_TICKETS_issue(), rp, 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
clsour revocation operation handle
successrevocation result (GNUNET_OK if successful)

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

841 {
842  struct TicketRevocationOperation *rop = cls;
843  struct GNUNET_MQ_Envelope *env;
844  struct RevokeTicketResultMessage *trm;
845 
847  "Sending REVOKE_TICKET_RESULT message\n");
848  rop->rh = NULL;
850  trm->id = htonl (rop->r_id);
851  trm->success = htonl (success);
852  GNUNET_MQ_send (rop->client->mq, env);
854  rop->client->revoke_op_tail,
855  rop);
856  GNUNET_free (rop);
857 }
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET_RESULT
struct TicketRevocationOperation * revoke_op_head
Head of DLL of ticket revocation ops.
struct TicketRevocationOperation * revoke_op_tail
Tail of DLL of ticket revocation ops.
Ticket revoke message.
Definition: reclaim.h:470
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:479
uint32_t success
Revocation result.
Definition: reclaim.h:484
struct IdpClient * client
Client connection.

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 im 
)
static

Check revocation message format.

Parameters
clsunused
imthe message to check
Returns
GNUNET_OK if message is ok

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

869 {
870  uint16_t size;
871 
872  size = ntohs (im->header.size);
873  if (size != sizeof(struct RevokeTicketMessage))
874  {
875  GNUNET_break (0);
876  return GNUNET_SYSERR;
877  }
878  return GNUNET_OK;
879 }
Ticket revoke message.
Definition: reclaim.h:438
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_RECLAIM_REVOKE_TICKET.
Definition: reclaim.h:442

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

◆ 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
clsour client
rmthe message to handle

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

890 {
891  struct TicketRevocationOperation *rop;
892  struct IdpClient *idp = cls;
895  size_t key_len;
896  size_t tkt_len;
897  size_t read;
898  char *buf;
899 
900  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received REVOKE_TICKET message\n");
901  key_len = ntohs (rm->key_len);
902  buf = (char *) &rm[1];
903  if ((GNUNET_SYSERR ==
905  &identity, &read)) ||
906  (read != key_len))
907  {
909  "Failed to read private key\n");
911  return;
912  }
913  buf += read;
914  tkt_len = ntohs (rm->tkt_len);
915  if ((GNUNET_SYSERR ==
917  &ticket, &read)) ||
918  (read != tkt_len))
919  {
921  "Failed to read ticket\n");
923  return;
924  }
925  rop = GNUNET_new (struct TicketRevocationOperation);
926  rop->r_id = ntohl (rm->id);
927  rop->client = idp;
928  GNUNET_CONTAINER_DLL_insert (idp->revoke_op_head, idp->revoke_op_tail, rop);
929  rop->rh
932 }
static void revoke_result_cb(void *cls, int32_t success)
Handles revocation result.
struct RECLAIM_TICKETS_RevokeHandle * RECLAIM_TICKETS_revoke(const struct GNUNET_RECLAIM_Ticket *ticket, const struct GNUNET_IDENTITY_PrivateKey *identity, RECLAIM_TICKETS_RevokeCallback cb, void *cb_cls)
Revoke a ticket.
enum GNUNET_GenericReturnValue GNUNET_RECLAIM_read_ticket_from_buffer(const void *buffer, size_t len, struct GNUNET_RECLAIM_Ticket *tkt, size_t *tb_read)
Deserializes a ticket.
Definition: reclaim_api.c:1750
The authorization ticket.
uint16_t key_len
The length of the private key.
Definition: reclaim.h:452
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:447
uint16_t tkt_len
The length of the ticket.
Definition: reclaim.h:457

References buf, TicketRevocationOperation::client, GNUNET_RECLAIM_Handle::client, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_read_private_key_from_buffer(), GNUNET_log, GNUNET_new, GNUNET_RECLAIM_read_ticket_from_buffer(), 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, ticket, and RevokeTicketMessage::tkt_len.

Here is the call graph for this function:

◆ consume_result_cb()

static void consume_result_cb ( void *  cls,
const struct GNUNET_IDENTITY_PublicKey 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
clsour consume ticket operation handle
identitythe attribute authority
attrsthe attribute/claim list
successGNUNET_OK if successful
emsgerror message (NULL if success=GNUNET_OK)

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

951 {
952  struct ConsumeTicketOperation *cop = cls;
953  struct ConsumeTicketResultMessage *crm;
954  struct GNUNET_MQ_Envelope *env;
955  char *data_tmp;
956  size_t attrs_len = 0;
957  size_t pres_len = 0;
958  size_t key_len;
959  ssize_t written;
960 
961  if (GNUNET_OK != success)
962  {
963  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error consuming ticket: %s\n", emsg);
964  }
967  presentations);
970  "Sending CONSUME_TICKET_RESULT message\n");
971  env = GNUNET_MQ_msg_extra (crm,
972  attrs_len + pres_len + key_len,
974  crm->id = htonl (cop->r_id);
975  crm->attrs_len = htons (attrs_len);
976  crm->presentations_len = htons (pres_len);
977  crm->key_len = htons (key_len);
978  crm->result = htons (success);
979  data_tmp = (char *) &crm[1];
981  data_tmp,
982  key_len);
983  GNUNET_assert (0 <= written);
984  data_tmp += written;
985  GNUNET_RECLAIM_attribute_list_serialize (attrs, data_tmp);
986  data_tmp += attrs_len;
987  GNUNET_RECLAIM_presentation_list_serialize (presentations, data_tmp);
988  GNUNET_MQ_send (cop->client->mq, env);
990  cop->client->consume_op_tail,
991  cop);
992  GNUNET_free (cop);
993 }
ssize_t GNUNET_IDENTITY_write_public_key_to_buffer(const struct GNUNET_IDENTITY_PublicKey *key, void *buffer, size_t len)
Writes a GNUNET_IDENTITY_PublicKey to a compact buffer.
Definition: identity_api.c:890
ssize_t GNUNET_IDENTITY_public_key_get_length(const struct GNUNET_IDENTITY_PublicKey *key)
Get the compacted length of a GNUNET_IDENTITY_PublicKey.
Definition: identity_api.c:830
#define GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET_RESULT
size_t GNUNET_RECLAIM_attribute_list_serialize(const struct GNUNET_RECLAIM_AttributeList *attrs, char *result)
Serialize an attribute list.
size_t GNUNET_RECLAIM_attribute_list_serialize_get_size(const struct GNUNET_RECLAIM_AttributeList *attrs)
Get required size for serialization buffer.
struct IdpClient * client
Client connection.
Attribute list is returned from the idp.
Definition: reclaim.h:554
uint16_t attrs_len
Length of serialized attribute data.
Definition: reclaim.h:578
uint16_t presentations_len
Length of presentation data.
Definition: reclaim.h:583
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:563
uint16_t key_len
The length of the private key.
Definition: reclaim.h:588
uint32_t result
Result.
Definition: reclaim.h:568
struct ConsumeTicketOperation * consume_op_head
Head of DLL of ticket consume ops.
struct ConsumeTicketOperation * consume_op_tail
Tail of DLL of ticket consume ops.

References ConsumeTicketResultMessage::attrs_len, ConsumeTicketOperation::client, IdpClient::consume_op_head, IdpClient::consume_op_tail, env, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_IDENTITY_public_key_get_length(), GNUNET_IDENTITY_write_public_key_to_buffer(), 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
clsunused
cmthe message to handle

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

1004 {
1005  uint16_t size;
1006 
1007  size = ntohs (cm->header.size);
1008  if (size <= sizeof(struct ConsumeTicketMessage))
1009  {
1010  GNUNET_break (0);
1011  return GNUNET_SYSERR;
1012  }
1013  return GNUNET_OK;
1014 }
Ticket consume message.
Definition: reclaim.h:523
struct GNUNET_MessageHeader header
Type will be GNUNET_MESSAGE_TYPE_RECLAIM_CONSUME_TICKET.
Definition: reclaim.h:527

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

◆ handle_consume_ticket_message()

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

Handle a consume ticket message.

Parameters
clsour client handle
cmthe message to handle

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

1025 {
1026  struct ConsumeTicketOperation *cop;
1027  struct IdpClient *idp = cls;
1030  size_t key_len;
1031  size_t tkt_len;
1032  size_t read;
1033  char *buf;
1034 
1035  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CONSUME_TICKET message\n");
1036  key_len = ntohs (cm->key_len);
1037  buf = (char *) &cm[1];
1038  if ((GNUNET_SYSERR ==
1040  &identity, &read)) ||
1041  (read != key_len))
1042  {
1044  "Failed to read private key\n");
1046  return;
1047  }
1048  buf += read;
1049  tkt_len = ntohs (cm->tkt_len);
1050  if ((GNUNET_SYSERR ==
1052  &ticket, &read)) ||
1053  (read != tkt_len))
1054  {
1056  "Failed to read ticket\n");
1058  return;
1059  }
1060  cop = GNUNET_new (struct ConsumeTicketOperation);
1061  cop->r_id = ntohl (cm->id);
1062  cop->client = idp;
1063  cop->ch
1065  cop);
1066  GNUNET_CONTAINER_DLL_insert (idp->consume_op_head, idp->consume_op_tail, cop);
1068 }
static void consume_result_cb(void *cls, const struct GNUNET_IDENTITY_PublicKey *identity, const struct GNUNET_RECLAIM_AttributeList *attrs, const struct GNUNET_RECLAIM_PresentationList *presentations, int32_t success, const char *emsg)
Handle a ticket consume result.
struct RECLAIM_TICKETS_ConsumeHandle * RECLAIM_TICKETS_consume(const struct GNUNET_IDENTITY_PrivateKey *id, const struct GNUNET_RECLAIM_Ticket *ticket, RECLAIM_TICKETS_ConsumeCallback cb, void *cb_cls)
Consume a ticket.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:532
uint16_t key_len
The length of the private key.
Definition: reclaim.h:537
uint16_t tkt_len
The length of the ticket.
Definition: reclaim.h:542

References buf, ConsumeTicketOperation::ch, ConsumeTicketOperation::client, GNUNET_RECLAIM_Handle::client, consume_result_cb(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_read_private_key_from_buffer(), GNUNET_log, GNUNET_new, GNUNET_RECLAIM_read_ticket_from_buffer(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SYSERR, ConsumeTicketMessage::id, identity, idp, ConsumeTicketMessage::key_len, 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
clsour attribute store handle
successGNUNET_OK if successful
emsgerror message (NULL if success=GNUNET_OK)

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

1085 {
1086  struct AttributeStoreHandle *ash = cls;
1087  struct GNUNET_MQ_Envelope *env;
1088  struct SuccessResultMessage *acr_msg;
1089 
1090  ash->ns_qe = NULL;
1092  ash->client->store_op_tail,
1093  ash);
1094 
1095  if (GNUNET_EC_NONE != ec)
1096  {
1098  "Failed to store attribute %s\n",
1100  cleanup_as_handle (ash);
1102  return;
1103  }
1104 
1105  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
1107  acr_msg->id = htonl (ash->r_id);
1108  acr_msg->op_result = htonl (GNUNET_OK);
1109  GNUNET_MQ_send (ash->client->mq, env);
1110  cleanup_as_handle (ash);
1111 }
const char * GNUNET_ErrorCode_get_hint(enum GNUNET_ErrorCode ec)
Returns a hint for a given error code.
@ GNUNET_EC_NONE
No error (success).
static void do_shutdown(void *cls)
Shutdown task.
#define GNUNET_MESSAGE_TYPE_RECLAIM_SUCCESS_RESPONSE
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1299
struct IdpClient * client
Client connection.
struct AttributeStoreHandle * store_op_head
Head of DLL of attribute store ops.
struct AttributeStoreHandle * store_op_tail
Tail of DLL of attribute store ops.
Attribute store/delete response message.
Definition: reclaim.h:106
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:115
int32_t op_result
GNUNET_SYSERR on failure, GNUNET_OK on success
Definition: reclaim.h:120

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
clsthe AttributeStoreHandle

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

1121 {
1122  struct AttributeStoreHandle *ash = cls;
1123  struct GNUNET_GNSRECORD_Data rd[1];
1124  char *buf;
1125  char *label;
1126  size_t buf_size;
1127 
1128  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing attribute\n");
1130  buf = GNUNET_malloc (buf_size);
1131  // Give the ash a new id if unset
1132  if (GNUNET_YES == GNUNET_RECLAIM_id_is_zero (&ash->claim->id))
1135  label
1137  sizeof (ash->claim->id));
1138  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Encrypting with label %s\n", label);
1139 
1140  rd[0].data_size = buf_size;
1141  rd[0].data = buf;
1144  rd[0].expiration_time = ash->exp.rel_value_us;
1146  &ash->identity,
1147  label,
1148  1,
1149  rd,
1150  &attr_store_cont,
1151  ash);
1152  GNUNET_free (buf);
1153  GNUNET_free (label);
1154 }
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE
identity attribute
static struct GNUNET_GNSRECORD_Data rd[50]
The record data under a single label.
static void attr_store_cont(void *cls, enum GNUNET_ErrorCode ec)
Attribute store result handler.
@ GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION
This expiration time of the record is a relative time (not an absolute time).
@ GNUNET_YES
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_store(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *pkey, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
Store an item in the namestore.
#define GNUNET_RECLAIM_id_is_zero(a)
#define GNUNET_RECLAIM_id_generate(id)
size_t GNUNET_RECLAIM_attribute_serialize_get_size(const struct GNUNET_RECLAIM_Attribute *attr)
Get required size for serialization buffer.
size_t GNUNET_RECLAIM_attribute_serialize(const struct GNUNET_RECLAIM_Attribute *attr, char *result)
Serialize an attribute.
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:763
struct GNUNET_IDENTITY_PrivateKey identity
Identity.
struct GNUNET_TIME_Relative exp
The attribute expiration interval.
uint32_t record_type
Type of the GNS/DNS record.
const void * data
Binary value stored in the DNS record.
size_t data_size
Number of bytes in data.
enum GNUNET_GNSRECORD_Flags flags
Flags for the record.
uint64_t expiration_time
Expiration time for the DNS record.
struct GNUNET_RECLAIM_Identifier id
ID.
uint64_t rel_value_us
The actual value.

References attr_store_cont(), buf, 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_records_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
clsunused
samthe message to check

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

1166 {
1167  uint16_t size;
1168 
1169  size = ntohs (sam->header.size);
1170  if (size <= sizeof(struct AttributeStoreMessage))
1171  {
1172  GNUNET_break (0);
1173  return GNUNET_SYSERR;
1174  }
1175  return GNUNET_OK;
1176 }
Use to store an identity attribute.
Definition: reclaim.h:41
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT.
Definition: reclaim.h:45

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
clsour client
samthe message to handle

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

1188 {
1189  struct AttributeStoreHandle *ash;
1190  struct IdpClient *idp = cls;
1192  size_t data_len;
1193  size_t key_len;
1194  size_t read;
1195  char *buf;
1196 
1197  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_STORE message\n");
1198 
1199  data_len = ntohs (sam->attr_len);
1200  key_len = ntohs (sam->key_len);
1201  buf = (char *) &sam[1];
1202  if ((GNUNET_SYSERR ==
1204  &identity, &read)) ||
1205  (read != key_len))
1206  {
1208  "Failed to read private key\n");
1210  return;
1211  }
1212  buf += read;
1213  ash = GNUNET_new (struct AttributeStoreHandle);
1215  data_len,
1216  &ash->claim);
1217 
1218  ash->r_id = ntohl (sam->id);
1219  ash->identity = identity;
1220  ash->exp.rel_value_us = GNUNET_ntohll (sam->exp);
1222 
1224  ash->client = idp;
1225  GNUNET_CONTAINER_DLL_insert (idp->store_op_head, idp->store_op_tail, ash);
1227 }
static void attr_store_task(void *cls)
Add a new attribute.
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_key_get_public(const struct GNUNET_IDENTITY_PrivateKey *privkey, struct GNUNET_IDENTITY_PublicKey *key)
Retrieves the public key representation of a private key.
Definition: identity_api.c:179
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
ssize_t GNUNET_RECLAIM_attribute_deserialize(const char *data, size_t data_size, struct GNUNET_RECLAIM_Attribute **attr)
Deserialize an attribute.
struct GNUNET_IDENTITY_PublicKey identity_pkey
Identity pubkey.
uint64_t exp
The expiration interval of the attribute.
Definition: reclaim.h:50
uint16_t key_len
The length of the private key.
Definition: reclaim.h:65
uint16_t attr_len
The length of the attribute.
Definition: reclaim.h:60
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:55

References AttributeStoreMessage::attr_len, attr_store_task(), buf, AttributeStoreHandle::claim, AttributeStoreHandle::client, GNUNET_RECLAIM_Handle::client, AttributeStoreHandle::exp, AttributeStoreMessage::exp, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_key_get_public(), GNUNET_IDENTITY_read_private_key_from_buffer(), 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
clsour attribute store handle
successGNUNET_OK if successful
emsgerror message (NULL if success=GNUNET_OK)

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

1239 {
1240  struct AttributeStoreHandle *ash = cls;
1241  struct GNUNET_MQ_Envelope *env;
1242  struct SuccessResultMessage *acr_msg;
1243 
1244  ash->ns_qe = NULL;
1246  ash->client->store_op_tail,
1247  ash);
1248 
1249  if (GNUNET_EC_NONE != ec)
1250  {
1252  "Failed to store credential: %s\n",
1254  cleanup_as_handle (ash);
1256  return;
1257  }
1258 
1259  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
1261  acr_msg->id = htonl (ash->r_id);
1262  acr_msg->op_result = htonl (GNUNET_OK);
1263  GNUNET_MQ_send (ash->client->mq, env);
1264  cleanup_as_handle (ash);
1265 }

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
clsour attribute store handle

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

1275 {
1276  struct AttributeStoreHandle *ash = cls;
1278  "Failed to check for existing credential.\n");
1279  cleanup_as_handle (ash);
1281  return;
1282 }

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_IDENTITY_PrivateKey zone,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Check for existing record before storing credential.

Parameters
clsour attribute store handle
zonezone we are iterating
labellabel of the records
rd_countrecord count
rdrecords

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

1300 {
1301  struct AttributeStoreHandle *ash = cls;
1302  struct GNUNET_GNSRECORD_Data rd_new[1];
1303  char *buf;
1304  size_t buf_size;
1305 
1307  buf = GNUNET_malloc (buf_size);
1310  "Storing new credential under `%s'.\n",
1311  label);
1312  rd_new[0].data_size = buf_size;
1313  rd_new[0].data = buf;
1314  rd_new[0].record_type = GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL;
1315  rd_new[0].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
1316  rd_new[0].expiration_time = ash->exp.rel_value_us;
1318  &ash->identity,
1319  label,
1320  1,
1321  rd_new,
1322  &cred_store_cont,
1323  ash);
1324  GNUNET_free (buf);
1325  return;
1326 }
#define GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL
Record type for an attribute attestation (e.g.
static void cred_store_cont(void *cls, enum GNUNET_ErrorCode ec)
Credential store result handler.
size_t GNUNET_RECLAIM_credential_serialize(const struct GNUNET_RECLAIM_Credential *credential, char *result)
Serialize an credential.
size_t GNUNET_RECLAIM_credential_serialize_get_size(const struct GNUNET_RECLAIM_Credential *credential)
Get required size for serialization buffer.

References buf, 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_records_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
clsthe AttributeStoreHandle

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

1336 {
1337  struct AttributeStoreHandle *ash = cls;
1338  char *label;
1339 
1340  // Give the ash a new id if unset
1344  sizeof (ash->credential->id));
1346  "Looking up existing data under label `%s'\n", label);
1348  &ash->identity,
1349  label,
1350  &cred_error,
1351  ash,
1352  &cred_add_cb,
1353  ash);
1354  GNUNET_free (label);
1355 }
static void cred_error(void *cls)
Error looking up potential credential.
static void cred_add_cb(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Check for existing record before storing credential.
struct GNUNET_NAMESTORE_QueueEntry * GNUNET_NAMESTORE_records_lookup(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *pkey, const char *label, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor rm, void *rm_cls)
Lookup an item in the namestore.
struct GNUNET_RECLAIM_Identifier id
ID.

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
clsunused
samthe message to check

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

1367 {
1368  uint16_t size;
1369 
1370  size = ntohs (sam->header.size);
1371  if (size <= sizeof(struct AttributeStoreMessage))
1372  {
1373  GNUNET_break (0);
1374  return GNUNET_SYSERR;
1375  }
1376  return GNUNET_OK;
1377 }

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
clsour client
samthe message to handle

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

1389 {
1390  struct AttributeStoreHandle *ash;
1391  struct IdpClient *idp = cls;
1393  size_t data_len;
1394  size_t key_len;
1395  size_t read;
1396  char *buf;
1397 
1398  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREDENTIAL_STORE message\n");
1399 
1400  data_len = ntohs (sam->attr_len);
1401  key_len = ntohs (sam->key_len);
1402  buf = (char *) &sam[1];
1403  if ((GNUNET_SYSERR ==
1405  &identity, &read)) ||
1406  (read != key_len))
1407  {
1409  "Failed to read private key\n");
1411  return;
1412  }
1413  buf += read;
1414  ash = GNUNET_new (struct AttributeStoreHandle);
1416  data_len);
1417 
1418  ash->r_id = ntohl (sam->id);
1419  ash->identity = identity;
1420  ash->exp.rel_value_us = GNUNET_ntohll (sam->exp);
1422 
1424  ash->client = idp;
1425  GNUNET_CONTAINER_DLL_insert (idp->store_op_head, idp->store_op_tail, ash);
1427 }
static void cred_store_task(void *cls)
Add a new credential.
struct GNUNET_RECLAIM_Credential * GNUNET_RECLAIM_credential_deserialize(const char *data, size_t data_size)
Deserialize an credential.

References AttributeStoreMessage::attr_len, buf, AttributeStoreHandle::client, GNUNET_RECLAIM_Handle::client, cred_store_task(), AttributeStoreHandle::credential, AttributeStoreHandle::exp, AttributeStoreMessage::exp, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_key_get_public(), GNUNET_IDENTITY_read_private_key_from_buffer(), 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
adhour attribute deletion handle
successthe success status

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

1438 {
1439  struct GNUNET_MQ_Envelope *env;
1440  struct SuccessResultMessage *acr_msg;
1441 
1443  adh->client->delete_op_tail,
1444  adh);
1445 
1446  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending SUCCESS_RESPONSE message\n");
1448  acr_msg->id = htonl (adh->r_id);
1449  acr_msg->op_result = htonl (success);
1450  GNUNET_MQ_send (adh->client->mq, env);
1451 }
struct IdpClient * client
Client connection.
struct AttributeDeleteHandle * delete_op_tail
Tail of DLL of attribute delete ops.
struct AttributeDeleteHandle * delete_op_head
Head of DLL of attribute delete ops.

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_IDENTITY_PrivateKey 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
clsour attribute deletion handle
zonethe private key of the ticket issuer
labelthe label of the record
rd_countnumber of records
rdrecord data

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

1470 {
1471  struct AttributeDeleteHandle *adh = cls;
1472  struct TicketRecordsEntry *le;
1475  int is_ticket = GNUNET_NO;
1476  for (int i = 0; i < rd_count; i++)
1477  {
1478  switch (rd[i].record_type)
1479  {
1483  rd[i].data_size,
1484  &ale->attribute);
1487  ale);
1488  break;
1492  rd[i].data_size);
1495  cle);
1496  break;
1499  "Ticket to delete found (%s)\n",
1500  label);
1501  is_ticket = GNUNET_YES;
1502  break;
1503  default:
1504  break;
1505  }
1506  if (GNUNET_YES == is_ticket)
1507  break;
1508  }
1509  if (GNUNET_YES == is_ticket)
1510  {
1511  le = GNUNET_new (struct TicketRecordsEntry);
1513  le->data = GNUNET_malloc (le->data_size);
1514  le->rd_count = rd_count;
1515  le->label = GNUNET_strdup (label);
1519  le);
1520  }
1522 }
#define GNUNET_GNSRECORD_TYPE_RECLAIM_TICKET
local ticket reference
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
uint32_t data
The data value.
static unsigned int rd_count
Number of records for currently parsed set.
ssize_t GNUNET_GNSRECORD_records_serialize(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, size_t dest_size, char *dest)
Serialize the given records to the given destination buffer.
GNUNET_NETWORK_STRUCT_END ssize_t GNUNET_GNSRECORD_records_get_size(unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Calculate how many bytes we will need to serialize the given records.
@ GNUNET_NO
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
void GNUNET_NAMESTORE_zone_iterator_next(struct GNUNET_NAMESTORE_ZoneIterator *it, uint64_t limit)
Calls the record processor specified in GNUNET_NAMESTORE_zone_iteration_start for the next record.
struct GNUNET_RECLAIM_AttributeListEntry * list_tail
List tail.
struct GNUNET_RECLAIM_Credential * credential
The credential.
struct GNUNET_RECLAIM_CredentialListEntry * list_head
List head.
struct GNUNET_RECLAIM_CredentialListEntry * list_tail
List tail.
unsigned int rd_count
Record count.

References GNUNET_RECLAIM_AttributeListEntry::attribute, GNUNET_RECLAIM_CredentialListEntry::credential, TicketRecordsEntry::data, 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
clsour deletion handle

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

Parameters
clsour attribute deletion handle

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

1559 {
1560  struct AttributeDeleteHandle *adh = cls;
1561  struct TicketRecordsEntry *le;
1562 
1563  if (NULL == adh->tickets_to_update_head)
1564  {
1566  "Finished updating tickets, success\n");
1568  cleanup_adh (adh);
1569  return;
1570  }
1571  le = adh->tickets_to_update_head;
1574  le);
1575  struct GNUNET_GNSRECORD_Data rd[le->rd_count];
1576  struct GNUNET_GNSRECORD_Data rd_new[le->rd_count - 1];
1578  le->data,
1579  le->rd_count,
1580  rd))
1581  {
1583  "Unable to deserialize record data!\n");
1585  cleanup_adh (adh);
1586  return;
1587  }
1588  int j = 0;
1589  int i = 0;
1592  struct GNUNET_RECLAIM_Presentation *presentation;
1593  for (i = 0; i < le->rd_count; i++)
1594  {
1595  switch (rd[i].record_type)
1596  {
1598  for (ale = adh->existing_attributes->list_head; NULL != ale; ale =
1599  ale->next)
1600  {
1602  &ale->attribute->id))
1603  {
1605  "Found attribute %s, readding...\n",
1606  ale->attribute->name);
1607  rd_new[j] = rd[i];
1608  j++;
1609  break; // Found and added
1610  }
1611  }
1612  break;
1614  presentation = GNUNET_RECLAIM_presentation_deserialize (rd[i].data,
1615  rd[i].data_size);
1616  for (cle = adh->existing_credentials->list_head; NULL != cle; cle =
1617  cle->next)
1618  {
1620  &presentation->credential_id,
1621  &cle->credential->id))
1622  {
1624  "Found presentation for credential %s, readding...\n",
1625  cle->credential->name);
1626  rd_new[j] = rd[i];
1627  j++;
1628  break; // Found and added
1629  }
1630  }
1631  GNUNET_free (presentation);
1632  break;
1634  rd_new[j] = rd[i];
1635  j++;
1636  break; // Found and added
1637  default:
1638  GNUNET_break (0);
1639  }
1640  }
1642  "Updating ticket with %d entries (%d before)...\n",
1643  j, i);
1645  &adh->identity,
1646  le->label,
1647  j,
1648  rd_new,
1649  &ticket_updated,
1650  adh);
1651  GNUNET_free (le->label);
1652  GNUNET_free (le->data);
1653  GNUNET_free (le);
1654 }
#define GNUNET_GNSRECORD_TYPE_RECLAIM_PRESENTATION
Record type for a presentation of a credential.
#define GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE_REF
for reclaim records
static void send_delete_response(struct AttributeDeleteHandle *adh, int32_t success)
Send a deletion success response.
static void ticket_updated(void *cls, enum GNUNET_ErrorCode ec)
Callback called when a ticket was updated.
int GNUNET_GNSRECORD_records_deserialize(size_t len, const char *src, unsigned int rd_count, struct GNUNET_GNSRECORD_Data *dest)
Deserialize the given records to the given destination.
#define GNUNET_RECLAIM_id_is_equal(a, b)
struct GNUNET_RECLAIM_Presentation * GNUNET_RECLAIM_presentation_deserialize(const char *data, size_t data_size)
Deserialize a presentation.
struct GNUNET_IDENTITY_PrivateKey identity
Identity.
struct GNUNET_RECLAIM_CredentialListEntry * next
DLL.
const char * name
The name of the credential.
A credential presentation.
struct GNUNET_RECLAIM_Identifier credential_id
The credential id of which this is a presentation.

References GNUNET_RECLAIM_AttributeListEntry::attribute, cleanup_adh(), GNUNET_RECLAIM_CredentialListEntry::credential, GNUNET_RECLAIM_Presentation::credential_id, TicketRecordsEntry::data, data, data_size, TicketRecordsEntry::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_records_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, TicketRecordsEntry::label, 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, TicketRecordsEntry::rd_count, 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
clsour attribute deletion handle
successGNUNET_OK if successful
emsgerror message (NULL if success=GNUNET_OK)

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

1542 {
1543  struct AttributeDeleteHandle *adh = cls;
1544 
1545  adh->ns_qe = NULL;
1547 }
static void update_tickets(void *cls)
Recursion prototype for function.

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 1689 of file gnunet-service-reclaim.c.

1690 {
1691  struct AttributeDeleteHandle *adh = cls;
1694 
1695  for (ale = adh->existing_attributes->list_head; NULL != ale; ale = ale->next)
1696  {
1697  if (GNUNET_YES ==
1699  continue;
1700 
1701  for (cle = adh->existing_credentials->list_head;
1702  NULL != cle; cle = cle->next)
1703  {
1704  if (GNUNET_YES !=
1706  &ale->attribute->credential))
1707  continue;
1708  break;
1709  }
1710  if (NULL == cle)
1711  {
1713  "Found attribute with missing credential\n");
1714  break;
1715  }
1716  }
1717  if (NULL == ale)
1718  {
1720  "Attributes consistent, updating tickets.\n");
1722  return;
1723  }
1725  "Attributes inconsistent, deleting offending attribute.\n");
1726  char *label
1728  sizeof(ale->attribute->id));
1729 
1731  &adh->identity,
1732  label,
1733  0,
1734  NULL,
1736  adh);
1739  ale);
1740  GNUNET_free (ale);
1741  GNUNET_free (label);
1742 }
static void offending_attr_delete_cont(void *cls, enum GNUNET_ErrorCode ec)
@ GNUNET_ERROR_TYPE_WARNING
struct GNUNET_RECLAIM_Identifier credential
Referenced ID of credential (may be GNUNET_RECLAIM_ID_ZERO if self-creded)

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_records_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 1665 of file gnunet-service-reclaim.c.

1666 {
1667  struct AttributeDeleteHandle *adh = cls;
1668 
1669  adh->ns_qe = NULL;
1670  if (GNUNET_EC_NONE != ec)
1671  {
1673  "Error deleting attribute %s\n",
1674  adh->label);
1676  cleanup_adh (adh);
1677  return;
1678  }
1679  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Continuing consistency check...\n");
1681 }
static void purge_attributes(void *cls)
Delete all attributes which reference credentials that no longer exist.

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
clsour attribute deletion handle

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

1752 {
1753  struct AttributeDeleteHandle *adh = cls;
1754  adh->ns_it = NULL;
1756 }

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
clsour attribute deletion handle

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

1766 {
1767  struct AttributeDeleteHandle *adh = cls;
1768 
1769  adh->ns_it = NULL;
1771  "Namestore error on consistency check\n");
1773  cleanup_adh (adh);
1774 }

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
clsattribute deletion handle

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

1785 {
1786  struct AttributeDeleteHandle *adh = cls;
1787 
1790 
1792  &adh->identity,
1794  adh,
1796  adh,
1798  adh);
1799 }
static void consistency_iter(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Namestore iteration within attribute deletion.
static void consistency_iter_err(void *cls)
Error collecting affected tickets.
static void consistency_iter_fin(void *cls)
Done collecting affected tickets, start updating.
struct GNUNET_NAMESTORE_ZoneIterator * GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h, const struct GNUNET_IDENTITY_PrivateKey *zone, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)
A list of GNUNET_RECLAIM_Credential structures.

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
clsour handle
successsuccess status
emsgerror message (NULL if success=GNUNET_OK)

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

1811 {
1812  struct AttributeDeleteHandle *adh = cls;
1813 
1814  adh->ns_qe = NULL;
1815  if (GNUNET_EC_NONE != ec)
1816  {
1818  "Error deleting attribute %s\n",
1819  adh->label);
1821  cleanup_adh (adh);
1822  return;
1823  }
1824  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating tickets...\n");
1826 }
static void start_consistency_update(void *cls)
Start processing tickets which may still contain reference to deleted attribute.

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
clsunused
dammessage to check

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

1838 {
1839  uint16_t size;
1840 
1841  size = ntohs (dam->header.size);
1842  if (size <= sizeof(struct AttributeDeleteMessage))
1843  {
1844  GNUNET_break (0);
1845  return GNUNET_SYSERR;
1846  }
1847  return GNUNET_OK;
1848 }
Use to delete an identity attribute.
Definition: reclaim.h:77
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT.
Definition: reclaim.h:81

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
clsour client
damdeletion message

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

1860 {
1861  struct AttributeDeleteHandle *adh;
1862  struct IdpClient *idp = cls;
1864  size_t data_len;
1865  size_t key_len;
1866  size_t read;
1867  char *buf;
1868 
1869  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received ATTRIBUTE_DELETE message\n");
1870 
1871  data_len = ntohs (dam->attr_len);
1872  key_len = ntohs (dam->key_len);
1873  buf = (char *) &dam[1];
1874  if ((GNUNET_SYSERR ==
1876  &identity, &read)) ||
1877  (read != key_len))
1878  {
1880  "Failed to read private key\n");
1882  return;
1883  }
1884  buf += read;
1885  adh = GNUNET_new (struct AttributeDeleteHandle);
1887  data_len,
1888  &adh->claim);
1889  adh->credential = NULL;
1890 
1891  adh->r_id = ntohl (dam->id);
1892  adh->identity = identity;
1893  adh->label
1895  sizeof(adh->claim->id));
1897  adh->client = idp;
1898  GNUNET_CONTAINER_DLL_insert (idp->delete_op_head, idp->delete_op_tail, adh);
1900  &adh->identity,
1901  adh->label,
1902  0,
1903  NULL,
1905  adh);
1906 }
static void attr_delete_cont(void *cls, enum GNUNET_ErrorCode ec)
Attribute deleted callback.
uint16_t key_len
The length of the private key.
Definition: reclaim.h:96
uint16_t attr_len
The length of the attribute.
Definition: reclaim.h:91
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:86

References attr_delete_cont(), AttributeDeleteMessage::attr_len, buf, AttributeDeleteHandle::claim, AttributeDeleteHandle::client, GNUNET_RECLAIM_Handle::client, AttributeDeleteHandle::credential, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_read_private_key_from_buffer(), GNUNET_log, GNUNET_NAMESTORE_records_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
clsour handle
successsuccess status
emsgerror message (NULL if success=GNUNET_OK)

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

1918 {
1919  struct AttributeDeleteHandle *adh = cls;
1920 
1921  adh->ns_qe = NULL;
1922  if (GNUNET_EC_NONE != ec)
1923  {
1925  "Error deleting credential `%s'\n",
1926  adh->label);
1928  cleanup_adh (adh);
1929  return;
1930  }
1931  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating tickets...\n");
1933 }

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
clsunused
dammessage to check

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

1945 {
1946  uint16_t size;
1947 
1948  size = ntohs (dam->header.size);
1949  if (size <= sizeof(struct AttributeDeleteMessage))
1950  {
1951  GNUNET_break (0);
1952  return GNUNET_SYSERR;
1953  }
1954  return GNUNET_OK;
1955 }

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
clsour client
damdeletion message

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

1967 {
1968  struct AttributeDeleteHandle *adh;
1969  struct IdpClient *idp = cls;
1971  size_t data_len;
1972  size_t key_len;
1973  size_t read;
1974  char *buf;
1975 
1976  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received CREDENTIAL_DELETE message\n");
1977 
1978  data_len = ntohs (dam->attr_len);
1979  key_len = ntohs (dam->key_len);
1980  buf = (char *) &dam[1];
1981  if ((GNUNET_SYSERR ==
1983  &identity, &read)) ||
1984  (read != key_len))
1985  {
1987  "Failed to read private key\n");
1989  return;
1990  }
1991  buf += read;
1992  adh = GNUNET_new (struct AttributeDeleteHandle);
1994  data_len);
1995  adh->claim = NULL;
1996 
1997  adh->r_id = ntohl (dam->id);
1998  adh->identity = identity;
1999  adh->label
2001  sizeof(adh->credential->id));
2003  adh->client = idp;
2004  GNUNET_CONTAINER_DLL_insert (idp->delete_op_head, idp->delete_op_tail, adh);
2006  &adh->identity,
2007  adh->label,
2008  0,
2009  NULL,
2011  adh);
2012 }
static void cred_delete_cont(void *cls, enum GNUNET_ErrorCode ec)
Credential deleted callback.

References AttributeDeleteMessage::attr_len, buf, AttributeDeleteHandle::claim, AttributeDeleteHandle::client, GNUNET_RECLAIM_Handle::client, cred_delete_cont(), AttributeDeleteHandle::credential, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_read_private_key_from_buffer(), GNUNET_log, GNUNET_NAMESTORE_records_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
clsour iterator handle

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

2027 {
2028  struct Iterator *ai = cls;
2029  struct GNUNET_MQ_Envelope *env;
2030  struct AttributeResultMessage *arm;
2031 
2032  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ATTRIBUTE_RESULT message\n");
2034  arm->id = htonl (ai->request_id);
2035  arm->attr_len = htons (0);
2036  arm->pkey_len = htons (0);
2037  GNUNET_MQ_send (ai->client->mq, env);
2038  GNUNET_CONTAINER_DLL_remove (ai->client->attr_iter_head,
2039  ai->client->attr_iter_tail,
2040  ai);
2041  GNUNET_free (ai);
2042 }
#define GNUNET_MESSAGE_TYPE_RECLAIM_ATTRIBUTE_RESULT
Attribute is returned from the idp.
Definition: reclaim.h:127
uint16_t attr_len
Length of serialized attribute data.
Definition: reclaim.h:146
uint16_t pkey_len
The length of the public key.
Definition: reclaim.h:156
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:136

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
clsour attribute iteration handle

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

2052 {
2053  struct Iterator *ai = cls;
2054 
2055  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over attributes\n");
2057 }
static void attr_iter_finished(void *cls)
Done iterating over attributes.

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_IDENTITY_PrivateKey zone,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Got record.

Return if it is an attribute.

Parameters
clsour attribute iterator
zonezone we are iterating
labellabel of the records
rd_countrecord count
rdrecords

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

2075 {
2076  struct Iterator *ai = cls;
2077  struct GNUNET_MQ_Envelope *env;
2079  char *data_tmp;
2080  size_t key_len;
2081  ssize_t written;
2082 
2083  if ((rd_count != 1) ||
2085  {
2087  return;
2088  }
2089  struct AttributeResultMessage *arm;
2090  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found attribute under: %s\n",
2091  label);
2093  "Sending ATTRIBUTE_RESULT message\n");
2096  env = GNUNET_MQ_msg_extra (arm,
2097  rd->data_size + key_len,
2099  arm->id = htonl (ai->request_id);
2100  arm->attr_len = htons (rd->data_size);
2101  data_tmp = (char *) &arm[1];
2102  arm->pkey_len = htons (key_len);
2104  data_tmp,
2105  key_len);
2106  GNUNET_assert (0 <= written);
2107  data_tmp += written;
2108  GNUNET_memcpy (data_tmp, rd->data, rd->data_size);
2109  GNUNET_MQ_send (ai->client->mq, env);
2110 }
static char * zone
Name of the zone being managed.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.

References ai, AttributeResultMessage::attr_len, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_TYPE_RECLAIM_ATTRIBUTE, GNUNET_IDENTITY_key_get_public(), GNUNET_IDENTITY_public_key_get_length(), GNUNET_IDENTITY_write_public_key_to_buffer(), 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, GNUNET_GNSRECORD_Data::record_type, and zone.

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 2070 of file gnunet-service-reclaim.c.

2117 {
2118  uint16_t size;
2119  size_t key_len;
2120 
2121  size = ntohs (ais_msg->header.size);
2122  key_len = ntohs (ais_msg->key_len);
2123 
2124  if (size < key_len + sizeof(*ais_msg))
2125  {
2126  GNUNET_break (0);
2127  return GNUNET_SYSERR;
2128  }
2129  return GNUNET_OK;
2130 }
uint16_t key_len
The length of the private key.
Definition: reclaim.h:221
struct GNUNET_MessageHeader header
Message.
Definition: reclaim.h:206

◆ handle_iteration_start()

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

Iterate over zone to get attributes.

Parameters
clsour client
ais_msgthe iteration message to start

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

2141 {
2142  struct IdpClient *idp = cls;
2143  struct Iterator *ai;
2145  size_t key_len;
2146  size_t read;
2147 
2149  "Received ATTRIBUTE_ITERATION_START message\n");
2150  key_len = ntohs (ais_msg->key_len);
2151  if ((GNUNET_SYSERR ==
2153  key_len,
2154  &identity,
2155  &read)) ||
2156  (read != key_len))
2157  {
2159  "Failed to read private key.\n");
2161  return;
2162  }
2163  ai = GNUNET_new (struct Iterator);
2164  ai->request_id = ntohl (ais_msg->id);
2165  ai->client = idp;
2166  ai->identity = identity;
2167 
2168  GNUNET_CONTAINER_DLL_insert (idp->attr_iter_head, idp->attr_iter_tail, ai);
2170  &ai->identity,
2171  &attr_iter_error,
2172  ai,
2173  &attr_iter_cb,
2174  ai,
2176  ai);
2178 }
static void attr_iter_cb(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Got record.
static void attr_iter_error(void *cls)
Error iterating over attributes.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:211

References ai, attr_iter_cb(), attr_iter_error(), attr_iter_finished(), GNUNET_RECLAIM_Handle::client, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_read_private_key_from_buffer(), 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
clsthe client
ais_msgthe stop message

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

2190 {
2191  struct IdpClient *idp = cls;
2192  struct Iterator *ai;
2193  uint32_t rid;
2194 
2196  "Received `%s' message\n",
2197  "ATTRIBUTE_ITERATION_STOP");
2198  rid = ntohl (ais_msg->id);
2199  for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
2200  if (ai->request_id == rid)
2201  break;
2202  if (NULL == ai)
2203  {
2204  GNUNET_break (0);
2206  return;
2207  }
2208  GNUNET_CONTAINER_DLL_remove (idp->attr_iter_head, idp->attr_iter_tail, ai);
2209  GNUNET_free (ai);
2211 }
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:324
struct GNUNET_TRANSPORT_AddressIdentifier * next
Kept in a DLL.

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
clsthe client
ais_msgthe message

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

2223 {
2224  struct IdpClient *idp = cls;
2225  struct Iterator *ai;
2226  uint32_t rid;
2227 
2229  "Received ATTRIBUTE_ITERATION_NEXT message\n");
2230  rid = ntohl (ais_msg->id);
2231  for (ai = idp->attr_iter_head; NULL != ai; ai = ai->next)
2232  if (ai->request_id == rid)
2233  break;
2234  if (NULL == ai)
2235  {
2236  GNUNET_break (0);
2238  return;
2239  }
2242 }
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:242

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
clsour iterator handle

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

2257 {
2258  struct Iterator *ai = cls;
2259  struct GNUNET_MQ_Envelope *env;
2260  struct CredentialResultMessage *arm;
2261 
2262  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending CREDENTIAL_RESULT message\n");
2264  arm->id = htonl (ai->request_id);
2265  arm->credential_len = htons (0);
2266  arm->key_len = htons (0);
2267  GNUNET_MQ_send (ai->client->mq, env);
2268  GNUNET_CONTAINER_DLL_remove (ai->client->cred_iter_head,
2269  ai->client->cred_iter_tail,
2270  ai);
2271  GNUNET_free (ai);
2272 }
#define GNUNET_MESSAGE_TYPE_RECLAIM_CREDENTIAL_RESULT
Credential is returned from the idp.
Definition: reclaim.h:169
uint16_t credential_len
Length of serialized attribute data.
Definition: reclaim.h:183
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:178
uint16_t key_len
The length of the public key.
Definition: reclaim.h:188

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
clsour attribute iteration handle

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

2282 {
2283  struct Iterator *ai = cls;
2284 
2285  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to iterate over credentials\n");
2287 }
static void cred_iter_finished(void *cls)
Done iterating over credentials.

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_IDENTITY_PrivateKey zone,
const char *  label,
unsigned int  rd_count,
const struct GNUNET_GNSRECORD_Data rd 
)
static

Got record.

Return credential.

Parameters
clsour attribute iterator
zonezone we are iterating
labellabel of the records
rd_countrecord count
rdrecords

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

2305 {
2306  struct Iterator *ai = cls;
2307  struct GNUNET_MQ_Envelope *env;
2308  struct CredentialResultMessage *arm;
2310  char *data_tmp;
2311  size_t key_len;
2312  ssize_t written;
2313 
2314  if ((rd_count != 1) ||
2316  {
2318  return;
2319  }
2320  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found credential under: %s\n",
2321  label);
2323  "Sending CREDENTIAL_RESULT message\n");
2326  env = GNUNET_MQ_msg_extra (arm,
2327  rd->data_size + key_len,
2329  arm->id = htonl (ai->request_id);
2330  arm->credential_len = htons (rd->data_size);
2331  arm->key_len = htons (key_len);
2332  data_tmp = (char *) &arm[1];
2334  data_tmp,
2335  key_len);
2336  GNUNET_assert (written >= 0);
2337  data_tmp += written;
2338  GNUNET_memcpy (data_tmp, rd->data, rd->data_size);
2339  GNUNET_MQ_send (ai->client->mq, env);
2340 }

Referenced by handle_credential_iteration_start().

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 2300 of file gnunet-service-reclaim.c.

2346 {
2347  uint16_t size;
2348  size_t key_len;
2349 
2350  size = ntohs (cis_msg->header.size);
2351  key_len = ntohs (cis_msg->key_len);
2352 
2353  if (size < key_len + sizeof(*cis_msg))
2354  {
2355  GNUNET_break (0);
2356  return GNUNET_SYSERR;
2357  }
2358  return GNUNET_OK;
2359 }
struct GNUNET_MessageHeader header
Message.
Definition: reclaim.h:254
uint16_t key_len
The length of the private key.
Definition: reclaim.h:269

References ai, CredentialResultMessage::credential_len, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_TYPE_RECLAIM_CREDENTIAL, GNUNET_IDENTITY_key_get_public(), GNUNET_IDENTITY_public_key_get_length(), GNUNET_IDENTITY_write_public_key_to_buffer(), 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, GNUNET_GNSRECORD_Data::record_type, and zone.

Here is the call graph for this function:

◆ 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
clsour client
ais_msgthe iteration message to start

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

2372 {
2373  struct IdpClient *idp = cls;
2374  struct Iterator *ai;
2376  size_t key_len;
2377  size_t read;
2378 
2380  "Received CREDENTIAL_ITERATION_START message\n");
2381  key_len = ntohs (ais_msg->key_len);
2382  if ((GNUNET_SYSERR ==
2384  key_len,
2385  &identity,
2386  &read)) ||
2387  (read != key_len))
2388  {
2390  "Failed to read private key.\n");
2392  return;
2393  }
2394  ai = GNUNET_new (struct Iterator);
2395  ai->request_id = ntohl (ais_msg->id);
2396  ai->client = idp;
2397  ai->identity = identity;
2398 
2399  GNUNET_CONTAINER_DLL_insert (idp->cred_iter_head, idp->cred_iter_tail,
2400  ai);
2402  &ai->identity,
2403  &cred_iter_error,
2404  ai,
2405  &cred_iter_cb,
2406  ai,
2408  ai);
2410 }
static void cred_iter_error(void *cls)
Error iterating over credentials.
static void cred_iter_cb(void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
Got record.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:259

References ai, GNUNET_RECLAIM_Handle::client, cred_iter_cb(), cred_iter_error(), cred_iter_finished(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_read_private_key_from_buffer(), 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
clsthe client
ais_msgthe stop message

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

2423 {
2424  struct IdpClient *idp = cls;
2425  struct Iterator *ai;
2426  uint32_t rid;
2427 
2429  "Received `%s' message\n",
2430  "CREDENTIAL_ITERATION_STOP");
2431  rid = ntohl (ais_msg->id);
2432  for (ai = idp->cred_iter_head; NULL != ai; ai = ai->next)
2433  if (ai->request_id == rid)
2434  break;
2435  if (NULL == ai)
2436  {
2437  GNUNET_break (0);
2439  return;
2440  }
2441  GNUNET_CONTAINER_DLL_remove (idp->cred_iter_head, idp->cred_iter_tail,
2442  ai);
2443  GNUNET_free (ai);
2445 }
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:307

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
clsthe client
ais_msgthe message

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

2458 {
2459  struct IdpClient *idp = cls;
2460  struct Iterator *ai;
2461  uint32_t rid;
2462 
2464  "Received CREDENTIAL_ITERATION_NEXT message\n");
2465  rid = ntohl (ais_msg->id);
2466  for (ai = idp->cred_iter_head; NULL != ai; ai = ai->next)
2467  if (ai->request_id == rid)
2468  break;
2469  if (NULL == ai)
2470  {
2471  GNUNET_break (0);
2473  return;
2474  }
2477 }
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:290

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 
)
static

Got a ticket.

Return to client

Parameters
clsour ticket iterator
ticketthe ticket

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

2492 {
2493  struct TicketIteration *ti = cls;
2494  struct GNUNET_MQ_Envelope *env;
2495  struct TicketResultMessage *trm;
2496  size_t tkt_len;
2497 
2498  if (NULL == ticket)
2499  tkt_len = 0;
2500  else
2502 
2503  env = GNUNET_MQ_msg_extra (trm,
2504  tkt_len,
2506  if (NULL == ticket)
2507  {
2508  /* send empty response to indicate end of list */
2510  ti->client->ticket_iter_tail,
2511  ti);
2512  }
2513  else
2514  {
2516  &trm[1],
2517  tkt_len);
2518  }
2519  trm->tkt_len = htons (tkt_len);
2520  trm->id = htonl (ti->r_id);
2521  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending TICKET_RESULT message\n");
2522  GNUNET_MQ_send (ti->client->mq, env);
2523  if (NULL == ticket)
2524  GNUNET_free (ti);
2525 }
struct TicketIteration * ticket_iter_tail
Tail of DLL of ticket iteration ops.
struct TicketIteration * ticket_iter_head
Head of DLL of ticket iteration ops.
struct IdpClient * client
Client which intiated this zone iteration.
uint32_t r_id
The operation id for the iteration in the response for the client.

Referenced by handle_ticket_iteration_start().

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 2491 of file gnunet-service-reclaim.c.

2531 {
2532  uint16_t size;
2533  size_t key_len;
2534 
2535  size = ntohs (tis_msg->header.size);
2536  key_len = ntohs (tis_msg->key_len);
2537 
2538  if (size < key_len + sizeof(*tis_msg))
2539  {
2540  GNUNET_break (0);
2541  return GNUNET_SYSERR;
2542  }
2543  return GNUNET_OK;
2544 }
uint16_t key_len
The length of the private key.
Definition: reclaim.h:350
struct GNUNET_MessageHeader header
Message.
Definition: reclaim.h:335

References TicketIteration::client, env, 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(), GNUNET_RECLAIM_ticket_serialize_get_size(), GNUNET_RECLAIM_write_ticket_to_buffer(), TicketResultMessage::id, IdpClient::mq, TicketIteration::r_id, ticket, IdpClient::ticket_iter_head, IdpClient::ticket_iter_tail, and TicketResultMessage::tkt_len.

Here is the call graph for this function:

◆ handle_ticket_iteration_start()

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

Client requests a ticket iteration.

Parameters
clsthe client
tis_msgthe iteration request message

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

2556 {
2558  struct IdpClient *client = cls;
2559  struct TicketIteration *ti;
2560  size_t key_len;
2561  size_t read;
2562 
2564  "Received TICKET_ITERATION_START message\n");
2565  key_len = ntohs (tis_msg->key_len);
2566  if ((GNUNET_SYSERR ==
2568  key_len,
2569  &identity,
2570  &read)) ||
2571  (read != key_len))
2572  {
2574  "Failed to read private key\n");
2576  return;
2577  }
2578  ti = GNUNET_new (struct TicketIteration);
2579  ti->r_id = ntohl (tis_msg->id);
2580  ti->client = client;
2583  ti);
2584  ti->iter
2587 }
static void ticket_iter_cb(void *cls, struct GNUNET_RECLAIM_Ticket *ticket)
Got a ticket.
struct RECLAIM_TICKETS_Iterator * RECLAIM_TICKETS_iteration_start(const struct GNUNET_IDENTITY_PrivateKey *identity, RECLAIM_TICKETS_TicketIter cb, void *cb_cls)
Iterate over all tickets issued by an identity.
struct GNUNET_SERVICE_Client * client
The client.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:340

References TicketIteration::client, IdpClient::client, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_read_private_key_from_buffer(), 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
clsthe client
tis_msgthe stop message

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

2599 {
2600  struct IdpClient *client = cls;
2601  struct TicketIteration *ti;
2602  uint32_t rid;
2603 
2605  "Received `%s' message\n",
2606  "TICKET_ITERATION_STOP");
2607  rid = ntohl (tis_msg->id);
2608  for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next)
2609  if (ti->r_id == rid)
2610  break;
2611  if (NULL == ti)
2612  {
2613  GNUNET_break (0);
2615  return;
2616  }
2620  ti);
2621  GNUNET_free (ti);
2623 }
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:388
struct TicketIteration * next
DLL.

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
clsthe client
tis_msgthe message

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

2635 {
2636  struct IdpClient *client = cls;
2637  struct TicketIteration *ti;
2638  uint32_t rid;
2639 
2641  "Received TICKET_ITERATION_NEXT message\n");
2642  rid = ntohl (tis_msg->id);
2643  for (ti = client->ticket_iter_head; NULL != ti; ti = ti->next)
2644  if (ti->r_id == rid)
2645  break;
2646  if (NULL == ti)
2647  {
2648  GNUNET_break (0);
2650  return;
2651  }
2654 }
void RECLAIM_TICKETS_iteration_next(struct RECLAIM_TICKETS_Iterator *iter)
Continue ticket iteration.
uint32_t id
Unique identifier for this request (for key collisions).
Definition: reclaim.h:371

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
clsclosure
cthe configuration used
serverthe service handle

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

2668 {
2669  cfg = c;
2670 
2672  {
2674  "Unable to initialize TICKETS subsystem.\n");
2676  return;
2677  }
2678  // Connect to identity and namestore services
2680  if (NULL == nsh)
2681  {
2683  "error connecting to namestore");
2684  }
2685 
2687 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
int RECLAIM_TICKETS_init(const struct GNUNET_CONFIGURATION_Handle *c)
Initialize tickets component.
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the namestore service.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:562
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1334

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
clsclosure
clientidentification of the client
app_ctxclient

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

2701 {
2702  struct IdpClient *idp = app_ctx;
2703 
2704  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p disconnected\n", client);
2707  idp);
2708  cleanup_client (idp);
2709 }
static struct IdpClient * client_list_tail
Client list.
static struct IdpClient * client_list_head
Client list.
static void cleanup_client(struct IdpClient *idp)
Cleanup client.

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
clsNULL
clientclient to add
mqmessage queue for client
Returns
internal namestore client structure for this client

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

2724 {
2725  struct IdpClient *idp;
2726 
2727  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Client %p connected\n", client);
2728  idp = GNUNET_new (struct IdpClient);
2729  idp->client = client;
2730  idp->mq = mq;
2733  idp);
2734  return idp;
2735 }
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MQ_Handle * mq
Connection to service (if available).
Definition: reclaim_api.c:391

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 ( "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

◆ timeout_task

struct GNUNET_SCHEDULER_Task* timeout_task
static

Timeout task.

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

Referenced by cleanup().

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

Our configuration.

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

Referenced by run().

◆ client_list_head

struct IdpClient* client_list_head = NULL
static

Client list.

Definition at line 475 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 480 of file gnunet-service-reclaim.c.

Referenced by client_connect_cb(), and client_disconnect_cb().