nat_auto_api_test.c File Reference

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_nat_service.h"
#include "gnunet_nat_auto_service.h"
#include "nat-auto.h"

Include dependency graph for nat_auto_api_test.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_AUTO_Test
	Handle to a NAT test. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "nat-auto", __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.
static void	do_udp_read (void *cls)
	Activity on our incoming socket.
static void	do_read (void *cls)
	Activity on our incoming socket.
static void	do_accept (void *cls)
	Activity on our listen socket.
static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	We got disconnected from the NAT server.
static void	addr_cb (void *cls, void **app_ctx, int add_remove, enum GNUNET_NAT_AddressClass ac, const struct sockaddr *addr, socklen_t addrlen)
	Address-callback, used to send message to gnunet-nat-server.
static void	do_fail (void *cls)
	Calls the report-callback reporting failure.
struct GNUNET_NAT_AUTO_Test *	GNUNET_NAT_AUTO_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg, uint8_t proto, const char *section_name, GNUNET_NAT_TestCallback report, void *report_cls)
	Start testing if NAT traversal works using the given configuration.
void	GNUNET_NAT_AUTO_test_stop (struct GNUNET_NAT_AUTO_Test *tst)
	Stop an active NAT test.

Macro Definition Documentation

LOG

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

Definition at line 31 of file nat_auto_api_test.c.

NAT_SERVER_TIMEOUT

#define NAT_SERVER_TIMEOUT    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)

Definition at line 33 of file nat_auto_api_test.c.

{
  struct NatActivity *next;
 
  struct NatActivity *prev;
 
  struct GNUNET_NETWORK_Handle *sock;
 
  struct GNUNET_NAT_AUTO_Test *h;
 
  struct GNUNET_SCHEDULER_Task *rtask;
};
 
 
struct ClientActivity
{
  struct ClientActivity *next;
 
  struct ClientActivity *prev;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct GNUNET_NAT_AUTO_Test *h;
};
 
 
struct GNUNET_NAT_AUTO_Test
{
  const struct GNUNET_CONFIGURATION_Handle *cfg;
 
  GNUNET_NAT_TestCallback report;
 
  void *report_cls;
 
  struct GNUNET_NAT_Handle *nat;
 
  struct GNUNET_NETWORK_Handle *lsock;
 
  struct NatActivity *na_head;
 
  struct NatActivity *na_tail;
 
  struct ClientActivity *ca_head;
 
  struct ClientActivity *ca_tail;
 
  struct GNUNET_SCHEDULER_Task *ltask;
 
  struct GNUNET_SCHEDULER_Task *ttask;
 
  char *section_name;
 
  int proto;
 
  uint16_t data;
 
  enum GNUNET_NAT_StatusCode status;
};
 
 
static void
reversal_cb (void *cls, const struct sockaddr *addr, socklen_t addrlen)
{
  struct GNUNET_NAT_AUTO_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);
}
 
 
static void
do_udp_read (void *cls)
{
  struct GNUNET_NAT_AUTO_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");
}
 
 
static void
do_read (void *cls)
{
  struct NatActivity *na = cls;
  struct GNUNET_NAT_AUTO_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);
}
 
 
static void
do_accept (void *cls)
{
  struct GNUNET_NAT_AUTO_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);
}
 
 
static void
mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
{
  struct ClientActivity *ca = cls;
  struct GNUNET_NAT_AUTO_Test *tst = ca->h;
 
  GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, ca);
  GNUNET_MQ_destroy (ca->mq);
  GNUNET_free (ca);
}
 
 
static void
addr_cb (void *cls,
         void **app_ctx,
         int add_remove,
         enum GNUNET_NAT_AddressClass ac,
         const struct sockaddr *addr,
         socklen_t addrlen)
{
  struct GNUNET_NAT_AUTO_Test *h = cls;
  struct ClientActivity *ca;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_NAT_AUTO_TestMessage *msg;
  const struct sockaddr_in *sa;
 
  (void) app_ctx;
  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->proto == IPPROTO_TCP));
  GNUNET_MQ_send (ca->mq, env);
}
 
 
static void
do_fail (void *cls)
{
  struct GNUNET_NAT_AUTO_Test *nh = cls;
 
  nh->ttask = NULL;
  nh->report (nh->report_cls, nh->status);
}
 
 
struct GNUNET_NAT_AUTO_Test *
GNUNET_NAT_AUTO_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
                            uint8_t proto,
                            const char *section_name,
                            GNUNET_NAT_TestCallback report,
                            void *report_cls)
{
  struct GNUNET_NAT_AUTO_Test *nh;
  unsigned long long bnd_port;
  struct sockaddr_in sa;
  const struct sockaddr *addrs[] = { (const struct sockaddr *) &sa };
  const socklen_t addrlens[] = { sizeof(sa) };
 
  if ((GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg,
                                                           section_name,
                                                           "PORT",
                                                           &bnd_port)) ||
      (bnd_port > 65535))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to find valid PORT in section `%s'\n"),
                section_name);
    return NULL;
  }
 
  memset (&sa, 0, sizeof(sa));
  sa.sin_family = AF_INET;
  sa.sin_port = htons ((uint16_t) bnd_port);
#if HAVE_SOCKADDR_IN_SIN_LEN
  sa.sin_len = sizeof(sa);
#endif
 
  nh = GNUNET_new (struct GNUNET_NAT_AUTO_Test);
  nh->cfg = cfg;
  nh->proto = proto;
  nh->section_name = GNUNET_strdup (section_name);
  nh->report = report;
  nh->report_cls = report_cls;
  nh->status = GNUNET_NAT_ERROR_SUCCESS;
  if (0 == bnd_port)
  {
    nh->nat = GNUNET_NAT_register (cfg,
                                   section_name,
                                   proto,
                                   0,
                                   NULL,
                                   NULL,
                                   &addr_cb,
                                   &reversal_cb,
                                   nh);
  }
  else
  {
    nh->lsock =
      GNUNET_NETWORK_socket_create (AF_INET,
                                    (IPPROTO_UDP == proto) ? SOCK_DGRAM
                                    : SOCK_STREAM,
                                    proto);
    if ((NULL == nh->lsock) ||
        (GNUNET_OK != GNUNET_NETWORK_socket_bind (nh->lsock,
                                                  (const struct sockaddr *) &sa,
                                                  sizeof(sa))))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Failed to create 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_fail, nh);
      return nh;
    }
    if (IPPROTO_TCP == proto)
    {
      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 %llu (%s)\n",
         bnd_port,
         (IPPROTO_TCP == proto) ? "tcp" : "udp");
    nh->nat = GNUNET_NAT_register (cfg,
                                   section_name,
                                   proto,
                                   1,
                                   addrs,
                                   addrlens,
                                   &addr_cb,
                                   NULL,
                                   nh);
    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_fail, nh);
      return nh;
    }
  }
  return nh;
}
 
 
void
GNUNET_NAT_AUTO_test_stop (struct GNUNET_NAT_AUTO_Test *tst)
{
  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->section_name);
  GNUNET_free (tst);
}
 
 
/* end of nat_auto_api_test.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 nat_auto_api_test.c.

{
  struct GNUNET_NAT_AUTO_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_AUTO_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_AUTO_Test

Definition at line 212 of file nat_auto_api_test.c.

{
  struct GNUNET_NAT_AUTO_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 data, GNUNET_NAT_AUTO_Test::data, do_udp_read(), 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_AUTO_Test::lsock, GNUNET_NAT_AUTO_Test::ltask, GNUNET_SCHEDULER_TaskContext::read_ready, GNUNET_NAT_AUTO_Test::report, GNUNET_NAT_AUTO_Test::report_cls, tc, and GNUNET_SCHEDULER_TaskContext::write_ready.

Referenced by do_udp_read(), and GNUNET_NAT_AUTO_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 nat_auto_api_test.c.

{
  struct NatActivity *na = cls;
  struct GNUNET_NAT_AUTO_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 data, GNUNET_NAT_AUTO_Test::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_AUTO_Test::na_head, GNUNET_NAT_AUTO_Test::na_tail, GNUNET_SCHEDULER_TaskContext::read_ready, GNUNET_NAT_AUTO_Test::report, GNUNET_NAT_AUTO_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_AUTO_Test

Definition at line 284 of file nat_auto_api_test.c.

{
  struct GNUNET_NAT_AUTO_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_accept(), 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_AUTO_Test::lsock, GNUNET_NAT_AUTO_Test::ltask, GNUNET_NAT_AUTO_Test::na_head, GNUNET_NAT_AUTO_Test::na_tail, NatActivity::rtask, and NatActivity::sock.

Referenced by do_accept(), and GNUNET_NAT_AUTO_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 nat_auto_api_test.c.

{
  struct ClientActivity *ca = cls;
  struct GNUNET_NAT_AUTO_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_AUTO_Test::ca_head, GNUNET_NAT_AUTO_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, void **  app_ctx, int  add_remove, enum GNUNET_NAT_AddressClass  ac, const struct sockaddr *  addr, socklen_t  addrlen  )

static

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

Parameters

	cls	closure
[in,out]	app_ctx	location where the app can store stuff on add and retrieve it on remove
	add_remove	GNUNET_YES to mean the new public IP address, GNUNET_NO to mean the previous (now invalid) one
	ac	address class the address belongs to
	addr	either the previous or the new public IP address
	addrlen	actual length of the addr

Definition at line 345 of file nat_auto_api_test.c.

{
  struct GNUNET_NAT_AUTO_Test *h = cls;
  struct ClientActivity *ca;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_NAT_AUTO_TestMessage *msg;
  const struct sockaddr_in *sa;
 
  (void) app_ctx;
  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->proto == IPPROTO_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_AUTO_test_start().

Here is the call graph for this function:

Here is the caller graph for this function:

do_fail()

static void do_fail ( void *  cls )

static

Calls the report-callback reporting failure.

Destroys the nat handle after the callback has been processed.

Parameters

cls	handle to the timed out NAT test

Definition at line 405 of file nat_auto_api_test.c.

{
  struct GNUNET_NAT_AUTO_Test *nh = cls;
 
  nh->ttask = NULL;
  nh->report (nh->report_cls, nh->status);
}

References nh.

Referenced by GNUNET_NAT_AUTO_test_start().

Here is the caller graph for this function: