Set service

Two-peer set operations. More...

Collaboration diagram for Set service:

Data Structures
struct	GNUNET_SET_Element
	Element stored in a set. More...
struct	GNUNET_SET_Option
	Option for set operations. More...
struct	GNUNET_SETI_Element
	Element stored in a set. More...
struct	GNUNET_SETI_Option
	Option for set operations. More...
struct	GNUNET_SETU_Element
	Element stored in a set. More...
struct	GNUNET_SETU_Option
	Option for set operations. More...

Macros
#define	GNUNET_SET_CONTEXT_MESSAGE_MAX_SIZE   ((1 << 16) - 1024)
	Maximum size of a context message for set operation requests. More...
#define	GNUNET_SETI_CONTEXT_MESSAGE_MAX_SIZE   ((1 << 16) - 1024)
	Maximum size of a context message for set operation requests. More...
#define	GNUNET_SETU_CONTEXT_MESSAGE_MAX_SIZE   ((1 << 16) - 1024)
	Maximum size of a context message for set operation requests. More...

Typedefs
typedef void(*	GNUNET_SET_Continuation) (void *cls)
	Continuation used for some of the set operations. More...
typedef void(*	GNUNET_SET_ResultIterator) (void *cls, const struct GNUNET_SET_Element *element, uint64_t current_size, enum GNUNET_SET_Status status)
	Callback for set operation results. More...
typedef int(*	GNUNET_SET_ElementIterator) (void *cls, const struct GNUNET_SET_Element *element)
	Iterator for set elements. More...
typedef void(*	GNUNET_SET_ListenCallback) (void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SET_Request *request)
	Called when another peer wants to do a set operation with the local peer. More...
typedef void(*	GNUNET_SET_CopyReadyCallback) (void *cls, struct GNUNET_SET_Handle *copy)
typedef void(*	GNUNET_SETI_ResultIterator) (void *cls, const struct GNUNET_SETI_Element *element, uint64_t current_size, enum GNUNET_SETI_Status status)
	Callback for set union operation results. More...
typedef void(*	GNUNET_SETI_ListenCallback) (void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SETI_Request *request)
	Called when another peer wants to do a set operation with the local peer. More...
typedef void(*	GNUNET_SETU_ResultIterator) (void *cls, const struct GNUNET_SETU_Element *element, uint64_t current_size, enum GNUNET_SETU_Status status)
	Callback for set union operation results. More...
typedef void(*	GNUNET_SETU_ListenCallback) (void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SETU_Request *request)
	Called when another peer wants to do a set operation with the local peer. More...

Enumerations
enum	GNUNET_SET_OperationType { GNUNET_SET_OPERATION_NONE , GNUNET_SET_OPERATION_INTERSECTION , GNUNET_SET_OPERATION_UNION }
	The operation that a set set supports. More...
enum	GNUNET_SET_Status {   GNUNET_SET_STATUS_OK , GNUNET_SET_STATUS_ADD_LOCAL , GNUNET_SET_STATUS_ADD_REMOTE , GNUNET_SET_STATUS_FAILURE ,   GNUNET_SET_STATUS_HALF_DONE , GNUNET_SET_STATUS_DONE }
	Status for the result callback. More...
enum	GNUNET_SET_ResultMode { GNUNET_SET_RESULT_FULL , GNUNET_SET_RESULT_SYMMETRIC , GNUNET_SET_RESULT_REMOVED , GNUNET_SET_RESULT_ADDED }
	The way results are given to the client. More...
enum	GNUNET_SET_OptionType { GNUNET_SET_OPTION_END =0 , GNUNET_SET_OPTION_BYZANTINE =1 , GNUNET_SET_OPTION_FORCE_FULL =2 , GNUNET_SET_OPTION_FORCE_DELTA =4 }
	Possible options to pass to a set operation. More...
enum	GNUNET_SETI_Status { GNUNET_SETI_STATUS_ADD_LOCAL , GNUNET_SETI_STATUS_DEL_LOCAL , GNUNET_SETI_STATUS_FAILURE , GNUNET_SETI_STATUS_DONE }
	Status for the result callback. More...
enum	GNUNET_SETI_OptionType { GNUNET_SETI_OPTION_END = 0 , GNUNET_SETI_OPTION_RETURN_INTERSECTION = 1 }
	Possible options to pass to a set operation. More...
enum	GNUNET_SETU_Status { GNUNET_SETU_STATUS_ADD_LOCAL , GNUNET_SETU_STATUS_ADD_REMOTE , GNUNET_SETU_STATUS_FAILURE , GNUNET_SETU_STATUS_DONE }
	Status for the result callback. More...
enum	GNUNET_SETU_OptionType {   GNUNET_SETU_OPTION_END =0 , GNUNET_SETU_OPTION_BYZANTINE =1 , GNUNET_SETU_OPTION_FORCE_FULL =2 , GNUNET_SETU_OPTION_FORCE_DELTA =4 ,   GNUNET_SETU_OPTION_SYMMETRIC = 8 , GNUNET_SETU_OPTION_CUSTOM_BYZANTINE_UPPER_BOUND = 16 , GNUNET_SETU_OPTION_CUSTOM_BANDWIDTH_LATENCY_TRADEOFF = 32 , GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKET_NUMBER_FACTOR = 64 ,   GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKETS_PER_ELEMENT = 128 }
	Possible options to pass to a set operation. More...

Functions
struct GNUNET_SET_Handle *	GNUNET_SET_create (const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_SET_OperationType op)
	Create an empty set, supporting the specified operation. More...
int	GNUNET_SET_add_element (struct GNUNET_SET_Handle *set, const struct GNUNET_SET_Element *element, GNUNET_SET_Continuation cont, void *cont_cls)
	Add an element to the given set. More...
int	GNUNET_SET_remove_element (struct GNUNET_SET_Handle *set, const struct GNUNET_SET_Element *element, GNUNET_SET_Continuation cont, void *cont_cls)
	Remove an element to the given set. More...
void	GNUNET_SET_copy_lazy (struct GNUNET_SET_Handle *set, GNUNET_SET_CopyReadyCallback cb, void *cls)
void	GNUNET_SET_destroy (struct GNUNET_SET_Handle *set)
	Destroy the set handle, and free all associated resources. More...
struct GNUNET_SET_OperationHandle *	GNUNET_SET_prepare (const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, enum GNUNET_SET_ResultMode result_mode, struct GNUNET_SET_Option options[], GNUNET_SET_ResultIterator result_cb, void *result_cls)
	Prepare a set operation to be evaluated with another peer. More...
struct GNUNET_SET_ListenHandle *	GNUNET_SET_listen (const struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_SET_OperationType op_type, const struct GNUNET_HashCode *app_id, GNUNET_SET_ListenCallback listen_cb, void *listen_cls)
	Wait for set operation requests for the given application ID. More...
void	GNUNET_SET_listen_cancel (struct GNUNET_SET_ListenHandle *lh)
	Cancel the given listen operation. More...
struct GNUNET_SET_OperationHandle *	GNUNET_SET_accept (struct GNUNET_SET_Request *request, enum GNUNET_SET_ResultMode result_mode, struct GNUNET_SET_Option options[], GNUNET_SET_ResultIterator result_cb, void *result_cls)
	Accept a request we got via GNUNET_SET_listen(). More...
int	GNUNET_SET_commit (struct GNUNET_SET_OperationHandle *oh, struct GNUNET_SET_Handle *set)
	Commit a set to be used with a set operation. More...
void	GNUNET_SET_operation_cancel (struct GNUNET_SET_OperationHandle *oh)
	Cancel the given set operation. More...
int	GNUNET_SET_iterate (struct GNUNET_SET_Handle *set, GNUNET_SET_ElementIterator iter, void *iter_cls)
	Iterate over all elements in the given set. More...
void	GNUNET_SET_iterate_cancel (struct GNUNET_SET_Handle *set)
	Stop iteration over all elements in the given set. More...
struct GNUNET_SET_Element *	GNUNET_SET_element_dup (const struct GNUNET_SET_Element *element)
	Create a copy of an element. More...
void	GNUNET_SET_element_hash (const struct GNUNET_SET_Element *element, struct GNUNET_HashCode *ret_hash)
	Hash a set element. More...
