GNUnet  0.10.x
Macros | Typedefs | Functions
RPS service

Random Peer Sampling. More...

Macros

#define GNUNET_RPS_VERSION   0x00000000
 Version of the rps API. More...
 

Typedefs

typedef void(* GNUNET_RPS_NotifyReadyCB) (void *cls, uint64_t num_peers, const struct GNUNET_PeerIdentity *peers)
 Callback called when requested random peers are available. More...
 
typedef void(* GNUNET_RPS_NotifyReadySingleInfoCB) (void *cls, const struct GNUNET_PeerIdentity *peer, double probability, uint32_t num_observed)
 Callback called when requested random peer with additional information is available. More...
 

Functions

struct GNUNET_RPS_HandleGNUNET_RPS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
 Connect to the rps service. More...
 
void GNUNET_RPS_sub_start (struct GNUNET_RPS_Handle *h, const char *shared_value)
 Start a sub with the given shared value. More...
 
void GNUNET_RPS_sub_stop (struct GNUNET_RPS_Handle *h, const char *shared_value)
 Stop a sub with the given shared value. More...
 
struct GNUNET_RPS_Request_HandleGNUNET_RPS_request_peers (struct GNUNET_RPS_Handle *h, uint32_t n, GNUNET_RPS_NotifyReadyCB ready_cb, void *cls)
 Request n random peers. More...
 
struct GNUNET_RPS_Request_Handle_Single_InfoGNUNET_RPS_request_peer_info (struct GNUNET_RPS_Handle *rps_handle, GNUNET_RPS_NotifyReadySingleInfoCB ready_cb, void *cls)
 Request one random peer, getting additional information. More...
 
void GNUNET_RPS_seed_ids (struct GNUNET_RPS_Handle *h, uint32_t n, const struct GNUNET_PeerIdentity *ids)
 Seed rps service with peerIDs. More...
 
void GNUNET_RPS_request_cancel (struct GNUNET_RPS_Request_Handle *rh)
 Cancle an issued request. More...
 
void GNUNET_RPS_request_single_info_cancel (struct GNUNET_RPS_Request_Handle_Single_Info *rhs)
 Cancle an issued single info request. More...
 
void GNUNET_RPS_view_request (struct GNUNET_RPS_Handle *rps_handle, uint32_t num_updates, GNUNET_RPS_NotifyReadyCB view_update_cb, void *cls)
 Request updates of view. More...
 
struct GNUNET_RPS_StreamRequestHandleGNUNET_RPS_stream_request (struct GNUNET_RPS_Handle *rps_handle, GNUNET_RPS_NotifyReadyCB stream_input_cb, void *cls)
 Request biased stream of peers that are being put into the sampler. More...
 
void GNUNET_RPS_stream_cancel (struct GNUNET_RPS_StreamRequestHandle *srh)
 Cancel a specific request for updates from the biased peer stream. More...
 
void GNUNET_RPS_disconnect (struct GNUNET_RPS_Handle *h)
 Disconnect from the rps service. More...
 

Detailed Description

Random Peer Sampling.

Macro Definition Documentation

◆ GNUNET_RPS_VERSION

#define GNUNET_RPS_VERSION   0x00000000

Version of the rps API.

Definition at line 45 of file gnunet_rps_service.h.

Typedef Documentation

◆ GNUNET_RPS_NotifyReadyCB

typedef void(* GNUNET_RPS_NotifyReadyCB) (void *cls, uint64_t num_peers, const struct GNUNET_PeerIdentity *peers)

Callback called when requested random peers are available.

Parameters
clsthe closure given with the request
num_peersthe number of peers returned
peersarray with num_peers PeerIDs

Definition at line 64 of file gnunet_rps_service.h.

◆ GNUNET_RPS_NotifyReadySingleInfoCB

typedef void(* GNUNET_RPS_NotifyReadySingleInfoCB) (void *cls, const struct GNUNET_PeerIdentity *peer, double probability, uint32_t num_observed)

Callback called when requested random peer with additional information is available.

Parameters
clsthe closure given with the request
peerThe Peer ID
probabilityThe probability with which all elements have been observed
num_observedNumber of IDs this sampler has observed

Definition at line 78 of file gnunet_rps_service.h.

Function Documentation

◆ GNUNET_RPS_connect()

struct GNUNET_RPS_Handle* GNUNET_RPS_connect ( const struct GNUNET_CONFIGURATION_Handle cfg)

Connect to the rps service.

Parameters
cfgconfiguration to use
Returns
handle to the rps service
Parameters
cfgconfiguration to use
Returns
a handle to the service, NULL on error

Definition at line 836 of file rps_api.c.

References GNUNET_RPS_Handle::cfg, cfg, GNUNET_RPS_Handle::deficiency_factor, GNUNET_RPS_Handle::desired_probability, GNUNET_CONFIGURATION_get_value_float(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_config_missing(), GNUNET_new, GNUNET_OK, h, LOG, GNUNET_RPS_Handle::mq, and reconnect().

Referenced by rps_connect_adapter(), and run().

837 {
838  struct GNUNET_RPS_Handle *h;
839 
840  h = GNUNET_new (struct GNUNET_RPS_Handle);
841  h->cfg = cfg;
842  if (GNUNET_OK !=
844  "RPS",
845  "DESIRED_PROBABILITY",
846  &h->desired_probability))
847  {
849  "RPS", "DESIRED_PROBABILITY");
850  GNUNET_free (h);
851  return NULL;
852  }
853  if (0 > h->desired_probability ||
854  1 < h->desired_probability)
855  {
857  "The desired probability must be in the interval [0;1]\n");
858  GNUNET_free (h);
859  return NULL;
860  }
861  if (GNUNET_OK !=
863  "RPS",
864  "DEFICIENCY_FACTOR",
865  &h->deficiency_factor))
866  {
868  "RPS", "DEFICIENCY_FACTOR");
869  GNUNET_free (h);
870  return NULL;
871  }
872  if (0 > h->desired_probability ||
873  1 < h->desired_probability)
874  {
876  "The deficiency factor must be in the interval [0;1]\n");
877  GNUNET_free (h);
878  return NULL;
879  }
880  reconnect (h);
881  if (NULL == h->mq)
882  {
883  GNUNET_free (h);
884  return NULL;
885  }
886  return h;
887 }
static void reconnect(struct GNUNET_RPS_Handle *h)
Reconnect to the service.
Definition: rps_api.c:802
float deficiency_factor
A factor that catches the &#39;bias&#39; of a random stream of peer ids.
Definition: rps_api.c:152
int GNUNET_CONFIGURATION_get_value_float(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, float *number)
Get a configuration value that should be a floating point number.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Handler to handle requests from a client.
Definition: rps_api.c:78
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
struct GNUNET_MQ_Handle * mq
The message queue to the client.
Definition: rps_api.c:88
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
const struct GNUNET_CONFIGURATION_Handle * cfg
The handle to the client configuration.
Definition: rps_api.c:83
float desired_probability
The desired probability with which we want to have observed all peers.
Definition: rps_api.c:144
#define GNUNET_free(ptr)
Wrapper around free.
#define LOG(kind,...)
Definition: rps_api.c:36
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_RPS_sub_start()

void GNUNET_RPS_sub_start ( struct GNUNET_RPS_Handle h,
const char *  shared_value 
)

Start a sub with the given shared value.

Parameters
hHandle to rps
shared_valueThe shared value that defines the members of the sub (-group)
hHandle to rps
shared_valueThe shared value that defines the members of the sub (-gorup)

Definition at line 897 of file rps_api.c.

References GNUNET_assert, GNUNET_MESSAGE_TYPE_RPS_CS_SUB_START, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_TIME_relative_hton(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_SECONDS, GNUNET_RPS_CS_SubStartMessage::hash, hash_from_share_val(), GNUNET_RPS_Handle::mq, msg, GNUNET_TIME_RelativeNBO::rel_value_us__, and GNUNET_RPS_CS_SubStartMessage::round_interval.

899 {
901  struct GNUNET_MQ_Envelope *ev;
902 
904  hash_from_share_val (shared_value, &msg->hash);
905  msg->round_interval = GNUNET_TIME_relative_hton (// TODO read from config!
908 
909  GNUNET_MQ_send (h->mq, ev);
910 }
#define GNUNET_MESSAGE_TYPE_RPS_CS_SUB_START
RPS client-service message to start a sub sampler.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_TIME_UNIT_SECONDS
One second.
uint64_t rel_value_us__
The actual value (in network byte order).
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_MQ_Handle * mq
The message queue to the client.
Definition: rps_api.c:88
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:439
Message from client to service telling it to start a new sub.
Definition: rps.h:122
static void hash_from_share_val(const char *share_val, struct GNUNET_HashCode *hash)
Create the hash value from the share value that defines the sub (-group)
Definition: rps_api.c:747
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:622
struct GNUNET_TIME_RelativeNBO round_interval
Mean interval between two rounds.
Definition: rps.h:137
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:353
struct GNUNET_HashCode hash
Length of the shared value represented as string.
Definition: rps.h:142
Here is the call graph for this function:

◆ GNUNET_RPS_sub_stop()

void GNUNET_RPS_sub_stop ( struct GNUNET_RPS_Handle h,
const char *  shared_value 
)

Stop a sub with the given shared value.

Parameters
hHandle to rps
shared_valueThe shared value that defines the members of the sub (-group)
hHandle to rps
shared_valueThe shared value that defines the members of the sub (-gorup)

Definition at line 920 of file rps_api.c.

References GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_RPS_CS_SubStopMessage::hash, hash_from_share_val(), GNUNET_RPS_Handle::mq, and msg.

922 {
924  struct GNUNET_MQ_Envelope *ev;
925 
927  hash_from_share_val (shared_value, &msg->hash);
928 
929  GNUNET_MQ_send (h->mq, ev);
930 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP
RPS client-service message to stop a sub sampler.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_MQ_Handle * mq
The message queue to the client.
Definition: rps_api.c:88
struct GNUNET_HashCode hash
Length of the shared value represented as string.
Definition: rps.h:159
Message from client to service telling it to stop a new sub.
Definition: rps.h:149
static void hash_from_share_val(const char *share_val, struct GNUNET_HashCode *hash)
Create the hash value from the share value that defines the sub (-group)
Definition: rps_api.c:747
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:353
Here is the call graph for this function:

◆ GNUNET_RPS_request_peers()

struct GNUNET_RPS_Request_Handle* GNUNET_RPS_request_peers ( struct GNUNET_RPS_Handle rps_handle,
uint32_t  num_req_peers,
GNUNET_RPS_NotifyReadyCB  ready_cb,
void *  cls 
)

Request n random peers.

This does exacly the same as GNUNET_RPS_request_peers_single_call but needs a GNUNET_RPS_Handle. This exists only for other parts of GNUnet that expect having to (dis)connect from/to a service.

Parameters
hhandle to the rps service
nnumber of random peers to return
ready_cbthe callback to be called when the peers are available
clsa closure that will be given to the callback
Returns
handle to this request
Parameters
rps_handlehandle to the rps service
num_req_peersnumber of peers we want to receive
ready_cbthe callback called when the peers are available
clsclosure given to the callback
Returns
a handle to cancel this request

Definition at line 943 of file rps_api.c.

References collect_peers_cb(), GNUNET_RPS_Handle::deficiency_factor, GNUNET_RPS_Handle::desired_probability, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_INFO, GNUNET_new, GNUNET_RPS_stream_request(), GNUNET_TIME_UNIT_SECONDS, LOG, GNUNET_RPS_Request_Handle::num_requests, peers_ready_cb(), GNUNET_RPS_StreamRequestHandle::ready_cb, GNUNET_RPS_Request_Handle::ready_cb, GNUNET_RPS_Request_Handle::ready_cb_cls, GNUNET_RPS_Handle::rh_head, GNUNET_RPS_Handle::rh_tail, GNUNET_RPS_StreamRequestHandle::rps_handle, GNUNET_RPS_Request_Handle::rps_handle, RPS_sampler_get_n_rand_peers(), RPS_sampler_mod_init(), RPS_sampler_set_deficiency_factor(), RPS_sampler_set_desired_probability(), GNUNET_RPS_Request_Handle::sampler, GNUNET_RPS_Request_Handle::sampler_rh, and GNUNET_RPS_Request_Handle::srh.

Referenced by run().

947 {
948  struct GNUNET_RPS_Request_Handle *rh;
949 
951  "Client requested %" PRIu32 " peers\n",
952  num_req_peers);
954  rh->rps_handle = rps_handle;
955  rh->num_requests = num_req_peers;
956  rh->sampler = RPS_sampler_mod_init (num_req_peers,
957  GNUNET_TIME_UNIT_SECONDS); // TODO remove this time-stuff
959  rps_handle->desired_probability);
961  rps_handle->deficiency_factor);
963  num_req_peers,
965  rh);
966  rh->srh = GNUNET_RPS_stream_request (rps_handle,
968  rh); /* cls */
969  rh->ready_cb = ready_cb;
970  rh->ready_cb_cls = cls;
972  rps_handle->rh_tail,
973  rh);
974 
975  return rh;
976 }
static void collect_peers_cb(void *cls, uint64_t num_peers, const struct GNUNET_PeerIdentity *peers)
Callback to collect the peers from the biased stream and put those into the sampler.
Definition: rps_api.c:406
struct GNUNET_RPS_Request_Handle * rh_tail
Pointer to the tail element in DLL of request handles.
Definition: rps_api.c:128
struct GNUNET_RPS_StreamRequestHandle * srh
Request handle of the request of the biased stream of peers - needed to cancel the request...
Definition: rps_api.c:185
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
GNUNET_RPS_NotifyReadyCB ready_cb
The callback to be called when we receive an answer.
Definition: rps_api.c:190
struct RPS_Sampler * sampler
The Sampler for the client request.
Definition: rps_api.c:174
struct GNUNET_RPS_Request_Handle * rh_head
Pointer to the head element in DLL of request handles.
Definition: rps_api.c:123
void RPS_sampler_set_deficiency_factor(struct RPS_Sampler *sampler, double deficiency_factor)
Set the deficiency factor.
void RPS_sampler_set_desired_probability(struct RPS_Sampler *sampler, double desired_probability)
Set the probability that is needed at least with what a sampler element has to have observed all elem...
#define GNUNET_TIME_UNIT_SECONDS
One second.
static struct GNUNET_RPS_Handle * rps_handle
RPS handle.
Definition: gnunet-rps.c:36
float deficiency_factor
A factor that catches the &#39;bias&#39; of a random stream of peer ids.
Definition: rps_api.c:152
static void peers_ready_cb(const struct GNUNET_PeerIdentity *peers, uint32_t num_peers, void *cls)
Called once the sampler has collected all requested peers.
Definition: rps_api.c:355
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct RPS_Sampler * RPS_sampler_mod_init(size_t init_size, struct GNUNET_TIME_Relative max_round_interval)
Initialise a modified tuple of sampler elements.
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:164
struct RPS_SamplerRequestHandle * RPS_sampler_get_n_rand_peers(struct RPS_Sampler *sampler, uint32_t num_peers, RPS_sampler_n_rand_peers_ready_cb cb, void *cls)
Get n random peers out of the sampled peers.
struct RPS_SamplerRequestHandle * sampler_rh
Request handle of the request to the sampler - needed to cancel the request.
Definition: rps_api.c:179
void * ready_cb_cls
The closure for the callback.
Definition: rps_api.c:195
uint32_t num_requests
The number of requested peers.
Definition: rps_api.c:169
struct GNUNET_RPS_StreamRequestHandle * GNUNET_RPS_stream_request(struct GNUNET_RPS_Handle *rps_handle, GNUNET_RPS_NotifyReadyCB stream_input_cb, void *cls)
Request biased stream of peers that are being put into the sampler.
Definition: rps_api.c:503
Handler for a single request from a client.
Definition: rps_api.c:159
float desired_probability
The desired probability with which we want to have observed all peers.
Definition: rps_api.c:144
#define LOG(kind,...)
Definition: rps_api.c:36
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_RPS_request_peer_info()

