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_server.c:

Data Structures
struct	WriteQueueItem
	A message in the queue to be written to the cadet. More...

struct	CadetClient
	Struct containing information about a client of the service. More...

Macros
#define	IDLE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2)
	After how long do we terminate idle connections? More...

Functions
static void	timeout_cadet_task (void *cls)
	Task run to asynchronously terminate the cadet due to timeout. More...

static void	refresh_timeout_task (struct CadetClient *sc)
	Reset the timeout for the cadet client (due to activity). More...

static void	continue_writing (void *cls)
	Check if we are done with the write queue, and if so tell CADET that we are ready to read more. More...

static void	handle_datastore_reply (void cls, const struct GNUNET_HashCode key, size_t size, const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid)
	Process a datum that was stored in the datastore. More...

static void	handle_request (void cls, const struct CadetQueryMessage sqm)
	Functions with this signature are called whenever a complete query message is received. More...

static void *	connect_cb (void cls, struct GNUNET_CADET_Channel channel, const struct GNUNET_PeerIdentity *initiator)
	Functions of this type are called upon new cadet connection from other peers. 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...

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

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

Variables
static struct GNUNET_CADET_Port *	cadet_port
	Listen port for incoming requests. More...

static struct CadetClient *	sc_head
	Head of DLL of cadet clients. More...

static struct CadetClient *	sc_tail
	Tail of DLL of cadet clients. More...

static unsigned int	sc_count
	Number of active cadet clients in the 'sc_*'-DLL. More...

static unsigned long long	sc_count_max
	Maximum allowed number of cadet clients. 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_server.c.

Macro Definition Documentation

◆ IDLE_TIMEOUT

#define IDLE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2)

After how long do we terminate idle connections?

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

Function Documentation

◆ timeout_cadet_task()

static void timeout_cadet_task ( void * cls )

static

Task run to asynchronously terminate the cadet due to timeout.

Parameters

cls	the 'struct CadetClient'

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

{
  struct CadetClient *sc = cls;
  struct GNUNET_CADET_Channel *tun;
 
  sc->timeout_task = NULL;
  tun = sc->channel;
  sc->channel = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Timeout for inactive cadet client %p\n",
              sc);
  GNUNET_CADET_channel_destroy (tun);
}

References GNUNET_CADET_channel_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and sc.

Referenced by refresh_timeout_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ refresh_timeout_task()

static void refresh_timeout_task ( struct CadetClient * sc )

static

Reset the timeout for the cadet client (due to activity).

Parameters

sc	client handle to reset timeout for

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

{
  if (NULL != sc->timeout_task)
    GNUNET_SCHEDULER_cancel (sc->timeout_task);
  sc->timeout_task = GNUNET_SCHEDULER_add_delayed (IDLE_TIMEOUT,
                                                   &timeout_cadet_task,
                                                   sc);
}

References GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), IDLE_TIMEOUT, sc, and timeout_cadet_task().

Referenced by connect_cb(), continue_writing(), and handle_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ continue_writing()

static void continue_writing ( void * cls )

static

Check if we are done with the write queue, and if so tell CADET that we are ready to read more.

Parameters

cls	where to process the write queue

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

{
  struct CadetClient *sc = cls;
  struct GNUNET_MQ_Handle *mq;
 
  mq = GNUNET_CADET_get_mq (sc->channel);
  if (0 != GNUNET_MQ_get_length (mq))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Write pending, waiting for it to complete\n");
    return;
  }
  refresh_timeout_task (sc);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Finished processing cadet request from client %p, ready to receive the next one\n",
              sc);
  GNUNET_CADET_receive_done (sc->channel);
}

References GNUNET_CADET_get_mq(), GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_get_length(), mq, refresh_timeout_task(), and sc.

Referenced by handle_datastore_reply(), and handle_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_datastore_reply()

static void handle_datastore_reply	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		size_t	size,
		const void *	data,
		enum GNUNET_BLOCK_Type	type,
		uint32_t	priority,
		uint32_t	anonymity,
		uint32_t	replication,
		struct GNUNET_TIME_Absolute	expiration,
		uint64_t	uid
	)

static

Process a datum that was stored in the datastore.

Parameters

cls	closure with the `struct CadetClient` which sent the query
key	key for the content
size	number of bytes in data
data	content stored
type	type of the content
priority	priority of the content
anonymity	anonymity-level for the content
replication	replication-level for the content
expiration	expiration time for the content
uid	unique identifier for the datum; maybe 0 if no unique identifier is available

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

{
  struct CadetClient *sc = cls;
  size_t msize = size + sizeof(struct CadetReplyMessage);
  struct GNUNET_MQ_Envelope *env;
  struct CadetReplyMessage *srm;
 
  sc->qe = NULL;
  if (NULL == data)
  {
    /* no result, this should not really happen, as for
       non-anonymous routing only peers that HAVE the
       answers should be queried; OTOH, this is not a
       hard error as we might have had the answer in the
       past and the user might have unindexed it. Hence
       we log at level "INFO" for now. */if (NULL == key)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "Have no answer and the query was NULL\n");
    }
    else
    {
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "Have no answer for query `%s'\n",
                  GNUNET_h2s (key));
    }
    GNUNET_STATISTICS_update (GSF_stats,
                              gettext_noop (
                                "# queries received via CADET not answered"),
                              1,
                              GNUNET_NO);
    continue_writing (sc);
    return;
  }
  if (GNUNET_BLOCK_TYPE_FS_ONDEMAND == type)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Performing on-demand encoding for query %s\n",
                GNUNET_h2s (key));
    if (GNUNET_OK !=
        GNUNET_FS_handle_on_demand_block (key,
                                          size,
                                          data,
                                          type,
                                          priority,
                                          anonymity,
                                          replication,
                                          expiration,
                                          uid,
                                          &handle_datastore_reply,
                                          sc))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "On-demand encoding request failed\n");
      continue_writing (sc);
    }
    return;
  }
  if (msize > GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    continue_writing (sc);
    return;
  }
  GNUNET_break (GNUNET_BLOCK_TYPE_ANY != type);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting transmission of %u byte reply of type %d for query `%s' via cadet to %p\n",
              (unsigned int) size,
              (unsigned int) type,
              GNUNET_h2s (key),
              sc);
  env = GNUNET_MQ_msg_extra (srm,
                             size,
                             GNUNET_MESSAGE_TYPE_FS_CADET_REPLY);
  srm->type = htonl (type);
  srm->expiration = GNUNET_TIME_absolute_hton (expiration);
  GNUNET_memcpy (&srm[1],
                 data,
                 size);
  GNUNET_MQ_notify_sent (env,
                         &continue_writing,
                         sc);
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# Blocks transferred via cadet"),
                            1,
                            GNUNET_NO);
  GNUNET_MQ_send (GNUNET_CADET_get_mq (sc->channel),
                  env);
}

References anonymity, continue_writing(), data, env, expiration, CadetReplyMessage::expiration, gettext_noop, GNUNET_BLOCK_TYPE_ANY, GNUNET_BLOCK_TYPE_FS_ONDEMAND, GNUNET_break, GNUNET_CADET_get_mq(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_FS_handle_on_demand_block(), GNUNET_h2s(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_FS_CADET_REPLY, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_hton(), GSF_stats, handle_datastore_reply(), key, replication, sc, size, type, and CadetReplyMessage::type.

Referenced by handle_datastore_reply(), and handle_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_request()

static void handle_request	(	void *	cls,
		const struct CadetQueryMessage *	sqm
	)

static

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

Parameters

cls	closure with the `struct CadetClient`
sqm	the actual message

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

{
  struct CadetClient *sc = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received query for `%s' via cadet from client %p\n",
              GNUNET_h2s (&sqm->query),
              sc);
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# queries received via cadet"),
                            1,
                            GNUNET_NO);
  refresh_timeout_task (sc);
  sc->qe = GNUNET_DATASTORE_get_key (GSF_dsh,
                                     0 /* next_uid */,
                                     false /* random */,
                                     &sqm->query,
                                     ntohl (sqm->type),
                                     0 /* priority */,
                                     GSF_datastore_queue_size,
                                     &handle_datastore_reply,
                                     sc);
  if (NULL == sc->qe)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Queueing request with datastore failed (queue full?)\n");
    continue_writing (sc);
  }
}

References continue_writing(), gettext_noop, GNUNET_DATASTORE_get_key(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GSF_datastore_queue_size, GSF_dsh, GSF_stats, handle_datastore_reply(), CadetQueryMessage::query, refresh_timeout_task(), sc, and CadetQueryMessage::type.

Here is the call graph for this function:

◆ connect_cb()

static void * connect_cb	(	void *	cls,
		struct GNUNET_CADET_Channel *	channel,
		const struct GNUNET_PeerIdentity *	initiator
	)

static

Functions of this type are called upon new cadet connection from other peers.

Parameters

cls	the closure from GNUNET_CADET_connect
channel	the channel representing the cadet
initiator	the identity of the peer who wants to establish a cadet with us; NULL on binding error

Returns: initial channel context (our struct CadetClient)

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

{
  struct CadetClient *sc;
 
  GNUNET_assert (NULL != channel);
  if (sc_count >= sc_count_max)
  {
    GNUNET_STATISTICS_update (GSF_stats,
                              gettext_noop (
                                "# cadet client connections rejected"),
                              1,
                              GNUNET_NO);
    GNUNET_CADET_channel_destroy (channel);
    return NULL;
  }
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# cadet connections active"),
                            1,
                            GNUNET_NO);
  sc = GNUNET_new (struct CadetClient);
  sc->channel = channel;
  GNUNET_CONTAINER_DLL_insert (sc_head,
                               sc_tail,
                               sc);
  sc_count++;
  refresh_timeout_task (sc);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Accepting inbound cadet connection from `%s' as client %p\n",
              GNUNET_i2s (initiator),
              sc);
  return sc;
}

References CadetClient::channel, gettext_noop, GNUNET_assert, GNUNET_CADET_channel_destroy(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), GSF_stats, refresh_timeout_task(), sc, sc_count, sc_count_max, sc_head, and sc_tail.

Referenced by GNUNET_SERVICE_register_(), GNUNET_SERVICE_run_(), GNUNET_SERVICE_start(), and GSF_cadet_start_server().

Here is the call graph for this function:

Here is the caller 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 420 of file gnunet-service-fs_cadet_server.c.

{
  struct CadetClient *sc = cls;
  struct WriteQueueItem *wqi;
 
  if (NULL == sc)
    return;
  sc->channel = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Terminating cadet connection with client %p\n",
              sc);
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# cadet connections active"), -1,
                            GNUNET_NO);
  if (NULL != sc->terminate_task)
    GNUNET_SCHEDULER_cancel (sc->terminate_task);
  if (NULL != sc->timeout_task)
    GNUNET_SCHEDULER_cancel (sc->timeout_task);
  if (NULL != sc->qe)
    GNUNET_DATASTORE_cancel (sc->qe);
  while (NULL != (wqi = sc->wqi_head))
  {
    GNUNET_CONTAINER_DLL_remove (sc->wqi_head,
                                 sc->wqi_tail,
                                 wqi);
    GNUNET_free (wqi);
  }
  GNUNET_CONTAINER_DLL_remove (sc_head,
                               sc_tail,
                               sc);
  sc_count--;
  GNUNET_free (sc);
}

References gettext_noop, GNUNET_CONTAINER_DLL_remove, GNUNET_DATASTORE_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GSF_stats, sc, sc_count, sc_head, and sc_tail.

Referenced by GSF_cadet_start_server().

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 471 of file gnunet-service-fs_cadet_server.c.

{
  /* FIXME: could do flow control here... */
}

Referenced by GSF_cadet_start_server().

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);
}