struct GNUNET_SETI_Handle *	GNUNET_SETI_create (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Create an empty set, supporting the specified operation. More...
int	GNUNET_SETI_add_element (struct GNUNET_SETI_Handle *set, const struct GNUNET_SETI_Element *element, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
	Add an element to the given set. More...
void	GNUNET_SETI_destroy (struct GNUNET_SETI_Handle *set)
	Destroy the set handle, and free all associated resources. More...
struct GNUNET_SETI_OperationHandle *	GNUNET_SETI_prepare (const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, const struct GNUNET_SETI_Option options[], GNUNET_SETI_ResultIterator result_cb, void *result_cls)
	Prepare a set operation to be evaluated with another peer. More...
struct GNUNET_SETI_ListenHandle *	GNUNET_SETI_listen (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_HashCode *app_id, GNUNET_SETI_ListenCallback listen_cb, void *listen_cls)
	Wait for set operation requests for the given application ID. More...
void	GNUNET_SETI_listen_cancel (struct GNUNET_SETI_ListenHandle *lh)
	Cancel the given listen operation. More...
struct GNUNET_SETI_OperationHandle *	GNUNET_SETI_accept (struct GNUNET_SETI_Request *request, const struct GNUNET_SETI_Option options[], GNUNET_SETI_ResultIterator result_cb, void *result_cls)
	Accept a request we got via GNUNET_SETI_listen(). More...
int	GNUNET_SETI_commit (struct GNUNET_SETI_OperationHandle *oh, struct GNUNET_SETI_Handle *set)
	Commit a set to be used with a set operation. More...
void	GNUNET_SETI_operation_cancel (struct GNUNET_SETI_OperationHandle *oh)
	Cancel the given set operation. More...
void	GNUNET_SETI_element_hash (const struct GNUNET_SETI_Element *element, struct GNUNET_HashCode *ret_hash)
	Hash a set element. More...
struct GNUNET_SETU_Handle *	GNUNET_SETU_create (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Create an empty set, supporting the specified operation. More...
int	GNUNET_SETU_add_element (struct GNUNET_SETU_Handle *set, const struct GNUNET_SETU_Element *element, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
	Add an element to the given set. More...
void	GNUNET_SETU_destroy (struct GNUNET_SETU_Handle *set)
	Destroy the set handle, and free all associated resources. More...
struct GNUNET_SETU_OperationHandle *	GNUNET_SETU_prepare (const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_HashCode *app_id, const struct GNUNET_MessageHeader *context_msg, const struct GNUNET_SETU_Option options[], GNUNET_SETU_ResultIterator result_cb, void *result_cls)
	Prepare a set operation to be evaluated with another peer. More...
struct GNUNET_SETU_ListenHandle *	GNUNET_SETU_listen (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_HashCode *app_id, GNUNET_SETU_ListenCallback listen_cb, void *listen_cls)
	Wait for set operation requests for the given application ID. More...
void	GNUNET_SETU_listen_cancel (struct GNUNET_SETU_ListenHandle *lh)
	Cancel the given listen operation. More...
struct GNUNET_SETU_OperationHandle *	GNUNET_SETU_accept (struct GNUNET_SETU_Request *request, const struct GNUNET_SETU_Option options[], GNUNET_SETU_ResultIterator result_cb, void *result_cls)
	Accept a request we got via GNUNET_SETU_listen(). More...
int	GNUNET_SETU_commit (struct GNUNET_SETU_OperationHandle *oh, struct GNUNET_SETU_Handle *set)
	Commit a set to be used with a set operation. More...
void	GNUNET_SETU_operation_cancel (struct GNUNET_SETU_OperationHandle *oh)
	Cancel the given set operation. More...
void	GNUNET_SETU_element_hash (const struct GNUNET_SETU_Element *element, struct GNUNET_HashCode *ret_hash)
	Hash a set element. More...

Detailed Description

Two-peer set operations.

See also

Documentation

Macro Definition Documentation

GNUNET_SET_CONTEXT_MESSAGE_MAX_SIZE

#define GNUNET_SET_CONTEXT_MESSAGE_MAX_SIZE   ((1 << 16) - 1024)

Maximum size of a context message for set operation requests.

Definition at line 59 of file gnunet_set_service.h.

GNUNET_SETI_CONTEXT_MESSAGE_MAX_SIZE

#define GNUNET_SETI_CONTEXT_MESSAGE_MAX_SIZE   ((1 << 16) - 1024)

Maximum size of a context message for set operation requests.

Definition at line 56 of file gnunet_seti_service.h.

GNUNET_SETU_CONTEXT_MESSAGE_MAX_SIZE

#define GNUNET_SETU_CONTEXT_MESSAGE_MAX_SIZE   ((1 << 16) - 1024)

Maximum size of a context message for set operation requests.

Definition at line 56 of file gnunet_setu_service.h.

Typedef Documentation

GNUNET_SET_Continuation

typedef void(* GNUNET_SET_Continuation) (void *cls)

Continuation used for some of the set operations.

Parameters

cls

closure

Definition at line 276 of file gnunet_set_service.h.

GNUNET_SET_ResultIterator

typedef void(* GNUNET_SET_ResultIterator) (void *cls, const struct GNUNET_SET_Element *element, uint64_t current_size, enum GNUNET_SET_Status status)

Callback for set operation results.

Called for each element in the result set.

Parameters

cls	closure
element	a result element, only valid if status is GNUNET_SET_STATUS_OK
current_size	current set size
status	see enum GNUNET_SET_Status

Definition at line 289 of file gnunet_set_service.h.

GNUNET_SET_ElementIterator

typedef int(* GNUNET_SET_ElementIterator) (void *cls, const struct GNUNET_SET_Element *element)

Iterator for set elements.

Parameters

cls	closure
element	the current element, NULL if all elements have been iterated over

Returns

GNUNET_YES to continue iterating, GNUNET_NO to stop.

Definition at line 303 of file gnunet_set_service.h.

GNUNET_SET_ListenCallback

typedef void(* GNUNET_SET_ListenCallback) (void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SET_Request *request)

Called when another peer wants to do a set operation with the local peer.

If a listen error occurs, the request is NULL.

Parameters

cls	closure
other_peer	the other peer
context_msg	message with application specific information from the other peer
request	request from the other peer (never NULL), use GNUNET_SET_accept() to accept it, otherwise the request will be refused Note that we can't just return value from the listen callback, as it is also necessary to specify the set we want to do the operation with, with sometimes can be derived from the context message. It's necessary to specify the timeout.

Definition at line 323 of file gnunet_set_service.h.

GNUNET_SET_CopyReadyCallback

typedef void(* GNUNET_SET_CopyReadyCallback) (void *cls, struct GNUNET_SET_Handle *copy)

Definition at line 330 of file gnunet_set_service.h.

GNUNET_SETI_ResultIterator

typedef void(* GNUNET_SETI_ResultIterator) (void *cls, const struct GNUNET_SETI_Element *element, uint64_t current_size, enum GNUNET_SETI_Status status)

Callback for set union operation results.

Called for each element in the result set.

Parameters

cls	closure
element	a result element, only valid if status is #GNUNET_SETI_STATUS_OK
current_size	current set size
status	see enum GNUNET_SETI_Status

Definition at line 182 of file gnunet_seti_service.h.

GNUNET_SETI_ListenCallback

typedef void(* GNUNET_SETI_ListenCallback) (void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SETI_Request *request)

Called when another peer wants to do a set operation with the local peer.

If a listen error occurs, the request is NULL.

Parameters

cls	closure
other_peer	the other peer
context_msg	message with application specific information from the other peer
request	request from the other peer (never NULL), use GNUNET_SETI_accept() to accept it, otherwise the request will be refused Note that we can't just return value from the listen callback, as it is also necessary to specify the set we want to do the operation with, with sometimes can be derived from the context message. It's necessary to specify the timeout.

Definition at line 204 of file gnunet_seti_service.h.

GNUNET_SETU_ResultIterator

typedef void(* GNUNET_SETU_ResultIterator) (void *cls, const struct GNUNET_SETU_Element *element, uint64_t current_size, enum GNUNET_SETU_Status status)

Callback for set union operation results.

Called for each element in the result set.

Parameters

cls	closure
element	a result element, only valid if status is #GNUNET_SETU_STATUS_OK
current_size	current set size
status	see enum GNUNET_SETU_Status

Definition at line 227 of file gnunet_setu_service.h.

GNUNET_SETU_ListenCallback

typedef void(* GNUNET_SETU_ListenCallback) (void *cls, const struct GNUNET_PeerIdentity *other_peer, const struct GNUNET_MessageHeader *context_msg, struct GNUNET_SETU_Request *request)

Called when another peer wants to do a set operation with the local peer.

If a listen error occurs, the request is NULL.

Parameters

cls	closure
other_peer	the other peer
context_msg	message with application specific information from the other peer
request	request from the other peer (never NULL), use GNUNET_SETU_accept() to accept it, otherwise the request will be refused Note that we can't just return value from the listen callback, as it is also necessary to specify the set we want to do the operation with, with sometimes can be derived from the context message. It's necessary to specify the timeout.

Definition at line 249 of file gnunet_setu_service.h.

Enumeration Type Documentation

GNUNET_SET_OperationType

enum GNUNET_SET_OperationType

The operation that a set set supports.

Enumerator
GNUNET_SET_OPERATION_NONE	A purely local set that does not support any operation.
GNUNET_SET_OPERATION_INTERSECTION	Set intersection, only return elements that are in both sets.
GNUNET_SET_OPERATION_UNION	Set union, return all elements that are in at least one of the sets.

Definition at line 86 of file gnunet_set_service.h.

{
  GNUNET_SET_OPERATION_NONE,
 
  GNUNET_SET_OPERATION_INTERSECTION,
 
  GNUNET_SET_OPERATION_UNION
};

GNUNET_SET_Status

enum GNUNET_SET_Status

Status for the result callback.

Enumerator
GNUNET_SET_STATUS_OK	Everything went ok, we are transmitting an element of the result (in set, or to be removed from set, depending on the enum GNUNET_SET_ResultMode). Only applies to GNUNET_SET_RESULT_FULL, GNUNET_SET_RESULT_ADDED, GNUNET_SET_RESULT_REMOVED,
GNUNET_SET_STATUS_ADD_LOCAL	Element should be added to the result set of the local peer, i.e. the local peer is missing an element. Only applies to GNUNET_SET_RESULT_SYMMETRIC
GNUNET_SET_STATUS_ADD_REMOTE	Element should be added to the result set of the remote peer, i.e. the remote peer is missing an element. Only applies to GNUNET_SET_RESULT_SYMMETRIC
GNUNET_SET_STATUS_FAILURE	The other peer refused to to the operation with us, or something went wrong.
GNUNET_SET_STATUS_HALF_DONE	Success, all elements have been returned (but the other peer might still be receiving some from us, so we are not done). Only used during UNION operation.
GNUNET_SET_STATUS_DONE	Success, all elements have been sent (and received).

Definition at line 108 of file gnunet_set_service.h.

{
  GNUNET_SET_STATUS_OK,
 
  GNUNET_SET_STATUS_ADD_LOCAL,
 
  GNUNET_SET_STATUS_ADD_REMOTE,
 
  GNUNET_SET_STATUS_FAILURE,
 
  GNUNET_SET_STATUS_HALF_DONE,
 
  GNUNET_SET_STATUS_DONE
};

GNUNET_SET_ResultMode

enum GNUNET_SET_ResultMode

The way results are given to the client.

Enumerator
GNUNET_SET_RESULT_FULL	Client gets every element in the resulting set. Only supported for set intersection.
GNUNET_SET_RESULT_SYMMETRIC	Client gets notified of the required changes for both the local and the remote set. Only supported for set
GNUNET_SET_RESULT_REMOVED	Client gets only elements that have been removed from the set. Only supported for set intersection.
GNUNET_SET_RESULT_ADDED	Client gets only elements that have been added to the set. Only supported for set union.

Definition at line 163 of file gnunet_set_service.h.

{
  GNUNET_SET_RESULT_FULL,
 
  GNUNET_SET_RESULT_SYMMETRIC,
 
  GNUNET_SET_RESULT_REMOVED,
 
  GNUNET_SET_RESULT_ADDED
};

GNUNET_SET_OptionType

enum GNUNET_SET_OptionType

Possible options to pass to a set operation.

Used as tag for struct GNUNET_SET_Option.

Enumerator
GNUNET_SET_OPTION_END	List terminator.
GNUNET_SET_OPTION_BYZANTINE	Fail set operations when the other peer shows weird behavior that might by a Byzantine fault. For set union, 'v.num' is a lower bound on elements that the other peer must have in common with us.
GNUNET_SET_OPTION_FORCE_FULL	Do not use the optimized set operation, but send full sets. Might trigger Byzantine fault detection.
GNUNET_SET_OPTION_FORCE_DELTA	Only use optimized set operations, even though for this particular set operation they might be much slower. Might trigger Byzantine fault detection.

Definition at line 223 of file gnunet_set_service.h.

{
  GNUNET_SET_OPTION_END=0,
  GNUNET_SET_OPTION_BYZANTINE=1,
  GNUNET_SET_OPTION_FORCE_FULL=2,
  GNUNET_SET_OPTION_FORCE_DELTA=4,
};

GNUNET_SETI_Status

enum GNUNET_SETI_Status

Status for the result callback.

Enumerator
GNUNET_SETI_STATUS_ADD_LOCAL	Element should be added to the result set of the local peer, i.e. the element is in the intersection.
GNUNET_SETI_STATUS_DEL_LOCAL	Element should be delete from the result set of the local peer, i.e. the local peer is having an element that is not in the intersection.
GNUNET_SETI_STATUS_FAILURE	The other peer refused to do the operation with us, or something went wrong.
GNUNET_SETI_STATUS_DONE	Success, all elements have been sent (and received).

Definition at line 82 of file gnunet_seti_service.h.

{
 
  GNUNET_SETI_STATUS_ADD_LOCAL,
 
  GNUNET_SETI_STATUS_DEL_LOCAL,
 
  GNUNET_SETI_STATUS_FAILURE,
 
  GNUNET_SETI_STATUS_DONE
};

GNUNET_SETI_OptionType

enum GNUNET_SETI_OptionType

Possible options to pass to a set operation.

Used as tag for struct GNUNET_SETI_Option.

Enumerator
GNUNET_SETI_OPTION_END	List terminator.
GNUNET_SETI_OPTION_RETURN_INTERSECTION	Return the elements remaining in the intersection (GNUNET_SETI_STATUS_ADD_LOCAL). If not given, the default is to return a list of the elements to be removed (GNUNET_SETI_STATUS_DEL_LOCAL).

Definition at line 137 of file gnunet_seti_service.h.

{
  GNUNET_SETI_OPTION_END = 0,
 
  GNUNET_SETI_OPTION_RETURN_INTERSECTION = 1,
};

GNUNET_SETU_Status

enum GNUNET_SETU_Status

Status for the result callback.

Enumerator
GNUNET_SETU_STATUS_ADD_LOCAL	Element should be added to the result set of the local peer, i.e. the local peer is missing an element.
GNUNET_SETU_STATUS_ADD_REMOTE	Element should be added to the result set of the remote peer, i.e. the remote peer is missing an element. Only used if GNUNET_SETU_OPTION_SYMMETRIC is set.
GNUNET_SETU_STATUS_FAILURE	The other peer refused to do the operation with us, or something went wrong.
GNUNET_SETU_STATUS_DONE	Success, all elements have been sent (and received).

Definition at line 82 of file gnunet_setu_service.h.

{
 
  GNUNET_SETU_STATUS_ADD_LOCAL,
 
  GNUNET_SETU_STATUS_ADD_REMOTE,
 
  GNUNET_SETU_STATUS_FAILURE,
 
  GNUNET_SETU_STATUS_DONE
};

GNUNET_SETU_OptionType

enum GNUNET_SETU_OptionType

Possible options to pass to a set operation.

Used as tag for struct GNUNET_SETU_Option.

Enumerator
GNUNET_SETU_OPTION_END	List terminator.
GNUNET_SETU_OPTION_BYZANTINE	Fail set operations when the other peer shows weird behavior that might by a Byzantine fault. For set union, 'v.num' is a lower bound on elements that the other peer must have in common with us.
GNUNET_SETU_OPTION_FORCE_FULL	Do not use the optimized set operation, but send full sets. Might trigger Byzantine fault detection.
GNUNET_SETU_OPTION_FORCE_DELTA	Only use optimized set operations, even though for this particular set operation they might be much slower. Might trigger Byzantine fault detection.
GNUNET_SETU_OPTION_SYMMETRIC	Notify client also if we are sending a value to the other peer.
GNUNET_SETU_OPTION_CUSTOM_BYZANTINE_UPPER_BOUND	Byzantine upper bound. Is the maximal plausible number of elements a peer can have default max uint64
GNUNET_SETU_OPTION_CUSTOM_BANDWIDTH_LATENCY_TRADEOFF	Bandwidth latency tradeoff determines how much bytes a single RTT is worth, which is a performance setting.
GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKET_NUMBER_FACTOR	The factor determines the number of buckets an IBF has which is multiplied by the estimated setsize default: 2.
GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKETS_PER_ELEMENT	This setting determines to how many IBF buckets an single elements is mapped to.

Definition at line 138 of file gnunet_setu_service.h.

{
  GNUNET_SETU_OPTION_END=0,
 
  GNUNET_SETU_OPTION_BYZANTINE=1,
 
  GNUNET_SETU_OPTION_FORCE_FULL=2,
 
  GNUNET_SETU_OPTION_FORCE_DELTA=4,
 
  GNUNET_SETU_OPTION_SYMMETRIC = 8,
 
  GNUNET_SETU_OPTION_CUSTOM_BYZANTINE_UPPER_BOUND = 16,
 
  GNUNET_SETU_OPTION_CUSTOM_BANDWIDTH_LATENCY_TRADEOFF= 32,
 
    GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKET_NUMBER_FACTOR= 64,
 
    GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKETS_PER_ELEMENT= 128
};

Function Documentation

GNUNET_SET_create()

struct GNUNET_SET_Handle * GNUNET_SET_create	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		enum GNUNET_SET_OperationType	op
	)

Create an empty set, supporting the specified operation.

Parameters

cfg	configuration to use for connecting to the set service
op	operation supported by the set Note that the operation has to be specified beforehand, as certain set operations need to maintain data structures specific to the operation

Returns

a handle to the set

Definition at line 656 of file set_api.c.

{
  struct GNUNET_SET_Handle *set;
 
  set = create_internal (cfg,
                         op,
                         NULL);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Creating set %p for operation %d\n",
       set,
       op);
  return set;
}

References cfg, create_internal(), GNUNET_ERROR_TYPE_DEBUG, LOG, and op.

Referenced by commit_set(), and handle_client_join().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SET_add_element()

int GNUNET_SET_add_element	(	struct GNUNET_SET_Handle *	set,
		const struct GNUNET_SET_Element *	element,
		GNUNET_SET_Continuation	cont,
		void *	cont_cls
	)

Add an element to the given set.

After the element has been added (in the sense of being transmitted to the set service), cont will be called. Calls to GNUNET_SET_add_element can be queued

Parameters

set	set to add element to
element	element to add to the set
cont	continuation called after the element has been added
cont_cls	closure for cont

Returns

GNUNET_OK on success, GNUNET_SYSERR if the set is invalid (e.g. the set service crashed)

Definition at line 673 of file set_api.c.

{
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SET_ElementMessage *msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "adding element of type %u to set %p\n",
       (unsigned int) element->element_type,
       set);
  GNUNET_assert (NULL != set);
  if (GNUNET_YES == set->invalid)
  {
    if (NULL != cont)
      cont (cont_cls);
    return GNUNET_SYSERR;
  }
  mqm = GNUNET_MQ_msg_extra (msg,
                             element->size,
                             GNUNET_MESSAGE_TYPE_SET_ADD);
  msg->element_type = htons (element->element_type);
  GNUNET_memcpy (&msg[1],
                 element->data,
                 element->size);
  GNUNET_MQ_notify_sent (mqm,
                         cont, cont_cls);
  GNUNET_MQ_send (set->mq, mqm);
  return GNUNET_OK;
}

References GNUNET_SET_Element::data, GNUNET_SET_Element::element_type, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SET_ADD, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_SET_Handle::invalid, LOG, GNUNET_SET_Handle::mq, msg, and GNUNET_SET_Element::size.

Referenced by commit_set(), handle_client_insert(), set_result_cb(), task_start_apply_round(), and task_start_eval_echo().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SET_remove_element()

int GNUNET_SET_remove_element	(	struct GNUNET_SET_Handle *	set,
		const struct GNUNET_SET_Element *	element,
		GNUNET_SET_Continuation	cont,
		void *	cont_cls
	)

Remove an element to the given set.

After the element has been removed (in the sense of the request being transmitted to the set service), cont will be called.
Multiple calls to GNUNET_SET_remove_element() can be queued

Parameters

set	set to remove element from
element	element to remove from the set
cont	continuation called after the element has been removed
cont_cls	closure for cont

Returns

GNUNET_OK on success, GNUNET_SYSERR if the set is invalid (e.g. the set service crashed)

Definition at line 707 of file set_api.c.

{
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SET_ElementMessage *msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Removing element from set %p\n",
       set);
  if (GNUNET_YES == set->invalid)
  {
    if (NULL != cont)
      cont (cont_cls);
    return GNUNET_SYSERR;
  }
  mqm = GNUNET_MQ_msg_extra (msg,
                             element->size,
                             GNUNET_MESSAGE_TYPE_SET_REMOVE);
  msg->element_type = htons (element->element_type);
  GNUNET_memcpy (&msg[1],
                 element->data,
                 element->size);
  GNUNET_MQ_notify_sent (mqm,
                         cont, cont_cls);
  GNUNET_MQ_send (set->mq, mqm);
  return GNUNET_OK;
}