struct GNUNET_RPS_Request_Handle_Single_Info* GNUNET_RPS_request_peer_info ( struct GNUNET_RPS_Handle rps_handle,
GNUNET_RPS_NotifyReadySingleInfoCB  ready_cb,
void *  cls 
)

Request one random peer, getting additional information.

Parameters
rps_handlehandle to the rps service
ready_cbthe callback called when the peers are available
clsclosure given to the callback
Returns
a handle to cancel this request

Definition at line 988 of file rps_api.c.

References collect_peers_info_cb(), GNUNET_RPS_Handle::deficiency_factor, GNUNET_RPS_Handle::desired_probability, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_INFO, GNUNET_new, GNUNET_RPS_stream_request(), GNUNET_TIME_UNIT_SECONDS, LOG, peer_info_ready_cb(), GNUNET_RPS_StreamRequestHandle::ready_cb, GNUNET_RPS_Request_Handle_Single_Info::ready_cb, GNUNET_RPS_Request_Handle_Single_Info::ready_cb_cls, GNUNET_RPS_Handle::rhs_head, GNUNET_RPS_Handle::rhs_tail, GNUNET_RPS_StreamRequestHandle::rps_handle, GNUNET_RPS_Request_Handle_Single_Info::rps_handle, RPS_sampler_get_rand_peer_info(), RPS_sampler_mod_init(), RPS_sampler_set_deficiency_factor(), RPS_sampler_set_desired_probability(), GNUNET_RPS_Request_Handle_Single_Info::sampler, GNUNET_RPS_Request_Handle_Single_Info::sampler_rh, and GNUNET_RPS_Request_Handle_Single_Info::srh.

Referenced by request_peers().

991 {
993  uint32_t num_req_peers = 1;
994 
996  "Client requested peer with additional info\n");
998  rhs->rps_handle = rps_handle;
999  rhs->sampler = RPS_sampler_mod_init (num_req_peers,
1000  GNUNET_TIME_UNIT_SECONDS); // TODO remove this time-stuff
1002  rps_handle->desired_probability);
1004  rps_handle->deficiency_factor);
1007  rhs);
1008  rhs->srh = GNUNET_RPS_stream_request (rps_handle,
1010  rhs); /* cls */
1011  rhs->ready_cb = ready_cb;
1012  rhs->ready_cb_cls = cls;
1014  rps_handle->rhs_tail,
1015  rhs);
1016 
1017  return rhs;
1018 }
struct GNUNET_RPS_Request_Handle_Single_Info * rhs_head
Pointer to the head element in DLL of single request handles.
Definition: rps_api.c:133
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
void RPS_sampler_set_deficiency_factor(struct RPS_Sampler *sampler, double deficiency_factor)
Set the deficiency factor.
void RPS_sampler_set_desired_probability(struct RPS_Sampler *sampler, double desired_probability)
Set the probability that is needed at least with what a sampler element has to have observed all elem...
#define GNUNET_TIME_UNIT_SECONDS
One second.
static struct GNUNET_RPS_Handle * rps_handle
RPS handle.
Definition: gnunet-rps.c:36
float deficiency_factor
A factor that catches the &#39;bias&#39; of a random stream of peer ids.
Definition: rps_api.c:152
void * ready_cb_cls
The closure for the callback.
Definition: rps_api.c:243
static void collect_peers_info_cb(void *cls, uint64_t num_peers, const struct GNUNET_PeerIdentity *peers)
Callback to collect the peers from the biased stream and put those into the sampler.
Definition: rps_api.c:433
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:217
struct RPS_Sampler * RPS_sampler_mod_init(size_t init_size, struct GNUNET_TIME_Relative max_round_interval)
Initialise a modified tuple of sampler elements.
static void peer_info_ready_cb(const struct GNUNET_PeerIdentity *peers, void *cls, double probability, uint32_t num_observed)
Called once the sampler has collected the requested peer.
Definition: rps_api.c:381
struct RPS_SamplerRequestHandleSingleInfo * RPS_sampler_get_rand_peer_info(struct RPS_Sampler *sampler, RPS_sampler_sinlge_info_ready_cb cb, void *cls)
Get one random peer with additional information.
Handler for a single request from a client.
Definition: rps_api.c:212
struct GNUNET_RPS_StreamRequestHandle * srh
Request handle of the request of the biased stream of peers - needed to cancel the request...
Definition: rps_api.c:233
struct RPS_SamplerRequestHandleSingleInfo * sampler_rh
Request handle of the request to the sampler - needed to cancel the request.
Definition: rps_api.c:227
GNUNET_RPS_NotifyReadySingleInfoCB ready_cb
The callback to be called when we receive an answer.
Definition: rps_api.c:238
struct RPS_Sampler * sampler
The Sampler for the client request.
Definition: rps_api.c:222
struct GNUNET_RPS_Request_Handle_Single_Info * rhs_tail
Pointer to the tail element in DLL of single request handles.
Definition: rps_api.c:138
struct GNUNET_RPS_StreamRequestHandle * GNUNET_RPS_stream_request(struct GNUNET_RPS_Handle *rps_handle, GNUNET_RPS_NotifyReadyCB stream_input_cb, void *cls)
Request biased stream of peers that are being put into the sampler.
Definition: rps_api.c:503
float desired_probability
The desired probability with which we want to have observed all peers.
Definition: rps_api.c:144
#define LOG(kind,...)
Definition: rps_api.c:36
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_RPS_seed_ids()

