GNUnet  0.11.x
Data Structures | Macros | Enumerations | Functions | Variables
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_applications.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  perf_num_send_resived_msg
 Added Roundtripscounter. More...
 
struct  perf_rtt_struct
 
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_IBF_SIZE   80
 Size of the IBFs in the strata estimator. More...
 
#define SE_IBF_HASH_NUM   4
 The hash num parameter for the difference digests and strata estimators. More...
 
#define MAX_BUCKETS_PER_MESSAGE   ((1 << 15) / IBF_BUCKET_SIZE)
 Number of buckets that can be transmitted in one message. More...
 
#define MAX_IBF_ORDER   (20)
 The maximum size of an ibf we use is 2^(MAX_IBF_ORDER). More...
 
#define IBF_ALPHA   4
 Number of buckets used in the ibf per estimated difference. 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...
 

Functions

static int sum_sent_received_bytes (int size, struct perf_num_send_resived_msg perf_rtt_struct)
 
static float calculate_perf_rtt ()
 
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 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 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 KeyEntryop_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)
 FIXME. 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, uint16_t ibf_order)
 Send an ibf of appropriate size. More...
 
static unsigned int get_order_from_difference (unsigned int diff)
 Compute the necessary order of an ibf from the size of the symmetric set difference. More...
 
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_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 void handle_union_p2p_request_full (void *cls, const struct GNUNET_MessageHeader *mh)
 Handle a request for full set transmission. More...
 
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 Operationget_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 ("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_Handlecadet
 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 Listenerlistener_head
 Listeners are held in a doubly linked list. More...
 
static struct Listenerlistener_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...
 
struct perf_rtt_struct perf_rtt
 

Detailed Description

set union operation

Author
Florian Dold
Christian Grothoff

Definition in file gnunet-service-setu.c.

Macro Definition Documentation

◆ LOG

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

◆ 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.

Referenced by channel_new_cb().

◆ 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.

Referenced by check_union_p2p_strata_estimator(), handle_client_create_set(), and handle_union_p2p_strata_estimator().

◆ SE_IBF_SIZE

#define SE_IBF_SIZE   80

Size of the IBFs in the strata estimator.

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

Referenced by check_union_p2p_strata_estimator(), handle_client_create_set(), and handle_union_p2p_strata_estimator().

◆ SE_IBF_HASH_NUM

#define SE_IBF_HASH_NUM   4

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

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

Referenced by get_order_from_difference(), handle_client_create_set(), handle_union_p2p_ibf(), handle_union_p2p_strata_estimator(), and prepare_ibf().

◆ MAX_BUCKETS_PER_MESSAGE

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

Number of buckets that can be transmitted in one message.

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

Referenced by send_ibf().

◆ MAX_IBF_ORDER

#define MAX_IBF_ORDER   (20)

The maximum size of an ibf we use is 2^(MAX_IBF_ORDER).

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

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

Referenced by decode_and_send(), and get_order_from_difference().

◆ IBF_ALPHA

#define IBF_ALPHA   4

Number of buckets used in the ibf per estimated difference.

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

Referenced by get_order_from_difference().

Enumeration Type Documentation

◆ 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 85 of file gnunet-service-setu.c.

86 {
91 
102 
107 
112 
117 
123 
129 
135 
141 
147 };
After sending the full set, wait for responses with the elements that the local peer is missing...
The other peer is decoding the IBF we just sent.
In the ultimate phase, we wait until our demands are satisfied and then quit (sending another DONE me...
The protocol is almost finished, but we still have to flush our message queue and/or expect some elem...
We sent the strata estimator, and expect an IBF.
Continuation for multi part IBFs.
In the penultimate phase, we wait until all our demands are satisfied.
We are decoding an IBF.
Phase that receives full set first and then sends elements that are the local peer missing...
We sent the request message, and expect a strata estimator.

Function Documentation

◆ sum_sent_received_bytes()

static int sum_sent_received_bytes ( int  size,
struct perf_num_send_resived_msg  perf_rtt_struct 
)
static

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

References perf_num_send_resived_msg::received, perf_num_send_resived_msg::received_var_bytes, perf_num_send_resived_msg::sent, and perf_num_send_resived_msg::sent_var_bytes.

Referenced by calculate_perf_rtt().

672  {
673  return (size * perf_rtt_struct.sent) +
674  (size * perf_rtt_struct.received) +
675  perf_rtt_struct.sent_var_bytes +
676  perf_rtt_struct.received_var_bytes;
677 }
static unsigned int size
Size of the "table".
Definition: peer.c:67
Here is the caller graph for this function:

◆ calculate_perf_rtt()

static float calculate_perf_rtt ( )
static

Calculate RTT of init phase normally always 1

Calculate RGNUNET_SETU_AcceptMessageRT of Fullsync normally 1 or 1.5 depending

In case of a differential sync 3 rtt's are needed. for every active/passive switch additional 3.5 rtt's are used

Calculate data sended size

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

References perf_rtt_struct::demand, perf_rtt_struct::done, perf_rtt_struct::element, perf_rtt_struct::element_full, perf_rtt_struct::full_done, GNUNET_ERROR_TYPE_ERROR, 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_REQUEST_FULL, GNUNET_MESSAGE_TYPE_SETU_P2P_SE, perf_rtt_struct::ibf, perf_rtt_struct::inquery, LOG, perf_rtt_struct::offer, perf_rtt_struct::operation_request, perf_rtt, perf_num_send_resived_msg::received, perf_rtt_struct::request_full, perf_rtt_struct::se, perf_num_send_resived_msg::sent, and sum_sent_received_bytes().

Referenced by shutdown_task().

680  {
684  float rtt = 1;
685  int bytes_transmitted = 0;
686 
690  if (( perf_rtt.element_full.received != 0 ) ||
691  ( perf_rtt.element_full.sent != 0)
692  ) rtt += 1;
693 
694  if (( perf_rtt.request_full.received != 0 ) ||
695  ( perf_rtt.request_full.sent != 0)
696  ) rtt += 0.5;
697 
703  int iterations = perf_rtt.ibf.received;
704  if(iterations > 1)
705  rtt += (iterations - 1 ) * 0.5;
706  rtt += 3 * iterations;
707 
722 
723  LOG(GNUNET_ERROR_TYPE_ERROR,"Bytes Transmitted: %d\n", bytes_transmitted);
724 
725  LOG(GNUNET_ERROR_TYPE_ERROR,"Reached tradeoff bandwidth/rtt: %f\n", (bytes_transmitted / rtt ));
726 
727  return rtt;
728 }
#define GNUNET_MESSAGE_TYPE_SETU_P2P_OPERATION_REQUEST
Request a set union operation from a remote peer.
struct perf_num_send_resived_msg ibf
struct perf_num_send_resived_msg element
#define GNUNET_MESSAGE_TYPE_SETU_P2P_SE
Strata estimator.
#define GNUNET_MESSAGE_TYPE_SETU_P2P_OFFER
Tell the other peer which hashes match a given IBF key.
#define GNUNET_MESSAGE_TYPE_SETU_P2P_DONE
Set operation is done.
struct perf_num_send_resived_msg element_full
struct perf_num_send_resived_msg request_full
struct perf_num_send_resived_msg se
#define GNUNET_MESSAGE_TYPE_SETU_P2P_REQUEST_FULL
Demand the whole element from the other peer, given only the hash code.
struct perf_num_send_resived_msg operation_request
struct perf_num_send_resived_msg demand
struct perf_num_send_resived_msg done
#define GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE
Request all missing elements from the other peer, based on their sets and the elements we previously ...
#define LOG(kind,...)
#define GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT
Send a set element, not as response to a demand but because we&#39;re sending the full set...
static int sum_sent_received_bytes(int size, struct perf_num_send_resived_msg perf_rtt_struct)
struct perf_num_send_resived_msg offer
struct perf_num_send_resived_msg inquery
struct perf_num_send_resived_msg full_done
#define GNUNET_MESSAGE_TYPE_SETU_P2P_IBF
Invertible bloom filter.
#define GNUNET_MESSAGE_TYPE_SETU_P2P_DEMAND
Demand the whole element from the other peer, given only the hash code.
#define GNUNET_MESSAGE_TYPE_SETU_P2P_INQUIRY
Tell the other peer to send us a list of hashes that match an IBF key.
#define GNUNET_MESSAGE_TYPE_SETU_P2P_ELEMENTS
Actual set elements.
struct perf_rtt_struct perf_rtt
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
clsclosure
keycurrent key code
valuevalue in the hash map
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

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

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

Referenced by _GSS_operation_destroy().

745 {
746  struct KeyEntry *k = value;
747 
748  GNUNET_assert (NULL != k);
749  if (GNUNET_YES == k->element->remote)
750  {
751  GNUNET_free (k->element);
752  k->element = NULL;
753  }
754  GNUNET_free (k);
755  return GNUNET_YES;
756 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
The key entry is used to associate an ibf key with an element.
static char * value
Value of the record to add/remove.
int remote
GNUNET_YES if the element is a remote element, and does not belong to the operation&#39;s set...
struct ElementEntry * element
The actual element associated with the key.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsoperation to destroy

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

References Operation::client_done_sent, Operation::client_request_id, Set::cs, 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, Operation::key_to_element, LOG, ClientState::mq, op, Operation::phase, PHASE_FINISHED, GNUNET_SETU_ResultMessage::request_id, GNUNET_SETU_ResultMessage::result_status, and Operation::set.

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

767 {
768  struct Operation *op = cls;
769  struct GNUNET_MQ_Envelope *ev;
770  struct GNUNET_SETU_ResultMessage *rm;
771 
772  if (GNUNET_YES == op->client_done_sent)
773  return;
774  if (PHASE_FINISHED != op->phase)
775  {
777  "Union operation failed\n");
779  "# Union operations failed",
780  1,
781  GNUNET_NO);
784  rm->request_id = htonl (op->client_request_id);
785  rm->element_type = htons (0);
786  GNUNET_MQ_send (op->set->cs->mq,
787  ev);
788  return;
789  }
790 
792 
794  "# Union operations succeeded",
795  1,
796  GNUNET_NO);
798  "Signalling client that union operation is done\n");
799  ev = GNUNET_MQ_msg (rm,
801  rm->request_id = htonl (op->client_request_id);
803  rm->element_type = htons (0);
805  op->key_to_element));
806  GNUNET_MQ_send (op->set->cs->mq,
807  ev);
808 }
enum IntersectionOperationPhase phase
Current state of the operation.
struct GNUNET_MQ_Handle * mq
MQ to talk to client.
In the ultimate phase, we wait until our demands are satisfied and then quit (sending another DONE me...
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
uint32_t request_id
id the result belongs to
Definition: setu.h:255
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
uint16_t element_type
Type of the element attached to the message, if any.
Definition: setu.h:266
The other peer refused to do the operation with us, or something went wrong.
#define GNUNET_MESSAGE_TYPE_SETU_RESULT
Handle result message from operation.
Success, all elements have been sent (and received).
unsigned int GNUNET_CONTAINER_multihashmap32_size(const struct GNUNET_CONTAINER_MultiHashMap32 *map)
Get the number of key-value pairs in the map.
struct Set * set
Set associated with the operation, NULL until the spec has been associated with a set...
uint16_t result_status
Was the evaluation successful? Contains an enum GNUNET_SETU_Status in NBO.
Definition: setu.h:261
#define LOG(kind,...)
struct GNUNET_CONTAINER_MultiHashMap32 * key_to_element
Maps unsalted IBF-Keys to elements.
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:36
uint64_t current_size
Current set size.
Definition: setu.h:250
struct ClientState * cs
Client that owns the set.
int client_done_sent
Did we send the client that we are done?
Operation context used to execute a set operation.
static struct GNUNET_STATISTICS_Handle * _GSS_statistics
Statistics handle.
Message sent by the service to the client to indicate an element that is removed (set intersection) o...
Definition: setu.h:240
uint32_t client_request_id
ID used to identify an operation between service and client.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
Here is the call graph for this function:
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
opoperation to destroy

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

References _GSS_operation_destroy2(), Operation::channel, Operation::context_msg, Operation::demanded_hashes, destroy_key_to_element_iter(), GNUNET_assert, GNUNET_CADET_channel_destroy(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap32_destroy(), GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, ibf_destroy(), Operation::key_to_element, Operation::listener, Operation::local_ibf, op, Operation::remote_ibf, Operation::se, Operation::set, and strata_estimator_destroy().

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

827 {
828  struct Set *set = op->set;
829  struct GNUNET_CADET_Channel *channel;
830 
832  "Destroying union operation %p\n",
833  op);
834  GNUNET_assert (NULL == op->listener);
835  /* check if the op was canceled twice */
836  if (NULL != op->remote_ibf)
837  {
838  ibf_destroy (op->remote_ibf);
839  op->remote_ibf = NULL;
840  }
841  if (NULL != op->demanded_hashes)
842  {
844  op->demanded_hashes = NULL;
845  }
846  if (NULL != op->local_ibf)
847  {
848  ibf_destroy (op->local_ibf);
849  op->local_ibf = NULL;
850  }
851  if (NULL != op->se)
852  {
854  op->se = NULL;
855  }
856  if (NULL != op->key_to_element)
857  {
860  NULL);
862  op->key_to_element = NULL;
863  }
864  if (NULL != set)
865  {
866  GNUNET_CONTAINER_DLL_remove (set->ops_head,
867  set->ops_tail,
868  op);
869  op->set = NULL;
870  }
871  if (NULL != op->context_msg)
872  {
873  GNUNET_free (op->context_msg);
874  op->context_msg = NULL;
875  }
876  if (NULL != (channel = op->channel))
877  {
878  /* This will free op; called conditionally as this helper function
879  is also called from within the channel disconnect handler. */
880  op->channel = NULL;
882  }
883  /* We rely on the channel end handler to free 'op'. When 'op->channel' was NULL,
884  * there was a channel end handler that will free 'op' on the call stack. */
885 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct StrataEstimator * se
Copy of the set&#39;s strata estimator at the time of creation of this operation.
struct GNUNET_MessageHeader * context_msg
Context message, may be NULL.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
struct InvertibleBloomFilter * remote_ibf
The IBF we currently receive.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Opaque handle to a channel.
Definition: cadet.h:116
struct GNUNET_CONTAINER_MultiHashMap * demanded_hashes
Hashes for elements that we have demanded from the other peer.
void strata_estimator_destroy(struct StrataEstimator *se)
Destroy a strata estimator, free all of its resources.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
A set that supports a specific operation with other peers.
struct Set * set
Set associated with the operation, NULL until the spec has been associated with a set...
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...
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
struct GNUNET_CONTAINER_MultiHashMap32 * key_to_element
Maps unsalted IBF-Keys to elements.
void ibf_destroy(struct InvertibleBloomFilter *ibf)
Destroy all resources associated with the invertible bloom filter.
Definition: ibf.c:403
struct GNUNET_CADET_Channel * channel
Channel to the peer.
struct InvertibleBloomFilter * local_ibf
The IBF with the local set&#39;s element.
#define GNUNET_log(kind,...)
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:837
struct Listener * listener
Port this operation runs on.
#define GNUNET_free(ptr)
Wrapper around free.
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 932 of file gnunet-service-setu.c.

References _GSS_operation_destroy(), Operation::channel, GNUNET_CADET_channel_destroy(), GNUNET_free, incoming_destroy(), Operation::listener, send_client_done(), and Operation::set.

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

933 {
934  struct GNUNET_CADET_Channel *channel;
935 
936  if (NULL != (channel = op->channel))
937  {
938  /* This will free op; called conditionally as this helper function
939  is also called from within the channel disconnect handler. */
940  op->channel = NULL;
942  }
943  if (NULL != op->listener)
944  {
945  incoming_destroy (op);
946  return;
947  }
948  if (NULL != op->set)
949  send_client_done (op);
951  GNUNET_free (op);
952 }
Opaque handle to a channel.
Definition: cadet.h:116
static void _GSS_operation_destroy(struct Operation *op)
Destroy the given operation.
static void send_client_done(void *cls)
Signal to the client that the operation has finished and destroy the operation.
struct Set * set
Set associated with the operation, NULL until the spec has been associated with a set...
static void incoming_destroy(struct Operation *op)
Destroy an incoming request from a remote peer.
struct GNUNET_CADET_Channel * channel
Channel to the peer.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:837
struct Listener * listener
Port this operation runs on.
#define GNUNET_free(ptr)
Wrapper around free.
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
opremote request to destroy

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

References _GSS_operation_destroy2(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SCHEDULER_cancel(), Operation::listener, Listener::op_head, Listener::op_tail, and Operation::timeout_task.

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

904 {
905  struct Listener *listener;
906 
908  "Destroying incoming operation %p\n",
909  op);
910  if (NULL != (listener = op->listener))
911  {
913  listener->op_tail,
914  op);
915  op->listener = NULL;
916  }
917  if (NULL != op->timeout_task)
918  {
920  op->timeout_task = NULL;
921  }
923 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct Operation * op_head
Head of DLL of operations this listener is responsible for.
A listener is inhabited by a client, and waits for evaluation requests from remote peers...
static void _GSS_operation_destroy2(struct Operation *op)
This function probably should not exist and be replaced by inlining more specific logic in the variou...
struct GNUNET_SCHEDULER_Task * timeout_task
Timeout task, if the incoming peer has not been accepted after the timeout, it will be disconnected...
#define GNUNET_log(kind,...)
struct Operation * op_tail
Tail of DLL of operations this listener is responsible for.
struct Listener * listener
Port this operation runs on.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972
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
opthe union operation to fail

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

References _GSS_operation_destroy(), Operation::client_request_id, Set::cs, GNUNET_SETU_ResultMessage::element_type, GNUNET_ERROR_TYPE_WARNING, GNUNET_MESSAGE_TYPE_SETU_RESULT, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SETU_STATUS_FAILURE, LOG, ClientState::mq, msg, GNUNET_SETU_ResultMessage::request_id, GNUNET_SETU_ResultMessage::result_status, and Operation::set.

Referenced by decode_and_send(), 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_request_full(), and handle_union_p2p_strata_estimator().

963 {
964  struct GNUNET_MQ_Envelope *ev;
966 
968  "union operation failed\n");
971  msg->request_id = htonl (op->client_request_id);
972  msg->element_type = htons (0);
973  GNUNET_MQ_send (op->set->cs->mq,
974  ev);
976 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Handle * mq
MQ to talk to client.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
uint32_t request_id
id the result belongs to
Definition: setu.h:255
uint16_t element_type
Type of the element attached to the message, if any.
Definition: setu.h:266
static void _GSS_operation_destroy(struct Operation *op)
Destroy the given operation.
The other peer refused to do the operation with us, or something went wrong.
#define GNUNET_MESSAGE_TYPE_SETU_RESULT
Handle result message from operation.
struct Set * set
Set associated with the operation, NULL until the spec has been associated with a set...
uint16_t result_status
Was the evaluation successful? Contains an enum GNUNET_SETU_Status in NBO.
Definition: setu.h:261
#define LOG(kind,...)
struct ClientState * cs
Client that owns the set.
Message sent by the service to the client to indicate an element that is removed (set intersection) o...
Definition: setu.h:240
uint32_t client_request_id
ID used to identify an operation between service and client.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
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
srcthe hash code
Returns
the derived IBF key

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

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

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

988 {
989  struct IBF_Key key;
990  uint16_t salt = 0;
991 
993  GNUNET_CRYPTO_kdf (&key, sizeof(key),
994  src, sizeof *src,
995  &salt, sizeof(salt),
996  NULL, 0));
997  return key;
998 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_kdf(void *result, size_t out_len, const void *xts, size_t xts_len, const void *skm, size_t skm_len,...)
Derive key.
Definition: crypto_kdf.c:90
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_CRYPTO_PowSalt salt
Salt for PoW calcualations.
Keys that can be inserted into and removed from an IBF.
Definition: ibf.h:45
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
clsclosure
keycurrent key code
valuevalue in the hash map
Returns
GNUNET_YES if we should search further, GNUNET_NO if we've found the element.

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

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

Referenced by op_get_element().

1032 {
1033  struct GetElementContext *ctx = cls;
1034  struct KeyEntry *k = value;
1035 
1036  GNUNET_assert (NULL != k);
1038  &ctx->hash))
1039  {
1040  ctx->k = k;
1041  return GNUNET_NO;
1042  }
1043  return GNUNET_YES;
1044 }
Context for op_get_element_iterator.
struct GNUNET_HashCode element_hash
Hash of the element.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct KeyEntry * k
FIXME.
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
The key entry is used to associate an ibf key with an element.
static char * value
Value of the record to add/remove.
struct ElementEntry * element
The actual element associated with the key.
int GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
Compare function for HashCodes, producing a total ordering of all hashcodes.
Definition: crypto_hash.c:201
struct GNUNET_HashCode hash
FIXME.
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
opoperation that should be tested for 'element_hash'
element_hashhash of the element to look for
Returns
GNUNET_YES if the element has been found, GNUNET_NO otherwise

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

