gnunet-service-fs_cadet_client.c File Reference

non-anonymous file-transfer More...

#include "platform.h"
#include "gnunet_constants.h"
#include "gnunet_util_lib.h"
#include "gnunet_cadet_service.h"
#include "gnunet_protocols.h"
#include "gnunet_applications.h"
#include "gnunet-service-fs.h"
#include "gnunet-service-fs_indexing.h"
#include "gnunet-service-fs_cadet.h"

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

Go to the source code of this file.

Data Structures
struct	GSF_CadetRequest
	Handle for a request that is going out via cadet API. More...
struct	CadetHandle
	Handle for a cadet to another peer. More...
struct	HandleReplyClosure
	Closure for handle_reply(). More...

Macros
#define	CLIENT_RETRY_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
	After how long do we reset connections without replies? More...

Functions
static void	transmit_pending (void *cls)
	Transmit pending requests via the cadet. More...
static int	move_to_pending (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator called on each entry in a waiting map to move it back to the pending list. More...
static int	check_reply (void *cls, const struct CadetReplyMessage *srm)
	Functions with this signature are called whenever a complete reply is received. More...
static void	reset_cadet_task (void *cls)
	Task called when it is time to reset an cadet. More...
static void	reset_cadet_async (struct CadetHandle *mh)
	We had a serious error, tear down and re-create cadet from scratch, but do so asynchronously. More...
static int	process_reply (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator called on each entry in a waiting map to process a result. More...
static int	free_waiting_entry (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator called on each entry in a waiting map to call the 'proc' continuation and release associated resources. More...
static void	handle_reply (void *cls, const struct CadetReplyMessage *srm)
	Functions with this signature are called whenever a complete reply is received. More...
static void	disconnect_cb (void *cls, const struct GNUNET_CADET_Channel *channel)
	Function called by cadet when a client disconnects. More...
static void	window_change_cb (void *cls, const struct GNUNET_CADET_Channel *channel, int window_size)
	Function called whenever an MQ-channel's transmission window size changes. More...
static void	reset_cadet (struct CadetHandle *mh)
	We had a serious error, tear down and re-create cadet from scratch. More...
static void	cadet_timeout (void *cls)
	Task called when it is time to destroy an inactive cadet channel. More...
static struct CadetHandle *	get_cadet (const struct GNUNET_PeerIdentity *target)
	Get (or create) a cadet to talk to the given peer. More...
struct GSF_CadetRequest *	GSF_cadet_query (const struct GNUNET_PeerIdentity *target, const struct GNUNET_HashCode *query, enum GNUNET_BLOCK_Type type, GSF_CadetReplyProcessor proc, void *proc_cls)
	Look for a block by directly contacting a particular peer. More...
void	GSF_cadet_query_cancel (struct GSF_CadetRequest *sr)
	Cancel an active request; must not be called after 'proc' was called. More...
int	GSF_cadet_release_clients (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
	Function called on each active cadets to shut them down. More...

Variables
struct GNUNET_CADET_Handle *	cadet_handle
	Cadet channel for creating outbound channels. More...
struct GNUNET_CONTAINER_MultiPeerMap *	cadet_map
	Map from peer identities to 'struct CadetHandles' with cadet channels to those peers. More...

Detailed Description

non-anonymous file-transfer

Author

Christian Grothoff

TODO:

• PORT is set to old application type, unsure if we should keep it that way (fine for now)

Definition in file gnunet-service-fs_cadet_client.c.

Macro Definition Documentation

CLIENT_RETRY_TIMEOUT

#define CLIENT_RETRY_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)

After how long do we reset connections without replies?

Definition at line 44 of file gnunet-service-fs_cadet_client.c.

Function Documentation

transmit_pending()

static void transmit_pending ( void *  cls )

static

Transmit pending requests via the cadet.

Parameters

cls	struct CadetHandle to process

Definition at line 528 of file gnunet-service-fs_cadet_client.c.

{
  struct CadetHandle *mh = cls;
  struct GNUNET_MQ_Handle *mq = GNUNET_CADET_get_mq (mh->channel);
  struct GSF_CadetRequest *sr;
  struct GNUNET_MQ_Envelope *env;
  struct CadetQueryMessage *sqm;
 
  if ((0 != GNUNET_MQ_get_length (mq)) || (NULL == (sr = mh->pending_head)))
    return;
  GNUNET_CONTAINER_DLL_remove (mh->pending_head, mh->pending_tail, sr);
  GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (
                   mh->waiting_map,
                   &sr->query,
                   sr,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
  sr->was_transmitted = GNUNET_YES;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending query for %s via cadet to %s\n",
              GNUNET_h2s (&sr->query),
              GNUNET_i2s (&mh->target));
  env = GNUNET_MQ_msg (sqm, GNUNET_MESSAGE_TYPE_FS_CADET_QUERY);
  GNUNET_MQ_env_set_options (env,
                             GNUNET_MQ_PREF_GOODPUT
                             | GNUNET_MQ_PREF_CORK_ALLOWED
                             | GNUNET_MQ_PREF_OUT_OF_ORDER);
  sqm->type = htonl (sr->type);
  sqm->query = sr->query;
  GNUNET_MQ_notify_sent (env, &transmit_pending, mh);
  GNUNET_MQ_send (mq, env);
}

References env, GNUNET_assert, GNUNET_CADET_get_mq(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_FS_CADET_QUERY, GNUNET_MQ_env_set_options(), GNUNET_MQ_get_length(), GNUNET_MQ_msg, GNUNET_MQ_notify_sent(), GNUNET_MQ_PREF_CORK_ALLOWED, GNUNET_MQ_PREF_GOODPUT, GNUNET_MQ_PREF_OUT_OF_ORDER, GNUNET_MQ_send(), GNUNET_OK, GNUNET_YES, mh, mq, CadetQueryMessage::query, GSF_CadetRequest::query, CadetQueryMessage::type, GSF_CadetRequest::type, and GSF_CadetRequest::was_transmitted.

Referenced by GSF_cadet_query(), reset_cadet(), and window_change_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

move_to_pending()

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

static

Iterator called on each entry in a waiting map to move it back to the pending list.

Parameters

cls	the struct CadetHandle
key	the key of the entry in the map (the query)
value	the struct GSF_CadetRequest to move to pending

Returns

GNUNET_YES (continue to iterate)

Definition at line 183 of file gnunet-service-fs_cadet_client.c.

{
  struct CadetHandle *mh = cls;
  struct GSF_CadetRequest *sr = value;
 
  GNUNET_assert (
    GNUNET_YES ==
    GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map, key, value));
  GNUNET_CONTAINER_DLL_insert (mh->pending_head, mh->pending_tail, sr);
  sr->was_transmitted = GNUNET_NO;
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_NO, GNUNET_YES, key, mh, value, and GSF_CadetRequest::was_transmitted.

Referenced by reset_cadet().

Here is the call graph for this function:

Here is the caller graph for this function:

check_reply()

static int check_reply ( void *  cls, const struct CadetReplyMessage *  srm  )

static

Functions with this signature are called whenever a complete reply is received.

Parameters

cls	closure with the struct CadetHandle
srm	the actual message

Returns

GNUNET_OK on success, GNUNET_SYSERR to stop further processing

Definition at line 206 of file gnunet-service-fs_cadet_client.c.

{
  /* We check later... */
  return GNUNET_OK;
}

References GNUNET_OK.

reset_cadet_task()

static void reset_cadet_task ( void *  cls )

static

Task called when it is time to reset an cadet.

Parameters

cls	the struct CadetHandle to tear down

Definition at line 513 of file gnunet-service-fs_cadet_client.c.

{
  struct CadetHandle *mh = cls;
 
  mh->reset_task = NULL;
  reset_cadet (mh);
}

References mh, and reset_cadet().

Referenced by get_cadet(), and reset_cadet_async().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_cadet_async()

static void reset_cadet_async ( struct CadetHandle *  mh )

static

We had a serious error, tear down and re-create cadet from scratch, but do so asynchronously.

Parameters

mh	cadet to reset

Definition at line 229 of file gnunet-service-fs_cadet_client.c.

{
  if (NULL != mh->reset_task)
    GNUNET_SCHEDULER_cancel (mh->reset_task);
  mh->reset_task = GNUNET_SCHEDULER_add_now (&reset_cadet_task, mh);
}

References GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), mh, and reset_cadet_task().

Referenced by handle_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

process_reply()

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

static

Iterator called on each entry in a waiting map to process a result.

Parameters

cls	the struct HandleReplyClosure
key	the key of the entry in the map (the query)
value	the struct GSF_CadetRequest to handle result for

Returns

GNUNET_YES (continue to iterate)

Definition at line 279 of file gnunet-service-fs_cadet_client.c.

{
  struct HandleReplyClosure *hrc = cls;
  struct GSF_CadetRequest *sr = value;
 
  sr->proc (sr->proc_cls,
            hrc->type,
            hrc->expiration,
            hrc->data_size,
            hrc->data);
  sr->proc = NULL;
  GSF_cadet_query_cancel (sr);
  hrc->found = GNUNET_YES;
  return GNUNET_YES;
}

References HandleReplyClosure::data, HandleReplyClosure::data_size, HandleReplyClosure::expiration, HandleReplyClosure::found, GNUNET_YES, GSF_cadet_query_cancel(), GSF_CadetRequest::proc, GSF_CadetRequest::proc_cls, HandleReplyClosure::type, and value.

Referenced by handle_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

free_waiting_entry()

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

static

Iterator called on each entry in a waiting map to call the 'proc' continuation and release associated resources.

Parameters

cls	the struct CadetHandle
key	the key of the entry in the map (the query)
value	the struct GSF_CadetRequest to clean up

Returns

GNUNET_YES (continue to iterate)

Definition at line 307 of file gnunet-service-fs_cadet_client.c.

{
  struct GSF_CadetRequest *sr = value;
 
  GSF_cadet_query_cancel (sr);
  return GNUNET_YES;
}

References GNUNET_YES, GSF_cadet_query_cancel(), and value.

Referenced by disconnect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_reply()

static void handle_reply ( void *  cls, const struct CadetReplyMessage *  srm  )

static

Functions with this signature are called whenever a complete reply is received.

Parameters

cls	closure with the struct CadetHandle
srm	the actual message

Definition at line 324 of file gnunet-service-fs_cadet_client.c.

{
  struct CadetHandle *mh = cls;
  struct HandleReplyClosure hrc;
  uint16_t msize;
  enum GNUNET_BLOCK_Type type;
  struct GNUNET_HashCode query;
 
  msize = ntohs (srm->header.size) - sizeof(struct CadetReplyMessage);
  type = (enum GNUNET_BLOCK_Type) ntohl (srm->type);
  if (GNUNET_YES !=
      GNUNET_BLOCK_get_key (GSF_block_ctx, type, &srm[1], msize, &query))
  {
    GNUNET_break_op (0);
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      "Received bogus reply of type %u with %u bytes via cadet from peer %s\n",
      type,
      msize,
      GNUNET_i2s (&mh->target));
    reset_cadet_async (mh);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received reply `%s' via cadet from peer %s\n",
              GNUNET_h2s (&query),
              GNUNET_i2s (&mh->target));
  GNUNET_CADET_receive_done (mh->channel);
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# replies received via cadet"),
                            1,
                            GNUNET_NO);
  hrc.data = &srm[1];
  hrc.data_size = msize;
  hrc.expiration = GNUNET_TIME_absolute_ntoh (srm->expiration);
  hrc.type = type;
  hrc.found = GNUNET_NO;
  GNUNET_CONTAINER_multihashmap_get_multiple (mh->waiting_map,
                                              &query,
                                              &process_reply,
                                              &hrc);
  if (GNUNET_NO == hrc.found)
  {
    GNUNET_STATISTICS_update (GSF_stats,
                              gettext_noop (
                                "# replies received via cadet dropped"),
                              1,
                              GNUNET_NO);
  }
}

References HandleReplyClosure::data, HandleReplyClosure::data_size, CadetReplyMessage::expiration, HandleReplyClosure::expiration, HandleReplyClosure::found, gettext_noop, GNUNET_BLOCK_get_key(), GNUNET_break_op, GNUNET_CADET_receive_done(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, GSF_block_ctx, GSF_stats, CadetReplyMessage::header, mh, process_reply(), reset_cadet_async(), GNUNET_MessageHeader::size, CadetReplyMessage::type, HandleReplyClosure::type, and type.

Here is the call graph for this function:

disconnect_cb()

static void disconnect_cb ( void *  cls, const struct GNUNET_CADET_Channel *  channel  )

static

Function called by cadet when a client disconnects.

Cleans up our struct CadetClient of that channel.

Parameters

cls	our struct CadetClient
channel	channel of the disconnecting client

Definition at line 384 of file gnunet-service-fs_cadet_client.c.

{
  struct CadetHandle *mh = cls;
  struct GSF_CadetRequest *sr;
 
  if (NULL == mh->channel)
    return; /* being destroyed elsewhere */
  GNUNET_assert (channel == mh->channel);
  mh->channel = NULL;
  while (NULL != (sr = mh->pending_head))
    GSF_cadet_query_cancel (sr);
  /* first remove `mh` from the `cadet_map`, so that if the
     callback from `free_waiting_entry()` happens to re-issue
     the request, we don't immediately have it back in the
     `waiting_map`. */
  GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (cadet_map,
                                                                    &mh->target,
                                                                    mh));
  GNUNET_CONTAINER_multihashmap_iterate (mh->waiting_map,
                                         &free_waiting_entry,
                                         mh);
  if (NULL != mh->timeout_task)
    GNUNET_SCHEDULER_cancel (mh->timeout_task);
  if (NULL != mh->reset_task)
    GNUNET_SCHEDULER_cancel (mh->reset_task);
  GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (mh->waiting_map));
  GNUNET_CONTAINER_multihashmap_destroy (mh->waiting_map);
  GNUNET_free (mh);
}

References cadet_map, free_waiting_entry(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_free, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GSF_cadet_query_cancel(), and mh.

Referenced by get_cadet(), GNUNET_SERVICE_run_(), GNUNET_SERVICE_start(), and reset_cadet().

Here is the call graph for this function:

Here is the caller graph for this function:

window_change_cb()

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

static

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

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

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

Parameters

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

Definition at line 430 of file gnunet-service-fs_cadet_client.c.

{
  /* FIXME: for flow control, implement? */
#if 0
  /* Something like this instead of the GNUNET_MQ_notify_sent() in
     transmit_pending() might be good (once the window change CB works...) */
  if (0 < window_size) /* test needed? */
    transmit_pending (mh);
#endif
}

References mh, and transmit_pending().

Referenced by get_cadet(), and reset_cadet().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_cadet()

static void reset_cadet ( struct CadetHandle *  mh )

static

We had a serious error, tear down and re-create cadet from scratch.

Parameters

mh	cadet to reset

Definition at line 450 of file gnunet-service-fs_cadet_client.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Resetting cadet channel to %s\n",
              GNUNET_i2s (&mh->target));
  if (NULL != mh->channel)
  {
    GNUNET_CADET_channel_destroy (mh->channel);
    mh->channel = NULL;
  }
  GNUNET_CONTAINER_multihashmap_iterate (mh->waiting_map, &move_to_pending, mh);
  {
    struct GNUNET_MQ_MessageHandler handlers[] =
    { GNUNET_MQ_hd_var_size (reply,
                             GNUNET_MESSAGE_TYPE_FS_CADET_REPLY,
                             struct CadetReplyMessage,
                             mh),
      GNUNET_MQ_handler_end () };
    struct GNUNET_HashCode port;
 
    GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER,
                        strlen (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER),
                        &port);
    mh->channel = GNUNET_CADET_channel_create (cadet_handle,
                                               mh,
                                               &mh->target,
                                               &port,
                                               &window_change_cb,
                                               &disconnect_cb,
                                               handlers);
  }
  transmit_pending (mh);
}

References cadet_handle, disconnect_cb(), GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, GNUNET_CADET_channel_create(), GNUNET_CADET_channel_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, handlers, mh, move_to_pending(), port, transmit_pending(), and window_change_cb().

Referenced by reset_cadet_task().

Here is the call graph for this function:

Here is the caller graph for this function:

cadet_timeout()

static void cadet_timeout ( void *  cls )

static

Task called when it is time to destroy an inactive cadet channel.

Parameters

cls	the struct CadetHandle to tear down

Definition at line 491 of file gnunet-service-fs_cadet_client.c.

{
  struct CadetHandle *mh = cls;
  struct GNUNET_CADET_Channel *tun;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Timeout on cadet channel to %s\n",
              GNUNET_i2s (&mh->target));
  mh->timeout_task = NULL;
  tun = mh->channel;
  mh->channel = NULL;
  if (NULL != tun)
    GNUNET_CADET_channel_destroy (tun);
}

References GNUNET_CADET_channel_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, and mh.

Referenced by GSF_cadet_query_cancel().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cadet()

static struct CadetHandle* get_cadet ( const struct GNUNET_PeerIdentity *  target )

static

Get (or create) a cadet to talk to the given peer.

Parameters

target

peer we want to communicate with

Definition at line 567 of file gnunet-service-fs_cadet_client.c.

{
  struct CadetHandle *mh;
 
  mh = GNUNET_CONTAINER_multipeermap_get (cadet_map, target);
  if (NULL != mh)
  {
    if (NULL != mh->timeout_task)
    {
      GNUNET_SCHEDULER_cancel (mh->timeout_task);
      mh->timeout_task = NULL;
    }
    return mh;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Creating cadet channel to %s\n",
              GNUNET_i2s (target));
  mh = GNUNET_new (struct CadetHandle);
  mh->reset_task =
    GNUNET_SCHEDULER_add_delayed (CLIENT_RETRY_TIMEOUT, &reset_cadet_task, mh);
  mh->waiting_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_YES);
  mh->target = *target;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multipeermap_put (
                   cadet_map,
                   &mh->target,
                   mh,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  {
    struct GNUNET_MQ_MessageHandler handlers[] =
    { GNUNET_MQ_hd_var_size (reply,
                             GNUNET_MESSAGE_TYPE_FS_CADET_REPLY,
                             struct CadetReplyMessage,
                             mh),
      GNUNET_MQ_handler_end () };
    struct GNUNET_HashCode port;
 
    GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER,
                        strlen (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER),
                        &port);
    mh->channel = GNUNET_CADET_channel_create (cadet_handle,
                                               mh,
                                               &mh->target,
                                               &port,
                                               &window_change_cb,
                                               &disconnect_cb,
                                               handlers);
  }
  return mh;
}

References cadet_handle, cadet_map, CLIENT_RETRY_TIMEOUT, disconnect_cb(), GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, GNUNET_assert, GNUNET_CADET_channel_create(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, handlers, mh, port, reset_cadet_task(), CadetHandle::target, and window_change_cb().

Referenced by GSF_cadet_query().

Here is the call graph for this function:

Here is the caller graph for this function:

GSF_cadet_query()

struct GSF_CadetRequest* GSF_cadet_query	(	const struct GNUNET_PeerIdentity *	target,
		const struct GNUNET_HashCode *	query,
		enum GNUNET_BLOCK_Type	type,
		GSF_CadetReplyProcessor	proc,
		void *	proc_cls
	)

Look for a block by directly contacting a particular peer.

Parameters

target	peer that should have the block
query	hash to query for the block
type	desired type for the block
proc	function to call with result
proc_cls	closure for proc

Returns

handle to cancel the operation

Definition at line 630 of file gnunet-service-fs_cadet_client.c.

{
  struct CadetHandle *mh;
  struct GSF_CadetRequest *sr;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Preparing to send query for %s via cadet to %s\n",
              GNUNET_h2s (query),
              GNUNET_i2s (target));
  mh = get_cadet (target);
  sr = GNUNET_new (struct GSF_CadetRequest);
  sr->mh = mh;
  sr->proc = proc;
  sr->proc_cls = proc_cls;
  sr->type = type;
  sr->query = *query;
  GNUNET_CONTAINER_DLL_insert (mh->pending_head, mh->pending_tail, sr);
  transmit_pending (mh);
  return sr;
}

References get_cadet(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_new, mh, GSF_CadetRequest::mh, GSF_CadetRequest::proc, GSF_CadetRequest::proc_cls, GSF_CadetRequest::query, transmit_pending(), GSF_CadetRequest::type, and type.

Referenced by cadet_reply_proc(), and GSF_cadet_lookup_().

Here is the call graph for this function:

Here is the caller graph for this function:

GSF_cadet_query_cancel()

void GSF_cadet_query_cancel

(

struct GSF_CadetRequest *

sr

)

Cancel an active request; must not be called after 'proc' was called.

Parameters

sr	request to cancel

Definition at line 663 of file gnunet-service-fs_cadet_client.c.

{
  struct CadetHandle *mh = sr->mh;
  GSF_CadetReplyProcessor p;
 
  p = sr->proc;
  sr->proc = NULL;
  if (NULL != p)
  {
    /* signal failure / cancellation to callback */
    p (sr->proc_cls, GNUNET_BLOCK_TYPE_ANY, GNUNET_TIME_UNIT_ZERO_ABS, 0, NULL);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Cancelled query for %s via cadet to %s\n",
              GNUNET_h2s (&sr->query),
              GNUNET_i2s (&sr->mh->target));
  if (GNUNET_YES == sr->was_transmitted)
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map, &sr->query, sr));
  else
    GNUNET_CONTAINER_DLL_remove (mh->pending_head, mh->pending_tail, sr);
  GNUNET_free (sr);
  if ((0 == GNUNET_CONTAINER_multihashmap_size (mh->waiting_map)) &&
      (NULL == mh->pending_head))
    mh->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                                     &cadet_timeout,
                                                     mh);
}

References cadet_timeout(), GNUNET_assert, GNUNET_BLOCK_TYPE_ANY, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_UNIT_SECONDS, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, mh, GSF_CadetRequest::mh, p, GSF_CadetRequest::proc, GSF_CadetRequest::proc_cls, GSF_CadetRequest::query, CadetHandle::target, and GSF_CadetRequest::was_transmitted.

Referenced by clean_request(), disconnect_cb(), free_waiting_entry(), GSF_pending_request_cancel_(), and process_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

GSF_cadet_release_clients()

int GSF_cadet_release_clients	(	void *	cls,
		const struct GNUNET_PeerIdentity *	key,
		void *	value
	)

Function called on each active cadets to shut them down.

Parameters

cls	NULL
key	target peer, unused
value	the struct CadetHandle to destroy

Returns

GNUNET_YES (continue to iterate)

Definition at line 703 of file gnunet-service-fs_cadet_client.c.

{
  struct CadetHandle *mh = value;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Timeout on cadet channel to %s\n",
              GNUNET_i2s (&mh->target));
  if (NULL != mh->channel)
  {
    struct GNUNET_CADET_Channel *channel = mh->channel;
 
    mh->channel = NULL;
    GNUNET_CADET_channel_destroy (channel);
  }
  if (NULL != mh->reset_task)
  {
    GNUNET_SCHEDULER_cancel (mh->reset_task);
    mh->reset_task = NULL;
  }
  return GNUNET_YES;
}

References GNUNET_CADET_channel_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_YES, mh, and value.

Referenced by GSF_cadet_stop_server().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

cadet_handle

struct GNUNET_CADET_Handle* cadet_handle

Cadet channel for creating outbound channels.

Definition at line 152 of file gnunet-service-fs_cadet_client.c.

Referenced by get_cadet(), and reset_cadet().

cadet_map

struct GNUNET_CONTAINER_MultiPeerMap* cadet_map

Map from peer identities to 'struct CadetHandles' with cadet channels to those peers.

Definition at line 158 of file gnunet-service-fs_cadet_client.c.

Referenced by disconnect_cb(), get_cadet(), GSF_cadet_start_server(), and GSF_cadet_stop_server().