void GNUNET_RPS_seed_ids ( struct GNUNET_RPS_Handle h,
uint32_t  n,
const struct GNUNET_PeerIdentity ids 
)

Seed rps service with peerIDs.

Parameters
hhandle to the rps service
nnumber of peers to seed
idsthe ids of the peers seeded

Definition at line 1029 of file rps_api.c.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_RPS_CS_SEED, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), ids, LOG, GNUNET_RPS_Handle::mq, msg, num_peers, GNUNET_RPS_CS_SeedMessage::num_peers, peer_ids, target_peer, and type.

Referenced by run(), and seed_peers().

1032 {
1033  size_t size_needed;
1034  uint32_t num_peers_max;
1035  const struct GNUNET_PeerIdentity *tmp_peer_pointer;
1036  struct GNUNET_MQ_Envelope *ev;
1038 
1040  "Client wants to seed %" PRIu32 " peers:\n",
1041  n);
1042  for (unsigned int i = 0 ; i < n ; i++)
1044  "%u. peer: %s\n",
1045  i,
1046  GNUNET_i2s (&ids[i]));
1047 
1048  /* The actual size the message occupies */
1049  size_needed = sizeof (struct GNUNET_RPS_CS_SeedMessage) +
1050  n * sizeof (struct GNUNET_PeerIdentity);
1051  /* The number of peers that fits in one message together with
1052  * the respective header */
1053  num_peers_max = (GNUNET_MAX_MESSAGE_SIZE -
1054  sizeof (struct GNUNET_RPS_CS_SeedMessage)) /
1055  sizeof (struct GNUNET_PeerIdentity);
1056  tmp_peer_pointer = ids;
1057 
1058  while (GNUNET_MAX_MESSAGE_SIZE < size_needed)
1059  {
1060  ev = GNUNET_MQ_msg_extra (msg,
1061  num_peers_max * sizeof (struct GNUNET_PeerIdentity),
1063  msg->num_peers = htonl (num_peers_max);
1064  GNUNET_memcpy (&msg[1],
1065  tmp_peer_pointer,
1066  num_peers_max * sizeof (struct GNUNET_PeerIdentity));
1067  GNUNET_MQ_send (h->mq,
1068  ev);
1069  n -= num_peers_max;
1070  size_needed = sizeof (struct GNUNET_RPS_CS_SeedMessage) +
1071  n * sizeof (struct GNUNET_PeerIdentity);
1072  /* Set pointer to beginning of next block of num_peers_max peers */
1073  tmp_peer_pointer = &ids[num_peers_max];
1074  }
1075 
1076  ev = GNUNET_MQ_msg_extra (msg,
1077  n * sizeof (struct GNUNET_PeerIdentity),
1079  msg->num_peers = htonl (n);
1080  GNUNET_memcpy (&msg[1],
1081  tmp_peer_pointer,
1082  n * sizeof (struct GNUNET_PeerIdentity));
1083  GNUNET_MQ_send (h->mq,
1084  ev);
1085 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
Message from client to service with seed of peers.
Definition: rps.h:67
#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_memcpy(dst, src, n)
struct GNUNET_MQ_Handle * mq
The message queue to the client.
Definition: rps_api.c:88
static struct GNUNET_CONTAINER_MultiPeerMap * ids
GNUNET_PeerIdentity -> CadetPeer.
#define GNUNET_MESSAGE_TYPE_RPS_CS_SEED
RPS CS SEED Message for the Client to seed peers into rps.
uint32_t num_peers
Number of peers.
Definition: rps.h:77
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
The identity of the host (wraps the signing key of the peer).
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:353
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define LOG(kind,...)
Definition: rps_api.c:36
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_RPS_request_cancel()

void GNUNET_RPS_request_cancel ( struct GNUNET_RPS_Request_Handle rh)

Cancle an issued request.

Parameters
rhhandle of the pending request to be canceled
rhrequest handle of request to cancle

Definition at line 1187 of file rps_api.c.

References cancel_stream(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_RPS_stream_cancel(), h, GNUNET_RPS_Handle::rh_head, GNUNET_RPS_Handle::rh_tail, GNUNET_RPS_StreamRequestHandle::rps_handle, GNUNET_RPS_Request_Handle::rps_handle, RPS_sampler_destroy(), RPS_sampler_request_cancel(), GNUNET_RPS_Request_Handle::sampler, GNUNET_RPS_Request_Handle::sampler_rh, GNUNET_RPS_Request_Handle::srh, and GNUNET_RPS_Handle::stream_requests_head.

Referenced by do_shutdown(), GNUNET_RPS_disconnect(), and peers_ready_cb().

1188 {
1189  struct GNUNET_RPS_Handle *h;
1190 
1191  h = rh->rps_handle;
1192  GNUNET_assert (NULL != rh);
1193  GNUNET_assert (NULL != rh->srh);
1194  GNUNET_assert (h == rh->srh->rps_handle);
1196  rh->srh = NULL;
1197  if (NULL == h->stream_requests_head) cancel_stream(h);
1198  if (NULL != rh->sampler_rh)
1199  {
1201  }
1203  rh->sampler = NULL;
1205  h->rh_tail,
1206  rh);
1207  GNUNET_free (rh);
1208 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_RPS_Request_Handle * rh_tail
Pointer to the tail element in DLL of request handles.
Definition: rps_api.c:128
struct GNUNET_RPS_StreamRequestHandle * srh
Request handle of the request of the biased stream of peers - needed to cancel the request...
Definition: rps_api.c:185
struct RPS_Sampler * sampler
The Sampler for the client request.
Definition: rps_api.c:174
struct GNUNET_RPS_Request_Handle * rh_head
Pointer to the head element in DLL of request handles.
Definition: rps_api.c:123
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void GNUNET_RPS_stream_cancel(struct GNUNET_RPS_StreamRequestHandle *srh)
Cancel a specific request for updates from the biased peer stream.
Definition: rps_api.c:597
static void cancel_stream(struct GNUNET_RPS_Handle *rps_handle)
Send message to service that this client does not want to receive further updates from the biased pee...
Definition: rps_api.c:582
Handler to handle requests from a client.
Definition: rps_api.c:78
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:164
void RPS_sampler_destroy(struct RPS_Sampler *sampler)
Cleans the samplers.
struct RPS_SamplerRequestHandle * sampler_rh
Request handle of the request to the sampler - needed to cancel the request.
Definition: rps_api.c:179
struct GNUNET_RPS_StreamRequestHandle * stream_requests_head
Head of the DLL of stream requests.
Definition: rps_api.c:108
void RPS_sampler_request_cancel(struct RPS_SamplerRequestHandle *req_handle)
Cancle a request issued through RPS_sampler_n_rand_peers_ready_cb.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:46
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_RPS_request_single_info_cancel()

void GNUNET_RPS_request_single_info_cancel ( struct GNUNET_RPS_Request_Handle_Single_Info rhs)

Cancle an issued single info request.

Parameters
rhsrequest handle of request to cancle

Definition at line 1217 of file rps_api.c.

References cancel_stream(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_RPS_stream_cancel(), h, GNUNET_RPS_Handle::rhs_head, GNUNET_RPS_Handle::rhs_tail, GNUNET_RPS_StreamRequestHandle::rps_handle, GNUNET_RPS_Request_Handle_Single_Info::rps_handle, RPS_sampler_destroy(), RPS_sampler_request_single_info_cancel(), GNUNET_RPS_Request_Handle_Single_Info::sampler, GNUNET_RPS_Request_Handle_Single_Info::sampler_rh, GNUNET_RPS_Request_Handle_Single_Info::srh, and GNUNET_RPS_Handle::stream_requests_head.

Referenced by cancel_request(), GNUNET_RPS_disconnect(), and peer_info_ready_cb().

1219 {
1220  struct GNUNET_RPS_Handle *h;
1221 
1222  h = rhs->rps_handle;
1223  GNUNET_assert (NULL != rhs);
1224  GNUNET_assert (NULL != rhs->srh);
1225  GNUNET_assert (h == rhs->srh->rps_handle);
1227  rhs->srh = NULL;
1228  if (NULL == h->stream_requests_head) cancel_stream(h);
1229  if (NULL != rhs->sampler_rh)
1230  {
1232  }
1234  rhs->sampler = NULL;
1236  h->rhs_tail,
1237  rhs);
1238  GNUNET_free (rhs);
1239 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_RPS_Request_Handle_Single_Info * rhs_head
Pointer to the head element in DLL of single request handles.
Definition: rps_api.c:133
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void RPS_sampler_request_single_info_cancel(struct RPS_SamplerRequestHandleSingleInfo *req_single_info_handle)
Cancle a request issued through RPS_sampler_sinlge_info_ready_cb.
void GNUNET_RPS_stream_cancel(struct GNUNET_RPS_StreamRequestHandle *srh)
Cancel a specific request for updates from the biased peer stream.
Definition: rps_api.c:597
static void cancel_stream(struct GNUNET_RPS_Handle *rps_handle)
Send message to service that this client does not want to receive further updates from the biased pee...
Definition: rps_api.c:582
Handler to handle requests from a client.
Definition: rps_api.c:78
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:217
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
void RPS_sampler_destroy(struct RPS_Sampler *sampler)
Cleans the samplers.
struct GNUNET_RPS_StreamRequestHandle * stream_requests_head
Head of the DLL of stream requests.
Definition: rps_api.c:108
struct GNUNET_RPS_StreamRequestHandle * srh
Request handle of the request of the biased stream of peers - needed to cancel the request...
Definition: rps_api.c:233
struct RPS_SamplerRequestHandleSingleInfo * sampler_rh
Request handle of the request to the sampler - needed to cancel the request.
Definition: rps_api.c:227
struct RPS_Sampler * sampler
The Sampler for the client request.
Definition: rps_api.c:222
struct GNUNET_RPS_Request_Handle_Single_Info * rhs_tail
Pointer to the tail element in DLL of single request handles.
Definition: rps_api.c:138
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:46
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_RPS_view_request()

void GNUNET_RPS_view_request ( struct GNUNET_RPS_Handle rps_handle,
uint32_t  num_updates,
GNUNET_RPS_NotifyReadyCB  view_update_cb,
void *  cls 
)

Request updates of view.

Parameters
rps_handlehandle to the rps service
num_req_peersnumber of peers we want to receive (0 for infinite updates)
clsa closure that will be given to the callback
ready_cbthe callback called when the peers are available

Definition at line 461 of file rps_api.c.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST, GNUNET_MQ_msg, GNUNET_MQ_send(), LOG, GNUNET_RPS_Handle::mq, msg, GNUNET_RPS_CS_DEBUG_ViewRequest::num_updates, GNUNET_RPS_Handle::view_update_cb, view_update_cb(), and GNUNET_RPS_Handle::view_update_cls.

Referenced by pre_profiler(), and run().

465 {
466  struct GNUNET_MQ_Envelope *ev;
468 
470  "Client requests %" PRIu32 " view updates\n",
471  num_updates);
472  rps_handle->view_update_cb = view_update_cb;
473  rps_handle->view_update_cls = cls;
474 
476  msg->num_updates = htonl (num_updates);
477  GNUNET_MQ_send (rps_handle->mq, ev);
478 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint32_t num_updates
Number of updates 0 for sending updates until cancellation.
Definition: rps.h:180
Message from client to service indicating that clients wants to get updates of the view...
Definition: rps.h:169
#define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST
Request updates of the view.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
GNUNET_RPS_NotifyReadyCB view_update_cb
Callback called on each update of the view.
Definition: rps_api.c:93
struct GNUNET_MQ_Handle * mq
The message queue to the client.
Definition: rps_api.c:88
void view_update_cb(void *cls, uint64_t view_size, const struct GNUNET_PeerIdentity *peers)
void * view_update_cls
Closure to each requested update of the view.
Definition: rps_api.c:98
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:353
#define LOG(kind,...)
Definition: rps_api.c:36
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_RPS_stream_request()

struct GNUNET_RPS_StreamRequestHandle* GNUNET_RPS_stream_request ( struct GNUNET_RPS_Handle rps_handle,
GNUNET_RPS_NotifyReadyCB  stream_input_cb,
void *  cls 
)

Request biased stream of peers that are being put into the sampler.

Parameters
rps_handlehandle to the rps service
clsa closure that will be given to the callback
ready_cbthe callback called when the peers are available

Definition at line 503 of file rps_api.c.

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REQUEST, GNUNET_MQ_msg, GNUNET_MQ_send(), LOG, GNUNET_RPS_Handle::mq, msg, and new_stream_request().

Referenced by GNUNET_RPS_request_peer_info(), GNUNET_RPS_request_peers(), and run().

506 {
507  struct GNUNET_RPS_StreamRequestHandle *srh;
508  struct GNUNET_MQ_Envelope *ev;
510 
511  srh = new_stream_request (rps_handle,
512  stream_input_cb,
513  cls);
514  LOG (GNUNET_ERROR_TYPE_DEBUG, "Client requests biased stream updates\n");
515 
517  GNUNET_MQ_send (rps_handle->mq, ev);
518  return srh;
519 }
Handle for a request to get peers from biased stream of ids.
Definition: rps_api.c:41
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
Message from client to service indicating that clients wants to get stream of biased peers...
Definition: rps.h:209
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_MQ_Handle * mq
The message queue to the client.
Definition: rps_api.c:88
static struct GNUNET_RPS_StreamRequestHandle * new_stream_request(struct GNUNET_RPS_Handle *rps_handle, GNUNET_RPS_NotifyReadyCB ready_cb, void *cls)
Create a new handle for a stream request.
Definition: rps_api.c:304
#define GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REQUEST
Request biased input stream.
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:353
#define LOG(kind,...)
Definition: rps_api.c:36
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_RPS_stream_cancel()

void GNUNET_RPS_stream_cancel ( struct GNUNET_RPS_StreamRequestHandle srh)

Cancel a specific request for updates from the biased peer stream.

Parameters
srhThe request handle to cancel

Definition at line 597 of file rps_api.c.

References cancel_stream(), remove_stream_request(), GNUNET_RPS_StreamRequestHandle::rps_handle, and GNUNET_RPS_Handle::stream_requests_head.

Referenced by GNUNET_RPS_disconnect(), GNUNET_RPS_request_cancel(), and GNUNET_RPS_request_single_info_cancel().

598 {
600 
601  rps_handle = srh->rps_handle;
602  remove_stream_request (srh);
603  if (NULL == rps_handle->stream_requests_head)
604  cancel_stream (rps_handle);
605 }
static struct GNUNET_RPS_Handle * rps_handle
RPS handle.
Definition: gnunet-rps.c:36
static void cancel_stream(struct GNUNET_RPS_Handle *rps_handle)
Send message to service that this client does not want to receive further updates from the biased pee...
Definition: rps_api.c:582
static void remove_stream_request(struct GNUNET_RPS_StreamRequestHandle *srh)
Remove the given stream request from the list of requests and memory.
Definition: rps_api.c:328
Handler to handle requests from a client.
Definition: rps_api.c:78
struct GNUNET_RPS_StreamRequestHandle * stream_requests_head
Head of the DLL of stream requests.
Definition: rps_api.c:108
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:46
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_RPS_disconnect()

void GNUNET_RPS_disconnect ( struct GNUNET_RPS_Handle h)

Disconnect from the rps service.

Parameters
hthe handle to the rps service

Definition at line 1248 of file rps_api.c.

References GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_NSE_disconnect(), GNUNET_RPS_request_cancel(), GNUNET_RPS_request_single_info_cancel(), GNUNET_RPS_stream_cancel(), GNUNET_RPS_view_request_cancel(), LOG, GNUNET_RPS_Handle::mq, GNUNET_RPS_StreamRequestHandle::next, GNUNET_RPS_Handle::nse, GNUNET_RPS_Handle::rh_head, GNUNET_RPS_Handle::rhs_head, GNUNET_RPS_Handle::stream_requests_head, and GNUNET_RPS_Handle::view_update_cb.

Referenced by do_shutdown(), and rps_disconnect_adapter().

1249 {
1250  if (NULL != h->stream_requests_head)
1251  {
1252  struct GNUNET_RPS_StreamRequestHandle *srh_next;
1253 
1255  "Still waiting for replies\n");
1256  for (struct GNUNET_RPS_StreamRequestHandle *srh_iter = h->stream_requests_head;
1257  NULL != srh_iter;
1258  srh_iter = srh_next)
1259  {
1260  srh_next = srh_iter->next;
1261  GNUNET_RPS_stream_cancel (srh_iter);
1262  }
1263  }
1264  if (NULL != h->rh_head)
1265  {
1267  "Not all requests were cancelled!\n");
1268  for (struct GNUNET_RPS_Request_Handle *rh_iter = h->rh_head;
1269  h->rh_head != NULL;
1270  rh_iter = h->rh_head)
1271  {
1272  GNUNET_RPS_request_cancel (rh_iter);
1273  }
1274  }
1275  if (NULL != h->rhs_head)
1276  {
1278  "Not all requests were cancelled!\n");
1279  for (struct GNUNET_RPS_Request_Handle_Single_Info *rhs_iter = h->rhs_head;
1280  h->rhs_head != NULL;
1281  rhs_iter = h->rhs_head)
1282  {
1284  }
1285  }
1286  if (NULL != srh_callback_peers)
1287  {
1289  srh_callback_peers = NULL;
1290  }
1291  if (NULL != h->view_update_cb)
1292  {
1294  "Still waiting for view updates\n");
1296  }
1297  if (NULL != h->nse)
1299  GNUNET_MQ_destroy (h->mq);
1300  GNUNET_free (h);
1301 }
struct GNUNET_RPS_Request_Handle_Single_Info * rhs_head
Pointer to the head element in DLL of single request handles.
Definition: rps_api.c:133
Handle for a request to get peers from biased stream of ids.
Definition: rps_api.c:41
struct GNUNET_RPS_Request_Handle * rh_head
Pointer to the head element in DLL of request handles.
Definition: rps_api.c:123
void GNUNET_RPS_stream_cancel(struct GNUNET_RPS_StreamRequestHandle *srh)
Cancel a specific request for updates from the biased peer stream.
Definition: rps_api.c:597
GNUNET_RPS_NotifyReadyCB view_update_cb
Callback called on each update of the view.
Definition: rps_api.c:93
void GNUNET_RPS_request_single_info_cancel(struct GNUNET_RPS_Request_Handle_Single_Info *rhs)
Cancle an issued single info request.
Definition: rps_api.c:1217
struct GNUNET_MQ_Handle * mq
The message queue to the client.
Definition: rps_api.c:88
struct GNUNET_RPS_StreamRequestHandle * stream_requests_head
Head of the DLL of stream requests.
Definition: rps_api.c:108
Handler for a single request from a client.
Definition: rps_api.c:212
void GNUNET_NSE_disconnect(struct GNUNET_NSE_Handle *h)
Disconnect from network size estimation service.
Definition: nse_api.c:193
void GNUNET_RPS_view_request_cancel(struct GNUNET_RPS_Handle *rps_handle)
Definition: rps_api.c:482
void GNUNET_RPS_request_cancel(struct GNUNET_RPS_Request_Handle *rh)
Cancle an issued request.
Definition: rps_api.c:1187
struct GNUNET_NSE_Handle * nse
Handle to nse service.
Definition: rps_api.c:118
static struct GNUNET_PeerIdentity * srh_callback_peers
Peers received from the biased stream to be passed to all srh_handlers.
Definition: rps_api.c:284
struct GNUNET_RPS_StreamRequestHandle * next
Next element of the DLL.
Definition: rps_api.c:66
Handler for a single request from a client.
Definition: rps_api.c:159
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
#define GNUNET_free(ptr)
Wrapper around free.
#define LOG(kind,...)
Definition: rps_api.c:36
Here is the call graph for this function:
Here is the caller graph for this function: