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 835 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().

836 {
837  struct GNUNET_RPS_Handle *h;
838 
839  h = GNUNET_new(struct GNUNET_RPS_Handle);
840  h->cfg = cfg;
841  if (GNUNET_OK !=
843  "RPS",
844  "DESIRED_PROBABILITY",
845  &h->desired_probability))
846  {
848  "RPS", "DESIRED_PROBABILITY");
849  GNUNET_free(h);
850  return NULL;
851  }
852  if (0 > h->desired_probability ||
853  1 < h->desired_probability)
854  {
856  "The desired probability must be in the interval [0;1]\n");
857  GNUNET_free(h);
858  return NULL;
859  }
860  if (GNUNET_OK !=
862  "RPS",
863  "DEFICIENCY_FACTOR",
864  &h->deficiency_factor))
865  {
867  "RPS", "DEFICIENCY_FACTOR");
868  GNUNET_free(h);
869  return NULL;
870  }
871  if (0 > h->desired_probability ||
872  1 < h->desired_probability)
873  {
875  "The deficiency factor must be in the interval [0;1]\n");
876  GNUNET_free(h);
877  return NULL;
878  }
879  reconnect(h);
880  if (NULL == h->mq)
881  {
882  GNUNET_free(h);
883  return NULL;
884  }
885  return h;
886 }
static void reconnect(struct GNUNET_RPS_Handle *h)
Reconnect to the service.
Definition: rps_api.c:801
float deficiency_factor
A factor that catches the &#39;bias&#39; of a random stream of peer ids.
Definition: rps_api.c:150
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:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Handler to handle requests from a client.
Definition: rps_api.c:77
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:86
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:81
float desired_probability
The desired probability with which we want to have observed all peers.
Definition: rps_api.c:142
#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 896 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.

898 {
900  struct GNUNET_MQ_Envelope *ev;
901 
903  hash_from_share_val(shared_value, &msg->hash);
904  msg->round_interval = GNUNET_TIME_relative_hton( // TODO read from config!
907 
908  GNUNET_MQ_send(h->mq, ev);
909 }
#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:86
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:440
Message from client to service telling it to start a new sub.
Definition: rps.h:119
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:745
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:623
struct GNUNET_TIME_RelativeNBO round_interval
Mean interval between two rounds.
Definition: rps.h:133
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:351
struct GNUNET_HashCode hash
Length of the shared value represented as string.
Definition: rps.h:138
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 919 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.

921 {
923  struct GNUNET_MQ_Envelope *ev;
924 
926  hash_from_share_val(shared_value, &msg->hash);
927 
928  GNUNET_MQ_send(h->mq, ev);
929 }
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:86
struct GNUNET_HashCode hash
Length of the shared value represented as string.
Definition: rps.h:154
Message from client to service telling it to stop a new sub.
Definition: rps.h:145
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:745
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:351
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 942 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().

946 {
947  struct GNUNET_RPS_Request_Handle *rh;
948 
950  "Client requested %" PRIu32 " peers\n",
951  num_req_peers);
953  rh->rps_handle = rps_handle;
954  rh->num_requests = num_req_peers;
955  rh->sampler = RPS_sampler_mod_init(num_req_peers,
956  GNUNET_TIME_UNIT_SECONDS); // TODO remove this time-stuff
958  rps_handle->desired_probability);
960  rps_handle->deficiency_factor);
962  num_req_peers,
964  rh);
965  rh->srh = GNUNET_RPS_stream_request(rps_handle,
967  rh); /* cls */
968  rh->ready_cb = ready_cb;
969  rh->ready_cb_cls = cls;
971  rps_handle->rh_tail,
972  rh);
973 
974  return rh;
975 }
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:401
struct GNUNET_RPS_Request_Handle * rh_tail
Pointer to the tail element in DLL of request handles.
Definition: rps_api.c:126
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:182
#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:187
struct RPS_Sampler * sampler
The Sampler for the client request.
Definition: rps_api.c:171
struct GNUNET_RPS_Request_Handle * rh_head
Pointer to the head element in DLL of request handles.
Definition: rps_api.c:121
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:150
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:350
#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:161
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:176
void * ready_cb_cls
The closure for the callback.
Definition: rps_api.c:192
uint32_t num_requests
The number of requested peers.
Definition: rps_api.c:166
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:498
Handler for a single request from a client.
Definition: rps_api.c:157
float desired_probability
The desired probability with which we want to have observed all peers.
Definition: rps_api.c:142
#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 987 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().

990 {
992  uint32_t num_req_peers = 1;
993 
995  "Client requested peer with additional info\n");
997  rhs->rps_handle = rps_handle;
998  rhs->sampler = RPS_sampler_mod_init(num_req_peers,
999  GNUNET_TIME_UNIT_SECONDS); // TODO remove this time-stuff
1001  rps_handle->desired_probability);
1003  rps_handle->deficiency_factor);
1006  rhs);
1007  rhs->srh = GNUNET_RPS_stream_request(rps_handle,
1009  rhs); /* cls */
1010  rhs->ready_cb = ready_cb;
1011  rhs->ready_cb_cls = cls;
1013  rps_handle->rhs_tail,
1014  rhs);
1015 
1016  return rhs;
1017 }
struct GNUNET_RPS_Request_Handle_Single_Info * rhs_head
Pointer to the head element in DLL of single request handles.
Definition: rps_api.c:131
#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:150
void * ready_cb_cls
The closure for the callback.
Definition: rps_api.c:239
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:428
#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:213
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:376
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:209
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:229
struct RPS_SamplerRequestHandleSingleInfo * sampler_rh
Request handle of the request to the sampler - needed to cancel the request.
Definition: rps_api.c:223
GNUNET_RPS_NotifyReadySingleInfoCB ready_cb
The callback to be called when we receive an answer.
Definition: rps_api.c:234
struct RPS_Sampler * sampler
The Sampler for the client request.
Definition: rps_api.c:218
struct GNUNET_RPS_Request_Handle_Single_Info * rhs_tail
Pointer to the tail element in DLL of single request handles.
Definition: rps_api.c:136
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:498
float desired_probability
The desired probability with which we want to have observed all peers.
Definition: rps_api.c:142
#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 1028 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().

1031 {
1032  size_t size_needed;
1033  uint32_t num_peers_max;
1034  const struct GNUNET_PeerIdentity *tmp_peer_pointer;
1035  struct GNUNET_MQ_Envelope *ev;
1037 
1039  "Client wants to seed %" PRIu32 " peers:\n",
1040  n);
1041  for (unsigned int i = 0; i < n; i++)
1043  "%u. peer: %s\n",
1044  i,
1045  GNUNET_i2s(&ids[i]));
1046 
1047  /* The actual size the message occupies */
1048  size_needed = sizeof(struct GNUNET_RPS_CS_SeedMessage) +
1049  n * sizeof(struct GNUNET_PeerIdentity);
1050  /* The number of peers that fits in one message together with
1051  * the respective header */
1052  num_peers_max = (GNUNET_MAX_MESSAGE_SIZE -
1053  sizeof(struct GNUNET_RPS_CS_SeedMessage)) /
1054  sizeof(struct GNUNET_PeerIdentity);
1055  tmp_peer_pointer = ids;
1056 
1057  while (GNUNET_MAX_MESSAGE_SIZE < size_needed)
1058  {
1059  ev = GNUNET_MQ_msg_extra(msg,
1060  num_peers_max * sizeof(struct GNUNET_PeerIdentity),
1062  msg->num_peers = htonl(num_peers_max);
1063  GNUNET_memcpy(&msg[1],
1064  tmp_peer_pointer,
1065  num_peers_max * sizeof(struct GNUNET_PeerIdentity));
1066  GNUNET_MQ_send(h->mq,
1067  ev);
1068  n -= num_peers_max;
1069  size_needed = sizeof(struct GNUNET_RPS_CS_SeedMessage) +
1070  n * sizeof(struct GNUNET_PeerIdentity);
1071  /* Set pointer to beginning of next block of num_peers_max peers */
1072  tmp_peer_pointer = &ids[num_peers_max];
1073  }
1074 
1075  ev = GNUNET_MQ_msg_extra(msg,
1076  n * sizeof(struct GNUNET_PeerIdentity),
1078  msg->num_peers = htonl(n);
1079  GNUNET_memcpy(&msg[1],
1080  tmp_peer_pointer,
1081  n * sizeof(struct GNUNET_PeerIdentity));
1082  GNUNET_MQ_send(h->mq,
1083  ev);
1084 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Message from client to service with seed of peers.
Definition: rps.h:66
#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
struct GNUNET_MQ_Handle * mq
The message queue to the client.
Definition: rps_api.c:86
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:75
#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:351
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 1186 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().

1187 {
1188  struct GNUNET_RPS_Handle *h;
1189 
1190  h = rh->rps_handle;
1191  GNUNET_assert(NULL != rh);
1192  GNUNET_assert(NULL != rh->srh);
1193  GNUNET_assert(h == rh->srh->rps_handle);
1195  rh->srh = NULL;
1196  if (NULL == h->stream_requests_head)
1197  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:126
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:182
struct RPS_Sampler * sampler
The Sampler for the client request.
Definition: rps_api.c:171
struct GNUNET_RPS_Request_Handle * rh_head
Pointer to the head element in DLL of request handles.
Definition: rps_api.c:121
#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:593
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:578
Handler to handle requests from a client.
Definition: rps_api.c:77
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:161
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:176
struct GNUNET_RPS_StreamRequestHandle * stream_requests_head
Head of the DLL of stream requests.
Definition: rps_api.c:106
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:45
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)
1229  cancel_stream(h);
1230  if (NULL != rhs->sampler_rh)
1231  {
1233  }
1235  rhs->sampler = NULL;
1237  h->rhs_tail,
1238  rhs);
1239  GNUNET_free(rhs);
1240 }
#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:131
#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:593
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:578
Handler to handle requests from a client.
Definition: rps_api.c:77
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:213
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:106
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:229
struct RPS_SamplerRequestHandleSingleInfo * sampler_rh
Request handle of the request to the sampler - needed to cancel the request.
Definition: rps_api.c:223
struct RPS_Sampler * sampler
The Sampler for the client request.
Definition: rps_api.c:218
struct GNUNET_RPS_Request_Handle_Single_Info * rhs_tail
Pointer to the tail element in DLL of single request handles.
Definition: rps_api.c:136
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:45
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 456 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().

460 {
461  struct GNUNET_MQ_Envelope *ev;
463 
465  "Client requests %" PRIu32 " view updates\n",
466  num_updates);
467  rps_handle->view_update_cb = view_update_cb;
468  rps_handle->view_update_cls = cls;
469 
471  msg->num_updates = htonl(num_updates);
472  GNUNET_MQ_send(rps_handle->mq, ev);
473 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint32_t num_updates
Number of updates 0 for sending updates until cancellation.
Definition: rps.h:174
Message from client to service indicating that clients wants to get updates of the view...
Definition: rps.h:164
#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:91
struct GNUNET_MQ_Handle * mq
The message queue to the client.
Definition: rps_api.c:86
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:96
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:351
#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 498 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().

501 {
502  struct GNUNET_RPS_StreamRequestHandle *srh;
503  struct GNUNET_MQ_Envelope *ev;
505 
506  srh = new_stream_request(rps_handle,
507  stream_input_cb,
508  cls);
509  LOG(GNUNET_ERROR_TYPE_DEBUG, "Client requests biased stream updates\n");
510 
512  GNUNET_MQ_send(rps_handle->mq, ev);
513  return srh;
514 }
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:202
#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:86
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:299
#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:351
#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 593 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().

594 {
596 
597  rps_handle = srh->rps_handle;
599  if (NULL == rps_handle->stream_requests_head)
600  cancel_stream(rps_handle);
601 }
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:578
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:323
Handler to handle requests from a client.
Definition: rps_api.c:77
struct GNUNET_RPS_StreamRequestHandle * stream_requests_head
Head of the DLL of stream requests.
Definition: rps_api.c:106
struct GNUNET_RPS_Handle * rps_handle
The client issuing the request.
Definition: rps_api.c:45
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 1249 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().

1250 {
1251  if (NULL != h->stream_requests_head)
1252  {
1253  struct GNUNET_RPS_StreamRequestHandle *srh_next;
1254 
1256  "Still waiting for replies\n");
1257  for (struct GNUNET_RPS_StreamRequestHandle *srh_iter = h->stream_requests_head;
1258  NULL != srh_iter;
1259  srh_iter = srh_next)
1260  {
1261  srh_next = srh_iter->next;
1262  GNUNET_RPS_stream_cancel(srh_iter);
1263  }
1264  }
1265  if (NULL != h->rh_head)
1266  {
1268  "Not all requests were cancelled!\n");
1269  for (struct GNUNET_RPS_Request_Handle *rh_iter = h->rh_head;
1270  h->rh_head != NULL;
1271  rh_iter = h->rh_head)
1272  {
1273  GNUNET_RPS_request_cancel(rh_iter);
1274  }
1275  }
1276  if (NULL != h->rhs_head)
1277  {
1279  "Not all requests were cancelled!\n");
1280  for (struct GNUNET_RPS_Request_Handle_Single_Info *rhs_iter = h->rhs_head;
1281  h->rhs_head != NULL;
1282  rhs_iter = h->rhs_head)
1283  {
1285  }
1286  }
1287  if (NULL != srh_callback_peers)
1288  {
1290  srh_callback_peers = NULL;
1291  }
1292  if (NULL != h->view_update_cb)
1293  {
1295  "Still waiting for view updates\n");
1297  }
1298  if (NULL != h->nse)
1300  GNUNET_MQ_destroy(h->mq);
1301  GNUNET_free(h);
1302 }
struct GNUNET_RPS_Request_Handle_Single_Info * rhs_head
Pointer to the head element in DLL of single request handles.
Definition: rps_api.c:131
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:121
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:593
GNUNET_RPS_NotifyReadyCB view_update_cb
Callback called on each update of the view.
Definition: rps_api.c:91
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:86
struct GNUNET_RPS_StreamRequestHandle * stream_requests_head
Head of the DLL of stream requests.
Definition: rps_api.c:106
Handler for a single request from a client.
Definition: rps_api.c:209
void GNUNET_NSE_disconnect(struct GNUNET_NSE_Handle *h)
Disconnect from network size estimation service.
Definition: nse_api.c:192
void GNUNET_RPS_view_request_cancel(struct GNUNET_RPS_Handle *rps_handle)
Definition: rps_api.c:477
void GNUNET_RPS_request_cancel(struct GNUNET_RPS_Request_Handle *rh)
Cancle an issued request.
Definition: rps_api.c:1186
struct GNUNET_NSE_Handle * nse
Handle to nse service.
Definition: rps_api.c:116
static struct GNUNET_PeerIdentity * srh_callback_peers
Peers received from the biased stream to be passed to all srh_handlers.
Definition: rps_api.c:279
struct GNUNET_RPS_StreamRequestHandle * next
Next element of the DLL.
Definition: rps_api.c:65
Handler for a single request from a client.
Definition: rps_api.c:157
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:821
#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: