gnunet-service-nat_helper.c File Reference

runs the gnunet-helper-nat-server More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet-service-nat_helper.h"

Include dependency graph for gnunet-service-nat_helper.c:

Go to the source code of this file.

Data Structures
struct	HelperContext
	Information we keep per NAT helper process. More...

Functions
static void	restart_nat_server (void *cls)
	Task that restarts the gnunet-helper-nat-server process after a crash after a certain delay. More...
static void	try_again (struct HelperContext *h)
	Try again starting the helper later. More...
static void	nat_server_read (void *cls)
	We have been notified that gnunet-helper-nat-server has written something to stdout. More...
struct HelperContext *	GN_start_gnunet_nat_server_ (const struct in_addr *internal_address, GN_ReversalCallback cb, void *cb_cls, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Start the gnunet-helper-nat-server and process incoming requests. More...
void	GN_stop_gnunet_nat_server_ (struct HelperContext *h)
	Start the gnunet-helper-nat-server and process incoming requests. More...
int	GN_request_connection_reversal (const struct in_addr *internal_address, uint16_t internal_port, const struct in_addr *remote_v4, const struct GNUNET_CONFIGURATION_Handle *cfg)
	We want to connect to a peer that is behind NAT. More...

Detailed Description

runs the gnunet-helper-nat-server

Author

Milan Bouchet-Valat

Christian Grothoff

Definition in file gnunet-service-nat_helper.c.

Function Documentation

restart_nat_server()

static void restart_nat_server ( void *  cls )

static

Task that restarts the gnunet-helper-nat-server process after a crash after a certain delay.

Parameters

cls	a struct HelperContext

Definition at line 206 of file gnunet-service-nat_helper.c.

{
  struct HelperContext *h = cls;
  char *binary;
  char ia[INET_ADDRSTRLEN];
 
  h->server_read_task = NULL;
  GNUNET_assert (NULL !=
                 inet_ntop (AF_INET, &h->internal_address, ia, sizeof(ia)));
  /* Start the server process */
  binary = GNUNET_OS_get_suid_binary_path (GNUNET_OS_project_data_gnunet (),
                                           h->cfg,
                                           "gnunet-helper-nat-server");
  if (GNUNET_YES !=
      GNUNET_OS_check_helper_binary (binary,
                                     GNUNET_YES,
                                     ia))
  {
    /* move instantly to max delay, as this is unlikely to be fixed */
    h->server_retry_delay = GNUNET_TIME_STD_EXPONENTIAL_BACKOFF_THRESHOLD;
    GNUNET_free (binary);
    try_again (h);
    return;
  }
  h->server_stdout =
    GNUNET_DISK_pipe (GNUNET_DISK_PF_BLOCKING_RW);
  if (NULL == h->server_stdout)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "pipe");
    GNUNET_free (binary);
    try_again (h);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting `%s' at `%s'\n",
              "gnunet-helper-nat-server",
              ia);
  h->server_proc = GNUNET_OS_start_process (GNUNET_OS_INHERIT_STD_NONE,
                                            NULL,
                                            h->server_stdout,
                                            NULL,
                                            binary,
                                            "gnunet-helper-nat-server",
                                            ia,
                                            NULL);
  GNUNET_free (binary);
  if (NULL == h->server_proc)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to start %s\n"),
                "gnunet-helper-nat-server");
    GNUNET_DISK_pipe_close (h->server_stdout);
    h->server_stdout = NULL;
    try_again (h);
    return;
  }
  /* Close the write end of the read pipe */
  GNUNET_DISK_pipe_close_end (h->server_stdout, GNUNET_DISK_PIPE_END_WRITE);
  h->server_stdout_handle =
    GNUNET_DISK_pipe_handle (h->server_stdout, GNUNET_DISK_PIPE_END_READ);
  h->server_read_task =
    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                    h->server_stdout_handle,
                                    &nat_server_read,
                                    h);
}

References _, GNUNET_ARM_Handle::cfg, GNUNET_assert, GNUNET_DISK_PF_BLOCKING_RW, GNUNET_DISK_pipe(), GNUNET_DISK_pipe_close(), GNUNET_DISK_pipe_close_end(), GNUNET_DISK_PIPE_END_READ, GNUNET_DISK_PIPE_END_WRITE, GNUNET_DISK_pipe_handle(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_strerror, GNUNET_OS_check_helper_binary(), GNUNET_OS_get_suid_binary_path(), GNUNET_OS_INHERIT_STD_NONE, GNUNET_OS_project_data_gnunet(), GNUNET_OS_start_process(), GNUNET_SCHEDULER_add_read_file(), GNUNET_TIME_STD_EXPONENTIAL_BACKOFF_THRESHOLD, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, h, nat_server_read(), and try_again().

Referenced by GN_start_gnunet_nat_server_(), and try_again().

Here is the call graph for this function:

Here is the caller graph for this function:

try_again()

static void try_again ( struct HelperContext *  h )

static

Try again starting the helper later.

Parameters

h	context of the helper

Definition at line 100 of file gnunet-service-nat_helper.c.

{
  GNUNET_assert (NULL == h->server_read_task);
  h->server_retry_delay = GNUNET_TIME_STD_BACKOFF (h->server_retry_delay);
  h->server_read_task = GNUNET_SCHEDULER_add_delayed (h->server_retry_delay,
                                                      &restart_nat_server,
                                                      h);
}

References GNUNET_assert, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, h, and restart_nat_server().

Referenced by nat_server_read(), and restart_nat_server().

Here is the call graph for this function:

Here is the caller graph for this function:

nat_server_read()

static void nat_server_read ( void *  cls )

static

We have been notified that gnunet-helper-nat-server has written something to stdout.

Handle the output, then reschedule this function to be called again once more is available.

Parameters

cls	the struct HelperContext

Definition at line 118 of file gnunet-service-nat_helper.c.

{
  struct HelperContext *h = cls;
  char mybuf[40];
  ssize_t bytes;
  int port;
  const char *port_start;
  struct sockaddr_in sin_addr;
 
  h->server_read_task = NULL;
  memset (mybuf, 0, sizeof(mybuf));
  bytes =
    GNUNET_DISK_file_read (h->server_stdout_handle, mybuf, sizeof(mybuf));
  if (bytes < 1)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Finished reading from server stdout with code: %d\n",
                (int) bytes);
    if (0 != GNUNET_OS_process_kill (h->server_proc, GNUNET_TERM_SIG))
      GNUNET_log_from_strerror (GNUNET_ERROR_TYPE_WARNING, "nat", "kill");
    GNUNET_OS_process_wait (h->server_proc);
    GNUNET_OS_process_destroy (h->server_proc);
    h->server_proc = NULL;
    GNUNET_DISK_pipe_close (h->server_stdout);
    h->server_stdout = NULL;
    h->server_stdout_handle = NULL;
    try_again (h);
    return;
  }
 
  port_start = NULL;
  for (size_t i = 0; i < sizeof(mybuf); i++)
  {
    if (mybuf[i] == '\n')
    {
      mybuf[i] = '\0';
      break;
    }
    if ((mybuf[i] == ':') && (i + 1 < sizeof(mybuf)))
    {
      mybuf[i] = '\0';
      port_start = &mybuf[i + 1];
    }
  }
 
  /* construct socket address of sender */
  memset (&sin_addr, 0, sizeof(sin_addr));
  sin_addr.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
  sin_addr.sin_len = sizeof(sin_addr);
#endif
  if ((NULL == port_start) || (1 != sscanf (port_start, "%d", &port)) ||
      (-1 == inet_pton (AF_INET, mybuf, &sin_addr.sin_addr)))
  {
    /* should we restart gnunet-helper-nat-server? */
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ (
                  "gnunet-helper-nat-server generated malformed address `%s'\n")
                ,
                mybuf);
    h->server_read_task =
      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                      h->server_stdout_handle,
                                      &nat_server_read,
                                      h);
    return;
  }
  sin_addr.sin_port = htons ((uint16_t) port);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "gnunet-helper-nat-server read: %s:%d\n",
              mybuf,
              port);
  h->cb (h->cb_cls, &sin_addr);
  h->server_read_task =
    GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                    h->server_stdout_handle,
                                    &nat_server_read,
                                    h);
}

References _, GNUNET_DISK_file_read(), GNUNET_DISK_pipe_close(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_from_strerror, GNUNET_OS_process_destroy(), GNUNET_OS_process_kill(), GNUNET_OS_process_wait(), GNUNET_SCHEDULER_add_read_file(), GNUNET_TERM_SIG, GNUNET_TIME_UNIT_FOREVER_REL, h, nat_server_read(), port, and try_again().

Referenced by nat_server_read(), and restart_nat_server().

Here is the call graph for this function:

Here is the caller graph for this function:

GN_start_gnunet_nat_server_()

struct HelperContext * GN_start_gnunet_nat_server_	(	const struct in_addr *	internal_address,
		GN_ReversalCallback	cb,
		void *	cb_cls,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

Start the gnunet-helper-nat-server and process incoming requests.

Parameters

internal_address
cb	function to call if we receive a request
cb_cls	closure for cb
cfg	handle to the GNUnet configuration

Returns

NULL on error

Definition at line 275 of file gnunet-service-nat_helper.c.

{
  struct HelperContext *h;
 
  h = GNUNET_new (struct HelperContext);
  h->cb = cb;
  h->cb_cls = cb_cls;
  h->internal_address = *internal_address;
  h->cfg = cfg;
  restart_nat_server (h);
  if (NULL == h->server_stdout)
  {
    GN_stop_gnunet_nat_server_ (h);
    return NULL;
  }
  return h;
}

References HelperContext::cb, HelperContext::cb_cls, cfg, GNUNET_ARM_Handle::cfg, GN_stop_gnunet_nat_server_(), GNUNET_new, h, HelperContext::internal_address, and restart_nat_server().

Referenced by run_scan().

Here is the call graph for this function:

Here is the caller graph for this function:

GN_stop_gnunet_nat_server_()

void GN_stop_gnunet_nat_server_

(

struct HelperContext *

h

)

Start the gnunet-helper-nat-server and process incoming requests.

Parameters

h	helper context to stop

Definition at line 304 of file gnunet-service-nat_helper.c.

{
  if (NULL != h->server_read_task)
  {
    GNUNET_SCHEDULER_cancel (h->server_read_task);
    h->server_read_task = NULL;
  }
  if (NULL != h->server_proc)
  {
    if (0 != GNUNET_OS_process_kill (h->server_proc, GNUNET_TERM_SIG))
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
    GNUNET_OS_process_wait (h->server_proc);
    GNUNET_OS_process_destroy (h->server_proc);
    h->server_proc = NULL;
    GNUNET_DISK_pipe_close (h->server_stdout);
    h->server_stdout = NULL;
    h->server_stdout_handle = NULL;
  }
  if (NULL != h->server_stdout)
  {
    GNUNET_DISK_pipe_close (h->server_stdout);
    h->server_stdout = NULL;
    h->server_stdout_handle = NULL;
  }
  GNUNET_free (h);
}

References GNUNET_DISK_pipe_close(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror, GNUNET_OS_process_destroy(), GNUNET_OS_process_kill(), GNUNET_OS_process_wait(), GNUNET_SCHEDULER_cancel(), GNUNET_TERM_SIG, and h.

Referenced by free_lal(), and GN_start_gnunet_nat_server_().

Here is the call graph for this function:

Here is the caller graph for this function:

GN_request_connection_reversal()

int GN_request_connection_reversal	(	const struct in_addr *	internal_address,
		uint16_t	internal_port,
		const struct in_addr *	remote_v4,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

We want to connect to a peer that is behind NAT.

Run the gnunet-helper-nat-client to send dummy ICMP responses to cause that peer to connect to us (connection reversal).

Parameters

internal_address	out internal address to use
internal_port	port to use
remote_v4	the address of the peer (IPv4-only)
cfg	handle to the GNUnet configuration

Returns

GNUNET_SYSERR on error, GNUNET_OK otherwise

Definition at line 345 of file gnunet-service-nat_helper.c.

{
  char intv4[INET_ADDRSTRLEN];
  char remv4[INET_ADDRSTRLEN];
  char port_as_string[6];
  struct GNUNET_OS_Process *proc;
  char *binary;
 
  if (NULL == inet_ntop (AF_INET, internal_address, intv4, INET_ADDRSTRLEN))
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
    return GNUNET_SYSERR;
  }
  if (NULL == inet_ntop (AF_INET, remote_v4, remv4, INET_ADDRSTRLEN))
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
    return GNUNET_SYSERR;
  }
  GNUNET_snprintf (port_as_string,
                   sizeof(port_as_string),
                   "%d",
                   internal_port);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Running gnunet-helper-nat-client %s %s %u\n",
              intv4,
              remv4,
              internal_port);
  binary = GNUNET_OS_get_suid_binary_path (GNUNET_OS_project_data_gnunet (),
                                           cfg,
                                           "gnunet-helper-nat-client");
  proc = GNUNET_OS_start_process (GNUNET_OS_INHERIT_STD_NONE,
                                  NULL,
                                  NULL,
                                  NULL,
                                  binary,
                                  "gnunet-helper-nat-client",
                                  intv4,
                                  remv4,
                                  port_as_string,
                                  NULL);
  GNUNET_free (binary);
  if (NULL == proc)
    return GNUNET_SYSERR;
  /* we know that the gnunet-helper-nat-client will terminate virtually
   * instantly */
  GNUNET_OS_process_wait (proc);
  GNUNET_OS_process_destroy (proc);
  return GNUNET_OK;
}

References cfg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_strerror, GNUNET_OK, GNUNET_OS_get_suid_binary_path(), GNUNET_OS_INHERIT_STD_NONE, GNUNET_OS_process_destroy(), GNUNET_OS_process_wait(), GNUNET_OS_project_data_gnunet(), GNUNET_OS_start_process(), GNUNET_snprintf(), and GNUNET_SYSERR.

Referenced by handle_request_connection_reversal().

Here is the call graph for this function:

Here is the caller graph for this function: