plugin_dhtu_gnunet.c File Reference

plain IP based DHT network underlay More...

#include "platform.h"
#include "gnunet_dhtu_plugin.h"
#include "gnunet_ats_service.h"
#include "gnunet_core_service.h"
#include "gnunet_transport_service.h"
#include "gnunet_hello_lib.h"
#include "gnunet_peerinfo_service.h"
#include "gnunet_nse_service.h"
#include "../peerinfo-tool/gnunet-peerinfo_plugins.c"

Include dependency graph for plugin_dhtu_gnunet.c:

Go to the source code of this file.

Data Structures
struct	HelloHandle
	Handle for a HELLO we're offering the transport. More...
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	hello_offered_cb (void *cls)
	Function called once a hello offer is completed. More...
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. More...
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. More...
static void	gnunet_drop (struct GNUNET_DHTU_PreferenceHandle *ph)
	Do no long request underlay to keep the connection alive. More...
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. More...
static void *	core_connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
	Method called whenever a given peer connects. More...
static void	core_disconnect_cb (void *cls, const struct GNUNET_PeerIdentity *peer, void *peer_cls)
	Method called whenever a peer disconnects. More...
static void	peerinfo_cb (void *cls, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_HELLO_Message *hello, const char *err_msg)
	Find the hello for our identity and then pass it to the DHT as a URL. More...
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). More...
static int	check_core_message (void *cls, const struct GNUNET_MessageHeader *msg)
	Anything goes, always return GNUNET_OK. More...
static void	handle_core_message (void *cls, const struct GNUNET_MessageHeader *msg)
	Handle message from CORE for the DHT. More...
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. More...
void *	libgnunet_plugin_dhtu_gnunet_done (void *cls)
	Exit point from the plugin. More...
void *	libgnunet_plugin_dhtu_gnunet_init (void *cls)
	Entry point for the plugin. More...

Detailed Description

plain IP based DHT network underlay

Author

Christian Grothoff

Definition in file plugin_dhtu_gnunet.c.

Function Documentation

hello_offered_cb()

static void hello_offered_cb ( void *  cls )

static

Function called once a hello offer is completed.

Parameters

cls	a struct HelloHandle

Definition at line 214 of file plugin_dhtu_gnunet.c.

{
  struct HelloHandle *hh = cls;
  struct Plugin *plugin = hh->plugin;
 
  GNUNET_CONTAINER_DLL_remove (plugin->hh_head,
                               plugin->hh_tail,
                               hh);
  GNUNET_free (hh);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, HelloHandle::plugin, and plugin.

Referenced by gnunet_try_connect().

Here is the caller graph for this function:

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 237 of file plugin_dhtu_gnunet.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_HELLO_Message *hello = NULL;
  struct HelloHandle *hh;
  struct GNUNET_CRYPTO_EddsaPublicKey pubkey;
 
  (void) pid; /* will be needed with future address URIs */
  if (GNUNET_OK !=
      GNUNET_HELLO_parse_uri (address,
                              &pubkey,
                              &hello,
                              &GPI_plugins_find))
    return;
  hh = GNUNET_new (struct HelloHandle);
  hh->plugin = plugin;
  GNUNET_CONTAINER_DLL_insert (plugin->hh_head,
                               plugin->hh_tail,
                               hh);
  hh->ohh = GNUNET_TRANSPORT_offer_hello (plugin->env->cfg,
                                          &hello->header,
                                          &hello_offered_cb,
                                          hh);
  GNUNET_free (hello);
}

References address, GNUNET_CONTAINER_DLL_insert, GNUNET_free, GNUNET_HELLO_parse_uri(), GNUNET_new, GNUNET_OK, GNUNET_TRANSPORT_offer_hello(), GPI_plugins_find(), GNUNET_HELLO_Message::header, hello_offered_cb(), HelloHandle::ohh, pid, HelloHandle::plugin, plugin, and pubkey.

Referenced by libgnunet_plugin_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 275 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->csh)
    GNUNET_ATS_connectivity_suggest_cancel (target->csh);
  target->csh
    = GNUNET_ATS_connectivity_suggest (plugin->ats,
                                       &target->pid,
                                       target->ph_count);
  return ph;
}

References GNUNET_DHTU_Target::csh, GNUNET_ATS_connectivity_suggest(), GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_CONTAINER_DLL_insert, GNUNET_new, ph, 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 libgnunet_plugin_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 304 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->csh)
    GNUNET_ATS_connectivity_suggest_cancel (target->csh);
  if (0 == target->ph_count)
    target->csh = NULL;
  else
    target->csh
      = GNUNET_ATS_connectivity_suggest (plugin->ats,
                                         &target->pid,
                                         target->ph_count);
}

References GNUNET_DHTU_Target::csh, GNUNET_ATS_connectivity_suggest(), GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, ph, GNUNET_DHTU_Target::ph_count, GNUNET_DHTU_Target::ph_head, GNUNET_DHTU_Target::ph_tail, GNUNET_DHTU_Target::pid, GNUNET_DHTU_Target::plugin, and plugin.

Referenced by libgnunet_plugin_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 342 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 libgnunet_plugin_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  )

static

Method called whenever a given peer connects.

Parameters

cls	closure
peer	peer identity this notification is about

Returns

closure associated with peer. given to mq callbacks and GNUNET_CORE_DisconnectEventHandler

Definition at line 375 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_new, mq, GNUNET_DHTU_Target::mq, peer, GNUNET_DHTU_Target::pid, GNUNET_DHTU_Target::plugin, and plugin.

Referenced by libgnunet_plugin_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 403 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->csh)
    GNUNET_ATS_connectivity_suggest_cancel (target->csh);
  GNUNET_free (target);
}

References GNUNET_DHTU_Target::app_ctx, GNUNET_DHTU_Target::csh, GNUNET_ATS_connectivity_suggest_cancel(), GNUNET_free, and plugin.

Referenced by libgnunet_plugin_dhtu_gnunet_init().

Here is the call graph for this function:

Here is the caller graph for this function:

peerinfo_cb()

static void peerinfo_cb ( void *  cls, const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_HELLO_Message *  hello, const char *  err_msg  )

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 430 of file plugin_dhtu_gnunet.c.

{
  struct Plugin *plugin = cls;
  char *addr;
 
  if (NULL == hello)
    return;
  if (NULL == peer)
    return;
  if (0 !=
      GNUNET_memcmp (peer,
                     &plugin->my_identity))
    return;
  addr = GNUNET_HELLO_compose_uri (hello,
                                   &GPI_plugins_find);
  if (NULL == addr)
    return;
  plugin->env->address_add_cb (plugin->env->cls,
                               addr,
                               &plugin->src,
                               &plugin->src.app_ctx);
  GNUNET_free (addr);
}

References GNUNET_free, GNUNET_HELLO_compose_uri(), GNUNET_memcmp, GPI_plugins_find(), peer, and plugin.

Referenced by core_init_cb().

Here is the call graph for this function:

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 471 of file plugin_dhtu_gnunet.c.

{
  struct Plugin *plugin = cls;
 
  plugin->my_identity = *my_identity;
  plugin->nc = GNUNET_PEERINFO_notify (plugin->env->cfg,
                                       GNUNET_NO,
                                       &peerinfo_cb,
                                       plugin);
}

References GNUNET_NO, GNUNET_PEERINFO_notify(), my_identity, peerinfo_cb(), and plugin.

Referenced by libgnunet_plugin_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 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 plugin.

Referenced by libgnunet_plugin_dhtu_gnunet_init().

Here is the caller graph for this function:

libgnunet_plugin_dhtu_gnunet_done()

void* libgnunet_plugin_dhtu_gnunet_done

(

void *

cls

)

Exit point from the plugin.

Parameters

cls	closure (our struct Plugin)

Returns

NULL

Definition at line 553 of file plugin_dhtu_gnunet.c.

{
  struct GNUNET_DHTU_PluginFunctions *api = cls;
  struct Plugin *plugin = api->cls;
  struct HelloHandle *hh;
 
  while (NULL != (hh = plugin->hh_head))
  {
    GNUNET_CONTAINER_DLL_remove (plugin->hh_head,
                                 plugin->hh_tail,
                                 hh);
    GNUNET_TRANSPORT_offer_hello_cancel (hh->ohh);
    GNUNET_free (hh);
  }
  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->ats)
    GNUNET_ATS_connectivity_done (plugin->ats);
  if (NULL != plugin->nc)
    GNUNET_PEERINFO_notify_cancel (plugin->nc);
  GPI_plugins_unload ();
  GNUNET_free (plugin);
  GNUNET_free (api);
  return NULL;
}

References Plugin::api, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_DHTU_PluginFunctions::cls, GNUNET_ATS_connectivity_done(), GNUNET_CONTAINER_DLL_remove, GNUNET_CORE_disconnect(), GNUNET_free, GNUNET_NSE_disconnect(), GNUNET_PEERINFO_notify_cancel(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TRANSPORT_offer_hello_cancel(), GPI_plugins_unload(), HelloHandle::ohh, and plugin.

Referenced by libgnunet_plugin_dhtu_gnunet_init().

Here is the call graph for this function:

Here is the caller graph for this function:

libgnunet_plugin_dhtu_gnunet_init()

void* libgnunet_plugin_dhtu_gnunet_init

(

void *

cls

)

Entry point for the plugin.

Parameters

cls	closure (the struct GNUNET_DHTU_PluginEnvironment)

Returns

the plugin's API

Definition at line 593 of file plugin_dhtu_gnunet.c.

{
  struct GNUNET_DHTU_PluginEnvironment *env = cls;
  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 ()
  };
 
  plugin = GNUNET_new (struct Plugin);
  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->ats = GNUNET_ATS_connectivity_init (env->cfg);
  plugin->core = GNUNET_CORE_connect (env->cfg,
                                      plugin,
                                      &core_init_cb,
                                      &core_connect_cb,
                                      &core_disconnect_cb,
                                      handlers);
  plugin->nse = GNUNET_NSE_connect (env->cfg,
                                    &nse_cb,
                                    plugin);
  if ( (NULL == plugin->ats) ||
       (NULL == plugin->core) ||
       (NULL == plugin->nse) )
  {
    GNUNET_break (0);
    GNUNET_free (api);
    libgnunet_plugin_dhtu_gnunet_done (plugin);
    return NULL;
  }
  GPI_plugins_load (env->cfg);
  return api;
}

References GNUNET_DHTU_PluginEnvironment::cls, GNUNET_DHTU_PluginFunctions::cls, core_connect_cb(), core_disconnect_cb(), core_init_cb(), GNUNET_DHTU_PluginFunctions::drop, env, GNUNET_ATS_connectivity_init(), GNUNET_break, GNUNET_CORE_connect(), gnunet_drop(), GNUNET_free, gnunet_hold(), GNUNET_MESSAGE_TYPE_DHT_CORE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_new, GNUNET_NSE_connect(), gnunet_send(), gnunet_try_connect(), GPI_plugins_load(), handlers, GNUNET_DHTU_PluginFunctions::hold, libgnunet_plugin_dhtu_gnunet_done(), nse_cb(), plugin, GNUNET_DHTU_PluginFunctions::send, and GNUNET_DHTU_PluginFunctions::try_connect.

Here is the call graph for this function: