non-anonymous file-transfer More...

This graph shows which files directly or indirectly include this file:

Data Structures
struct	CadetQueryMessage
	Query from one peer, asking the other for CHK-data. More...

struct	CadetReplyMessage
	Reply to a CadetQueryMessage. More...

Typedefs
typedef void(*	GSF_CadetReplyProcessor) (void cls, enum GNUNET_BLOCK_Type type, struct GNUNET_TIME_Absolute expiration, size_t data_size, const void data)
	Function called with a reply from the cadet.

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

int	GSF_cadet_release_clients (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Function called on each active cadets to shut them down.

void	GSF_cadet_query_cancel (struct GSF_CadetRequest *sr)
	Cancel an active request; must not be called after 'proc' was called.

void	GSF_cadet_start_server (void)
	Initialize subsystem for non-anonymous file-sharing.

void	GSF_cadet_stop_server (void)
	Shutdown subsystem for non-anonymous file-sharing.

Variables
struct GNUNET_CADET_Handle *	cadet_handle
	Cadet channel for creating outbound channels.

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

Detailed Description

non-anonymous file-transfer

Author: Christian Grothoff

Definition in file gnunet-service-fs_cadet.h.

Typedef Documentation

◆ GSF_CadetReplyProcessor

typedef void(* GSF_CadetReplyProcessor) (void *cls, enum GNUNET_BLOCK_Type type, struct GNUNET_TIME_Absolute expiration, size_t data_size, const void *data)

Function called with a reply from the cadet.

Parameters

cls	closure
type	type of the block, ANY on error
expiration	expiration time for the block
data_size	number of bytes in data, 0 on error
data	reply block data, NULL on error

Definition at line 44 of file gnunet-service-fs_cadet.h.

Function Documentation

◆ 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 628 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(), type, and GSF_CadetRequest::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_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 701 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:

◆ 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 661 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_start_server()

void GSF_cadet_start_server ( void )

Initialize subsystem for non-anonymous file-sharing.

Definition at line 483 of file gnunet-service-fs_cadet_server.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (request,
                             GNUNET_MESSAGE_TYPE_FS_CADET_QUERY,
                             struct CadetQueryMessage,
                             NULL),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_HashCode port;
 
  if (GNUNET_YES !=
      GNUNET_CONFIGURATION_get_value_number (GSF_cfg,
                                             "fs",
                                             "MAX_CADET_CLIENTS",
                                             &sc_count_max))
    return;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Initializing cadet FS server with a limit of %llu connections\n",
              sc_count_max);
  cadet_map = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_YES);
  cadet_handle = GNUNET_CADET_connect (GSF_cfg);
  GNUNET_assert (NULL != cadet_handle);
  GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER,
                      strlen (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER),
                      &port);
  cadet_port = GNUNET_CADET_open_port (cadet_handle,
                                       &port,
                                       &connect_cb,
                                       NULL,
                                       &window_change_cb,
                                       &disconnect_cb,
                                       handlers);
}

References cadet_handle, cadet_map, cadet_port, connect_cb(), disconnect_cb(), GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER, GNUNET_assert, GNUNET_CADET_connect(), GNUNET_CADET_open_port(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_FS_CADET_QUERY, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_YES, GSF_cfg, handlers, port, request, sc_count_max, and window_change_cb().

Referenced by main_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GSF_cadet_stop_server()

void GSF_cadet_stop_server ( void )

Shutdown subsystem for non-anonymous file-sharing.

Definition at line 523 of file gnunet-service-fs_cadet_server.c.

{
  GNUNET_CONTAINER_multipeermap_iterate (cadet_map,
                                         &GSF_cadet_release_clients,
                                         NULL);
  GNUNET_CONTAINER_multipeermap_destroy (cadet_map);
  cadet_map = NULL;
  if (NULL != cadet_port)
  {
    GNUNET_CADET_close_port (cadet_port);
    cadet_port = NULL;
  }
  if (NULL != cadet_handle)
  {
    GNUNET_CADET_disconnect (cadet_handle);
    cadet_handle = NULL;
  }
  GNUNET_assert (NULL == sc_head);
  GNUNET_assert (0 == sc_count);
}