References GNUNET_SET_Element::data, GNUNET_SET_Element::element_type, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SET_REMOVE, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_SET_Handle::invalid, LOG, GNUNET_SET_Handle::mq, msg, and GNUNET_SET_Element::size.

Referenced by set_result_cb(), task_start_apply_round(), and task_start_eval_echo().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SET_copy_lazy()

void GNUNET_SET_copy_lazy	(	struct GNUNET_SET_Handle *	set,
		GNUNET_SET_CopyReadyCallback	cb,
		void *	cls
	)

Definition at line 1139 of file set_api.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct SetCopyRequest *req;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Creating lazy copy of set\n");
  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_PREPARE);
  GNUNET_MQ_send (set->mq, ev);
 
  req = GNUNET_new (struct SetCopyRequest);
  req->cb = cb;
  req->cls = cls;
  GNUNET_CONTAINER_DLL_insert (set->copy_req_head,
                               set->copy_req_tail,
                               req);
}

References SetCopyRequest::cb, SetCopyRequest::cls, GNUNET_SET_Handle::copy_req_head, GNUNET_SET_Handle::copy_req_tail, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SET_COPY_LAZY_PREPARE, GNUNET_MQ_msg_header, GNUNET_MQ_send(), GNUNET_new, LOG, and GNUNET_SET_Handle::mq.

Referenced by create_set_copy_for_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SET_destroy()

void GNUNET_SET_destroy

(

struct GNUNET_SET_Handle *

set

)

Destroy the set handle, and free all associated resources.

Iterations must have completed (or be explicitly canceled) before destroying the corresponding set. Operations may still be pending when a set is destroyed.

Parameters

set	set to destroy

Destroy the set handle, and free all associated resources.

Parameters

set	set handle to destroy

Definition at line 745 of file set_api.c.

{
  /* destroying set while iterator is active is currently
     not supported; we should expand the API to allow
     clients to explicitly cancel the iteration! */
  GNUNET_assert (NULL != set);
  if ((NULL != set->ops_head) ||
      (NULL != set->iterator) ||
      (GNUNET_SYSERR == set->destroy_requested))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Set operations are pending, delaying set destruction\n");
    set->destroy_requested = GNUNET_YES;
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Really destroying set\n");
  if (NULL != set->mq)
  {
    GNUNET_MQ_destroy (set->mq);
    set->mq = NULL;
  }
  GNUNET_free (set);
}

References GNUNET_SET_Handle::destroy_requested, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SYSERR, GNUNET_YES, GNUNET_SET_Handle::iterator, LOG, GNUNET_SET_Handle::mq, and GNUNET_SET_Handle::ops_head.

Referenced by client_disconnect_cb(), commit_set(), GNUNET_SET_operation_cancel(), handle_iter_done(), and handle_result().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SET_prepare()

struct GNUNET_SET_OperationHandle * GNUNET_SET_prepare	(	const struct GNUNET_PeerIdentity *	other_peer,
		const struct GNUNET_HashCode *	app_id,
		const struct GNUNET_MessageHeader *	context_msg,
		enum GNUNET_SET_ResultMode	result_mode,
		struct GNUNET_SET_Option	options[],
		GNUNET_SET_ResultIterator	result_cb,
		void *	result_cls
	)

Prepare a set operation to be evaluated with another peer.

The evaluation will not start until the client provides a local set with GNUNET_SET_commit().

Parameters

other_peer	peer with the other set
app_id	hash for the application using the set
context_msg	additional information for the request
result_mode	specified how results will be returned, see enum GNUNET_SET_ResultMode.
result_cb	called on error or success
result_cls	closure for result_cb

Returns

a handle to cancel the operation

Definition at line 772 of file set_api.c.

{
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SET_OperationHandle *oh;
  struct GNUNET_SET_EvaluateMessage *msg;
  struct GNUNET_SET_Option *opt;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client prepares set operation (%d)\n",
       result_mode);
  oh = GNUNET_new (struct GNUNET_SET_OperationHandle);
  oh->result_cb = result_cb;
  oh->result_cls = result_cls;
  mqm = GNUNET_MQ_msg_nested_mh (msg,
                                 GNUNET_MESSAGE_TYPE_SET_EVALUATE,
                                 context_msg);
  msg->app_id = *app_id;
  msg->result_mode = htonl (result_mode);
  msg->target_peer = *other_peer;
  for (opt = options; opt->type != 0; opt++)
  {
    switch (opt->type)
    {
    case GNUNET_SET_OPTION_BYZANTINE:
      msg->byzantine = GNUNET_YES;
      msg->byzantine_lower_bound = opt->v.num;
      break;
 
    case GNUNET_SET_OPTION_FORCE_FULL:
      msg->force_full = GNUNET_YES;
      break;
 
    case GNUNET_SET_OPTION_FORCE_DELTA:
      msg->force_delta = GNUNET_YES;
      break;
 
    default:
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Option with type %d not recognized\n", (int) opt->type);
    }
  }
  oh->conclude_mqm = mqm;
  oh->request_id_addr = &msg->request_id;
 
  return oh;
}

References GNUNET_SET_OperationHandle::conclude_mqm, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_MESSAGE_TYPE_SET_EVALUATE, GNUNET_MQ_msg_nested_mh, GNUNET_new, GNUNET_SET_OPTION_BYZANTINE, GNUNET_SET_OPTION_FORCE_DELTA, GNUNET_SET_OPTION_FORCE_FULL, GNUNET_YES, LOG, msg, GNUNET_SET_Option::num, options, GNUNET_SET_OperationHandle::request_id_addr, GNUNET_SET_OperationHandle::result_cb, GNUNET_SET_OperationHandle::result_cls, GNUNET_SET_Option::type, and GNUNET_SET_Option::v.

Referenced by task_start_reconcile().

Here is the caller graph for this function:

GNUNET_SET_listen()

struct GNUNET_SET_ListenHandle * GNUNET_SET_listen	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		enum GNUNET_SET_OperationType	operation,
		const struct GNUNET_HashCode *	app_id,
		GNUNET_SET_ListenCallback	listen_cb,
		void *	listen_cls
	)

Wait for set operation requests for the given application ID.

If the connection to the set service is lost, the listener is re-created transparently with exponential backoff.

Parameters

cfg	configuration to use for connecting to the set service
operation	operation we want to listen for
app_id	id of the application that handles set operation requests
listen_cb	called for each incoming request matching the operation and application id
listen_cls	handle for listen_cb

Returns

a handle that can be used to cancel the listen operation

Wait for set operation requests for the given application ID.

Parameters

cfg	configuration to use for connecting to the set service, needs to be valid for the lifetime of the listen handle
operation	operation we want to listen for
app_id	id of the application that handles set operation requests
listen_cb	called for each incoming request matching the operation and application id
listen_cls	handle for listen_cb

Returns

a handle that can be used to cancel the listen operation

Definition at line 976 of file set_api.c.

{
  struct GNUNET_SET_ListenHandle *lh;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Starting listener for app %s\n",
       GNUNET_h2s (app_id));
  lh = GNUNET_new (struct GNUNET_SET_ListenHandle);
  lh->listen_cb = listen_cb;
  lh->listen_cls = listen_cls;
  lh->cfg = cfg;
  lh->operation = operation;
  lh->app_id = *app_id;
  lh->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
  listen_connect (lh);
  if (NULL == lh->mq)
  {
    GNUNET_free (lh);
    return NULL;
  }
  return lh;
}

References GNUNET_SET_ListenHandle::app_id, cfg, GNUNET_SET_ListenHandle::cfg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_new, GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_SET_ListenHandle::listen_cb, listen_cb(), GNUNET_SET_ListenHandle::listen_cls, listen_connect(), LOG, GNUNET_SET_ListenHandle::mq, GNUNET_SET_ListenHandle::operation, and GNUNET_SET_ListenHandle::reconnect_backoff.

Referenced by handle_client_join().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SET_listen_cancel()

void GNUNET_SET_listen_cancel

(

struct GNUNET_SET_ListenHandle *

lh

)

Cancel the given listen operation.

After calling cancel, the listen callback for this listen handle will not be called again. Note that cancelling a listen operation will automatically reject all operations that have not yet been accepted.

Parameters

lh	handle for the listen operation
lh	handle for the listen operation

Definition at line 1010 of file set_api.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Canceling listener %s\n",
       GNUNET_h2s (&lh->app_id));
  if (NULL != lh->mq)
  {
    GNUNET_MQ_destroy (lh->mq);
    lh->mq = NULL;
  }
  if (NULL != lh->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (lh->reconnect_task);
    lh->reconnect_task = NULL;
  }
  GNUNET_free (lh);
}

References GNUNET_SET_ListenHandle::app_id, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), LOG, GNUNET_SET_ListenHandle::mq, and GNUNET_SET_ListenHandle::reconnect_task.

Referenced by client_disconnect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SET_accept()

struct GNUNET_SET_OperationHandle * GNUNET_SET_accept	(	struct GNUNET_SET_Request *	request,
		enum GNUNET_SET_ResultMode	result_mode,
		struct GNUNET_SET_Option	options[],
		GNUNET_SET_ResultIterator	result_cb,
		void *	result_cls
	)

Accept a request we got via GNUNET_SET_listen().

Must be called during GNUNET_SET_listen(), as the struct GNUNET_SET_Request becomes invalid afterwards. Call GNUNET_SET_commit() to provide the local set to use for the operation, and to begin the exchange with the remote peer.

Parameters

request	request to accept
result_mode	specified how results will be returned, see enum GNUNET_SET_ResultMode.
result_cb	callback for the results
result_cls	closure for result_cb

Returns

a handle to cancel the operation

Definition at line 1030 of file set_api.c.

{
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SET_OperationHandle *oh;
  struct GNUNET_SET_AcceptMessage *msg;
 
  GNUNET_assert (GNUNET_NO == request->accepted);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client accepts set operation (%d) with id %u\n",
       result_mode,
       request->accept_id);
  request->accepted = GNUNET_YES;
  mqm = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_SET_ACCEPT);
  msg->accept_reject_id = htonl (request->accept_id);
  msg->result_mode = htonl (result_mode);
  oh = GNUNET_new (struct GNUNET_SET_OperationHandle);
  oh->result_cb = result_cb;
  oh->result_cls = result_cls;
  oh->conclude_mqm = mqm;
  oh->request_id_addr = &msg->request_id;
  return oh;
}

References GNUNET_SET_OperationHandle::conclude_mqm, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SET_ACCEPT, GNUNET_MQ_msg, GNUNET_new, GNUNET_NO, GNUNET_YES, LOG, msg, request, GNUNET_SET_OperationHandle::request_id_addr, GNUNET_SET_OperationHandle::result_cb, GNUNET_SET_OperationHandle::result_cls, and GNUNET_SET_AcceptMessage::result_mode.

Referenced by set_listen_cb().

Here is the caller graph for this function:

GNUNET_SET_commit()

int GNUNET_SET_commit	(	struct GNUNET_SET_OperationHandle *	oh,
		struct GNUNET_SET_Handle *	set
	)

Commit a set to be used with a set operation.

This function is called once we have fully constructed the set that we want to use for the operation. At this time, the P2P protocol can then begin to exchange the set information and call the result callback with the result information.

Parameters

oh	handle to the set operation
set	the set to use for the operation

Returns

GNUNET_OK on success, GNUNET_SYSERR if the set is invalid (e.g. the set service crashed)

Definition at line 1073 of file set_api.c.

{
  if (NULL != oh->set)
  {
    /* Some other set was already committed for this
     * operation, there is a logic bug in the client of this API */
    GNUNET_break (0);
    return GNUNET_OK;
  }
  GNUNET_assert (NULL != set);
  if (GNUNET_YES == set->invalid)
    return GNUNET_SYSERR;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client commits to SET\n");
  GNUNET_assert (NULL != oh->conclude_mqm);
  oh->set = set;
  GNUNET_CONTAINER_DLL_insert (set->ops_head,
                               set->ops_tail,
                               oh);
  oh->request_id = GNUNET_MQ_assoc_add (set->mq,
                                        oh);
  *oh->request_id_addr = htonl (oh->request_id);
  GNUNET_MQ_send (set->mq,
                  oh->conclude_mqm);
  oh->conclude_mqm = NULL;
  oh->request_id_addr = NULL;
  return GNUNET_OK;
}

References GNUNET_SET_OperationHandle::conclude_mqm, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_assoc_add(), GNUNET_MQ_send(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_SET_Handle::invalid, LOG, GNUNET_SET_Handle::mq, GNUNET_SET_Handle::ops_head, GNUNET_SET_Handle::ops_tail, GNUNET_SET_OperationHandle::request_id, GNUNET_SET_OperationHandle::request_id_addr, and GNUNET_SET_OperationHandle::set.

Referenced by commit_set().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SET_operation_cancel()

void GNUNET_SET_operation_cancel

(

struct GNUNET_SET_OperationHandle *

oh

)

Cancel the given set operation.

May not be called after the operation's GNUNET_SET_ResultIterator has been called with a status that indicates error, timeout or done.

Parameters

oh	set operation to cancel

We need to send an explicit cancel message, as all operations one one set communicate using one handle.

Parameters

oh	set operation to cancel

Definition at line 516 of file set_api.c.

{
  struct GNUNET_SET_Handle *set = oh->set;
  struct GNUNET_SET_CancelMessage *m;
  struct GNUNET_MQ_Envelope *mqm;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Cancelling SET operation\n");
  if (NULL != set)
  {
    mqm = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_SET_CANCEL);
    m->request_id = htonl (oh->request_id);
    GNUNET_MQ_send (set->mq, mqm);
  }
  set_operation_destroy (oh);
  if ((NULL != set) &&
      (GNUNET_YES == set->destroy_requested) &&
      (NULL == set->ops_head))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Destroying set after operation cancel\n");
    GNUNET_SET_destroy (set);
  }
}

References GNUNET_SET_Handle::destroy_requested, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SET_CANCEL, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SET_destroy(), GNUNET_YES, LOG, m, GNUNET_SET_Handle::mq, GNUNET_SET_Handle::ops_head, GNUNET_SET_OperationHandle::request_id, GNUNET_SET_OperationHandle::set, and set_operation_destroy().

Referenced by commit_set().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SET_iterate()

int GNUNET_SET_iterate	(	struct GNUNET_SET_Handle *	set,
		GNUNET_SET_ElementIterator	iter,
		void *	iter_cls
	)

Iterate over all elements in the given set.

Note that this operation involves transferring every element of the set from the service to the client, and is thus costly. Only one iteration per set may be active at the same time.

Parameters

set	the set to iterate over
iter	the iterator to call for each element
iter_cls	closure for iter

Returns

GNUNET_YES if the iteration started successfully, GNUNET_NO if another iteration was still active, GNUNET_SYSERR if the set is invalid (e.g. the server crashed, disconnected)

Note that this operation involves transferring every element of the set from the service to the client, and is thus costly.

Parameters

set	the set to iterate over
iter	the iterator to call for each element
iter_cls	closure for iter

Returns

GNUNET_YES if the iteration started successfully, GNUNET_NO if another iteration is active GNUNET_SYSERR if the set is invalid (e.g. the server crashed, disconnected)

Definition at line 1117 of file set_api.c.

{
  struct GNUNET_MQ_Envelope *ev;
 
  GNUNET_assert (NULL != iter);
  if (GNUNET_YES == set->invalid)
    return GNUNET_SYSERR;
  if (NULL != set->iterator)
    return GNUNET_NO;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Iterating over set\n");
  set->iterator = iter;
  set->iterator_cls = iter_cls;
  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SET_ITER_REQUEST);
  GNUNET_MQ_send (set->mq, ev);
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SET_ITER_REQUEST, GNUNET_MQ_msg_header, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, GNUNET_SET_Handle::invalid, GNUNET_SET_Handle::iterator, GNUNET_SET_Handle::iterator_cls, LOG, and GNUNET_SET_Handle::mq.

Referenced by task_start_finish().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SET_iterate_cancel()

void GNUNET_SET_iterate_cancel

(

struct GNUNET_SET_Handle *

set

)

Stop iteration over all elements in the given set.

Can only be called before the iteration has "naturally" completed its turn.

Parameters

set	the set to stop iterating over

GNUNET_SET_element_dup()

struct GNUNET_SET_Element * GNUNET_SET_element_dup

(

const struct GNUNET_SET_Element *

element

)

Create a copy of an element.

The copy must be GNUNET_free-d by the caller.

Parameters

element

the element to copy

Returns

the copied element

Definition at line 1168 of file set_api.c.

{
  struct GNUNET_SET_Element *copy;
 
  copy = GNUNET_malloc (element->size + sizeof(struct GNUNET_SET_Element));
  copy->size = element->size;
  copy->element_type = element->element_type;
  copy->data = &copy[1];
  GNUNET_memcpy (&copy[1],
                 element->data,
                 copy->size);
  return copy;
}

References GNUNET_SET_Element::data, GNUNET_SET_Element::element_type, GNUNET_malloc, GNUNET_memcpy, and GNUNET_SET_Element::size.

Referenced by diff_insert(), and rfn_vote().

Here is the caller graph for this function:

GNUNET_SET_element_hash()

void GNUNET_SET_element_hash	(	const struct GNUNET_SET_Element *	element,
		struct GNUNET_HashCode *	ret_hash
	)

Hash a set element.

Parameters

	element	the element that should be hashed
[out]	ret_hash	a pointer to where the hash of element should be stored

Definition at line 1184 of file set_api.c.

{
  struct GNUNET_HashContext *ctx = GNUNET_CRYPTO_hash_context_start ();
 
  /* It's not guaranteed that the element data is always after the element header,
     so we need to hash the chunks separately. */
  GNUNET_CRYPTO_hash_context_read (ctx, &element->size, sizeof(uint16_t));
  GNUNET_CRYPTO_hash_context_read (ctx, &element->element_type,
                                   sizeof(uint16_t));
  GNUNET_CRYPTO_hash_context_read (ctx, element->data, element->size);
  GNUNET_CRYPTO_hash_context_finish (ctx, ret_hash);
}

References ctx, GNUNET_SET_Element::data, GNUNET_SET_Element::element_type, GNUNET_CRYPTO_hash_context_finish(), GNUNET_CRYPTO_hash_context_read(), GNUNET_CRYPTO_hash_context_start(), and GNUNET_SET_Element::size.

Referenced by diff_insert(), execute_add(), execute_remove(), handle_union_p2p_elements(), handle_union_p2p_full_element(), and rfn_vote().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETI_create()

struct GNUNET_SETI_Handle * GNUNET_SETI_create

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Create an empty set, supporting the specified operation.

Parameters

cfg	configuration to use for connecting to the set service

Returns

a handle to the set

Create an empty set, supporting the specified operation.

Parameters

cfg	configuration to use for connecting to the set service

Returns

a handle to the set

Definition at line 399 of file seti_api.c.

{
  struct GNUNET_SETI_Handle *set = GNUNET_new (struct GNUNET_SETI_Handle);
  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
    GNUNET_MQ_hd_var_size (result,
                           GNUNET_MESSAGE_TYPE_SETI_RESULT,
                           struct GNUNET_SETI_ResultMessage,
                           set),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SETI_CreateMessage *create_msg;
 
  set->cfg = cfg;
  set->mq = GNUNET_CLIENT_connect (cfg,
                                   "seti",
                                   mq_handlers,
                                   &handle_client_set_error,
                                   set);
  if (NULL == set->mq)
  {
    GNUNET_free (set);
    return NULL;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Creating new intersection set\n");
  mqm = GNUNET_MQ_msg (create_msg,
                       GNUNET_MESSAGE_TYPE_SETI_CREATE);
  GNUNET_MQ_send (set->mq,
                  mqm);
  return set;
}

References cfg, GNUNET_SETI_Handle::cfg, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MESSAGE_TYPE_SETI_CREATE, GNUNET_MESSAGE_TYPE_SETI_RESULT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, handle_client_set_error(), LOG, GNUNET_SETI_Handle::mq, and result.

Referenced by handle_alice_client_message(), and handle_bob_client_message().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETI_add_element()

int GNUNET_SETI_add_element	(	struct GNUNET_SETI_Handle *	set,
		const struct GNUNET_SETI_Element *	element,
		GNUNET_SCHEDULER_TaskCallback	cb,
		void *	cb_cls
	)

Add an element to the given set.

Parameters

set	set to add element to
element	element to add to the set
cb	function to call when finished, can be NULL
cb_cls	closure for cb

Returns

GNUNET_OK on success, GNUNET_SYSERR if the set is invalid (e.g. the set service crashed)

After the element has been added (in the sense of being transmitted to the set service), cont will be called. Multiple calls to GNUNET_SETI_add_element() can be queued.

Parameters

set	set to add element to
element	element to add to the set
cb	continuation called after the element has been added
cb_cls	closure for cont

Returns

GNUNET_OK on success, GNUNET_SYSERR if the set is invalid (e.g. the set service crashed)

Definition at line 447 of file seti_api.c.

{
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SETI_ElementMessage *msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "adding element of type %u to set %p\n",
       (unsigned int) element->element_type,
       set);
  if (GNUNET_YES == set->invalid)
  {
    if (NULL != cb)
      cb (cb_cls);
    return GNUNET_SYSERR;
  }
  mqm = GNUNET_MQ_msg_extra (msg,
                             element->size,
                             GNUNET_MESSAGE_TYPE_SETI_ADD);
  msg->element_type = htons (element->element_type);
  GNUNET_memcpy (&msg[1],
                 element->data,
                 element->size);
  GNUNET_MQ_notify_sent (mqm,
                         cb,
                         cb_cls);
  GNUNET_MQ_send (set->mq,
                  mqm);
  return GNUNET_OK;
}

References GNUNET_SETI_Element::data, GNUNET_SETI_Element::element_type, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SETI_ADD, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_SETI_Handle::invalid, LOG, GNUNET_SETI_Handle::mq, msg, and GNUNET_SETI_Element::size.

Referenced by handle_alice_client_message(), handle_alice_client_message_multipart(), handle_bob_client_message(), and handle_bob_client_message_multipart().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETI_destroy()

void GNUNET_SETI_destroy

(

struct GNUNET_SETI_Handle *

set

)

Destroy the set handle, and free all associated resources.

Operations may still be pending when a set is destroyed (and will be allowed to complete).

Parameters

set	set to destroy

Destroy the set handle, and free all associated resources.

Parameters

set	set handle to destroy

Definition at line 488 of file seti_api.c.

{
  /* destroying set while iterator is active is currently
     not supported; we should expand the API to allow
     clients to explicitly cancel the iteration! */
  if ((NULL != set->ops_head) ||
      (GNUNET_SYSERR == set->destroy_requested))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Set operations are pending, delaying set destruction\n");
    set->destroy_requested = GNUNET_YES;
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Really destroying set\n");
  if (NULL != set->mq)
  {
    GNUNET_MQ_destroy (set->mq);
    set->mq = NULL;
  }
  GNUNET_free (set);
}

References GNUNET_SETI_Handle::destroy_requested, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SYSERR, GNUNET_YES, LOG, GNUNET_SETI_Handle::mq, and GNUNET_SETI_Handle::ops_head.

Referenced by cb_intersection_element_removed(), destroy_service_session(), GNUNET_SETI_operation_cancel(), and handle_result().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETI_prepare()

struct GNUNET_SETI_OperationHandle * GNUNET_SETI_prepare	(	const struct GNUNET_PeerIdentity *	other_peer,
		const struct GNUNET_HashCode *	app_id,
		const struct GNUNET_MessageHeader *	context_msg,
		const struct GNUNET_SETI_Option	options[],
		GNUNET_SETI_ResultIterator	result_cb,
		void *	result_cls
	)

Prepare a set operation to be evaluated with another peer.

The evaluation will not start until the client provides a local set with GNUNET_SETI_commit().

Parameters

other_peer	peer with the other set
app_id	hash for the application using the set
context_msg	additional information for the request
options	options to use when processing the request
result_cb	called on error or success
result_cls	closure for result_cb

Returns

a handle to cancel the operation

Definition at line 513 of file seti_api.c.

