gnunet-service-setu.c File Reference

set union operation More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_statistics_service.h"
#include "ibf.h"
#include "gnunet_protocols.h"
#include "gnunet_cadet_service.h"
#include "gnunet-service-setu_strata_estimator.h"
#include "gnunet-service-setu_protocol.h"
#include <gcrypt.h>
#include "gnunet_setu_service.h"
#include "setu.h"

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

Go to the source code of this file.

Data Structures
struct	ElementEntry
	Information about an element element in the set. More...
struct	ClientState
	State we keep per client. More...
struct	Operation
	Operation context used to execute a set operation. More...
struct	SetContent
	SetContent stores the actual set elements, which may be shared by multiple generations derived from one set. More...
struct	Set
	A set that supports a specific operation with other peers. More...
struct	KeyEntry
	The key entry is used to associate an ibf key with an element. More...
struct	SendElementClosure
	Used as a closure for sending elements with a specific IBF key. More...
struct	Listener
	A listener is inhabited by a client, and waits for evaluation requests from remote peers. More...
struct	messageControlFlowElement
	Struct to tracked messages in message control flow. More...
struct	GetElementContext
	Context for op_get_element_iterator. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "setu", __VA_ARGS__)
#define	INCOMING_CHANNEL_TIMEOUT   GNUNET_TIME_UNIT_MINUTES
	How long do we hold on to an incoming channel if there is no local listener before giving up? More...
#define	SE_STRATA_COUNT   32
	Number of IBFs in a strata estimator. More...
#define	SE_IBFS_TOTAL_SIZE   632
	Primes for all 4 different strata estimators 61,67,71,73,79,83,89,97 348 Based on the bsc thesis of Elias Summermatter (2021) More...
#define	SE_IBF_HASH_NUM   3
	The hash num parameter for the difference digests and strata estimators. More...
#define	MAX_BUCKETS_PER_MESSAGE   ((1 << 16) / IBF_BUCKET_SIZE)
	Number of buckets that can be transmitted in one message. More...
#define	MAX_IBF_SIZE   1048576
	The maximum size of an ibf we use is MAX_IBF_SIZE=2^20. More...
#define	IBF_MIN_SIZE   37
	Minimal size of an ibf Based on the bsc thesis of Elias Summermatter (2021) More...
#define	DIFFERENTIAL_RTT_MEAN   3.65145
	AVG RTT for differential sync when k=2 and Factor = 2 Based on the bsc thesis of Elias Summermatter (2021) More...
#define	SECURITY_LEVEL   80
	Security level used for byzantine checks (2^80) More...
#define	PROBABILITY_FOR_NEW_ROUND   0.15
	Is the estimated probability for a new round this values is based on the bsc thesis of Elias Summermatter (2021) More...
#define	MEASURE_PERFORMANCE   0
	Measure the performance in a csv. More...

Enumerations
enum	UnionOperationPhase {   PHASE_EXPECT_SE , PHASE_EXPECT_IBF , PHASE_EXPECT_IBF_CONT , PHASE_INVENTORY_ACTIVE ,   PHASE_INVENTORY_PASSIVE , PHASE_FINISH_CLOSING , PHASE_FINISH_WAITING , PHASE_DONE ,   PHASE_FULL_SENDING , PHASE_EXPECT_SE , PHASE_EXPECT_IBF , PHASE_EXPECT_IBF_LAST ,   PHASE_ACTIVE_DECODING , PHASE_PASSIVE_DECODING , PHASE_FINISH_CLOSING , PHASE_FINISH_WAITING ,   PHASE_FINISHED , PHASE_FULL_SENDING , PHASE_FULL_RECEIVING }
	Current phase we are in for a union operation. More...
enum	MODE_OF_OPERATION { DIFFERENTIAL_SYNC , FULL_SYNC_LOCAL_SENDING_FIRST , FULL_SYNC_REMOTE_SENDING_FIRST }
	Different modes of operations. More...
enum	MESSAGE_CONTROL_FLOW_STATE { MSG_CFS_UNINITIALIZED , MSG_CFS_SENT , MSG_CFS_EXPECTED , MSG_CFS_RECEIVED }
	Different states to control the messages flow in differential mode. More...
enum	MESSAGE_TYPE { OFFER_MESSAGE , DEMAND_MESSAGE , ELEMENT_MESSAGE }
	Message types to track in message control flow. More...

Functions
static uint8_t	estimate_best_mode_of_operation (uint64_t avg_element_size, uint64_t local_set_size, uint64_t remote_set_size, uint64_t est_set_diff_remote, uint64_t est_set_diff_local, uint64_t bandwith_latency_tradeoff, uint64_t ibf_bucket_number_factor)
	Function that chooses the optimal mode of operation depending on operation parameters. More...
static enum GNUNET_GenericReturnValue	check_valid_phase (const uint8_t allowed_phases[], size_t size_phases, struct Operation *op)
	Validates the if a message is received in a correct phase. More...
static int	update_message_control_flow (struct GNUNET_CONTAINER_MultiHashMap *hash_map, enum MESSAGE_CONTROL_FLOW_STATE new_mcfs, const struct GNUNET_HashCode *hash_code, enum MESSAGE_TYPE mt)
	Function to update, track and validate message received in differential sync. More...
static int	is_message_in_message_control_flow (struct GNUNET_CONTAINER_MultiHashMap *hash_map, struct GNUNET_HashCode *hash_code, enum MESSAGE_TYPE mt)
	Validate if a message in differential sync si already received before. More...
static int	determinate_done_message_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator for determining if all demands have been satisfied. More...
static int	determinate_avg_element_size_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator for determining average size. More...
static int	create_randomized_element_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
	Create randomized element hashmap for full sending. More...
static int	destroy_key_to_element_iter (void *cls, uint32_t key, void *value)
	Iterator over hash map entries, called to destroy the linked list of colliding ibf key entries. More...
static void	send_client_done (void *cls)
	Signal to the client that the operation has finished and destroy the operation. More...
static int	check_byzantine_bounds (struct Operation *op)
	Check if all given byzantine parameters are in given boundaries. More...
static enum GNUNET_GenericReturnValue	free_values_iter (void *cls, const struct GNUNET_HashCode *key, void *value)
static void	_GSS_operation_destroy (struct Operation *op)
	Destroy the given operation. More...
static void	_GSS_operation_destroy2 (struct Operation *op)
	This function probably should not exist and be replaced by inlining more specific logic in the various places where it is called. More...
static void	incoming_destroy (struct Operation *op)
	Destroy an incoming request from a remote peer. More...
static void	fail_union_operation (struct Operation *op)
	Inform the client that the union operation has failed, and proceed to destroy the evaluate operation. More...
static void	full_sync_plausibility_check (struct Operation *op)
	Function that checks if full sync is plausible. More...
static void	check_max_differential_rounds (struct Operation *op)
	Limit active passive switches in differential sync to configured security level. More...
static struct IBF_Key	get_ibf_key (const struct GNUNET_HashCode *src)
	Derive the IBF key from a hash code and a salt. More...
static int	op_get_element_iterator (void *cls, uint32_t key, void *value)
	Iterator over the mapping from IBF keys to element entries. More...
static struct KeyEntry *	op_get_element (struct Operation *op, const struct GNUNET_HashCode *element_hash)
	Determine whether the given element is already in the operation's element set. More...
static void	op_register_element (struct Operation *op, struct ElementEntry *ee, int received)
	Insert an element into the union operation's key-to-element mapping. More...
static void	salt_key (const struct IBF_Key *k_in, uint32_t salt, struct IBF_Key *k_out)
	Modify an IBF key k_in based on the salt, returning a salted key in k_out. More...
static void	unsalt_key (const struct IBF_Key *k_in, uint32_t salt, struct IBF_Key *k_out)
	Reverse modification done in the salt_key function. More...
static int	prepare_ibf_iterator (void *cls, uint32_t key, void *value)
	Insert a key into an ibf. More...
static int	_GSS_is_element_of_operation (struct ElementEntry *ee, struct Operation *op)
	Is element ee part of the set used by op? More...
static int	init_key_to_element_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator for initializing the key-to-element mapping of a union operation. More...
static void	initialize_key_to_element (struct Operation *op)
	Initialize the IBF key to element mapping local to this set operation. More...
static int	prepare_ibf (struct Operation *op, uint32_t size)
	Create an ibf with the operation's elements of the specified size. More...
static int	send_ibf (struct Operation *op, uint32_t ibf_size)
	Send an ibf of appropriate size. More...
static unsigned int	get_size_from_difference (unsigned int diff, int number_buckets_per_element, float ibf_bucket_number_factor)
	Compute the necessary order of an ibf from the size of the symmetric set difference. More...
static unsigned int	get_next_ibf_size (float ibf_bucket_number_factor, unsigned int decoded_elements, unsigned int last_ibf_size)
static int	send_full_element_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
	Send a set element. More...
static void	send_full_set (struct Operation *op)
	Switch to full set transmission for op. More...
static int	check_union_p2p_strata_estimator (void *cls, const struct StrataEstimatorMessage *msg)
	Handle a strata estimator from a remote peer. More...
static void	handle_union_p2p_strata_estimator (void *cls, const struct StrataEstimatorMessage *msg)
	Handle a strata estimator from a remote peer. More...
static int	send_offers_iterator (void *cls, uint32_t key, void *value)
	Iterator to send elements to a remote peer. More...
static void	send_offers_for_key (struct Operation *op, struct IBF_Key ibf_key)
	Send offers (in the form of GNUNET_Hash-es) to the remote peer for the given IBF key. More...
static int	decode_and_send (struct Operation *op)
	Decode which elements are missing on each side, and send the appropriate offers and inquiries. More...
static int	check_union_p2p_send_full (void *cls, const struct TransmitFullMessage *msg)
	Check send full message received from other peer. More...
static void	handle_union_p2p_send_full (void *cls, const struct TransmitFullMessage *msg)
	Handle send full message received from other peer. More...
static int	check_union_p2p_ibf (void *cls, const struct IBFMessage *msg)
	Check an IBF message from a remote peer. More...
static void	handle_union_p2p_ibf (void *cls, const struct IBFMessage *msg)
	Handle an IBF message from a remote peer. More...
static void	send_client_element (struct Operation *op, const struct GNUNET_SETU_Element *element, enum GNUNET_SETU_Status status)
	Send a result message to the client indicating that there is a new element. More...
static void	maybe_finish (struct Operation *op)
	Tests if the operation is finished, and if so notify. More...
static int	check_union_p2p_elements (void *cls, const struct GNUNET_SETU_ElementMessage *emsg)
	Check an element message from a remote peer. More...
static void	handle_union_p2p_elements (void *cls, const struct GNUNET_SETU_ElementMessage *emsg)
	Handle an element message from a remote peer. More...
static int	check_union_p2p_full_element (void *cls, const struct GNUNET_SETU_ElementMessage *emsg)
	Check a full element message from a remote peer. More...
static void	handle_union_p2p_full_element (void *cls, const struct GNUNET_SETU_ElementMessage *emsg)
	Handle an element message from a remote peer. More...
static int	check_union_p2p_inquiry (void *cls, const struct InquiryMessage *msg)
	Send offers (for GNUNET_Hash-es) in response to inquiries (for IBF_Key-s). More...
static void	handle_union_p2p_inquiry (void *cls, const struct InquiryMessage *msg)
	Send offers (for GNUNET_Hash-es) in response to inquiries (for IBF_Key-s). More...
static int	send_missing_full_elements_iter (void *cls, uint32_t key, void *value)
	Iterator over hash map entries, called to destroy the linked list of colliding ibf key entries. More...
static int	check_union_p2p_request_full (void *cls, const struct TransmitFullMessage *mh)
	Handle a request for full set transmission. More...
static void	handle_union_p2p_request_full (void *cls, const struct TransmitFullMessage *msg)
static void	handle_union_p2p_full_done (void *cls, const struct GNUNET_MessageHeader *mh)
	Handle a "full done" message. More...
static int	check_union_p2p_demand (void *cls, const struct GNUNET_MessageHeader *mh)
	Check a demand by the other peer for elements based on a list of struct GNUNET_HashCodes. More...
static void	handle_union_p2p_demand (void *cls, const struct GNUNET_MessageHeader *mh)
	Handle a demand by the other peer for elements based on a list of struct GNUNET_HashCodes. More...
static int	check_union_p2p_offer (void *cls, const struct GNUNET_MessageHeader *mh)
	Check offer (of struct GNUNET_HashCodes). More...
static void	handle_union_p2p_offer (void *cls, const struct GNUNET_MessageHeader *mh)
	Handle offers (of struct GNUNET_HashCodes) and respond with demands (of struct GNUNET_HashCodes). More...
static void	handle_union_p2p_done (void *cls, const struct GNUNET_MessageHeader *mh)
	Handle a done message from a remote peer. More...
static void	handle_union_p2p_over (void *cls, const struct GNUNET_MessageHeader *mh)
	Handle a over message from a remote peer. More...
static struct Operation *	get_incoming (uint32_t id)
	Get the incoming socket associated with the given id. More...
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *c, struct GNUNET_MQ_Handle *mq)
	Callback called when a client connects to the service. More...
static int	destroy_elements_iterator (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator over hash map entries to free element entries. More...
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *internal_cls)
	Clean up after a client has disconnected. More...
static int	check_incoming_msg (void *cls, const struct OperationRequestMessage *msg)
	Check a request for a set operation from another peer. More...
static void	handle_incoming_msg (void *cls, const struct OperationRequestMessage *msg)
	Handle a request for a set operation from another peer. More...
static void	handle_client_create_set (void *cls, const struct GNUNET_SETU_CreateMessage *msg)
	Called when a client wants to create a new set. More...
static void	incoming_timeout_cb (void *cls)
	Timeout happens iff: More...
static void *	channel_new_cb (void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *source)
	Method called whenever another peer has added us to a channel the other peer initiated. More...
static void	channel_end_cb (void *channel_ctx, const struct GNUNET_CADET_Channel *channel)
	Function called whenever a channel is destroyed. More...
static void	channel_window_cb (void *cls, const struct GNUNET_CADET_Channel *channel, int window_size)
	Function called whenever an MQ-channel's transmission window size changes. More...
static void	handle_client_listen (void *cls, const struct GNUNET_SETU_ListenMessage *msg)
	Called when a client wants to create a new listener. More...
static void	handle_client_reject (void *cls, const struct GNUNET_SETU_RejectMessage *msg)
	Called when the listening client rejects an operation request by another peer. More...
static int	check_client_set_add (void *cls, const struct GNUNET_SETU_ElementMessage *msg)
	Called when a client wants to add or remove an element to a set it inhabits. More...
static void	handle_client_set_add (void *cls, const struct GNUNET_SETU_ElementMessage *msg)
	Called when a client wants to add or remove an element to a set it inhabits. More...
static void	advance_generation (struct Set *set)
	Advance the current generation of a set, adding exclusion ranges if necessary. More...
static int	check_client_evaluate (void *cls, const struct GNUNET_SETU_EvaluateMessage *msg)
	Called when a client wants to initiate a set operation with another peer. More...
static void	handle_client_evaluate (void *cls, const struct GNUNET_SETU_EvaluateMessage *msg)
	Called when a client wants to initiate a set operation with another peer. More...
static void	handle_client_cancel (void *cls, const struct GNUNET_SETU_CancelMessage *msg)
	Handle a request from the client to cancel a running set operation. More...
static void	handle_client_accept (void *cls, const struct GNUNET_SETU_AcceptMessage *msg)
	Handle a request from the client to accept a set operation that came from a remote peer. More...
static void	shutdown_task (void *cls)
	Called to clean up, after a shutdown has been requested. More...
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
	Function called by the service's run method to run service-specific setup code. More...
	GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "set", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(client_accept, GNUNET_MESSAGE_TYPE_SETU_ACCEPT, struct GNUNET_SETU_AcceptMessage, NULL), GNUNET_MQ_hd_var_size(client_set_add, GNUNET_MESSAGE_TYPE_SETU_ADD, struct GNUNET_SETU_ElementMessage, NULL), GNUNET_MQ_hd_fixed_size(client_create_set, GNUNET_MESSAGE_TYPE_SETU_CREATE, struct GNUNET_SETU_CreateMessage, NULL), GNUNET_MQ_hd_var_size(client_evaluate, GNUNET_MESSAGE_TYPE_SETU_EVALUATE, struct GNUNET_SETU_EvaluateMessage, NULL), GNUNET_MQ_hd_fixed_size(client_listen, GNUNET_MESSAGE_TYPE_SETU_LISTEN, struct GNUNET_SETU_ListenMessage, NULL), GNUNET_MQ_hd_fixed_size(client_reject, GNUNET_MESSAGE_TYPE_SETU_REJECT, struct GNUNET_SETU_RejectMessage, NULL), GNUNET_MQ_hd_fixed_size(client_cancel, GNUNET_MESSAGE_TYPE_SETU_CANCEL, struct GNUNET_SETU_CancelMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro. More...

Variables
static struct GNUNET_CADET_Handle *	cadet
	Handle to the cadet service, used to listen for and connect to remote peers. More...
static struct GNUNET_STATISTICS_Handle *	_GSS_statistics
	Statistics handle. More...
static struct Listener *	listener_head
	Listeners are held in a doubly linked list. More...
static struct Listener *	listener_tail
	Listeners are held in a doubly linked list. More...
static unsigned int	num_clients
	Number of active clients. More...
static int	in_shutdown
	Are we in shutdown? if GNUNET_YES and the number of clients drops to zero, disconnect from CADET. More...
static uint32_t	suggest_id
	Counter for allocating unique IDs for clients, used to identify incoming operation requests from remote peers, that the client can choose to accept or refuse. More...

Detailed Description

set union operation

Author

Florian Dold

Christian Grothoff

Elias Summermatter

Definition in file gnunet-service-setu.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "setu", __VA_ARGS__)

Definition at line 40 of file gnunet-service-setu.c.

INCOMING_CHANNEL_TIMEOUT

#define INCOMING_CHANNEL_TIMEOUT   GNUNET_TIME_UNIT_MINUTES

How long do we hold on to an incoming channel if there is no local listener before giving up?

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

SE_STRATA_COUNT

#define SE_STRATA_COUNT   32

Number of IBFs in a strata estimator.

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

SE_IBFS_TOTAL_SIZE

#define SE_IBFS_TOTAL_SIZE   632

Primes for all 4 different strata estimators 61,67,71,73,79,83,89,97 348 Based on the bsc thesis of Elias Summermatter (2021)

Definition at line 58 of file gnunet-service-setu.c.

SE_IBF_HASH_NUM

#define SE_IBF_HASH_NUM   3

The hash num parameter for the difference digests and strata estimators.

Definition at line 63 of file gnunet-service-setu.c.

MAX_BUCKETS_PER_MESSAGE

#define MAX_BUCKETS_PER_MESSAGE   ((1 << 16) / IBF_BUCKET_SIZE)

Number of buckets that can be transmitted in one message.

Definition at line 68 of file gnunet-service-setu.c.

MAX_IBF_SIZE

#define MAX_IBF_SIZE   1048576

The maximum size of an ibf we use is MAX_IBF_SIZE=2^20.

Choose this value so that computing the IBF is still cheaper than transmitting all values.

Definition at line 75 of file gnunet-service-setu.c.

IBF_MIN_SIZE

#define IBF_MIN_SIZE   37

Minimal size of an ibf Based on the bsc thesis of Elias Summermatter (2021)

Definition at line 82 of file gnunet-service-setu.c.

DIFFERENTIAL_RTT_MEAN

#define DIFFERENTIAL_RTT_MEAN   3.65145

AVG RTT for differential sync when k=2 and Factor = 2 Based on the bsc thesis of Elias Summermatter (2021)

Definition at line 88 of file gnunet-service-setu.c.

SECURITY_LEVEL

#define SECURITY_LEVEL   80

Security level used for byzantine checks (2^80)

Definition at line 94 of file gnunet-service-setu.c.

PROBABILITY_FOR_NEW_ROUND

#define PROBABILITY_FOR_NEW_ROUND   0.15

Is the estimated probability for a new round this values is based on the bsc thesis of Elias Summermatter (2021)

Definition at line 101 of file gnunet-service-setu.c.

MEASURE_PERFORMANCE

#define MEASURE_PERFORMANCE   0

Measure the performance in a csv.

Definition at line 107 of file gnunet-service-setu.c.

Enumeration Type Documentation

UnionOperationPhase

enum UnionOperationPhase

Current phase we are in for a union operation.

Enumerator
PHASE_EXPECT_SE	We sent the request message, and expect a strata estimator.
PHASE_EXPECT_IBF	We sent the strata estimator, and expect an IBF. This phase is entered once upon initialization and later via #PHASE_EXPECT_ELEMENTS_AND_REQUESTS. XXX: could use better wording. XXX: repurposed to also expect a "request full set" message, should be renamed After receiving the complete IBF, we enter #PHASE_EXPECT_ELEMENTS
PHASE_EXPECT_IBF_CONT	Continuation for multi part IBFs.
PHASE_INVENTORY_ACTIVE	We are decoding an IBF.
PHASE_INVENTORY_PASSIVE	The other peer is decoding the IBF we just sent.
PHASE_FINISH_CLOSING	The protocol is almost finished, but we still have to flush our message queue and/or expect some elements.
PHASE_FINISH_WAITING	In the penultimate phase, we wait until all our demands are satisfied. Then we send a done message, and wait for another done message.
PHASE_DONE	In the ultimate phase, we wait until our demands are satisfied and then quit (sending another DONE message).
PHASE_FULL_SENDING	After sending the full set, wait for responses with the elements that the local peer is missing.
PHASE_EXPECT_SE	We sent the request message, and expect a strata estimator.
PHASE_EXPECT_IBF	We sent the strata estimator, and expect an IBF. This phase is entered once upon initialization and later via #PHASE_EXPECT_ELEMENTS_AND_REQUESTS. XXX: could use better wording. XXX: repurposed to also expect a "request full set" message, should be renamed After receiving the complete IBF, we enter #PHASE_EXPECT_ELEMENTS
PHASE_EXPECT_IBF_LAST	Continuation for multi part IBFs.
PHASE_ACTIVE_DECODING	We are decoding an IBF.
PHASE_PASSIVE_DECODING	The other peer is decoding the IBF we just sent.
PHASE_FINISH_CLOSING	The protocol is almost finished, but we still have to flush our message queue and/or expect some elements.
PHASE_FINISH_WAITING	In the penultimate phase, we wait until all our demands are satisfied. Then we send a done message, and wait for another done message.
PHASE_FINISHED	In the ultimate phase, we wait until our demands are satisfied and then quit (sending another DONE message).
PHASE_FULL_SENDING	After sending the full set, wait for responses with the elements that the local peer is missing.
PHASE_FULL_RECEIVING	Phase that receives full set first and then sends elements that are the local peer missing.

Definition at line 113 of file gnunet-service-setu.c.

{
  PHASE_EXPECT_SE,
 
  PHASE_EXPECT_IBF,
 
  PHASE_EXPECT_IBF_LAST,
 
  PHASE_ACTIVE_DECODING,
 
  PHASE_PASSIVE_DECODING,
 
  PHASE_FINISH_CLOSING,
 
  PHASE_FINISH_WAITING,
 
  PHASE_FINISHED,
 
  PHASE_FULL_SENDING,
 
  PHASE_FULL_RECEIVING
};

MODE_OF_OPERATION

enum MODE_OF_OPERATION

Different modes of operations.

Enumerator
DIFFERENTIAL_SYNC	Mode just synchronizes the difference between sets.
FULL_SYNC_LOCAL_SENDING_FIRST	Mode send full set sending local set first.
FULL_SYNC_REMOTE_SENDING_FIRST	Mode request full set from remote peer.

Definition at line 181 of file gnunet-service-setu.c.

{
  DIFFERENTIAL_SYNC,
 
  FULL_SYNC_LOCAL_SENDING_FIRST,
 
  FULL_SYNC_REMOTE_SENDING_FIRST
};

MESSAGE_CONTROL_FLOW_STATE

enum MESSAGE_CONTROL_FLOW_STATE

Different states to control the messages flow in differential mode.

Enumerator
MSG_CFS_UNINITIALIZED	Initial message state.
MSG_CFS_SENT	Track that a message has been sent.
MSG_CFS_EXPECTED	Track that receiving this message is expected.
MSG_CFS_RECEIVED	Track that message has been received.

Definition at line 812 of file gnunet-service-setu.c.

{
  MSG_CFS_UNINITIALIZED,
 
  MSG_CFS_SENT,
 
  MSG_CFS_EXPECTED,
 
  MSG_CFS_RECEIVED,
};

MESSAGE_TYPE

enum MESSAGE_TYPE

Message types to track in message control flow.

Enumerator
OFFER_MESSAGE	Offer message type.
DEMAND_MESSAGE	Demand message type.
ELEMENT_MESSAGE	Element message type.

Definition at line 839 of file gnunet-service-setu.c.

{
  OFFER_MESSAGE,
 
  DEMAND_MESSAGE,
 
  ELEMENT_MESSAGE,
};

Function Documentation

estimate_best_mode_of_operation()

static uint8_t estimate_best_mode_of_operation ( uint64_t  avg_element_size, uint64_t  local_set_size, uint64_t  remote_set_size, uint64_t  est_set_diff_remote, uint64_t  est_set_diff_local, uint64_t  bandwith_latency_tradeoff, uint64_t  ibf_bucket_number_factor  )

static

Function that chooses the optimal mode of operation depending on operation parameters.

Parameters

avg_element_size
local_set_size
remote_set_size
est_set_diff_remote
est_set_diff_local
bandwith_latency_tradeoff
ibf_bucket_number_factor

Returns

calculated mode of operation

Definition at line 1050 of file gnunet-service-setu.c.

{
 
  /*
   * In case of initial sync fall to predefined states
   */
  {
    if (0 == local_set_size)
      return FULL_SYNC_REMOTE_SENDING_FIRST;
    if (0 == remote_set_size)
      return FULL_SYNC_LOCAL_SENDING_FIRST;
  }
  /*
  * Calculate bytes for full Sync
  */
  {
    uint8_t sizeof_full_done_header = 4;
    uint8_t sizeof_done_header = 4;
    uint8_t rtt_min_full = 2;
    uint8_t sizeof_request_full = 4;
    uint64_t estimated_total_diff = (est_set_diff_remote + est_set_diff_local);
 
    /* Estimate byte required if we send first */
    uint64_t total_elements_to_send_local_send_first = est_set_diff_remote
                                                       + local_set_size;
 
    uint64_t total_bytes_full_local_send_first = (avg_element_size
                                                  *
                                                  total_elements_to_send_local_send_first)   \
                                                 + (
      total_elements_to_send_local_send_first * sizeof(struct
                                                       GNUNET_SETU_ElementMessage)
      )   \
                                                 + (sizeof_full_done_header * 2)   \
                                                 + rtt_min_full
                                                 * bandwith_latency_tradeoff;
 
    /* Estimate bytes required if we request from remote peer */
    uint64_t total_elements_to_send_remote_send_first = est_set_diff_local
                                                        + remote_set_size;
 
    uint64_t total_bytes_full_remote_send_first = (avg_element_size
                                                   *
                                                   total_elements_to_send_remote_send_first)   \
                                                  + (
      total_elements_to_send_remote_send_first * sizeof(struct
                                                        GNUNET_SETU_ElementMessage))   \
                                                  + (sizeof_full_done_header * 2
                                                     )   \
                                                  + (rtt_min_full + 0.5)
                                                  * bandwith_latency_tradeoff   \
                                                  + sizeof_request_full;
 
    /*
    * Calculate bytes for differential Sync
    */
 
    /* Estimate bytes required by IBF transmission*/
 
    long double ibf_bucket_count = estimated_total_diff
                                   * ibf_bucket_number_factor;
 
    if (ibf_bucket_count <= IBF_MIN_SIZE)
    {
      ibf_bucket_count = IBF_MIN_SIZE;
    }
    {
      uint64_t ibf_message_count = ceil ( ((float) ibf_bucket_count)
                                          / ((float) MAX_BUCKETS_PER_MESSAGE));
 
      uint64_t estimated_counter_size = ceil (
        MIN (2 * log2l (((float) local_set_size)
                        / ((float) ibf_bucket_count)),
             log2l (local_set_size)));
 
      long double counter_bytes = (float) estimated_counter_size / 8;
 
      uint64_t ibf_bytes = ceil ((sizeof (struct IBFMessage) * ibf_message_count
                                  )
                                 * 1.2   \
                                 + (ibf_bucket_count * sizeof(struct IBF_Key))
                                 * 1.2   \
                                 + (ibf_bucket_count * sizeof(struct
                                                              IBF_KeyHash))
                                 * 1.2   \
                                 + (ibf_bucket_count * counter_bytes) * 1.2);
 
      /* Estimate full byte count for differential sync */
      uint64_t element_size = (avg_element_size
                               + sizeof (struct GNUNET_SETU_ElementMessage))   \
                              * estimated_total_diff;
      uint64_t done_size = sizeof_done_header;
      uint64_t inquery_size = (sizeof (struct IBF_Key)
                               + sizeof (struct InquiryMessage))
                              * estimated_total_diff;
      uint64_t demand_size =
        (sizeof(struct GNUNET_HashCode) + sizeof(struct GNUNET_MessageHeader))
        * estimated_total_diff;
      uint64_t offer_size = (sizeof (struct GNUNET_HashCode)
                             + sizeof (struct GNUNET_MessageHeader))
                            * estimated_total_diff;
 
      uint64_t total_bytes_diff = (element_size + done_size + inquery_size
                                   + demand_size + offer_size + ibf_bytes)   \
                                  + (DIFFERENTIAL_RTT_MEAN
                                     * bandwith_latency_tradeoff);
 
      uint64_t full_min = MIN (total_bytes_full_local_send_first,
                               total_bytes_full_remote_send_first);
 
      /* Decide between full and differential sync */
 
      if (full_min < total_bytes_diff)
      {
        /* Decide between sending all element first or receiving all elements */
        if (total_bytes_full_remote_send_first >
            total_bytes_full_local_send_first
            )
        {
          return FULL_SYNC_LOCAL_SENDING_FIRST;
        }
        else
        {
          return FULL_SYNC_REMOTE_SENDING_FIRST;
        }
      }
      else
      {
        return DIFFERENTIAL_SYNC;
      }
    }
  }
}

References DIFFERENTIAL_RTT_MEAN, DIFFERENTIAL_SYNC, FULL_SYNC_LOCAL_SENDING_FIRST, FULL_SYNC_REMOTE_SENDING_FIRST, IBF_MIN_SIZE, and MAX_BUCKETS_PER_MESSAGE.

Referenced by handle_union_p2p_request_full(), handle_union_p2p_send_full(), and handle_union_p2p_strata_estimator().

Here is the caller graph for this function:

check_valid_phase()

static enum GNUNET_GenericReturnValue check_valid_phase ( const uint8_t  allowed_phases[], size_t  size_phases, struct Operation *  op  )

static

Validates the if a message is received in a correct phase.

Parameters

allowed_phases
size_phases
op

Returns

GNUNET_YES if message permitted in phase and GNUNET_NO if not permitted in given phase

Iterate over allowed phases

Definition at line 1200 of file gnunet-service-setu.c.

{
  for (uint32_t phase_ctr = 0; phase_ctr < size_phases; phase_ctr++)
  {
    uint8_t phase = allowed_phases[phase_ctr];
    if (phase == op->phase)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Message received in valid phase\n");
      return GNUNET_YES;
    }
  }
  LOG (GNUNET_ERROR_TYPE_ERROR,
       "Received message in invalid phase: %u\n", op->phase);
  return GNUNET_NO;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_NO, GNUNET_YES, LOG, op, and phase.

Referenced by handle_union_p2p_demand(), handle_union_p2p_done(), handle_union_p2p_elements(), handle_union_p2p_full_done(), handle_union_p2p_full_element(), handle_union_p2p_ibf(), handle_union_p2p_inquiry(), handle_union_p2p_offer(), handle_union_p2p_request_full(), handle_union_p2p_send_full(), and handle_union_p2p_strata_estimator().

Here is the caller graph for this function:

update_message_control_flow()

static int update_message_control_flow ( struct GNUNET_CONTAINER_MultiHashMap *  hash_map, enum MESSAGE_CONTROL_FLOW_STATE  new_mcfs, const struct GNUNET_HashCode *  hash_code, enum MESSAGE_TYPE  mt  )

static

Function to update, track and validate message received in differential sync.

This function tracks states of messages and check it against different constraints as described in Summermatter's BSc Thesis (2021)

Parameters

hash_map	Hashmap to store message control flow
new_mcfs	The new message control flow state an given message type should be set to
hash_code	Hash code of the element
mt	The message type for which the message control flow state should be set

Returns

GNUNET_YES message is valid in message control flow GNUNET_NO when message is not valid at this point in message flow

Check logic for forbidden messages

In case the element hash is not in the hashmap create a new entry

Set state of message

Check if state is allowed

Definition at line 1235 of file gnunet-service-setu.c.

{
  struct messageControlFlowElement *cfe = NULL;
  enum MESSAGE_CONTROL_FLOW_STATE *mcfs;
 
  cfe = GNUNET_CONTAINER_multihashmap_get (hash_map, hash_code);
  if ((ELEMENT_MESSAGE == mt) && (cfe != NULL))
  {
    if ((new_mcfs != MSG_CFS_SENT) && (MSG_CFS_RECEIVED != cfe->offer))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Received an element without sent offer!\n");
      return GNUNET_NO;
    }
    /* Check that only requested elements are received! */
    if ((ELEMENT_MESSAGE == mt) && (new_mcfs != MSG_CFS_SENT) && (cfe->demand !=
                                                                  MSG_CFS_SENT))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Received an element that was not demanded\n");
      return GNUNET_NO;
    }
  }
 
  if (NULL == cfe)
  {
    cfe = GNUNET_new (struct messageControlFlowElement);
    if (GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put (hash_map, hash_code,
                                                            cfe,
                                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
    {
      GNUNET_free (cfe);
      return GNUNET_SYSERR;
    }
  }
 
  if (OFFER_MESSAGE == mt)
  {
    mcfs = &cfe->offer;
  }
  else if (DEMAND_MESSAGE == mt)
  {
    mcfs = &cfe->demand;
  }
  else if (ELEMENT_MESSAGE == mt)
  {
    mcfs = &cfe->element;
  }
  else
  {
    return GNUNET_SYSERR;
  }
 
  if (new_mcfs <= *mcfs)
  {
    return GNUNET_NO;
  }
 
  *mcfs = new_mcfs;
  return GNUNET_YES;
}

References messageControlFlowElement::demand, DEMAND_MESSAGE, messageControlFlowElement::element, ELEMENT_MESSAGE, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_new, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, LOG, MSG_CFS_RECEIVED, MSG_CFS_SENT, messageControlFlowElement::offer, and OFFER_MESSAGE.

Referenced by handle_union_p2p_demand(), handle_union_p2p_elements(), handle_union_p2p_offer(), and send_offers_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

is_message_in_message_control_flow()

static int is_message_in_message_control_flow ( struct GNUNET_CONTAINER_MultiHashMap *  hash_map, struct GNUNET_HashCode *  hash_code, enum MESSAGE_TYPE  mt  )

static

Validate if a message in differential sync si already received before.

Parameters

hash_map
hash_code
mt

Returns

GNUNET_YES when message is already in store if message is not in store return GNUNET_NO

Set state of message

Evaluate if set is in message

Definition at line 1325 of file gnunet-service-setu.c.

{
  struct messageControlFlowElement *cfe = NULL;
  enum MESSAGE_CONTROL_FLOW_STATE *mcfs;
 
  cfe = GNUNET_CONTAINER_multihashmap_get (hash_map, hash_code);
 
  if (cfe != NULL)
  {
    if (OFFER_MESSAGE == mt)
    {
      mcfs = &cfe->offer;
    }
    else if (DEMAND_MESSAGE == mt)
    {
      mcfs = &cfe->demand;
    }
    else if (ELEMENT_MESSAGE == mt)
    {
      mcfs = &cfe->element;
    }
    else
    {
      return GNUNET_SYSERR;
    }
 
    if (*mcfs != MSG_CFS_UNINITIALIZED)
    {
      return GNUNET_YES;
    }
  }
  return GNUNET_NO;
}

References messageControlFlowElement::demand, DEMAND_MESSAGE, messageControlFlowElement::element, ELEMENT_MESSAGE, GNUNET_CONTAINER_multihashmap_get(), GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, MSG_CFS_UNINITIALIZED, messageControlFlowElement::offer, and OFFER_MESSAGE.

Referenced by send_offers_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

determinate_done_message_iterator()

static int determinate_done_message_iterator ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Iterator for determining if all demands have been satisfied.

Parameters

cls	the union operation struct Operation *
key	unused
value	the struct ElementEntry * to insert into the key-to-element mapping

Returns

GNUNET_YES (to continue iterating)

Definition at line 1381 of file gnunet-service-setu.c.

{
  struct messageControlFlowElement *mcfe = value;
 
  if (((mcfe->element == MSG_CFS_SENT) || (mcfe->element == MSG_CFS_RECEIVED) ))
  {
    return GNUNET_YES;
  }
  return GNUNET_NO;
}

References messageControlFlowElement::element, GNUNET_NO, GNUNET_YES, MSG_CFS_RECEIVED, MSG_CFS_SENT, and value.

Referenced by maybe_finish().

Here is the caller graph for this function:

determinate_avg_element_size_iterator()

static int determinate_avg_element_size_iterator ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Iterator for determining average size.

Parameters

cls	the union operation struct Operation *
key	unused
value	the struct ElementEntry * to insert into the key-to-element mapping

Returns

GNUNET_YES (to continue iterating)

Definition at line 1405 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  struct GNUNET_SETU_Element *element = value;
  op->total_elements_size_local += element->size;
  return GNUNET_YES;
}

References GNUNET_YES, op, GNUNET_SETU_Element::size, and value.

Referenced by handle_client_accept(), handle_union_p2p_request_full(), handle_union_p2p_send_full(), and handle_union_p2p_strata_estimator().

Here is the caller graph for this function:

create_randomized_element_iterator()

static int create_randomized_element_iterator ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Create randomized element hashmap for full sending.

Parameters

cls	the union operation struct Operation *
key	unused
value	the struct ElementEntry * to insert into the key-to-element mapping

Returns

GNUNET_YES (to continue iterating)

Hash element with new salt to randomize hashmap

Definition at line 1426 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
 
  struct GNUNET_HashContext *hashed_key_context =
    GNUNET_CRYPTO_hash_context_start ();
  struct GNUNET_HashCode new_key;
 
  GNUNET_CRYPTO_hash_context_read (hashed_key_context,
                                   &key,
                                   sizeof(struct IBF_Key));
  GNUNET_CRYPTO_hash_context_read (hashed_key_context,
                                   &op->set->content->elements_randomized_salt,
                                   sizeof(uint32_t));
  GNUNET_CRYPTO_hash_context_finish (hashed_key_context,
                                     &new_key);
  GNUNET_CONTAINER_multihashmap_put (op->set->content->elements_randomized,
                                     &new_key,value,
                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
  return GNUNET_YES;
}

References GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE, GNUNET_CRYPTO_hash_context_finish(), GNUNET_CRYPTO_hash_context_read(), GNUNET_CRYPTO_hash_context_start(), GNUNET_YES, key, op, and value.

Referenced by send_full_set().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_key_to_element_iter()

static int destroy_key_to_element_iter ( void *  cls, uint32_t  key, void *  value  )

static

Iterator over hash map entries, called to destroy the linked list of colliding ibf key entries.

Parameters

cls	closure
key	current key code
value	value in the hash map

Returns

GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

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

{
  struct KeyEntry *k = value;
 
  GNUNET_assert (NULL != k);
  if (GNUNET_YES == k->element->remote)
  {
    GNUNET_free (k->element);
    k->element = NULL;
  }
  GNUNET_free (k);
  return GNUNET_YES;
}

References KeyEntry::element, GNUNET_assert, GNUNET_free, GNUNET_YES, ElementEntry::remote, and value.

Referenced by _GSS_operation_destroy().

Here is the caller graph for this function:

send_client_done()

static void send_client_done ( void *  cls )

static

Signal to the client that the operation has finished and destroy the operation.

Parameters

cls	operation to destroy

Definition at line 1489 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SETU_ResultMessage *rm;
 
  if (GNUNET_YES == op->client_done_sent)
    return;
  if (PHASE_FINISHED != op->phase)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Union operation failed\n");
    GNUNET_STATISTICS_update (_GSS_statistics,
                              "# Union operations failed",
                              1,
                              GNUNET_NO);
    ev = GNUNET_MQ_msg (rm, GNUNET_MESSAGE_TYPE_SETU_RESULT);
    rm->result_status = htons (GNUNET_SETU_STATUS_FAILURE);
    rm->request_id = htonl (op->client_request_id);
    rm->element_type = htons (0);
    GNUNET_MQ_send (op->set->cs->mq,
                    ev);
    return;
  }
 
  op->client_done_sent = GNUNET_YES;
 
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# Union operations succeeded",
                            1,
                            GNUNET_NO);
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Signalling client that union operation is done\n");
  ev = GNUNET_MQ_msg (rm,
                      GNUNET_MESSAGE_TYPE_SETU_RESULT);
  rm->request_id = htonl (op->client_request_id);
  rm->result_status = htons (GNUNET_SETU_STATUS_DONE);
  rm->element_type = htons (0);
  rm->current_size = GNUNET_htonll (GNUNET_CONTAINER_multihashmap32_size (
                                      op->key_to_element));
  GNUNET_MQ_send (op->set->cs->mq,
                  ev);
}

References _GSS_statistics, GNUNET_SETU_ResultMessage::current_size, GNUNET_SETU_ResultMessage::element_type, GNUNET_CONTAINER_multihashmap32_size(), GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_SETU_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SETU_STATUS_DONE, GNUNET_SETU_STATUS_FAILURE, GNUNET_STATISTICS_update(), GNUNET_YES, LOG, op, PHASE_FINISHED, GNUNET_SETU_ResultMessage::request_id, and GNUNET_SETU_ResultMessage::result_status.

Referenced by _GSS_operation_destroy2(), handle_union_p2p_full_done(), handle_union_p2p_over(), and maybe_finish().

Here is the call graph for this function:

Here is the caller graph for this function:

check_byzantine_bounds()

static int check_byzantine_bounds ( struct Operation *  op )

static

Check if all given byzantine parameters are in given boundaries.

Parameters

op

Returns

indicator if all given byzantine parameters are in given boundaries

Check upper byzantine bounds

Check lower byzantine bounds

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

{
  if (op->byzantine != GNUNET_YES)
    return GNUNET_OK;
 
  if (op->remote_element_count + op->remote_set_diff >
      op->byzantine_upper_bound)
    return GNUNET_SYSERR;
  if (op->local_element_count + op->local_set_diff > op->byzantine_upper_bound)
    return GNUNET_SYSERR;
 
  if (op->remote_element_count < op->byzantine_lower_bound)
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

References GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, and op.

Referenced by handle_union_p2p_request_full(), and handle_union_p2p_send_full().

Here is the caller graph for this function:

free_values_iter()

static enum GNUNET_GenericReturnValue free_values_iter ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Definition at line 1565 of file gnunet-service-setu.c.

{
  GNUNET_free (value);
  return GNUNET_YES;
}

References GNUNET_free, GNUNET_YES, and value.

Referenced by _GSS_operation_destroy().

Here is the caller graph for this function:

_GSS_operation_destroy()

static void _GSS_operation_destroy ( struct Operation *  op )

static

Destroy the given operation.

Used for any operation where both peers were known and that thus actually had a vt and channel. Must not be used for operations where 'listener' is still set and we do not know the other peer.

Call the implementation-specific cancel function of the operation. Disconnects from the remote peer. Does not disconnect the client, as there may be multiple operations per set.

Parameters

op	operation to destroy

Definition at line 1589 of file gnunet-service-setu.c.

{
  struct Set *set = op->set;
  struct GNUNET_CADET_Channel *channel;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Destroying union operation %p\n",
              op);
  GNUNET_assert (NULL == op->listener);
  /* check if the op was canceled twice */
  if (NULL != op->remote_ibf)
  {
    ibf_destroy (op->remote_ibf);
    op->remote_ibf = NULL;
  }
  if (NULL != op->demanded_hashes)
  {
    GNUNET_CONTAINER_multihashmap_destroy (op->demanded_hashes);
    op->demanded_hashes = NULL;
  }
  if (NULL != op->local_ibf)
  {
    ibf_destroy (op->local_ibf);
    op->local_ibf = NULL;
  }
  if (NULL != op->se)
  {
    strata_estimator_destroy (op->se);
    op->se = NULL;
  }
  if (NULL != op->key_to_element)
  {
    GNUNET_CONTAINER_multihashmap32_iterate (op->key_to_element,
                                             &destroy_key_to_element_iter,
                                             NULL);
    GNUNET_CONTAINER_multihashmap32_destroy (op->key_to_element);
    op->key_to_element = NULL;
  }
  if (NULL != op->message_control_flow)
  {
    GNUNET_CONTAINER_multihashmap_iterate (op->message_control_flow,
                                           &free_values_iter,
                                           NULL);
    GNUNET_CONTAINER_multihashmap_destroy (op->message_control_flow);
    op->message_control_flow = NULL;
  }
  if (NULL != op->inquiries_sent)
  {
    GNUNET_CONTAINER_multihashmap_destroy (op->inquiries_sent);
    op->inquiries_sent = NULL;
  }
  if (NULL != set)
  {
    GNUNET_CONTAINER_DLL_remove (set->ops_head,
                                 set->ops_tail,
                                 op);
    op->set = NULL;
  }
  if (NULL != op->context_msg)
  {
    GNUNET_free (op->context_msg);
    op->context_msg = NULL;
  }
  if (NULL != (channel = op->channel))
  {
    /* This will free op; called conditionally as this helper function
       is also called from within the channel disconnect handler. */
    op->channel = NULL;
    GNUNET_CADET_channel_destroy (channel);
  }
  /* We rely on the channel end handler to free 'op'. When 'op->channel' was NULL,
   * there was a channel end handler that will free 'op' on the call stack. */
}

References destroy_key_to_element_iter(), free_values_iter(), GNUNET_assert, GNUNET_CADET_channel_destroy(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap32_destroy(), GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, ibf_destroy(), op, Set::ops_head, Set::ops_tail, and strata_estimator_destroy().

Referenced by _GSS_operation_destroy2(), client_disconnect_cb(), fail_union_operation(), and handle_client_cancel().

Here is the call graph for this function:

Here is the caller graph for this function:

_GSS_operation_destroy2()

static void _GSS_operation_destroy2 ( struct Operation *  op )

static

This function probably should not exist and be replaced by inlining more specific logic in the various places where it is called.

Definition at line 1708 of file gnunet-service-setu.c.

{
  struct GNUNET_CADET_Channel *channel;
 
  if (NULL != (channel = op->channel))
  {
    /* This will free op; called conditionally as this helper function
       is also called from within the channel disconnect handler. */
    op->channel = NULL;
    GNUNET_CADET_channel_destroy (channel);
  }
  if (NULL != op->listener)
  {
    incoming_destroy (op);
    return;
  }
  if (NULL != op->set)
    send_client_done (op);
  _GSS_operation_destroy (op);
  GNUNET_free (op);
}

References _GSS_operation_destroy(), GNUNET_CADET_channel_destroy(), GNUNET_free, incoming_destroy(), op, and send_client_done().

Referenced by channel_end_cb(), handle_client_reject(), handle_union_p2p_full_done(), incoming_destroy(), and maybe_finish().

Here is the call graph for this function:

Here is the caller graph for this function:

incoming_destroy()

static void incoming_destroy ( struct Operation *  op )

static

Destroy an incoming request from a remote peer.

Parameters

op	remote request to destroy

Definition at line 1679 of file gnunet-service-setu.c.

{
  struct Listener *listener;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Destroying incoming operation %p\n",
              op);
  if (NULL != (listener = op->listener))
  {
    GNUNET_CONTAINER_DLL_remove (listener->op_head,
                                 listener->op_tail,
                                 op);
    op->listener = NULL;
  }
  if (NULL != op->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (op->timeout_task);
    op->timeout_task = NULL;
  }
  _GSS_operation_destroy2 (op);
}

References _GSS_operation_destroy2(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_cancel(), op, Listener::op_head, and Listener::op_tail.

Referenced by _GSS_operation_destroy2(), client_disconnect_cb(), and incoming_timeout_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

fail_union_operation()

static void fail_union_operation ( struct Operation *  op )

static

Inform the client that the union operation has failed, and proceed to destroy the evaluate operation.

Parameters

op	the union operation to fail

Definition at line 1738 of file gnunet-service-setu.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SETU_ResultMessage *msg;
 
  LOG (GNUNET_ERROR_TYPE_WARNING,
       "union operation failed\n");
  ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_SETU_RESULT);
  msg->result_status = htons (GNUNET_SETU_STATUS_FAILURE);
  msg->request_id = htonl (op->client_request_id);
  msg->element_type = htons (0);
  GNUNET_MQ_send (op->set->cs->mq,
                  ev);
  _GSS_operation_destroy (op);
}

References _GSS_operation_destroy(), GNUNET_ERROR_TYPE_WARNING, GNUNET_MESSAGE_TYPE_SETU_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SETU_STATUS_FAILURE, LOG, msg, and op.

Referenced by check_max_differential_rounds(), decode_and_send(), full_sync_plausibility_check(), handle_union_p2p_demand(), handle_union_p2p_done(), handle_union_p2p_elements(), handle_union_p2p_full_done(), handle_union_p2p_full_element(), handle_union_p2p_ibf(), handle_union_p2p_inquiry(), handle_union_p2p_offer(), handle_union_p2p_request_full(), handle_union_p2p_send_full(), handle_union_p2p_strata_estimator(), and send_offers_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

full_sync_plausibility_check()

static void full_sync_plausibility_check ( struct Operation *  op )

static

Function that checks if full sync is plausible.

Parameters

initial_local_elements_in_set
estimated_set_difference
repeated_elements
fresh_elements
op

Returns

GNUNET_OK if

Definition at line 1766 of file gnunet-service-setu.c.

{
  int security_level_lb = -1 * SECURITY_LEVEL;
  uint64_t duplicates = op->received_fresh - op->received_total;
 
  if (GNUNET_YES != op->byzantine)
    return;
 
  /*
   * Protect full sync from receiving double element when in FULL SENDING
   */
  if (PHASE_FULL_SENDING == op->phase)
  {
    if (duplicates > 0)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "PROTOCOL VIOLATION: Received duplicate element in full receiving "
           "mode of operation this is not allowed! Duplicates: %llu\n",
           (unsigned long long) duplicates);
      GNUNET_break_op (0);
      fail_union_operation (op);
      return;
    }
 
  }
 
  /*
   * Protect full sync with probabilistic algorithm
   */
  if (PHASE_FULL_RECEIVING == op->phase)
  {
 
    long double base = (1 - (long double) (op->remote_set_diff
                                           / (long double) (op->initial_size
                                                            + op->
                                                            remote_set_diff)));
    long double exponent = (op->received_total - (op->received_fresh * ((long
                                                                         double)
                                                                        op->
                                                                        initial_size
                                                                        / (long
                                                                           double)
                                                                        op->
                                                                        remote_set_diff)));
    long double value = exponent * (log2l (base) / log2l (2));
    if (0 == op->remote_set_diff)
      op->remote_set_diff = 1;
    if ((value < security_level_lb) || (value > SECURITY_LEVEL) )
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "PROTOCOL VIOLATION: Other peer violated probabilistic rule for receiving "
           "to many duplicated full element : %LF\n",
           value);
      GNUNET_break_op (0);
      fail_union_operation (op);
      return;
    }
  }
}

References fail_union_operation(), GNUNET_break_op, GNUNET_ERROR_TYPE_ERROR, GNUNET_YES, LOG, op, PHASE_FULL_RECEIVING, PHASE_FULL_SENDING, SECURITY_LEVEL, and value.

Referenced by handle_union_p2p_full_element().

Here is the call graph for this function:

Here is the caller graph for this function:

check_max_differential_rounds()

static void check_max_differential_rounds ( struct Operation *  op )

static

Limit active passive switches in differential sync to configured security level.

Parameters

op

Definition at line 1832 of file gnunet-service-setu.c.

{
  double probability = op->differential_sync_iterations * (log2l (
                                                             PROBABILITY_FOR_NEW_ROUND)
                                                           / log2l (2));
  if ((-1 * SECURITY_LEVEL) > probability)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "PROTOCOL VIOLATION: Other peer violated probabilistic rule for to many active passive "
         "switches in differential sync: %u\n",
         op->differential_sync_iterations);
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
}

References fail_union_operation(), GNUNET_break_op, GNUNET_ERROR_TYPE_ERROR, LOG, op, PROBABILITY_FOR_NEW_ROUND, and SECURITY_LEVEL.

Referenced by handle_union_p2p_ibf().

Here is the call graph for this function:

Here is the caller graph for this function:

get_ibf_key()

static struct IBF_Key get_ibf_key ( const struct GNUNET_HashCode *  src )

static

Derive the IBF key from a hash code and a salt.

Parameters

src	the hash code

Returns

the derived IBF key

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

{
  struct IBF_Key key;
  uint16_t salt = 0;
 
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CRYPTO_kdf (&key, sizeof(key),
                                    src, sizeof *src,
                                    &salt, sizeof(salt),
                                    NULL, 0));
  return key;
}

References GNUNET_assert, GNUNET_CRYPTO_kdf(), GNUNET_OK, key, and salt.

Referenced by handle_client_set_add(), op_get_element(), and op_register_element().

Here is the call graph for this function:

Here is the caller graph for this function:

op_get_element_iterator()

static int op_get_element_iterator ( void *  cls, uint32_t  key, void *  value  )

static

Iterator over the mapping from IBF keys to element entries.

Checks if we have an element with a given GNUNET_HashCode.

Parameters

cls	closure
key	current key code
value	value in the hash map

Returns

GNUNET_YES if we should search further, GNUNET_NO if we've found the element.

Definition at line 1900 of file gnunet-service-setu.c.

{
  struct GetElementContext *ctx = cls;
  struct KeyEntry *k = value;
 
  GNUNET_assert (NULL != k);
  if (0 == GNUNET_CRYPTO_hash_cmp (&k->element->element_hash,
                                   &ctx->hash))
  {
    ctx->k = k;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References ctx, KeyEntry::element, ElementEntry::element_hash, GNUNET_assert, GNUNET_CRYPTO_hash_cmp(), GNUNET_NO, GNUNET_YES, and value.

Referenced by op_get_element().

Here is the call graph for this function:

Here is the caller graph for this function:

op_get_element()

static struct KeyEntry * op_get_element ( struct Operation *  op, const struct GNUNET_HashCode *  element_hash  )

static

Determine whether the given element is already in the operation's element set.

Parameters

op	operation that should be tested for 'element_hash'
element_hash	hash of the element to look for

Returns

GNUNET_YES if the element has been found, GNUNET_NO otherwise

Definition at line 1927 of file gnunet-service-setu.c.

{
  int ret;
  struct IBF_Key ibf_key;
  struct GetElementContext ctx = { { { 0 } }, 0 };
 
  ctx.hash = *element_hash;
 
  ibf_key = get_ibf_key (element_hash);
  ret = GNUNET_CONTAINER_multihashmap32_get_multiple (op->key_to_element,
                                                      (uint32_t) ibf_key.key_val
                                                      ,
                                                      &op_get_element_iterator,
                                                      &ctx);
 
  /* was the iteration aborted because we found the element? */
  if (GNUNET_SYSERR == ret)
  {
    GNUNET_assert (NULL != ctx.k);
    return ctx.k;
  }
  return NULL;
}

References ctx, get_ibf_key(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_get_multiple(), GNUNET_SYSERR, IBF_Key::key_val, op, op_get_element_iterator(), and ret.

Referenced by 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:

op_register_element()

static void op_register_element ( struct Operation *  op, struct ElementEntry *  ee, int  received  )

static

Insert an element into the union operation's key-to-element mapping.

Takes ownership of 'ee'. Note that this does not insert the element in the set, only in the operation's key-element mapping. This is done to speed up re-tried operations, if some elements were transmitted, and then the IBF fails to decode.

XXX: clarify ownership, doesn't sound right.

Parameters

op	the union operation
ee	the element entry
received	was this element received from the remote peer?

Definition at line 1968 of file gnunet-service-setu.c.

{
  struct IBF_Key ibf_key;
  struct KeyEntry *k;
 
  ibf_key = get_ibf_key (&ee->element_hash);
  k = GNUNET_new (struct KeyEntry);
  k->element = ee;
  k->ibf_key = ibf_key;
  k->received = received;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap32_put (op->key_to_element,
                                                      (uint32_t) ibf_key.key_val
                                                      ,
                                                      k,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
}

References KeyEntry::element, ElementEntry::element_hash, get_ibf_key(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_new, GNUNET_OK, KeyEntry::ibf_key, IBF_Key::key_val, op, and KeyEntry::received.

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

Here is the call graph for this function:

Here is the caller graph for this function:

salt_key()

static void salt_key ( const struct IBF_Key *  k_in, uint32_t  salt, struct IBF_Key *  k_out  )

static

Modify an IBF key k_in based on the salt, returning a salted key in k_out.

Definition at line 1994 of file gnunet-service-setu.c.

{
  int s = (salt * 7) % 64;
  uint64_t x = k_in->key_val;
 
  /* rotate ibf key */
  x = (x >> s) | (x << (64 - s));
  k_out->key_val = x;
}

References IBF_Key::key_val, and salt.

Referenced by prepare_ibf_iterator().

Here is the caller graph for this function:

unsalt_key()

static void unsalt_key ( const struct IBF_Key *  k_in, uint32_t  salt, struct IBF_Key *  k_out  )

static

Reverse modification done in the salt_key function.

Definition at line 2011 of file gnunet-service-setu.c.

{
  int s = (salt * 7) % 64;
  uint64_t x = k_in->key_val;
 
  x = (x << s) | (x >> (64 - s));
  k_out->key_val = x;
}

References IBF_Key::key_val, and salt.

Referenced by decode_and_send(), and handle_union_p2p_inquiry().

Here is the caller graph for this function:

prepare_ibf_iterator()

static int prepare_ibf_iterator ( void *  cls, uint32_t  key, void *  value  )

static

Insert a key into an ibf.

Parameters

cls	the ibf
key	unused
value	the key entry to get the key from

Definition at line 2031 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  struct KeyEntry *ke = value;
  struct IBF_Key salted_key;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "[OP %p] inserting %lx (hash %s) into ibf\n",
       op,
       (unsigned long) ke->ibf_key.key_val,
       GNUNET_h2s (&ke->element->element_hash));
  salt_key (&ke->ibf_key,
            op->salt_send,
            &salted_key);
  ibf_insert (op->local_ibf, salted_key);
  return GNUNET_YES;
}

References KeyEntry::element, ElementEntry::element_hash, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_YES, ibf_insert(), KeyEntry::ibf_key, IBF_Key::key_val, LOG, op, salt_key(), and value.

Referenced by prepare_ibf().

Here is the call graph for this function:

Here is the caller graph for this function:

_GSS_is_element_of_operation()

static int _GSS_is_element_of_operation ( struct ElementEntry *  ee, struct Operation *  op  )

static

Is element ee part of the set used by op?

Parameters

ee	element to test
op	operation the defines the set and its generation

Returns

GNUNET_YES if the element is in the set, GNUNET_NO if not

Definition at line 2060 of file gnunet-service-setu.c.

{
  return ee->generation >= op->generation_created;
}

References ElementEntry::generation, and op.

Referenced by handle_union_p2p_demand(), handle_union_p2p_offer(), and init_key_to_element_iterator().

Here is the caller graph for this function:

init_key_to_element_iterator()

static int init_key_to_element_iterator ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Iterator for initializing the key-to-element mapping of a union operation.

Parameters

cls	the union operation struct Operation *
key	unused
value	the struct ElementEntry * to insert into the key-to-element mapping

Returns

GNUNET_YES (to continue iterating)

Definition at line 2078 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  struct ElementEntry *ee = value;
 
  /* make sure that the element belongs to the set at the time
   * of creating the operation */
  if (GNUNET_NO ==
      _GSS_is_element_of_operation (ee,
                                    op))
    return GNUNET_YES;
  GNUNET_assert (GNUNET_NO == ee->remote);
  op_register_element (op,
                       ee,
                       GNUNET_NO);
  return GNUNET_YES;
}

References _GSS_is_element_of_operation(), GNUNET_assert, GNUNET_NO, GNUNET_YES, op, op_register_element(), ElementEntry::remote, and value.

Referenced by initialize_key_to_element().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_key_to_element()

static void initialize_key_to_element ( struct Operation *  op )

static

Initialize the IBF key to element mapping local to this set operation.

Parameters

op	the set union operation

Definition at line 2105 of file gnunet-service-setu.c.

{
  unsigned int len;
 
  GNUNET_assert (NULL == op->key_to_element);
  len = GNUNET_CONTAINER_multihashmap_size (op->set->content->elements);
  op->key_to_element = GNUNET_CONTAINER_multihashmap32_create (len + 1);
  GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
                                         &init_key_to_element_iterator,
                                         op);
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_create(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), init_key_to_element_iterator(), and op.

Referenced by handle_client_accept(), and handle_client_evaluate().

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_ibf()

static int prepare_ibf ( struct Operation *  op, uint32_t  size  )

static

Create an ibf with the operation's elements of the specified size.

Parameters

op	the union operation
size	size of the ibf to create

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 2127 of file gnunet-service-setu.c.

{
  GNUNET_assert (NULL != op->key_to_element);
 
  if (NULL != op->local_ibf)
    ibf_destroy (op->local_ibf);
  // op->local_ibf = ibf_create (size, SE_IBF_HASH_NUM);
  op->local_ibf = ibf_create (size,
                              ((uint8_t) op->ibf_number_buckets_per_element));
  if (NULL == op->local_ibf)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to allocate local IBF\n");
    return GNUNET_SYSERR;
  }
  GNUNET_CONTAINER_multihashmap32_iterate (op->key_to_element,
                                           &prepare_ibf_iterator,
                                           op);
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, ibf_create(), ibf_destroy(), op, prepare_ibf_iterator(), and size.

Referenced by decode_and_send(), and send_ibf().

Here is the call graph for this function:

Here is the caller graph for this function:

send_ibf()

static int send_ibf ( struct Operation *  op, uint32_t  ibf_size  )

static

Send an ibf of appropriate size.

Fragments the IBF into multiple messages if necessary.

Parameters

op	the union operation
ibf_order	order of the ibf to send, size=2^order

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Enforce min size of IBF

Definition at line 2160 of file gnunet-service-setu.c.

{
  uint64_t buckets_sent = 0;
  struct InvertibleBloomFilter *ibf;
 
  uint32_t ibf_min_size = IBF_MIN_SIZE;
 
  op->differential_sync_iterations++;
  if (ibf_size < ibf_min_size)
  {
    ibf_size = ibf_min_size;
  }
  if (GNUNET_OK !=
      prepare_ibf (op, ibf_size))
  {
    /* allocation failed */
    return GNUNET_SYSERR;
  }
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "sending ibf of size %u\n",
       (unsigned int) ibf_size);
 
  {
    char name[64];
 
    GNUNET_snprintf (name,
                     sizeof(name),
                     "# sent IBF (order %u)",
                     ibf_size);
    GNUNET_STATISTICS_update (_GSS_statistics, name, 1, GNUNET_NO);
  }
 
  ibf = op->local_ibf;
 
  while (buckets_sent < ibf_size)
  {
    unsigned int buckets_in_message;
    struct GNUNET_MQ_Envelope *ev;
    struct IBFMessage *msg;
 
    buckets_in_message = ibf_size - buckets_sent;
    /* limit to maximum */
    if (buckets_in_message > MAX_BUCKETS_PER_MESSAGE)
      buckets_in_message = MAX_BUCKETS_PER_MESSAGE;
 
#if MEASURE_PERFORMANCE
    perf_store.ibf.sent += 1;
    perf_store.ibf.sent_var_bytes += (buckets_in_message * IBF_BUCKET_SIZE);
#endif
    ev = GNUNET_MQ_msg_extra (msg,
                              buckets_in_message * IBF_BUCKET_SIZE,
                              GNUNET_MESSAGE_TYPE_SETU_P2P_IBF);
    msg->ibf_size = ibf_size;
    msg->offset = htonl (buckets_sent);
    msg->salt = htonl (op->salt_send);
    msg->ibf_counter_bit_length = ibf_get_max_counter (ibf);
 
 
    ibf_write_slice (ibf, buckets_sent,
                     buckets_in_message, &msg[1], msg->ibf_counter_bit_length);
    buckets_sent += buckets_in_message;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "ibf chunk size %u, %llu/%u sent\n",
         (unsigned int) buckets_in_message,
         (unsigned long long) buckets_sent,
         (unsigned int) ibf_size);
    GNUNET_MQ_send (op->mq, ev);
  }
 
  /* The other peer must decode the IBF, so
   * we're passive. */
  op->phase = PHASE_PASSIVE_DECODING;
  return GNUNET_OK;
}

References _GSS_statistics, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SETU_P2P_IBF, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_snprintf(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, IBF_BUCKET_SIZE, ibf_get_max_counter(), IBF_MIN_SIZE, ibf_size, ibf_write_slice(), LOG, MAX_BUCKETS_PER_MESSAGE, msg, name, op, PHASE_PASSIVE_DECODING, and prepare_ibf().

Referenced by decode_and_send(), and handle_union_p2p_strata_estimator().

Here is the call graph for this function:

Here is the caller graph for this function:

get_size_from_difference()

static unsigned int get_size_from_difference ( unsigned int  diff, int  number_buckets_per_element, float  ibf_bucket_number_factor  )

static

Compute the necessary order of an ibf from the size of the symmetric set difference.

Parameters

diff	the difference

Returns

the required size of the ibf

Make ibf estimation size odd reasoning can be found in BSc Thesis of Elias Summermatter (2021) in section 3.11

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

{
  return (((int) (diff * ibf_bucket_number_factor)) | 1);
 
}

Referenced by handle_union_p2p_strata_estimator().

Here is the caller graph for this function:

get_next_ibf_size()

static unsigned int get_next_ibf_size ( float  ibf_bucket_number_factor, unsigned int  decoded_elements, unsigned int  last_ibf_size  )

static

Make ibf estimation size odd reasoning can be found in BSc Thesis of Elias Summermatter (2021) in section 3.11

Definition at line 2260 of file gnunet-service-setu.c.

{
  unsigned int next_size = (unsigned int) ((last_ibf_size * 2)
                                           - (ibf_bucket_number_factor
                                              * decoded_elements));
  return next_size | 1;
}

References consensus-simulation::int.

Referenced by decode_and_send().

Here is the caller graph for this function:

send_full_element_iterator()

static int send_full_element_iterator ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Send a set element.

Parameters

cls	the union operation struct Operation *
key	unused
value	the struct ElementEntry * to insert into the key-to-element mapping

Returns

GNUNET_YES (to continue iterating)

Definition at line 2282 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  struct GNUNET_SETU_ElementMessage *emsg;
  struct ElementEntry *ee = value;
  struct GNUNET_SETU_Element *el = &ee->element;
  struct GNUNET_MQ_Envelope *ev;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending element %s\n",
       GNUNET_h2s (key));
#if MEASURE_PERFORMANCE
  perf_store.element_full.received += 1;
  perf_store.element_full.received_var_bytes += el->size;
#endif
  ev = GNUNET_MQ_msg_extra (emsg,
                            el->size,
                            GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT);
  emsg->element_type = htons (el->element_type);
  GNUNET_memcpy (&emsg[1],
                 el->data,
                 el->size);
  GNUNET_MQ_send (op->mq,
                  ev);
  return GNUNET_YES;
}

References el, ElementEntry::element, GNUNET_SETU_ElementMessage::element_type, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_YES, key, LOG, op, and value.

Referenced by send_full_set().

Here is the call graph for this function:

Here is the caller graph for this function:

send_full_set()

static void send_full_set ( struct Operation *  op )

static

Switch to full set transmission for op.

Parameters

op	operation to switch to full set transmission.

Definition at line 2318 of file gnunet-service-setu.c.

{
  struct GNUNET_MQ_Envelope *ev;
 
  op->phase = PHASE_FULL_SENDING;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Dedicing to transmit the full set\n");
  /* FIXME: use a more memory-friendly way of doing this with an
     iterator, just as we do in the non-full case! */
 
  // Randomize Elements to send
  op->set->content->elements_randomized = GNUNET_CONTAINER_multihashmap_create (
    32,GNUNET_NO);
  op->set->content->elements_randomized_salt = GNUNET_CRYPTO_random_u64 (
    GNUNET_CRYPTO_QUALITY_NONCE,
    UINT64_MAX);
  (void) GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
                                                &
                                                create_randomized_element_iterator,
                                                op);
 
  (void) GNUNET_CONTAINER_multihashmap_iterate (
    op->set->content->elements_randomized,
    &send_full_element_iterator,
    op);
#if MEASURE_PERFORMANCE
  perf_store.full_done.sent += 1;
#endif
  ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE);
  GNUNET_MQ_send (op->mq,
                  ev);
}

References create_randomized_element_iterator(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u64(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE, GNUNET_MQ_msg_header, GNUNET_MQ_send(), GNUNET_NO, LOG, op, PHASE_FULL_SENDING, and send_full_element_iterator().

Referenced by handle_union_p2p_request_full(), and handle_union_p2p_strata_estimator().

Here is the call graph for this function:

Here is the caller graph for this function:

check_union_p2p_strata_estimator()

static int check_union_p2p_strata_estimator ( void *  cls, const struct StrataEstimatorMessage *  msg  )

static

Handle a strata estimator from a remote peer.

Parameters

cls	the union operation
msg	the message

Definition at line 2359 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  int is_compressed;
  size_t len;
 
  if (op->phase != PHASE_EXPECT_SE)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  is_compressed = (GNUNET_MESSAGE_TYPE_SETU_P2P_SEC == htons (
                     msg->header.type));
  len = ntohs (msg->header.size) - sizeof(struct StrataEstimatorMessage);
  if ((GNUNET_NO == is_compressed) &&
      (len != SE_STRATA_COUNT * SE_IBFS_TOTAL_SIZE * IBF_BUCKET_SIZE))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_MESSAGE_TYPE_SETU_P2P_SEC, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, IBF_BUCKET_SIZE, msg, op, PHASE_EXPECT_SE, SE_IBFS_TOTAL_SIZE, SE_STRATA_COUNT, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

handle_union_p2p_strata_estimator()

static void handle_union_p2p_strata_estimator ( void *  cls, const struct StrataEstimatorMessage *  msg  )

static

Handle a strata estimator from a remote peer.

Parameters

cls	the union operation
msg	the message

Check that the message is received only in supported phase

Only allow 1,2,4,8 SEs

Calculate avg element size if not initial sync

Definition at line 2391 of file gnunet-service-setu.c.

{
#if MEASURE_PERFORMANCE
  perf_store.se.received += 1;
  perf_store.se.received_var_bytes += ntohs (msg->header.size) - sizeof(struct
                                                                        StrataEstimatorMessage);
#endif
  struct Operation *op = cls;
  struct MultiStrataEstimator *remote_se;
  unsigned int diff;
  uint64_t other_size;
  size_t len;
  int is_compressed;
  uint8_t allowed_phases[] = {PHASE_EXPECT_SE};
  op->local_element_count = GNUNET_CONTAINER_multihashmap_size (
    op->set->content->elements);
  // Setting peer site to receiving peer
  op->peer_site = 1;
 
  if (GNUNET_OK !=
      check_valid_phase (allowed_phases,sizeof(allowed_phases),op))
  {
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
 
  if ((msg->se_count > 8) || (__builtin_popcount ((int) msg->se_count) != 1))
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "PROTOCOL VIOLATION: Invalid number of se transmitted by other peer %u\n",
         msg->se_count);
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
 
  is_compressed = (GNUNET_MESSAGE_TYPE_SETU_P2P_SEC == htons (
                     msg->header.type));
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# bytes of SE received",
                            ntohs (msg->header.size),
                            GNUNET_NO);
  len = ntohs (msg->header.size) - sizeof(struct StrataEstimatorMessage);
  other_size = GNUNET_ntohll (msg->set_size);
  op->remote_element_count = other_size;
 
  if (op->byzantine_upper_bound < op->remote_element_count)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Exceeded configured upper bound <%" PRIu64 "> of element: %u\n",
         op->byzantine_upper_bound,
         op->remote_element_count);
    fail_union_operation (op);
    return;
  }
 
  remote_se = strata_estimator_create (SE_STRATA_COUNT,
                                       SE_IBFS_TOTAL_SIZE,
                                       SE_IBF_HASH_NUM);
  if (NULL == remote_se)
  {
    /* insufficient resources, fail */
    fail_union_operation (op);
    return;
  }
  if (GNUNET_OK !=
      strata_estimator_read (&msg[1],
                             len,
                             is_compressed,
                             msg->se_count,
                             SE_IBFS_TOTAL_SIZE,
                             remote_se))
  {
    /* decompression failed */
    strata_estimator_destroy (remote_se);
    fail_union_operation (op);
    return;
  }
  GNUNET_assert (NULL != op->se);
  strata_estimator_difference (remote_se,
                               op->se);
  {
    /* Calculate remote local diff */
    long diff_remote = remote_se->stratas[0]->strata[0]->remote_decoded_count;
    long diff_local = remote_se->stratas[0]->strata[0]->local_decoded_count;
    uint64_t avg_element_size = 0;
 
    /* Prevent estimations from overshooting max element */
    if (diff_remote + op->remote_element_count > op->byzantine_upper_bound)
      diff_remote = op->byzantine_upper_bound - op->remote_element_count;
    if (diff_local + op->local_element_count > op->byzantine_upper_bound)
      diff_local = op->byzantine_upper_bound - op->local_element_count;
    if ((diff_remote < 0) || (diff_local < 0))
    {
      strata_estimator_destroy (remote_se);
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "PROTOCOL VIOLATION: More element is set as upper boundary or other peer is "
           "malicious: remote diff %ld, local diff: %ld\n",
           diff_remote, diff_local);
      GNUNET_break_op (0);
      fail_union_operation (op);
      return;
    }
    /* Make estimation more precise in initial sync cases */
    if (0 == op->remote_element_count)
    {
      diff_remote = 0;
      diff_local = op->local_element_count;
    }
    if (0 == op->local_element_count)
    {
      diff_local = 0;
      diff_remote = op->remote_element_count;
    }
 
    diff = diff_remote + diff_local;
    op->remote_set_diff = diff_remote;
 
    if (0 < op->local_element_count)
    {
      op->total_elements_size_local = 0;
      GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
                                             &
                                             determinate_avg_element_size_iterator,
                                             op);
      avg_element_size = op->total_elements_size_local / op->local_element_count
      ;
    }
 
    op->mode_of_operation = estimate_best_mode_of_operation (avg_element_size,
                                                             GNUNET_CONTAINER_multihashmap_size
                                                             (
                                                               op->set->content
                                                               ->
                                                               elements),
                                                             op->
                                                             remote_element_count,
                                                             diff_remote,
                                                             diff_local,
                                                             op->
                                                             rtt_bandwidth_tradeoff,
                                                             op->
                                                             ibf_bucket_number_factor);
 
#if MEASURE_PERFORMANCE
    perf_store.se_diff_local = diff_local;
    perf_store.se_diff_remote = diff_remote;
    perf_store.se_diff = diff;
    perf_store.mode_of_operation = op->mode_of_operation;
#endif
 
    strata_estimator_destroy (remote_se);
    strata_estimator_destroy (op->se);
    op->se = NULL;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "got se diff=%d, using ibf size %d\n",
         diff,
         1U << get_size_from_difference (diff, op->
                                         ibf_number_buckets_per_element,
                                         op->ibf_bucket_number_factor));
 
    {
      char *set_debug;
 
      set_debug = getenv ("GNUNET_SETU_BENCHMARK");
      if ((NULL != set_debug) &&
          (0 == strcmp (set_debug, "1")))
      {
        FILE *f = fopen ("set.log", "a");
        fprintf (f, "%llu\n", (unsigned long long) diff);
        fclose (f);
      }
    }
 
    if ((GNUNET_YES == op->byzantine) &&
        (other_size < op->byzantine_lower_bound))
    {
      GNUNET_break (0);
      fail_union_operation (op);
      return;
    }
 
    if ((GNUNET_YES == op->force_full) ||
        (op->mode_of_operation != DIFFERENTIAL_SYNC))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Deciding to go for full set transmission (diff=%d, own set=%llu)\n",
           diff,
           (unsigned long long) op->initial_size);
      GNUNET_STATISTICS_update (_GSS_statistics,
                                "# of full sends",
                                1,
                                GNUNET_NO);
      if (FULL_SYNC_LOCAL_SENDING_FIRST == op->mode_of_operation)
      {
        struct TransmitFullMessage *signal_msg;
        struct GNUNET_MQ_Envelope *ev;
        ev = GNUNET_MQ_msg_extra (signal_msg,sizeof(struct TransmitFullMessage),
                                  GNUNET_MESSAGE_TYPE_SETU_P2P_SEND_FULL);
        signal_msg->remote_set_difference = htonl (diff_local);
        signal_msg->remote_set_size = htonl (op->local_element_count);
        signal_msg->local_set_difference = htonl (diff_remote);
        GNUNET_MQ_send (op->mq,
                        ev);
        send_full_set (op);
      }
      else
      {
        struct GNUNET_MQ_Envelope *ev;
 
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "Telling other peer that we expect its full set\n");
        op->phase = PHASE_FULL_RECEIVING;
#if MEASURE_PERFORMANCE
        perf_store.request_full.sent += 1;
#endif
        {
          struct TransmitFullMessage *signal_msg;
          ev = GNUNET_MQ_msg_extra (signal_msg,sizeof(struct
                                                      TransmitFullMessage),
                                    GNUNET_MESSAGE_TYPE_SETU_P2P_REQUEST_FULL);
          signal_msg->remote_set_difference = htonl (diff_local);
          signal_msg->remote_set_size = htonl (op->local_element_count);
          signal_msg->local_set_difference = htonl (diff_remote);
          GNUNET_MQ_send (op->mq,
                          ev);
        }
      }
    }
    else
    {
      GNUNET_STATISTICS_update (_GSS_statistics,
                                "# of ibf sends",
                                1,
                                GNUNET_NO);
      if (GNUNET_OK !=
          send_ibf (op,
                    get_size_from_difference (diff,
                                              op->ibf_number_buckets_per_element
                                              ,
                                              op->ibf_bucket_number_factor)))
      {
        /* Internal error, best we can do is shut the connection */
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Failed to send IBF, closing connection\n");
        fail_union_operation (op);
        return;
      }
    }
    GNUNET_CADET_receive_done (op->channel);
  }
}

References _GSS_statistics, check_valid_phase(), determinate_avg_element_size_iterator(), DIFFERENTIAL_SYNC, estimate_best_mode_of_operation(), removetrailingwhitespace::f, fail_union_operation(), FULL_SYNC_LOCAL_SENDING_FIRST, get_size_from_difference(), getenv(), GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSAGE_TYPE_SETU_P2P_REQUEST_FULL, GNUNET_MESSAGE_TYPE_SETU_P2P_SEC, GNUNET_MESSAGE_TYPE_SETU_P2P_SEND_FULL, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_YES, InvertibleBloomFilter::local_decoded_count, TransmitFullMessage::local_set_difference, LOG, msg, op, PHASE_EXPECT_SE, PHASE_FULL_RECEIVING, InvertibleBloomFilter::remote_decoded_count, TransmitFullMessage::remote_set_difference, TransmitFullMessage::remote_set_size, SE_IBF_HASH_NUM, SE_IBFS_TOTAL_SIZE, SE_STRATA_COUNT, send_full_set(), send_ibf(), GNUNET_MessageHeader::size, StrataEstimator::strata, strata_estimator_create(), strata_estimator_destroy(), strata_estimator_difference(), strata_estimator_read(), MultiStrataEstimator::stratas, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

send_offers_iterator()

static int send_offers_iterator ( void *  cls, uint32_t  key, void *  value  )

static

Iterator to send elements to a remote peer.

Parameters

cls	closure with the element key and the union operation
key	ignored
value	the key entry

Definition at line 2660 of file gnunet-service-setu.c.

{
  struct SendElementClosure *sec = cls;
  struct Operation *op = sec->op;
  struct KeyEntry *ke = value;
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_MessageHeader *mh;
 
  /* Detect 32-bit key collision for the 64-bit IBF keys. */
  if (ke->ibf_key.key_val != sec->ibf_key.key_val)
  {
    op->active_passive_switch_required = true;
    return GNUNET_YES;
  }
 
  /* Prevent implementation from sending a offer multiple times in case of roll switch */
  if (GNUNET_YES ==
      is_message_in_message_control_flow (
        op->message_control_flow,
        &ke->element->element_hash,
        OFFER_MESSAGE)
      )
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Skipping already sent processed element offer!\n");
    return GNUNET_YES;
  }
 
  /* Save send offer message for message control */
  if (GNUNET_YES !=
      update_message_control_flow (
        op->message_control_flow,
        MSG_CFS_SENT,
        &ke->element->element_hash,
        OFFER_MESSAGE)
      )
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Double offer message sent found!\n");
    GNUNET_break (0);
    fail_union_operation (op);
    return GNUNET_NO;
  }
  ;
 
  /* Mark element to be expected to received */
  if (GNUNET_YES !=
      update_message_control_flow (
        op->message_control_flow,
        MSG_CFS_EXPECTED,
        &ke->element->element_hash,
        DEMAND_MESSAGE)
      )
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Double demand received found!\n");
    GNUNET_break (0);
    fail_union_operation (op);
    return GNUNET_NO;
  }
  ;
#if MEASURE_PERFORMANCE
  perf_store.offer.sent += 1;
  perf_store.offer.sent_var_bytes += sizeof(struct GNUNET_HashCode);
#endif
  ev = GNUNET_MQ_msg_header_extra (mh,
                                   sizeof(struct GNUNET_HashCode),
                                   GNUNET_MESSAGE_TYPE_SETU_P2P_OFFER);
  GNUNET_assert (NULL != ev);
  *(struct GNUNET_HashCode *) &mh[1] = ke->element->element_hash;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "[OP %p] sending element offer (%s) to peer\n",
       op,
       GNUNET_h2s (&ke->element->element_hash));
  GNUNET_MQ_send (op->mq, ev);
  return GNUNET_YES;
}

References DEMAND_MESSAGE, KeyEntry::element, ElementEntry::element_hash, fail_union_operation(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_MESSAGE_TYPE_SETU_P2P_OFFER, GNUNET_MQ_msg_header_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_YES, KeyEntry::ibf_key, SendElementClosure::ibf_key, is_message_in_message_control_flow(), IBF_Key::key_val, LOG, mh, MSG_CFS_EXPECTED, MSG_CFS_SENT, OFFER_MESSAGE, op, SendElementClosure::op, update_message_control_flow(), and value.

Referenced by send_offers_for_key().

Here is the call graph for this function:

Here is the caller graph for this function:

send_offers_for_key()

static void send_offers_for_key ( struct Operation *  op, struct IBF_Key  ibf_key  )

static

Send offers (in the form of GNUNET_Hash-es) to the remote peer for the given IBF key.

Parameters

op	union operation
ibf_key	IBF key of interest

Definition at line 2748 of file gnunet-service-setu.c.

{
  struct SendElementClosure send_cls;
 
  send_cls.ibf_key = ibf_key;
  send_cls.op = op;
  (void) GNUNET_CONTAINER_multihashmap32_get_multiple (
    op->key_to_element,
    (uint32_t) ibf_key.
    key_val,
    &send_offers_iterator,
    &send_cls);
}

References GNUNET_CONTAINER_multihashmap32_get_multiple(), SendElementClosure::ibf_key, op, SendElementClosure::op, and send_offers_iterator().

Referenced by decode_and_send(), and handle_union_p2p_inquiry().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_and_send()

static int decode_and_send ( struct Operation *  op )

static

Decode which elements are missing on each side, and send the appropriate offers and inquiries.

Parameters

op	union operation

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Enforce odd ibf size

Make ibf estimation size odd reasoning can be found in BSc Thesis of Elias Summermatter (2021) in section 3.11

Add sent inquiries to hashmap for flow control

Definition at line 2772 of file gnunet-service-setu.c.

{
  struct IBF_Key key;
  struct IBF_Key last_key;
  int side;
  unsigned int num_decoded;
  struct InvertibleBloomFilter *diff_ibf;
 
  GNUNET_assert (PHASE_ACTIVE_DECODING == op->phase);
 
  if (GNUNET_OK !=
      prepare_ibf (op,
                   op->remote_ibf->size))
  {
    GNUNET_break (0);
    /* allocation failed */
    return GNUNET_SYSERR;
  }
 
  diff_ibf = ibf_dup (op->local_ibf);
  ibf_subtract (diff_ibf,
                op->remote_ibf);
 
  ibf_destroy (op->remote_ibf);
  op->remote_ibf = NULL;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "decoding IBF (size=%u)\n",
       diff_ibf->size);
 
  num_decoded = 0;
  key.key_val = 0;   /* just to avoid compiler thinking we use undef'ed variable */
 
  while (1)
  {
    int res;
    int cycle_detected = GNUNET_NO;
 
    last_key = key;
 
    res = ibf_decode (diff_ibf,
                      &side,
                      &key);
    if (res == GNUNET_OK)
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "decoded ibf key %lx\n",
           (unsigned long) key.key_val);
      num_decoded += 1;
      if ((num_decoded > diff_ibf->size) ||
          ((num_decoded > 1) &&
           (last_key.key_val == key.key_val)))
      {
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "detected cyclic ibf (decoded %u/%u)\n",
             num_decoded,
             diff_ibf->size);
        cycle_detected = GNUNET_YES;
      }
    }
    if ((GNUNET_SYSERR == res) ||
        (GNUNET_YES == cycle_detected))
    {
      uint32_t next_size;
      next_size = get_next_ibf_size (op->ibf_bucket_number_factor, num_decoded,
                                     diff_ibf->size);
      {
        uint32_t ibf_min_size = IBF_MIN_SIZE | 1;
 
        if (next_size<ibf_min_size)
          next_size = ibf_min_size;
      }
 
      if (next_size <= MAX_IBF_SIZE)
      {
        LOG (GNUNET_ERROR_TYPE_DEBUG,
             "decoding failed, sending larger ibf (size %u)\n",
             next_size);
        GNUNET_STATISTICS_update (_GSS_statistics,
                                  "# of IBF retries",
                                  1,
                                  GNUNET_NO);
#if MEASURE_PERFORMANCE
        perf_store.active_passive_switches += 1;
#endif
 
        op->salt_send = op->salt_receive++;
 
        if (GNUNET_OK !=
            send_ibf (op, next_size))
        {
          /* Internal error, best we can do is shut the connection */
          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                      "Failed to send IBF, closing connection\n");
          fail_union_operation (op);
          ibf_destroy (diff_ibf);
          return GNUNET_SYSERR;
        }
      }
      else
      {
        GNUNET_STATISTICS_update (_GSS_statistics,
                                  "# of failed union operations (too large)",
                                  1,
                                  GNUNET_NO);
        // XXX: Send the whole set, element-by-element
        LOG (GNUNET_ERROR_TYPE_ERROR,
             "set union failed: reached ibf limit\n");
        fail_union_operation (op);
        ibf_destroy (diff_ibf);
        return GNUNET_SYSERR;
      }
      break;
    }
    if (GNUNET_NO == res)
    {
      struct GNUNET_MQ_Envelope *ev;
 
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "transmitted all values, sending DONE\n");
 
#if MEASURE_PERFORMANCE
      perf_store.done.sent += 1;
#endif
      ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SETU_P2P_DONE);
      GNUNET_MQ_send (op->mq, ev);
      /* We now wait until we get a DONE message back
       * and then wait for our MQ to be flushed and all our
       * demands be delivered. */
      break;
    }
    if (1 == side)
    {
      struct IBF_Key unsalted_key;
      unsalt_key (&key,
                  op->salt_receive,
                  &unsalted_key);
      send_offers_for_key (op,
                           unsalted_key);
    }
    else if (-1 == side)
    {
      struct GNUNET_MQ_Envelope *ev;
      struct InquiryMessage *msg;
 
#if MEASURE_PERFORMANCE
      perf_store.inquery.sent += 1;
      perf_store.inquery.sent_var_bytes += sizeof(struct IBF_Key);
#endif
 
      struct GNUNET_HashContext *hashed_key_context =
        GNUNET_CRYPTO_hash_context_start ();
      struct GNUNET_HashCode *hashed_key = (struct
                                            GNUNET_HashCode*) GNUNET_malloc (
        sizeof(struct GNUNET_HashCode));
      enum MESSAGE_CONTROL_FLOW_STATE mcfs = MSG_CFS_SENT;
      GNUNET_CRYPTO_hash_context_read (hashed_key_context,
                                       &key,
                                       sizeof(struct IBF_Key));
      GNUNET_CRYPTO_hash_context_finish (hashed_key_context,
                                         hashed_key);
      GNUNET_CONTAINER_multihashmap_put (op->inquiries_sent,
                                         hashed_key,
                                         &mcfs,
                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE
                                         );
 
      /* It may be nice to merge multiple requests, but with CADET's corking it is not worth
       * the effort additional complexity. */
      ev = GNUNET_MQ_msg_extra (msg,
                                sizeof(struct IBF_Key),
                                GNUNET_MESSAGE_TYPE_SETU_P2P_INQUIRY);
      msg->salt = htonl (op->salt_receive);
      GNUNET_memcpy (&msg[1],
                     &key,
                     sizeof(struct IBF_Key));
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "sending element inquiry for IBF key %lx\n",
           (unsigned long) key.key_val);
      GNUNET_MQ_send (op->mq, ev);
    }
    else
    {
      GNUNET_assert (0);
    }
  }
  ibf_destroy (diff_ibf);
  return GNUNET_OK;
}

References _GSS_statistics, fail_union_operation(), get_next_ibf_size(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE, GNUNET_CRYPTO_hash_context_finish(), GNUNET_CRYPTO_hash_context_read(), GNUNET_CRYPTO_hash_context_start(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SETU_P2P_DONE, GNUNET_MESSAGE_TYPE_SETU_P2P_INQUIRY, GNUNET_MQ_msg_extra, GNUNET_MQ_msg_header, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_YES, ibf_decode(), ibf_destroy(), ibf_dup(), IBF_MIN_SIZE, ibf_subtract(), key, IBF_Key::key_val, LOG, MAX_IBF_SIZE, msg, MSG_CFS_SENT, op, PHASE_ACTIVE_DECODING, prepare_ibf(), res, send_ibf(), send_offers_for_key(), InvertibleBloomFilter::size, and unsalt_key().

Referenced by handle_union_p2p_ibf().

Here is the call graph for this function:

Here is the caller graph for this function:

check_union_p2p_send_full()

static int check_union_p2p_send_full ( void *  cls, const struct TransmitFullMessage *  msg  )

static

Check send full message received from other peer.

Parameters

cls
msg

Returns

Definition at line 2976 of file gnunet-service-setu.c.

{
  return GNUNET_OK;
}

References GNUNET_OK.

handle_union_p2p_send_full()

static void handle_union_p2p_send_full ( void *  cls, const struct TransmitFullMessage *  msg  )

static

Handle send full message received from other peer.

Parameters

cls
msg

Check that the message is received only in supported phase

write received values to operator

Check byzantine limits

Calculate avg element size if not initial sync

Validate mode of operation

Definition at line 2990 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
 
  uint8_t allowed_phases[] = {PHASE_EXPECT_IBF};
  if (GNUNET_OK !=
      check_valid_phase (allowed_phases,sizeof(allowed_phases),op))
  {
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
 
  op->remote_element_count = ntohl (msg->remote_set_size);
  op->remote_set_diff = ntohl (msg->remote_set_difference);
  op->local_set_diff = ntohl (msg->local_set_difference);
 
  if (check_byzantine_bounds (op) != GNUNET_OK)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "PROTOCOL VIOLATION: Parameters transmitted from other peer do not satisfie byzantine "
         "criteria\n");
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
 
  op->local_element_count = GNUNET_CONTAINER_multihashmap_size (
    op->set->content->elements);
  {
    uint64_t avg_element_size = 0;
    int mode_of_operation;
    if (0 < op->local_element_count)
    {
      op->total_elements_size_local = 0;
      GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
                                             &
                                             determinate_avg_element_size_iterator,
                                             op);
      avg_element_size = op->total_elements_size_local / op->local_element_count
      ;
    }
 
    mode_of_operation = estimate_best_mode_of_operation (avg_element_size,
                                                         op->
                                                         remote_element_count,
                                                         op->
                                                         local_element_count,
                                                         op->local_set_diff,
                                                         op->remote_set_diff
                                                         ,
                                                         op->
                                                         rtt_bandwidth_tradeoff,
                                                         op->
                                                         ibf_bucket_number_factor);
    if (FULL_SYNC_LOCAL_SENDING_FIRST != mode_of_operation)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "PROTOCOL VIOLATION: Remote peer choose to send his full set first but correct mode would have been"
           " : %d\n", mode_of_operation);
      GNUNET_break_op (0);
      fail_union_operation (op);
      return;
    }
    op->phase = PHASE_FULL_RECEIVING;
  }
}

References check_byzantine_bounds(), check_valid_phase(), determinate_avg_element_size_iterator(), estimate_best_mode_of_operation(), fail_union_operation(), FULL_SYNC_LOCAL_SENDING_FIRST, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, Operation::ibf_bucket_number_factor, Operation::local_element_count, LOG, Operation::mode_of_operation, msg, op, PHASE_EXPECT_IBF, PHASE_FULL_RECEIVING, Operation::remote_element_count, and Operation::rtt_bandwidth_tradeoff.

Here is the call graph for this function:

check_union_p2p_ibf()

static int check_union_p2p_ibf ( void *  cls, const struct IBFMessage *  msg  )

static

Check an IBF message from a remote peer.

Reassemble the IBF from multiple pieces, and process the whole IBF once possible.

Parameters

cls	the union operation
msg	the header of the message

Returns

GNUNET_OK if msg is well-formed

Definition at line 3078 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  unsigned int buckets_in_message;
 
  buckets_in_message = (ntohs (msg->header.size) - sizeof *msg)
                       / IBF_BUCKET_SIZE;
  if (0 == buckets_in_message)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if ((ntohs (msg->header.size) - sizeof *msg) != buckets_in_message
      * IBF_BUCKET_SIZE)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (op->phase == PHASE_EXPECT_IBF_LAST)
  {
    if (ntohl (msg->offset) != op->ibf_buckets_received)
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
 
    if (msg->ibf_size != op->remote_ibf->size)
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    if (ntohl (msg->salt) != op->salt_receive)
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
  }
  else if ((op->phase != PHASE_PASSIVE_DECODING) &&
           (op->phase != PHASE_EXPECT_IBF))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
 
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, IBF_BUCKET_SIZE, msg, op, PHASE_EXPECT_IBF, PHASE_EXPECT_IBF_LAST, PHASE_PASSIVE_DECODING, and GNUNET_MessageHeader::size.

handle_union_p2p_ibf()

static void handle_union_p2p_ibf ( void *  cls, const struct IBFMessage *  msg  )

static

Handle an IBF message from a remote peer.

Reassemble the IBF from multiple pieces, and process the whole IBF once possible.

Parameters

cls	the union operation
msg	the header of the message

Check that the message is received only in supported phase

Definition at line 3137 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  unsigned int buckets_in_message;
  uint8_t allowed_phases[] = {PHASE_EXPECT_IBF, PHASE_EXPECT_IBF_LAST,
                              PHASE_PASSIVE_DECODING};
  if (GNUNET_OK !=
      check_valid_phase (allowed_phases,sizeof(allowed_phases),op))
  {
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
  op->differential_sync_iterations++;
  check_max_differential_rounds (op);
  op->active_passive_switch_required = false;
 
#if MEASURE_PERFORMANCE
  perf_store.ibf.received += 1;
  perf_store.ibf.received_var_bytes += (ntohs (msg->header.size) - sizeof *msg);
#endif
 
  buckets_in_message = (ntohs (msg->header.size) - sizeof *msg)
                       / IBF_BUCKET_SIZE;
  if ((op->phase == PHASE_PASSIVE_DECODING) ||
      (op->phase == PHASE_EXPECT_IBF))
  {
    op->phase = PHASE_EXPECT_IBF_LAST;
    GNUNET_assert (NULL == op->remote_ibf);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Creating new ibf of size %u\n",
         ntohl (msg->ibf_size));
    // op->remote_ibf = ibf_create (1 << msg->order, SE_IBF_HASH_NUM);
    op->remote_ibf = ibf_create (msg->ibf_size,
                                 ((uint8_t) op->ibf_number_buckets_per_element))
    ;
    op->salt_receive = ntohl (msg->salt);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Receiving new IBF with salt %u\n",
         op->salt_receive);
    if (NULL == op->remote_ibf)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to parse remote IBF, closing connection\n");
      fail_union_operation (op);
      return;
    }
    op->ibf_buckets_received = 0;
    if (0 != ntohl (msg->offset))
    {
      GNUNET_break_op (0);
      fail_union_operation (op);
      return;
    }
  }
  else
  {
    GNUNET_assert (op->phase == PHASE_EXPECT_IBF_LAST);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received more of IBF\n");
  }
  GNUNET_assert (NULL != op->remote_ibf);
 
  ibf_read_slice (&msg[1],
                  op->ibf_buckets_received,
                  buckets_in_message,
                  op->remote_ibf, msg->ibf_counter_bit_length);
  op->ibf_buckets_received += buckets_in_message;
 
  if (op->ibf_buckets_received == op->remote_ibf->size)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "received full ibf\n");
    op->phase = PHASE_ACTIVE_DECODING;
    if (GNUNET_OK !=
        decode_and_send (op))
    {
      /* Internal error, best we can do is shut down */
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to decode IBF, closing connection\n");
      fail_union_operation (op);
      return;
    }
  }
  GNUNET_CADET_receive_done (op->channel);
}

References check_max_differential_rounds(), check_valid_phase(), decode_and_send(), fail_union_operation(), GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, IBF_BUCKET_SIZE, ibf_create(), ibf_read_slice(), LOG, msg, op, PHASE_ACTIVE_DECODING, PHASE_EXPECT_IBF, PHASE_EXPECT_IBF_LAST, PHASE_PASSIVE_DECODING, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

send_client_element()

static void send_client_element ( struct Operation *  op, const struct GNUNET_SETU_Element *  element, enum GNUNET_SETU_Status  status  )

static

Send a result message to the client indicating that there is a new element.

Parameters

op	union operation
element	element to send
status	status to send with the new element

Definition at line 3238 of file gnunet-service-setu.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SETU_ResultMessage *rm;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "sending element (size %u) to client\n",
       element->size);
  GNUNET_assert (0 != op->client_request_id);
  ev = GNUNET_MQ_msg_extra (rm,
                            element->size,
                            GNUNET_MESSAGE_TYPE_SETU_RESULT);
  if (NULL == ev)
  {
    GNUNET_MQ_discard (ev);
    GNUNET_break (0);
    return;
  }
  rm->result_status = htons (status);
  rm->request_id = htonl (op->client_request_id);
  rm->element_type = htons (element->element_type);
  rm->current_size = GNUNET_htonll (GNUNET_CONTAINER_multihashmap32_size (
                                      op->key_to_element));
  GNUNET_memcpy (&rm[1],
                 element->data,
                 element->size);
  GNUNET_MQ_send (op->set->cs->mq,
                  ev);
}

References GNUNET_SETU_ResultMessage::current_size, GNUNET_SETU_Element::data, GNUNET_SETU_Element::element_type, GNUNET_SETU_ResultMessage::element_type, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap32_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_htonll(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SETU_RESULT, GNUNET_MQ_discard(), GNUNET_MQ_msg_extra, GNUNET_MQ_send(), LOG, op, GNUNET_SETU_ResultMessage::request_id, GNUNET_SETU_ResultMessage::result_status, GNUNET_SETU_Element::size, and status.

Referenced by handle_union_p2p_demand(), 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:

maybe_finish()

static void maybe_finish ( struct Operation *  op )

static

Tests if the operation is finished, and if so notify.

Parameters

op	operation to check

Definition at line 3277 of file gnunet-service-setu.c.

{
  unsigned int num_demanded;
  int send_done  =  GNUNET_CONTAINER_multihashmap_iterate (
    op->message_control_flow,
    &
    determinate_done_message_iterator,
    op);
  num_demanded = GNUNET_CONTAINER_multihashmap_size (
    op->demanded_hashes);
  if (PHASE_FINISH_WAITING == op->phase)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "In PHASE_FINISH_WAITING, pending %u demands -> %d\n",
         num_demanded, op->peer_site);
    if (-1 != send_done)
    {
      struct GNUNET_MQ_Envelope *ev;
 
      op->phase = PHASE_FINISHED;
#if MEASURE_PERFORMANCE
      perf_store.done.sent += 1;
#endif
      ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SETU_P2P_DONE);
      GNUNET_MQ_send (op->mq,
                      ev);
      /* We now wait until the other peer sends P2P_OVER
       * after it got all elements from us. */
    }
  }
  if (PHASE_FINISH_CLOSING == op->phase)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "In PHASE_FINISH_CLOSING, pending %u demands %d\n",
         num_demanded, op->peer_site);
    if (-1 != send_done)
    {
      op->phase = PHASE_FINISHED;
      send_client_done (op);
      _GSS_operation_destroy2 (op);
    }
  }
}

References _GSS_operation_destroy2(), determinate_done_message_iterator(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SETU_P2P_DONE, GNUNET_MQ_msg_header, GNUNET_MQ_send(), LOG, op, PHASE_FINISH_CLOSING, PHASE_FINISH_WAITING, PHASE_FINISHED, and send_client_done().

Referenced by handle_union_p2p_demand(), handle_union_p2p_done(), and handle_union_p2p_elements().

Here is the call graph for this function:

Here is the caller graph for this function:

check_union_p2p_elements()

static int check_union_p2p_elements ( void *  cls, const struct GNUNET_SETU_ElementMessage *  emsg  )

static

Check an element message from a remote peer.

Parameters

cls	the union operation
emsg	the message

Definition at line 3329 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
 
  if (0 == GNUNET_CONTAINER_multihashmap_size (op->demanded_hashes))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_CONTAINER_multihashmap_size(), GNUNET_OK, GNUNET_SYSERR, and op.

Here is the call graph for this function:

handle_union_p2p_elements()

static void handle_union_p2p_elements ( void *  cls, const struct GNUNET_SETU_ElementMessage *  emsg  )

static

Handle an element message from a remote peer.

Sent by the other peer either because we decoded an IBF and placed a demand, or because the other peer switched to full set transmission.

Parameters

cls	the union operation
emsg	the message

Check that the message is received only in supported phase

Definition at line 3352 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  struct ElementEntry *ee;
  struct KeyEntry *ke;
  uint16_t element_size;
 
  uint8_t allowed_phases[] = {PHASE_ACTIVE_DECODING, PHASE_PASSIVE_DECODING,
                              PHASE_FINISH_WAITING, PHASE_FINISH_CLOSING};
  if (GNUNET_OK !=
      check_valid_phase (allowed_phases,sizeof(allowed_phases),op))
  {
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
 
  element_size = ntohs (emsg->header.size) - sizeof(struct
                                                    GNUNET_SETU_ElementMessage);
#if MEASURE_PERFORMANCE
  perf_store.element.received += 1;
  perf_store.element.received_var_bytes += element_size;
#endif
 
  ee = GNUNET_malloc (sizeof(struct ElementEntry) + element_size);
  GNUNET_memcpy (&ee[1],
                 &emsg[1],
                 element_size);
  ee->element.size = element_size;
  ee->element.data = &ee[1];
  ee->element.element_type = ntohs (emsg->element_type);
  ee->remote = GNUNET_YES;
  GNUNET_SETU_element_hash (&ee->element,
                            &ee->element_hash);
  if (GNUNET_NO ==
      GNUNET_CONTAINER_multihashmap_remove (op->demanded_hashes,
                                            &ee->element_hash,
                                            NULL))
  {
    /* We got something we didn't demand, since it's not in our map. */
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
 
  if (GNUNET_OK !=
      update_message_control_flow (
        op->message_control_flow,
        MSG_CFS_RECEIVED,
        &ee->element_hash,
        ELEMENT_MESSAGE)
      )
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "An element has been received more than once!\n");
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got element (size %u, hash %s) from peer\n",
       (unsigned int) element_size,
       GNUNET_h2s (&ee->element_hash));
 
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# received elements",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# exchanged elements",
                            1,
                            GNUNET_NO);
 
  op->received_total++;
 
  ke = op_get_element (op,
                       &ee->element_hash);
  if (NULL != ke)
  {
    /* Got repeated element.  Should not happen since
     * we track demands. */
    GNUNET_STATISTICS_update (_GSS_statistics,
                              "# repeated elements",
                              1,
                              GNUNET_NO);
    ke->received = GNUNET_YES;
    GNUNET_free (ee);
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Registering new element from remote peer\n");
    op->received_fresh++;
    op_register_element (op, ee, GNUNET_YES);
    /* only send results immediately if the client wants it */
    send_client_element (op,
                         &ee->element,
                         GNUNET_SETU_STATUS_ADD_LOCAL);
  }
 
  if ((op->received_total > 8) &&
      (op->received_fresh < op->received_total / 3))
  {
    /* The other peer gave us lots of old elements, there's something wrong. */
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
  GNUNET_CADET_receive_done (op->channel);
  maybe_finish (op);
}

References _GSS_statistics, check_valid_phase(), GNUNET_SET_Element::data, ElementEntry::element, ElementEntry::element_hash, ELEMENT_MESSAGE, GNUNET_SET_Element::element_type, GNUNET_SETU_ElementMessage::element_type, fail_union_operation(), GNUNET_break, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_h2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_SETU_element_hash(), GNUNET_SETU_STATUS_ADD_LOCAL, GNUNET_STATISTICS_update(), GNUNET_YES, GNUNET_SETU_ElementMessage::header, LOG, maybe_finish(), MSG_CFS_RECEIVED, op, op_get_element(), op_register_element(), PHASE_ACTIVE_DECODING, PHASE_FINISH_CLOSING, PHASE_FINISH_WAITING, PHASE_PASSIVE_DECODING, KeyEntry::received, ElementEntry::remote, send_client_element(), GNUNET_MessageHeader::size, GNUNET_SET_Element::size, and update_message_control_flow().

Here is the call graph for this function:

check_union_p2p_full_element()

static int check_union_p2p_full_element ( void *  cls, const struct GNUNET_SETU_ElementMessage *  emsg  )

static

Check a full element message from a remote peer.

Parameters

cls	the union operation
emsg	the message

Definition at line 3477 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
 
  (void) op;
 
  // FIXME: check that we expect full elements here?
  return GNUNET_OK;
}

References GNUNET_OK, and op.

handle_union_p2p_full_element()

static void handle_union_p2p_full_element ( void *  cls, const struct GNUNET_SETU_ElementMessage *  emsg  )

static

Handle an element message from a remote peer.

Parameters

cls	the union operation
emsg	the message

Check that the message is received only in supported phase

Definition at line 3496 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  struct ElementEntry *ee;
  struct KeyEntry *ke;
  uint16_t element_size;
 
  uint8_t allowed_phases[] = {PHASE_FULL_RECEIVING, PHASE_FULL_SENDING};
  if (GNUNET_OK !=
      check_valid_phase (allowed_phases,sizeof(allowed_phases),op))
  {
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
 
  element_size = ntohs (emsg->header.size)
                 - sizeof(struct GNUNET_SETU_ElementMessage);
 
#if MEASURE_PERFORMANCE
  perf_store.element_full.received += 1;
  perf_store.element_full.received_var_bytes += element_size;
#endif
 
  ee = GNUNET_malloc (sizeof(struct ElementEntry) + element_size);
  GNUNET_memcpy (&ee[1], &emsg[1], element_size);
  ee->element.size = element_size;
  ee->element.data = &ee[1];
  ee->element.element_type = ntohs (emsg->element_type);
  ee->remote = GNUNET_YES;
  GNUNET_SETU_element_hash (&ee->element,
                            &ee->element_hash);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got element (full diff, size %u, hash %s) from peer\n",
       (unsigned int) element_size,
       GNUNET_h2s (&ee->element_hash));
 
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# received elements",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# exchanged elements",
                            1,
                            GNUNET_NO);
 
  op->received_total++;
  ke = op_get_element (op,
                       &ee->element_hash);
  if (NULL != ke)
  {
    GNUNET_STATISTICS_update (_GSS_statistics,
                              "# repeated elements",
                              1,
                              GNUNET_NO);
    full_sync_plausibility_check (op);
    ke->received = GNUNET_YES;
    GNUNET_free (ee);
  }
  else
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Registering new element from remote peer\n");
    op->received_fresh++;
    op_register_element (op, ee, GNUNET_YES);
    /* only send results immediately if the client wants it */
    send_client_element (op,
                         &ee->element,
                         GNUNET_SETU_STATUS_ADD_LOCAL);
  }
 
 
  if ((GNUNET_YES == op->byzantine) &&
      (op->received_total > op->remote_element_count) )
  {
    /* The other peer gave us lots of old elements, there's something wrong. */
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "Other peer sent %llu elements while pretending to have %llu elements, failing operation\n",
         (unsigned long long) op->received_total,
         (unsigned long long) op->remote_element_count);
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
  GNUNET_CADET_receive_done (op->channel);
}

References _GSS_statistics, check_valid_phase(), GNUNET_SET_Element::data, ElementEntry::element, ElementEntry::element_hash, GNUNET_SET_Element::element_type, GNUNET_SETU_ElementMessage::element_type, fail_union_operation(), full_sync_plausibility_check(), GNUNET_break, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_h2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_SETU_element_hash(), GNUNET_SETU_STATUS_ADD_LOCAL, GNUNET_STATISTICS_update(), GNUNET_YES, GNUNET_SETU_ElementMessage::header, LOG, op, op_get_element(), op_register_element(), PHASE_FULL_RECEIVING, PHASE_FULL_SENDING, KeyEntry::received, ElementEntry::remote, send_client_element(), GNUNET_MessageHeader::size, and GNUNET_SET_Element::size.

Here is the call graph for this function:

check_union_p2p_inquiry()

static int check_union_p2p_inquiry ( void *  cls, const struct InquiryMessage *  msg  )

static

Send offers (for GNUNET_Hash-es) in response to inquiries (for IBF_Key-s).

Parameters

cls	the union operation
msg	the message

Definition at line 3596 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  unsigned int num_keys;
 
  if (op->phase != PHASE_PASSIVE_DECODING)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  num_keys = (ntohs (msg->header.size) - sizeof(struct InquiryMessage))
             / sizeof(struct IBF_Key);
  if ((ntohs (msg->header.size) - sizeof(struct InquiryMessage))
      != num_keys * sizeof(struct IBF_Key))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, msg, op, PHASE_PASSIVE_DECODING, and GNUNET_MessageHeader::size.

handle_union_p2p_inquiry()

static void handle_union_p2p_inquiry ( void *  cls, const struct InquiryMessage *  msg  )

static

Send offers (for GNUNET_Hash-es) in response to inquiries (for IBF_Key-s).

Parameters

cls	the union operation
msg	the message

Check that the message is received only in supported phase

Add received inquiries to hashmap for flow control

Definition at line 3626 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  const struct IBF_Key *ibf_key;
  unsigned int num_keys;
 
  uint8_t allowed_phases[] = {PHASE_ACTIVE_DECODING, PHASE_PASSIVE_DECODING};
  if (GNUNET_OK !=
      check_valid_phase (allowed_phases,sizeof(allowed_phases),op))
  {
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
 
#if MEASURE_PERFORMANCE
  perf_store.inquery.received += 1;
  perf_store.inquery.received_var_bytes += (ntohs (msg->header.size)
                                            - sizeof(struct InquiryMessage));
#endif
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received union inquiry\n");
  num_keys = (ntohs (msg->header.size) - sizeof(struct InquiryMessage))
             / sizeof(struct IBF_Key);
  ibf_key = (const struct IBF_Key *) &msg[1];
  {
    struct GNUNET_HashContext *hashed_key_context =
      GNUNET_CRYPTO_hash_context_start ();
    struct GNUNET_HashCode *hashed_key = GNUNET_new (struct GNUNET_HashCode);
    enum MESSAGE_CONTROL_FLOW_STATE mcfs = MSG_CFS_RECEIVED;
    GNUNET_CRYPTO_hash_context_read (hashed_key_context,
                                     &ibf_key,
                                     sizeof(struct IBF_Key));
    GNUNET_CRYPTO_hash_context_finish (hashed_key_context,
                                       hashed_key);
    GNUNET_CONTAINER_multihashmap_put (op->inquiries_sent,
                                       hashed_key,
                                       &mcfs,
                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE
                                       );
 
    while (0 != num_keys--)
    {
      struct IBF_Key unsalted_key;
      unsalt_key (ibf_key,
                  ntohl (msg->salt),
                  &unsalted_key);
      send_offers_for_key (op,
                           unsalted_key);
      ibf_key++;
    }
    GNUNET_CADET_receive_done (op->channel);
  }
}

References check_valid_phase(), fail_union_operation(), GNUNET_break, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE, GNUNET_CRYPTO_hash_context_finish(), GNUNET_CRYPTO_hash_context_read(), GNUNET_CRYPTO_hash_context_start(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_new, GNUNET_OK, LOG, msg, MSG_CFS_RECEIVED, op, PHASE_ACTIVE_DECODING, PHASE_PASSIVE_DECODING, send_offers_for_key(), GNUNET_MessageHeader::size, and unsalt_key().

Here is the call graph for this function:

send_missing_full_elements_iter()

static int send_missing_full_elements_iter ( void *  cls, uint32_t  key, void *  value  )

static

Iterator over hash map entries, called to destroy the linked list of colliding ibf key entries.

Parameters

cls	closure
key	current key code
value	value in the hash map

Returns

GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

Definition at line 3699 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  struct KeyEntry *ke = value;
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_SETU_ElementMessage *emsg;
  struct ElementEntry *ee = ke->element;
 
  if (GNUNET_YES == ke->received)
    return GNUNET_YES;
#if MEASURE_PERFORMANCE
  perf_store.element_full.received += 1;
#endif
  ev = GNUNET_MQ_msg_extra (emsg,
                            ee->element.size,
                            GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT);
  GNUNET_memcpy (&emsg[1],
                 ee->element.data,
                 ee->element.size);
  emsg->element_type = htons (ee->element.element_type);
  GNUNET_MQ_send (op->mq,
                  ev);
  return GNUNET_YES;
}

References GNUNET_SET_Element::data, ElementEntry::element, KeyEntry::element, GNUNET_SET_Element::element_type, GNUNET_SETU_ElementMessage::element_type, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_YES, op, KeyEntry::received, GNUNET_SET_Element::size, and value.

Referenced by handle_union_p2p_full_done().

Here is the call graph for this function:

Here is the caller graph for this function:

check_union_p2p_request_full()

static int check_union_p2p_request_full ( void *  cls, const struct TransmitFullMessage *  mh  )

static

Handle a request for full set transmission.

Parameters

cls	closure, a set union operation
mh	the demand message

Definition at line 3734 of file gnunet-service-setu.c.

{
  return GNUNET_OK;
}

References GNUNET_OK.

handle_union_p2p_request_full()

static void handle_union_p2p_request_full ( void *  cls, const struct TransmitFullMessage *  msg  )

static

Check that the message is received only in supported phase

Calculate avg element size if not initial sync

Definition at line 3742 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  uint64_t avg_element_size = 0;
  uint8_t allowed_phases[] = {PHASE_EXPECT_IBF};
 
  if (GNUNET_OK !=
      check_valid_phase (allowed_phases,sizeof(allowed_phases),op))
  {
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
 
  op->remote_element_count = ntohl (msg->remote_set_size);
  op->remote_set_diff = ntohl (msg->remote_set_difference);
  op->local_set_diff = ntohl (msg->local_set_difference);
 
 
  if (check_byzantine_bounds (op) != GNUNET_OK)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "PROTOCOL VIOLATION: Parameters transmitted from other peer do not satisfie byzantine "
         "criteria\n");
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
 
#if MEASURE_PERFORMANCE
  perf_store.request_full.received += 1;
#endif
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received request for full set transmission\n");
 
  op->local_element_count = GNUNET_CONTAINER_multihashmap_size (
    op->set->content->elements);
  if (0 < op->local_element_count)
  {
    op->total_elements_size_local = 0;
    GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
                                           &
                                           determinate_avg_element_size_iterator,
                                           op);
    avg_element_size = op->total_elements_size_local / op->local_element_count;
  }
  {
    int mode_of_operation = estimate_best_mode_of_operation (avg_element_size,
                                                             op->
                                                             remote_element_count,
                                                             op->
                                                             local_element_count,
                                                             op->local_set_diff,
                                                             op->remote_set_diff
                                                             ,
                                                             op->
                                                             rtt_bandwidth_tradeoff,
                                                             op->
                                                             ibf_bucket_number_factor);
    if (FULL_SYNC_REMOTE_SENDING_FIRST != mode_of_operation)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "PROTOCOL VIOLATION: Remote peer choose to request the full set first but correct mode would have been"
           " : %d\n", mode_of_operation);
      GNUNET_break_op (0);
      fail_union_operation (op);
      return;
    }
  }
  // FIXME: we need to check that our set is larger than the
  // byzantine_lower_bound by some threshold
  send_full_set (op);
  GNUNET_CADET_receive_done (op->channel);
}

References check_byzantine_bounds(), check_valid_phase(), determinate_avg_element_size_iterator(), estimate_best_mode_of_operation(), fail_union_operation(), FULL_SYNC_REMOTE_SENDING_FIRST, GNUNET_break, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, Operation::ibf_bucket_number_factor, Operation::local_element_count, LOG, Operation::mode_of_operation, msg, op, PHASE_EXPECT_IBF, Operation::remote_element_count, Operation::rtt_bandwidth_tradeoff, and send_full_set().

Here is the call graph for this function:

handle_union_p2p_full_done()

static void handle_union_p2p_full_done ( void *  cls, const struct GNUNET_MessageHeader *  mh  )

static

Handle a "full done" message.

Parameters

cls	closure, a set union operation
mh	the demand message

Check that the message is received only in supported phase

Definition at line 3831 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
 
  uint8_t allowed_phases[] = {PHASE_FULL_SENDING, PHASE_FULL_RECEIVING};
  if (GNUNET_OK !=
      check_valid_phase (allowed_phases,sizeof(allowed_phases),op))
  {
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
 
#if MEASURE_PERFORMANCE
  perf_store.full_done.received += 1;
#endif
 
  switch (op->phase)
  {
  case PHASE_FULL_RECEIVING:
    {
      struct GNUNET_MQ_Envelope *ev;
 
      if ((GNUNET_YES == op->byzantine) &&
          (op->received_total != op->remote_element_count) )
      {
        /* The other peer gave not enough elements before sending full done, there's something wrong. */
        LOG (GNUNET_ERROR_TYPE_ERROR,
             "Other peer sent only %llu/%llu fresh elements, failing operation\n",
             (unsigned long long) op->received_total,
             (unsigned long long) op->remote_element_count);
        GNUNET_break_op (0);
        fail_union_operation (op);
        return;
      }
 
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "got FULL DONE, sending elements that other peer is missing\n");
 
      /* send all the elements that did not come from the remote peer */
      GNUNET_CONTAINER_multihashmap32_iterate (op->key_to_element,
                                               &send_missing_full_elements_iter,
                                               op);
#if MEASURE_PERFORMANCE
      perf_store.full_done.sent += 1;
#endif
      ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE);
      GNUNET_MQ_send (op->mq,
                      ev);
      op->phase = PHASE_FINISHED;
      /* we now wait until the other peer sends us the OVER message*/
    }
    break;
 
  case PHASE_FULL_SENDING:
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "got FULL DONE, finishing\n");
      /* We sent the full set, and got the response for that.  We're done. */
      op->phase = PHASE_FINISHED;
      GNUNET_CADET_receive_done (op->channel);
      send_client_done (op);
      _GSS_operation_destroy2 (op);
      return;
    }
 
  default:
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Handle full done phase is %u\n",
                (unsigned) op->phase);
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
  GNUNET_CADET_receive_done (op->channel);
}

References _GSS_operation_destroy2(), check_valid_phase(), fail_union_operation(), GNUNET_break, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE, GNUNET_MQ_msg_header, GNUNET_MQ_send(), GNUNET_OK, GNUNET_YES, LOG, op, PHASE_FINISHED, PHASE_FULL_RECEIVING, PHASE_FULL_SENDING, send_client_done(), and send_missing_full_elements_iter().

Here is the call graph for this function:

check_union_p2p_demand()

static int check_union_p2p_demand ( void *  cls, const struct GNUNET_MessageHeader *  mh  )

static

Check a demand by the other peer for elements based on a list of struct GNUNET_HashCodes.

Parameters

cls	closure, a set union operation
mh	the demand message

Returns

GNUNET_OK if mh is well-formed

Definition at line 3922 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  unsigned int num_hashes;
 
  (void) op;
  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
               / sizeof(struct GNUNET_HashCode);
  if ((ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
      != num_hashes * sizeof(struct GNUNET_HashCode))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, mh, and op.

handle_union_p2p_demand()

static void handle_union_p2p_demand ( void *  cls, const struct GNUNET_MessageHeader *  mh  )

static

Handle a demand by the other peer for elements based on a list of struct GNUNET_HashCodes.

Parameters

cls	closure, a set union operation
mh	the demand message

Check that the message is received only in supported phase

Definition at line 3949 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  struct ElementEntry *ee;
  struct GNUNET_SETU_ElementMessage *emsg;
  const struct GNUNET_HashCode *hash;
  unsigned int num_hashes;
  struct GNUNET_MQ_Envelope *ev;
 
  uint8_t allowed_phases[] = {PHASE_ACTIVE_DECODING, PHASE_PASSIVE_DECODING,
                              PHASE_FINISH_WAITING};
  if (GNUNET_OK !=
      check_valid_phase (allowed_phases,sizeof(allowed_phases),op))
  {
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
#if MEASURE_PERFORMANCE
  perf_store.demand.received += 1;
  perf_store.demand.received_var_bytes += (ntohs (mh->size) - sizeof(struct
                                                                     GNUNET_MessageHeader));
#endif
 
  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
               / sizeof(struct GNUNET_HashCode);
  for (hash = (const struct GNUNET_HashCode *) &mh[1];
       num_hashes > 0;
       hash++, num_hashes--)
  {
    ee = GNUNET_CONTAINER_multihashmap_get (op->set->content->elements,
                                            hash);
    if (NULL == ee)
    {
      /* Demand for non-existing element. */
      GNUNET_break_op (0);
      fail_union_operation (op);
      return;
    }
 
    /* Save send demand message for message control */
    if (GNUNET_YES !=
        update_message_control_flow (
          op->message_control_flow,
          MSG_CFS_RECEIVED,
          &ee->element_hash,
          DEMAND_MESSAGE)
        )
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Double demand message received found!\n");
      GNUNET_break (0);
      fail_union_operation (op);
      return;
    }
    ;
 
    /* Mark element to be expected to received */
    if (GNUNET_YES !=
        update_message_control_flow (
          op->message_control_flow,
          MSG_CFS_SENT,
          &ee->element_hash,
          ELEMENT_MESSAGE)
        )
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Double element message sent found!\n");
      GNUNET_break (0);
      fail_union_operation (op);
      return;
    }
    if (GNUNET_NO == _GSS_is_element_of_operation (ee, op))
    {
      /* Probably confused lazily copied sets. */
      GNUNET_break_op (0);
      fail_union_operation (op);
      return;
    }
#if MEASURE_PERFORMANCE
    perf_store.element.sent += 1;
    perf_store.element.sent_var_bytes += ee->element.size;
#endif
    ev = GNUNET_MQ_msg_extra (emsg,
                              ee->element.size,
                              GNUNET_MESSAGE_TYPE_SETU_P2P_ELEMENTS);
    GNUNET_memcpy (&emsg[1],
                   ee->element.data,
                   ee->element.size);
    emsg->reserved = htons (0);
    emsg->element_type = htons (ee->element.element_type);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "[OP %p] Sending demanded element (size %u, hash %s) to peer\n",
         op,
         (unsigned int) ee->element.size,
         GNUNET_h2s (&ee->element_hash));
    GNUNET_MQ_send (op->mq, ev);
    GNUNET_STATISTICS_update (_GSS_statistics,
                              "# exchanged elements",
                              1,
                              GNUNET_NO);
    if (op->symmetric)
      send_client_element (op,
                           &ee->element,
                           GNUNET_SETU_STATUS_ADD_REMOTE);
  }
  GNUNET_CADET_receive_done (op->channel);
  maybe_finish (op);
}

References _GSS_is_element_of_operation(), _GSS_statistics, check_valid_phase(), GNUNET_SET_Element::data, DEMAND_MESSAGE, ElementEntry::element, ElementEntry::element_hash, ELEMENT_MESSAGE, GNUNET_SET_Element::element_type, GNUNET_SETU_ElementMessage::element_type, fail_union_operation(), GNUNET_break, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SETU_P2P_ELEMENTS, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_SETU_STATUS_ADD_REMOTE, GNUNET_STATISTICS_update(), GNUNET_YES, LOG, maybe_finish(), mh, MSG_CFS_RECEIVED, MSG_CFS_SENT, op, PHASE_ACTIVE_DECODING, PHASE_FINISH_WAITING, PHASE_PASSIVE_DECODING, GNUNET_SETU_ElementMessage::reserved, send_client_element(), GNUNET_SET_Element::size, and update_message_control_flow().

Here is the call graph for this function:

check_union_p2p_offer()

static int check_union_p2p_offer ( void *  cls, const struct GNUNET_MessageHeader *  mh  )

static

Check offer (of struct GNUNET_HashCodes).

Parameters

cls	the union operation
mh	the message

Returns

GNUNET_OK if mh is well-formed

Definition at line 4072 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  unsigned int num_hashes;
 
  /* look up elements and send them */
  if ((op->phase != PHASE_PASSIVE_DECODING) &&
      (op->phase != PHASE_ACTIVE_DECODING))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
               / sizeof(struct GNUNET_HashCode);
  if ((ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader)) !=
      num_hashes * sizeof(struct GNUNET_HashCode))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, mh, op, PHASE_ACTIVE_DECODING, and PHASE_PASSIVE_DECODING.

handle_union_p2p_offer()

static void handle_union_p2p_offer ( void *  cls, const struct GNUNET_MessageHeader *  mh  )

static

Handle offers (of struct GNUNET_HashCodes) and respond with demands (of struct GNUNET_HashCodes).

Parameters

cls	the union operation
mh	the message

Check that the message is received only in supported phase

Definition at line 4105 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  const struct GNUNET_HashCode *hash;
  unsigned int num_hashes;
  uint8_t allowed_phases[] = {PHASE_ACTIVE_DECODING, PHASE_PASSIVE_DECODING};
  if (GNUNET_OK !=
      check_valid_phase (allowed_phases,sizeof(allowed_phases),op))
  {
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
 
#if MEASURE_PERFORMANCE
  perf_store.offer.received += 1;
  perf_store.offer.received_var_bytes += (ntohs (mh->size) - sizeof(struct
                                                                    GNUNET_MessageHeader));
#endif
 
  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
               / sizeof(struct GNUNET_HashCode);
  for (hash = (const struct GNUNET_HashCode *) &mh[1];
       num_hashes > 0;
       hash++, num_hashes--)
  {
    struct ElementEntry *ee;
    struct GNUNET_MessageHeader *demands;
    struct GNUNET_MQ_Envelope *ev;
 
    ee = GNUNET_CONTAINER_multihashmap_get (op->set->content->elements,
                                            hash);
    if (NULL != ee)
      if (GNUNET_YES == _GSS_is_element_of_operation (ee, op))
        continue;
 
    if (GNUNET_YES ==
        GNUNET_CONTAINER_multihashmap_contains (op->demanded_hashes,
                                                hash))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Skipped sending duplicate demand\n");
      continue;
    }
 
    GNUNET_assert (GNUNET_OK ==
                   GNUNET_CONTAINER_multihashmap_put (
                     op->demanded_hashes,
                     hash,
                     NULL,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "[OP %p] Requesting element (hash %s)\n",
         op, GNUNET_h2s (hash));
 
#if MEASURE_PERFORMANCE
    perf_store.demand.sent += 1;
    perf_store.demand.sent_var_bytes += sizeof(struct GNUNET_HashCode);
#endif
    /* Save send demand message for message control */
    if (GNUNET_YES !=
        update_message_control_flow (
          op->message_control_flow,
          MSG_CFS_SENT,
          hash,
          DEMAND_MESSAGE))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Double demand message sent found!\n");
      GNUNET_break (0);
      fail_union_operation (op);
      return;
    }
 
    /* Mark offer as received received */
    if (GNUNET_YES !=
        update_message_control_flow (
          op->message_control_flow,
          MSG_CFS_RECEIVED,
          hash,
          OFFER_MESSAGE))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Double offer message received found!\n");
      GNUNET_break (0);
      fail_union_operation (op);
      return;
    }
    /* Mark element to be expected to received */
    if (GNUNET_YES !=
        update_message_control_flow (
          op->message_control_flow,
          MSG_CFS_EXPECTED,
          hash,
          ELEMENT_MESSAGE))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           "Element already expected!\n");
      GNUNET_break (0);
      fail_union_operation (op);
      return;
    }
    ev = GNUNET_MQ_msg_header_extra (demands,
                                     sizeof(struct GNUNET_HashCode),
                                     GNUNET_MESSAGE_TYPE_SETU_P2P_DEMAND);
    GNUNET_memcpy (&demands[1],
                   hash,
                   sizeof(struct GNUNET_HashCode));
    GNUNET_MQ_send (op->mq, ev);
  }
  GNUNET_CADET_receive_done (op->channel);
}

References _GSS_is_element_of_operation(), check_valid_phase(), DEMAND_MESSAGE, ELEMENT_MESSAGE, fail_union_operation(), GNUNET_assert, GNUNET_break, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SETU_P2P_DEMAND, GNUNET_MQ_msg_header_extra, GNUNET_MQ_send(), GNUNET_OK, GNUNET_YES, LOG, mh, MSG_CFS_EXPECTED, MSG_CFS_RECEIVED, MSG_CFS_SENT, OFFER_MESSAGE, op, PHASE_ACTIVE_DECODING, PHASE_PASSIVE_DECODING, and update_message_control_flow().

Here is the call graph for this function:

handle_union_p2p_done()

static void handle_union_p2p_done ( void *  cls, const struct GNUNET_MessageHeader *  mh  )

static

Handle a done message from a remote peer.

Parameters

cls	the union operation
mh	the message

Check that the message is received only in supported phase

Definition at line 4231 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
 
  uint8_t allowed_phases[] = {PHASE_ACTIVE_DECODING, PHASE_PASSIVE_DECODING};
  if (GNUNET_OK !=
      check_valid_phase (allowed_phases,sizeof(allowed_phases),op))
  {
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
 
  if (op->active_passive_switch_required)
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "PROTOCOL VIOLATION: Received done but role change is necessary\n");
    GNUNET_break (0);
    fail_union_operation (op);
    return;
  }
 
#if MEASURE_PERFORMANCE
  perf_store.done.received += 1;
#endif
  switch (op->phase)
  {
  case PHASE_PASSIVE_DECODING:
    /* We got all requests, but still have to send our elements in response. */
    op->phase = PHASE_FINISH_WAITING;
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "got DONE (as passive partner), waiting for our demands to be satisfied\n");
    /* The active peer is done sending offers
         * and inquiries.  This means that all
         * our responses to that (demands and offers)
         * must be in flight (queued or in mesh).
         *
         * We should notify the active peer once
         * all our demands are satisfied, so that the active
         * peer can quit if we gave it everything.
         */GNUNET_CADET_receive_done (op->channel);
    maybe_finish (op);
    return;
  case PHASE_ACTIVE_DECODING:
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "got DONE (as active partner), waiting to finish\n");
    /* All demands of the other peer are satisfied,
         * and we processed all offers, thus we know
         * exactly what our demands must be.
         *
         * We'll close the channel
         * to the other peer once our demands are met.
         */op->phase = PHASE_FINISH_CLOSING;
    GNUNET_CADET_receive_done (op->channel);
    maybe_finish (op);
    return;
  default:
    GNUNET_break_op (0);
    fail_union_operation (op);
    return;
  }
}

References check_valid_phase(), fail_union_operation(), GNUNET_break, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, LOG, maybe_finish(), op, PHASE_ACTIVE_DECODING, PHASE_FINISH_CLOSING, PHASE_FINISH_WAITING, and PHASE_PASSIVE_DECODING.

Here is the call graph for this function:

handle_union_p2p_over()

static void handle_union_p2p_over ( void *  cls, const struct GNUNET_MessageHeader *  mh  )

static

Handle a over message from a remote peer.

Parameters

cls	the union operation
mh	the message

Definition at line 4306 of file gnunet-service-setu.c.

{
#if MEASURE_PERFORMANCE
  perf_store.over.received += 1;
#endif
  send_client_done (cls);
}

References send_client_done().

Here is the call graph for this function:

get_incoming()

static struct Operation * get_incoming ( uint32_t  id )

static

Get the incoming socket associated with the given id.

Parameters

listener	the listener to look in
id	id to look for

Returns

the incoming socket associated with the id, or NULL if there is none

Definition at line 4325 of file gnunet-service-setu.c.

{
  for (struct Listener *listener = listener_head;
       NULL != listener;
       listener = listener->next)
  {
    for (struct Operation *op = listener->op_head;
         NULL != op;
         op = op->next)
      if (op->suggest_id == id)
        return op;
  }
  return NULL;
}

References Operation::listener, listener_head, Listener::next, GNUNET_ARM_Operation::next, op, and Listener::op_head.

Referenced by handle_client_accept(), and handle_client_reject().

Here is the caller graph for this function:

client_connect_cb()

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

static

Callback called when a client connects to the service.

Parameters

cls	closure for the service
c	the new client that connected to the service
mq	the message queue used to send messages to the client

Returns

`struct ClientState`

Definition at line 4350 of file gnunet-service-setu.c.

{
  struct ClientState *cs;
 
  num_clients++;
  cs = GNUNET_new (struct ClientState);
  cs->client = c;
  cs->mq = mq;
  return cs;
}

References ClientState::client, GNUNET_new, mq, ClientState::mq, and num_clients.

destroy_elements_iterator()

static int destroy_elements_iterator ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Iterator over hash map entries to free element entries.

Parameters

cls	closure
key	current key code
value	a struct ElementEntry * to be free'd

Returns

GNUNET_YES (continue to iterate)

Definition at line 4373 of file gnunet-service-setu.c.

{
  struct ElementEntry *ee = value;
 
  GNUNET_free (ee);
  return GNUNET_YES;
}

References GNUNET_free, GNUNET_YES, and value.

Referenced by client_disconnect_cb().

Here is the caller graph for this function:

client_disconnect_cb()

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

static

Clean up after a client has disconnected.

Parameters

cls	closure, unused
client	the client to clean up after
internal_cls	the struct ClientState

Definition at line 4392 of file gnunet-service-setu.c.

{
  struct ClientState *cs = internal_cls;
  struct Operation *op;
  struct Listener *listener;
  struct Set *set;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client disconnected, cleaning up\n");
  if (NULL != (set = cs->set))
  {
    struct SetContent *content = set->content;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Destroying client's set\n");
    /* Destroy pending set operations */
    while (NULL != set->ops_head)
      _GSS_operation_destroy (set->ops_head);
 
    /* Destroy operation-specific state */
    if (NULL != set->se)
    {
      strata_estimator_destroy (set->se);
      set->se = NULL;
    }
    /* free set content (or at least decrement RC) */
    set->content = NULL;
    GNUNET_assert (0 != content->refcount);
    content->refcount--;
    if (0 == content->refcount)
    {
      GNUNET_assert (NULL != content->elements);
      GNUNET_CONTAINER_multihashmap_iterate (content->elements,
                                             &destroy_elements_iterator,
                                             NULL);
      GNUNET_CONTAINER_multihashmap_destroy (content->elements);
      content->elements = NULL;
      GNUNET_free (content);
    }
    GNUNET_free (set);
  }
 
  if (NULL != (listener = cs->listener))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Destroying client's listener\n");
    GNUNET_CADET_close_port (listener->open_port);
    listener->open_port = NULL;
    while (NULL != (op = listener->op_head))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "Destroying incoming operation `%u' from peer `%s'\n",
                  (unsigned int) op->client_request_id,
                  GNUNET_i2s (&op->peer));
      incoming_destroy (op);
    }
    GNUNET_CONTAINER_DLL_remove (listener_head,
                                 listener_tail,
                                 listener);
    GNUNET_free (listener);
  }
  GNUNET_free (cs);
  num_clients--;
  if ( (GNUNET_YES == in_shutdown) &&
       (0 == num_clients) )
  {
    if (NULL != cadet)
    {
      GNUNET_CADET_disconnect (cadet);
      cadet = NULL;
    }
  }
}

References _GSS_operation_destroy(), cadet, Set::content, Set::cs, destroy_elements_iterator(), SetContent::elements, GNUNET_assert, GNUNET_CADET_close_port(), GNUNET_CADET_disconnect(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_YES, in_shutdown, incoming_destroy(), ClientState::listener, listener_head, listener_tail, num_clients, op, Listener::op_head, Listener::open_port, Set::ops_head, SetContent::refcount, Set::se, ClientState::set, and strata_estimator_destroy().

Here is the call graph for this function:

check_incoming_msg()

static int check_incoming_msg ( void *  cls, const struct OperationRequestMessage *  msg  )

static

Check a request for a set operation from another peer.

Parameters

cls	the operation state
msg	the received message

Returns

GNUNET_OK if the channel should be kept alive, GNUNET_SYSERR to destroy the channel

Definition at line 4478 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  struct Listener *listener = op->listener;
  const struct GNUNET_MessageHeader *nested_context;
 
  /* double operation request */
  if (0 != op->suggest_id)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  /* This should be equivalent to the previous condition, but can't hurt to check twice */
  if (NULL == listener)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  nested_context = GNUNET_MQ_extract_nested_mh (msg);
  if ((NULL != nested_context) &&
      (ntohs (nested_context->size) > GNUNET_SETU_CONTEXT_MESSAGE_MAX_SIZE))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_break_op, GNUNET_MQ_extract_nested_mh, GNUNET_OK, GNUNET_SETU_CONTEXT_MESSAGE_MAX_SIZE, GNUNET_SYSERR, msg, op, and GNUNET_MessageHeader::size.

handle_incoming_msg()

static void handle_incoming_msg ( void *  cls, const struct OperationRequestMessage *  msg  )

static

Handle a request for a set operation from another peer.

Checks if we have a listener waiting for such a request (and in that case initiates asking the listener about accepting the connection). If no listener is waiting, we queue the operation request in hope that a listener shows up soon (before timeout).

This msg is expected as the first and only msg handled through the non-operation bound virtual table, acceptance of this operation replaces our virtual table and subsequent msgs would be routed differently (as we then know what type of operation this is).

Parameters

cls	the operation state
msg	the received message

Definition at line 4524 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
  struct Listener *listener = op->listener;
  const struct GNUNET_MessageHeader *nested_context;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_SETU_RequestMessage *cmsg;
 
  nested_context = GNUNET_MQ_extract_nested_mh (msg);
  /* Make a copy of the nested_context (application-specific context
     information that is opaque to set) so we can pass it to the
     listener later on */
  if (NULL != nested_context)
    op->context_msg = GNUNET_copy_message (nested_context);
  op->remote_element_count = ntohl (msg->element_count);
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Received P2P operation request (port %s) for active listener\n",
    GNUNET_h2s (&op->listener->app_id));
  GNUNET_assert (0 == op->suggest_id);
  if (0 == suggest_id)
    suggest_id++;
  op->suggest_id = suggest_id++;
  GNUNET_assert (NULL != op->timeout_task);
  GNUNET_SCHEDULER_cancel (op->timeout_task);
  op->timeout_task = NULL;
  env = GNUNET_MQ_msg_nested_mh (cmsg,
                                 GNUNET_MESSAGE_TYPE_SETU_REQUEST,
                                 op->context_msg);
  GNUNET_log (
    GNUNET_ERROR_TYPE_DEBUG,
    "Suggesting incoming request with accept id %u to listener %p of client %p\n",
    op->suggest_id,
    listener,
    listener->cs);
  cmsg->accept_id = htonl (op->suggest_id);
  cmsg->peer_id = op->peer;
  GNUNET_MQ_send (listener->cs->mq,
                  env);
  /* NOTE: GNUNET_CADET_receive_done() will be called in
   #handle_client_accept() */
}

References GNUNET_SETU_RequestMessage::accept_id, Listener::cs, env, GNUNET_assert, GNUNET_copy_message(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_SETU_REQUEST, GNUNET_MQ_extract_nested_mh, GNUNET_MQ_msg_nested_mh, GNUNET_MQ_send(), GNUNET_SCHEDULER_cancel(), ClientState::mq, msg, op, GNUNET_SETU_RequestMessage::peer_id, and suggest_id.

Here is the call graph for this function:

handle_client_create_set()

static void handle_client_create_set ( void *  cls, const struct GNUNET_SETU_CreateMessage *  msg  )

static

Called when a client wants to create a new set.

This is typically the first request from a client, and includes the type of set operation to be performed.

Parameters

cls	client that sent the message
m	message sent by the client

Definition at line 4578 of file gnunet-service-setu.c.

{
  struct ClientState *cs = cls;
  struct Set *set;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client created new set for union operation\n");
  if (NULL != cs->set)
  {
    /* There can only be one set per client */
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (cs->client);
    return;
  }
  set = GNUNET_new (struct Set);
  {
    struct MultiStrataEstimator *se;
 
    se = strata_estimator_create (SE_STRATA_COUNT,
                                  SE_IBFS_TOTAL_SIZE,
                                  SE_IBF_HASH_NUM);
    if (NULL == se)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to allocate strata estimator\n");
      GNUNET_free (set);
      GNUNET_SERVICE_client_drop (cs->client);
      return;
    }
    set->se = se;
  }
  set->content = GNUNET_new (struct SetContent);
  set->content->refcount = 1;
  set->content->elements = GNUNET_CONTAINER_multihashmap_create (1,
                                                                 GNUNET_YES);
  set->cs = cs;
  cs->set = set;
  GNUNET_SERVICE_client_continue (cs->client);
}

References ClientState::client, Set::content, Set::cs, SetContent::elements, GNUNET_break, GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_YES, SetContent::refcount, Set::se, SE_IBF_HASH_NUM, SE_IBFS_TOTAL_SIZE, SE_STRATA_COUNT, ClientState::set, and strata_estimator_create().

Here is the call graph for this function:

incoming_timeout_cb()

static void incoming_timeout_cb ( void *  cls )

static

Timeout happens iff:

• we suggested an operation to our listener, but did not receive a response in time
• we got the channel from a peer but no GNUNET_MESSAGE_TYPE_SETU_P2P_OPERATION_REQUEST

Parameters

cls	channel context
tc	context information (why was this task triggered now)

Definition at line 4630 of file gnunet-service-setu.c.

{
  struct Operation *op = cls;
 
  op->timeout_task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Remote peer's incoming request timed out\n");
  incoming_destroy (op);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, incoming_destroy(), and op.

Referenced by channel_new_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

channel_new_cb()

static void * channel_new_cb ( void *  cls, struct GNUNET_CADET_Channel *  channel, const struct GNUNET_PeerIdentity *  source  )

static

Method called whenever another peer has added us to a channel the other peer initiated.

Only called (once) upon reception of data from a channel we listen on.

The channel context represents the operation itself and gets added to a DLL, from where it gets looked up when our local listener client responds to a proposed/suggested operation or connects and associates with this operation.

Parameters

cls	closure
channel	new handle to the channel
source	peer that started the channel

Returns

initial channel context for the channel returns NULL on error

Definition at line 4658 of file gnunet-service-setu.c.

{
  struct Listener *listener = cls;
  struct Operation *op;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "New incoming channel\n");
  op = GNUNET_new (struct Operation);
  op->listener = listener;
  op->peer = *source;
  op->channel = channel;
  op->mq = GNUNET_CADET_get_mq (op->channel);
  op->salt = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                       UINT32_MAX);
  op->timeout_task = GNUNET_SCHEDULER_add_delayed (INCOMING_CHANNEL_TIMEOUT,
                                                   &incoming_timeout_cb,
                                                   op);
  GNUNET_CONTAINER_DLL_insert (listener->op_head,
                               listener->op_tail,
                               op);
  return op;
}

References Operation::channel, GNUNET_CADET_get_mq(), GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_delayed(), INCOMING_CHANNEL_TIMEOUT, incoming_timeout_cb(), Operation::listener, op, Listener::op_head, Listener::op_tail, and source.

Referenced by handle_client_listen().

Here is the call graph for this function:

Here is the caller graph for this function:

channel_end_cb()

static void channel_end_cb ( void *  channel_ctx, const struct GNUNET_CADET_Channel *  channel  )

static

Function called whenever a channel is destroyed.

Should clean up any associated state. It must NOT call GNUNET_CADET_channel_destroy() on the channel.

The peer_disconnect function is part of a a virtual table set initially either when a peer creates a new channel with us, or once we create a new channel ourselves (evaluate).

Once we know the exact type of operation (union/intersection), the vt is replaced with an operation specific instance (GSS[op]_vt).

Parameters

channel_ctx	place where local state associated with the channel is stored
channel	connection to the other end (henceforth invalid)

Definition at line 4701 of file gnunet-service-setu.c.

{
  struct Operation *op = channel_ctx;
 
  op->channel = NULL;
  _GSS_operation_destroy2 (op);
}

References _GSS_operation_destroy2(), and op.

Referenced by handle_client_evaluate(), and handle_client_listen().

Here is the call graph for this function:

Here is the caller graph for this function:

channel_window_cb()

static void channel_window_cb ( void *  cls, const struct GNUNET_CADET_Channel *  channel, int  window_size  )

static

Function called whenever an MQ-channel's transmission window size changes.

The first callback in an outgoing channel will be with a non-zero value and will mean the channel is connected to the destination.

For an incoming channel it will be called immediately after the GNUNET_CADET_ConnectEventHandler, also with a non-zero value.

Parameters

cls	Channel closure.
channel	Connection to the other end (henceforth invalid).
window_size	New window size. If the is more messages than buffer size this value will be negative..

Definition at line 4726 of file gnunet-service-setu.c.

{
  /* FIXME: not implemented, we could do flow control here... */
}

Referenced by handle_client_evaluate(), and handle_client_listen().

Here is the caller graph for this function:

handle_client_listen()

static void handle_client_listen ( void *  cls, const struct GNUNET_SETU_ListenMessage *  msg  )

static

Called when a client wants to create a new listener.

Parameters

cls	client that sent the message
msg	message sent by the client

Definition at line 4742 of file gnunet-service-setu.c.

{
  struct ClientState *cs = cls;
  struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
    GNUNET_MQ_hd_var_size (incoming_msg,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_OPERATION_REQUEST,
                           struct OperationRequestMessage,
                           NULL),
    GNUNET_MQ_hd_var_size (union_p2p_ibf,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_IBF,
                           struct IBFMessage,
                           NULL),
    GNUNET_MQ_hd_var_size (union_p2p_elements,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_ELEMENTS,
                           struct GNUNET_SETU_ElementMessage,
                           NULL),
    GNUNET_MQ_hd_var_size (union_p2p_offer,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_OFFER,
                           struct GNUNET_MessageHeader,
                           NULL),
    GNUNET_MQ_hd_var_size (union_p2p_inquiry,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_INQUIRY,
                           struct InquiryMessage,
                           NULL),
    GNUNET_MQ_hd_var_size (union_p2p_demand,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_DEMAND,
                           struct GNUNET_MessageHeader,
                           NULL),
    GNUNET_MQ_hd_fixed_size (union_p2p_done,
                             GNUNET_MESSAGE_TYPE_SETU_P2P_DONE,
                             struct GNUNET_MessageHeader,
                             NULL),
    GNUNET_MQ_hd_fixed_size (union_p2p_over,
                             GNUNET_MESSAGE_TYPE_SETU_P2P_OVER,
                             struct GNUNET_MessageHeader,
                             NULL),
    GNUNET_MQ_hd_fixed_size (union_p2p_full_done,
                             GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE,
                             struct GNUNET_MessageHeader,
                             NULL),
    GNUNET_MQ_hd_var_size (union_p2p_request_full,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_REQUEST_FULL,
                           struct TransmitFullMessage,
                           NULL),
    GNUNET_MQ_hd_var_size (union_p2p_strata_estimator,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_SE,
                           struct StrataEstimatorMessage,
                           NULL),
    GNUNET_MQ_hd_var_size (union_p2p_strata_estimator,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_SEC,
                           struct StrataEstimatorMessage,
                           NULL),
    GNUNET_MQ_hd_var_size (union_p2p_full_element,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT,
                           struct GNUNET_SETU_ElementMessage,
                           NULL),
    GNUNET_MQ_hd_var_size (union_p2p_send_full,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_SEND_FULL,
                           struct TransmitFullMessage,
                           NULL),
    GNUNET_MQ_handler_end ()
  };
  struct Listener *listener;
 
  if (NULL != cs->listener)
  {
    /* max. one active listener per client! */
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (cs->client);
    return;
  }
  listener = GNUNET_new (struct Listener);
  listener->cs = cs;
  cs->listener = listener;
  listener->app_id = msg->app_id;
  GNUNET_CONTAINER_DLL_insert (listener_head,
                               listener_tail,
                               listener);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "New listener created (port %s)\n",
              GNUNET_h2s (&listener->app_id));
  listener->open_port = GNUNET_CADET_open_port (cadet,
                                                &msg->app_id,
                                                &channel_new_cb,
                                                listener,
                                                &channel_window_cb,
                                                &channel_end_cb,
                                                cadet_handlers);
  GNUNET_SERVICE_client_continue (cs->client);
}

References Listener::app_id, cadet, channel_end_cb(), channel_new_cb(), channel_window_cb(), ClientState::client, Listener::cs, GNUNET_break, GNUNET_CADET_open_port(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_SETU_P2P_DEMAND, GNUNET_MESSAGE_TYPE_SETU_P2P_DONE, GNUNET_MESSAGE_TYPE_SETU_P2P_ELEMENTS, GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE, GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT, GNUNET_MESSAGE_TYPE_SETU_P2P_IBF, GNUNET_MESSAGE_TYPE_SETU_P2P_INQUIRY, GNUNET_MESSAGE_TYPE_SETU_P2P_OFFER, GNUNET_MESSAGE_TYPE_SETU_P2P_OPERATION_REQUEST, GNUNET_MESSAGE_TYPE_SETU_P2P_OVER, GNUNET_MESSAGE_TYPE_SETU_P2P_REQUEST_FULL, GNUNET_MESSAGE_TYPE_SETU_P2P_SE, GNUNET_MESSAGE_TYPE_SETU_P2P_SEC, GNUNET_MESSAGE_TYPE_SETU_P2P_SEND_FULL, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_new, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), ClientState::listener, listener_head, listener_tail, msg, and Listener::open_port.

Here is the call graph for this function:

handle_client_reject()

static void handle_client_reject ( void *  cls, const struct GNUNET_SETU_RejectMessage *  msg  )

static

Called when the listening client rejects an operation request by another peer.

Parameters

cls	client that sent the message
msg	message sent by the client

Definition at line 4843 of file gnunet-service-setu.c.

{
  struct ClientState *cs = cls;
  struct Operation *op;
 
  op = get_incoming (ntohl (msg->accept_reject_id));
  if (NULL == op)
  {
    /* no matching incoming operation for this reject;
       could be that the other peer already disconnected... */
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Client rejected unknown operation %u\n",
                (unsigned int) ntohl (msg->accept_reject_id));
    GNUNET_SERVICE_client_continue (cs->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Peer request (app %s) rejected by client\n",
              GNUNET_h2s (&cs->listener->app_id));
  _GSS_operation_destroy2 (op);
  GNUNET_SERVICE_client_continue (cs->client);
}

References _GSS_operation_destroy2(), Listener::app_id, ClientState::client, get_incoming(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_h2s(), GNUNET_log, GNUNET_SERVICE_client_continue(), ClientState::listener, msg, and op.

Here is the call graph for this function:

check_client_set_add()

static int check_client_set_add ( void *  cls, const struct GNUNET_SETU_ElementMessage *  msg  )

static

Called when a client wants to add or remove an element to a set it inhabits.

Parameters

cls	client that sent the message
msg	message sent by the client

Definition at line 4875 of file gnunet-service-setu.c.

{
  /* NOTE: Technically, we should probably check with the
     block library whether the element we are given is well-formed */
  return GNUNET_OK;
}

References GNUNET_OK.

handle_client_set_add()

static void handle_client_set_add ( void *  cls, const struct GNUNET_SETU_ElementMessage *  msg  )

static

Called when a client wants to add or remove an element to a set it inhabits.

Parameters

cls	client that sent the message
msg	message sent by the client

Definition at line 4891 of file gnunet-service-setu.c.

{
  struct ClientState *cs = cls;
  struct Set *set;
  struct GNUNET_SETU_Element el;
  struct ElementEntry *ee;
  struct GNUNET_HashCode hash;
 
  if (NULL == (set = cs->set))
  {
    /* client without a set requested an operation */
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (cs->client);
    return;
  }
  GNUNET_SERVICE_client_continue (cs->client);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing mutation on set\n");
  el.size = ntohs (msg->header.size) - sizeof(*msg);
  el.data = &msg[1];
  el.element_type = ntohs (msg->element_type);
  GNUNET_SETU_element_hash (&el,
                            &hash);
  ee = GNUNET_CONTAINER_multihashmap_get (set->content->elements,
                                          &hash);
  if (NULL == ee)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Client inserts element %s of size %u\n",
                GNUNET_h2s (&hash),
                el.size);
    ee = GNUNET_malloc (el.size + sizeof(*ee));
    ee->element.size = el.size;
    GNUNET_memcpy (&ee[1], el.data, el.size);
    ee->element.data = &ee[1];
    ee->element.element_type = el.element_type;
    ee->remote = GNUNET_NO;
    ee->generation = set->current_generation;
    ee->element_hash = hash;
    GNUNET_break (GNUNET_YES ==
                  GNUNET_CONTAINER_multihashmap_put (
                    set->content->elements,
                    &ee->element_hash,
                    ee,
                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Client inserted element %s of size %u twice (ignored)\n",
                GNUNET_h2s (&hash),
                el.size);
    /* same element inserted twice */
    return;
  }
  strata_estimator_insert (set->se,
                           get_ibf_key (&ee->element_hash));
}

References ClientState::client, Set::content, Set::current_generation, GNUNET_SET_Element::data, el, ElementEntry::element, ElementEntry::element_hash, GNUNET_SET_Element::element_type, SetContent::elements, ElementEntry::generation, get_ibf_key(), GNUNET_break, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SETU_element_hash(), GNUNET_YES, msg, ElementEntry::remote, Set::se, ClientState::set, GNUNET_MessageHeader::size, GNUNET_SET_Element::size, and strata_estimator_insert().

Here is the call graph for this function:

advance_generation()

static void advance_generation ( struct Set *  set )

static

Advance the current generation of a set, adding exclusion ranges if necessary.

Parameters

set	the set where we want to advance the generation

Definition at line 4958 of file gnunet-service-setu.c.

{
  set->content->latest_generation++;
  set->current_generation++;
}

References Set::content, Set::current_generation, and SetContent::latest_generation.

Referenced by handle_client_accept(), and handle_client_evaluate().

Here is the caller graph for this function:

check_client_evaluate()

static int check_client_evaluate ( void *  cls, const struct GNUNET_SETU_EvaluateMessage *  msg  )

static

Called when a client wants to initiate a set operation with another peer.

Initiates the CADET connection to the listener and sends the request.

Parameters

cls	client that sent the message
msg	message sent by the client

Returns

GNUNET_OK if the message is well-formed

Definition at line 4975 of file gnunet-service-setu.c.

{
  /* FIXME: suboptimal, even if the context below could be NULL,
     there are malformed messages this does not check for... */
  return GNUNET_OK;
}

References GNUNET_OK.

handle_client_evaluate()

static void handle_client_evaluate ( void *  cls, const struct GNUNET_SETU_EvaluateMessage *  msg  )

static

Called when a client wants to initiate a set operation with another peer.

Initiates the CADET connection to the listener and sends the request.

Parameters

cls	client that sent the message
msg	message sent by the client

Definition at line 4993 of file gnunet-service-setu.c.

{
  struct ClientState *cs = cls;
  struct Operation *op = GNUNET_new (struct Operation);
 
  const struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
    GNUNET_MQ_hd_var_size (incoming_msg,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_OPERATION_REQUEST,
                           struct OperationRequestMessage,
                           op),
    GNUNET_MQ_hd_var_size (union_p2p_ibf,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_IBF,
                           struct IBFMessage,
                           op),
    GNUNET_MQ_hd_var_size (union_p2p_elements,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_ELEMENTS,
                           struct GNUNET_SETU_ElementMessage,
                           op),
    GNUNET_MQ_hd_var_size (union_p2p_offer,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_OFFER,
                           struct GNUNET_MessageHeader,
                           op),
    GNUNET_MQ_hd_var_size (union_p2p_inquiry,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_INQUIRY,
                           struct InquiryMessage,
                           op),
    GNUNET_MQ_hd_var_size (union_p2p_demand,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_DEMAND,
                           struct GNUNET_MessageHeader,
                           op),
    GNUNET_MQ_hd_fixed_size (union_p2p_done,
                             GNUNET_MESSAGE_TYPE_SETU_P2P_DONE,
                             struct GNUNET_MessageHeader,
                             op),
    GNUNET_MQ_hd_fixed_size (union_p2p_over,
                             GNUNET_MESSAGE_TYPE_SETU_P2P_OVER,
                             struct GNUNET_MessageHeader,
                             op),
    GNUNET_MQ_hd_fixed_size (union_p2p_full_done,
                             GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE,
                             struct GNUNET_MessageHeader,
                             op),
    GNUNET_MQ_hd_var_size (union_p2p_request_full,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_REQUEST_FULL,
                           struct TransmitFullMessage,
                           op),
    GNUNET_MQ_hd_var_size (union_p2p_strata_estimator,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_SE,
                           struct StrataEstimatorMessage,
                           op),
    GNUNET_MQ_hd_var_size (union_p2p_strata_estimator,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_SEC,
                           struct StrataEstimatorMessage,
                           op),
    GNUNET_MQ_hd_var_size (union_p2p_full_element,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT,
                           struct GNUNET_SETU_ElementMessage,
                           op),
    GNUNET_MQ_hd_var_size (union_p2p_send_full,
                           GNUNET_MESSAGE_TYPE_SETU_P2P_SEND_FULL,
                           struct TransmitFullMessage,
                           NULL),
    GNUNET_MQ_handler_end ()
  };
  struct Set *set;
  const struct GNUNET_MessageHeader *context;
 
  if (NULL == (set = cs->set))
  {
    GNUNET_break (0);
    GNUNET_free (op);
    GNUNET_SERVICE_client_drop (cs->client);
    return;
  }
  op->salt = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                       UINT32_MAX);
  op->peer = msg->target_peer;
  op->client_request_id = ntohl (msg->request_id);
  op->byzantine = msg->byzantine;
  op->byzantine_lower_bound = ntohl (msg->byzantine_lower_bound);
  op->force_full = msg->force_full;
  op->force_delta = msg->force_delta;
  op->symmetric = msg->symmetric;
  op->rtt_bandwidth_tradeoff = msg->bandwidth_latency_tradeoff;
  op->ibf_bucket_number_factor = msg->ibf_bucket_number_factor;
  op->ibf_number_buckets_per_element = msg->ibf_number_of_buckets_per_element;
  op->byzantine_upper_bound = msg->byzantine_upper_bond;
  op->active_passive_switch_required = false;
  context = GNUNET_MQ_extract_nested_mh (msg);
 
  /* create hashmap for message control */
  op->message_control_flow = GNUNET_CONTAINER_multihashmap_create (32,
                                                                   GNUNET_NO);
  op->inquiries_sent = GNUNET_CONTAINER_multihashmap_create (32,GNUNET_NO);
 
#if MEASURE_PERFORMANCE
  /* load config */
  load_config (op);
#endif
 
  /* Advance generation values, so that
     mutations won't interfere with the running operation. */
  op->set = set;
  op->generation_created = set->current_generation;
  advance_generation (set);
  GNUNET_CONTAINER_DLL_insert (set->ops_head,
                               set->ops_tail,
                               op);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Creating new CADET channel to port %s for set union\n",
              GNUNET_h2s (&msg->app_id));
  op->channel = GNUNET_CADET_channel_create (cadet,
                                             op,
                                             &msg->target_peer,
                                             &msg->app_id,
                                             &channel_window_cb,
                                             &channel_end_cb,
                                             cadet_handlers);
  op->mq = GNUNET_CADET_get_mq (op->channel);
  {
    struct GNUNET_MQ_Envelope *ev;
    struct OperationRequestMessage *msg_tmp;
 
#if MEASURE_PERFORMANCE
    perf_store.operation_request.sent += 1;
#endif
    ev = GNUNET_MQ_msg_nested_mh (msg_tmp,
                                  GNUNET_MESSAGE_TYPE_SETU_P2P_OPERATION_REQUEST,
                                  context);
    if (NULL == ev)
    {
      /* the context message is too large */
      GNUNET_break (0);
      GNUNET_SERVICE_client_drop (cs->client);
      return;
    }
    op->demanded_hashes = GNUNET_CONTAINER_multihashmap_create (32,
                                                                GNUNET_NO);
    /* copy the current generation's strata estimator for this operation */
    op->se = strata_estimator_dup (op->set->se);
    /* we started the operation, thus we have to send the operation request */
    op->phase = PHASE_EXPECT_SE;
 
    op->salt_receive = (op->peer_site + 1) % 2;
    op->salt_send = op->peer_site;     // FIXME?????
 
 
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Initiating union operation evaluation\n");
    GNUNET_STATISTICS_update (_GSS_statistics,
                              "# of total union operations",
                              1,
                              GNUNET_NO);
    GNUNET_STATISTICS_update (_GSS_statistics,
                              "# of initiated union operations",
                              1,
                              GNUNET_NO);
    GNUNET_MQ_send (op->mq,
                    ev);
    if (NULL != context)
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "sent op request with context message\n");
    else
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "sent op request without context message\n");
    initialize_key_to_element (op);
    op->initial_size = GNUNET_CONTAINER_multihashmap32_size (
      op->key_to_element);
 
  }
  GNUNET_SERVICE_client_continue (cs->client);
}

References _GSS_statistics, advance_generation(), cadet, channel_end_cb(), channel_window_cb(), ClientState::client, context, Set::current_generation, GNUNET_break, GNUNET_CADET_channel_create(), GNUNET_CADET_get_mq(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multihashmap32_size(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_SETU_P2P_DEMAND, GNUNET_MESSAGE_TYPE_SETU_P2P_DONE, GNUNET_MESSAGE_TYPE_SETU_P2P_ELEMENTS, GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE, GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT, GNUNET_MESSAGE_TYPE_SETU_P2P_IBF, GNUNET_MESSAGE_TYPE_SETU_P2P_INQUIRY, GNUNET_MESSAGE_TYPE_SETU_P2P_OFFER, GNUNET_MESSAGE_TYPE_SETU_P2P_OPERATION_REQUEST, GNUNET_MESSAGE_TYPE_SETU_P2P_OVER, GNUNET_MESSAGE_TYPE_SETU_P2P_REQUEST_FULL, GNUNET_MESSAGE_TYPE_SETU_P2P_SE, GNUNET_MESSAGE_TYPE_SETU_P2P_SEC, GNUNET_MESSAGE_TYPE_SETU_P2P_SEND_FULL, GNUNET_MQ_extract_nested_mh, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg_nested_mh, GNUNET_MQ_send(), GNUNET_new, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), initialize_key_to_element(), LOG, msg, op, Set::ops_head, Set::ops_tail, PHASE_EXPECT_SE, ClientState::set, and strata_estimator_dup().

Here is the call graph for this function:

handle_client_cancel()

static void handle_client_cancel ( void *  cls, const struct GNUNET_SETU_CancelMessage *  msg  )

static

Handle a request from the client to cancel a running set operation.

Parameters

cls	the client
msg	the message

Definition at line 5175 of file gnunet-service-setu.c.

{
  struct ClientState *cs = cls;
  struct Set *set;
  struct Operation *op;
  int found;
 
  if (NULL == (set = cs->set))
  {
    /* client without a set requested an operation */
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (cs->client);
    return;
  }
  found = GNUNET_NO;
  for (op = set->ops_head; NULL != op; op = op->next)
  {
    if (op->client_request_id == ntohl (msg->request_id))
    {
      found = GNUNET_YES;
      break;
    }
  }
  if (GNUNET_NO == found)
  {
    /* It may happen that the operation was already destroyed due to
     * the other peer disconnecting.  The client may not know about this
     * yet and try to cancel the (just barely non-existent) operation.
     * So this is not a hard error.
     *///
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Client canceled non-existent op %u\n",
                (uint32_t) ntohl (msg->request_id));
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Client requested cancel for op %u\n",
                (uint32_t) ntohl (msg->request_id));
    _GSS_operation_destroy (op);
  }
  GNUNET_SERVICE_client_continue (cs->client);
}

References _GSS_operation_destroy(), ClientState::client, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_YES, msg, GNUNET_ARM_Operation::next, op, Set::ops_head, ClientState::set, and Operation::set.

Here is the call graph for this function:

handle_client_accept()

static void handle_client_accept ( void *  cls, const struct GNUNET_SETU_AcceptMessage *  msg  )

static

Handle a request from the client to accept a set operation that came from a remote peer.

We forward the accept to the associated operation for handling

Parameters

cls	the client
msg	the message

Definition at line 5230 of file gnunet-service-setu.c.

{
  struct ClientState *cs = cls;
  struct Set *set;
  struct Operation *op;
  struct GNUNET_SETU_ResultMessage *result_message;
  struct GNUNET_MQ_Envelope *ev;
  struct Listener *listener;
 
  if (NULL == (set = cs->set))
  {
    /* client without a set requested to accept */
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (cs->client);
    return;
  }
  op = get_incoming (ntohl (msg->accept_reject_id));
  if (NULL == op)
  {
    /* It is not an error if the set op does not exist -- it may
    * have been destroyed when the partner peer disconnected. */
    GNUNET_log (
      GNUNET_ERROR_TYPE_INFO,
      "Client %p accepted request %u of listener %p that is no longer active\n",
      cs,
      ntohl (msg->accept_reject_id),
      cs->listener);
    ev = GNUNET_MQ_msg (result_message,
                        GNUNET_MESSAGE_TYPE_SETU_RESULT);
    result_message->request_id = msg->request_id;
    result_message->result_status = htons (GNUNET_SETU_STATUS_FAILURE);
    GNUNET_MQ_send (set->cs->mq, ev);
    GNUNET_SERVICE_client_continue (cs->client);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client accepting request %u\n",
              (uint32_t) ntohl (msg->accept_reject_id));
  listener = op->listener;
  op->listener = NULL;
  GNUNET_CONTAINER_DLL_remove (listener->op_head,
                               listener->op_tail,
                               op);
  op->set = set;
  GNUNET_CONTAINER_DLL_insert (set->ops_head,
                               set->ops_tail,
                               op);
  op->client_request_id = ntohl (msg->request_id);
  op->byzantine = msg->byzantine;
  op->byzantine_lower_bound = ntohl (msg->byzantine_lower_bound);
  op->force_full = msg->force_full;
  op->force_delta = msg->force_delta;
  op->symmetric = msg->symmetric;
  op->rtt_bandwidth_tradeoff = msg->bandwidth_latency_tradeoff;
  op->ibf_bucket_number_factor = msg->ibf_bucket_number_factor;
  op->ibf_number_buckets_per_element = msg->ibf_number_of_buckets_per_element;
  op->byzantine_upper_bound = msg->byzantine_upper_bond;
  op->active_passive_switch_required = false;
  /* create hashmap for message control */
  op->message_control_flow = GNUNET_CONTAINER_multihashmap_create (32,
                                                                   GNUNET_NO);
  op->inquiries_sent = GNUNET_CONTAINER_multihashmap_create (32,GNUNET_NO);
 
#if MEASURE_PERFORMANCE
  /* load config */
  load_config (op);
#endif
 
  /* Advance generation values, so that future mutations do not
     interfere with the running operation. */
  op->generation_created = set->current_generation;
  advance_generation (set);
  GNUNET_assert (NULL == op->se);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "accepting set union operation\n");
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# of accepted union operations",
                            1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (_GSS_statistics,
                            "# of total union operations",
                            1,
                            GNUNET_NO);
  {
    struct MultiStrataEstimator *se;
    struct GNUNET_MQ_Envelope *ev_tmp;
    struct StrataEstimatorMessage *strata_msg;
    char *buf;
    size_t len;
    uint16_t type;
 
    op->se = strata_estimator_dup (op->set->se);
    op->demanded_hashes = GNUNET_CONTAINER_multihashmap_create (32,
                                                                GNUNET_NO);
    op->salt_receive = (op->peer_site + 1) % 2;
    op->salt_send = op->peer_site;     // FIXME?????
    initialize_key_to_element (op);
    op->initial_size = GNUNET_CONTAINER_multihashmap32_size (
      op->key_to_element);
 
    /* kick off the operation */
    se = op->se;
 
    {
      uint8_t se_count = 1;
      if (op->initial_size > 0)
      {
        op->total_elements_size_local = 0;
        GNUNET_CONTAINER_multihashmap_iterate (op->set->content->elements,
                                               &
                                               determinate_avg_element_size_iterator,
                                               op);
        se_count = determine_strata_count (
          op->total_elements_size_local / op->initial_size,
          op->initial_size);
      }
      buf = GNUNET_malloc (se->stratas[0]->strata_count * IBF_BUCKET_SIZE
                           * ((SE_IBFS_TOTAL_SIZE / 8) * se_count));
      len = strata_estimator_write (se,
                                    SE_IBFS_TOTAL_SIZE,
                                    se_count,
                                    buf);
#if MEASURE_PERFORMANCE
      perf_store.se.sent += 1;
      perf_store.se.sent_var_bytes += len;
#endif
 
      if (len < se->stratas[0]->strata_count * IBF_BUCKET_SIZE
          * SE_IBFS_TOTAL_SIZE)
        type = GNUNET_MESSAGE_TYPE_SETU_P2P_SEC;
      else
        type = GNUNET_MESSAGE_TYPE_SETU_P2P_SE;
      ev_tmp = GNUNET_MQ_msg_extra (strata_msg,
                                    len,
                                    type);
      GNUNET_memcpy (&strata_msg[1],
                     buf,
                     len);
      GNUNET_free (buf);
      strata_msg->set_size
        = GNUNET_htonll (GNUNET_CONTAINER_multihashmap_size (
                           op->set->content->elements));
      strata_msg->se_count = se_count;
      GNUNET_MQ_send (op->mq,
                      ev_tmp);
      op->phase = PHASE_EXPECT_IBF;
    }
  }
  /* Now allow CADET to continue, as we did not do this in
   #handle_incoming_msg (as we wanted to first see if the
     local client would accept the request). */
  GNUNET_CADET_receive_done (op->channel);
  GNUNET_SERVICE_client_continue (cs->client);
}

References _GSS_statistics, advance_generation(), ClientState::client, Listener::cs, Set::cs, Set::current_generation, determinate_avg_element_size_iterator(), determine_strata_count(), get_incoming(), GNUNET_assert, GNUNET_break, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap32_size(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_htonll(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SETU_P2P_SE, GNUNET_MESSAGE_TYPE_SETU_P2P_SEC, GNUNET_MESSAGE_TYPE_SETU_RESULT, GNUNET_MQ_msg, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_SETU_STATUS_FAILURE, GNUNET_STATISTICS_update(), IBF_BUCKET_SIZE, initialize_key_to_element(), ClientState::listener, LOG, ClientState::mq, msg, op, Listener::op_head, Listener::op_tail, Set::ops_head, Set::ops_tail, PHASE_EXPECT_IBF, GNUNET_SETU_ResultMessage::request_id, GNUNET_SETU_ResultMessage::result_status, StrataEstimatorMessage::se_count, SE_IBFS_TOTAL_SIZE, ClientState::set, StrataEstimatorMessage::set_size, StrataEstimator::strata_count, strata_estimator_dup(), strata_estimator_write(), MultiStrataEstimator::stratas, and type.

Here is the call graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Called to clean up, after a shutdown has been requested.

Parameters

cls	closure, NULL

Definition at line 5394 of file gnunet-service-setu.c.

{
  /* Delay actual shutdown to allow service to disconnect clients */
  in_shutdown = GNUNET_YES;
  if (0 == num_clients)
  {
    if (NULL != cadet)
    {
      GNUNET_CADET_disconnect (cadet);
      cadet = NULL;
    }
  }
  GNUNET_STATISTICS_destroy (_GSS_statistics,
                             GNUNET_YES);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "handled shutdown request\n");
#if MEASURE_PERFORMANCE
  calculate_perf_store ();
#endif
}

References _GSS_statistics, cadet, GNUNET_CADET_disconnect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_STATISTICS_destroy(), GNUNET_YES, in_shutdown, and num_clients.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  cfg, struct GNUNET_SERVICE_Handle *  service  )

static

Function called by the service's run method to run service-specific setup code.

Parameters

cls	closure
cfg	configuration to use
service	the initialized service

Definition at line 5425 of file gnunet-service-setu.c.

{
  /* FIXME: need to modify SERVICE (!) API to allow
     us to run a shutdown task *after* clients were
     forcefully disconnected! */
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
  _GSS_statistics = GNUNET_STATISTICS_create ("setu",
                                              cfg);
  cadet = GNUNET_CADET_connect (cfg);
  if (NULL == cadet)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Could not connect to CADET service\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

References _, _GSS_statistics, cadet, cfg, GNUNET_CADET_connect(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), and shutdown_task().

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	GNUNET_OS_project_data_gnunet()	,
		"set"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_fixed_size(client_accept, GNUNET_MESSAGE_TYPE_SETU_ACCEPT, struct GNUNET_SETU_AcceptMessage, NULL)	,
		GNUNET_MQ_hd_var_size(client_set_add, GNUNET_MESSAGE_TYPE_SETU_ADD, struct GNUNET_SETU_ElementMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_create_set, GNUNET_MESSAGE_TYPE_SETU_CREATE, struct GNUNET_SETU_CreateMessage, NULL)	,
		GNUNET_MQ_hd_var_size(client_evaluate, GNUNET_MESSAGE_TYPE_SETU_EVALUATE, struct GNUNET_SETU_EvaluateMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_listen, GNUNET_MESSAGE_TYPE_SETU_LISTEN, struct GNUNET_SETU_ListenMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_reject, GNUNET_MESSAGE_TYPE_SETU_REJECT, struct GNUNET_SETU_RejectMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_cancel, GNUNET_MESSAGE_TYPE_SETU_CANCEL, struct GNUNET_SETU_CancelMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

cadet

struct GNUNET_CADET_Handle* cadet

static

Handle to the cadet service, used to listen for and connect to remote peers.

Definition at line 725 of file gnunet-service-setu.c.

Referenced by client_disconnect_cb(), handle_client_evaluate(), handle_client_listen(), run(), and shutdown_task().

_GSS_statistics

struct GNUNET_STATISTICS_Handle* _GSS_statistics

static

Statistics handle.

Definition at line 730 of file gnunet-service-setu.c.

Referenced by decode_and_send(), handle_client_accept(), handle_client_evaluate(), handle_union_p2p_demand(), handle_union_p2p_elements(), handle_union_p2p_full_element(), handle_union_p2p_strata_estimator(), run(), send_client_done(), send_ibf(), and shutdown_task().

listener_head

struct Listener* listener_head

static

Listeners are held in a doubly linked list.

Definition at line 735 of file gnunet-service-setu.c.

Referenced by client_disconnect_cb(), get_incoming(), and handle_client_listen().

listener_tail

struct Listener* listener_tail

static

Listeners are held in a doubly linked list.

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

Referenced by client_disconnect_cb(), and handle_client_listen().

num_clients

unsigned int num_clients

static

Number of active clients.

Definition at line 745 of file gnunet-service-setu.c.

Referenced by client_connect_cb(), client_disconnect_cb(), and shutdown_task().

in_shutdown

int in_shutdown

static

Are we in shutdown? if GNUNET_YES and the number of clients drops to zero, disconnect from CADET.

Definition at line 751 of file gnunet-service-setu.c.

Referenced by client_disconnect_cb(), and shutdown_task().

suggest_id

uint32_t suggest_id

static

Counter for allocating unique IDs for clients, used to identify incoming operation requests from remote peers, that the client can choose to accept or refuse.

0 must not be used (reserved for uninitialized).

Definition at line 758 of file gnunet-service-setu.c.

Referenced by handle_incoming_msg().