gnunet-service-nat-auto_legacy.c File Reference

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

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

Go to the source code of this file.

Data Structures
struct	GNUNET_NAT_AutoHandle
	Handle to auto-configuration in progress. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "nat", __VA_ARGS__)
#define	TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
	How long do we wait for the NAT test to report success?
#define	NAT_SERVER_TIMEOUT

Enumerations
enum	AutoPhase {   AUTO_INIT = 0 , AUTO_EXTERNAL_IP , AUTO_STUN , AUTO_LOCAL_IP ,   AUTO_NAT_PUNCHED , AUTO_UPNPC , AUTO_ICMP_SERVER , AUTO_ICMP_CLIENT ,   AUTO_DONE }
	Phases of the auto configuration. More...

Functions
static void	next_phase (struct GNUNET_NAT_AutoHandle *ah)
	Run the next phase of the auto test.
static void	process_stun_reply (struct sockaddr_in *answer, struct GNUNET_NAT_AutoHandle *ah)
static void	stop_stun ()
	Function that terminates the test.
static void	do_udp_read (void *cls)
	Activity on our incoming socket.
static struct GNUNET_NETWORK_Handle *	bind_v4 ()
	Create an IPv4 listen socket bound to our port.
static void	request_callback (void *cls, enum GNUNET_NAT_StatusCode result)
static void	result_callback (void *cls, enum GNUNET_NAT_StatusCode ret)
	Function called by NAT to report the outcome of the nat-test.
static void	reversal_test (void *cls)
	Main function for the connection reversal test.
static void	set_external_ipv4 (void *cls, const struct in_addr *addr, enum GNUNET_NAT_StatusCode ret)
	Set our external IPv4 address based on the UPnP.
static void	test_external_ip (struct GNUNET_NAT_AutoHandle *ah)
	Determine our external IPv4 address.
static void	test_stun (struct GNUNET_NAT_AutoHandle *ah)
	Determine our external IPv4 address and port using an external STUN server.
static int	process_if (void *cls, const char *name, int isDefault, const struct sockaddr *addr, const struct sockaddr *broadcast_addr, const struct sockaddr *netmask, socklen_t addrlen)
	Process list of local IP addresses.
static void	test_local_ip (struct GNUNET_NAT_AutoHandle *ah)
	Determine our local IP addresses; detect internal IP & IPv6-support.
static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	We got disconnected from the NAT server.
static void	test_nat_punched (struct GNUNET_NAT_AutoHandle *ah)
	Test if NAT has been punched.
static void	test_upnpc (struct GNUNET_NAT_AutoHandle *ah)
	Test if UPnPC works.
static void	test_icmp_server (struct GNUNET_NAT_AutoHandle *ah)
	Test if ICMP server is working.
static void	test_icmp_client (struct GNUNET_NAT_AutoHandle *ah)
	Test if ICMP client is working.
struct GNUNET_NAT_AutoHandle *	GNUNET_NAT_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_NAT_AutoResultCallback cb, void *cb_cls)
	Start auto-configuration routine.
void	GNUNET_NAT_autoconfig_cancel (struct GNUNET_NAT_AutoHandle *ah)
	Abort autoconfiguration.

Variables
static struct GNUNET_NETWORK_Handle *	lsock4
	The listen socket of the service for IPv4.
static struct GNUNET_SCHEDULER_Task *	ltask4
	The listen task ID for IPv4.
static unsigned long long	port = 7895
	The port the test service is running on (default 7895)
static char *	stun_server = "stun.ekiga.net"
static unsigned int	stun_port = 3478

Macro Definition Documentation

LOG

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

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

TIMEOUT

#define TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)

How long do we wait for the NAT test to report success?

Definition at line 39 of file gnunet-service-nat-auto_legacy.c.

NAT_SERVER_TIMEOUT

#define NAT_SERVER_TIMEOUT

Value:

    GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_SECONDS, 10)

Definition at line 41 of file gnunet-service-nat-auto_legacy.c.

{
  AUTO_INIT = 0,
 
  AUTO_EXTERNAL_IP,
 
  AUTO_STUN,
 
  AUTO_LOCAL_IP,
 
  AUTO_NAT_PUNCHED,
 
  AUTO_UPNPC,
 
  AUTO_ICMP_SERVER,
 
  AUTO_ICMP_CLIENT,
 
  AUTO_DONE
};
 
 
struct GNUNET_NAT_AutoHandle
{
  struct GNUNET_NAT_Test *tst;
 
  GNUNET_NAT_AutoResultCallback fin_cb;
 
  void *fin_cb_cls;
 
  struct GNUNET_NAT_ExternalHandle *eh;
 
  struct GNUNET_CONFIGURATION_Handle *cfg;
 
  struct GNUNET_CONFIGURATION_Handle *initial_cfg;
 
  struct GNUNET_SCHEDULER_Task *task;
 
  struct GNUNET_MQ_Handle *mq;
 
  enum AutoPhase phase;
 
  enum GNUNET_NAT_Type type;
 
  int have_v6;
 
  int upnp_set_external_address;
 
  int connected_back;
 
  char *stun_ip;
 
  unsigned int stun_port;
 
  int internal_ip_is_public;
 
  enum GNUNET_NAT_StatusCode ret;
};
 
 
static struct GNUNET_NETWORK_Handle *lsock4;
 
static struct GNUNET_SCHEDULER_Task *ltask4;
 
static unsigned long long port = 7895;
 
static char *stun_server = "stun.ekiga.net";
 
static unsigned int stun_port = 3478;
 
 
static void
next_phase (struct GNUNET_NAT_AutoHandle *ah);
 
 
static void
process_stun_reply (struct sockaddr_in *answer,
                    struct GNUNET_NAT_AutoHandle *ah)
{
  ah->stun_ip = inet_ntoa (answer->sin_addr);
  ah->stun_port = ntohs (answer->sin_port);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "External IP is: %s , with port %u\n",
              ah->stun_ip,
              ah->stun_port);
  next_phase (ah);
}
 
 
static void
stop_stun ()
{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Stopping STUN and quitting...\n");
  /* Clean task */
  if (NULL != ltask4)
  {
    GNUNET_SCHEDULER_cancel (ltask4);
    ltask4 = NULL;
  }
  /* Clean socket */
  if (NULL != lsock4)
  {
    GNUNET_NETWORK_socket_close (lsock4);
    lsock4 = NULL;
  }
}
 
 
static void
do_udp_read (void *cls)
{
  struct GNUNET_NAT_AutoHandle *ah = cls;
  unsigned char reply_buf[1024];
  ssize_t rlen;
  struct sockaddr_in answer;
  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
  tc = GNUNET_SCHEDULER_get_task_context ();
  if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
      (GNUNET_NETWORK_fdset_isset (tc->read_ready,
                                   lsock4)))
  {
    rlen = GNUNET_NETWORK_socket_recv (lsock4,
                                       reply_buf,
                                       sizeof(reply_buf));
 
    // Lets handle the packet
    memset (&answer, 0, sizeof(struct sockaddr_in));
    if (ah->phase == AUTO_NAT_PUNCHED)
    {
      // Destroy the connection
      GNUNET_NETWORK_socket_close (lsock4);
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "The external server was able to connect back");
      ah->connected_back = GNUNET_YES;
      next_phase (ah);
    }
    else
    {
      if (GNUNET_OK ==
          GNUNET_NAT_stun_handle_packet (reply_buf, rlen, &answer))
      {
        // Process the answer
        process_stun_reply (&answer, ah);
      }
      else
      {
        next_phase (ah);
      }
    }
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "TIMEOUT while waiting for an answer\n");
    if (ah->phase == AUTO_NAT_PUNCHED)
    {
      stop_stun ();
    }
 
    next_phase (ah);
  }
}
 
 
static struct GNUNET_NETWORK_Handle *
bind_v4 ()
{
  struct GNUNET_NETWORK_Handle *ls;
  struct sockaddr_in sa4;
  int eno;
 
  memset (&sa4, 0, sizeof(sa4));
  sa4.sin_family = AF_INET;
  sa4.sin_port = htons (port);
#if HAVE_SOCKADDR_IN_SIN_LEN
  sa4.sin_len = sizeof(sa4);
#endif
  ls = GNUNET_NETWORK_socket_create (AF_INET,
                                     SOCK_DGRAM,
                                     0);
  if (NULL == ls)
    return NULL;
  if (GNUNET_OK !=
      GNUNET_NETWORK_socket_bind (ls, (const struct sockaddr *) &sa4,
                                  sizeof(sa4)))
  {
    eno = errno;
    GNUNET_NETWORK_socket_close (ls);
    errno = eno;
    return NULL;
  }
  return ls;
}
 
 
static void
request_callback (void *cls,
                  enum GNUNET_NAT_StatusCode result)
{
  // struct GNUNET_NAT_AutoHandle *ah = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Request callback: stop and quit\n");
  stop_stun ();
 
  // next_phase (ah); FIXME this always will be NULL, as called in test_stun()
}
 
 
static void
result_callback (void *cls,
                 enum GNUNET_NAT_StatusCode ret)
{
  struct GNUNET_NAT_AutoHandle *ah = cls;
 
  if (GNUNET_NAT_ERROR_SUCCESS == ret)
    GNUNET_NAT_test_stop (ah->tst);
  ah->tst = NULL;
  ah->ret = ret;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              GNUNET_NAT_ERROR_SUCCESS == ret
              ? _ ("NAT traversal with ICMP Server succeeded.\n")
              : _ ("NAT traversal with ICMP Server failed.\n"));
  GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_ICMP_SERVER",
                                         GNUNET_NAT_ERROR_SUCCESS == ret ?
                                         "NO" : "YES");
  next_phase (ah);
}
 
 
static void
reversal_test (void *cls)
{
  struct GNUNET_NAT_AutoHandle *ah = cls;
 
  ah->task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Testing connection reversal with ICMP server.\n"));
  GNUNET_RESOLVER_connect (ah->cfg);
  ah->tst = GNUNET_NAT_test_start (ah->cfg, GNUNET_YES, 0, 0, TIMEOUT,
                                   &result_callback, ah);
}
 
 
static void
set_external_ipv4 (void *cls,
                   const struct in_addr *addr,
                   enum GNUNET_NAT_StatusCode ret)
{
  struct GNUNET_NAT_AutoHandle *ah = cls;
  char buf[INET_ADDRSTRLEN];
 
  ah->eh = NULL;
  ah->ret = ret;
  if (GNUNET_NAT_ERROR_SUCCESS != ret)
  {
    next_phase (ah);
    return;
  }
  /* enable 'behind nat' */
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Detected external IP `%s'\n"),
              inet_ntop (AF_INET,
                         addr,
                         buf,
                         sizeof(buf)));
  GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "BEHIND_NAT", "YES");
 
  /* set external IP address */
  if (NULL == inet_ntop (AF_INET, addr, buf, sizeof(buf)))
  {
    GNUNET_break (0);
    /* actually, this should never happen, as the caller already executed just
     * this check, but for consistency (eg: future changes in the caller)
     * we still need to report this error...
     */
    ah->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID;
    next_phase (ah);
    return;
  }
  GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS",
                                         buf);
  ah->upnp_set_external_address = GNUNET_YES;
  next_phase (ah);
}
 
 
static void
test_external_ip (struct GNUNET_NAT_AutoHandle *ah)
{
  if (GNUNET_NAT_ERROR_SUCCESS != ah->ret)
    next_phase (ah);
 
  // FIXME: CPS?
  /* try to detect external IP */
  ah->eh = GNUNET_NAT_mini_get_external_ipv4 (TIMEOUT,
                                              &set_external_ipv4, ah);
}
 
 
static void
test_stun (struct GNUNET_NAT_AutoHandle *ah)
{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running STUN test\n");
 
  /* Get port from the configuration */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (ah->cfg,
                                             "transport-udp",
                                             "PORT",
                                             &port))
  {
    port = 2086;
  }
 
  // Lets create the socket
  lsock4 = bind_v4 ();
  if (NULL == lsock4)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
    next_phase (ah);
    return;
  }
  else
  {
    // Lets call our function now when it accepts
    ltask4 = GNUNET_SCHEDULER_add_read_net (NAT_SERVER_TIMEOUT,
                                            lsock4,
                                            &do_udp_read,
                                            ah);
  }
 
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "STUN service listens on port %u\n",
              (unsigned int) port);
  if (GNUNET_NO ==
      GNUNET_NAT_stun_make_request (stun_server,
                                    stun_port,
                                    lsock4,
                                    &request_callback,
                                    NULL))
  {
    /*An error happened*/
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "STUN error, stopping\n");
    stop_stun ();
    next_phase (ah);
  }
}
 
 
static int
process_if (void *cls,
            const char *name,
            int isDefault,
            const struct sockaddr *addr,
            const struct sockaddr *broadcast_addr,
            const struct sockaddr *netmask,
            socklen_t addrlen)
{
  struct GNUNET_NAT_AutoHandle *ah = cls;
  const struct sockaddr_in *in;
  char buf[INET_ADDRSTRLEN];
 
 
  if ((sizeof(struct sockaddr_in6) == addrlen) &&
      (0 != GNUNET_memcmp (&in6addr_loopback, &((const struct
                                                 sockaddr_in6 *) addr)->
                           sin6_addr)) &&
      (! IN6_IS_ADDR_LINKLOCAL (&((const struct
                                   sockaddr_in6 *) addr)->sin6_addr)))
  {
    ah->have_v6 = GNUNET_YES;
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ (
                  "This system has a global IPv6 address, setting IPv6 to supported.\n"));
 
    return GNUNET_OK;
  }
  if (addrlen != sizeof(struct sockaddr_in))
    return GNUNET_OK;
  in = (const struct sockaddr_in *) addr;
 
 
  /* set internal IP address */
  if (NULL == inet_ntop (AF_INET, &in->sin_addr, buf, sizeof(buf)))
  {
    GNUNET_break (0);
    return GNUNET_OK;
  }
  GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "INTERNAL_ADDRESS",
                                         buf);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Detected internal network address `%s'.\n"),
              buf);
 
 
  ah->ret = GNUNET_NAT_ERROR_SUCCESS;
 
  /* Check if our internal IP is the same as the External detect by STUN*/
  if (ah->stun_ip && (strcmp (buf, ah->stun_ip) == 0))
  {
    ah->internal_ip_is_public = GNUNET_YES;
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "A internal IP is the sameas the external");
    /* No need to continue*/
    return GNUNET_SYSERR;
  }
 
  /* no need to continue iteration if we found the default */
  if (! isDefault)
    return GNUNET_OK;
  else
    return GNUNET_SYSERR;
}
 
 
static void
test_local_ip (struct GNUNET_NAT_AutoHandle *ah)
{
  ah->have_v6 = GNUNET_NO;
  ah->ret = GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO; // reset to success if any of the IFs in below iterator has a valid IP
  GNUNET_OS_network_interfaces_list (&process_if, ah);
 
  GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "DISABLEV6",
                                         (GNUNET_YES == ah->have_v6) ? "NO" :
                                         "YES");
  next_phase (ah);
}
 
 
static void
mq_error_handler (void *cls,
                  enum GNUNET_MQ_Error error)
{
  struct GNUNET_NAT_AutoHandle *ah = cls;
 
  GNUNET_MQ_destroy (ah->mq);
  ah->mq = NULL;
  /* wait a bit first? */
  next_phase (ah);
}
 
 
static void
test_nat_punched (struct GNUNET_NAT_AutoHandle *ah)
{
  struct GNUNET_NAT_TestMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  if (! ah->stun_ip)
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         "We don't have a STUN IP");
    next_phase (ah);
    return;
  }
 
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Asking gnunet-nat-server to connect to `%s'\n",
       ah->stun_ip);
  ah->mq = GNUNET_CLIENT_connect (ah->cfg,
                                  "gnunet-nat-server",
                                  NULL,
                                  &mq_error_handler,
                                  ah);
  if (NULL == ah->mq)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `gnunet-nat-server'\n"));
    next_phase (ah);
    return;
  }
  env = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_NAT_TEST);
  msg->dst_ipv4 = inet_addr (ah->stun_ip);
  msg->dport = htons (ah->stun_port);
  msg->data = port;
  msg->is_tcp = htonl ((uint32_t) GNUNET_NO);
  GNUNET_MQ_send (ah->mq,
                  env);
  if (NULL != ltask4)
  {
    GNUNET_SCHEDULER_cancel (ltask4);
    ltask4 = GNUNET_SCHEDULER_add_read_net (NAT_SERVER_TIMEOUT,
                                            lsock4,
                                            &do_udp_read,
                                            ah);
  }
}
 
 
static void
test_upnpc (struct GNUNET_NAT_AutoHandle *ah)
{
  int have_upnpc;
 
  if (GNUNET_NAT_ERROR_SUCCESS != ah->ret)
    next_phase (ah);
 
  // test if upnpc is available
  have_upnpc = (GNUNET_SYSERR !=
                GNUNET_OS_check_helper_binary ("upnpc", GNUNET_NO, NULL));
  // FIXME: test if upnpc is actually working, that is, if transports start to work once we use UPnP
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              (have_upnpc)
              ? _ ("upnpc found, enabling its use\n")
              : _ ("upnpc not found\n"));
  GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_UPNP",
                                         (GNUNET_YES == have_upnpc) ? "YES" :
                                         "NO");
  next_phase (ah);
}
 
 
static void
test_icmp_server (struct GNUNET_NAT_AutoHandle *ah)
{
  int ext_ip;
  int nated;
  int binary;
  char *tmp;
  char *helper;
 
  ext_ip = GNUNET_NO;
  nated = GNUNET_NO;
  binary = GNUNET_NO;
 
  tmp = NULL;
  helper = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-server");
  if ((GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_string (ah->cfg,
                                              "nat",
                                              "EXTERNAL_ADDRESS",
                                              &tmp)) &&
      (0 < strlen (tmp)))
  {
    ext_ip = GNUNET_OK;
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ (
                  "test_icmp_server not possible, as we have no public IPv4 address\n"));
  }
  else
    goto err;
 
  if (GNUNET_YES ==
      GNUNET_CONFIGURATION_get_value_yesno (ah->cfg,
                                            "nat",
                                            "BEHIND_NAT"))
  {
    nated = GNUNET_YES;
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ (
                  "test_icmp_server not possible, as we are not behind NAT\n"));
  }
  else
    goto err;
 
  if (GNUNET_YES ==
      GNUNET_OS_check_helper_binary (helper,
                                     GNUNET_YES,
                                     "-d 127.0.0.1"))
  {
    binary = GNUNET_OK;   // use localhost as source for that one udp-port, ok for testing
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("No working gnunet-helper-nat-server found\n"));
  }
err:
  GNUNET_free (tmp);
  GNUNET_free (helper);
 
  if ((GNUNET_OK == ext_ip) &&
      (GNUNET_YES == nated) &&
      (GNUNET_OK == binary))
    ah->task = GNUNET_SCHEDULER_add_now (&reversal_test,
                                         ah);
  else
    next_phase (ah);
}
 
 
static void
test_icmp_client (struct GNUNET_NAT_AutoHandle *ah)
{
  char *tmp;
  char *helper;
 
  tmp = NULL;
  helper = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-client");
  if ((GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_string (ah->cfg,
                                              "nat",
                                              "INTERNAL_ADDRESS",
                                              &tmp)) &&
      (0 < strlen (tmp)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ (
                  "test_icmp_client not possible, as we have no internal IPv4 address\n"));
  }
  else
    goto err;
 
  if (GNUNET_YES !=
      GNUNET_CONFIGURATION_get_value_yesno (ah->cfg,
                                            "nat",
                                            "BEHIND_NAT"))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ (
                  "test_icmp_server not possible, as we are not behind NAT\n"));
  }
  else
    goto err;
 
  if (GNUNET_YES ==
      GNUNET_OS_check_helper_binary (helper,
                                     GNUNET_YES,
                                     "-d 127.0.0.1 127.0.0.2 42"))
  {
    // none of these parameters are actually used in privilege testing mode
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("No working gnunet-helper-nat-server found\n"));
  }
err:
  GNUNET_free (tmp);
  GNUNET_free (helper);
 
  next_phase (ah);
}
 
 
static void
next_phase (struct GNUNET_NAT_AutoHandle *ah)
{
  struct GNUNET_CONFIGURATION_Handle *diff;
 
  ah->phase++;
  switch (ah->phase)
  {
  case AUTO_INIT:
    GNUNET_assert (0);
    break;
 
  case AUTO_EXTERNAL_IP:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_EXTERNAL_IP\n");
    test_external_ip (ah);
    break;
 
  case AUTO_STUN:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_STUN\n");
    test_stun (ah);
    break;
 
  case AUTO_LOCAL_IP:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_LOCAL_IP\n");
    test_local_ip (ah);
    break;
 
  case AUTO_NAT_PUNCHED:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_NAT_PUNCHED\n");
    test_nat_punched (ah);
    break;
 
  case AUTO_UPNPC:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_UPNPC\n");
    test_upnpc (ah);
    break;
 
  case AUTO_ICMP_SERVER:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_ICMP_SERVER\n");
    test_icmp_server (ah);
    break;
 
  case AUTO_ICMP_CLIENT:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_ICMP_CLIENT\n");
    test_icmp_client (ah);
    break;
 
  case AUTO_DONE:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Done with tests\n");
    if (! ah->internal_ip_is_public)
    {
      GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                             "nat",
                                             "BEHIND_NAT",
                                             "YES");
 
      if (ah->connected_back)
      {
        GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                               "nat",
                                               "PUNCHED_NAT",
                                               "YES");
      }
      else
      {
        GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                               "nat",
                                               "PUNCHED_NAT",
                                               "NO");
      }
 
      if (ah->stun_ip)
      {
        GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                               "nat",
                                               "EXTERNAL_ADDRESS",
                                               ah->stun_ip);
        if (ah->connected_back)
        {
          ah->type = GNUNET_NAT_TYPE_STUN_PUNCHED_NAT;
          GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                                 "nat",
                                                 "USE_STUN",
                                                 "YES");
        }
        else
        {
          ah->type = GNUNET_NAT_TYPE_UNREACHABLE_NAT;
          GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                                 "nat",
                                                 "USE_STUN",
                                                 "NO");
        }
      }
      if (0 != ah->stun_port)
      {
        GNUNET_CONFIGURATION_set_value_number (ah->cfg,
                                               "transport-udp",
                                               "ADVERTISED_PORT",
                                               ah->stun_port);
      }
    }
    else
    {
      // The internal IP is the same as public, but we didn't got a incoming connection
      if (ah->connected_back)
      {
        ah->type = GNUNET_NAT_TYPE_NO_NAT;
        GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                               "nat",
                                               "BEHIND_NAT",
                                               "NO");
      }
      else
      {
        GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                               "nat",
                                               "BEHIND_NAT",
                                               "YES");
        ah->type = GNUNET_NAT_TYPE_UNREACHABLE_NAT;
        if (ah->stun_ip)
        {
          GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                                 "nat",
                                                 "EXTERNAL_ADDRESS",
                                                 ah->stun_ip);
        }
        if (0 != ah->stun_port)
        {
          GNUNET_CONFIGURATION_set_value_number (ah->cfg,
                                                 "transport-udp",
                                                 "ADVERTISED_PORT",
                                                 ah->stun_port);
        }
      }
    }
 
    diff = GNUNET_CONFIGURATION_get_diff (ah->initial_cfg,
                                          ah->cfg);
 
 
    ah->fin_cb (ah->fin_cb_cls,
                diff,
                ah->ret,
                ah->type);
    GNUNET_CONFIGURATION_destroy (diff);
    GNUNET_NAT_autoconfig_cancel (ah);
  }
}
 
 
struct GNUNET_NAT_AutoHandle *
GNUNET_NAT_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
                             GNUNET_NAT_AutoResultCallback cb,
                             void *cb_cls)
{
  struct GNUNET_NAT_AutoHandle *ah;
 
  ah = GNUNET_new (struct GNUNET_NAT_AutoHandle);
  ah->fin_cb = cb;
  ah->fin_cb_cls = cb_cls;
  ah->ret = GNUNET_NAT_ERROR_SUCCESS;
  ah->cfg = GNUNET_CONFIGURATION_dup (cfg);
  ah->initial_cfg = GNUNET_CONFIGURATION_dup (cfg);
 
  /* never use loopback addresses if user wanted autoconfiguration */
  GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                         "nat",
                                         "USE_LOCALADDR",
                                         "NO");
 
  next_phase (ah);
  return ah;
}
 
 
void
GNUNET_NAT_autoconfig_cancel (struct GNUNET_NAT_AutoHandle *ah)
{
  if (NULL != ah->tst)
  {
    GNUNET_NAT_test_stop (ah->tst);
    ah->tst = NULL;
  }
  if (NULL != ah->eh)
  {
    GNUNET_NAT_mini_get_external_ipv4_cancel (ah->eh);
    ah->eh = NULL;
  }
  if (NULL != ah->mq)
  {
    GNUNET_MQ_destroy (ah->mq);
    ah->mq = NULL;
  }
  if (NULL != ah->task)
  {
    GNUNET_SCHEDULER_cancel (ah->task);
    ah->task = NULL;
  }
  GNUNET_CONFIGURATION_destroy (ah->cfg);
  GNUNET_CONFIGURATION_destroy (ah->initial_cfg);
  GNUNET_free (ah);
}
 
 
/* end of nat_auto.c */

Enumeration Type Documentation

AutoPhase

enum AutoPhase

Phases of the auto configuration.

Enumerator
AUTO_INIT	Initial start value.
AUTO_EXTERNAL_IP	Test our external IP.
AUTO_STUN	Test our external IP.
AUTO_LOCAL_IP	Test our internal IP.
AUTO_NAT_PUNCHED	Test if NAT was punched.
AUTO_UPNPC	Test if UPnP is working.
AUTO_ICMP_SERVER	Test if ICMP server works.
AUTO_ICMP_CLIENT	Test if ICMP client works.
AUTO_DONE	Last phase, we're done.

Definition at line 47 of file gnunet-service-nat-auto_legacy.c.

{
  AUTO_INIT = 0,
 
  AUTO_EXTERNAL_IP,
 
  AUTO_STUN,
 
  AUTO_LOCAL_IP,
 
  AUTO_NAT_PUNCHED,
 
  AUTO_UPNPC,
 
  AUTO_ICMP_SERVER,
 
  AUTO_ICMP_CLIENT,
 
  AUTO_DONE
};

Function Documentation

next_phase()

static void next_phase ( struct GNUNET_NAT_AutoHandle *  ah )

static

Run the next phase of the auto test.

Parameters

ah	auto test handle

Definition at line 867 of file gnunet-service-nat-auto_legacy.c.

{
  struct GNUNET_CONFIGURATION_Handle *diff;
 
  ah->phase++;
  switch (ah->phase)
  {
  case AUTO_INIT:
    GNUNET_assert (0);
    break;
 
  case AUTO_EXTERNAL_IP:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_EXTERNAL_IP\n");
    test_external_ip (ah);
    break;
 
  case AUTO_STUN:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_STUN\n");
    test_stun (ah);
    break;
 
  case AUTO_LOCAL_IP:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_LOCAL_IP\n");
    test_local_ip (ah);
    break;
 
  case AUTO_NAT_PUNCHED:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_NAT_PUNCHED\n");
    test_nat_punched (ah);
    break;
 
  case AUTO_UPNPC:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_UPNPC\n");
    test_upnpc (ah);
    break;
 
  case AUTO_ICMP_SERVER:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_ICMP_SERVER\n");
    test_icmp_server (ah);
    break;
 
  case AUTO_ICMP_CLIENT:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Will run AUTO_ICMP_CLIENT\n");
    test_icmp_client (ah);
    break;
 
  case AUTO_DONE:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Done with tests\n");
    if (! ah->internal_ip_is_public)
    {
      GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                             "nat",
                                             "BEHIND_NAT",
                                             "YES");
 
      if (ah->connected_back)
      {
        GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                               "nat",
                                               "PUNCHED_NAT",
                                               "YES");
      }
      else
      {
        GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                               "nat",
                                               "PUNCHED_NAT",
                                               "NO");
      }
 
      if (ah->stun_ip)
      {
        GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                               "nat",
                                               "EXTERNAL_ADDRESS",
                                               ah->stun_ip);
        if (ah->connected_back)
        {
          ah->type = GNUNET_NAT_TYPE_STUN_PUNCHED_NAT;
          GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                                 "nat",
                                                 "USE_STUN",
                                                 "YES");
        }
        else
        {
          ah->type = GNUNET_NAT_TYPE_UNREACHABLE_NAT;
          GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                                 "nat",
                                                 "USE_STUN",
                                                 "NO");
        }
      }
      if (0 != ah->stun_port)
      {
        GNUNET_CONFIGURATION_set_value_number (ah->cfg,
                                               "transport-udp",
                                               "ADVERTISED_PORT",
                                               ah->stun_port);
      }
    }
    else
    {
      // The internal IP is the same as public, but we didn't got a incoming connection
      if (ah->connected_back)
      {
        ah->type = GNUNET_NAT_TYPE_NO_NAT;
        GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                               "nat",
                                               "BEHIND_NAT",
                                               "NO");
      }
      else
      {
        GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                               "nat",
                                               "BEHIND_NAT",
                                               "YES");
        ah->type = GNUNET_NAT_TYPE_UNREACHABLE_NAT;
        if (ah->stun_ip)
        {
          GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                                 "nat",
                                                 "EXTERNAL_ADDRESS",
                                                 ah->stun_ip);
        }
        if (0 != ah->stun_port)
        {
          GNUNET_CONFIGURATION_set_value_number (ah->cfg,
                                                 "transport-udp",
                                                 "ADVERTISED_PORT",
                                                 ah->stun_port);
        }
      }
    }
 
    diff = GNUNET_CONFIGURATION_get_diff (ah->initial_cfg,
                                          ah->cfg);
 
 
    ah->fin_cb (ah->fin_cb_cls,
                diff,
                ah->ret,
                ah->type);
    GNUNET_CONFIGURATION_destroy (diff);
    GNUNET_NAT_autoconfig_cancel (ah);
  }
}

References ah, AUTO_DONE, AUTO_EXTERNAL_IP, AUTO_ICMP_CLIENT, AUTO_ICMP_SERVER, AUTO_INIT, AUTO_LOCAL_IP, AUTO_NAT_PUNCHED, AUTO_STUN, AUTO_UPNPC, GNUNET_NAT_AUTO_AutoHandle::cfg, GNUNET_assert, GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_diff(), GNUNET_CONFIGURATION_set_value_number(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NAT_autoconfig_cancel(), GNUNET_NAT_TYPE_NO_NAT, GNUNET_NAT_TYPE_STUN_PUNCHED_NAT, GNUNET_NAT_TYPE_UNREACHABLE_NAT, test_external_ip(), test_icmp_client(), test_icmp_server(), test_local_ip(), test_nat_punched(), test_stun(), and test_upnpc().

Referenced by do_udp_read(), GNUNET_NAT_autoconfig_start(), mq_error_handler(), process_stun_reply(), result_callback(), set_external_ipv4(), test_external_ip(), test_icmp_client(), test_icmp_server(), test_local_ip(), test_nat_punched(), test_stun(), and test_upnpc().

Here is the call graph for this function:

Here is the caller graph for this function:

process_stun_reply()

static void process_stun_reply ( struct sockaddr_in *  answer, struct GNUNET_NAT_AutoHandle *  ah  )

static

Definition at line 215 of file gnunet-service-nat-auto_legacy.c.

{
  ah->stun_ip = inet_ntoa (answer->sin_addr);
  ah->stun_port = ntohs (answer->sin_port);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "External IP is: %s , with port %u\n",
              ah->stun_ip,
              ah->stun_port);
  next_phase (ah);
}

References ah, GNUNET_ERROR_TYPE_INFO, GNUNET_log, and next_phase().

Referenced by do_udp_read().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_stun()

static void stop_stun ( )

static

Function that terminates the test.

Definition at line 232 of file gnunet-service-nat-auto_legacy.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Stopping STUN and quitting...\n");
  /* Clean task */
  if (NULL != ltask4)
  {
    GNUNET_SCHEDULER_cancel (ltask4);
    ltask4 = NULL;
  }
  /* Clean socket */
  if (NULL != lsock4)
  {
    GNUNET_NETWORK_socket_close (lsock4);
    lsock4 = NULL;
  }
}

References GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NETWORK_socket_close(), GNUNET_SCHEDULER_cancel(), lsock4, and ltask4.

Referenced by do_udp_read(), request_callback(), and test_stun().

Here is the call graph for this function:

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

Definition at line 258 of file gnunet-service-nat-auto_legacy.c.

{
  struct GNUNET_NAT_AutoHandle *ah = cls;
  unsigned char reply_buf[1024];
  ssize_t rlen;
  struct sockaddr_in answer;
  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
  tc = GNUNET_SCHEDULER_get_task_context ();
  if ((0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
      (GNUNET_NETWORK_fdset_isset (tc->read_ready,
                                   lsock4)))
  {
    rlen = GNUNET_NETWORK_socket_recv (lsock4,
                                       reply_buf,
                                       sizeof(reply_buf));
 
    // Lets handle the packet
    memset (&answer, 0, sizeof(struct sockaddr_in));
    if (ah->phase == AUTO_NAT_PUNCHED)
    {
      // Destroy the connection
      GNUNET_NETWORK_socket_close (lsock4);
      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                  "The external server was able to connect back");
      ah->connected_back = GNUNET_YES;
      next_phase (ah);
    }
    else
    {
      if (GNUNET_OK ==
          GNUNET_NAT_stun_handle_packet (reply_buf, rlen, &answer))
      {
        // Process the answer
        process_stun_reply (&answer, ah);
      }
      else
      {
        next_phase (ah);
      }
    }
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "TIMEOUT while waiting for an answer\n");
    if (ah->phase == AUTO_NAT_PUNCHED)
    {
      stop_stun ();
    }
 
    next_phase (ah);
  }
}

References ah, AUTO_NAT_PUNCHED, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAT_stun_handle_packet(), GNUNET_NETWORK_fdset_isset(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_recv(), GNUNET_OK, GNUNET_SCHEDULER_get_task_context(), GNUNET_SCHEDULER_REASON_READ_READY, GNUNET_YES, lsock4, next_phase(), process_stun_reply(), GNUNET_SCHEDULER_TaskContext::read_ready, GNUNET_SCHEDULER_TaskContext::reason, stop_stun(), and tc.

Referenced by test_nat_punched(), and test_stun().

Here is the call graph for this function:

Here is the caller graph for this function:

bind_v4()

static struct GNUNET_NETWORK_Handle * bind_v4 ( )

static

Create an IPv4 listen socket bound to our port.

Returns

NULL on error

Definition at line 320 of file gnunet-service-nat-auto_legacy.c.

{
  struct GNUNET_NETWORK_Handle *ls;
  struct sockaddr_in sa4;
  int eno;
 
  memset (&sa4, 0, sizeof(sa4));
  sa4.sin_family = AF_INET;
  sa4.sin_port = htons (port);
#if HAVE_SOCKADDR_IN_SIN_LEN
  sa4.sin_len = sizeof(sa4);
#endif
  ls = GNUNET_NETWORK_socket_create (AF_INET,
                                     SOCK_DGRAM,
                                     0);
  if (NULL == ls)
    return NULL;
  if (GNUNET_OK !=
      GNUNET_NETWORK_socket_bind (ls, (const struct sockaddr *) &sa4,
                                  sizeof(sa4)))
  {
    eno = errno;
    GNUNET_NETWORK_socket_close (ls);
    errno = eno;
    return NULL;
  }
  return ls;
}

References GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_OK, ls, and port.

Referenced by test_stun().

Here is the call graph for this function:

Here is the caller graph for this function:

request_callback()

static void request_callback ( void *  cls, enum GNUNET_NAT_StatusCode  result  )

static

Definition at line 351 of file gnunet-service-nat-auto_legacy.c.

{
  // struct GNUNET_NAT_AutoHandle *ah = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Request callback: stop and quit\n");
  stop_stun ();
 
  // next_phase (ah); FIXME this always will be NULL, as called in test_stun()
}

References GNUNET_ERROR_TYPE_INFO, GNUNET_log, and stop_stun().

Referenced by test_stun().

Here is the call graph for this function:

Here is the caller graph for this function:

result_callback()

static void result_callback ( void *  cls, enum GNUNET_NAT_StatusCode  ret  )

static

Function called by NAT to report the outcome of the nat-test.

Clean up and update GUI.

Parameters

cls	the auto handle
success	currently always GNUNET_OK
emsg	NULL on success, otherwise an error message

Definition at line 373 of file gnunet-service-nat-auto_legacy.c.

{
  struct GNUNET_NAT_AutoHandle *ah = cls;
 
  if (GNUNET_NAT_ERROR_SUCCESS == ret)
    GNUNET_NAT_test_stop (ah->tst);
  ah->tst = NULL;
  ah->ret = ret;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              GNUNET_NAT_ERROR_SUCCESS == ret
              ? _ ("NAT traversal with ICMP Server succeeded.\n")
              : _ ("NAT traversal with ICMP Server failed.\n"));
  GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_ICMP_SERVER",
                                         GNUNET_NAT_ERROR_SUCCESS == ret ?
                                         "NO" : "YES");
  next_phase (ah);
}

References _, ah, GNUNET_NAT_AUTO_AutoHandle::cfg, GNUNET_CONFIGURATION_set_value_string(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAT_ERROR_SUCCESS, GNUNET_NAT_test_stop(), next_phase(), and ret.

Referenced by reversal_test().

Here is the call graph for this function:

Here is the caller graph for this function:

reversal_test()

static void reversal_test ( void *  cls )

static

Main function for the connection reversal test.

Parameters

cls	the struct GNUNET_NAT_AutoHandle

Definition at line 399 of file gnunet-service-nat-auto_legacy.c.

{
  struct GNUNET_NAT_AutoHandle *ah = cls;
 
  ah->task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Testing connection reversal with ICMP server.\n"));
  GNUNET_RESOLVER_connect (ah->cfg);
  ah->tst = GNUNET_NAT_test_start (ah->cfg, GNUNET_YES, 0, 0, TIMEOUT,
                                   &result_callback, ah);
}

References _, ah, GNUNET_NAT_AUTO_AutoHandle::cfg, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAT_test_start(), GNUNET_RESOLVER_connect(), GNUNET_YES, result_callback(), and TIMEOUT.

Referenced by test_icmp_server().

Here is the call graph for this function:

Here is the caller graph for this function:

set_external_ipv4()

static void set_external_ipv4 ( void *  cls, const struct in_addr *  addr, enum GNUNET_NAT_StatusCode  ret  )

static

Set our external IPv4 address based on the UPnP.

Parameters

cls	closure with our setup context
addr	the address, NULL on errors
emsg	NULL on success, otherwise an error message

Definition at line 421 of file gnunet-service-nat-auto_legacy.c.

{
  struct GNUNET_NAT_AutoHandle *ah = cls;
  char buf[INET_ADDRSTRLEN];
 
  ah->eh = NULL;
  ah->ret = ret;
  if (GNUNET_NAT_ERROR_SUCCESS != ret)
  {
    next_phase (ah);
    return;
  }
  /* enable 'behind nat' */
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Detected external IP `%s'\n"),
              inet_ntop (AF_INET,
                         addr,
                         buf,
                         sizeof(buf)));
  GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "BEHIND_NAT", "YES");
 
  /* set external IP address */
  if (NULL == inet_ntop (AF_INET, addr, buf, sizeof(buf)))
  {
    GNUNET_break (0);
    /* actually, this should never happen, as the caller already executed just
     * this check, but for consistency (eg: future changes in the caller)
     * we still need to report this error...
     */
    ah->ret = GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID;
    next_phase (ah);
    return;
  }
  GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS",
                                         buf);
  ah->upnp_set_external_address = GNUNET_YES;
  next_phase (ah);
}

References _, ah, GNUNET_NAT_AUTO_AutoHandle::cfg, GNUNET_break, GNUNET_CONFIGURATION_set_value_string(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID, GNUNET_NAT_ERROR_SUCCESS, GNUNET_YES, next_phase(), and ret.

Referenced by test_external_ip().

Here is the call graph for this function:

Here is the caller graph for this function:

test_external_ip()

static void test_external_ip ( struct GNUNET_NAT_AutoHandle *  ah )

static

Determine our external IPv4 address.

Parameters

ah	auto setup context

Definition at line 469 of file gnunet-service-nat-auto_legacy.c.

{
  if (GNUNET_NAT_ERROR_SUCCESS != ah->ret)
    next_phase (ah);
 
  // FIXME: CPS?
  /* try to detect external IP */
  ah->eh = GNUNET_NAT_mini_get_external_ipv4 (TIMEOUT,
                                              &set_external_ipv4, ah);
}

References ah, GNUNET_NAT_ERROR_SUCCESS, next_phase(), set_external_ipv4(), and TIMEOUT.

Referenced by next_phase().

Here is the call graph for this function:

Here is the caller graph for this function:

test_stun()

static void test_stun ( struct GNUNET_NAT_AutoHandle *  ah )

static

Determine our external IPv4 address and port using an external STUN server.

Parameters

ah	auto setup context

Definition at line 487 of file gnunet-service-nat-auto_legacy.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running STUN test\n");
 
  /* Get port from the configuration */
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (ah->cfg,
                                             "transport-udp",
                                             "PORT",
                                             &port))
  {
    port = 2086;
  }
 
  // Lets create the socket
  lsock4 = bind_v4 ();
  if (NULL == lsock4)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind");
    next_phase (ah);
    return;
  }
  else
  {
    // Lets call our function now when it accepts
    ltask4 = GNUNET_SCHEDULER_add_read_net (NAT_SERVER_TIMEOUT,
                                            lsock4,
                                            &do_udp_read,
                                            ah);
  }
 
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "STUN service listens on port %u\n",
              (unsigned int) port);
  if (GNUNET_NO ==
      GNUNET_NAT_stun_make_request (stun_server,
                                    stun_port,
                                    lsock4,
                                    &request_callback,
                                    NULL))
  {
    /*An error happened*/
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "STUN error, stopping\n");
    stop_stun ();
    next_phase (ah);
  }
}

References ah, bind_v4(), GNUNET_NAT_AUTO_AutoHandle::cfg, do_udp_read(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_log_strerror, GNUNET_NAT_stun_make_request(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), lsock4, ltask4, NAT_SERVER_TIMEOUT, next_phase(), port, request_callback(), stop_stun(), stun_port, and stun_server.

Referenced by next_phase().

Here is the call graph for this function:

Here is the caller graph for this function:

process_if()

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

static

Process list of local IP addresses.

Find and set the one of the default interface.

Parameters

cls	our struct GNUNET_NAT_AutoHandle
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 addr and broadcast_addr

Returns

GNUNET_OK to continue iteration, GNUNET_SYSERR to abort

Definition at line 551 of file gnunet-service-nat-auto_legacy.c.

{
  struct GNUNET_NAT_AutoHandle *ah = cls;
  const struct sockaddr_in *in;
  char buf[INET_ADDRSTRLEN];
 
 
  if ((sizeof(struct sockaddr_in6) == addrlen) &&
      (0 != GNUNET_memcmp (&in6addr_loopback, &((const struct
                                                 sockaddr_in6 *) addr)->
                           sin6_addr)) &&
      (! IN6_IS_ADDR_LINKLOCAL (&((const struct
                                   sockaddr_in6 *) addr)->sin6_addr)))
  {
    ah->have_v6 = GNUNET_YES;
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ (
                  "This system has a global IPv6 address, setting IPv6 to supported.\n"));
 
    return GNUNET_OK;
  }
  if (addrlen != sizeof(struct sockaddr_in))
    return GNUNET_OK;
  in = (const struct sockaddr_in *) addr;
 
 
  /* set internal IP address */
  if (NULL == inet_ntop (AF_INET, &in->sin_addr, buf, sizeof(buf)))
  {
    GNUNET_break (0);
    return GNUNET_OK;
  }
  GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "INTERNAL_ADDRESS",
                                         buf);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              _ ("Detected internal network address `%s'.\n"),
              buf);
 
 
  ah->ret = GNUNET_NAT_ERROR_SUCCESS;
 
  /* Check if our internal IP is the same as the External detect by STUN*/
  if (ah->stun_ip && (strcmp (buf, ah->stun_ip) == 0))
  {
    ah->internal_ip_is_public = GNUNET_YES;
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "A internal IP is the sameas the external");
    /* No need to continue*/
    return GNUNET_SYSERR;
  }
 
  /* no need to continue iteration if we found the default */
  if (! isDefault)
    return GNUNET_OK;
  else
    return GNUNET_SYSERR;
}

References _, ah, GNUNET_NAT_AUTO_AutoHandle::cfg, GNUNET_break, GNUNET_CONFIGURATION_set_value_string(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_memcmp, GNUNET_NAT_ERROR_SUCCESS, GNUNET_OK, GNUNET_SYSERR, and GNUNET_YES.

Referenced by test_local_ip().

Here is the call graph for this function:

Here is the caller graph for this function:

test_local_ip()

static void test_local_ip ( struct GNUNET_NAT_AutoHandle *  ah )

static

Determine our local IP addresses; detect internal IP & IPv6-support.

Parameters

ah	auto setup context

Definition at line 622 of file gnunet-service-nat-auto_legacy.c.

{
  ah->have_v6 = GNUNET_NO;
  ah->ret = GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO; // reset to success if any of the IFs in below iterator has a valid IP
  GNUNET_OS_network_interfaces_list (&process_if, ah);
 
  GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "DISABLEV6",
                                         (GNUNET_YES == ah->have_v6) ? "NO" :
                                         "YES");
  next_phase (ah);
}

References ah, GNUNET_NAT_AUTO_AutoHandle::cfg, GNUNET_CONFIGURATION_set_value_string(), GNUNET_NAT_ERROR_NO_VALID_IF_IP_COMBO, GNUNET_NO, GNUNET_OS_network_interfaces_list(), GNUNET_YES, next_phase(), and process_if().

Referenced by next_phase().

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 GNUNET_NAT_AutoHandle
error	error code

Definition at line 643 of file gnunet-service-nat-auto_legacy.c.

{
  struct GNUNET_NAT_AutoHandle *ah = cls;
 
  GNUNET_MQ_destroy (ah->mq);
  ah->mq = NULL;
  /* wait a bit first? */
  next_phase (ah);
}

References ah, GNUNET_MQ_destroy(), GNUNET_NAT_AUTO_AutoHandle::mq, and next_phase().

Referenced by test_nat_punched().

Here is the call graph for this function:

Here is the caller graph for this function:

test_nat_punched()

static void test_nat_punched ( struct GNUNET_NAT_AutoHandle *  ah )

static

Test if NAT has been punched.

Parameters

ah	auto setup context

Definition at line 661 of file gnunet-service-nat-auto_legacy.c.

{
  struct GNUNET_NAT_TestMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  if (! ah->stun_ip)
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         "We don't have a STUN IP");
    next_phase (ah);
    return;
  }
 
  LOG (GNUNET_ERROR_TYPE_INFO,
       "Asking gnunet-nat-server to connect to `%s'\n",
       ah->stun_ip);
  ah->mq = GNUNET_CLIENT_connect (ah->cfg,
                                  "gnunet-nat-server",
                                  NULL,
                                  &mq_error_handler,
                                  ah);
  if (NULL == ah->mq)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `gnunet-nat-server'\n"));
    next_phase (ah);
    return;
  }
  env = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_NAT_TEST);
  msg->dst_ipv4 = inet_addr (ah->stun_ip);
  msg->dport = htons (ah->stun_port);
  msg->data = port;
  msg->is_tcp = htonl ((uint32_t) GNUNET_NO);
  GNUNET_MQ_send (ah->mq,
                  env);
  if (NULL != ltask4)
  {
    GNUNET_SCHEDULER_cancel (ltask4);
    ltask4 = GNUNET_SCHEDULER_add_read_net (NAT_SERVER_TIMEOUT,
                                            lsock4,
                                            &do_udp_read,
                                            ah);
  }
}

References _, ah, GNUNET_NAT_AUTO_AutoHandle::cfg, do_udp_read(), env, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_MESSAGE_TYPE_NAT_TEST, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_cancel(), LOG, lsock4, ltask4, GNUNET_NAT_AUTO_AutoHandle::mq, mq_error_handler(), msg, NAT_SERVER_TIMEOUT, next_phase(), and port.

Referenced by next_phase().

Here is the call graph for this function:

Here is the caller graph for this function:

test_upnpc()

static void test_upnpc ( struct GNUNET_NAT_AutoHandle *  ah )

static

Test if UPnPC works.

Parameters

ah	auto setup context

Definition at line 714 of file gnunet-service-nat-auto_legacy.c.

{
  int have_upnpc;
 
  if (GNUNET_NAT_ERROR_SUCCESS != ah->ret)
    next_phase (ah);
 
  // test if upnpc is available
  have_upnpc = (GNUNET_SYSERR !=
                GNUNET_OS_check_helper_binary ("upnpc", GNUNET_NO, NULL));
  // FIXME: test if upnpc is actually working, that is, if transports start to work once we use UPnP
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              (have_upnpc)
              ? _ ("upnpc found, enabling its use\n")
              : _ ("upnpc not found\n"));
  GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_UPNP",
                                         (GNUNET_YES == have_upnpc) ? "YES" :
                                         "NO");
  next_phase (ah);
}

References _, ah, GNUNET_NAT_AUTO_AutoHandle::cfg, GNUNET_CONFIGURATION_set_value_string(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAT_ERROR_SUCCESS, GNUNET_NO, GNUNET_OS_check_helper_binary(), GNUNET_SYSERR, GNUNET_YES, and next_phase().

Referenced by next_phase().

Here is the call graph for this function:

Here is the caller graph for this function:

test_icmp_server()

static void test_icmp_server ( struct GNUNET_NAT_AutoHandle *  ah )

static

Test if ICMP server is working.

Parameters

ah	auto setup context

Definition at line 742 of file gnunet-service-nat-auto_legacy.c.

{
  int ext_ip;
  int nated;
  int binary;
  char *tmp;
  char *helper;
 
  ext_ip = GNUNET_NO;
  nated = GNUNET_NO;
  binary = GNUNET_NO;
 
  tmp = NULL;
  helper = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-server");
  if ((GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_string (ah->cfg,
                                              "nat",
                                              "EXTERNAL_ADDRESS",
                                              &tmp)) &&
      (0 < strlen (tmp)))
  {
    ext_ip = GNUNET_OK;
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ (
                  "test_icmp_server not possible, as we have no public IPv4 address\n"));
  }
  else
    goto err;
 
  if (GNUNET_YES ==
      GNUNET_CONFIGURATION_get_value_yesno (ah->cfg,
                                            "nat",
                                            "BEHIND_NAT"))
  {
    nated = GNUNET_YES;
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ (
                  "test_icmp_server not possible, as we are not behind NAT\n"));
  }
  else
    goto err;
 
  if (GNUNET_YES ==
      GNUNET_OS_check_helper_binary (helper,
                                     GNUNET_YES,
                                     "-d 127.0.0.1"))
  {
    binary = GNUNET_OK;   // use localhost as source for that one udp-port, ok for testing
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("No working gnunet-helper-nat-server found\n"));
  }
err:
  GNUNET_free (tmp);
  GNUNET_free (helper);
 
  if ((GNUNET_OK == ext_ip) &&
      (GNUNET_YES == nated) &&
      (GNUNET_OK == binary))
    ah->task = GNUNET_SCHEDULER_add_now (&reversal_test,
                                         ah);
  else
    next_phase (ah);
}

References _, ah, GNUNET_NAT_AUTO_AutoHandle::cfg, GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_OS_check_helper_binary(), GNUNET_OS_get_libexec_binary_path(), GNUNET_SCHEDULER_add_now(), GNUNET_YES, next_phase(), and reversal_test().

Referenced by next_phase().

Here is the call graph for this function:

Here is the caller graph for this function:

test_icmp_client()

static void test_icmp_client ( struct GNUNET_NAT_AutoHandle *  ah )

static

Test if ICMP client is working.

Parameters

ah	auto setup context

Definition at line 813 of file gnunet-service-nat-auto_legacy.c.

{
  char *tmp;
  char *helper;
 
  tmp = NULL;
  helper = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-client");
  if ((GNUNET_OK ==
       GNUNET_CONFIGURATION_get_value_string (ah->cfg,
                                              "nat",
                                              "INTERNAL_ADDRESS",
                                              &tmp)) &&
      (0 < strlen (tmp)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ (
                  "test_icmp_client not possible, as we have no internal IPv4 address\n"));
  }
  else
    goto err;
 
  if (GNUNET_YES !=
      GNUNET_CONFIGURATION_get_value_yesno (ah->cfg,
                                            "nat",
                                            "BEHIND_NAT"))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ (
                  "test_icmp_server not possible, as we are not behind NAT\n"));
  }
  else
    goto err;
 
  if (GNUNET_YES ==
      GNUNET_OS_check_helper_binary (helper,
                                     GNUNET_YES,
                                     "-d 127.0.0.1 127.0.0.2 42"))
  {
    // none of these parameters are actually used in privilege testing mode
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _ ("No working gnunet-helper-nat-server found\n"));
  }
err:
  GNUNET_free (tmp);
  GNUNET_free (helper);
 
  next_phase (ah);
}

References _, ah, GNUNET_NAT_AUTO_AutoHandle::cfg, GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_OS_check_helper_binary(), GNUNET_OS_get_libexec_binary_path(), GNUNET_YES, and next_phase().

Referenced by next_phase().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAT_autoconfig_start()

struct GNUNET_NAT_AutoHandle * GNUNET_NAT_autoconfig_start	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		GNUNET_NAT_AutoResultCallback	cb,
		void *	cb_cls
	)

Start auto-configuration routine.

The resolver service should be available when this function is called.

Parameters

cfg	initial configuration
cb	function to call with autoconfiguration result
cb_cls	closure for cb

Returns

handle to cancel operation

Definition at line 1035 of file gnunet-service-nat-auto_legacy.c.

{
  struct GNUNET_NAT_AutoHandle *ah;
 
  ah = GNUNET_new (struct GNUNET_NAT_AutoHandle);
  ah->fin_cb = cb;
  ah->fin_cb_cls = cb_cls;
  ah->ret = GNUNET_NAT_ERROR_SUCCESS;
  ah->cfg = GNUNET_CONFIGURATION_dup (cfg);
  ah->initial_cfg = GNUNET_CONFIGURATION_dup (cfg);
 
  /* never use loopback addresses if user wanted autoconfiguration */
  GNUNET_CONFIGURATION_set_value_string (ah->cfg,
                                         "nat",
                                         "USE_LOCALADDR",
                                         "NO");
 
  next_phase (ah);
  return ah;
}

References ah, cfg, GNUNET_NAT_AUTO_AutoHandle::cfg, GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_NAT_ERROR_SUCCESS, GNUNET_new, and next_phase().

Here is the call graph for this function:

GNUNET_NAT_autoconfig_cancel()

void GNUNET_NAT_autoconfig_cancel

(

struct GNUNET_NAT_AutoHandle *

ah

)

Abort autoconfiguration.

Parameters

ah	handle for operation to abort

Definition at line 1065 of file gnunet-service-nat-auto_legacy.c.

{
  if (NULL != ah->tst)
  {
    GNUNET_NAT_test_stop (ah->tst);
    ah->tst = NULL;
  }
  if (NULL != ah->eh)
  {
    GNUNET_NAT_mini_get_external_ipv4_cancel (ah->eh);
    ah->eh = NULL;
  }
  if (NULL != ah->mq)
  {
    GNUNET_MQ_destroy (ah->mq);
    ah->mq = NULL;
  }
  if (NULL != ah->task)
  {
    GNUNET_SCHEDULER_cancel (ah->task);
    ah->task = NULL;
  }
  GNUNET_CONFIGURATION_destroy (ah->cfg);
  GNUNET_CONFIGURATION_destroy (ah->initial_cfg);
  GNUNET_free (ah);
}

References ah, GNUNET_NAT_AUTO_AutoHandle::cfg, GNUNET_CONFIGURATION_destroy(), GNUNET_free, GNUNET_MQ_destroy(), GNUNET_NAT_test_stop(), GNUNET_SCHEDULER_cancel(), and GNUNET_NAT_AUTO_AutoHandle::mq.

Referenced by next_phase().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

lsock4

struct GNUNET_NETWORK_Handle* lsock4

static

The listen socket of the service for IPv4.

Definition at line 188 of file gnunet-service-nat-auto_legacy.c.

Referenced by do_udp_read(), stop_stun(), test_nat_punched(), and test_stun().

ltask4

struct GNUNET_SCHEDULER_Task* ltask4

static

The listen task ID for IPv4.

Definition at line 193 of file gnunet-service-nat-auto_legacy.c.

Referenced by stop_stun(), test_nat_punched(), and test_stun().

port

unsigned long long port = 7895

static

The port the test service is running on (default 7895)

Definition at line 198 of file gnunet-service-nat-auto_legacy.c.

Referenced by bind_v4(), test_nat_punched(), and test_stun().

stun_server

char* stun_server = "stun.ekiga.net"

static

Definition at line 200 of file gnunet-service-nat-auto_legacy.c.

Referenced by test_stun().

stun_port

unsigned int stun_port = 3478

static

Definition at line 202 of file gnunet-service-nat-auto_legacy.c.

Referenced by test_stun().