plugin_dhtu_gnunet.c File Reference

plain IP based DHT network underlay More...

#include "platform.h"
#include "gnunet_dhtu_plugin.h"
#include "gnunet_core_service.h"
#include "gnunet_transport_application_service.h"
#include "gnunet_hello_uri_lib.h"
#include "gnunet_peerstore_service.h"
#include "gnunet_nse_service.h"
#include "plugin_dhtu_gnunet.h"

Include dependency graph for plugin_dhtu_gnunet.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_DHTU_Source
	Opaque handle that the underlay offers for our address to be used when sending messages to another peer. More...
struct	GNUNET_DHTU_Target
	Opaque handle that the underlay offers for the target peer when sending messages to another peer. More...
struct	GNUNET_DHTU_PreferenceHandle
	Opaque handle expressing a preference of the DHT to keep a particular target connected. More...
struct	Plugin
	Handle for a plugin. More...

Functions
static void	gnunet_try_connect (void *cls, const struct GNUNET_PeerIdentity *pid, const char *address)
	Request creation of a session with a peer at the given address.
static struct GNUNET_DHTU_PreferenceHandle *	gnunet_hold (void *cls, struct GNUNET_DHTU_Target *target)
	Request underlay to keep the connection to target alive if possible.
static void	gnunet_drop (struct GNUNET_DHTU_PreferenceHandle *ph)
	Do no long request underlay to keep the connection alive.
static void	gnunet_send (void *cls, struct GNUNET_DHTU_Target *target, const void *msg, size_t msg_size, GNUNET_SCHEDULER_TaskCallback finished_cb, void *finished_cb_cls)
	Send message to some other participant over the network.
static void *	core_connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq, enum GNUNET_CORE_PeerClass class)
	Method called whenever a given peer connects.
static void	core_disconnect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, void *peer_cls)
	Method called whenever a peer disconnects.
static void	add_addr (void *cls, const struct GNUNET_PeerIdentity *pid, const char *addr)
static void	peerinfo_cb (void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *emsg)
	Find the hello for our identity and then pass it to the DHT as a URL.
static void	error_cb (void *cls)
static void	sync_cb (void *cls)
static void	core_init_cb (void *cls, const struct GNUNET_PeerIdentity *my_identity)
	Function called after GNUNET_CORE_connect has succeeded (or failed for good).
static int	check_core_message (void *cls, const struct GNUNET_MessageHeader *msg)
	Anything goes, always return GNUNET_OK.
static void	handle_core_message (void *cls, const struct GNUNET_MessageHeader *msg)
	Handle message from CORE for the DHT.
static void	nse_cb (void *cls, struct GNUNET_TIME_Absolute timestamp, double logestimate, double std_dev)
	Callback to call when network size estimate is updated.
void *	DHTU_gnunet_done (struct GNUNET_DHTU_PluginFunctions *api)
	Exit point from the plugin.
struct GNUNET_DHTU_PluginFunctions *	DHTU_gnunet_init (struct GNUNET_DHTU_PluginEnvironment *env)
	Entry point for the plugin.

Detailed Description

plain IP based DHT network underlay

Author

Christian Grothoff

Definition in file plugin_dhtu_gnunet.c.

Function Documentation

gnunet_try_connect()

static void gnunet_try_connect ( void *  cls, const struct GNUNET_PeerIdentity *  pid, const char *  address  )

static

Request creation of a session with a peer at the given address.

Parameters

cls	closure (internal context for the plugin)
pid	target identity of the peer to connect to
address	target address to connect to

Definition at line 191 of file plugin_dhtu_gnunet.c.

{
  struct Plugin *plugin = cls;
  enum GNUNET_NetworkType nt = 0;
  char *addr;
  const char *eou;
  int pfx_len;
 
  eou = strstr (address,
                "://");
  if (NULL == eou)
  {
    GNUNET_break (0);
    return;
  }
  pfx_len = eou - address;
  eou += 3;
  GNUNET_asprintf (&addr,
                   "%.*s-%s",
                   pfx_len,
                   address,
                   eou);
  GNUNET_TRANSPORT_application_validate (plugin->transport,
                                         pid,
                                         nt,
                                         addr);
  GNUNET_free (addr);
}

References address, GNUNET_asprintf(), GNUNET_break, GNUNET_free, GNUNET_TRANSPORT_application_validate(), nt, pid, and plugin.

Referenced by DHTU_gnunet_init().

Here is the call graph for this function:

Here is the caller graph for this function:

gnunet_hold()

static struct GNUNET_DHTU_PreferenceHandle * gnunet_hold ( void *  cls, struct GNUNET_DHTU_Target *  target  )

static

Request underlay to keep the connection to target alive if possible.

Hold may be called multiple times to express a strong preference to keep a connection, say because a target is in multiple tables.

Parameters

cls	closure
target	connection to keep alive

Definition at line 232 of file plugin_dhtu_gnunet.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_DHTU_PreferenceHandle *ph;
 
  ph = GNUNET_new (struct GNUNET_DHTU_PreferenceHandle);
  ph->target = target;
  GNUNET_CONTAINER_DLL_insert (target->ph_head,
                               target->ph_tail,
                               ph);
  target->ph_count++;
  if (NULL != target->ash)
    GNUNET_TRANSPORT_application_suggest_cancel (target->ash);
  target->ash
    = GNUNET_TRANSPORT_application_suggest (plugin->transport,
                                            &target->pid,
                                            GNUNET_MQ_PRIO_BEST_EFFORT,
                                            GNUNET_BANDWIDTH_ZERO);
  return ph;
}

References GNUNET_DHTU_Target::ash, GNUNET_BANDWIDTH_ZERO, GNUNET_CONTAINER_DLL_insert, GNUNET_MQ_PRIO_BEST_EFFORT, GNUNET_new, GNUNET_TRANSPORT_application_suggest(), GNUNET_TRANSPORT_application_suggest_cancel(), GNUNET_DHTU_Target::ph_count, GNUNET_DHTU_Target::ph_head, GNUNET_DHTU_Target::ph_tail, GNUNET_DHTU_Target::pid, plugin, and GNUNET_DHTU_PreferenceHandle::target.

Referenced by DHTU_gnunet_init().

Here is the call graph for this function:

Here is the caller graph for this function:

gnunet_drop()

static void gnunet_drop ( struct GNUNET_DHTU_PreferenceHandle *  ph )

static

Do no long request underlay to keep the connection alive.

Parameters

cls	closure
target	connection to keep alive

Definition at line 262 of file plugin_dhtu_gnunet.c.

{
  struct GNUNET_DHTU_Target *target = ph->target;
  struct Plugin *plugin = target->plugin;
 
  GNUNET_CONTAINER_DLL_remove (target->ph_head,
                               target->ph_tail,
                               ph);
  target->ph_count--;
  GNUNET_free (ph);
  if (NULL != target->ash)
    GNUNET_TRANSPORT_application_suggest_cancel (target->ash);
  if (0 == target->ph_count)
    target->ash = NULL;
  else
    target->ash
      = GNUNET_TRANSPORT_application_suggest (plugin->transport,
                                              &target->pid,
                                              GNUNET_MQ_PRIO_BEST_EFFORT,
                                              GNUNET_BANDWIDTH_ZERO);
}

References GNUNET_DHTU_Target::ash, GNUNET_BANDWIDTH_ZERO, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_PRIO_BEST_EFFORT, GNUNET_TRANSPORT_application_suggest(), GNUNET_TRANSPORT_application_suggest_cancel(), GNUNET_DHTU_Target::ph_count, GNUNET_DHTU_Target::ph_head, GNUNET_DHTU_Target::ph_tail, GNUNET_DHTU_Target::pid, plugin, GNUNET_DHTU_Target::plugin, and GNUNET_DHTU_PreferenceHandle::target.

Referenced by DHTU_gnunet_init().

Here is the call graph for this function:

Here is the caller graph for this function:

gnunet_send()

static void gnunet_send ( void *  cls, struct GNUNET_DHTU_Target *  target, const void *  msg, size_t  msg_size, GNUNET_SCHEDULER_TaskCallback  finished_cb, void *  finished_cb_cls  )

static

Send message to some other participant over the network.

Note that sending is not guaranteeing that the other peer actually received the message. For any given target, the DHT must wait for the finished_cb to be called before calling send() again.

Parameters

cls	closure (internal context for the plugin)
target	receiver identification
msg	message
msg_size	number of bytes in msg
finished_cb	function called once transmission is done (not called if target disconnects, then only the disconnect_cb is called).
finished_cb_cls	closure for finished_cb

Definition at line 301 of file plugin_dhtu_gnunet.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *cmsg;
 
  env = GNUNET_MQ_msg_extra (cmsg,
                             msg_size,
                             GNUNET_MESSAGE_TYPE_DHT_CORE);
  GNUNET_MQ_notify_sent (env,
                         finished_cb,
                         finished_cb_cls);
  memcpy (&cmsg[1],
          msg,
          msg_size);
  GNUNET_MQ_send (target->mq,
                  env);
}

References env, finished_cb(), GNUNET_MESSAGE_TYPE_DHT_CORE, GNUNET_MQ_msg_extra, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_DHTU_Target::mq, and msg.

Referenced by DHTU_gnunet_init().

Here is the call graph for this function:

Here is the caller graph for this function:

core_connect_cb()

static void * core_connect_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GNUNET_MQ_Handle *  mq, enum GNUNET_CORE_PeerClass  class  )

static

Method called whenever a given peer connects.

Parameters

cls	closure
peer	peer identity this notification is about
class	class of the connecting peer

Returns

closure associated with peer. given to mq callbacks and GNUNET_CORE_DisconnectEventHandler

Definition at line 335 of file plugin_dhtu_gnunet.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_DHTU_Target *target;
 
  target = GNUNET_new (struct GNUNET_DHTU_Target);
  target->plugin = plugin;
  target->mq = mq;
  target->pid = *peer;
  plugin->env->connect_cb (plugin->env->cls,
                           target,
                           &target->pid,
                           &target->app_ctx);
  return target;
}

References GNUNET_DHTU_Target::app_ctx, GNUNET_TESTING_PluginFunctions::cls, GNUNET_new, mq, GNUNET_DHTU_Target::mq, GNUNET_DHTU_Target::pid, plugin, and GNUNET_DHTU_Target::plugin.

Referenced by DHTU_gnunet_init().

Here is the caller graph for this function:

core_disconnect_cb()

static void core_disconnect_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, void *  peer_cls  )

static

Method called whenever a peer disconnects.

Parameters

cls	closure
peer	peer identity this notification is about
peer_cls	closure associated with peer. given in GNUNET_CORE_ConnectEventHandler

Definition at line 364 of file plugin_dhtu_gnunet.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_DHTU_Target *target = peer_cls;
 
  plugin->env->disconnect_cb (target->app_ctx);
  if (NULL != target->ash)
    GNUNET_TRANSPORT_application_suggest_cancel (target->ash);
  GNUNET_free (target);
}

References GNUNET_DHTU_Target::app_ctx, GNUNET_DHTU_Target::ash, GNUNET_free, GNUNET_TRANSPORT_application_suggest_cancel(), and plugin.

Referenced by DHTU_gnunet_init().

Here is the call graph for this function:

Here is the caller graph for this function:

add_addr()

static void add_addr ( void *  cls, const struct GNUNET_PeerIdentity *  pid, const char *  addr  )

static

Definition at line 379 of file plugin_dhtu_gnunet.c.

{
  struct Plugin *plugin = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "peerinfo_cb addr %s\n",
              addr);
  plugin->env->address_add_cb (plugin->env->cls,
                               addr,
                               &plugin->src,
                               &plugin->src.app_ctx);
}

References GNUNET_TESTING_PluginFunctions::cls, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and plugin.

Referenced by peerinfo_cb().

Here is the caller graph for this function:

peerinfo_cb()

static void peerinfo_cb ( void *  cls, const struct GNUNET_PEERSTORE_Record *  record, const char *  emsg  )

static

Find the hello for our identity and then pass it to the DHT as a URL.

Note that we only add addresses, never remove them, due to limitations of the current peerinfo/core/transport APIs. This will change with TNG.

Parameters

cls	a struct Plugin
peer	id of the peer, NULL for last call
hello	hello message for the peer (can be NULL)
err_msg	message

Definition at line 408 of file plugin_dhtu_gnunet.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_HELLO_Parser *parser;
  struct GNUNET_MessageHeader *hello;
 
  hello = record->value;
  if (NULL == hello)
    return;
  if (0 !=
      GNUNET_memcmp (&record->peer,
                     &plugin->my_identity))
  {
    GNUNET_PEERSTORE_monitor_next (plugin->peerstore_notify, 1);
    return;
  }
  parser = GNUNET_HELLO_parser_from_msg (hello);
  GNUNET_HELLO_parser_iterate (parser,
                               add_addr,
                               plugin);
  GNUNET_HELLO_parser_free (parser);
  GNUNET_PEERSTORE_monitor_next (plugin->peerstore_notify, 1);
}

References add_addr(), GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_iterate(), GNUNET_memcmp, GNUNET_PEERSTORE_monitor_next(), plugin, and record().

Referenced by core_init_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

error_cb()

static void error_cb ( void *  cls )

static

Definition at line 436 of file plugin_dhtu_gnunet.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Error in PEERSTORE monitoring\n");
}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by core_init_cb().

Here is the caller graph for this function:

sync_cb()

static void sync_cb ( void *  cls )

static

Definition at line 444 of file plugin_dhtu_gnunet.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              "Done with initial PEERSTORE iteration during monitoring\n");
}

References GNUNET_ERROR_TYPE_WARNING, and GNUNET_log.

Referenced by core_init_cb().

Here is the caller graph for this function:

core_init_cb()

static void core_init_cb ( void *  cls, const struct GNUNET_PeerIdentity *  my_identity  )

static

Function called after GNUNET_CORE_connect has succeeded (or failed for good).

Note that the private key of the peer is intentionally not exposed here; if you need it, your process should try to read the private key file directly (which should work if you are authorized...). Implementations of this function must not call GNUNET_CORE_disconnect (other than by scheduling a new task to do this later).

Parameters

cls	closure
my_identity	ID of this peer, NULL if we failed

Definition at line 464 of file plugin_dhtu_gnunet.c.

{
  struct Plugin *plugin = cls;
 
  plugin->my_identity = *my_identity;
  plugin->peerstore_notify = GNUNET_PEERSTORE_monitor_start (plugin->env->cfg,
                                                             GNUNET_YES,
                                                             "peerstore",
                                                             NULL,
                                                             GNUNET_PEERSTORE_HELLO_KEY,
                                                             &error_cb,
                                                             NULL,
                                                             &sync_cb,
                                                             NULL,
                                                             &peerinfo_cb,
                                                             plugin);
}

References error_cb(), GNUNET_PEERSTORE_HELLO_KEY, GNUNET_PEERSTORE_monitor_start(), GNUNET_YES, my_identity, peerinfo_cb(), plugin, and sync_cb().

Referenced by DHTU_gnunet_init().

Here is the call graph for this function:

Here is the caller graph for this function:

check_core_message()

static int check_core_message ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

Anything goes, always return GNUNET_OK.

Parameters

cls	unused
msg	message to check

Returns

GNUNET_OK if all is fine

Definition at line 492 of file plugin_dhtu_gnunet.c.

{
  (void) cls;
  (void) msg;
  return GNUNET_OK;
}

References GNUNET_OK, and msg.

handle_core_message()

static void handle_core_message ( void *  cls, const struct GNUNET_MessageHeader *  msg  )

static

Handle message from CORE for the DHT.

Passes it to the DHT logic.

Parameters

cls	a struct GNUNET_DHTU_Target of the sender
msg	the message we received

Definition at line 509 of file plugin_dhtu_gnunet.c.

{
  struct GNUNET_DHTU_Target *origin = cls;
  struct Plugin *plugin = origin->plugin;
 
  plugin->env->receive_cb (plugin->env->cls,
                           &origin->app_ctx,
                           &plugin->src.app_ctx,
                           &msg[1],
                           ntohs (msg->size) - sizeof (*msg));
}

References GNUNET_TESTING_PluginFunctions::cls, msg, origin, plugin, and GNUNET_MessageHeader::size.

nse_cb()

static void nse_cb ( void *  cls, struct GNUNET_TIME_Absolute  timestamp, double  logestimate, double  std_dev  )

static

Callback to call when network size estimate is updated.

Parameters

cls	closure
timestamp	time when the estimate was received from the server (or created by the server)
logestimate	the log(Base 2) value of the current network size estimate
std_dev	standard deviation for the estimate

Definition at line 532 of file plugin_dhtu_gnunet.c.

{
  struct Plugin *plugin = cls;
 
  plugin->env->network_size_cb (plugin->env->cls,
                                timestamp,
                                logestimate,
                                std_dev);
}

References GNUNET_TESTING_PluginFunctions::cls, plugin, and timestamp().

Referenced by DHTU_gnunet_init().

Here is the call graph for this function:

Here is the caller graph for this function:

DHTU_gnunet_done()

void * DHTU_gnunet_done

(

struct GNUNET_DHTU_PluginFunctions *

api

)

Exit point from the plugin.

Parameters

cls	closure (our struct Plugin)

Returns

NULL

Definition at line 553 of file plugin_dhtu_gnunet.c.

{
  struct Plugin *plugin = api->cls;
 
  if (NULL != plugin->nse)
    GNUNET_NSE_disconnect (plugin->nse);
  plugin->env->network_size_cb (plugin->env->cls,
                                GNUNET_TIME_UNIT_FOREVER_ABS,
                                0.0,
                                0.0);
  if (NULL != plugin->core)
    GNUNET_CORE_disconnect (plugin->core);
  if (NULL != plugin->transport)
    GNUNET_TRANSPORT_application_done (plugin->transport);
  if (NULL != plugin->peerstore_notify)
    GNUNET_PEERSTORE_monitor_stop (plugin->peerstore_notify);
  if (NULL != plugin->peerstore)
    GNUNET_PEERSTORE_disconnect (plugin->peerstore);
  // GPI_plugins_unload ();
  GNUNET_free (plugin->my_priv);
  GNUNET_free (plugin);
  GNUNET_free (api);
  return NULL;
}

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_TESTING_PluginFunctions::cls, GNUNET_CORE_disconnect(), GNUNET_free, GNUNET_NSE_disconnect(), GNUNET_PEERSTORE_disconnect(), GNUNET_PEERSTORE_monitor_stop(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TRANSPORT_application_done(), and plugin.

Referenced by DHTU_gnunet_init(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

DHTU_gnunet_init()

struct GNUNET_DHTU_PluginFunctions * DHTU_gnunet_init

(

struct GNUNET_DHTU_PluginEnvironment *

env

)

Entry point for the plugin.

Parameters

cls	closure (the struct GNUNET_DHTU_PluginEnvironment)

Returns

the plugin's API

Definition at line 586 of file plugin_dhtu_gnunet.c.

{
  struct GNUNET_DHTU_PluginFunctions *api;
  struct Plugin *plugin;
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (core_message,
                           GNUNET_MESSAGE_TYPE_DHT_CORE,
                           struct GNUNET_MessageHeader,
                           NULL),
    GNUNET_MQ_handler_end ()
  };
  const struct GNUNET_CORE_ServiceInfo service_info =
  {
    .service = GNUNET_CORE_SERVICE_DHT,
    .version = { 1, 0 },
    .version_max = { 1, 0 },
    .version_min = { 1, 0 },
  };
 
  plugin = GNUNET_new (struct Plugin);
  plugin->my_priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (
    env->cfg);
  plugin->env = env;
  api = GNUNET_new (struct GNUNET_DHTU_PluginFunctions);
  api->cls = plugin;
  api->try_connect = &gnunet_try_connect;
  api->hold = &gnunet_hold;
  api->drop = &gnunet_drop;
  api->send = &gnunet_send;
  plugin->peerstore = GNUNET_PEERSTORE_connect (env->cfg);
  plugin->transport = GNUNET_TRANSPORT_application_init (env->cfg);
  plugin->core = GNUNET_CORE_connect (env->cfg,
                                      plugin,
                                      &core_init_cb,
                                      &core_connect_cb,
                                      &core_disconnect_cb,
                                      handlers,
                                      &service_info);
  plugin->nse = GNUNET_NSE_connect (env->cfg,
                                    &nse_cb,
                                    plugin);
  if ( (NULL == plugin->transport) ||
       (NULL == plugin->core) ||
       (NULL == plugin->nse) )
  {
    GNUNET_break (0);
    DHTU_gnunet_done (api);
    return NULL;
  }
  // GPI_plugins_load (env->cfg);
  return api;
}

References GNUNET_DHTU_PluginFunctions::cls, core_connect_cb(), core_disconnect_cb(), core_init_cb(), DHTU_gnunet_done(), GNUNET_DHTU_PluginFunctions::drop, env, GNUNET_break, GNUNET_CORE_connect(), GNUNET_CORE_SERVICE_DHT, GNUNET_CRYPTO_eddsa_key_create_from_configuration(), gnunet_drop(), gnunet_hold(), GNUNET_MESSAGE_TYPE_DHT_CORE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_new, GNUNET_NSE_connect(), GNUNET_PEERSTORE_connect(), gnunet_send(), GNUNET_TRANSPORT_application_init(), gnunet_try_connect(), handlers, GNUNET_DHTU_PluginFunctions::hold, nse_cb(), plugin, GNUNET_DHTU_PluginFunctions::send, GNUNET_CORE_ServiceInfo::service, and GNUNET_DHTU_PluginFunctions::try_connect.

Referenced by load_underlay().

Here is the call graph for this function:

Here is the caller graph for this function: