gnunet-nat-auto_legacy.c File Reference

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_nat_lib.h"
#include "nat.h"

Include dependency graph for gnunet-nat-auto_legacy.c:

Go to the source code of this file.

Data Structures
struct	NatActivity
	Entry we keep for each incoming connection. More...
struct	ClientActivity
	Entry we keep for each connection to the gnunet-nat-service. More...
struct	GNUNET_NAT_Test
	Handle to a NAT test. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "nat", __VA_ARGS__)
#define	NAT_SERVER_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)

Functions
static void	reversal_cb (void *cls, const struct sockaddr *addr, socklen_t addrlen)
	Function called from GNUNET_NAT_register whenever someone asks us to do connection reversal. More...
static void	do_udp_read (void *cls)
	Activity on our incoming socket. More...
static void	do_read (void *cls)
	Activity on our incoming socket. More...
static void	do_accept (void *cls)
	Activity on our listen socket. More...
static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	We got disconnected from the NAT server. More...
static void	addr_cb (void *cls, int add_remove, const struct sockaddr *addr, socklen_t addrlen)
	Address-callback, used to send message to gnunet-nat-server. More...
static void	do_timeout (void *cls)
	Timeout task for a nat test. More...
struct GNUNET_NAT_Test *	GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, int is_tcp, uint16_t bnd_port, uint16_t adv_port, struct GNUNET_TIME_Relative timeout, GNUNET_NAT_TestCallback report, void *report_cls)
	Start testing if NAT traversal works using the given configuration (IPv4-only). More...
void	GNUNET_NAT_test_stop (struct GNUNET_NAT_Test *tst)
	Stop an active NAT test. More...

Macro Definition Documentation

LOG

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

Definition at line 31 of file gnunet-nat-auto_legacy.c.

NAT_SERVER_TIMEOUT

#define NAT_SERVER_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)

Definition at line 33 of file gnunet-nat-auto_legacy.c.

Function Documentation

reversal_cb()

static void reversal_cb ( void *  cls, const struct sockaddr *  addr, socklen_t  addrlen  )

static

Function called from GNUNET_NAT_register whenever someone asks us to do connection reversal.

Parameters

cls	closure, our struct GNUNET_NAT_Handle
addr	public IP address of the other peer
addrlen	actual length of the addr

Definition at line 186 of file gnunet-nat-auto_legacy.c.

{
  struct GNUNET_NAT_Test *h = cls;
  const struct sockaddr_in *sa;
 
  if (sizeof(struct sockaddr_in) != addrlen)
    return;
  sa = (const struct sockaddr_in *) addr;
  if (h->data != sa->sin_port)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received connection reversal request for wrong port\n");
    return;   /* wrong port */
  }
  /* report success */
  h->report (h->report_cls, GNUNET_NAT_ERROR_SUCCESS);
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_NAT_ERROR_SUCCESS, h, and LOG.

Referenced by GNUNET_NAT_test_start().

Here is the caller graph for this function:

do_udp_read()

static void do_udp_read ( void *  cls )

static

Activity on our incoming socket.

Read data from the incoming connection.

Parameters

cls	the struct GNUNET_NAT_Test

Definition at line 212 of file gnunet-nat-auto_legacy.c.

{
  struct GNUNET_NAT_Test *tst = cls;
  uint16_t data;
  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
  tc = GNUNET_SCHEDULER_get_task_context ();
  tst->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                              tst->lsock,
                                              &do_udp_read,
                                              tst);
  if ((NULL != tc->write_ready) &&
      (GNUNET_NETWORK_fdset_isset (tc->read_ready, tst->lsock)) &&
      (sizeof(data) ==
       GNUNET_NETWORK_socket_recv (tst->lsock, &data, sizeof(data))))
  {
    if (data == tst->data)
      tst->report (tst->report_cls, GNUNET_NAT_ERROR_SUCCESS);
    else
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Received data mismatches expected value\n");
  }
  else
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Failed to receive data from inbound connection\n");
}

References GNUNET_NAT_Test::data, data, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NAT_ERROR_SUCCESS, GNUNET_NETWORK_fdset_isset(), GNUNET_NETWORK_socket_recv(), GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_get_task_context(), GNUNET_TIME_UNIT_FOREVER_REL, LOG, GNUNET_NAT_Test::lsock, GNUNET_NAT_Test::ltask, GNUNET_SCHEDULER_TaskContext::read_ready, GNUNET_NAT_Test::report, GNUNET_NAT_Test::report_cls, tc, and GNUNET_SCHEDULER_TaskContext::write_ready.

Referenced by GNUNET_NAT_test_start().

Here is the call graph for this function:

Here is the caller graph for this function:

do_read()

static void do_read ( void *  cls )

static

