summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorBruno Cabral <bcabral@uw.edu>2015-08-22 06:24:03 +0000
committerBruno Cabral <bcabral@uw.edu>2015-08-22 06:24:03 +0000
commit5475027f60525bcf22d75fb7f7ee721703e01cfd (patch)
tree374daa52fd9da6a975b7ef37dbf276fa152c7103
parentdd1927b960c7cea13733e061a11142274652ba27 (diff)
gnunet-nat, tool to suggest changes to configure based on NAT configuration
-rw-r--r--src/include/gnunet_nat_lib.h29
-rw-r--r--src/nat/Makefile.am9
-rw-r--r--src/nat/gnunet-nat.c181
-rw-r--r--src/nat/nat_auto.c477
-rw-r--r--src/nat/nat_test.c9
5 files changed, 660 insertions, 45 deletions
diff --git a/src/include/gnunet_nat_lib.h b/src/include/gnunet_nat_lib.h
index 3e9d8171c..2eb18d74f 100644
--- a/src/include/gnunet_nat_lib.h
+++ b/src/include/gnunet_nat_lib.h
@@ -70,6 +70,31 @@ typedef void
struct GNUNET_NAT_Handle;
+
+/**
+ * What the situation of the NAT connectivity
+ */
+enum GNUNET_NAT_Type
+{
+ /**
+ * We have a direct connection
+ */
+ GNUNET_NAT_TYPE_NO_NAT = GNUNET_OK,
+ /**
+ * We are under a NAT but cannot traverse it
+ */
+ GNUNET_NAT_TYPE_UNREACHABLE_NAT,
+ /**
+ * We can traverse using STUN
+ */
+ GNUNET_NAT_TYPE_STUN_PUNCHED_NAT,
+ /**
+ * WE can traverse using UPNP
+ */
+ GNUNET_NAT_TYPE_UPNP_NAT
+
+};
+
/**
* Error Types for the NAT subsystem (which can then later be converted/resolved to a string)
*/
@@ -428,11 +453,13 @@ struct GNUNET_NAT_AutoHandle;
* @param diff minimal suggested changes to the original configuration
* to make it work (as best as we can)
* @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code
+ * @param type what the situation of the NAT
*/
typedef void
(*GNUNET_NAT_AutoResultCallback)(void *cls,
const struct GNUNET_CONFIGURATION_Handle *diff,
- enum GNUNET_NAT_StatusCode result);
+ enum GNUNET_NAT_StatusCode result,
+ enum GNUNET_NAT_Type type);
/**
diff --git a/src/nat/Makefile.am b/src/nat/Makefile.am
index 037c97ef4..0fde4c22d 100644
--- a/src/nat/Makefile.am
+++ b/src/nat/Makefile.am
@@ -34,7 +34,8 @@ install-exec-hook:
endif
bin_PROGRAMS = \
- gnunet-nat-server
+ gnunet-nat-server \
+ gnunet-nat
libexec_PROGRAMS = \
$(NATBIN)
@@ -51,6 +52,12 @@ gnunet_helper_nat_server_SOURCES = \
gnunet_helper_nat_client_SOURCES = \
$(NATCLIENT)
+
+gnunet_nat_SOURCES = \
+gnunet-nat.c nat.h
+gnunet_nat_LDADD = \
+ libgnunetnat.la \
+ $(top_builddir)/src/util/libgnunetutil.la
if USE_COVERAGE
diff --git a/src/nat/gnunet-nat.c b/src/nat/gnunet-nat.c
new file mode 100644
index 000000000..f9aae10cf
--- /dev/null
+++ b/src/nat/gnunet-nat.c
@@ -0,0 +1,181 @@
+/*
+ This file is part of GNUnet.
+ Copyright (C) 2015 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING. If not, write to the
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+/**
+ * @file src/nat/gnunet-nat.c
+ * @brief Daemon to auto configure nat
+ * @author Christian Grothoff
+ * @author Bruno Cabral
+ */
+#include "platform.h"
+#include "gnunet_util_lib.h"
+#include "gnunet_nat_lib.h"
+#include "gnunet_protocols.h"
+#include "nat.h"
+
+
+struct GNUNET_CONFIGURATION_Handle *cfg;
+
+
+
+/**
+ * Function to iterate over sugested changes options
+ *
+ * @param cls closure
+ * @param section name of the section
+ * @param option name of the option
+ * @param value value of the option
+ */
+static void
+auto_conf_iter (void *cls,
+ const char *section,
+ const char *option,
+ const char *value)
+{
+
+ printf( "%s: %s \n", option, value);
+}
+
+
+
+/**
+ * Function called with the result from the autoconfiguration.
+ *
+ * @param cls closure
+ * @param diff minimal suggested changes to the original configuration
+ * to make it work (as best as we can)
+ * @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code
+ * @param type what the situation of the NAT
+ */
+
+void
+auto_config_cb(void *cls,
+ const struct GNUNET_CONFIGURATION_Handle *diff,
+ enum GNUNET_NAT_StatusCode result, enum GNUNET_NAT_Type type)
+{
+ char* nat_type;
+
+
+ switch (type)
+ {
+ case GNUNET_NAT_TYPE_NO_NAT:
+ nat_type = "NO NAT";
+ break;
+ case GNUNET_NAT_TYPE_UNREACHABLE_NAT:
+ nat_type = "NAT but we can traverse";
+ break;
+ case GNUNET_NAT_TYPE_STUN_PUNCHED_NAT:
+ nat_type = "NAT but STUN is able to identify the correct information";
+ break;
+ case GNUNET_NAT_TYPE_UPNP_NAT:
+ nat_type = "NAT but UPNP opened the ports";
+ break;
+
+ }
+
+ printf("NAT status: %s \n", nat_type );
+ printf("SUGGESTED CHANGES: \n" );
+
+ GNUNET_CONFIGURATION_iterate_section_values (diff,
+ "nat",
+ &auto_conf_iter,
+ NULL);
+
+ //TODO: Save config
+
+}
+
+
+
+
+
+/**
+ * Main function that will be run.
+ *
+ * @param cls closure
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param c configuration
+ */
+static void
+run (void *cls, char *const *args, const char *cfgfile,
+ const struct GNUNET_CONFIGURATION_Handle *c)
+{
+
+
+ GNUNET_NAT_autoconfig_start(c,auto_config_cb, NULL);
+
+}
+
+
+/**
+ * Main function of gnunet-nat
+ *
+ * @param argc number of command-line arguments
+ * @param argv command line
+ * @return 0 on success, -1 on error
+ */
+int
+main (int argc, char *const argv[])
+{
+ static const struct GNUNET_GETOPT_CommandLineOption options[] = {
+ GNUNET_GETOPT_OPTION_END
+ };
+
+ int ret = 0;
+ if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
+ return 2;
+
+ /* Lets start resolver */
+ char *fn;
+ struct GNUNET_OS_Process *proc;
+
+ fn = GNUNET_OS_get_libexec_binary_path ("gnunet-service-resolver");
+ proc = GNUNET_OS_start_process (GNUNET_YES,
+ GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+ NULL, NULL, NULL,
+ fn,
+ "gnunet-service-resolver");
+ GNUNET_assert (NULL != proc);
+
+ if (GNUNET_OK !=
+ GNUNET_PROGRAM_run (argc, argv, "gnunet-nat [options]",
+ _("GNUnet NAT traversal autoconfigure daemon"), options,
+ &run, NULL))
+ {
+ ret = 1;
+ }
+
+ /* Now kill the resolver */
+ if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG))
+ {
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+ }
+ GNUNET_OS_process_wait (proc);
+ GNUNET_OS_process_destroy (proc);
+ proc = NULL;
+
+
+ GNUNET_free ((void*) argv);
+ return ret;
+}
+
+
+/* end of gnunet-nat-server.c */
diff --git a/src/nat/nat_auto.c b/src/nat/nat_auto.c
index 327970e0a..dc7eecb3e 100644
--- a/src/nat/nat_auto.c
+++ b/src/nat/nat_auto.c
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- Copyright (C) 2012 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2015 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
@@ -22,6 +22,7 @@
* @file nat/nat_auto.c
* @brief functions for auto-configuration of the network
* @author Christian Grothoff
+ * @author Bruno Cabral
*/
#include "platform.h"
#include "gnunet_util_lib.h"
@@ -37,6 +38,8 @@
*/
#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 15)
+#define NAT_SERVER_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
+
/**
* Phases of the auto configuration.
*/
@@ -48,14 +51,14 @@ enum AutoPhase
AUTO_INIT = 0,
/**
- * Test if we are online.
+ * Test our external IP.
*/
- AUTO_ONLINE,
+ AUTO_EXTERNAL_IP,
/**
* Test our external IP.
*/
- AUTO_EXTERNAL_IP,
+ AUTO_STUN,
/**
* Test our internal IP.
@@ -136,25 +139,236 @@ struct GNUNET_NAT_AutoHandle
*/
enum AutoPhase phase;
+
+ /**
+ * Situation of the NAT
+ */
+ enum GNUNET_NAT_Type type;
+
/**
* Do we have IPv6?
*/
int have_v6;
/**
+ * UPnP already set the external ip address ?
+ */
+ int upnp_set_external_address;
+
+ /**
+ * Did the external server connected back ?
+ */
+ int connected_back;
+
+ /**
+ * Address detected by STUN
+ */
+ char* stun_ip;
+ int stun_port;
+
+ /**
+ * Internal IP is the same as the public one ?
+ */
+ int internal_ip_is_public;
+
+ /**
* Error code for better debugging and user feedback
*/
enum GNUNET_NAT_StatusCode ret;
};
+
+
+
+
+/**
+ * The listen socket of the service for IPv4
+ */
+static struct GNUNET_NETWORK_Handle *lsock4;
+
+
+/**
+ * The listen task ID for IPv4
+ */
+static struct GNUNET_SCHEDULER_Task * ltask4;
+
+
+
+
+/**
+ * The port the test service is running on (default 7895)
+ */
+static unsigned long long port = 7895;
+
+static char *stun_server = "stun.ekiga.net";
+static int stun_port = 3478;
+
+
+
/**
* Run the next phase of the auto test.
*
* @param ah auto test handle
*/
static void
-next_phase (struct GNUNET_NAT_AutoHandle *ah);
+ 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 %d\n", ah->stun_ip, ah->stun_port);
+
+
+ next_phase (ah);
+
+}
+
+/**
+ * Function that terminates the test.
+ */
+static void
+stop_stun ()
+{
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping NAT and quitting...\n");
+
+ //Clean task
+ if(NULL != ltask4)
+ GNUNET_SCHEDULER_cancel (ltask4);
+
+ //Clean socket
+ if(NULL != ltask4)
+ GNUNET_NETWORK_socket_close (lsock4);
+
+}
+
+/**
+ * Activity on our incoming socket. Read data from the
+ * incoming connection.
+ *
+ * @param cls
+ * @param tc scheduler context
+ */
+static void
+do_udp_read (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct GNUNET_NAT_AutoHandle *ah = cls;
+ unsigned char reply_buf[1024];
+ ssize_t rlen;
+ struct sockaddr_in answer;
+
+
+ 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 aiting for an answer");
+ if(ah->phase == AUTO_NAT_PUNCHED)
+ {
+ stop_stun();
+ }
+
+ next_phase(ah);
+ }
+
+
+
+}
+
+
+/**
+ * Create an IPv4 listen socket bound to our port.
+ *
+ * @return NULL on error
+ */
+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, "Stopping NAT and quitting...\n");
+ stop_stun();
+
+ next_phase(ah);
+};
+
+
+
/**
@@ -170,6 +384,7 @@ 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;
@@ -206,24 +421,8 @@ reversal_test (void *cls,
/**
- * Test if we are online at all.
+ * Set our external IPv4 address based on the UPnP.
*
- * @param ah auto setup context
- */
-static void
-test_online (struct GNUNET_NAT_AutoHandle *ah)
-{
- // FIXME: not implemented
- /*
- * if (failure)
- * ah->ret = GNUNET_NAT_ERROR_NOT_ONLINE;
- */
- next_phase (ah);
-}
-
-
-/**
- * Set our external IPv4 address.
*
* @param cls closure with our setup context
* @param addr the address, NULL on errors
@@ -267,6 +466,7 @@ set_external_ipv4 (void *cls,
}
GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "EXTERNAL_ADDRESS",
buf);
+ ah->upnp_set_external_address = GNUNET_YES;
next_phase (ah);
}
@@ -290,6 +490,59 @@ test_external_ip (struct GNUNET_NAT_AutoHandle *ah)
/**
+ * Determine our external IPv4 address and port using an external STUN server
+ *
+ * @param ah auto setup context
+ */
+static void
+test_stun (struct GNUNET_NAT_AutoHandle *ah)
+{
+
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,"Running STUN test");
+
+ /* 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",
+ port);
+ if( GNUNET_NO == GNUNET_NAT_stun_make_request(stun_server, stun_port, lsock4, &request_callback, NULL))
+ {
+ /*An error happened*/
+ stop_stun();
+ next_phase(ah);
+ }
+
+
+}
+
+
+
+/**
* Process list of local IP addresses. Find and set the
* one of the default interface.
*
@@ -315,8 +568,7 @@ process_if (void *cls,
const struct sockaddr_in *in;
char buf[INET_ADDRSTRLEN];
- if (!isDefault)
- return GNUNET_OK;
+
if ( (sizeof (struct sockaddr_in6) == addrlen) &&
(0 != memcmp (&in6addr_loopback, &((const struct sockaddr_in6 *) addr)->sin6_addr,
sizeof (struct in6_addr))) &&
@@ -325,12 +577,14 @@ process_if (void *cls,
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)))
{
@@ -342,9 +596,24 @@ process_if (void *cls,
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Detected internal network address `%s'.\n"),
buf);
+
+
ah->ret = GNUNET_NAT_ERROR_SUCCESS;
- /* no need to continue iteration */
- return GNUNET_SYSERR;
+
+ /* 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;
}
@@ -374,15 +643,55 @@ test_local_ip (struct GNUNET_NAT_AutoHandle *ah)
static void
test_nat_punched (struct GNUNET_NAT_AutoHandle *ah)
{
- if (GNUNET_NAT_ERROR_SUCCESS != ah->ret)
- next_phase (ah);
-
- // FIXME: not implemented
-
- next_phase (ah);
+
+ struct GNUNET_CLIENT_Connection *client;
+ struct GNUNET_NAT_TestMessage msg;
+
+
+ if(ah->stun_ip)
+ {
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ "Asking gnunet-nat-server to connect to `%s'\n",
+ ah->stun_ip);
+
+
+ msg.header.size = htons (sizeof (struct GNUNET_NAT_TestMessage));
+ msg.header.type = htons (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);
+
+ client = GNUNET_CLIENT_connect ("gnunet-nat-server", ah->cfg);
+ if (NULL == client)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _("Failed to connect to `gnunet-nat-server'\n"));
+ return;
+ }
+
+ GNUNET_break (GNUNET_OK ==
+ GNUNET_CLIENT_transmit_and_get_response (client, &msg.header,
+ NAT_SERVER_TIMEOUT,
+ GNUNET_YES, NULL,
+ NULL));
+ ltask4 = GNUNET_SCHEDULER_add_read_net (NAT_SERVER_TIMEOUT,
+ lsock4, &do_udp_read, ah);
+
+ }
+ else
+ {
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ "We don't have a STUN IP");
+ next_phase(ah);
+ }
+
+
}
+
+
/**
* Test if UPnPC works.
*
@@ -391,16 +700,16 @@ test_nat_punched (struct GNUNET_NAT_AutoHandle *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 */
+ // 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 */
+ //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")
@@ -408,6 +717,7 @@ test_upnpc (struct GNUNET_NAT_AutoHandle *ah)
GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat", "ENABLE_UPNP",
(GNUNET_YES == have_upnpc) ? "YES" : "NO");
next_phase (ah);
+
}
@@ -419,6 +729,7 @@ test_upnpc (struct GNUNET_NAT_AutoHandle *ah)
static void
test_icmp_server (struct GNUNET_NAT_AutoHandle *ah)
{
+
int ext_ip;
int nated;
int binary;
@@ -460,6 +771,7 @@ err:
ah->task = GNUNET_SCHEDULER_add_now (&reversal_test, ah);
else
next_phase (ah);
+
}
@@ -471,6 +783,8 @@ err:
static void
test_icmp_client (struct GNUNET_NAT_AutoHandle *ah)
{
+
+
char *tmp;
char *helper;
@@ -502,6 +816,7 @@ err:
GNUNET_free (helper);
next_phase (ah);
+
}
@@ -519,37 +834,116 @@ next_phase (struct GNUNET_NAT_AutoHandle *ah)
case AUTO_INIT:
GNUNET_assert (0);
break;
- case AUTO_ONLINE:
- test_online (ah);
- 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 GNUNET_ERROR_TYPE_DEBUG\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(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(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->cfg);
+
+
ah->fin_cb (ah->fin_cb_cls,
- diff,
- ah->ret);
+ diff,
+ ah->ret,
+ ah->type);
GNUNET_CONFIGURATION_destroy (diff);
GNUNET_NAT_autoconfig_cancel (ah);
return;
+
}
+
+
+
}
@@ -580,6 +974,7 @@ GNUNET_NAT_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat",
"USE_LOCALADDR",
"NO");
+
next_phase (ah);
return ah;
}
diff --git a/src/nat/nat_test.c b/src/nat/nat_test.c
index 3ee80ecae..b998d46a0 100644
--- a/src/nat/nat_test.c
+++ b/src/nat/nat_test.c
@@ -287,6 +287,8 @@ do_accept (void *cls,
struct GNUNET_NETWORK_Handle *s;
struct NatActivity *wl;
+ printf("Inbound");
+
tst->ltask = NULL;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
return;
@@ -333,6 +335,8 @@ addr_cb (void *cls,
struct GNUNET_NAT_TestMessage msg;
const struct sockaddr_in *sa;
+ printf("Addr callback");
+
if (GNUNET_YES != add_remove)
return;
if (addrlen != sizeof (struct sockaddr_in))
@@ -448,6 +452,7 @@ GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
}
else
{
+ printf("Vou criar o socket");
nh->lsock =
GNUNET_NETWORK_socket_create (AF_INET,
(is_tcp ==
@@ -484,7 +489,7 @@ GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
nh->lsock, &do_udp_read, nh);
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
+ LOG (GNUNET_ERROR_TYPE_INFO,
"NAT test listens on port %u (%s)\n",
bnd_port,
(GNUNET_YES == is_tcp) ? "tcp" : "udp");
@@ -493,7 +498,7 @@ GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
&addr_cb, NULL, nh, NULL);
if (NULL == nh->nat)
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
+ LOG (GNUNET_ERROR_TYPE_INFO,
_("NAT test failed to start NAT library\n"));
if (NULL != nh->ltask)
{