References ElementEntry::element_hash, get_ibf_key(), GNUNET_assert, GNUNET_CONTAINER_multihashmap32_get_multiple(), GNUNET_SYSERR, GetElementContext::hash, GetElementContext::k, Operation::key_to_element, IBF_Key::key_val, op_get_element_iterator(), and ret.

Referenced by handle_union_p2p_elements(), and handle_union_p2p_full_element().

1058 {
1059  int ret;
1060  struct IBF_Key ibf_key;
1061  struct GetElementContext ctx = { { { 0 } }, 0 };
1062 
1063  ctx.hash = *element_hash;
1064 
1065  ibf_key = get_ibf_key (element_hash);
1067  (uint32_t) ibf_key.key_val,
1069  &ctx);
1070 
1071  /* was the iteration aborted because we found the element? */
1072  if (GNUNET_SYSERR == ret)
1073  {
1074  GNUNET_assert (NULL != ctx.k);
1075  return ctx.k;
1076  }
1077  return NULL;
1078 }
Context for op_get_element_iterator.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
struct KeyEntry * k
FIXME.
int GNUNET_CONTAINER_multihashmap32_get_multiple(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
static struct GNUNET_DNSSTUB_Context * ctx
Context for DNS resolution.
static struct IBF_Key get_ibf_key(const struct GNUNET_HashCode *src)
Derive the IBF key from a hash code and a salt.
struct GNUNET_CONTAINER_MultiHashMap32 * key_to_element
Maps unsalted IBF-Keys to elements.
static int op_get_element_iterator(void *cls, uint32_t key, void *value)
Iterator over the mapping from IBF keys to element entries.
Keys that can be inserted into and removed from an IBF.
Definition: ibf.h:45
struct GNUNET_HashCode hash
FIXME.
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
opthe union operation
eethe element entry
receivedwas this element received from the remote peer?

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

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, Operation::key_to_element, IBF_Key::key_val, and KeyEntry::received.

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

1099 {
1100  struct IBF_Key ibf_key;
1101  struct KeyEntry *k;
1102 
1103  ibf_key = get_ibf_key (&ee->element_hash);
1104  k = GNUNET_new (struct KeyEntry);
1105  k->element = ee;
1106  k->ibf_key = ibf_key;
1107  k->received = received;
1110  (uint32_t) ibf_key.key_val,
1111  k,
1113 }
int received
Did we receive this element? Even if element->is_foreign is false, we might have received the element...
struct GNUNET_HashCode element_hash
Hash of the element.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
uint64_t key_val
Definition: ibf.h:47
int GNUNET_CONTAINER_multihashmap32_put(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
The key entry is used to associate an ibf key with an element.
static struct IBF_Key get_ibf_key(const struct GNUNET_HashCode *src)
Derive the IBF key from a hash code and a salt.
struct IBF_Key ibf_key
IBF key for the entry, derived from the current salt.
struct ElementEntry * element
The actual element associated with the key.
struct GNUNET_CONTAINER_MultiHashMap32 * key_to_element
Maps unsalted IBF-Keys to elements.
Allow multiple values with the same key.
Keys that can be inserted into and removed from an IBF.
Definition: ibf.h:45
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 1121 of file gnunet-service-setu.c.

References IBF_Key::key_val.

Referenced by prepare_ibf_iterator().

1124 {
1125  int s = salt % 64;
1126  uint64_t x = k_in->key_val;
1127 
1128  /* rotate ibf key */
1129  x = (x >> s) | (x << (64 - s));
1130  k_out->key_val = x;
1131 }
uint64_t key_val
Definition: ibf.h:47
static struct GNUNET_CRYPTO_PowSalt salt
Salt for PoW calcualations.
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

FIXME.

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

References IBF_Key::key_val.

Referenced by decode_and_send(), and handle_union_p2p_inquiry().

1141 {
1142  int s = salt % 64;
1143  uint64_t x = k_in->key_val;
1144 
1145  x = (x << s) | (x >> (64 - s));
1146  k_out->key_val = x;
1147 }
uint64_t key_val
Definition: ibf.h:47
static struct GNUNET_CRYPTO_PowSalt salt
Salt for PoW calcualations.
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
clsthe ibf
keyunused
valuethe key entry to get the key from

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

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

Referenced by prepare_ibf().

1161 {
1162  struct Operation *op = cls;
1163  struct KeyEntry *ke = value;
1164  struct IBF_Key salted_key;
1165 
1167  "[OP %p] inserting %lx (hash %s) into ibf\n",
1168  op,
1169  (unsigned long) ke->ibf_key.key_val,
1170  GNUNET_h2s (&ke->element->element_hash));
1171  salt_key (&ke->ibf_key,
1172  op->salt_send,
1173  &salted_key);
1174  ibf_insert (op->local_ibf, salted_key);
1175  return GNUNET_YES;
1176 }
struct GNUNET_HashCode element_hash
Hash of the element.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
uint64_t key_val
Definition: ibf.h:47
The key entry is used to associate an ibf key with an element.
static char * value
Value of the record to add/remove.
struct IBF_Key ibf_key
IBF key for the entry, derived from the current salt.
struct ElementEntry * element
The actual element associated with the key.
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.
#define LOG(kind,...)
Operation context used to execute a set operation.
void ibf_insert(struct InvertibleBloomFilter *ibf, struct IBF_Key key)
Insert a key into an IBF.
Definition: ibf.c:167
struct InvertibleBloomFilter * local_ibf
The IBF with the local set&#39;s element.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
Keys that can be inserted into and removed from an IBF.
Definition: ibf.h:45
uint32_t salt_send
Salt that we&#39;re using for sending IBFs.
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
eeelement to test
opoperation the defines the set and its generation
Returns
GNUNET_YES if the element is in the set, GNUNET_NO if not

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

References ElementEntry::generation, and Operation::generation_created.

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

1189 {
1190  return ee->generation >= op->generation_created;
1191 }
unsigned int generation_created
Generation in which the operation handle was created.
unsigned int generation
First generation that includes this element.
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
clsthe union operation struct Operation *
keyunused
valuethe struct ElementEntry * to insert into the key-to-element mapping
Returns
GNUNET_YES (to continue iterating)

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

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

Referenced by initialize_key_to_element().

1208 {
1209  struct Operation *op = cls;
1210  struct ElementEntry *ee = value;
1211 
1212  /* make sure that the element belongs to the set at the time
1213  * of creating the operation */
1214  if (GNUNET_NO ==
1216  op))
1217  return GNUNET_YES;
1218  GNUNET_assert (GNUNET_NO == ee->remote);
1219  op_register_element (op,
1220  ee,
1221  GNUNET_NO);
1222  return GNUNET_YES;
1223 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static char * value
Value of the record to add/remove.
Information about an element element in the set.
int remote
GNUNET_YES if the element is a remote element, and does not belong to the operation&#39;s set...
Operation context used to execute a set operation.
static void op_register_element(struct Operation *op, struct ElementEntry *ee, int received)
Insert an element into the union operation&#39;s key-to-element mapping.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
static int _GSS_is_element_of_operation(struct ElementEntry *ee, struct Operation *op)
Is element ee part of the set used by op?
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
opthe set union operation

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

References Set::content, SetContent::elements, GNUNET_assert, GNUNET_CONTAINER_multihashmap32_create(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), init_key_to_element_iterator(), Operation::key_to_element, len, and Operation::set.

Referenced by handle_client_accept(), and handle_client_evaluate().

1233 {
1234  unsigned int len;
1235 
1236  GNUNET_assert (NULL == op->key_to_element);
1241  op);
1242 }
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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.
struct GNUNET_CONTAINER_MultiHashMap * elements
Maps struct GNUNET_HashCode * to struct ElementEntry *.
struct Set * set
Set associated with the operation, NULL until the spec has been associated with a set...
struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
Create a 32-bit key multi hash map.
struct GNUNET_CONTAINER_MultiHashMap32 * key_to_element
Maps unsalted IBF-Keys to elements.
struct SetContent * content
Content, possibly shared by multiple sets, and thus reference counted.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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
opthe union operation
sizesize of the ibf to create
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

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

References GNUNET_assert, GNUNET_CONTAINER_multihashmap32_iterate(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, ibf_create(), ibf_destroy(), Operation::key_to_element, Operation::local_ibf, prepare_ibf_iterator(), and SE_IBF_HASH_NUM.

Referenced by decode_and_send(), and send_ibf().

1256 {
1257  GNUNET_assert (NULL != op->key_to_element);
1258 
1259  if (NULL != op->local_ibf)
1260  ibf_destroy (op->local_ibf);
1262  if (NULL == op->local_ibf)
1263  {
1265  "Failed to allocate local IBF\n");
1266  return GNUNET_SYSERR;
1267  }
1270  op);
1271  return GNUNET_OK;
1272 }
static int prepare_ibf_iterator(void *cls, uint32_t key, void *value)
Insert a key into an ibf.
#define SE_IBF_HASH_NUM
The hash num parameter for the difference digests and strata estimators.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_CONTAINER_MultiHashMap32 * key_to_element
Maps unsalted IBF-Keys to elements.
static unsigned int size
Size of the "table".
Definition: peer.c:67
void ibf_destroy(struct InvertibleBloomFilter *ibf)
Destroy all resources associated with the invertible bloom filter.
Definition: ibf.c:403
struct InvertibleBloomFilter * ibf_create(uint32_t size, uint8_t hash_num)
Create an invertible bloom filter.
Definition: ibf.c:79
struct InvertibleBloomFilter * local_ibf
The IBF with the local set&#39;s element.
#define GNUNET_log(kind,...)
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,
uint16_t  ibf_order 
)
static

Send an ibf of appropriate size.

Fragments the IBF into multiple messages if necessary.

Parameters
opthe union operation
ibf_orderorder of the ibf to send, size=2^order
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

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

References 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, perf_rtt_struct::ibf, IBF_BUCKET_SIZE, ibf_write_slice(), Operation::local_ibf, LOG, MAX_BUCKETS_PER_MESSAGE, Operation::mq, msg, name, IBFMessage::offset, IBFMessage::order, perf_rtt, Operation::phase, PHASE_PASSIVE_DECODING, prepare_ibf(), IBFMessage::reserved1, IBFMessage::reserved2, IBFMessage::salt, Operation::salt_send, perf_num_send_resived_msg::sent, and perf_num_send_resived_msg::sent_var_bytes.

Referenced by decode_and_send(), and handle_union_p2p_strata_estimator().

1287 {
1288  unsigned int buckets_sent = 0;
1289  struct InvertibleBloomFilter *ibf;
1290 
1291  if (GNUNET_OK !=
1292  prepare_ibf (op, 1 << ibf_order))
1293  {
1294  /* allocation failed */
1295  return GNUNET_SYSERR;
1296  }
1297 
1299  "sending ibf of size %u\n",
1300  1 << ibf_order);
1301 
1302  {
1303  char name[64];
1304  GNUNET_snprintf (name, sizeof(name), "# sent IBF (order %u)", ibf_order);
1306  }
1307 
1308  ibf = op->local_ibf;
1309 
1310  while (buckets_sent < (1 << ibf_order))
1311  {
1312  unsigned int buckets_in_message;
1313  struct GNUNET_MQ_Envelope *ev;
1314  struct IBFMessage *msg;
1315 
1316  buckets_in_message = (1 << ibf_order) - buckets_sent;
1317  /* limit to maximum */
1318  if (buckets_in_message > MAX_BUCKETS_PER_MESSAGE)
1319  buckets_in_message = MAX_BUCKETS_PER_MESSAGE;
1320 
1321  perf_rtt.ibf.sent += 1;
1322  perf_rtt.ibf.sent_var_bytes += ( buckets_in_message * IBF_BUCKET_SIZE );
1323  ev = GNUNET_MQ_msg_extra (msg,
1324  buckets_in_message * IBF_BUCKET_SIZE,
1326  msg->reserved1 = 0;
1327  msg->reserved2 = 0;
1328  msg->order = ibf_order;
1329  msg->offset = htonl (buckets_sent);
1330  msg->salt = htonl (op->salt_send);
1331  ibf_write_slice (ibf, buckets_sent,
1332  buckets_in_message, &msg[1]);
1333  buckets_sent += buckets_in_message;
1335  "ibf chunk size %u, %u/%u sent\n",
1336  buckets_in_message,
1337  buckets_sent,
1338  1 << ibf_order);
1339  GNUNET_MQ_send (op->mq, ev);
1340  }
1341 
1342  /* The other peer must decode the IBF, so
1343  * we're passive. */
1345  return GNUNET_OK;
1346 }
uint32_t offset
Offset of the strata in the rest of the message.
struct perf_num_send_resived_msg ibf
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
enum IntersectionOperationPhase phase
Current state of the operation.
uint8_t reserved1
Padding, must be 0.
Message containing buckets of an invertible bloom filter.
The other peer is decoding the IBF we just sent.
Invertible bloom filter (IBF).
Definition: ibf.h:82
void ibf_write_slice(const struct InvertibleBloomFilter *ibf, uint32_t start, uint32_t count, void *buf)
Write buckets from an ibf to a buffer.
Definition: ibf.c:290
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
int GNUNET_snprintf(char *buf, size_t size, const char *format,...) __attribute__((format(printf
Like snprintf, just aborts if the buffer is of insufficient size.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
#define MAX_BUCKETS_PER_MESSAGE
Number of buckets that can be transmitted in one message.
uint8_t order
Order of the whole ibf, where num_buckets = 2^order.
#define IBF_BUCKET_SIZE
Size of one ibf bucket in bytes.
Definition: ibf.h:72
#define LOG(kind,...)
uint16_t reserved2
Padding, must be 0.
static struct GNUNET_STATISTICS_Handle * _GSS_statistics
Statistics handle.
uint32_t salt
Salt used when hashing elements for this IBF.
const char * name
struct InvertibleBloomFilter * local_ibf
The IBF with the local set&#39;s element.
#define GNUNET_MESSAGE_TYPE_SETU_P2P_IBF
Invertible bloom filter.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
static int prepare_ibf(struct Operation *op, uint32_t size)
Create an ibf with the operation&#39;s elements of the specified size.
uint32_t salt_send
Salt that we&#39;re using for sending IBFs.
struct GNUNET_MQ_Handle * mq
Message queue for the channel.
struct perf_rtt_struct perf_rtt
Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_order_from_difference()

static unsigned int get_order_from_difference ( unsigned int  diff)
static

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

Parameters
diffthe difference
Returns
the required size of the ibf

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

References IBF_ALPHA, MAX_IBF_ORDER, and SE_IBF_HASH_NUM.

Referenced by handle_union_p2p_strata_estimator().

1358 {
1359  unsigned int ibf_order;
1360 
1361  ibf_order = 2;
1362  while (((1 << ibf_order) < (IBF_ALPHA * diff) ||
1363  ((1 << ibf_order) < SE_IBF_HASH_NUM)) &&
1364  (ibf_order < MAX_IBF_ORDER))
1365  ibf_order++;
1366  // add one for correction
1367  return ibf_order + 1;
1368 }
#define SE_IBF_HASH_NUM
The hash num parameter for the difference digests and strata estimators.
#define IBF_ALPHA
Number of buckets used in the ibf per estimated difference.
#define MAX_IBF_ORDER
The maximum size of an ibf we use is 2^(MAX_IBF_ORDER).
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
clsthe union operation struct Operation *
keyunused
valuethe 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.

References GNUNET_SETU_Element::data, el, ElementEntry::element, perf_rtt_struct::element_full, GNUNET_SETU_Element::element_type, 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, LOG, Operation::mq, perf_rtt, perf_num_send_resived_msg::received, perf_num_send_resived_msg::received_var_bytes, GNUNET_SETU_Element::size, and value.

Referenced by send_full_set().

1384 {
1385  struct Operation *op = cls;
1386  struct GNUNET_SETU_ElementMessage *emsg;
1387  struct ElementEntry *ee = value;
1388  struct GNUNET_SETU_Element *el = &ee->element;
1389  struct GNUNET_MQ_Envelope *ev;
1390 
1392  "Sending element %s\n",
1393  GNUNET_h2s (key));
1396  ev = GNUNET_MQ_msg_extra (emsg,
1397  el->size,
1399  emsg->element_type = htons (el->element_type);
1400  GNUNET_memcpy (&emsg[1],
1401  el->data,
1402  el->size);
1403  GNUNET_MQ_send (op->mq,
1404  ev);
1405  return GNUNET_YES;
1406 }
const void * data
Actual data of the element.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
struct perf_num_send_resived_msg element_full
uint16_t element_type
Type of the element to add or remove.
Definition: setu.h:286
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
static char * value
Value of the record to add/remove.
Information about an element element in the set.
uint16_t element_type
Application-specific element type.
#define LOG(kind,...)
#define GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT
Send a set element, not as response to a demand but because we&#39;re sending the full set...
Message sent by client to the service to add an element to the set.
Definition: setu.h:276
Operation context used to execute a set operation.
struct GNUNET_SET_Element element
The actual element.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
static struct GNUNET_IDENTITY_EgoLookup * el
EgoLookup.
Definition: gnunet-abd.c:51
uint16_t size
Number of bytes in the buffer pointed to by data.
struct GNUNET_MQ_Handle * mq
Message queue for the channel.
struct perf_rtt_struct perf_rtt
Element stored in a 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
opoperation to switch to full set transmission.

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

References Set::content, SetContent::elements, perf_rtt_struct::full_done, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE, GNUNET_MQ_msg_header, GNUNET_MQ_send(), LOG, Operation::mq, perf_rtt, Operation::phase, PHASE_FULL_SENDING, send_full_element_iterator(), perf_num_send_resived_msg::sent, and Operation::set.

Referenced by handle_union_p2p_request_full(), and handle_union_p2p_strata_estimator().

1416 {
1417  struct GNUNET_MQ_Envelope *ev;
1418 
1419  op->phase = PHASE_FULL_SENDING;
1421  "Dedicing to transmit the full set\n");
1422  /* FIXME: use a more memory-friendly way of doing this with an
1423  iterator, just as we do in the non-full case! */
1426  op);
1427  perf_rtt.full_done.sent += 1;
1429  GNUNET_MQ_send (op->mq,
1430  ev);
1431 }
After sending the full set, wait for responses with the elements that the local peer is missing...
enum IntersectionOperationPhase phase
Current state of the operation.
struct GNUNET_CONTAINER_MultiHashMap * elements
Maps struct GNUNET_HashCode * to struct ElementEntry *.
static int send_full_element_iterator(void *cls, const struct GNUNET_HashCode *key, void *value)
Send a set element.
struct Set * set
Set associated with the operation, NULL until the spec has been associated with a set...
#define GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE
Request all missing elements from the other peer, based on their sets and the elements we previously ...
#define LOG(kind,...)
#define GNUNET_MQ_msg_header(type)
Allocate a GNUNET_MQ_Envelope, where the message only consists of a header.
Definition: gnunet_mq_lib.h:76
struct SetContent * content
Content, possibly shared by multiple sets, and thus reference counted.
struct perf_num_send_resived_msg full_done
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_MQ_Handle * mq
Message queue for the channel.
struct perf_rtt_struct perf_rtt
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
clsthe union operation
msgthe message

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

References GNUNET_break, GNUNET_MESSAGE_TYPE_SETU_P2P_SEC, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, StrataEstimatorMessage::header, IBF_BUCKET_SIZE, len, Operation::phase, PHASE_EXPECT_SE, SE_IBF_SIZE, SE_STRATA_COUNT, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

1443 {
1444  struct Operation *op = cls;
1445  int is_compressed;
1446  size_t len;
1447 
1448  if (op->phase != PHASE_EXPECT_SE)
1449  {
1450  GNUNET_break (0);
1451  return GNUNET_SYSERR;
1452  }
1453  is_compressed = (GNUNET_MESSAGE_TYPE_SETU_P2P_SEC == htons (
1454  msg->header.type));
1455  len = ntohs (msg->header.size) - sizeof(struct StrataEstimatorMessage);
1456  if ((GNUNET_NO == is_compressed) &&
1458  {
1459  GNUNET_break (0);
1460  return GNUNET_SYSERR;
1461  }
1462  return GNUNET_OK;
1463 }
enum IntersectionOperationPhase phase
Current state of the operation.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE(C)
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define SE_IBF_SIZE
Size of the IBFs in the strata estimator.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_MESSAGE_TYPE_SETU_P2P_SEC
Compressed strata estimator.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
#define IBF_BUCKET_SIZE
Size of one ibf bucket in bytes.
Definition: ibf.h:72
Strata estimator together with the peer&#39;s overall set size.
Operation context used to execute a set operation.
#define SE_STRATA_COUNT
Number of IBFs in a strata estimator.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
We sent the request message, and expect a strata estimator.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...

◆ 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
clsthe union operation
msgthe message

Added rtt_bandwidth_tradeoff directly need future improvements

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

References Operation::byzantine, Operation::channel, removetrailingwhitespace::f, fail_union_operation(), Operation::force_full, get_order_from_difference(), getenv(), GNUNET_assert, GNUNET_break, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSAGE_TYPE_SETU_P2P_REQUEST_FULL, GNUNET_MESSAGE_TYPE_SETU_P2P_SEC, GNUNET_MQ_msg_header, GNUNET_MQ_send(), GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_YES, StrataEstimatorMessage::header, Operation::initial_size, len, LOG, Operation::mq, perf_rtt, Operation::phase, PHASE_FULL_RECEIVING, perf_num_send_resived_msg::received, perf_num_send_resived_msg::received_var_bytes, perf_rtt_struct::request_full, Operation::rtt_bandwidth_tradeoff, Operation::se, perf_rtt_struct::se, SE_IBF_HASH_NUM, SE_IBF_SIZE, SE_STRATA_COUNT, send_full_set(), send_ibf(), perf_num_send_resived_msg::sent, StrataEstimatorMessage::set_size, GNUNET_MessageHeader::size, strata_estimator_create(), strata_estimator_destroy(), strata_estimator_difference(), strata_estimator_read(), and GNUNET_MessageHeader::type.

1475 {
1476  perf_rtt.se.received += 1;
1477  perf_rtt.se.received_var_bytes += ntohs (msg->header.size) - sizeof(struct StrataEstimatorMessage);
1478  struct Operation *op = cls;
1479  struct StrataEstimator *remote_se;
1480  unsigned int diff;
1481  uint64_t other_size;
1482  size_t len;
1483  int is_compressed;
1484 
1485  is_compressed = (GNUNET_MESSAGE_TYPE_SETU_P2P_SEC == htons (
1486  msg->header.type));
1488  "# bytes of SE received",
1489  ntohs (msg->header.size),
1490  GNUNET_NO);
1491  len = ntohs (msg->header.size) - sizeof(struct StrataEstimatorMessage);
1492  other_size = GNUNET_ntohll (msg->set_size);
1494  SE_IBF_SIZE,
1495  SE_IBF_HASH_NUM);
1496  if (NULL == remote_se)
1497  {
1498  /* insufficient resources, fail */
1499  fail_union_operation (op);
1500  return;
1501  }
1502  if (GNUNET_OK !=
1503  strata_estimator_read (&msg[1],
1504  len,
1505  is_compressed,
1506  remote_se))
1507  {
1508  /* decompression failed */
1509  strata_estimator_destroy (remote_se);
1510  fail_union_operation (op);
1511  return;
1512  }
1513  GNUNET_assert (NULL != op->se);
1514  diff = strata_estimator_difference (remote_se,
1515  op->se);
1516 
1517  if (diff > 200)
1518  diff = diff * 3 / 2;
1519 
1520  strata_estimator_destroy (remote_se);
1522  op->se = NULL;
1524  "got se diff=%d, using ibf size %d\n",
1525  diff,
1526  1U << get_order_from_difference (diff));
1527 
1528  {
1529  char *set_debug;
1530 
1531  set_debug = getenv ("GNUNET_SETU_BENCHMARK");
1532  if ((NULL != set_debug) &&
1533  (0 == strcmp (set_debug, "1")))
1534  {
1535  FILE *f = fopen ("set.log", "a");
1536  fprintf (f, "%llu\n", (unsigned long long) diff);
1537  fclose (f);
1538  }
1539  }
1540 
1541  if ((GNUNET_YES == op->byzantine) &&
1542  (other_size < op->byzantine_lower_bound))
1543  {
1544  GNUNET_break (0);
1545  fail_union_operation (op);
1546  return;
1547  }
1548 
1550  "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx: %f\n", op->rtt_bandwidth_tradeoff);
1551 
1552 
1556  if ((GNUNET_YES == op->force_full) ||
1557  (diff > op->initial_size / 4) ||
1558  (0 == other_size))
1559  {
1561  "Deciding to go for full set transmission (diff=%d, own set=%llu)\n",
1562  diff,
1563  (unsigned long long) op->initial_size);
1565  "# of full sends",
1566  1,
1567  GNUNET_NO);
1568  if ((op->initial_size <= other_size) ||
1569  (0 == other_size))
1570  {
1571  send_full_set (op);
1572  }
1573  else
1574  {
1575  struct GNUNET_MQ_Envelope *ev;
1576 
1578  "Telling other peer that we expect its full set\n");
1580  perf_rtt.request_full.sent += 1;
1581  ev = GNUNET_MQ_msg_header (
1583  GNUNET_MQ_send (op->mq,
1584  ev);
1585  }
1586  }
1587  else
1588  {
1590  "# of ibf sends",
1591  1,
1592  GNUNET_NO);
1593  if (GNUNET_OK !=
1594  send_ibf (op,
1595  get_order_from_difference (diff)))
1596  {
1597  /* Internal error, best we can do is shut the connection */
1599  "Failed to send IBF, closing connection\n");
1600  fail_union_operation (op);
1601  return;
1602  }
1603  }
1605 }
struct StrataEstimator * se
Copy of the set&#39;s strata estimator at the time of creation of this operation.
static void send_full_set(struct Operation *op)
Switch to full set transmission for op.
#define SE_IBF_HASH_NUM
The hash num parameter for the difference digests and strata estimators.
enum IntersectionOperationPhase phase
Current state of the operation.
struct StrataEstimator * strata_estimator_create(unsigned int strata_count, uint32_t ibf_size, uint8_t ibf_hashnum)
Create a new strata estimator with the given parameters.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_SET_UNION_P2P_SE(C)
uint64_t initial_size
Initial size of our set, just before the operation started.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static int send_ibf(struct Operation *op, uint16_t ibf_order)
Send an ibf of appropriate size.
#define SE_IBF_SIZE
Size of the IBFs in the strata estimator.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct perf_num_send_resived_msg request_full
A handle to a strata estimator.
struct perf_num_send_resived_msg se
#define GNUNET_MESSAGE_TYPE_SETU_P2P_SEC
Compressed strata estimator.
static void fail_union_operation(struct Operation *op)
Inform the client that the union operation has failed, and proceed to destroy the evaluate operation...
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
#define GNUNET_MESSAGE_TYPE_SETU_P2P_REQUEST_FULL
Demand the whole element from the other peer, given only the hash code.
void strata_estimator_destroy(struct StrataEstimator *se)
Destroy a strata estimator, free all of its resources.
#define LOG(kind,...)
int strata_estimator_read(const void *buf, size_t buf_len, int is_compressed, struct StrataEstimator *se)
Read strata from the buffer into the given strata estimator.
int byzantine
GNUNET_YES to fail operations where Byzantine faults are suspected
char * getenv()
Strata estimator together with the peer&#39;s overall set size.
unsigned int strata_estimator_difference(const struct StrataEstimator *se1, const struct StrataEstimator *se2)
Estimate set difference with two strata estimators, i.e.
Operation context used to execute a set operation.
#define GNUNET_MQ_msg_header(type)
Allocate a GNUNET_MQ_Envelope, where the message only consists of a header.
Definition: gnunet_mq_lib.h:76
static struct GNUNET_STATISTICS_Handle * _GSS_statistics
Statistics handle.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
struct GNUNET_CADET_Channel * channel
Channel to the peer.
#define GNUNET_log(kind,...)
#define SE_STRATA_COUNT
Number of IBFs in a strata estimator.
Phase that receives full set first and then sends elements that are the local peer missing...
static unsigned int get_order_from_difference(unsigned int diff)
Compute the necessary order of an ibf from the size of the symmetric set difference.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
double rtt_bandwidth_tradeoff
User defined Bandwidth Round Trips Tradeoff.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
struct GNUNET_MQ_Handle * mq
Message queue for the channel.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
struct perf_rtt_struct perf_rtt
int force_full
Always send full sets, even if delta operations would be more efficient.
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
clsclosure with the element key and the union operation
keyignored
valuethe key entry

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

References KeyEntry::element, ElementEntry::element_hash, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_MESSAGE_TYPE_SETU_P2P_OFFER, GNUNET_MQ_msg_header_extra, GNUNET_MQ_send(), GNUNET_YES, KeyEntry::ibf_key, SendElementClosure::ibf_key, IBF_Key::key_val, LOG, mh, Operation::mq, perf_rtt_struct::offer, SendElementClosure::op, perf_rtt, perf_num_send_resived_msg::sent, perf_num_send_resived_msg::sent_var_bytes, and value.

Referenced by send_offers_for_key().

1619 {
1620  struct SendElementClosure *sec = cls;
1621  struct Operation *op = sec->op;
1622  struct KeyEntry *ke = value;
1623  struct GNUNET_MQ_Envelope *ev;
1624  struct GNUNET_MessageHeader *mh;
1625 
1626  /* Detect 32-bit key collision for the 64-bit IBF keys. */
1627  if (ke->ibf_key.key_val != sec->ibf_key.key_val)
1628  return GNUNET_YES;
1629 
1630  perf_rtt.offer.sent += 1;
1631  perf_rtt.offer.sent_var_bytes += sizeof(struct GNUNET_HashCode);
1632 
1633  ev = GNUNET_MQ_msg_header_extra (mh,
1634  sizeof(struct GNUNET_HashCode),
1636 
1637  GNUNET_assert (NULL != ev);
1638  *(struct GNUNET_HashCode *) &mh[1] = ke->element->element_hash;
1640  "[OP %p] sending element offer (%s) to peer\n",
1641  op,
1642  GNUNET_h2s (&ke->element->element_hash));
1643  GNUNET_MQ_send (op->mq, ev);
1644  return GNUNET_YES;
1645 }
struct Operation * op
Operation for which the elements should be sent.
struct GNUNET_HashCode element_hash
Hash of the element.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
#define GNUNET_MESSAGE_TYPE_SETU_P2P_OFFER
Tell the other peer which hashes match a given IBF key.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
uint64_t key_val
Definition: ibf.h:47
The key entry is used to associate an ibf key with an element.
static char * value
Value of the record to add/remove.
struct IBF_Key ibf_key
IBF key for the entry, derived from the current salt.
struct ElementEntry * element
The actual element associated with the key.
A 512-bit hashcode.
#define LOG(kind,...)
#define GNUNET_MQ_msg_header_extra(mh, esize, type)
Allocate a GNUNET_MQ_Envelope, where the message only consists of a header and extra space...
Definition: gnunet_mq_lib.h:88
Operation context used to execute a set operation.
struct perf_num_send_resived_msg offer
Header for all communications.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
struct GNUNET_MQ_Handle * mq
Message queue for the channel.
Used as a closure for sending elements with a specific IBF key.
struct IBF_Key ibf_key
The IBF key whose matching elements should be sent.
struct perf_rtt_struct perf_rtt
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
opunion operation
ibf_keyIBF key of interest

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

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

Referenced by decode_and_send(), and handle_union_p2p_inquiry().

1657 {
1658  struct SendElementClosure send_cls;
1659 
1660  send_cls.ibf_key = ibf_key;
1661  send_cls.op = op;
1663  op->key_to_element,
1664  (uint32_t) ibf_key.
1665  key_val,
1667  &send_cls);
1668 }
int GNUNET_CONTAINER_multihashmap32_get_multiple(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
struct GNUNET_CONTAINER_MultiHashMap32 * key_to_element
Maps unsalted IBF-Keys to elements.
static int send_offers_iterator(void *cls, uint32_t key, void *value)
Iterator to send elements to a remote peer.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
Used as a closure for sending elements with a specific IBF key.
struct IBF_Key ibf_key
The IBF key whose matching elements should be sent.
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
opunion operation
Returns
GNUNET_OK on success, GNUNET_SYSERR on failure

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

References perf_rtt_struct::done, fail_union_operation(), GNUNET_assert, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, 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_subtract(), perf_rtt_struct::inquery, key, IBF_Key::key_val, Operation::local_ibf, LOG, MAX_IBF_ORDER, Operation::mq, msg, perf_rtt, Operation::phase, PHASE_ACTIVE_DECODING, prepare_ibf(), Operation::remote_ibf, res, InquiryMessage::salt, Operation::salt_receive, Operation::salt_send, send_ibf(), send_offers_for_key(), perf_num_send_resived_msg::sent, perf_num_send_resived_msg::sent_var_bytes, size, InvertibleBloomFilter::size, and unsalt_key().

Referenced by handle_union_p2p_ibf().

1680 {
1681  struct IBF_Key key;
1682  struct IBF_Key last_key;
1683  int side;
1684  unsigned int num_decoded;
1685  struct InvertibleBloomFilter *diff_ibf;
1686 
1688 
1689  if (GNUNET_OK !=
1690  prepare_ibf (op,
1691  op->remote_ibf->size))
1692  {
1693  GNUNET_break (0);
1694  /* allocation failed */
1695  return GNUNET_SYSERR;
1696  }
1697  diff_ibf = ibf_dup (op->local_ibf);
1698  ibf_subtract (diff_ibf,
1699  op->remote_ibf);
1700 
1701  ibf_destroy (op->remote_ibf);
1702  op->remote_ibf = NULL;
1703 
1705  "decoding IBF (size=%u)\n",
1706  diff_ibf->size);
1707 
1708  num_decoded = 0;
1709  key.key_val = 0; /* just to avoid compiler thinking we use undef'ed variable */
1710 
1711  while (1)
1712  {
1713  int res;
1714  int cycle_detected = GNUNET_NO;
1715 
1716  last_key = key;
1717 
1718  res = ibf_decode (diff_ibf,
1719  &side,
1720  &key);
1721  if (res == GNUNET_OK)
1722  {
1724  "decoded ibf key %lx\n",
1725  (unsigned long) key.key_val);
1726  num_decoded += 1;
1727  if ((num_decoded > diff_ibf->size) ||
1728  ((num_decoded > 1) &&
1729  (last_key.key_val == key.key_val)))
1730  {
1732  "detected cyclic ibf (decoded %u/%u)\n",
1733  num_decoded,
1734  diff_ibf->size);
1735  cycle_detected = GNUNET_YES;
1736  }
1737  }
1738  if ((GNUNET_SYSERR == res) ||
1739  (GNUNET_YES == cycle_detected))
1740  {
1741  int next_order;
1742  next_order = 0;
1743  while (1 << next_order < diff_ibf->size)
1744  next_order++;
1745  next_order++;
1746  if (next_order <= MAX_IBF_ORDER)
1747  {
1749  "decoding failed, sending larger ibf (size %u)\n",
1750  1 << next_order);
1752  "# of IBF retries",
1753  1,
1754  GNUNET_NO);
1755  op->salt_send++;
1756  if (GNUNET_OK !=
1757  send_ibf (op, next_order))
1758  {
1759  /* Internal error, best we can do is shut the connection */
1761  "Failed to send IBF, closing connection\n");
1762  fail_union_operation (op);
1763  ibf_destroy (diff_ibf);
1764  return GNUNET_SYSERR;
1765  }
1766  }
1767  else
1768  {
1770  "# of failed union operations (too large)",
1771  1,
1772  GNUNET_NO);
1773  // XXX: Send the whole set, element-by-element
1775  "set union failed: reached ibf limit\n");
1776  fail_union_operation (op);
1777  ibf_destroy (diff_ibf);
1778  return GNUNET_SYSERR;
1779  }
1780  break;
1781  }
1782  if (GNUNET_NO == res)
1783  {
1784  struct GNUNET_MQ_Envelope *ev;
1785 
1787  "transmitted all values, sending DONE\n");
1788 
1789  perf_rtt.done.sent += 1;
1791  GNUNET_MQ_send (op->mq, ev);
1792  /* We now wait until we get a DONE message back
1793  * and then wait for our MQ to be flushed and all our
1794  * demands be delivered. */
1795  break;
1796  }
1797  if (1 == side)
1798  {
1799  struct IBF_Key unsalted_key;
1800 
1801  unsalt_key (&key,
1802  op->salt_receive,
1803  &unsalted_key);
1804  send_offers_for_key (op,
1805  unsalted_key);
1806  }
1807  else if (-1 == side)
1808  {
1809  struct GNUNET_MQ_Envelope *ev;
1810  struct InquiryMessage *msg;
1811 
1812  perf_rtt.inquery.sent += 1;
1813  perf_rtt.inquery.sent_var_bytes += sizeof(struct IBF_Key);
1814  /* It may be nice to merge multiple requests, but with CADET's corking it is not worth
1815  * the effort additional complexity. */
1816  ev = GNUNET_MQ_msg_extra (msg,
1817  sizeof(struct IBF_Key),
1819  msg->salt = htonl (op->salt_receive);
1820  GNUNET_memcpy (&msg[1],
1821  &key,
1822  sizeof(struct IBF_Key));
1824  "sending element inquiry for IBF key %lx\n",
1825  (unsigned long) key.key_val);
1826  GNUNET_MQ_send (op->mq, ev);
1827  }
1828  else
1829  {
1830  GNUNET_assert (0);
1831  }
1832  }
1833  ibf_destroy (diff_ibf);
1834  return GNUNET_OK;
1835 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
enum IntersectionOperationPhase phase
Current state of the operation.
struct InvertibleBloomFilter * remote_ibf
The IBF we currently receive.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Invertible bloom filter (IBF).
Definition: ibf.h:82
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
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.
static void unsalt_key(const struct IBF_Key *k_in, uint32_t salt, struct IBF_Key *k_out)
FIXME.
#define GNUNET_MESSAGE_TYPE_SETU_P2P_DONE
Set operation is done.
uint32_t salt_receive
Salt for the IBF we&#39;ve received and that we&#39;re currently decoding.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static int send_ibf(struct Operation *op, uint16_t ibf_order)
Send an ibf of appropriate size.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct InvertibleBloomFilter * ibf_dup(const struct InvertibleBloomFilter *ibf)
Create a copy of an IBF, the copy has to be destroyed properly.
Definition: ibf.c:379
uint32_t size
How many cells does this IBF have?
Definition: ibf.h:87
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
static void fail_union_operation(struct Operation *op)
Inform the client that the union operation has failed, and proceed to destroy the evaluate operation...
int ibf_decode(struct InvertibleBloomFilter *ibf, int *ret_side, struct IBF_Key *ret_id)
Decode and remove an element from the IBF, if possible.
Definition: ibf.c:228
void ibf_subtract(struct InvertibleBloomFilter *ibf1, const struct InvertibleBloomFilter *ibf2)
Subtract ibf2 from ibf1, storing the result in ibf1.
Definition: ibf.c:356
struct perf_num_send_resived_msg done
static int res
#define LOG(kind,...)
struct GNUNET_HashCode key
The key used in the DHT.
static unsigned int size
Size of the "table".
Definition: peer.c:67
void ibf_destroy(struct InvertibleBloomFilter *ibf)
Destroy all resources associated with the invertible bloom filter.
Definition: ibf.c:403
struct perf_num_send_resived_msg inquery
#define GNUNET_MQ_msg_header(type)
Allocate a GNUNET_MQ_Envelope, where the message only consists of a header.
Definition: gnunet_mq_lib.h:76
static struct GNUNET_STATISTICS_Handle * _GSS_statistics
Statistics handle.
We are decoding an IBF.
struct InvertibleBloomFilter * local_ibf
The IBF with the local set&#39;s element.
#define GNUNET_log(kind,...)
#define MAX_IBF_ORDER
The maximum size of an ibf we use is 2^(MAX_IBF_ORDER).
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
static int prepare_ibf(struct Operation *op, uint32_t size)
Create an ibf with the operation&#39;s elements of the specified size.
Keys that can be inserted into and removed from an IBF.
Definition: ibf.h:45
uint32_t salt
Salt used when hashing elements for this inquiry.
uint32_t salt_send
Salt that we&#39;re using for sending IBFs.
struct GNUNET_MQ_Handle * mq
Message queue for the channel.
#define GNUNET_MESSAGE_TYPE_SETU_P2P_INQUIRY
Tell the other peer to send us a list of hashes that match an IBF key.
struct perf_rtt_struct perf_rtt
Here is the call graph for this function:
Here is the caller 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
clsthe union operation
msgthe header of the message
Returns
GNUNET_OK if msg is well-formed

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

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, IBFMessage::header, IBF_BUCKET_SIZE, Operation::ibf_buckets_received, msg, IBFMessage::offset, IBFMessage::order, Operation::phase, PHASE_EXPECT_IBF, PHASE_EXPECT_IBF_LAST, PHASE_PASSIVE_DECODING, Operation::remote_ibf, IBFMessage::salt, Operation::salt_receive, InvertibleBloomFilter::size, and GNUNET_MessageHeader::size.

1851 {
1852  struct Operation *op = cls;
1853  unsigned int buckets_in_message;
1854 
1855  buckets_in_message = (ntohs (msg->header.size) - sizeof *msg)
1856  / IBF_BUCKET_SIZE;
1857  if (0 == buckets_in_message)
1858  {
1859  GNUNET_break_op (0);
1860  return GNUNET_SYSERR;
1861  }
1862  if ((ntohs (msg->header.size) - sizeof *msg) != buckets_in_message
1863  * IBF_BUCKET_SIZE)
1864  {
1865  GNUNET_break_op (0);
1866  return GNUNET_SYSERR;
1867  }
1868  if (op->phase == PHASE_EXPECT_IBF_LAST)
1869  {
1870  if (ntohl (msg->offset) != op->ibf_buckets_received)
1871  {
1872  GNUNET_break_op (0);
1873  return GNUNET_SYSERR;
1874  }
1875  if (1 << msg->order != op->remote_ibf->size)
1876  {
1877  GNUNET_break_op (0);
1878  return GNUNET_SYSERR;
1879  }
1880  if (ntohl (msg->salt) != op->salt_receive)
1881  {
1882  GNUNET_break_op (0);
1883  return GNUNET_SYSERR;
1884  }
1885  }
1886  else if ((op->phase != PHASE_PASSIVE_DECODING) &&
1887  (op->phase != PHASE_EXPECT_IBF))
1888  {
1889  GNUNET_break_op (0);
1890  return GNUNET_SYSERR;
1891  }
1892 
1893  return GNUNET_OK;
1894 }
uint32_t offset
Offset of the strata in the rest of the message.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
enum IntersectionOperationPhase phase
Current state of the operation.
struct InvertibleBloomFilter * remote_ibf
The IBF we currently receive.
The other peer is decoding the IBF we just sent.
unsigned int ibf_buckets_received
Number of ibf buckets already received into the remote_ibf.
uint32_t salt_receive
Salt for the IBF we&#39;ve received and that we&#39;re currently decoding.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
uint32_t size
How many cells does this IBF have?
Definition: ibf.h:87
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
uint8_t order
Order of the whole ibf, where num_buckets = 2^order.
We sent the strata estimator, and expect an IBF.
#define IBF_BUCKET_SIZE
Size of one ibf bucket in bytes.
Definition: ibf.h:72
Continuation for multi part IBFs.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF.
Operation context used to execute a set operation.
uint32_t salt
Salt used when hashing elements for this IBF.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144

◆ 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
clsthe union operation
msgthe header of the message

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

References Operation::channel, decode_and_send(), fail_union_operation(), GNUNET_assert, GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, IBFMessage::header, perf_rtt_struct::ibf, IBF_BUCKET_SIZE, Operation::ibf_buckets_received, ibf_create(), ibf_read_slice(), LOG, msg, IBFMessage::offset, IBFMessage::order, perf_rtt, Operation::phase, PHASE_ACTIVE_DECODING, PHASE_EXPECT_IBF, PHASE_EXPECT_IBF_LAST, PHASE_PASSIVE_DECODING, perf_num_send_resived_msg::received, perf_num_send_resived_msg::received_var_bytes, Operation::remote_ibf, IBFMessage::salt, Operation::salt_receive, SE_IBF_HASH_NUM, InvertibleBloomFilter::size, and GNUNET_MessageHeader::size.

1909 {
1910  struct Operation *op = cls;
1911  unsigned int buckets_in_message;
1912 
1913  perf_rtt.ibf.received += 1;
1914  perf_rtt.ibf.received_var_bytes += (ntohs (msg->header.size) - sizeof *msg);
1915 
1916  buckets_in_message = (ntohs (msg->header.size) - sizeof *msg)
1917  / IBF_BUCKET_SIZE;
1918  if ((op->phase == PHASE_PASSIVE_DECODING) ||
1919  (op->phase == PHASE_EXPECT_IBF))
1920  {
1922  GNUNET_assert (NULL == op->remote_ibf);
1924  "Creating new ibf of size %u\n",
1925  1 << msg->order);
1926  op->remote_ibf = ibf_create (1 << msg->order, SE_IBF_HASH_NUM);
1927  op->salt_receive = ntohl (msg->salt);
1929  "Receiving new IBF with salt %u\n",
1930  op->salt_receive);
1931  if (NULL == op->remote_ibf)
1932  {
1934  "Failed to parse remote IBF, closing connection\n");
1935  fail_union_operation (op);
1936  return;
1937  }
1938  op->ibf_buckets_received = 0;
1939  if (0 != ntohl (msg->offset))
1940  {
1941  GNUNET_break_op (0);
1942  fail_union_operation (op);
1943  return;
1944  }
1945  }
1946  else
1947  {
1950  "Received more of IBF\n");
1951  }
1952  GNUNET_assert (NULL != op->remote_ibf);
1953 
1954  ibf_read_slice (&msg[1],
1956  buckets_in_message,
1957  op->remote_ibf);
1958  op->ibf_buckets_received += buckets_in_message;
1959 
1960  if (op->ibf_buckets_received == op->remote_ibf->size)
1961  {
1963  "received full ibf\n");
1965  if (GNUNET_OK !=
1966  decode_and_send (op))
1967  {
1968  /* Internal error, best we can do is shut down */
1970  "Failed to decode IBF, closing connection\n");
1971  fail_union_operation (op);
1972  return;
1973  }
1974  }
1976 }
uint32_t offset
Offset of the strata in the rest of the message.
struct perf_num_send_resived_msg ibf
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define SE_IBF_HASH_NUM
The hash num parameter for the difference digests and strata estimators.
enum IntersectionOperationPhase phase
Current state of the operation.
struct InvertibleBloomFilter * remote_ibf
The IBF we currently receive.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
The other peer is decoding the IBF we just sent.
unsigned int ibf_buckets_received
Number of ibf buckets already received into the remote_ibf.
uint32_t salt_receive
Salt for the IBF we&#39;ve received and that we&#39;re currently decoding.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
uint32_t size
How many cells does this IBF have?
Definition: ibf.h:87
static void fail_union_operation(struct Operation *op)
Inform the client that the union operation has failed, and proceed to destroy the evaluate operation...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
uint8_t order
Order of the whole ibf, where num_buckets = 2^order.
We sent the strata estimator, and expect an IBF.
#define IBF_BUCKET_SIZE
Size of one ibf bucket in bytes.
Definition: ibf.h:72
Continuation for multi part IBFs.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF.
#define LOG(kind,...)
void ibf_read_slice(const void *buf, uint32_t start, uint32_t count, struct InvertibleBloomFilter *ibf)
Read buckets from a buffer into an ibf.
Definition: ibf.c:323
static int decode_and_send(struct Operation *op)
Decode which elements are missing on each side, and send the appropriate offers and inquiries...
struct InvertibleBloomFilter * ibf_create(uint32_t size, uint8_t hash_num)
Create an invertible bloom filter.
Definition: ibf.c:79
Operation context used to execute a set operation.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
struct GNUNET_CADET_Channel * channel
Channel to the peer.
We are decoding an IBF.
uint32_t salt
Salt used when hashing elements for this IBF.
#define GNUNET_log(kind,...)
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
struct perf_rtt_struct perf_rtt
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
opunion operation
elementelement to send
statusstatus to send with the new element

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

References Operation::client_request_id, Set::cs, 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(), Operation::key_to_element, LOG, ClientState::mq, GNUNET_SETU_ResultMessage::request_id, GNUNET_SETU_ResultMessage::result_status, Operation::set, and GNUNET_SETU_Element::size.

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

1991 {
1992  struct GNUNET_MQ_Envelope *ev;
1993  struct GNUNET_SETU_ResultMessage *rm;
1994 
1996  "sending element (size %u) to client\n",
1997  element->size);
1998  GNUNET_assert (0 != op->client_request_id);
1999  ev = GNUNET_MQ_msg_extra (rm,
2000  element->size,
2002  if (NULL == ev)
2003  {
2004  GNUNET_MQ_discard (ev);
2005  GNUNET_break (0);
2006  return;
2007  }
2008  rm->result_status = htons (status);
2009  rm->request_id = htonl (op->client_request_id);
2010  rm->element_type = htons (element->element_type);
2012  op->key_to_element));
2013  GNUNET_memcpy (&rm[1],
2014  element->data,
2015  element->size);
2016  GNUNET_MQ_send (op->set->cs->mq,
2017  ev);
2018 }
struct GNUNET_MQ_Handle * mq
MQ to talk to client.
const void * data
Actual data of the element.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint32_t request_id
id the result belongs to
Definition: setu.h:255
uint16_t element_type
Type of the element attached to the message, if any.
Definition: setu.h:266
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
#define GNUNET_MESSAGE_TYPE_SETU_RESULT
Handle result message from operation.
uint16_t element_type
Application-specific element type.
unsigned int GNUNET_CONTAINER_multihashmap32_size(const struct GNUNET_CONTAINER_MultiHashMap32 *map)
Get the number of key-value pairs in the map.
uint16_t status
See PRISM_STATUS_*-constants.
struct Set * set
Set associated with the operation, NULL until the spec has been associated with a set...
uint16_t result_status
Was the evaluation successful? Contains an enum GNUNET_SETU_Status in NBO.
Definition: setu.h:261
#define LOG(kind,...)
struct GNUNET_CONTAINER_MultiHashMap32 * key_to_element
Maps unsalted IBF-Keys to elements.
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:323
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:36
uint64_t current_size
Current set size.
Definition: setu.h:250
struct ClientState * cs
Client that owns the set.
Message sent by the service to the client to indicate an element that is removed (set intersection) o...
Definition: setu.h:240
uint32_t client_request_id
ID used to identify an operation between service and client.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
uint16_t size
Number of bytes in the buffer pointed to by data.
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
opoperation to check

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

References _GSS_operation_destroy2(), Operation::demanded_hashes, perf_rtt_struct::done, GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_SETU_P2P_DONE, GNUNET_MQ_msg_header, GNUNET_MQ_send(), LOG, Operation::mq, perf_rtt, Operation::phase, PHASE_FINISH_CLOSING, PHASE_FINISH_WAITING, PHASE_FINISHED, send_client_done(), and perf_num_send_resived_msg::sent.

Referenced by handle_union_p2p_done(), and handle_union_p2p_elements().

2028 {
2029  unsigned int num_demanded;
2030 
2031  num_demanded = GNUNET_CONTAINER_multihashmap_size (
2032  op->demanded_hashes);
2033 
2034  if (PHASE_FINISH_WAITING == op->phase)
2035  {
2037  "In PHASE_FINISH_WAITING, pending %u demands\n",
2038  num_demanded);
2039  if (0 == num_demanded)
2040  {
2041  struct GNUNET_MQ_Envelope *ev;
2042 
2043  op->phase = PHASE_FINISHED;
2044  perf_rtt.done.sent += 1;
2046  GNUNET_MQ_send (op->mq,
2047  ev);
2048  /* We now wait until the other peer sends P2P_OVER
2049  * after it got all elements from us. */
2050  }
2051  }
2052  if (PHASE_FINISH_CLOSING == op->phase)
2053  {
2055  "In PHASE_FINISH_CLOSING, pending %u demands\n",
2056  num_demanded);
2057  if (0 == num_demanded)
2058  {
2059  op->phase = PHASE_FINISHED;
2060  send_client_done (op);
2062  }
2063  }
2064 }
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
enum IntersectionOperationPhase phase
Current state of the operation.
In the ultimate phase, we wait until our demands are satisfied and then quit (sending another DONE me...
#define GNUNET_MESSAGE_TYPE_SETU_P2P_DONE
Set operation is done.
static void _GSS_operation_destroy2(struct Operation *op)
This function probably should not exist and be replaced by inlining more specific logic in the variou...
The protocol is almost finished, but we still have to flush our message queue and/or expect some elem...
static void send_client_done(void *cls)
Signal to the client that the operation has finished and destroy the operation.
struct GNUNET_CONTAINER_MultiHashMap * demanded_hashes
Hashes for elements that we have demanded from the other peer.
In the penultimate phase, we wait until all our demands are satisfied.
struct perf_num_send_resived_msg done
#define LOG(kind,...)
#define GNUNET_MQ_msg_header(type)
Allocate a GNUNET_MQ_Envelope, where the message only consists of a header.
Definition: gnunet_mq_lib.h:76
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
struct GNUNET_MQ_Handle * mq
Message queue for the channel.
struct perf_rtt_struct perf_rtt
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
clsthe union operation
emsgthe message

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

References Operation::demanded_hashes, GNUNET_break_op, GNUNET_CONTAINER_multihashmap_size(), GNUNET_OK, and GNUNET_SYSERR.

2076 {
2077  struct Operation *op = cls;
2078 
2080  {
2081  GNUNET_break_op (0);
2082  return GNUNET_SYSERR;
2083  }
2084  return GNUNET_OK;
2085 }
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
struct GNUNET_CONTAINER_MultiHashMap * demanded_hashes
Hashes for elements that we have demanded from the other peer.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Operation context used to execute a set operation.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
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
clsthe union operation
emsgthe message

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

References Operation::channel, GNUNET_SET_Element::data, Operation::demanded_hashes, ElementEntry::element, perf_rtt_struct::element, ElementEntry::element_hash, element_size, GNUNET_SET_Element::element_type, GNUNET_SETU_ElementMessage::element_type, fail_union_operation(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SETU_element_hash(), GNUNET_SETU_STATUS_ADD_LOCAL, GNUNET_STATISTICS_update(), GNUNET_YES, GNUNET_SETU_ElementMessage::header, LOG, maybe_finish(), op_get_element(), op_register_element(), perf_rtt, KeyEntry::received, perf_num_send_resived_msg::received, Operation::received_fresh, Operation::received_total, perf_num_send_resived_msg::received_var_bytes, ElementEntry::remote, send_client_element(), GNUNET_SET_Element::size, and GNUNET_MessageHeader::size.

2099 {
2100  struct Operation *op = cls;
2101  struct ElementEntry *ee;
2102  struct KeyEntry *ke;
2103  uint16_t element_size;
2104 
2105 
2106  element_size = ntohs (emsg->header.size) - sizeof(struct
2108  perf_rtt.element.received += 1;
2110 
2111  ee = GNUNET_malloc (sizeof(struct ElementEntry) + element_size);
2112  GNUNET_memcpy (&ee[1],
2113  &emsg[1],
2114  element_size);
2115  ee->element.size = element_size;
2116  ee->element.data = &ee[1];
2117  ee->element.element_type = ntohs (emsg->element_type);
2118  ee->remote = GNUNET_YES;
2120  &ee->element_hash);
2121  if (GNUNET_NO ==
2123  &ee->element_hash,
2124  NULL))
2125  {
2126  /* We got something we didn't demand, since it's not in our map. */
2127  GNUNET_break_op (0);
2128  fail_union_operation (op);
2129  return;
2130  }
2131 
2133  "Got element (size %u, hash %s) from peer\n",
2134  (unsigned int) element_size,
2135  GNUNET_h2s (&ee->element_hash));
2136 
2138  "# received elements",
2139  1,
2140  GNUNET_NO);
2142  "# exchanged elements",
2143  1,
2144  GNUNET_NO);
2145 
2146  op->received_total++;
2147 
2148  ke = op_get_element (op,
2149  &ee->element_hash);
2150  if (NULL != ke)
2151  {
2152  /* Got repeated element. Should not happen since
2153  * we track demands. */
2155  "# repeated elements",
2156  1,
2157  GNUNET_NO);
2158  ke->received = GNUNET_YES;
2159  GNUNET_free (ee);
2160  }
2161  else
2162  {
2164  "Registering new element from remote peer\n");
2165  op->received_fresh++;
2166  op_register_element (op, ee, GNUNET_YES);
2167  /* only send results immediately if the client wants it */
2168  send_client_element (op,
2169  &ee->element,
2171  }
2172 
2173  if ((op->received_total > 8) &&
2174  (op->received_fresh < op->received_total / 3))
2175  {
2176  /* The other peer gave us lots of old elements, there's something wrong. */
2177  GNUNET_break_op (0);
2178  fail_union_operation (op);
2179  return;
2180  }
2182  maybe_finish (op);
2183 }
uint32_t received_fresh
Number of elements we received from the other peer that were not in the local set yet...
static void maybe_finish(struct Operation *op)
Tests if the operation is finished, and if so notify.
struct perf_num_send_resived_msg element
static unsigned int element_size
int received
Did we receive this element? Even if element->is_foreign is false, we might have received the element...
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.
struct GNUNET_HashCode element_hash
Hash of the element.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
const void * data
Actual data of the element.
The key entry is used to associate an ibf key with an element.
uint16_t element_type
Type of the element to add or remove.
Definition: setu.h:286
static void fail_union_operation(struct Operation *op)
Inform the client that the union operation has failed, and proceed to destroy the evaluate operation...
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&#39;s element set.
struct GNUNET_CONTAINER_MultiHashMap * demanded_hashes
Hashes for elements that we have demanded from the other peer.
Information about an element element in the set.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
int remote
GNUNET_YES if the element is a remote element, and does not belong to the operation&#39;s set...
Element should be added to the result set of the local peer, i.e.
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
void GNUNET_SETU_element_hash(const struct GNUNET_SETU_Element *element, struct GNUNET_HashCode *ret_hash)
Hash a set element.
Definition: setu_api.c:876
#define LOG(kind,...)
Message sent by client to the service to add an element to the set.
Definition: setu.h:276
Operation context used to execute a set operation.
static void op_register_element(struct Operation *op, struct ElementEntry *ee, int received)
Insert an element into the union operation&#39;s key-to-element mapping.
static struct GNUNET_STATISTICS_Handle * _GSS_statistics
Statistics handle.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
struct GNUNET_CADET_Channel * channel
Channel to the peer.
uint16_t size
Number of bytes in the buffer pointed to by data.
struct GNUNET_SET_Element element
The actual element.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_SETU_ADD.
Definition: setu.h:281
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
#define GNUNET_malloc(size)
Wrapper around malloc.
uint32_t received_total
Total number of elements received from the other peer.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t element_type
Application-specific element type.
struct perf_rtt_struct perf_rtt
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
clsthe union operation
emsgthe message

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

References GNUNET_OK.

2195 {
2196  struct Operation *op = cls;
2197 
2198  (void) op;
2199 
2200  // FIXME: check that we expect full elements here?
2201  return GNUNET_OK;
2202 }
Operation context used to execute a set operation.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144

◆ 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
clsthe union operation
emsgthe message

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

References Operation::byzantine, Operation::channel, GNUNET_SET_Element::data, ElementEntry::element, perf_rtt_struct::element_full, ElementEntry::element_hash, element_size, GNUNET_SET_Element::element_type, GNUNET_SETU_ElementMessage::element_type, fail_union_operation(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SETU_element_hash(), GNUNET_SETU_STATUS_ADD_LOCAL, GNUNET_STATISTICS_update(), GNUNET_YES, GNUNET_SETU_ElementMessage::header, LOG, op_get_element(), op_register_element(), perf_rtt, Operation::phase, PHASE_EXPECT_IBF, PHASE_FULL_RECEIVING, PHASE_FULL_SENDING, KeyEntry::received, perf_num_send_resived_msg::received, Operation::received_fresh, Operation::received_total, perf_num_send_resived_msg::received_var_bytes, ElementEntry::remote, send_client_element(), GNUNET_SET_Element::size, and GNUNET_MessageHeader::size.

2214 {
2215  struct Operation *op = cls;
2216  struct ElementEntry *ee;
2217  struct KeyEntry *ke;
2218  uint16_t element_size;
2219 
2220 
2221 
2222  if(PHASE_EXPECT_IBF == op->phase) {
2224  }
2225 
2226 
2227 
2228  /* Allow only receiving of full element message if in expect IBF or in PHASE_FULL_RECEIVING state */
2229  if ((PHASE_FULL_RECEIVING != op->phase) &&
2230  (PHASE_FULL_SENDING != op->phase))
2231  {
2233  "Handle full element phase is %u\n",
2234  (unsigned) op->phase);
2235  GNUNET_break_op (0);
2236  fail_union_operation (op);
2237  return;
2238  }
2239 
2240 
2241 
2242  element_size = ntohs (emsg->header.size)
2243  - sizeof(struct GNUNET_SETU_ElementMessage);
2244 
2247 
2248  ee = GNUNET_malloc (sizeof(struct ElementEntry) + element_size);
2249  GNUNET_memcpy (&ee[1], &emsg[1], element_size);
2250  ee->element.size = element_size;
2251  ee->element.data = &ee[1];
2252  ee->element.element_type = ntohs (emsg->element_type);
2253  ee->remote = GNUNET_YES;
2255  &ee->element_hash);
2257  "Got element (full diff, size %u, hash %s) from peer\n",
2258  (unsigned int) element_size,
2259  GNUNET_h2s (&ee->element_hash));
2260 
2262  "# received elements",
2263  1,
2264  GNUNET_NO);
2266  "# exchanged elements",
2267  1,
2268  GNUNET_NO);
2269 
2270  op->received_total++;
2271 
2272  ke = op_get_element (op,
2273  &ee->element_hash);
2274  if (NULL != ke)
2275  {
2276  /* Got repeated element. Should not happen since
2277  * we track demands. */
2279  "# repeated elements",
2280  1,
2281  GNUNET_NO);
2282  ke->received = GNUNET_YES;
2283  GNUNET_free (ee);
2284  }
2285  else
2286  {
2288  "Registering new element from remote peer\n");
2289  op->received_fresh++;
2290  op_register_element (op, ee, GNUNET_YES);
2291  /* only send results immediately if the client wants it */
2292  send_client_element (op,
2293  &ee->element,
2295  }
2296 
2297  if ((GNUNET_YES == op->byzantine) &&
2298  (op->received_total > 384 + op->received_fresh * 4) &&
2299  (op->received_fresh < op->received_total / 6))
2300  {
2301  /* The other peer gave us lots of old elements, there's something wrong. */
2303  "Other peer sent only %llu/%llu fresh elements, failing operation\n",
2304  (unsigned long long) op->received_fresh,
2305  (unsigned long long) op->received_total);
2306  GNUNET_break_op (0);
2307  fail_union_operation (op);
2308  return;
2309  }
2311 }
uint32_t received_fresh
Number of elements we received from the other peer that were not in the local set yet...
After sending the full set, wait for responses with the elements that the local peer is missing...
enum IntersectionOperationPhase phase
Current state of the operation.
static unsigned int element_size
int received
Did we receive this element? Even if element->is_foreign is false, we might have received the element...
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.
struct GNUNET_HashCode element_hash
Hash of the element.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct perf_num_send_resived_msg element_full
const void * data
Actual data of the element.
The key entry is used to associate an ibf key with an element.
uint16_t element_type
Type of the element to add or remove.
Definition: setu.h:286
static void fail_union_operation(struct Operation *op)
Inform the client that the union operation has failed, and proceed to destroy the evaluate operation...
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&#39;s element set.
Information about an element element in the set.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
int remote
GNUNET_YES if the element is a remote element, and does not belong to the operation&#39;s set...
Element should be added to the result set of the local peer, i.e.
We sent the strata estimator, and expect an IBF.
void GNUNET_SETU_element_hash(const struct GNUNET_SETU_Element *element, struct GNUNET_HashCode *ret_hash)
Hash a set element.
Definition: setu_api.c:876
#define LOG(kind,...)
int byzantine
GNUNET_YES to fail operations where Byzantine faults are suspected
Message sent by client to the service to add an element to the set.
Definition: setu.h:276
Operation context used to execute a set operation.
static void op_register_element(struct Operation *op, struct ElementEntry *ee, int received)
Insert an element into the union operation&#39;s key-to-element mapping.
static struct GNUNET_STATISTICS_Handle * _GSS_statistics
Statistics handle.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
struct GNUNET_CADET_Channel * channel
Channel to the peer.
uint16_t size
Number of bytes in the buffer pointed to by data.
#define GNUNET_log(kind,...)
struct GNUNET_SET_Element element
The actual element.
Phase that receives full set first and then sends elements that are the local peer missing...
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_SETU_ADD.
Definition: setu.h:281
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
#define GNUNET_malloc(size)
Wrapper around malloc.
uint32_t received_total
Total number of elements received from the other peer.
#define GNUNET_free(ptr)
Wrapper around free.
uint16_t element_type
Application-specific element type.
struct perf_rtt_struct perf_rtt
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
clsthe union operation
msgthe message

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

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, InquiryMessage::header, Operation::phase, PHASE_PASSIVE_DECODING, and GNUNET_MessageHeader::size.

2324 {
2325  struct Operation *op = cls;
2326  unsigned int num_keys;
2327 
2328  if (op->phase != PHASE_PASSIVE_DECODING)
2329  {
2330  GNUNET_break_op (0);
2331  return GNUNET_SYSERR;
2332  }
2333  num_keys = (ntohs (msg->header.size) - sizeof(struct InquiryMessage))
2334  / sizeof(struct IBF_Key);
2335  if ((ntohs (msg->header.size) - sizeof(struct InquiryMessage))
2336  != num_keys * sizeof(struct IBF_Key))
2337  {
2338  GNUNET_break_op (0);
2339  return GNUNET_SYSERR;
2340  }
2341  return GNUNET_OK;
2342 }
enum IntersectionOperationPhase phase
Current state of the operation.
The other peer is decoding the IBF we just sent.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Operation context used to execute a set operation.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
Keys that can be inserted into and removed from an IBF.
Definition: ibf.h:45

◆ 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
clsthe union operation
msgthe message

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

References Operation::channel, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, InquiryMessage::header, perf_rtt_struct::inquery, LOG, perf_rtt, perf_num_send_resived_msg::received, perf_num_send_resived_msg::received_var_bytes, InquiryMessage::salt, send_offers_for_key(), GNUNET_MessageHeader::size, and unsalt_key().

2354 {
2355  struct Operation *op = cls;
2356  const struct IBF_Key *ibf_key;
2357  unsigned int num_keys;
2358 
2359  perf_rtt.inquery.received += 1;
2360  perf_rtt.inquery.received_var_bytes += (ntohs (msg->header.size) - sizeof(struct InquiryMessage));
2361 
2363  "Received union inquiry\n");
2364  num_keys = (ntohs (msg->header.size) - sizeof(struct InquiryMessage))
2365  / sizeof(struct IBF_Key);
2366  ibf_key = (const struct IBF_Key *) &msg[1];
2367  while (0 != num_keys--)
2368  {
2369  struct IBF_Key unsalted_key;
2370 
2371  unsalt_key (ibf_key,
2372  ntohl (msg->salt),
2373  &unsalted_key);
2374  send_offers_for_key (op,
2375  unsalted_key);
2376  ibf_key++;
2377  }
2379 }
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.
static void unsalt_key(const struct IBF_Key *k_in, uint32_t salt, struct IBF_Key *k_out)
FIXME.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define LOG(kind,...)
Operation context used to execute a set operation.
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_SET_UNION_P2P_IBF.
struct perf_num_send_resived_msg inquery
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
struct GNUNET_CADET_Channel * channel
Channel to the peer.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
Keys that can be inserted into and removed from an IBF.
Definition: ibf.h:45
uint32_t salt
Salt used when hashing elements for this inquiry.
struct perf_rtt_struct perf_rtt
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
clsclosure
keycurrent key code
valuevalue in the hash map
Returns
GNUNET_YES if we should continue to iterate, GNUNET_NO if not.

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

References GNUNET_SET_Element::data, ElementEntry::element, KeyEntry::element, perf_rtt_struct::element_full, 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, Operation::mq, perf_rtt, KeyEntry::received, perf_num_send_resived_msg::received, GNUNET_SET_Element::size, and value.

Referenced by handle_union_p2p_full_done().

2396 {
2397  struct Operation *op = cls;
2398  struct KeyEntry *ke = value;
2399  struct GNUNET_MQ_Envelope *ev;
2400  struct GNUNET_SETU_ElementMessage *emsg;
2401  struct ElementEntry *ee = ke->element;
2402 
2403  if (GNUNET_YES == ke->received)
2404  return GNUNET_YES;
2406  ev = GNUNET_MQ_msg_extra (emsg,
2407  ee->element.size,
2409  GNUNET_memcpy (&emsg[1],
2410  ee->element.data,
2411  ee->element.size);
2412  emsg->element_type = htons (ee->element.element_type);
2413  GNUNET_MQ_send (op->mq,
2414  ev);
2415  return GNUNET_YES;
2416 }
int received
Did we receive this element? Even if element->is_foreign is false, we might have received the element...
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct perf_num_send_resived_msg element_full
const void * data
Actual data of the element.
The key entry is used to associate an ibf key with an element.
uint16_t element_type
Type of the element to add or remove.
Definition: setu.h:286
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
static char * value
Value of the record to add/remove.
Information about an element element in the set.
struct ElementEntry * element
The actual element associated with the key.
#define GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_ELEMENT
Send a set element, not as response to a demand but because we&#39;re sending the full set...
Message sent by client to the service to add an element to the set.
Definition: setu.h:276
Operation context used to execute a set operation.
uint16_t size
Number of bytes in the buffer pointed to by data.
struct GNUNET_SET_Element element
The actual element.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
struct GNUNET_MQ_Handle * mq
Message queue for the channel.
uint16_t element_type
Application-specific element type.
struct perf_rtt_struct perf_rtt
Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_union_p2p_request_full()

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

Handle a request for full set transmission.

Parameters
clsclosure, a set union operation
mhthe demand message

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

References Operation::channel, fail_union_operation(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, LOG, perf_rtt, Operation::phase, PHASE_EXPECT_IBF, perf_num_send_resived_msg::received, perf_rtt_struct::request_full, and send_full_set().

2428 {
2429  struct Operation *op = cls;
2430 
2432 
2434  "Received request for full set transmission\n");
2435  if (PHASE_EXPECT_IBF != op->phase)
2436  {
2437  GNUNET_break_op (0);
2438  fail_union_operation (op);
2439  return;
2440  }
2441 
2442  // FIXME: we need to check that our set is larger than the
2443  // byzantine_lower_bound by some threshold
2444  send_full_set (op);
2446 }
static void send_full_set(struct Operation *op)
Switch to full set transmission for op.
enum IntersectionOperationPhase phase
Current state of the operation.
struct perf_num_send_resived_msg request_full
static void fail_union_operation(struct Operation *op)
Inform the client that the union operation has failed, and proceed to destroy the evaluate operation...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
We sent the strata estimator, and expect an IBF.
#define LOG(kind,...)
Operation context used to execute a set operation.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
struct GNUNET_CADET_Channel * channel
Channel to the peer.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
struct perf_rtt_struct perf_rtt
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
clsclosure, a set union operation
mhthe demand message

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

References _GSS_operation_destroy2(), Operation::channel, fail_union_operation(), perf_rtt_struct::full_done, 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(), Operation::key_to_element, LOG, Operation::mq, perf_rtt, Operation::phase, PHASE_FINISHED, PHASE_FULL_RECEIVING, PHASE_FULL_SENDING, perf_num_send_resived_msg::received, send_client_done(), send_missing_full_elements_iter(), and perf_num_send_resived_msg::sent.

2458 {
2459  struct Operation *op = cls;
2460 
2462 
2463  switch (op->phase)
2464  {
2465  case PHASE_FULL_RECEIVING:
2466  {
2467  struct GNUNET_MQ_Envelope *ev;
2468 
2470  "got FULL DONE, sending elements that other peer is missing\n");
2471 
2472  /* send all the elements that did not come from the remote peer */
2475  op);
2476  perf_rtt.full_done.sent += 1;
2478  GNUNET_MQ_send (op->mq,
2479  ev);
2480  op->phase = PHASE_FINISHED;
2481  /* we now wait until the other peer sends us the OVER message*/
2482  }
2483  break;
2484 
2485  case PHASE_FULL_SENDING:
2486  {
2488  "got FULL DONE, finishing\n");
2489  /* We sent the full set, and got the response for that. We're done. */
2490  op->phase = PHASE_FINISHED;
2492  send_client_done (op);
2494  return;
2495  }
2496 
2497  default:
2499  "Handle full done phase is %u\n",
2500  (unsigned) op->phase);
2501  GNUNET_break_op (0);
2502  fail_union_operation (op);
2503  return;
2504  }
2506 }
After sending the full set, wait for responses with the elements that the local peer is missing...
enum IntersectionOperationPhase phase
Current state of the operation.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
In the ultimate phase, we wait until our demands are satisfied and then quit (sending another DONE me...
static void _GSS_operation_destroy2(struct Operation *op)
This function probably should not exist and be replaced by inlining more specific logic in the variou...
static void send_client_done(void *cls)
Signal to the client that the operation has finished and destroy the operation.
static void fail_union_operation(struct Operation *op)
Inform the client that the union operation has failed, and proceed to destroy the evaluate operation...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_MESSAGE_TYPE_SETU_P2P_FULL_DONE
Request all missing elements from the other peer, based on their sets and the elements we previously ...
#define LOG(kind,...)
struct GNUNET_CONTAINER_MultiHashMap32 * key_to_element
Maps unsalted IBF-Keys to elements.
Operation context used to execute a set operation.
#define GNUNET_MQ_msg_header(type)
Allocate a GNUNET_MQ_Envelope, where the message only consists of a header.
Definition: gnunet_mq_lib.h:76
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
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...
struct GNUNET_CADET_Channel * channel
Channel to the peer.
struct perf_num_send_resived_msg full_done
#define GNUNET_log(kind,...)
Phase that receives full set first and then sends elements that are the local peer missing...
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
struct GNUNET_MQ_Handle * mq
Message queue for the channel.
struct perf_rtt_struct perf_rtt
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
clsclosure, a set union operation
mhthe demand message
Returns
GNUNET_OK if mh is well-formed

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

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, and GNUNET_MessageHeader::size.

2520 {
2521  struct Operation *op = cls;
2522  unsigned int num_hashes;
2523 
2524  (void) op;
2525  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
2526  / sizeof(struct GNUNET_HashCode);
2527  if ((ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
2528  != num_hashes * sizeof(struct GNUNET_HashCode))
2529  {
2530  GNUNET_break_op (0);
2531  return GNUNET_SYSERR;
2532  }
2533  return GNUNET_OK;
2534 }
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
A 512-bit hashcode.
Operation context used to execute a set operation.
Header for all communications.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144

◆ 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
clsclosure, a set union operation
mhthe demand message

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

References _GSS_is_element_of_operation(), Operation::channel, Set::content, GNUNET_SET_Element::data, perf_rtt_struct::demand, ElementEntry::element, perf_rtt_struct::element, ElementEntry::element_hash, GNUNET_SET_Element::element_type, GNUNET_SETU_ElementMessage::element_type, SetContent::elements, fail_union_operation(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SETU_P2P_ELEMENTS, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SET_STATUS_ADD_REMOTE, GNUNET_STATISTICS_update(), LOG, Operation::mq, perf_rtt, perf_num_send_resived_msg::received, perf_num_send_resived_msg::received_var_bytes, GNUNET_SETU_ElementMessage::reserved, send_client_element(), perf_num_send_resived_msg::sent, perf_num_send_resived_msg::sent_var_bytes, Operation::set, GNUNET_SET_Element::size, GNUNET_MessageHeader::size, and Operation::symmetric.

2547 {
2548  struct Operation *op = cls;
2549  struct ElementEntry *ee;
2550  struct GNUNET_SETU_ElementMessage *emsg;
2551  const struct GNUNET_HashCode *hash;
2552  unsigned int num_hashes;
2553  struct GNUNET_MQ_Envelope *ev;
2554 
2555  perf_rtt.demand.received += 1;
2556  perf_rtt.demand.received_var_bytes += (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader));
2557 
2558  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
2559  / sizeof(struct GNUNET_HashCode);
2560  for (hash = (const struct GNUNET_HashCode *) &mh[1];
2561  num_hashes > 0;
2562  hash++, num_hashes--)
2563  {
2565  hash);
2566  if (NULL == ee)
2567  {
2568  /* Demand for non-existing element. */
2569  GNUNET_break_op (0);
2570  fail_union_operation (op);
2571  return;
2572  }
2573  if (GNUNET_NO == _GSS_is_element_of_operation (ee, op))
2574  {
2575  /* Probably confused lazily copied sets. */
2576  GNUNET_break_op (0);
2577  fail_union_operation (op);
2578  return;
2579  }
2580  perf_rtt.element.sent += 1;
2582  ev = GNUNET_MQ_msg_extra (emsg,
2583  ee->element.size,
2585  GNUNET_memcpy (&emsg[1],
2586  ee->element.data,
2587  ee->element.size);
2588  emsg->reserved = htons (0);
2589  emsg->element_type = htons (ee->element.element_type);
2591  "[OP %p] Sending demanded element (size %u, hash %s) to peer\n",
2592  op,
2593  (unsigned int) ee->element.size,
2594  GNUNET_h2s (&ee->element_hash));
2595  GNUNET_MQ_send (op->mq, ev);
2597  "# exchanged elements",
2598  1,
2599  GNUNET_NO);
2600  if (op->symmetric)
2601  send_client_element (op,
2602  &ee->element,
2604  }
2606 }
struct perf_num_send_resived_msg element
Element should be added to the result set of the remote peer, i.e.
uint16_t reserved
For alignment, always zero.
Definition: setu.h:291
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.
struct GNUNET_HashCode element_hash
Hash of the element.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_CONTAINER_MultiHashMap * elements
Maps struct GNUNET_HashCode * to struct ElementEntry *.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
const void * data
Actual data of the element.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
uint16_t element_type
Type of the element to add or remove.
Definition: setu.h:286
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
static void fail_union_operation(struct Operation *op)
Inform the client that the union operation has failed, and proceed to destroy the evaluate operation...
Information about an element element in the set.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
struct perf_num_send_resived_msg demand
struct Set * set
Set associated with the operation, NULL until the spec has been associated with a set...
A 512-bit hashcode.
int symmetric
GNUNET_YES to also send back set elements we are sending to the remote peer.
#define LOG(kind,...)
Message sent by client to the service to add an element to the set.
Definition: setu.h:276
Operation context used to execute a set operation.
static struct GNUNET_STATISTICS_Handle * _GSS_statistics
Statistics handle.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
struct GNUNET_CADET_Channel * channel
Channel to the peer.
struct SetContent * content
Content, possibly shared by multiple sets, and thus reference counted.
uint16_t size
Number of bytes in the buffer pointed to by data.
struct GNUNET_SET_Element element
The actual element.
Header for all communications.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
struct GNUNET_MQ_Handle * mq
Message queue for the channel.
static int _GSS_is_element_of_operation(struct ElementEntry *ee, struct Operation *op)
Is element ee part of the set used by op?
#define GNUNET_MESSAGE_TYPE_SETU_P2P_ELEMENTS
Actual set elements.
uint16_t element_type
Application-specific element type.
struct perf_rtt_struct perf_rtt
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
clsthe union operation
mhthe message
Returns
GNUNET_OK if mh is well-formed

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

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, Operation::phase, PHASE_ACTIVE_DECODING, PHASE_PASSIVE_DECODING, and GNUNET_MessageHeader::size.

2619 {
2620  struct Operation *op = cls;
2621  unsigned int num_hashes;
2622 
2623  /* look up elements and send them */
2624  if ((op->phase != PHASE_PASSIVE_DECODING) &&
2625  (op->phase != PHASE_ACTIVE_DECODING))
2626  {
2627  GNUNET_break_op (0);
2628  return GNUNET_SYSERR;
2629  }
2630  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
2631  / sizeof(struct GNUNET_HashCode);
2632  if ((ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader)) !=
2633  num_hashes * sizeof(struct GNUNET_HashCode))
2634  {
2635  GNUNET_break_op (0);
2636  return GNUNET_SYSERR;
2637  }
2638  return GNUNET_OK;
2639 }
enum IntersectionOperationPhase phase
Current state of the operation.
The other peer is decoding the IBF we just sent.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
A 512-bit hashcode.
Operation context used to execute a set operation.
We are decoding an IBF.
Header for all communications.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144

◆ 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
clsthe union operation
mhthe message

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

References _GSS_is_element_of_operation(), Operation::channel, Set::content, perf_rtt_struct::demand, Operation::demanded_hashes, SetContent::elements, GNUNET_assert, 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_h2s(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_SETU_P2P_DEMAND, GNUNET_MQ_msg_header_extra, GNUNET_MQ_send(), GNUNET_OK, GNUNET_YES, LOG, Operation::mq, perf_rtt_struct::offer, perf_rtt, perf_num_send_resived_msg::received, perf_num_send_resived_msg::received_var_bytes, perf_num_send_resived_msg::sent, perf_num_send_resived_msg::sent_var_bytes, Operation::set, and GNUNET_MessageHeader::size.

2652 {
2653  struct Operation *op = cls;
2654  const struct GNUNET_HashCode *hash;
2655  unsigned int num_hashes;
2656 
2657  perf_rtt.offer.received += 1;
2658  perf_rtt.offer.received_var_bytes += (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader));
2659 
2660  num_hashes = (ntohs (mh->size) - sizeof(struct GNUNET_MessageHeader))
2661  / sizeof(struct GNUNET_HashCode);
2662  for (hash = (const struct GNUNET_HashCode *) &mh[1];
2663  num_hashes > 0;
2664  hash++, num_hashes--)
2665  {
2666  struct ElementEntry *ee;
2667  struct GNUNET_MessageHeader *demands;
2668  struct GNUNET_MQ_Envelope *ev;
2669 
2671  hash);
2672  if (NULL != ee)
2673  if (GNUNET_YES == _GSS_is_element_of_operation (ee, op))
2674  continue;
2675 
2676  if (GNUNET_YES ==
2678  hash))
2679  {
2681  "Skipped sending duplicate demand\n");
2682  continue;
2683  }
2684 
2687  op->demanded_hashes,
2688  hash,
2689  NULL,
2691 
2693  "[OP %p] Requesting element (hash %s)\n",
2694  op, GNUNET_h2s (hash));
2695 
2696  perf_rtt.demand.sent += 1;
2697  perf_rtt.demand.sent_var_bytes += sizeof(struct GNUNET_HashCode);
2698  ev = GNUNET_MQ_msg_header_extra (demands,
2699  sizeof(struct GNUNET_HashCode),
2701  GNUNET_memcpy (&demands[1],
2702  hash,
2703  sizeof(struct GNUNET_HashCode));
2704  GNUNET_MQ_send (op->mq, ev);
2705  }
2707 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_CONTAINER_MultiHashMap * elements
Maps struct GNUNET_HashCode * to struct ElementEntry *.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
int GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL)...
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
, &#39; bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_...
struct GNUNET_CONTAINER_MultiHashMap * demanded_hashes
Hashes for elements that we have demanded from the other peer.
Information about an element element in the set.
struct perf_num_send_resived_msg demand
struct Set * set
Set associated with the operation, NULL until the spec has been associated with a set...
A 512-bit hashcode.
#define LOG(kind,...)
#define GNUNET_MQ_msg_header_extra(mh, esize, type)
Allocate a GNUNET_MQ_Envelope, where the message only consists of a header and extra space...
Definition: gnunet_mq_lib.h:88
Operation context used to execute a set operation.
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct perf_num_send_resived_msg offer
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
struct GNUNET_CADET_Channel * channel
Channel to the peer.
struct SetContent * content
Content, possibly shared by multiple sets, and thus reference counted.
Header for all communications.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:355
#define GNUNET_MESSAGE_TYPE_SETU_P2P_DEMAND
Demand the whole element from the other peer, given only the hash code.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
struct GNUNET_MQ_Handle * mq
Message queue for the channel.
static int _GSS_is_element_of_operation(struct ElementEntry *ee, struct Operation *op)
Is element ee part of the set used by op?
struct perf_rtt_struct perf_rtt
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
clsthe union operation
mhthe message

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

References Operation::channel, perf_rtt_struct::done, fail_union_operation(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, LOG, maybe_finish(), perf_rtt, Operation::phase, PHASE_ACTIVE_DECODING, PHASE_FINISH_CLOSING, PHASE_FINISH_WAITING, PHASE_PASSIVE_DECODING, and perf_num_send_resived_msg::received.

2719 {
2720  struct Operation *op = cls;
2721 
2722  perf_rtt.done.received += 1;
2723  switch (op->phase)
2724  {
2726  /* We got all requests, but still have to send our elements in response. */
2729  "got DONE (as passive partner), waiting for our demands to be satisfied\n");
2730  /* The active peer is done sending offers
2731  * and inquiries. This means that all
2732  * our responses to that (demands and offers)
2733  * must be in flight (queued or in mesh).
2734  *
2735  * We should notify the active peer once
2736  * all our demands are satisfied, so that the active
2737  * peer can quit if we gave it everything.
2739  maybe_finish (op);
2740  return;
2741  case PHASE_ACTIVE_DECODING:
2743  "got DONE (as active partner), waiting to finish\n");
2744  /* All demands of the other peer are satisfied,
2745  * and we processed all offers, thus we know
2746  * exactly what our demands must be.
2747  *
2748  * We'll close the channel
2749  * to the other peer once our demands are met.
2750  */op->phase = PHASE_FINISH_CLOSING;
2752  maybe_finish (op);
2753  return;
2754  default:
2755  GNUNET_break_op (0);
2756  fail_union_operation (op);
2757  return;
2758  }
2759 }
static void maybe_finish(struct Operation *op)
Tests if the operation is finished, and if so notify.
enum IntersectionOperationPhase phase
Current state of the operation.
The other peer is decoding the IBF we just sent.
The protocol is almost finished, but we still have to flush our message queue and/or expect some elem...
static void fail_union_operation(struct Operation *op)
Inform the client that the union operation has failed, and proceed to destroy the evaluate operation...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
In the penultimate phase, we wait until all our demands are satisfied.
struct perf_num_send_resived_msg done
#define LOG(kind,...)
Operation context used to execute a set operation.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:888
struct GNUNET_CADET_Channel * channel
Channel to the peer.
We are decoding an IBF.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
struct perf_rtt_struct perf_rtt
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
clsthe union operation
mhthe message

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

References perf_rtt_struct::over, perf_rtt, perf_num_send_resived_msg::received, and send_client_done().

2771 {
2772  perf_rtt.over.received += 1;
2773  send_client_done (cls);
2774 }
static void send_client_done(void *cls)
Signal to the client that the operation has finished and destroy the operation.
struct perf_num_send_resived_msg over
struct perf_rtt_struct perf_rtt
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
listenerthe listener to look in
idid to look for
Returns
the incoming socket associated with the id, or NULL if there is none

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

References Operation::listener, Listener::next, Operation::next, op, Listener::op_head, and Operation::suggest_id.

Referenced by handle_client_accept(), and handle_client_reject().

2787 {
2788  for (struct Listener *listener = listener_head;
2789  NULL != listener;
2790  listener = listener->next)
2791  {
2792  for (struct Operation *op = listener->op_head;
2793  NULL != op;
2794  op = op->next)
2795  if (op->suggest_id == id)
2796  return op;
2797  }
2798  return NULL;
2799 }
struct GNUNET_ARM_Operation * next
This is a doubly-linked list.
Definition: arm_api.c:45
struct Listener * next
Listeners are held in a doubly linked list.
struct Operation * op_head
Head of DLL of operations this listener is responsible for.
A listener is inhabited by a client, and waits for evaluation requests from remote peers...
Operation context used to execute a set operation.
static struct Listener * listener_head
Listeners are held in a doubly linked list.
static struct GNUNET_ARM_Operation * op
Current operation.
Definition: gnunet-arm.c:144
struct Listener * listener
Port this operation runs on.
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 conne