Activity on our incoming socket.

Read data from the incoming connection.

Parameters

cls	the struct NatActivity

Definition at line 247 of file gnunet-nat-auto_legacy.c.

{
  struct NatActivity *na = cls;
  struct GNUNET_NAT_Test *tst;
  uint16_t data;
  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
  tc = GNUNET_SCHEDULER_get_task_context ();
  na->rtask = NULL;
  tst = na->h;
  GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, na);
  if ((NULL != tc->write_ready) &&
      (GNUNET_NETWORK_fdset_isset (tc->read_ready, na->sock)) &&
      (sizeof(data) ==
       GNUNET_NETWORK_socket_recv (na->sock, &data, sizeof(data))))
  {
    if (data == tst->data)
      tst->report (tst->report_cls, GNUNET_NAT_ERROR_SUCCESS);
    else
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Received data does not match expected value\n");
  }
  else
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Failed to receive data from inbound connection\n");
  GNUNET_NETWORK_socket_close (na->sock);
  GNUNET_free (na);
}

References GNUNET_NAT_Test::data, data, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NAT_ERROR_SUCCESS, GNUNET_NETWORK_fdset_isset(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_recv(), GNUNET_SCHEDULER_get_task_context(), NatActivity::h, LOG, GNUNET_NAT_Test::na_head, GNUNET_NAT_Test::na_tail, GNUNET_SCHEDULER_TaskContext::read_ready, GNUNET_NAT_Test::report, GNUNET_NAT_Test::report_cls, NatActivity::rtask, NatActivity::sock, tc, and GNUNET_SCHEDULER_TaskContext::write_ready.

Referenced by do_accept().

Here is the call graph for this function:

Here is the caller graph for this function:

do_accept()

static void do_accept ( void *  cls )

static

Activity on our listen socket.

Accept the incoming connection.

Parameters

cls	the struct GNUNET_NAT_Test

Definition at line 284 of file gnunet-nat-auto_legacy.c.

{
  struct GNUNET_NAT_Test *tst = cls;
  struct GNUNET_NETWORK_Handle *s;
  struct NatActivity *wl;
 
  tst->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                              tst->lsock,
                                              &do_accept,
                                              tst);
  s = GNUNET_NETWORK_socket_accept (tst->lsock, NULL, NULL);
  if (NULL == s)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "accept");
    return;   /* odd error */
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got an inbound connection, waiting for data\n");
  wl = GNUNET_new (struct NatActivity);
  wl->sock = s;
  wl->h = tst;
  wl->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                             wl->sock,
                                             &do_read,
                                             wl);
  GNUNET_CONTAINER_DLL_insert (tst->na_head, tst->na_tail, wl);
}

References do_read(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log_strerror, GNUNET_NETWORK_socket_accept(), GNUNET_new, GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_UNIT_FOREVER_REL, NatActivity::h, LOG, GNUNET_NAT_Test::lsock, GNUNET_NAT_Test::ltask, GNUNET_NAT_Test::na_head, GNUNET_NAT_Test::na_tail, NatActivity::rtask, and NatActivity::sock.

Referenced by GNUNET_NAT_test_start().

Here is the call graph for this function:

Here is the caller graph for this function:

mq_error_handler()

static void mq_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

We got disconnected from the NAT server.

Stop waiting for a reply.

Parameters

cls	the struct ClientActivity
error	error code

Definition at line 321 of file gnunet-nat-auto_legacy.c.

{
  struct ClientActivity *ca = cls;
  struct GNUNET_NAT_Test *tst = ca->h;
 
  GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, ca);
  GNUNET_MQ_destroy (ca->mq);
  GNUNET_free (ca);
}

References GNUNET_NAT_Test::ca_head, GNUNET_NAT_Test::ca_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_destroy(), ClientActivity::h, and ClientActivity::mq.

Referenced by addr_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

addr_cb()

static void addr_cb ( void *  cls, int  add_remove, const struct sockaddr *  addr, socklen_t  addrlen  )

static

Address-callback, used to send message to gnunet-nat-server.

Parameters

cls	closure
add_remove	GNUNET_YES to mean the new public IP address, GNUNET_NO to mean the previous (now invalid) one
addr	either the previous or the new public IP address
addrlen	actual length of the addr

Definition at line 342 of file gnunet-nat-auto_legacy.c.

{
  struct GNUNET_NAT_Test *h = cls;
  struct ClientActivity *ca;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_NAT_TestMessage *msg;
  const struct sockaddr_in *sa;
 
  if (GNUNET_YES != add_remove)
    return;
  if (addrlen != sizeof(struct sockaddr_in))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "NAT test ignores IPv6 address `%s' returned from NAT library\n",
         GNUNET_a2s (addr, addrlen));
    return;   /* ignore IPv6 here */
  }
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Asking gnunet-nat-server to connect to `%s'\n",
       GNUNET_a2s (addr, addrlen));
 
  ca = GNUNET_new (struct ClientActivity);
  ca->h = h;
  ca->mq = GNUNET_CLIENT_connect (h->cfg,
                                  "gnunet-nat-server",
                                  NULL,
                                  &mq_error_handler,
                                  ca);
  if (NULL == ca->mq)
  {
    GNUNET_free (ca);
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `gnunet-nat-server'\n"));
    return;
  }
  GNUNET_CONTAINER_DLL_insert (h->ca_head, h->ca_tail, ca);
  sa = (const struct sockaddr_in *) addr;
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAT_TEST);
  msg->dst_ipv4 = sa->sin_addr.s_addr;
  msg->dport = sa->sin_port;
  msg->data = h->data;
  msg->is_tcp = htonl ((uint32_t) h->is_tcp);
  GNUNET_MQ_send (ca->mq, env);
}

References _, GNUNET_ARM_Handle::cfg, env, GNUNET_a2s(), GNUNET_CLIENT_connect(), GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_NAT_TEST, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_YES, h, ClientActivity::h, LOG, ClientActivity::mq, mq_error_handler(), and msg.

Referenced by GNUNET_NAT_test_start().

Here is the call graph for this function:

Here is the caller graph for this function:

do_timeout()

static void do_timeout ( void *  cls )

static

Timeout task for a nat test.

Calls the report-callback with a timeout return value

Destroys the nat handle after the callback has been processed.

Parameters

cls	handle to the timed out NAT test

Definition at line 400 of file gnunet-nat-auto_legacy.c.

{
  struct GNUNET_NAT_Test *nh = cls;
 
  nh->ttask = NULL;
  nh->report (nh->report_cls,
              (GNUNET_NAT_ERROR_SUCCESS == nh->status)
              ? GNUNET_NAT_ERROR_TIMEOUT
              : nh->status);
}

References GNUNET_NAT_ERROR_SUCCESS, GNUNET_NAT_ERROR_TIMEOUT, and nh.

Referenced by GNUNET_NAT_test_start().

Here is the caller graph for this function:

GNUNET_NAT_test_start()

struct GNUNET_NAT_Test* GNUNET_NAT_test_start	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		int	is_tcp,
		uint16_t	bnd_port,
		uint16_t	adv_port,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_NAT_TestCallback	report,
		void *	report_cls
	)

Start testing if NAT traversal works using the given configuration (IPv4-only).

ALL failures are reported directly to the report callback

Parameters

cfg	configuration for the NAT traversal
is_tcp	GNUNET_YES to test TCP, GNUNET_NO to test UDP
bnd_port	port to bind to, 0 for connection reversal
adv_port	externally advertised port to use
timeout	delay after which the test should be aborted
report	function to call with the result of the test
report_cls	closure for report

Returns

handle to cancel NAT test or NULL. The error is always indicated via the report callback

Definition at line 428 of file gnunet-nat-auto_legacy.c.

{
  struct GNUNET_NAT_Test *nh;
  struct sockaddr_in sa;
  const struct sockaddr *addrs[] = { (const struct sockaddr *) &sa };
  const socklen_t addrlens[] = { sizeof(sa) };
 
  memset (&sa, 0, sizeof(sa));
  sa.sin_family = AF_INET;
  sa.sin_port = htons (bnd_port);
#if HAVE_SOCKADDR_IN_SIN_LEN
  sa.sin_len = sizeof(sa);
#endif
 
  nh = GNUNET_new (struct GNUNET_NAT_Test);
  nh->cfg = cfg;
  nh->is_tcp = is_tcp;
  nh->data = bnd_port;
  nh->adv_port = adv_port;
  nh->report = report;
  nh->report_cls = report_cls;
  nh->status = GNUNET_NAT_ERROR_SUCCESS;
  if (0 == bnd_port)
  {
    nh->nat = GNUNET_NAT_register (cfg,
                                   is_tcp,
                                   0,
                                   0,
                                   NULL,
                                   NULL,
                                   &addr_cb,
                                   &reversal_cb,
                                   nh,
                                   NULL);
  }
  else
  {
    nh->lsock =
      GNUNET_NETWORK_socket_create (AF_INET,
                                    (is_tcp == GNUNET_YES) ? SOCK_STREAM
                                    : SOCK_DGRAM,
                                    0);
    if ((nh->lsock == NULL) ||
        (GNUNET_OK != GNUNET_NETWORK_socket_bind (nh->lsock,
                                                  (const struct sockaddr *) &sa,
                                                  sizeof(sa))))
    {
      GNUNET_log (
        GNUNET_ERROR_TYPE_ERROR,
        _ ("Failed to create listen socket bound to `%s' for NAT test: %s\n"),
        GNUNET_a2s ((const struct sockaddr *) &sa, sizeof(sa)),
        strerror (errno));
      if (NULL != nh->lsock)
      {
        GNUNET_NETWORK_socket_close (nh->lsock);
        nh->lsock = NULL;
      }
      nh->status = GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR;
      nh->ttask = GNUNET_SCHEDULER_add_now (&do_timeout, nh);
      return nh;
    }
    if (GNUNET_YES == is_tcp)
    {
      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_listen (nh->lsock, 5));
      nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                                 nh->lsock,
                                                 &do_accept,
                                                 nh);
    }
    else
    {
      nh->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                                 nh->lsock,
                                                 &do_udp_read,
                                                 nh);
    }
    LOG (GNUNET_ERROR_TYPE_INFO,
         "NAT test listens on port %u (%s)\n",
         bnd_port,
         (GNUNET_YES == is_tcp) ? "tcp" : "udp");
    nh->nat = GNUNET_NAT_register (cfg,
                                   is_tcp,
                                   adv_port,
                                   1,
                                   addrs,
                                   addrlens,
                                   &addr_cb,
                                   NULL,
                                   nh,
                                   NULL);
    if (NULL == nh->nat)
    {
      LOG (GNUNET_ERROR_TYPE_INFO,
           _ ("NAT test failed to start NAT library\n"));
      if (NULL != nh->ltask)
      {
        GNUNET_SCHEDULER_cancel (nh->ltask);
        nh->ltask = NULL;
      }
      if (NULL != nh->lsock)
      {
        GNUNET_NETWORK_socket_close (nh->lsock);
        nh->lsock = NULL;
      }
      nh->status = GNUNET_NAT_ERROR_NAT_REGISTER_FAILED;
      nh->ttask = GNUNET_SCHEDULER_add_now (&do_timeout, nh);
      return nh;
    }
  }
  nh->ttask = GNUNET_SCHEDULER_add_delayed (timeout, &do_timeout, nh);
  return nh;
}

References _, addr_cb(), cfg, GNUNET_NAT_Handle::cfg, do_accept(), do_timeout(), do_udp_read(), GNUNET_a2s(), GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAT_ERROR_INTERNAL_NETWORK_ERROR, GNUNET_NAT_ERROR_NAT_REGISTER_FAILED, GNUNET_NAT_ERROR_SUCCESS, GNUNET_NAT_register(), GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NETWORK_socket_listen(), GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, LOG, nh, reversal_cb(), and timeout.

Referenced by reversal_test().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAT_test_stop()

void GNUNET_NAT_test_stop

(

struct GNUNET_NAT_Test *

tst

)

Stop an active NAT test.

Parameters

tst	test to stop.

Definition at line 554 of file gnunet-nat-auto_legacy.c.

{
  struct NatActivity *pos;
  struct ClientActivity *cpos;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Stopping NAT test\n");
  while (NULL != (cpos = tst->ca_head))
  {
    GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, cpos);
    GNUNET_MQ_destroy (cpos->mq);
    GNUNET_free (cpos);
  }
  while (NULL != (pos = tst->na_head))
  {
    GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, pos);
    GNUNET_SCHEDULER_cancel (pos->rtask);
    GNUNET_NETWORK_socket_close (pos->sock);
    GNUNET_free (pos);
  }
  if (NULL != tst->ttask)
  {
    GNUNET_SCHEDULER_cancel (tst->ttask);
    tst->ttask = NULL;
  }
  if (NULL != tst->ltask)
  {
    GNUNET_SCHEDULER_cancel (tst->ltask);
    tst->ltask = NULL;
  }
  if (NULL != tst->lsock)
  {
    GNUNET_NETWORK_socket_close (tst->lsock);
    tst->lsock = NULL;
  }
  if (NULL != tst->nat)
  {
    GNUNET_NAT_unregister (tst->nat);
    tst->nat = NULL;
  }
  GNUNET_free (tst);
}

References GNUNET_NAT_Test::ca_head, GNUNET_NAT_Test::ca_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_NAT_unregister(), GNUNET_NETWORK_socket_close(), GNUNET_SCHEDULER_cancel(), LOG, GNUNET_NAT_Test::lsock, GNUNET_NAT_Test::ltask, ClientActivity::mq, GNUNET_NAT_Test::na_head, GNUNET_NAT_Test::na_tail, GNUNET_NAT_Test::nat, NatActivity::rtask, NatActivity::sock, and GNUNET_NAT_Test::ttask.

Referenced by GNUNET_NAT_autoconfig_cancel(), and result_callback().

Here is the call graph for this function:

Here is the caller graph for this function: