nat.c File Reference

Library for NAT traversal related functionality. More...

#include "platform.h"
#include "gnunet_util_lib.h"

Include dependency graph for nat.c:

Go to the source code of this file.

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "util-nat", __VA_ARGS__)
#define	SEND_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 10)
#define	TIMEOUT_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100)
#define	RTT_DIFF    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 150)
	Difference of the average RTT for the DistanceVector calculate by us and the target we are willing to accept for starting the burst. More...

Functions
struct GNUNET_BurstSync *	GNUNET_get_burst_sync_msg (struct GNUNET_TIME_Relative rtt_average, enum GNUNET_GenericReturnValue sync_ready)
	Create GNUNET_BurstSync message. More...
void	GNUNET_is_burst_ready (struct GNUNET_TIME_Relative rtt_average, struct GNUNET_BurstSync *burst_sync, GNUNET_SCHEDULER_TaskCallback task, struct GNUNET_StartBurstCls *task_cls)
	Checks if we are ready and starts burst when we and the other peer is ready. More...
void	GNUNET_stop_burst (struct GNUNET_NETWORK_Handle *do_not_touch)
	Method to stop all sockets we established to the other peer. More...
static void	sock_read (void *cls)
	Socket read task. More...
static struct sockaddr *	udp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
	Convert UDP bind specification to a struct sockaddr * More...
static void	timeout_task_cb (void *cls)
static void	read_send (void *cls)
struct GNUNET_SCHEDULER_Task *	GNUNET_get_udp_socket (struct GNUNET_UdpSocketInfo *sock_info, GNUNET_NotifyUdpSocket nus)
	Method to get a UDP socket for a peer that is natted. More...

Variables
static struct GNUNET_UdpSocketInfo *	sock_infos_head
static struct GNUNET_UdpSocketInfo *	sock_infos_tail
static struct GNUNET_SCHEDULER_Task *	read_send_task
unsigned int	udp_port
unsigned int	nr_open_sockets
	Maximum of open sockets. More...

Detailed Description

Library for NAT traversal related functionality.

Author

t3sserakt

Definition in file nat.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "util-nat", __VA_ARGS__)

Definition at line 31 of file nat.c.

SEND_DELAY

#define SEND_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 10)

Definition at line 33 of file nat.c.

TIMEOUT_DELAY

#define TIMEOUT_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 100)

Definition at line 36 of file nat.c.

RTT_DIFF

#define RTT_DIFF    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 150)

Difference of the average RTT for the DistanceVector calculate by us and the target we are willing to accept for starting the burst.

Definition at line 43 of file nat.c.

Function Documentation

sock_read()

static void sock_read ( void *  cls )

static

Socket read task.

Parameters

cls

NULL

Definition at line 151 of file nat.c.

{
  struct GNUNET_UdpSocketInfo *sock_info = cls;
  struct sockaddr_storage sa;
  socklen_t salen = sizeof(sa);
  char buf[UINT16_MAX];
  ssize_t rcvd;
 
  sock_info->read_task = NULL;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Reading from socket\n");
  while (1)
  {
    rcvd = GNUNET_NETWORK_socket_recvfrom (sock_info->udp_sock,
                                           buf,
                                           sizeof(buf),
                                           (struct sockaddr *) &sa,
                                           &salen);
    if (-1 == rcvd)
    {
      struct sockaddr *addr = (struct sockaddr*) &sa;
 
      if (EAGAIN == errno)
        break; // We are done reading data
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to recv from %s family %d failed sock %p\n",
                  GNUNET_a2s ((struct sockaddr*) &sa,
                              sizeof (*addr)),
                  addr->sa_family,
                  sock_info->udp_sock);
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "recv");
      return;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Read %llu bytes\n",
                (unsigned long long) rcvd);
    if (0 == rcvd)
    {
      GNUNET_break_op (0);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Read 0 bytes from UDP socket\n");
      return;
    }
    /* first, see if it is a GNUNET_BurstMessage */
    if (rcvd == sizeof (struct GNUNET_BurstMessage))
    {
      struct GNUNET_BurstMessage *bm = (struct GNUNET_BurstMessage *) buf;
 
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Received a burst message from remote port %u to local port %u!\n",
                  bm->local_port,
                  sock_info->port);
      sock_info->actual_address = (struct sockaddr *) &sa;
      sock_info->nus (sock_info);
      GNUNET_stop_burst (sock_info->udp_sock);
      return;
    }
    else
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "Received a non burst message on local port %u %lu!\n",
                  sock_info->port,
                  sizeof (struct GNUNET_BurstMessage));
  }
}

References GNUNET_UdpSocketInfo::actual_address, GNUNET_a2s(), GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_socket_recvfrom(), GNUNET_stop_burst(), GNUNET_BurstMessage::local_port, GNUNET_UdpSocketInfo::nus, GNUNET_UdpSocketInfo::port, GNUNET_UdpSocketInfo::read_task, and GNUNET_UdpSocketInfo::udp_sock.

Referenced by read_send().

Here is the call graph for this function:

Here is the caller graph for this function:

udp_address_to_sockaddr()

static struct sockaddr * udp_address_to_sockaddr ( const char *  bindto, socklen_t *  sock_len  )

static

Convert UDP bind specification to a struct sockaddr *

Parameters

	bindto	bind specification to convert
[out]	sock_len	set to the length of the address

Returns

converted bindto specification

Definition at line 226 of file nat.c.

{
  struct sockaddr *in;
  unsigned int port;
  char dummy[2];
  char *colon;
  char *cp;
 
  cp = GNUNET_strdup (bindto);
  colon = strrchr (cp, ':');
  if (NULL != colon)
  {
    /* interpret value after colon as port */
    *colon = '\0';
    colon++;
    if (1 == sscanf (colon, "%u%1s", &port, dummy))
    {
      /* interpreting value as just a PORT number */
      if (port > UINT16_MAX)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "BINDTO specification `%s' invalid: value too large for port\n",
                    bindto);
        GNUNET_free (cp);
        return NULL;
      }
    }
    else
    {
      GNUNET_log (
        GNUNET_ERROR_TYPE_ERROR,
        "BINDTO specification `%s' invalid: last ':' not followed by number\n",
        bindto);
      GNUNET_free (cp);
      return NULL;
    }
  }
  else
  {
    /* interpret missing port as 0, aka pick any free one */
    port = 0;
  }
  {
    /* try IPv4 */
    struct sockaddr_in v4;
 
    memset (&v4, 0, sizeof(v4));
    if (1 == inet_pton (AF_INET, cp, &v4.sin_addr))
    {
      v4.sin_family = AF_INET;
      v4.sin_port = htons ((uint16_t) port);
#if HAVE_SOCKADDR_IN_SIN_LEN
      v4.sin_len = sizeof(struct sockaddr_in);
#endif
      in = GNUNET_memdup (&v4, sizeof(struct sockaddr_in));
      *sock_len = sizeof(struct sockaddr_in);
      GNUNET_free (cp);
      return in;
    }
  }
  {
    /* try IPv6 */
    struct sockaddr_in6 v6;
    const char *start;
 
    memset (&v6, 0, sizeof(v6));
    start = cp;
    if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
    {
      start++;   /* skip over '[' */
      cp[strlen (cp) - 1] = '\0';  /* eat ']' */
    }
    if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
    {
      v6.sin6_family = AF_INET6;
      v6.sin6_port = htons ((uint16_t) port);
#if HAVE_SOCKADDR_IN_SIN_LEN
      v6.sin6_len = sizeof(struct sockaddr_in6);
#endif
      in = GNUNET_memdup (&v6, sizeof(v6));
      *sock_len = sizeof(v6);
      GNUNET_free (cp);
      return in;
    }
  }
  /* #5528 FIXME (feature!): maybe also try getnameinfo()? */
  GNUNET_free (cp);
  return NULL;
}

References dummy, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_memdup, GNUNET_strdup, port, and start.

Referenced by GNUNET_get_udp_socket(), and read_send().

Here is the caller graph for this function:

timeout_task_cb()

static void timeout_task_cb ( void *  cls )

static

Definition at line 318 of file nat.c.

{
  struct GNUNET_UdpSocketInfo *sock_info = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "timeout task\n");
  if (NULL != sock_info->read_task)
    GNUNET_SCHEDULER_cancel (sock_info->read_task);
  GNUNET_NETWORK_socket_close (sock_info->udp_sock);
  nr_open_sockets--;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "timeout nr_open_sockets %u\n",
              nr_open_sockets);
  if (NULL != sock_infos_head)
    GNUNET_CONTAINER_DLL_remove (sock_infos_head,
                                 sock_infos_tail,
                                 sock_info);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "freeing sock_info %p\n",
              sock_info);
  GNUNET_free (sock_info);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NETWORK_socket_close(), GNUNET_SCHEDULER_cancel(), nr_open_sockets, GNUNET_UdpSocketInfo::read_task, sock_infos_head, sock_infos_tail, and GNUNET_UdpSocketInfo::udp_sock.

Referenced by read_send().

Here is the call graph for this function:

Here is the caller graph for this function:

read_send()

static void read_send ( void *  cls )

static

Definition at line 343 of file nat.c.

{
  struct GNUNET_UdpSocketInfo *sock_info = cls;
  struct GNUNET_UdpSocketInfo *si = GNUNET_new (struct GNUNET_UdpSocketInfo);
  struct GNUNET_NETWORK_Handle *udp_sock;
  struct GNUNET_BurstMessage bm;
  struct sockaddr *in;
  socklen_t in_len;
  char dgram[sizeof (struct GNUNET_BurstMessage)];
  char *address;
  struct sockaddr *bind_in;
  socklen_t bind_in_len;
  char *bind_address;
  struct GNUNET_TIME_Relative again = GNUNET_TIME_relative_multiply (sock_info->
                                                                     rtt,
                                                                     4);
 
  read_send_task = NULL;
  GNUNET_memcpy (si, sock_info, sizeof (struct GNUNET_UdpSocketInfo));
  if (sock_info->std_port == udp_port)
    udp_port++;
  if (512 < nr_open_sockets)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Trying again in %s",
                GNUNET_STRINGS_relative_time_to_string (again, GNUNET_NO));
    read_send_task = GNUNET_SCHEDULER_add_delayed (again,
                                                   &read_send,
                                                   sock_info);
  }
 
  GNUNET_asprintf (&address,
                   "%s:%u",
                   sock_info->address,
                   udp_port);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "3 sock %p addr %s addr %s %u\n",
              sock_info,
              sock_info->address,
              address,
              nr_open_sockets);
  in = udp_address_to_sockaddr (address, &in_len);
  if (NULL == in)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to setup UDP socket address with path `%s'\n",
                address);
    GNUNET_assert (0);
  }
  GNUNET_free (address);
  address = NULL;
  GNUNET_asprintf (&bind_address,
                   "%s:%u",
                   sock_info->bind_address,
                   udp_port);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "4 sock addr %s addr %s\n",
              sock_info->bind_address,
              bind_address);
  bind_in = udp_address_to_sockaddr (bind_address, &bind_in_len);
  if (NULL == bind_in)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to setup UDP socket bind address with path `%s'\n",
                bind_address);
    GNUNET_assert (0);
  }
  GNUNET_free (bind_address);
  bind_address = NULL;
  udp_sock =
    GNUNET_NETWORK_socket_create (bind_in->sa_family,
                                  SOCK_DGRAM,
                                  IPPROTO_UDP);
  if (NULL == udp_sock)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "socket");
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Failed to create socket for %s family %d\n",
                GNUNET_a2s (bind_in,
                            bind_in_len),
                in->sa_family);
    GNUNET_free (bind_in);
    if (EMFILE == errno)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Trying again in %s, because of EMFILE\n",
                  GNUNET_STRINGS_relative_time_to_string (again, GNUNET_NO));
      read_send_task = GNUNET_SCHEDULER_add_delayed (again,
                                                     &read_send,
                                                     sock_info);
      GNUNET_free (si);
      GNUNET_free (in);
      GNUNET_free (bind_in);
      return;
    }
    GNUNET_free (sock_info);
    goto next_port;
  }
  if (GNUNET_OK !=
      GNUNET_NETWORK_socket_bind (udp_sock,
                                  bind_in,
                                  bind_in_len))
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Failed to bind socket for %s family %d sock %p\n",
                GNUNET_a2s (bind_in,
                            bind_in_len),
                bind_in->sa_family,
                udp_sock);
    GNUNET_NETWORK_socket_close (udp_sock);
    udp_sock = NULL;
    GNUNET_free (sock_info);
    goto next_port;
  }
  nr_open_sockets++;
  bm.local_port = udp_port;
  sock_info->udp_sock = udp_sock;
  sock_info->port = udp_port;
  sock_info->read_task = GNUNET_SCHEDULER_add_read_net (
    GNUNET_TIME_UNIT_FOREVER_REL,
    udp_sock,
    &sock_read,
    sock_info);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Timeout in %s\n",
              GNUNET_STRINGS_relative_time_to_string (TIMEOUT_DELAY, GNUNET_NO))
  ;
  sock_info->timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT_DELAY,
                                                          &timeout_task_cb,
                                                          sock_info);
 
  GNUNET_CONTAINER_DLL_insert (sock_infos_head, sock_infos_tail, sock_info);
 
  memcpy (dgram, &bm, sizeof(bm));
  if (-1 == GNUNET_NETWORK_socket_sendto (udp_sock,
                                          dgram,
                                          sizeof(dgram),
                                          in,
                                          in_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Sending burst to %s family %d failed sock %p\n",
                GNUNET_a2s (in,
                            in_len),
                in->sa_family,
                udp_sock);
    timeout_task_cb (sock_info);
  }
 
next_port:
  GNUNET_free (si);
  GNUNET_free (in);
  GNUNET_free (bind_in);
 
  if (65535 == udp_port)
    return;
  udp_port++;
 
  read_send_task = GNUNET_SCHEDULER_add_delayed (SEND_DELAY,
                                                 &read_send,
                                                 si);
}

References address, GNUNET_UdpSocketInfo::address, GNUNET_UdpSocketInfo::bind_address, GNUNET_a2s(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_strerror, GNUNET_memcpy, GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NETWORK_socket_sendto(), GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_read_net(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_BurstMessage::local_port, nr_open_sockets, GNUNET_UdpSocketInfo::port, read_send(), read_send_task, GNUNET_UdpSocketInfo::read_task, SEND_DELAY, sock_infos_head, sock_infos_tail, sock_read(), GNUNET_UdpSocketInfo::std_port, TIMEOUT_DELAY, GNUNET_UdpSocketInfo::timeout_task, timeout_task_cb(), udp_address_to_sockaddr(), udp_port, GNUNET_UdpSocketInfo::udp_sock, and udp_sock.

Referenced by GNUNET_get_udp_socket(), and read_send().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

sock_infos_head

struct GNUNET_UdpSocketInfo* sock_infos_head

static

Definition at line 46 of file nat.c.

Referenced by GNUNET_stop_burst(), read_send(), and timeout_task_cb().

sock_infos_tail

struct GNUNET_UdpSocketInfo* sock_infos_tail

static

Definition at line 48 of file nat.c.

Referenced by GNUNET_stop_burst(), read_send(), and timeout_task_cb().

read_send_task

struct GNUNET_SCHEDULER_Task* read_send_task

static

Definition at line 50 of file nat.c.

Referenced by GNUNET_get_udp_socket(), GNUNET_stop_burst(), and read_send().

udp_port

unsigned int udp_port

Definition at line 52 of file nat.c.

Referenced by GNUNET_get_udp_socket(), and read_send().

nr_open_sockets

unsigned int nr_open_sockets

Maximum of open sockets.

Definition at line 57 of file nat.c.

Referenced by GNUNET_get_udp_socket(), read_send(), and timeout_task_cb().