RPS service

Random Peer Sampling. More...

Collaboration diagram for RPS service:

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_Handle *	GNUNET_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_Handle *	GNUNET_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_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. 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)
	Cancel an issued request. More...
void	GNUNET_RPS_request_single_info_cancel (struct GNUNET_RPS_Request_Handle_Single_Info *rhs)
	Cancel 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_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. 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 48 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

cls	the closure given with the request
num_peers	the number of peers returned
peers	array with num_peers PeerIDs

Definition at line 67 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

cls	the closure given with the request
peer	The Peer ID
probability	The probability with which all elements have been observed
num_observed	Number of IDs this sampler has observed

Definition at line 82 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

cfg	configuration to use

Returns

handle to the rps service

Parameters

cfg	configuration to use

Returns

a handle to the service, NULL on error

Definition at line 843 of file rps_api.c.

{
  struct GNUNET_RPS_Handle *h;
 
  h = GNUNET_new (struct GNUNET_RPS_Handle);
  h->cfg = cfg;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_float (cfg,
                                            "RPS",
                                            "DESIRED_PROBABILITY",
                                            &h->desired_probability))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "RPS", "DESIRED_PROBABILITY");
    GNUNET_free (h);
    return NULL;
  }
  if ((0 > h->desired_probability) ||
      (1 < h->desired_probability) )
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "The desired probability must be in the interval [0;1]\n");
    GNUNET_free (h);
    return NULL;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_float (cfg,
                                            "RPS",
                                            "DEFICIENCY_FACTOR",
                                            &h->deficiency_factor))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "RPS", "DEFICIENCY_FACTOR");
    GNUNET_free (h);
    return NULL;
  }
  if ((0 > h->desired_probability) ||
      (1 < h->desired_probability) )
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         "The deficiency factor must be in the interval [0;1]\n");
    GNUNET_free (h);
    return NULL;
  }
  reconnect (h);
  if (NULL == h->mq)
  {
    GNUNET_free (h);
    return NULL;
  }
  return h;
}

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

Referenced by run().

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

h	Handle to rps
shared_value	The shared value that defines the members of the sub (-group)
h	Handle to rps
shared_value	The shared value that defines the members of the sub (-gorup)

Definition at line 904 of file rps_api.c.

{
  struct GNUNET_RPS_CS_SubStartMessage *msg;
  struct GNUNET_MQ_Envelope *ev;
 
  ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RPS_CS_SUB_START);
  hash_from_share_val (shared_value, &msg->hash);
  msg->round_interval = GNUNET_TIME_relative_hton ( // TODO read from config!
    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30));
  GNUNET_assert (0 != msg->round_interval.rel_value_us__);
 
  GNUNET_MQ_send (h->mq, ev);
}

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, h, hash_from_share_val(), GNUNET_ARM_Handle::mq, and msg.

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

h	Handle to rps
shared_value	The shared value that defines the members of the sub (-group)
h	Handle to rps
shared_value	The shared value that defines the members of the sub (-gorup)

Definition at line 927 of file rps_api.c.

{
  struct GNUNET_RPS_CS_SubStopMessage *msg;
  struct GNUNET_MQ_Envelope *ev;
 
  ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP);
  hash_from_share_val (shared_value, &msg->hash);
 
  GNUNET_MQ_send (h->mq, ev);
}

References GNUNET_MESSAGE_TYPE_RPS_CS_SUB_STOP, GNUNET_MQ_msg, GNUNET_MQ_send(), h, hash_from_share_val(), GNUNET_ARM_Handle::mq, and msg.

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 exactly 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

h	handle to the rps service
n	number of random peers to return
ready_cb	the callback to be called when the peers are available
cls	a closure that will be given to the callback

Returns

handle to this request

Parameters

rps_handle	handle to the rps service
num_req_peers	number of peers we want to receive
ready_cb	the callback called when the peers are available
cls	closure given to the callback

Returns

a handle to cancel this request

Definition at line 950 of file rps_api.c.

{
  struct GNUNET_RPS_Request_Handle *rh;
 
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Client requested %" PRIu32 " peers\n",
       num_req_peers);
  rh = GNUNET_new (struct GNUNET_RPS_Request_Handle);
  rh->rps_handle = rps_handle;
  rh->num_requests = num_req_peers;
  rh->sampler = RPS_sampler_mod_init (num_req_peers,
                                      GNUNET_TIME_UNIT_SECONDS); // TODO remove this time-stuff
  RPS_sampler_set_desired_probability (rh->sampler,
                                       rps_handle->desired_probability);
  RPS_sampler_set_deficiency_factor (rh->sampler,
                                     rps_handle->deficiency_factor);
  rh->sampler_rh = RPS_sampler_get_n_rand_peers (rh->sampler,
                                                 num_req_peers,
                                                 peers_ready_cb,
                                                 rh);
  rh->srh = GNUNET_RPS_stream_request (rps_handle,
                                       collect_peers_cb,
                                       rh); /* cls */
  rh->ready_cb = ready_cb;
  rh->ready_cb_cls = cls;
  GNUNET_CONTAINER_DLL_insert (rps_handle->rh_head,
                               rps_handle->rh_tail,
                               rh);
 
  return rh;
}

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_Request_Handle::ready_cb, GNUNET_RPS_Request_Handle::ready_cb_cls, GNUNET_RPS_Handle::rh_head, GNUNET_RPS_Handle::rh_tail, 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().

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_handle	handle to the rps service
ready_cb	the callback called when the peers are available
cls	closure given to the callback

Returns

a handle to cancel this request

Definition at line 995 of file rps_api.c.

{
  struct GNUNET_RPS_Request_Handle_Single_Info *rhs;
  uint32_t num_req_peers = 1;
 
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Client requested peer with additional info\n");
  rhs = GNUNET_new (struct GNUNET_RPS_Request_Handle_Single_Info);
  rhs->rps_handle = rps_handle;
  rhs->sampler = RPS_sampler_mod_init (num_req_peers,
                                       GNUNET_TIME_UNIT_SECONDS); // TODO remove this time-stuff
  RPS_sampler_set_desired_probability (rhs->sampler,
                                       rps_handle->desired_probability);
  RPS_sampler_set_deficiency_factor (rhs->sampler,
                                     rps_handle->deficiency_factor);
  rhs->sampler_rh = RPS_sampler_get_rand_peer_info (rhs->sampler,
                                                    peer_info_ready_cb,
                                                    rhs);
  rhs->srh = GNUNET_RPS_stream_request (rps_handle,
                                        collect_peers_info_cb,
                                        rhs); /* cls */
  rhs->ready_cb = ready_cb;
  rhs->ready_cb_cls = cls;
  GNUNET_CONTAINER_DLL_insert (rps_handle->rhs_head,
                               rps_handle->rhs_tail,
                               rhs);
 
  return rhs;
}

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_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, 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.

Here is the call 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

h	handle to the rps service
n	number of peers to seed
ids	the ids of the peers seeded

Definition at line 1036 of file rps_api.c.

{
  size_t size_needed;
  uint32_t num_peers_max;
  const struct GNUNET_PeerIdentity *tmp_peer_pointer;
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_RPS_CS_SeedMessage *msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client wants to seed %" PRIu32 " peers:\n",
       n);
  for (unsigned int i = 0; i < n; i++)
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "%u. peer: %s\n",
         i,
         GNUNET_i2s (&ids[i]));
 
  /* The actual size the message occupies */
  size_needed = sizeof(struct GNUNET_RPS_CS_SeedMessage)
                + n * sizeof(struct GNUNET_PeerIdentity);
  /* The number of peers that fits in one message together with
   * the respective header */
  num_peers_max = (GNUNET_MAX_MESSAGE_SIZE
                   - sizeof(struct GNUNET_RPS_CS_SeedMessage))
                  / sizeof(struct GNUNET_PeerIdentity);
  tmp_peer_pointer = ids;
 
  while (GNUNET_MAX_MESSAGE_SIZE < size_needed)
  {
    ev = GNUNET_MQ_msg_extra (msg,
                              num_peers_max * sizeof(struct
                                                     GNUNET_PeerIdentity),
                              GNUNET_MESSAGE_TYPE_RPS_CS_SEED);
    msg->num_peers = htonl (num_peers_max);
    GNUNET_memcpy (&msg[1],
                   tmp_peer_pointer,
                   num_peers_max * sizeof(struct GNUNET_PeerIdentity));
    GNUNET_MQ_send (h->mq,
                    ev);
    n -= num_peers_max;
    size_needed = sizeof(struct GNUNET_RPS_CS_SeedMessage)
                  + n * sizeof(struct GNUNET_PeerIdentity);
    /* Set pointer to beginning of next block of num_peers_max peers */
    tmp_peer_pointer = &ids[num_peers_max];
  }
 
  ev = GNUNET_MQ_msg_extra (msg,
                            n * sizeof(struct GNUNET_PeerIdentity),
                            GNUNET_MESSAGE_TYPE_RPS_CS_SEED);
  msg->num_peers = htonl (n);
  GNUNET_memcpy (&msg[1],
                 tmp_peer_pointer,
                 n * sizeof(struct GNUNET_PeerIdentity));
  GNUNET_MQ_send (h->mq,
                  ev);
}

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(), h, LOG, GNUNET_ARM_Handle::mq, and msg.

Referenced by run().

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

)

Cancel an issued request.

Parameters

rh	handle of the pending request to be canceled
rh	request handle of request to cancel

Definition at line 1200 of file rps_api.c.

{
  struct GNUNET_RPS_Handle *h;
 
  h = rh->rps_handle;
  GNUNET_assert (NULL != rh);
  GNUNET_assert (NULL != rh->srh);
  GNUNET_assert (h == rh->srh->rps_handle);
  GNUNET_RPS_stream_cancel (rh->srh);
  rh->srh = NULL;
  if (NULL == h->stream_requests_head)
    cancel_stream (h);
  if (NULL != rh->sampler_rh)
  {
    RPS_sampler_request_cancel (rh->sampler_rh);
  }
  RPS_sampler_destroy (rh->sampler);
  rh->sampler = NULL;
  GNUNET_CONTAINER_DLL_remove (h->rh_head,
                               h->rh_tail,
                               rh);
  GNUNET_free (rh);
}

References cancel_stream(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_RPS_stream_cancel(), h, 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, and GNUNET_RPS_Request_Handle::srh.

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

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

)

Cancel an issued single info request.

Parameters

rhs	request handle of request to cancel

Definition at line 1231 of file rps_api.c.

{
  struct GNUNET_RPS_Handle *h;
 
  h = rhs->rps_handle;
  GNUNET_assert (NULL != rhs);
  GNUNET_assert (NULL != rhs->srh);
  GNUNET_assert (h == rhs->srh->rps_handle);
  GNUNET_RPS_stream_cancel (rhs->srh);
  rhs->srh = NULL;
  if (NULL == h->stream_requests_head)
    cancel_stream (h);
  if (NULL != rhs->sampler_rh)
  {
    RPS_sampler_request_single_info_cancel (rhs->sampler_rh);
  }
  RPS_sampler_destroy (rhs->sampler);
  rhs->sampler = NULL;
  GNUNET_CONTAINER_DLL_remove (h->rhs_head,
                               h->rhs_tail,
                               rhs);
  GNUNET_free (rhs);
}

References cancel_stream(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_RPS_stream_cancel(), h, 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, and GNUNET_RPS_Request_Handle_Single_Info::srh.

Referenced by GNUNET_RPS_disconnect(), and peer_info_ready_cb().

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_handle	handle to the rps service
num_req_peers	number of peers we want to receive (0 for infinite updates)
cls	a closure that will be given to the callback
ready_cb	the callback called when the peers are available

Definition at line 461 of file rps_api.c.

{
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_RPS_CS_DEBUG_ViewRequest *msg;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Client requests %" PRIu32 " view updates\n",
       num_updates);
  rps_handle->view_update_cb = view_update_cb;
  rps_handle->view_update_cls = cls;
 
  ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_VIEW_REQUEST);
  msg->num_updates = htonl (num_updates);
  GNUNET_MQ_send (rps_handle->mq, ev);
}

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, rps_handle, GNUNET_RPS_Handle::view_update_cb, and GNUNET_RPS_Handle::view_update_cls.

Referenced by run().

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_handle	handle to the rps service
cls	a closure that will be given to the callback
ready_cb	the callback called when the peers are available

Definition at line 503 of file rps_api.c.

{
  struct GNUNET_RPS_StreamRequestHandle *srh;
  struct GNUNET_MQ_Envelope *ev;
  struct GNUNET_RPS_CS_DEBUG_StreamRequest *msg;
 
  srh = new_stream_request (rps_handle,
                            stream_input_cb,
                            cls);
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Client requests biased stream updates\n");
 
  ev = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RPS_CS_DEBUG_STREAM_REQUEST);
  GNUNET_MQ_send (rps_handle->mq, ev);
  return srh;
}

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, new_stream_request(), and rps_handle.

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

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

srh	The request handle to cancel

Definition at line 598 of file rps_api.c.

{
  struct GNUNET_RPS_Handle *rps_handle;
 
  rps_handle = srh->rps_handle;
  remove_stream_request (srh);
  if (NULL == rps_handle->stream_requests_head)
    cancel_stream (rps_handle);
}

References cancel_stream(), remove_stream_request(), rps_handle, 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().

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

h	the handle to the rps service

Definition at line 1263 of file rps_api.c.

{
  if (NULL != h->stream_requests_head)
  {
    struct GNUNET_RPS_StreamRequestHandle *srh_next;
 
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Still waiting for replies\n");
    for (struct GNUNET_RPS_StreamRequestHandle *srh_iter =
           h->stream_requests_head;
         NULL != srh_iter;
         srh_iter = srh_next)
    {
      srh_next = srh_iter->next;
      GNUNET_RPS_stream_cancel (srh_iter);
    }
  }
  if (NULL != h->rh_head)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Not all requests were cancelled!\n");
    for (struct GNUNET_RPS_Request_Handle *rh_iter = h->rh_head;
         h->rh_head != NULL;
         rh_iter = h->rh_head)
    {
      GNUNET_RPS_request_cancel (rh_iter);
    }
  }
  if (NULL != h->rhs_head)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Not all requests were cancelled!\n");
    for (struct GNUNET_RPS_Request_Handle_Single_Info *rhs_iter = h->rhs_head;
         h->rhs_head != NULL;
         rhs_iter = h->rhs_head)
    {
      GNUNET_RPS_request_single_info_cancel (rhs_iter);
    }
  }
  if (NULL != srh_callback_peers)
  {
    GNUNET_free (srh_callback_peers);
    srh_callback_peers = NULL;
  }
  if (NULL != h->view_update_cb)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Still waiting for view updates\n");
    GNUNET_RPS_view_request_cancel (h);
  }
  if (NULL != h->nse)
    GNUNET_NSE_disconnect (h->nse);
  GNUNET_MQ_destroy (h->mq);
  GNUNET_free (h);
}

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(), h, LOG, GNUNET_ARM_Handle::mq, GNUNET_RPS_StreamRequestHandle::next, and srh_callback_peers.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function: