plugin_dhtu_ip.c File Reference

plain IP based DHT network underlay More...

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

Include dependency graph for plugin_dhtu_ip.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...

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...
void *	libgnunet_plugin_dhtu_ip_init (void *cls)
	Entry point for the plugin. More...
void *	libgnunet_plugin_dhtu_ip_done (void *cls)
	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 33 of file plugin_dhtu_ip.c.

MAX_DESTS

#define MAX_DESTS   256

Maximum number of concurrently active destinations to support.

Definition at line 38 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 246 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_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 311 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 360 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 libgnunet_plugin_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 424 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, ph, GNUNET_DHTU_Target::ph_count, GNUNET_DHTU_Target::ph_head, GNUNET_DHTU_Target::ph_tail, and GNUNET_DHTU_PreferenceHandle::target.

Referenced by libgnunet_plugin_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 446 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, ph, GNUNET_DHTU_Target::ph_count, GNUNET_DHTU_Target::ph_head, and GNUNET_DHTU_Target::ph_tail.

Referenced by libgnunet_plugin_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 474 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, buf, finished_cb(), GNUNET_NETWORK_socket_sendto(), msg, and plugin.

Referenced by libgnunet_plugin_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 508 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, buf, 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().

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

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

Referenced by scan().

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 741 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_DHTU_Source::address, GNUNET_DHTU_Source::app_ctx, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_OS_network_interfaces_list(), GNUNET_SCHEDULER_add_delayed(), GNUNET_DHTU_Source::next, plugin, process_ifcs(), SCAN_FREQ, and GNUNET_DHTU_Source::scan_generation.

Referenced by libgnunet_plugin_dhtu_ip_init().

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 779 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(), GNUNET_DHTU_Source::next, 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 806 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 = {
            .sin_family = AF_INET,
            .sin_addr = pi.ipi_addr,
            .sin_port = htons (plugin->port16)
          };
 
          src = find_source (plugin,
                             &sa,
                             sizeof (sa));
          /* 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 = {
            .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,
                             sizeof (sa));
          /* 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, buf, 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, pi, pid, plugin, ret, and GNUNET_DHTU_Source::scan_generation.

Referenced by libgnunet_plugin_dhtu_ip_init().

Here is the call graph for this function:

Here is the caller graph for this function:

libgnunet_plugin_dhtu_ip_init()

void* libgnunet_plugin_dhtu_ip_init

(

void *

cls

)

Entry point for the plugin.

Parameters

cls	closure (the struct GNUNET_DHTU_PluginEnvironment)

Returns

the plugin's API

Definition at line 950 of file plugin_dhtu_ip.c.

{
  struct GNUNET_DHTU_PluginEnvironment *env = cls;
  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;
  }
  af = AF_INET6;
  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_PluginEnvironment::cls, 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_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.

Here is the call graph for this function:

libgnunet_plugin_dhtu_ip_done()

void* libgnunet_plugin_dhtu_ip_done

(

void *

cls

)

Exit point from the plugin.

Parameters

cls	closure (our struct Plugin)

Returns

NULL

Definition at line 1129 of file plugin_dhtu_ip.c.

{
  struct GNUNET_DHTU_PluginFunctions *api = cls;
  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_DHTU_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.

Here is the call graph for this function: