plain IP based DHT network underlay More...

#include "platform.h"
#include "gnunet_dhtu_plugin.h"
#include "plugin_dhtu_ip.h"

Include dependency graph for plugin_dhtu_ip.c:

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

Macros
#define	SCAN_FREQ GNUNET_TIME_UNIT_MINUTES
	How frequently should we re-scan our local interfaces for IPs? More...

#define	MAX_DESTS 256
	Maximum number of concurrently active destinations to support. More...

Functions
static struct GNUNET_DHTU_Target *	create_target (struct Plugin plugin, const struct GNUNET_PeerIdentity pid, const struct sockaddr *addr, socklen_t addrlen)
	Create a target to which we may send traffic. More...

static struct GNUNET_DHTU_Target *	find_target (struct Plugin plugin, const struct GNUNET_PeerIdentity pid, const void *addr, size_t addrlen)
	Find target matching addr. More...

static void	ip_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 *	ip_hold (void cls, struct GNUNET_DHTU_Target target)
	Request underlay to keep the connection to target alive if possible. More...

static void	ip_drop (struct GNUNET_DHTU_PreferenceHandle *ph)
	Do no long request underlay to keep the connection alive. More...

static void	ip_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 struct GNUNET_DHTU_Source *	create_source (struct Plugin plugin, const struct sockaddr addr, socklen_t addrlen)
	Create a new source on which we may be receiving traffic. More...

static int	addrcmp_np (const struct sockaddr a1, const struct sockaddr a2, size_t alen)
	Compare two addresses excluding the ports for equality. More...

static int	addrcmp (const struct sockaddr a1, const struct sockaddr a2, size_t alen)
	Compare two addresses for equality. More...

static enum GNUNET_GenericReturnValue	process_ifcs (void cls, const char name, int isDefault, const struct sockaddr addr, const struct sockaddr broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen)
	Callback function invoked for each interface found. More...

static void	scan (void *cls)
	Scan network interfaces for IP address changes. More...

static struct GNUNET_DHTU_Source *	find_source (struct Plugin plugin, const void addr, size_t addrlen)
	Find our source matching addr. More...

static void	read_cb (void *cls)
	UDP socket is ready to receive. More...

struct GNUNET_DHTU_PluginFunctions *	DHTU_ip_init (struct GNUNET_DHTU_PluginEnvironment *env)
	Entry point for the plugin. More...

void *	DHTU_ip_done (struct GNUNET_DHTU_PluginFunctions *api)
	Exit point from the plugin. More...

Detailed Description

plain IP based DHT network underlay

Author: Christian Grothoff

Definition in file plugin_dhtu_ip.c.

Macro Definition Documentation

◆ SCAN_FREQ

#define SCAN_FREQ GNUNET_TIME_UNIT_MINUTES

How frequently should we re-scan our local interfaces for IPs?

Definition at line 34 of file plugin_dhtu_ip.c.

◆ MAX_DESTS

#define MAX_DESTS 256

Maximum number of concurrently active destinations to support.

Definition at line 39 of file plugin_dhtu_ip.c.

Function Documentation

◆ create_target()

static struct GNUNET_DHTU_Target * create_target	(	struct Plugin *	plugin,
		const struct GNUNET_PeerIdentity *	pid,
		const struct sockaddr *	addr,
		socklen_t	addrlen
	)

static

Create a target to which we may send traffic.

Parameters

plugin	our plugin
pid	presumed identity of the target
addr	target address
addrlen	number of bytes in addr

Returns: new target object

Definition at line 247 of file plugin_dhtu_ip.c.

{
  struct GNUNET_DHTU_Target *dst;
 
  if (MAX_DESTS <=
      GNUNET_CONTAINER_multihashmap_size (plugin->dsts))
  {
    struct GNUNET_HashCode key;
 
    dst = NULL;
    for (struct GNUNET_DHTU_Target *pos = plugin->dst_head;
         NULL != pos;
         pos = pos->next)
    {
      /* >= here assures we remove oldest entries first */
      if ( (NULL == dst) ||
           (dst->ph_count >= pos->ph_count) )
        dst = pos;
    }
    GNUNET_assert (NULL != dst);
    plugin->env->disconnect_cb (dst->app_ctx);
    GNUNET_CRYPTO_hash (&dst->addr,
                        dst->addrlen,
                        &key);
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multihashmap_remove (plugin->dsts,
                                                         &key,
                                                         dst));
    GNUNET_CONTAINER_DLL_remove (plugin->dst_head,
                                 plugin->dst_tail,
                                 dst);
    GNUNET_assert (NULL == dst->ph_head);
    GNUNET_free (dst);
  }
  dst = GNUNET_new (struct GNUNET_DHTU_Target);
  dst->addrlen = addrlen;
  dst->pid = *pid;
  memcpy (&dst->addr,
          addr,
          addrlen);
  GNUNET_CONTAINER_DLL_insert (plugin->dst_head,
                               plugin->dst_tail,
                               dst);
  plugin->env->connect_cb (plugin->env->cls,
                           dst,
                           &dst->pid,
                           &dst->app_ctx);
  return dst;
}

References GNUNET_DHTU_Target::addr, GNUNET_DHTU_Target::addrlen, GNUNET_DHTU_Target::app_ctx, GNUNET_TESTING_PluginFunctions::cls, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_new, GNUNET_YES, key, MAX_DESTS, GNUNET_DHTU_Target::pid, pid, and plugin.

Referenced by find_target().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_target()

static struct GNUNET_DHTU_Target * find_target	(	struct Plugin *	plugin,
		const struct GNUNET_PeerIdentity *	pid,
		const void *	addr,
		size_t	addrlen
	)

static

Find target matching addr.

If none exists, create one!

Parameters

plugin	the plugin handle
pid	presumed identity of the target
addr	socket address to find
addrlen	number of bytes in addr

Returns: matching target object

Definition at line 312 of file plugin_dhtu_ip.c.

{
  struct GNUNET_HashCode key;
  struct GNUNET_DHTU_Target *dst;
 
  GNUNET_CRYPTO_hash (addr,
                      addrlen,
                      &key);
  dst = GNUNET_CONTAINER_multihashmap_get (plugin->dsts,
                                           &key);
  if (NULL == dst)
  {
    dst = create_target (plugin,
                         pid,
                         (const struct sockaddr *) addr,
                         addrlen);
    GNUNET_assert (GNUNET_YES ==
                   GNUNET_CONTAINER_multihashmap_put (
                     plugin->dsts,
                     &key,
                     dst,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  }
  else
  {
    /* move to head of DLL */
    GNUNET_CONTAINER_DLL_remove (plugin->dst_head,
                                 plugin->dst_tail,
                                 dst);
    GNUNET_CONTAINER_DLL_insert (plugin->dst_head,
                                 plugin->dst_tail,
                                 dst);
 
  }
  return dst;
}

References GNUNET_DHTU_Target::addr, GNUNET_DHTU_Target::addrlen, create_target(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_YES, key, pid, and plugin.

Referenced by ip_try_connect(), and read_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ip_try_connect()

static void ip_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	identity of the target peer
address	target address to connect to

Definition at line 361 of file plugin_dhtu_ip.c.

{
  struct Plugin *plugin = cls;
  char *colon;
  const char *port;
  char *addr;
  struct addrinfo hints = {
    .ai_flags = AI_NUMERICHOST | AI_NUMERICSERV
  };
  struct addrinfo *result = NULL;
 
  if (0 !=
      strncmp (address,
               "ip+",
               strlen ("ip+")))
    return;
  address += strlen ("ip+");
  if (0 !=
      strncmp (address,
               "udp://",
               strlen ("udp://")))
    return;
  address += strlen ("udp://");
  addr = GNUNET_strdup (address);
  colon = strchr (addr, ':');
  if (NULL == colon)
  {
    port = plugin->port;
  }
  else
  {
    *colon = '\0';
    port = colon + 1;
  }
  if (0 !=
      getaddrinfo (addr,
                   port,
                   &hints,
                   &result))
  {
    GNUNET_break (0);
    GNUNET_free (addr);
    return;
  }
  GNUNET_free (addr);
  (void) find_target (plugin,
                      pid,
                      result->ai_addr,
                      result->ai_addrlen);
  freeaddrinfo (result);
}

References address, AI_NUMERICSERV, find_target(), GNUNET_break, GNUNET_free, GNUNET_strdup, pid, plugin, port, and result.

Referenced by DHTU_ip_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ip_hold()

static struct GNUNET_DHTU_PreferenceHandle * ip_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 425 of file plugin_dhtu_ip.c.

{
  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++;
  return ph;
}

References GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_DHTU_Target::ph_count, GNUNET_DHTU_Target::ph_head, GNUNET_DHTU_Target::ph_tail, and GNUNET_DHTU_PreferenceHandle::target.

Referenced by DHTU_ip_init().

Here is the caller graph for this function:

◆ ip_drop()

static void ip_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 447 of file plugin_dhtu_ip.c.

{
  struct GNUNET_DHTU_Target *target = ph->target;
 
  GNUNET_CONTAINER_DLL_remove (target->ph_head,
                               target->ph_tail,
                               ph);
  target->ph_count--;
  GNUNET_free (ph);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_DHTU_Target::ph_count, GNUNET_DHTU_Target::ph_head, GNUNET_DHTU_Target::ph_tail, and GNUNET_DHTU_PreferenceHandle::target.

Referenced by DHTU_ip_init().

Here is the caller graph for this function:

◆ ip_send()

static void ip_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 475 of file plugin_dhtu_ip.c.

{
  struct Plugin *plugin = cls;
  char buf[sizeof (plugin->my_id) + msg_size];
 
  memcpy (buf,
          &plugin->my_id,
          sizeof (plugin->my_id));
  memcpy (&buf[sizeof (plugin->my_id)],
          msg,
          msg_size);
  GNUNET_NETWORK_socket_sendto (plugin->sock,
                                buf,
                                sizeof (buf),
                                (const struct sockaddr *) &target->addr,
                                target->addrlen);
  finished_cb (finished_cb_cls);
}

References GNUNET_DHTU_Target::addr, GNUNET_DHTU_Target::addrlen, finished_cb(), GNUNET_NETWORK_socket_sendto(), msg, and plugin.

Referenced by DHTU_ip_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_source()

static struct GNUNET_DHTU_Source * create_source	(	struct Plugin *	plugin,
		const struct sockaddr *	addr,
		socklen_t	addrlen
	)

static

Create a new source on which we may be receiving traffic.

Parameters

plugin	our plugin
addr	our address
addrlen	number of bytes in addr

Returns: new source object

Definition at line 509 of file plugin_dhtu_ip.c.

{
  struct GNUNET_DHTU_Source *src;
 
  src = GNUNET_new (struct GNUNET_DHTU_Source);
  src->addrlen = addrlen;
  memcpy (&src->addr,
          addr,
          addrlen);
  src->scan_generation = plugin->scan_generation;
  switch (addr->sa_family)
  {
  case AF_INET:
    {
      const struct sockaddr_in *s4 = (const struct sockaddr_in *) addr;
      char buf[INET_ADDRSTRLEN];
 
      GNUNET_assert (sizeof (struct sockaddr_in) == addrlen);
      GNUNET_asprintf (&src->address,
                       "ip+udp://%s:%u",
                       inet_ntop (AF_INET,
                                  &s4->sin_addr,
                                  buf,
                                  sizeof (buf)),
                       ntohs (s4->sin_port));
    }
    break;
  case AF_INET6:
    {
      const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *) addr;
      char buf[INET6_ADDRSTRLEN];
 
      GNUNET_assert (sizeof (struct sockaddr_in6) == addrlen);
      GNUNET_asprintf (&src->address,
                       "ip+udp://[%s]:%u",
                       inet_ntop (AF_INET6,
                                  &s6->sin6_addr,
                                  buf,
                                  sizeof (buf)),
                       ntohs (s6->sin6_port));
    }
    break;
  default:
    GNUNET_break (0);
    GNUNET_free (src);
    return NULL;
  }
  GNUNET_CONTAINER_DLL_insert (plugin->src_head,
                               plugin->src_tail,
                               src);
  plugin->env->address_add_cb (plugin->env->cls,
                               src->address,
                               src,
                               &src->app_ctx);
  return src;
}

References GNUNET_DHTU_Source::addr, GNUNET_DHTU_Source::address, GNUNET_DHTU_Source::addrlen, GNUNET_DHTU_Source::app_ctx, GNUNET_TESTING_PluginFunctions::cls, GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_free, GNUNET_new, plugin, and GNUNET_DHTU_Source::scan_generation.

Referenced by find_source(), and process_ifcs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addrcmp_np()

static int addrcmp_np	(	const struct sockaddr *	a1,
		const struct sockaddr *	a2,
		size_t	alen
	)

static

Compare two addresses excluding the ports for equality.

Only compares IP address. Must only be called on AF_INET or AF_INET6 addresses.

Parameters

a1	address to compare
a2	address to compare
alen	number of bytes in a1 and a2

Returns: 0 if a1 == a2.

Definition at line 579 of file plugin_dhtu_ip.c.

{
  GNUNET_assert (a1->sa_family == a2->sa_family);
  switch (a1->sa_family)
  {
  case AF_INET:
    GNUNET_assert (sizeof (struct sockaddr_in) == alen);
    {
      const struct sockaddr_in *s1 = (const struct sockaddr_in *) a1;
      const struct sockaddr_in *s2 = (const struct sockaddr_in *) a2;
 
      if (s1->sin_addr.s_addr != s2->sin_addr.s_addr)
        return 1;
      break;
    }
  case AF_INET6:
    GNUNET_assert (sizeof (struct sockaddr_in6) == alen);
    {
      const struct sockaddr_in6 *s1 = (const struct sockaddr_in6 *) a1;
      const struct sockaddr_in6 *s2 = (const struct sockaddr_in6 *) a2;
 
      if (0 != GNUNET_memcmp (&s1->sin6_addr,
                              &s2->sin6_addr))
        return 1;
      break;
    }
  default:
    GNUNET_assert (0);
  }
  return 0;
}

References GNUNET_assert, and GNUNET_memcmp.

Referenced by process_ifcs().

Here is the caller graph for this function:

◆ addrcmp()

static int addrcmp	(	const struct sockaddr *	a1,
		const struct sockaddr *	a2,
		size_t	alen
	)

static

Compare two addresses for equality.

Only compares IP address and port. Must only be called on AF_INET or AF_INET6 addresses.

Parameters

a1	address to compare
a2	address to compare
alen	number of bytes in a1 and a2

Returns: 0 if a1 == a2.

Definition at line 625 of file plugin_dhtu_ip.c.

{
  GNUNET_assert (a1->sa_family == a2->sa_family);
  switch (a1->sa_family)
  {
  case AF_INET:
    GNUNET_assert (sizeof (struct sockaddr_in) == alen);
    {
      const struct sockaddr_in *s1 = (const struct sockaddr_in *) a1;
      const struct sockaddr_in *s2 = (const struct sockaddr_in *) a2;
 
      if (s1->sin_port != s2->sin_port)
        return 1;
      if (s1->sin_addr.s_addr != s2->sin_addr.s_addr)
        return 1;
      break;
    }
  case AF_INET6:
    GNUNET_assert (sizeof (struct sockaddr_in6) == alen);
    {
      const struct sockaddr_in6 *s1 = (const struct sockaddr_in6 *) a1;
      const struct sockaddr_in6 *s2 = (const struct sockaddr_in6 *) a2;
 
      if (s1->sin6_port != s2->sin6_port)
        return 1;
      if (0 != GNUNET_memcmp (&s1->sin6_addr,
                              &s2->sin6_addr))
        return 1;
      break;
    }
  default:
    GNUNET_assert (0);
  }
  return 0;
}

References GNUNET_assert, and GNUNET_memcmp.

Referenced by find_source().

Here is the caller graph for this function:

◆ process_ifcs()

static enum GNUNET_GenericReturnValue process_ifcs	(	void *	cls,
		const char *	name,
		int	isDefault,
		const struct sockaddr *	addr,
		const struct sockaddr *	broadcast_addr,
		const struct sockaddr *	netmask,
		socklen_t	addrlen
	)

static

Callback function invoked for each interface found.

Parameters

cls	closure
name	name of the interface (can be NULL for unknown)
isDefault	is this presumably the default interface
addr	address of this interface (can be NULL for unknown or unassigned)
broadcast_addr	the broadcast address (can be NULL for unknown or unassigned)
netmask	the network mask (can be NULL for unknown or unassigned)
addrlen	length of the address

Returns: GNUNET_OK to continue iteration, GNUNET_SYSERR to abort

Definition at line 677 of file plugin_dhtu_ip.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_DHTU_Source *src;
 
  for (src = plugin->src_head;
       NULL != src;
       src = src->next)
  {
    if ( (addrlen == src->addrlen) &&
         (0 == addrcmp_np (addr,
                           (const struct sockaddr *) &src->addr,
                           addrlen)) )
    {
      src->scan_generation = plugin->scan_generation;
      return GNUNET_OK;
    }
  }
  switch (addr->sa_family)
  {
  case AF_INET:
    {
      struct sockaddr_in v4;
 
      GNUNET_assert (sizeof(v4) == addrlen);
      memcpy (&v4,
              addr,
              addrlen);
      v4.sin_port = htons (plugin->port16);
      (void) create_source (plugin,
                            (const struct sockaddr *) &v4,
                            sizeof (v4));
      break;
    }
  case AF_INET6:
    {
      struct sockaddr_in6 v6;
 
      GNUNET_assert (sizeof(v6) == addrlen);
      memcpy (&v6,
              addr,
              addrlen);
      v6.sin6_port = htons (plugin->port16);
      (void) create_source (plugin,
                            (const struct sockaddr *) &v6,
                            sizeof (v6));
      break;
    }
  }
  return GNUNET_OK;
}

References GNUNET_DHTU_Source::addr, addrcmp_np(), GNUNET_DHTU_Source::addrlen, create_source(), GNUNET_assert, GNUNET_OK, GNUNET_DHTU_Source::next, plugin, and GNUNET_DHTU_Source::scan_generation.

Referenced by scan().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scan()

static void scan ( void * cls )

static

Scan network interfaces for IP address changes.

Parameters

cls	a `struct Plugin`

Definition at line 742 of file plugin_dhtu_ip.c.

{
  struct Plugin *plugin = cls;
  struct GNUNET_DHTU_Source *next;
 
  plugin->scan_generation++;
  GNUNET_OS_network_interfaces_list (&process_ifcs,
                                     plugin);
  for (struct GNUNET_DHTU_Source *src = plugin->src_head;
       NULL != src;
       src = next)
  {
    next = src->next;
    if (src->scan_generation >= plugin->scan_generation)
      continue;
    GNUNET_CONTAINER_DLL_remove (plugin->src_head,
                                 plugin->src_tail,
                                 src);
    plugin->env->address_del_cb (src->app_ctx);
    GNUNET_free (src->address);
    GNUNET_free (src);
  }
  plugin->scan_task = GNUNET_SCHEDULER_add_delayed (SCAN_FREQ,
                                                    &scan,
                                                    plugin);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_OS_network_interfaces_list(), GNUNET_SCHEDULER_add_delayed(), GNUNET_DHTU_Source::next, plugin, process_ifcs(), scan(), and SCAN_FREQ.

Referenced by DHTU_ip_init(), and scan().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_source()

static struct GNUNET_DHTU_Source * find_source	(	struct Plugin *	plugin,
		const void *	addr,
		size_t	addrlen
	)

static

Find our source matching addr.

If none exists, create one!

Parameters

plugin	the plugin handle
addr	socket address to find
addrlen	number of bytes in addr

Returns: matching source object

Definition at line 780 of file plugin_dhtu_ip.c.

{
  for (struct GNUNET_DHTU_Source *src = plugin->src_head;
       NULL != src;
       src = src->next)
  {
    if ( (addrlen == src->addrlen) &&
         (0 == addrcmp (addr,
                        (const struct sockaddr *) &src->addr,
                        addrlen)) )
      return src;
  }
 
  return create_source (plugin,
                        (const struct sockaddr *) addr,
                        addrlen);
}

References GNUNET_DHTU_Source::addr, addrcmp(), GNUNET_DHTU_Source::addrlen, create_source(), and plugin.

Referenced by read_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ read_cb()

static void read_cb ( void * cls )

static

UDP socket is ready to receive.

Read.

Parameters

cls	our `struct Plugin *`

Definition at line 807 of file plugin_dhtu_ip.c.

{
  struct Plugin *plugin = cls;
  ssize_t ret;
  const struct GNUNET_PeerIdentity *pid;
  char buf[65536] GNUNET_ALIGN;
  struct sockaddr_storage sa;
  struct iovec iov = {
    .iov_base = buf,
    .iov_len = sizeof (buf)
  };
  char ctl[128];
  struct msghdr mh = {
    .msg_name = &sa,
    .msg_namelen = sizeof (sa),
    .msg_iov = &iov,
    .msg_iovlen = 1,
    .msg_control = ctl,
    .msg_controllen = sizeof (ctl)
  };
  struct GNUNET_DHTU_Target *dst = NULL;
  struct GNUNET_DHTU_Source *src = NULL;
 
  ret = recvmsg  (GNUNET_NETWORK_get_fd (plugin->sock),
                  &mh,
                  MSG_DONTWAIT);
  plugin->read_task = GNUNET_SCHEDULER_add_read_net (
    GNUNET_TIME_UNIT_FOREVER_REL,
    plugin->sock,
    &read_cb,
    plugin);
  if (ret < 0)
    return; /* read failure, hopefully EAGAIN */
  if (ret < sizeof (*pid))
  {
    GNUNET_break_op (0);
    return;
  }
  /* find IP where we received message */
  for (struct cmsghdr *cmsg = CMSG_FIRSTHDR (&mh);
       NULL != cmsg;
       cmsg = CMSG_NXTHDR (&mh,
                           cmsg))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Got CMSG level %u (%d/%d), type %u (%d/%d)\n",
                cmsg->cmsg_level,
                (cmsg->cmsg_level == IPPROTO_IP),
                (cmsg->cmsg_level == IPPROTO_IPV6),
                cmsg->cmsg_type,
                (cmsg->cmsg_type == IP_PKTINFO),
                (cmsg->cmsg_type == IPV6_PKTINFO));
    if ( (cmsg->cmsg_level == IPPROTO_IP) &&
         (cmsg->cmsg_type == IP_PKTINFO) )
    {
      if (CMSG_LEN (sizeof (struct in_pktinfo)) ==
          cmsg->cmsg_len)
      {
        struct in_pktinfo pi;
 
        memcpy (&pi,
                CMSG_DATA (cmsg),
                sizeof (pi));
        {
          struct sockaddr_in sa_tmp = {
            .sin_family = AF_INET,
            .sin_addr = pi.ipi_addr,
            .sin_port = htons (plugin->port16)
          };
 
          src = find_source (plugin,
                             &sa_tmp,
                             sizeof (sa_tmp));
          /* For sources we discovered by reading,
             force the generation far into the future */
          src->scan_generation = plugin->scan_generation + 60;
        }
        break;
      }
      else
        GNUNET_break (0);
    }
    if ( (cmsg->cmsg_level == IPPROTO_IPV6) &&
         (cmsg->cmsg_type == IPV6_PKTINFO) )
    {
      if (CMSG_LEN (sizeof (struct in6_pktinfo)) ==
          cmsg->cmsg_len)
      {
        struct in6_pktinfo pi;
 
        memcpy (&pi,
                CMSG_DATA (cmsg),
                sizeof (pi));
        {
          struct sockaddr_in6 sa_tmp = {
            .sin6_family = AF_INET6,
            .sin6_addr = pi.ipi6_addr,
            .sin6_port = htons (plugin->port16),
            .sin6_scope_id = pi.ipi6_ifindex
          };
 
          src = find_source (plugin,
                             &sa_tmp,
                             sizeof (sa_tmp));
          /* For sources we discovered by reading,
             force the generation far into the future */
          src->scan_generation = plugin->scan_generation + 60;
          break;
        }
      }
      else
        GNUNET_break (0);
    }
  }
  if (NULL == src)
  {
    GNUNET_break (0);
    return;
  }
  pid = (const struct GNUNET_PeerIdentity *) buf;
  dst = find_target (plugin,
                     pid,
                     &sa,
                     mh.msg_namelen);
  if (NULL == dst)
  {
    GNUNET_break (0);
    return;
  }
  plugin->env->receive_cb (plugin->env->cls,
                           &dst->app_ctx,
                           &src->app_ctx,
                           &buf[sizeof(*pid)],
                           ret - sizeof (*pid));
}

References GNUNET_DHTU_Source::app_ctx, GNUNET_DHTU_Target::app_ctx, GNUNET_TESTING_PluginFunctions::cls, find_source(), find_target(), GNUNET_ALIGN, GNUNET_break, GNUNET_break_op, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NETWORK_get_fd(), GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_UNIT_FOREVER_REL, mh, pid, plugin, read_cb(), ret, and GNUNET_DHTU_Source::scan_generation.

Referenced by DHTU_ip_init(), and read_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DHTU_ip_init()

struct GNUNET_DHTU_PluginFunctions * DHTU_ip_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 951 of file plugin_dhtu_ip.c.

{
  struct GNUNET_DHTU_PluginFunctions *api;
  struct Plugin *plugin;
  char *port;
  unsigned int nport;
  int sock;
  int af;
  unsigned long long nse;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (env->cfg,
                                             "DHTU-IP",
                                             "NSE",
                                             &nse))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "DHTU-IP",
                               "NSE");
    return NULL;
  }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (env->cfg,
                                             "DHTU-IP",
                                             "UDP_PORT",
                                             &port))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
                               "DHTU-IP",
                               "UDP_PORT");
    return NULL;
  }
  {
    char dummy;
 
    if ( (1 != sscanf (port,
                       "%u%c",
                       &nport,
                       &dummy)) ||
         (nport > UINT16_MAX) )
    {
      GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                                 "DHTU-IP",
                                 "UDP_PORT",
                                 "must be number below 65536");
      GNUNET_free (port);
      return NULL;
    }
  }
  plugin = GNUNET_new (struct Plugin);
  plugin->env = env;
  plugin->port = port;
  plugin->port16 = (uint16_t) nport;
  if (GNUNET_OK !=
      GNUNET_CRYPTO_get_peer_identity (env->cfg,
                                       &plugin->my_id))
  {
    GNUNET_free (plugin);
    return NULL;
  }
  if (GNUNET_NETWORK_test_pf (PF_INET6))
    af = AF_INET6;
  else
    af = AF_INET;
  sock = socket (af,
                 SOCK_DGRAM,
                 IPPROTO_UDP);
  if (-1 == sock)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                         "socket");
    GNUNET_free (plugin->port);
    GNUNET_free (plugin);
    return NULL;
  }
  switch (af)
  {
  case AF_INET:
    {
      int on = 1;
 
      if (0 !=
          setsockopt (sock,
                      IPPROTO_IP,
                      IP_PKTINFO,
                      &on,
                      sizeof (on)))
      {
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                             "setsockopt");
      }
    }
    {
      struct sockaddr_in sa = {
        .sin_family = AF_INET,
        .sin_port = htons ((uint16_t) nport)
      };
 
      if (0 !=
          bind (sock,
                (const struct sockaddr *) &sa,
                sizeof (sa)))
      {
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                             "socket");
        GNUNET_break (0 ==
                      close (sock));
        GNUNET_free (plugin->port);
        GNUNET_free (plugin);
        return NULL;
      }
    }
    break;
  case AF_INET6:
    {
      int on = 1;
 
      if (0 !=
          setsockopt (sock,
                      IPPROTO_IPV6,
                      IPV6_RECVPKTINFO,
                      &on,
                      sizeof (on)))
      {
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                             "setsockopt");
      }
    }
    {
      struct sockaddr_in6 sa = {
        .sin6_family = AF_INET6,
        .sin6_port = htons ((uint16_t) nport)
      };
 
      if (0 !=
          bind (sock,
                (const struct sockaddr *) &sa,
                sizeof (sa)))
      {
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                             "socket");
        GNUNET_break (0 ==
                      close (sock));
        GNUNET_free (plugin->port);
        GNUNET_free (plugin);
        return NULL;
      }
    }
    break;
  }
  plugin->dsts = GNUNET_CONTAINER_multihashmap_create (128,
                                                       GNUNET_NO);
  plugin->sock = GNUNET_NETWORK_socket_box_native (sock);
  plugin->read_task = GNUNET_SCHEDULER_add_read_net (
    GNUNET_TIME_UNIT_FOREVER_REL,
    plugin->sock,
    &read_cb,
    plugin);
  env->network_size_cb (env->cls,
                        GNUNET_TIME_UNIT_ZERO_ABS,
                        log (nse) / log (2),
                        -1.0 /* stddev */);
  plugin->scan_task = GNUNET_SCHEDULER_add_now (&scan,
                                                plugin);
  api = GNUNET_new (struct GNUNET_DHTU_PluginFunctions);
  api->cls = plugin;
  api->try_connect = &ip_try_connect;
  api->hold = &ip_hold;
  api->drop = &ip_drop;
  api->send = &ip_send;
  return api;
}

References GNUNET_DHTU_PluginFunctions::cls, GNUNET_DHTU_PluginFunctions::drop, dummy, env, GNUNET_break, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CRYPTO_get_peer_identity(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_config_invalid(), GNUNET_log_config_missing(), GNUNET_log_strerror, GNUNET_NETWORK_socket_box_native(), GNUNET_NETWORK_test_pf(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_DHTU_PluginFunctions::hold, ip_drop(), ip_hold(), ip_send(), ip_try_connect(), nse, plugin, port, read_cb(), scan(), GNUNET_DHTU_PluginFunctions::send, Plugin::sock, 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:

◆ DHTU_ip_done()

void * DHTU_ip_done ( struct GNUNET_DHTU_PluginFunctions * api )

Exit point from the plugin.

Parameters

cls	closure (our `struct Plugin`)

Returns: NULL

Definition at line 1132 of file plugin_dhtu_ip.c.

{
  struct Plugin *plugin = api->cls;
  struct GNUNET_DHTU_Source *src;
  struct GNUNET_DHTU_Target *dst;
 
  while (NULL != (dst = plugin->dst_head))
  {
    plugin->env->disconnect_cb (dst->app_ctx);
    GNUNET_assert (NULL == dst->ph_head);
    GNUNET_CONTAINER_DLL_remove (plugin->dst_head,
                                 plugin->dst_tail,
                                 dst);
    GNUNET_free (dst);
  }
  while (NULL != (src = plugin->src_head))
  {
    plugin->env->address_del_cb (src->app_ctx);
    GNUNET_CONTAINER_DLL_remove (plugin->src_head,
                                 plugin->src_tail,
                                 src);
    GNUNET_free (src->address);
    GNUNET_free (src);
  }
  plugin->env->network_size_cb (plugin->env->cls,
                                GNUNET_TIME_UNIT_FOREVER_ABS,
                                0.0,
                                0.0);
  GNUNET_CONTAINER_multihashmap_destroy (plugin->dsts);
  if (NULL != plugin->read_task)
  {
    GNUNET_SCHEDULER_cancel (plugin->read_task);
    plugin->read_task = NULL;
  }
  GNUNET_SCHEDULER_cancel (plugin->scan_task);
  GNUNET_break (GNUNET_OK ==
                GNUNET_NETWORK_socket_close (plugin->sock));
  GNUNET_free (plugin->port);
  GNUNET_free (plugin);
  GNUNET_free (api);
  return NULL;
}

References GNUNET_DHTU_Source::address, Plugin::api, GNUNET_DHTU_Source::app_ctx, GNUNET_DHTU_Target::app_ctx, GNUNET_BLOCK_PluginFunctions::cls, GNUNET_TESTING_PluginFunctions::cls, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_DHTU_Target::ph_head, and plugin.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ SCAN_FREQ

◆ MAX_DESTS

Function Documentation

◆ create_target()

◆ find_target()

◆ ip_try_connect()

◆ ip_hold()

◆ ip_drop()

◆ ip_send()

◆ create_source()

◆ addrcmp_np()

◆ addrcmp()

◆ process_ifcs()

◆ scan()

◆ find_source()

◆ read_cb()

◆ DHTU_ip_init()

◆ DHTU_ip_done()