#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_nat_service.h"
#include "gnunet_nat_auto_service.h"

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

Functions
static void	test_finished ()
	Test if all activities have finished, and if so, terminate. More...

static void	auto_conf_iter (void cls, const char section, const char option, const char value)
	Function to iterate over suggested changes options. More...

static void	auto_config_cb (void cls, const struct GNUNET_CONFIGURATION_Handle diff, enum GNUNET_NAT_StatusCode result, enum GNUNET_NAT_Type type)
	Function called with the result from the autoconfiguration. More...

static void	test_report_cb (void *cls, enum GNUNET_NAT_StatusCode result)
	Function called to report success or failure for NAT configuration test. More...

static void	do_shutdown (void *cls)
	Task run on shutdown. More...

static void	run (void cls, char const args, const char cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Main function that will be run. More...

int	main (int argc, char *const argv[])
	Main function of gnunet-nat-auto. More...

Variables
static int	global_ret
	Value to return from main(). More...

static struct GNUNET_NAT_AUTO_AutoHandle *	ah
	Handle to ongoing autoconfiguration. More...

static int	write_cfg
	If we do auto-configuration, should we write the result to a file? More...

static const char *	cfg_file
	Configuration filename. More...

static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Original configuration. More...

static char *	section_name
	Adapter we are supposed to test. More...

static int	do_auto
	Should we run autoconfiguration? More...

static struct GNUNET_NAT_AUTO_Test *	nt
	Handle to a NAT test operation. More...

static int	use_udp
	Flag set to 1 if we use IPPROTO_UDP. More...

static int	use_tcp
	Flag set to 1 if we use IPPROTO_TCP. More...

static uint8_t	proto
	Protocol to use. More...

Function Documentation

◆ test_finished()

static void test_finished ( void )

static

Test if all activities have finished, and if so, terminate.

Definition at line 93 of file gnunet-nat-auto.c.

{
  if (NULL != ah)
    return;
  if (NULL != nt)
    return;
  GNUNET_SCHEDULER_shutdown ();
}

References ah, GNUNET_SCHEDULER_shutdown(), and nt.

Referenced by auto_config_cb(), run(), and test_report_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ auto_conf_iter()

static void auto_conf_iter	(	void *	cls,
		const char *	section,
		const char *	option,
		const char *	value
	)

static

Function to iterate over suggested changes options.

Parameters

cls	closure
section	name of the section
option	name of the option
value	value of the option

Definition at line 112 of file gnunet-nat-auto.c.

{
  struct GNUNET_CONFIGURATION_Handle *new_cfg = cls;
 
  printf ("%s: %s\n", option, value);
  if (NULL != new_cfg)
    GNUNET_CONFIGURATION_set_value_string (new_cfg, section, option, value);
}

References GNUNET_CONFIGURATION_set_value_string(), and value.

Referenced by auto_config_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ auto_config_cb()

static void auto_config_cb	(	void *	cls,
		const struct GNUNET_CONFIGURATION_Handle *	diff,
		enum GNUNET_NAT_StatusCode	result,
		enum GNUNET_NAT_Type	type
	)

static

Function called with the result from the autoconfiguration.

Parameters

cls	closure
diff	minimal suggested changes to the original configuration to make it work (as best as we can)
result	GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code
type	what the situation of the NAT

Definition at line 135 of file gnunet-nat-auto.c.

{
  const char *nat_type;
  char unknown_type[64];
  struct GNUNET_CONFIGURATION_Handle *new_cfg;
 
  ah = NULL;
  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;
 
  default:
    sprintf (unknown_type, "NAT unknown, type %u", type);
    nat_type = unknown_type;
    break;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
              "NAT status: %s/%s\n",
              GNUNET_NAT_AUTO_status2string (result),
              nat_type);
 
  if (NULL == diff)
    return;
 
  /* Shortcut: if there are no changes suggested, bail out early. */
  if (GNUNET_NO == GNUNET_CONFIGURATION_is_dirty (diff))
  {
    test_finished ();
    return;
  }
 
  /* Apply diff to original configuration and show changes
     to the user */
  new_cfg = write_cfg ? GNUNET_CONFIGURATION_dup (cfg) : NULL;
 
  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
              _ ("Suggested configuration changes:\n"));
  GNUNET_CONFIGURATION_iterate_section_values (diff,
                                               "nat",
                                               &auto_conf_iter,
                                               new_cfg);
 
  /* If desired, write configuration to file; we write only the
     changes to the defaults to keep things compact. */
  if (write_cfg)
  {
    struct GNUNET_CONFIGURATION_Handle *def_cfg;
 
    GNUNET_CONFIGURATION_set_value_string (new_cfg, "ARM", "CONFIG", NULL);
    def_cfg = GNUNET_CONFIGURATION_create ();
    GNUNET_break (GNUNET_OK == GNUNET_CONFIGURATION_load (def_cfg, NULL));
    if (GNUNET_OK !=
        GNUNET_CONFIGURATION_write_diffs (def_cfg, new_cfg, cfg_file))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  _ ("Failed to write configuration to `%s'\n"),
                  cfg_file);
      global_ret = 1;
    }
    else
    {
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  _ ("Wrote updated configuration to `%s'\n"),
                  cfg_file);
    }
    GNUNET_CONFIGURATION_destroy (def_cfg);
  }
 
  if (NULL != new_cfg)
    GNUNET_CONFIGURATION_destroy (new_cfg);
  test_finished ();
}

References _, ah, auto_conf_iter(), cfg, cfg_file, global_ret, GNUNET_break, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_dup(), GNUNET_CONFIGURATION_is_dirty(), GNUNET_CONFIGURATION_iterate_section_values(), GNUNET_CONFIGURATION_load(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_CONFIGURATION_write_diffs(), GNUNET_ERROR_TYPE_MESSAGE, GNUNET_log, GNUNET_NAT_AUTO_status2string(), GNUNET_NAT_TYPE_NO_NAT, GNUNET_NAT_TYPE_STUN_PUNCHED_NAT, GNUNET_NAT_TYPE_UNREACHABLE_NAT, GNUNET_NAT_TYPE_UPNP_NAT, GNUNET_NO, GNUNET_OK, result, test_finished(), type, and write_cfg.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ test_report_cb()

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

static

Function called to report success or failure for NAT configuration test.

Parameters

cls	closure
result	GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code

Definition at line 235 of file gnunet-nat-auto.c.

{
  nt = NULL;
  printf ("NAT test result: %s\n", GNUNET_NAT_AUTO_status2string (result));
  test_finished ();
}

References GNUNET_NAT_AUTO_status2string(), nt, result, and test_finished().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_shutdown()

static void do_shutdown ( void * cls )

static

Task run on shutdown.

Parameters

cls NULL

Definition at line 249 of file gnunet-nat-auto.c.

{
  if (NULL != ah)
  {
    GNUNET_NAT_AUTO_autoconfig_cancel (ah);
    ah = NULL;
  }
  if (NULL != nt)
  {
    GNUNET_NAT_AUTO_test_stop (nt);
    nt = NULL;
  }
}

References ah, GNUNET_NAT_AUTO_autoconfig_cancel(), GNUNET_NAT_AUTO_test_stop(), and nt.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run()

static void run	(	void *	cls,
		char const	args,
		const char *	cfgfile,
		const struct GNUNET_CONFIGURATION_Handle *	c
	)

static

Main function that will be run.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
c	configuration

Definition at line 273 of file gnunet-nat-auto.c.

{
  cfg_file = cfgfile;
  cfg = c;
 
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 
  if (do_auto)
  {
    ah = GNUNET_NAT_AUTO_autoconfig_start (c, &auto_config_cb, NULL);
  }
 
  if (use_tcp && use_udp)
  {
    if (do_auto)
      return;
    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, "Cannot use TCP and UDP\n");
    global_ret = 1;
    return;
  }
  proto = 0;
  if (use_tcp)
    proto = IPPROTO_TCP;
  if (use_udp)
    proto = IPPROTO_UDP;
 
  if (NULL != section_name)
  {
    nt = GNUNET_NAT_AUTO_test_start (c,
                                     proto,
                                     section_name,
                                     &test_report_cb,
                                     NULL);
  }
  test_finished ();
}

References ah, auto_config_cb(), cfg, cfg_file, do_auto, do_shutdown(), global_ret, GNUNET_ERROR_TYPE_MESSAGE, GNUNET_log, GNUNET_NAT_AUTO_autoconfig_start(), GNUNET_NAT_AUTO_test_start(), GNUNET_SCHEDULER_add_shutdown(), nt, proto, section_name, test_finished(), test_report_cb(), use_tcp, and use_udp.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int	argc,
		char *const	argv[]
	)

Main function of gnunet-nat-auto.

Parameters

argc	number of command-line arguments
argv	command line

Returns: 0 on success, -1 on error

Definition at line 322 of file gnunet-nat-auto.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_flag ('a',
                               "auto",
                               gettext_noop ("run autoconfiguration"),
                               &do_auto),
 
    GNUNET_GETOPT_option_string (
      'S',
      "section",
      "NAME",
      gettext_noop (
        "section name providing the configuration for the adapter"),
      &section_name),
 
    GNUNET_GETOPT_option_flag ('t', "tcp", gettext_noop ("use TCP"), &use_tcp),
 
    GNUNET_GETOPT_option_flag ('u', "udp", gettext_noop ("use UDP"), &use_udp),
 
    GNUNET_GETOPT_option_flag (
      'w',
      "write",
      gettext_noop ("write configuration file (for autoconfiguration)"),
      &write_cfg),
    GNUNET_GETOPT_OPTION_END };
 
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
  if (GNUNET_OK !=
      GNUNET_PROGRAM_run (argc,
                          argv,
                          "gnunet-nat-auto [options]",
                          _ ("GNUnet NAT traversal autoconfiguration"),
                          options,
                          &run,
                          NULL))
  {
    global_ret = 1;
  }
  GNUNET_free_nz ((void *) argv);
  return global_ret;
}