{
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SETI_OperationHandle *oh;
  struct GNUNET_SETI_EvaluateMessage *msg;
 
  oh = GNUNET_new (struct GNUNET_SETI_OperationHandle);
  oh->result_cb = result_cb;
  oh->result_cls = result_cls;
  mqm = GNUNET_MQ_msg_nested_mh (msg,
                                 GNUNET_MESSAGE_TYPE_SETI_EVALUATE,
                                 context_msg);
  msg->app_id = *app_id;
  msg->target_peer = *other_peer;
  for (const struct GNUNET_SETI_Option *opt = options;
       GNUNET_SETI_OPTION_END != opt->type;
       opt++)
  {
    switch (opt->type)
    {
    case GNUNET_SETI_OPTION_RETURN_INTERSECTION:
      msg->return_intersection = htonl (GNUNET_YES);
      break;
    default:
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Option with type %d not recognized\n",
           (int) opt->type);
    }
  }
  oh->conclude_mqm = mqm;
  oh->request_id_addr = &msg->request_id;
  return oh;
}

References GNUNET_SETI_EvaluateMessage::app_id, GNUNET_SETI_OperationHandle::conclude_mqm, GNUNET_ERROR_TYPE_ERROR, GNUNET_MESSAGE_TYPE_SETI_EVALUATE, GNUNET_MQ_msg_nested_mh, GNUNET_new, GNUNET_SETI_OPTION_END, GNUNET_SETI_OPTION_RETURN_INTERSECTION, GNUNET_YES, LOG, msg, options, GNUNET_SETI_OperationHandle::request_id_addr, GNUNET_SETI_OperationHandle::result_cb, and GNUNET_SETI_OperationHandle::result_cls.

Referenced by start_intersection().

Here is the caller graph for this function:

GNUNET_SETI_listen()

struct GNUNET_SETI_ListenHandle * GNUNET_SETI_listen	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const struct GNUNET_HashCode *	app_id,
		GNUNET_SETI_ListenCallback	listen_cb,
		void *	listen_cls
	)

Wait for set operation requests for the given application ID.

If the connection to the set service is lost, the listener is re-created transparently with exponential backoff.

Parameters

cfg	configuration to use for connecting to the set service
app_id	id of the application that handles set operation requests
listen_cb	called for each incoming request matching the operation and application id
listen_cls	handle for listen_cb

Returns

a handle that can be used to cancel the listen operation

Wait for set operation requests for the given application ID.

Parameters

cfg	configuration to use for connecting to the set service, needs to be valid for the lifetime of the listen handle
app_id	id of the application that handles set operation requests
listen_cb	called for each incoming request matching the operation and application id
listen_cls	handle for listen_cb

Returns

a handle that can be used to cancel the listen operation

Definition at line 702 of file seti_api.c.

{
  struct GNUNET_SETI_ListenHandle *lh;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Starting listener for app %s\n",
       GNUNET_h2s (app_id));
  lh = GNUNET_new (struct GNUNET_SETI_ListenHandle);
  lh->listen_cb = listen_cb;
  lh->listen_cls = listen_cls;
  lh->cfg = cfg;
  lh->app_id = *app_id;
  lh->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
  listen_connect (lh);
  if (NULL == lh->mq)
  {
    GNUNET_free (lh);
    return NULL;
  }
  return lh;
}

References GNUNET_SETI_ListenHandle::app_id, cfg, GNUNET_SETI_ListenHandle::cfg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_new, GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_SETI_ListenHandle::listen_cb, listen_cb(), GNUNET_SETI_ListenHandle::listen_cls, listen_connect(), LOG, GNUNET_SETI_ListenHandle::mq, and GNUNET_SETI_ListenHandle::reconnect_backoff.

Referenced by client_request_complete_alice().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETI_listen_cancel()

void GNUNET_SETI_listen_cancel

(

struct GNUNET_SETI_ListenHandle *

lh

)

Cancel the given listen operation.

After calling cancel, the listen callback for this listen handle will not be called again. Note that cancelling a listen operation will automatically reject all operations that have not yet been accepted.

Parameters

lh	handle for the listen operation
lh	handle for the listen operation

Definition at line 734 of file seti_api.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Canceling listener %s\n",
       GNUNET_h2s (&lh->app_id));
  if (NULL != lh->mq)
  {
    GNUNET_MQ_destroy (lh->mq);
    lh->mq = NULL;
  }
  if (NULL != lh->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (lh->reconnect_task);
    lh->reconnect_task = NULL;
  }
  GNUNET_free (lh);
}

References GNUNET_SETI_ListenHandle::app_id, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), LOG, GNUNET_SETI_ListenHandle::mq, and GNUNET_SETI_ListenHandle::reconnect_task.

Referenced by cb_intersection_element_removed(), and destroy_service_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETI_accept()

struct GNUNET_SETI_OperationHandle * GNUNET_SETI_accept	(	struct GNUNET_SETI_Request *	request,
		const struct GNUNET_SETI_Option	options[],
		GNUNET_SETI_ResultIterator	result_cb,
		void *	result_cls
	)

Accept a request we got via GNUNET_SETI_listen().

Must be called during GNUNET_SETI_listen(), as the struct GNUNET_SETI_Request becomes invalid afterwards. Call GNUNET_SETI_commit() to provide the local set to use for the operation, and to begin the exchange with the remote peer.

Parameters

request	request to accept
options	options to use when processing the request
result_cb	callback for the results
result_cls	closure for result_cb

Returns

a handle to cancel the operation

Definition at line 754 of file seti_api.c.

{
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SETI_OperationHandle *oh;
  struct GNUNET_SETI_AcceptMessage *msg;
 
  GNUNET_assert (GNUNET_NO == request->accepted);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client accepts set intersection operation with id %u\n",
       request->accept_id);
  request->accepted = GNUNET_YES;
  mqm = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_SETI_ACCEPT);
  msg->accept_reject_id = htonl (request->accept_id);
  oh = GNUNET_new (struct GNUNET_SETI_OperationHandle);
  oh->result_cb = result_cb;
  oh->result_cls = result_cls;
  oh->conclude_mqm = mqm;
  oh->request_id_addr = &msg->request_id;
  for (const struct GNUNET_SETI_Option *opt = options;
       GNUNET_SETI_OPTION_END != opt->type;
       opt++)
  {
    switch (opt->type)
    {
    case GNUNET_SETI_OPTION_RETURN_INTERSECTION:
      oh->return_intersection = GNUNET_YES;
      msg->return_intersection = htonl (GNUNET_YES);
      break;
    default:
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Option with type %d not recognized\n",
           (int) opt->type);
    }
  }
  return oh;
}

References GNUNET_SETI_OperationHandle::conclude_mqm, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_MESSAGE_TYPE_SETI_ACCEPT, GNUNET_MQ_msg, GNUNET_new, GNUNET_NO, GNUNET_SETI_OPTION_END, GNUNET_SETI_OPTION_RETURN_INTERSECTION, GNUNET_YES, LOG, msg, options, request, GNUNET_SETI_OperationHandle::request_id_addr, GNUNET_SETI_OperationHandle::result_cb, GNUNET_SETI_OperationHandle::result_cls, and GNUNET_SETI_OperationHandle::return_intersection.

Referenced by cb_intersection_request_alice().

Here is the caller graph for this function:

GNUNET_SETI_commit()

int GNUNET_SETI_commit	(	struct GNUNET_SETI_OperationHandle *	oh,
		struct GNUNET_SETI_Handle *	set
	)

Commit a set to be used with a set operation.

This function is called once we have fully constructed the set that we want to use for the operation. At this time, the P2P protocol can then begin to exchange the set information and call the result callback with the result information.

Parameters

oh	handle to the set operation
set	the set to use for the operation

Returns

GNUNET_OK on success, GNUNET_SYSERR if the set is invalid (e.g. the set service crashed)

Definition at line 810 of file seti_api.c.

{
  if (NULL != oh->set)
  {
    /* Some other set was already committed for this
     * operation, there is a logic bug in the client of this API */
    GNUNET_break (0);
    return GNUNET_OK;
  }
  GNUNET_assert (NULL != set);
  if (GNUNET_YES == set->invalid)
    return GNUNET_SYSERR;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client commits to SET\n");
  GNUNET_assert (NULL != oh->conclude_mqm);
  oh->set = set;
  GNUNET_CONTAINER_DLL_insert (set->ops_head,
                               set->ops_tail,
                               oh);
  oh->request_id = GNUNET_MQ_assoc_add (set->mq,
                                        oh);
  *oh->request_id_addr = htonl (oh->request_id);
  GNUNET_MQ_send (set->mq,
                  oh->conclude_mqm);
  oh->conclude_mqm = NULL;
  oh->request_id_addr = NULL;
  return GNUNET_OK;
}

References GNUNET_SETI_OperationHandle::conclude_mqm, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_assoc_add(), GNUNET_MQ_send(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_SETI_Handle::invalid, LOG, GNUNET_SETI_Handle::mq, GNUNET_SETI_Handle::ops_head, GNUNET_SETI_Handle::ops_tail, GNUNET_SETI_OperationHandle::request_id, GNUNET_SETI_OperationHandle::request_id_addr, and GNUNET_SETI_OperationHandle::set.

Referenced by cb_intersection_request_alice().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETI_operation_cancel()

void GNUNET_SETI_operation_cancel

(

struct GNUNET_SETI_OperationHandle *

oh

)

Cancel the given set operation.

May not be called after the operation's GNUNET_SETI_ResultIterator has been called with a status of GNUNET_SETI_STATUS_FAILURE or GNUNET_SETI_STATUS_DONE.

Parameters

oh	set operation to cancel

We need to send an explicit cancel message, as all operations one one set communicate using one handle.

Parameters

oh	set operation to cancel

Definition at line 335 of file seti_api.c.

{
  struct GNUNET_SETI_Handle *set = oh->set;
  struct GNUNET_SETI_CancelMessage *m;
  struct GNUNET_MQ_Envelope *mqm;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Cancelling SET operation\n");
  if (NULL != set)
  {
    mqm = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_SETI_CANCEL);
    m->request_id = htonl (oh->request_id);
    GNUNET_MQ_send (set->mq, mqm);
  }
  set_operation_destroy (oh);
  if ((NULL != set) &&
      (GNUNET_YES == set->destroy_requested) &&
      (NULL == set->ops_head))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Destroying set after operation cancel\n");
    GNUNET_SETI_destroy (set);
  }
}

References GNUNET_SETI_Handle::destroy_requested, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SETI_CANCEL, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SETI_destroy(), GNUNET_YES, LOG, m, GNUNET_SETI_Handle::mq, GNUNET_SETI_Handle::ops_head, GNUNET_SETI_OperationHandle::request_id, GNUNET_SETI_OperationHandle::set, and set_operation_destroy().

Referenced by destroy_service_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETI_element_hash()

void GNUNET_SETI_element_hash	(	const struct GNUNET_SETI_Element *	element,
		struct GNUNET_HashCode *	ret_hash
	)

Hash a set element.

Parameters

	element	the element that should be hashed
[out]	ret_hash	a pointer to where the hash of element should be stored

Definition at line 849 of file seti_api.c.

{
  struct GNUNET_HashContext *ctx = GNUNET_CRYPTO_hash_context_start ();
 
  /* It's not guaranteed that the element data is always after the element header,
     so we need to hash the chunks separately. */
  GNUNET_CRYPTO_hash_context_read (ctx,
                                   &element->size,
                                   sizeof(uint16_t));
  GNUNET_CRYPTO_hash_context_read (ctx,
                                   &element->element_type,
                                   sizeof(uint16_t));
  GNUNET_CRYPTO_hash_context_read (ctx,
                                   element->data,
                                   element->size);
  GNUNET_CRYPTO_hash_context_finish (ctx,
                                     ret_hash);
}

References ctx, GNUNET_SETI_Element::data, GNUNET_SETI_Element::element_type, GNUNET_CRYPTO_hash_context_finish(), GNUNET_CRYPTO_hash_context_read(), GNUNET_CRYPTO_hash_context_start(), and GNUNET_SETI_Element::size.

Referenced by handle_client_set_add().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETU_create()

struct GNUNET_SETU_Handle * GNUNET_SETU_create

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Create an empty set, supporting the specified operation.

Parameters

cfg	configuration to use for connecting to the set service

Returns

a handle to the set

Definition at line 384 of file setu_api.c.

{
  struct GNUNET_SETU_Handle *set = GNUNET_new (struct GNUNET_SETU_Handle);
  struct GNUNET_MQ_MessageHandler mq_handlers[] = {
    GNUNET_MQ_hd_var_size (result,
                           GNUNET_MESSAGE_TYPE_SETU_RESULT,
                           struct GNUNET_SETU_ResultMessage,
                           set),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SETU_CreateMessage *create_msg;
 
  set->mq = GNUNET_CLIENT_connect (cfg,
                                   "setu",
                                   mq_handlers,
                                   &handle_client_set_error,
                                   set);
  if (NULL == set->mq)
  {
    GNUNET_free (set);
    return NULL;
  }
  mqm = GNUNET_MQ_msg (create_msg,
                       GNUNET_MESSAGE_TYPE_SETU_CREATE);
  GNUNET_MQ_send (set->mq,
                  mqm);
  return set;
}

References cfg, GNUNET_CLIENT_connect(), GNUNET_free, GNUNET_MESSAGE_TYPE_SETU_CREATE, GNUNET_MESSAGE_TYPE_SETU_RESULT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, handle_client_set_error(), GNUNET_SETU_Handle::mq, and result.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETU_add_element()

int GNUNET_SETU_add_element	(	struct GNUNET_SETU_Handle *	set,
		const struct GNUNET_SETU_Element *	element,
		GNUNET_SCHEDULER_TaskCallback	cb,
		void *	cb_cls
	)

Add an element to the given set.

Parameters

set	set to add element to
element	element to add to the set
cb	function to call when finished, can be NULL
cb_cls	closure for cb

Returns

GNUNET_OK on success, GNUNET_SYSERR if the set is invalid (e.g. the set service crashed)

After the element has been added (in the sense of being transmitted to the set service), cont will be called. Multiple calls to GNUNET_SETU_add_element() can be queued.

Parameters

set	set to add element to
element	element to add to the set
cb	continuation called after the element has been added
cb_cls	closure for cb

Returns

GNUNET_OK on success, GNUNET_SYSERR if the set is invalid (e.g. the set service crashed)

Definition at line 429 of file setu_api.c.

{
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SETU_ElementMessage *msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "adding element of type %u to set %p\n",
       (unsigned int) element->element_type,
       set);
  GNUNET_assert (NULL != set);
  if (GNUNET_YES == set->invalid)
  {
    if (NULL != cb)
      cb (cb_cls);
    return GNUNET_SYSERR;
  }
  mqm = GNUNET_MQ_msg_extra (msg,
                             element->size,
                             GNUNET_MESSAGE_TYPE_SETU_ADD);
  msg->element_type = htons (element->element_type);
  GNUNET_memcpy (&msg[1],
                 element->data,
                 element->size);
  GNUNET_MQ_notify_sent (mqm,
                         cb,
                         cb_cls);
  GNUNET_MQ_send (set->mq,
                  mqm);
  return GNUNET_OK;
}

References GNUNET_SETU_Element::data, GNUNET_SETU_Element::element_type, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SETU_ADD, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_SETU_Handle::invalid, LOG, GNUNET_SETU_Handle::mq, msg, and GNUNET_SETU_Element::size.

Referenced by publicize_rm().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETU_destroy()

void GNUNET_SETU_destroy

(

struct GNUNET_SETU_Handle *

set

)

Destroy the set handle, and free all associated resources.

Operations may still be pending when a set is destroyed (and will be allowed to complete).

Parameters

set	set to destroy

Destroy the set handle, and free all associated resources.

Parameters

set	set handle to destroy

Definition at line 471 of file setu_api.c.

{
  /* destroying set while iterator is active is currently
     not supported; we should expand the API to allow
     clients to explicitly cancel the iteration! */
  GNUNET_assert (NULL != set);
  if ((NULL != set->ops_head) ||
      (GNUNET_SYSERR == set->destroy_requested))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Set operations are pending, delaying set destruction\n");
    set->destroy_requested = GNUNET_YES;
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Really destroying set\n");
  if (NULL != set->mq)
  {
    GNUNET_MQ_destroy (set->mq);
    set->mq = NULL;
  }
  GNUNET_free (set);
}

References GNUNET_SETU_Handle::destroy_requested, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SYSERR, GNUNET_YES, LOG, GNUNET_SETU_Handle::mq, and GNUNET_SETU_Handle::ops_head.

Referenced by GNUNET_SETU_operation_cancel(), handle_result(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETU_prepare()

struct GNUNET_SETU_OperationHandle * GNUNET_SETU_prepare	(	const struct GNUNET_PeerIdentity *	other_peer,
		const struct GNUNET_HashCode *	app_id,
		const struct GNUNET_MessageHeader *	context_msg,
		const struct GNUNET_SETU_Option	options[],
		GNUNET_SETU_ResultIterator	result_cb,
		void *	result_cls
	)

Prepare a set operation to be evaluated with another peer.

The evaluation will not start until the client provides a local set with GNUNET_SETU_commit().

Parameters

other_peer	peer with the other set
app_id	hash for the application using the set
context_msg	additional information for the request
options	options to use when processing the request
result_cb	called on error or success
result_cls	closure for result_cb

Returns

a handle to cancel the operation

Definition at line 497 of file setu_api.c.

{
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SETU_OperationHandle *oh;
  struct GNUNET_SETU_EvaluateMessage *msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client prepares set union operation\n");
  oh = GNUNET_new (struct GNUNET_SETU_OperationHandle);
  oh->result_cb = result_cb;
  oh->result_cls = result_cls;
  mqm = GNUNET_MQ_msg_nested_mh (msg,
                                 GNUNET_MESSAGE_TYPE_SETU_EVALUATE,
                                 context_msg);
  msg->app_id = *app_id;
  msg->target_peer = *other_peer;
 
  /* Set default values */
  msg->byzantine_upper_bond = UINT64_MAX;
  msg->bandwidth_latency_tradeoff = 0;
  msg->ibf_bucket_number_factor = 2;
  msg->ibf_number_of_buckets_per_element = 3;
 
 
  for (const struct GNUNET_SETU_Option *opt = options; opt->type != 0; opt++)
  {
    switch (opt->type)
    {
    case GNUNET_SETU_OPTION_BYZANTINE:
      msg->byzantine = GNUNET_YES;
      msg->byzantine_lower_bound = htonl (opt->v.num);
      break;
    case GNUNET_SETU_OPTION_CUSTOM_BYZANTINE_UPPER_BOUND:
      msg->byzantine_upper_bond = htonl (opt->v.num);
      break;
    case GNUNET_SETU_OPTION_CUSTOM_BANDWIDTH_LATENCY_TRADEOFF:
      msg->bandwidth_latency_tradeoff = htonl (opt->v.num);
      break;
    case GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKET_NUMBER_FACTOR:
      msg->ibf_bucket_number_factor = htonl (opt->v.num);
      break;
    case GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKETS_PER_ELEMENT:
      msg->ibf_number_of_buckets_per_element = htonl (opt->v.num);
      break;
    case GNUNET_SETU_OPTION_FORCE_FULL:
      msg->force_full = GNUNET_YES;
      break;
    case GNUNET_SETU_OPTION_FORCE_DELTA:
      msg->force_delta = GNUNET_YES;
      break;
    case GNUNET_SETU_OPTION_SYMMETRIC:
      msg->symmetric = GNUNET_YES;
      break;
    default:
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Option with type %d not recognized\n",
           (int) opt->type);
    }
  }
  oh->conclude_mqm = mqm;
  oh->request_id_addr = &msg->request_id;
  return oh;
}

References GNUNET_SETU_EvaluateMessage::app_id, GNUNET_SETU_OperationHandle::conclude_mqm, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_MESSAGE_TYPE_SETU_EVALUATE, GNUNET_MQ_msg_nested_mh, GNUNET_new, GNUNET_SETU_OPTION_BYZANTINE, GNUNET_SETU_OPTION_CUSTOM_BANDWIDTH_LATENCY_TRADEOFF, GNUNET_SETU_OPTION_CUSTOM_BYZANTINE_UPPER_BOUND, GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKET_NUMBER_FACTOR, GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKETS_PER_ELEMENT, GNUNET_SETU_OPTION_FORCE_DELTA, GNUNET_SETU_OPTION_FORCE_FULL, GNUNET_SETU_OPTION_SYMMETRIC, GNUNET_YES, LOG, msg, options, GNUNET_SETU_OperationHandle::request_id_addr, GNUNET_SETU_OperationHandle::result_cb, and GNUNET_SETU_OperationHandle::result_cls.

Referenced by transmit_task_cb().

Here is the caller graph for this function:

GNUNET_SETU_listen()

struct GNUNET_SETU_ListenHandle * GNUNET_SETU_listen	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const struct GNUNET_HashCode *	app_id,
		GNUNET_SETU_ListenCallback	listen_cb,
		void *	listen_cls
	)

Wait for set operation requests for the given application ID.

If the connection to the set service is lost, the listener is re-created transparently with exponential backoff.

Parameters

cfg	configuration to use for connecting to the set service
app_id	id of the application that handles set operation requests
listen_cb	called for each incoming request matching the operation and application id
listen_cls	handle for listen_cb

Returns

a handle that can be used to cancel the listen operation

Wait for set operation requests for the given application ID.

Parameters

cfg	configuration to use for connecting to the set service, needs to be valid for the lifetime of the listen handle
app_id	id of the application that handles set operation requests
listen_cb	called for each incoming request matching the operation and application id
listen_cls	handle for listen_cb

Returns

a handle that can be used to cancel the listen operation

Definition at line 717 of file setu_api.c.

{
  struct GNUNET_SETU_ListenHandle *lh;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Starting listener for app %s\n",
       GNUNET_h2s (app_id));
  lh = GNUNET_new (struct GNUNET_SETU_ListenHandle);
  lh->listen_cb = listen_cb;
  lh->listen_cls = listen_cls;
  lh->cfg = cfg;
  lh->app_id = *app_id;
  lh->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
  listen_connect (lh);
  if (NULL == lh->mq)
  {
    GNUNET_free (lh);
    return NULL;
  }
  return lh;
}

References GNUNET_SETU_ListenHandle::app_id, cfg, GNUNET_SETU_ListenHandle::cfg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_new, GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_SETU_ListenHandle::listen_cb, listen_cb(), GNUNET_SETU_ListenHandle::listen_cls, listen_connect(), LOG, GNUNET_SETU_ListenHandle::mq, and GNUNET_SETU_ListenHandle::reconnect_backoff.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETU_listen_cancel()

void GNUNET_SETU_listen_cancel

(

struct GNUNET_SETU_ListenHandle *

lh

)

Cancel the given listen operation.

After calling cancel, the listen callback for this listen handle will not be called again. Note that cancelling a listen operation will automatically reject all operations that have not yet been accepted.

Parameters

lh	handle for the listen operation
lh	handle for the listen operation

Definition at line 749 of file setu_api.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Canceling listener %s\n",
       GNUNET_h2s (&lh->app_id));
  if (NULL != lh->mq)
  {
    GNUNET_MQ_destroy (lh->mq);
    lh->mq = NULL;
  }
  if (NULL != lh->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (lh->reconnect_task);
    lh->reconnect_task = NULL;
  }
  GNUNET_free (lh);
}

References GNUNET_SETU_ListenHandle::app_id, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), LOG, GNUNET_SETU_ListenHandle::mq, and GNUNET_SETU_ListenHandle::reconnect_task.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETU_accept()

struct GNUNET_SETU_OperationHandle * GNUNET_SETU_accept	(	struct GNUNET_SETU_Request *	request,
		const struct GNUNET_SETU_Option	options[],
		GNUNET_SETU_ResultIterator	result_cb,
		void *	result_cls
	)

Accept a request we got via GNUNET_SETU_listen().

Must be called during GNUNET_SETU_listen(), as the struct GNUNET_SETU_Request becomes invalid afterwards. Call GNUNET_SETU_commit() to provide the local set to use for the operation, and to begin the exchange with the remote peer.

Parameters

request	request to accept
options	options to use when processing the request
result_cb	callback for the results
result_cls	closure for result_cb

Returns

a handle to cancel the operation

Definition at line 769 of file setu_api.c.

{
  struct GNUNET_MQ_Envelope *mqm;
  struct GNUNET_SETU_OperationHandle *oh;
  struct GNUNET_SETU_AcceptMessage *msg;
 
  GNUNET_assert (GNUNET_NO == request->accepted);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client accepts set union operation with id %u\n",
       request->accept_id);
  request->accepted = GNUNET_YES;
  mqm = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_SETU_ACCEPT);
  msg->accept_reject_id = htonl (request->accept_id);
 
  /* Set default values */
  msg->byzantine_upper_bond = UINT64_MAX;
  msg->bandwidth_latency_tradeoff = 0;
  msg->ibf_bucket_number_factor = 2;
  msg->ibf_number_of_buckets_per_element = 3;
 
  for (const struct GNUNET_SETU_Option *opt = options; opt->type != 0; opt++)
  {
    switch (opt->type)
    {
    case GNUNET_SETU_OPTION_BYZANTINE:
      msg->byzantine = GNUNET_YES;
      msg->byzantine_lower_bound = htonl (opt->v.num);
      break;
    case GNUNET_SETU_OPTION_CUSTOM_BYZANTINE_UPPER_BOUND:
      msg->byzantine_upper_bond = htonl (opt->v.num);
      break;
    case GNUNET_SETU_OPTION_CUSTOM_BANDWIDTH_LATENCY_TRADEOFF:
      msg->bandwidth_latency_tradeoff = htonl (opt->v.num);
      break;
    case GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKET_NUMBER_FACTOR:
      msg->ibf_bucket_number_factor = htonl (opt->v.num);
      break;
    case GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKETS_PER_ELEMENT:
      msg->ibf_number_of_buckets_per_element = htonl (opt->v.num);
      break;
    case GNUNET_SETU_OPTION_FORCE_FULL:
      msg->force_full = GNUNET_YES;
      break;
    case GNUNET_SETU_OPTION_FORCE_DELTA:
      msg->force_delta = GNUNET_YES;
      break;
    case GNUNET_SETU_OPTION_SYMMETRIC:
      msg->symmetric = GNUNET_YES;
      break;
    default:
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Option with type %d not recognized\n",
           (int) opt->type);
    }
  }
  oh = GNUNET_new (struct GNUNET_SETU_OperationHandle);
  oh->result_cb = result_cb;
  oh->result_cls = result_cls;
  oh->conclude_mqm = mqm;
  oh->request_id_addr = &msg->request_id;
  return oh;
}

References GNUNET_SETU_OperationHandle::conclude_mqm, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_MESSAGE_TYPE_SETU_ACCEPT, GNUNET_MQ_msg, GNUNET_new, GNUNET_NO, GNUNET_SETU_OPTION_BYZANTINE, GNUNET_SETU_OPTION_CUSTOM_BANDWIDTH_LATENCY_TRADEOFF, GNUNET_SETU_OPTION_CUSTOM_BYZANTINE_UPPER_BOUND, GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKET_NUMBER_FACTOR, GNUNET_SETU_OPTION_CUSTOM_IBF_BUCKETS_PER_ELEMENT, GNUNET_SETU_OPTION_FORCE_DELTA, GNUNET_SETU_OPTION_FORCE_FULL, GNUNET_SETU_OPTION_SYMMETRIC, GNUNET_YES, LOG, msg, options, request, GNUNET_SETU_OperationHandle::request_id_addr, GNUNET_SETU_OperationHandle::result_cb, and GNUNET_SETU_OperationHandle::result_cls.

Referenced by handle_revocation_union_request().

Here is the caller graph for this function:

GNUNET_SETU_commit()

int GNUNET_SETU_commit	(	struct GNUNET_SETU_OperationHandle *	oh,
		struct GNUNET_SETU_Handle *	set
	)

Commit a set to be used with a set operation.

This function is called once we have fully constructed the set that we want to use for the operation. At this time, the P2P protocol can then begin to exchange the set information and call the result callback with the result information.

Parameters

oh	handle to the set operation
set	the set to use for the operation

Returns

GNUNET_OK on success, GNUNET_SYSERR if the set is invalid (e.g. the set service crashed)

Definition at line 851 of file setu_api.c.

{
  if (NULL != oh->set)
  {
    /* Some other set was already committed for this
     * operation, there is a logic bug in the client of this API */
    GNUNET_break (0);
    return GNUNET_OK;
  }
  GNUNET_assert (NULL != set);
  if (GNUNET_YES == set->invalid)
    return GNUNET_SYSERR;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client commits to SET\n");
  GNUNET_assert (NULL != oh->conclude_mqm);
  oh->set = set;
  GNUNET_CONTAINER_DLL_insert (set->ops_head,
                               set->ops_tail,
                               oh);
  oh->request_id = GNUNET_MQ_assoc_add (set->mq,
                                        oh);
  *oh->request_id_addr = htonl (oh->request_id);
  GNUNET_MQ_send (set->mq,
                  oh->conclude_mqm);
  oh->conclude_mqm = NULL;
  oh->request_id_addr = NULL;
  return GNUNET_OK;
}

References GNUNET_SETU_OperationHandle::conclude_mqm, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_assoc_add(), GNUNET_MQ_send(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_SETU_Handle::invalid, LOG, GNUNET_SETU_Handle::mq, GNUNET_SETU_Handle::ops_head, GNUNET_SETU_Handle::ops_tail, GNUNET_SETU_OperationHandle::request_id, GNUNET_SETU_OperationHandle::request_id_addr, and GNUNET_SETU_OperationHandle::set.

Referenced by handle_revocation_union_request().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETU_operation_cancel()

void GNUNET_SETU_operation_cancel

(

struct GNUNET_SETU_OperationHandle *

oh

)

Cancel the given set operation.

May not be called after the operation's GNUNET_SETU_ResultIterator has been called with a status of GNUNET_SETU_STATUS_FAILURE or GNUNET_SETU_STATUS_DONE.

Parameters

oh	set operation to cancel

We need to send an explicit cancel message, as all operations one one set communicate using one handle.

Parameters

oh	set operation to cancel

Definition at line 320 of file setu_api.c.

{
  struct GNUNET_SETU_Handle *set = oh->set;
  struct GNUNET_SETU_CancelMessage *m;
  struct GNUNET_MQ_Envelope *mqm;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Cancelling SET operation\n");
  if (NULL != set)
  {
    mqm = GNUNET_MQ_msg (m, GNUNET_MESSAGE_TYPE_SETU_CANCEL);
    m->request_id = htonl (oh->request_id);
    GNUNET_MQ_send (set->mq, mqm);
  }
  set_operation_destroy (oh);
  if ((NULL != set) &&
      (GNUNET_YES == set->destroy_requested) &&
      (NULL == set->ops_head))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Destroying set after operation cancel\n");
    GNUNET_SETU_destroy (set);
  }
}

References GNUNET_SETU_Handle::destroy_requested, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SETU_CANCEL, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SETU_destroy(), GNUNET_YES, LOG, m, GNUNET_SETU_Handle::mq, GNUNET_SETU_Handle::ops_head, GNUNET_SETU_OperationHandle::request_id, GNUNET_SETU_OperationHandle::set, and set_operation_destroy().

Referenced by handle_core_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SETU_element_hash()

void GNUNET_SETU_element_hash	(	const struct GNUNET_SETU_Element *	element,
		struct GNUNET_HashCode *	ret_hash
	)

Hash a set element.

Parameters

	element	the element that should be hashed
[out]	ret_hash	a pointer to where the hash of element should be stored

Definition at line 890 of file setu_api.c.

{
  struct GNUNET_HashContext *ctx = GNUNET_CRYPTO_hash_context_start ();
 
  /* It's not guaranteed that the element data is always after the element header,
     so we need to hash the chunks separately. */
  GNUNET_CRYPTO_hash_context_read (ctx,
                                   &element->size,
                                   sizeof(uint16_t));
  GNUNET_CRYPTO_hash_context_read (ctx,
                                   &element->element_type,
                                   sizeof(uint16_t));
  GNUNET_CRYPTO_hash_context_read (ctx,
                                   element->data,
                                   element->size);
  GNUNET_CRYPTO_hash_context_finish (ctx,
                                     ret_hash);
}

References ctx, GNUNET_SETU_Element::data, GNUNET_SETU_Element::element_type, GNUNET_CRYPTO_hash_context_finish(), GNUNET_CRYPTO_hash_context_read(), GNUNET_CRYPTO_hash_context_start(), and GNUNET_SETU_Element::size.

Referenced by handle_client_set_add(), handle_union_p2p_elements(), and handle_union_p2p_full_element().

Here is the call graph for this function:

Here is the caller graph for this function: