gnunet-service-nat_helper.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2009, 2010, 2011, 2016 GNUnet e.V.
 
     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     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
     Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
 
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet-service-nat_helper.h"
 
 
struct HelperContext
{
  struct in_addr internal_address;
 
  GN_ReversalCallback cb;
 
  void *cb_cls;
 
  struct GNUNET_TIME_Relative server_retry_delay;
 
  struct GNUNET_SCHEDULER_Task *server_read_task;
 
  struct GNUNET_OS_Process *server_proc;
 
  struct GNUNET_DISK_PipeHandle *server_stdout;
 
  const struct GNUNET_DISK_FileHandle *server_stdout_handle;
 
  const struct GNUNET_CONFIGURATION_Handle *cfg;
};
 
 
static void
restart_nat_server (void *cls);
 
 
static void
try_again (struct HelperContext *h)
{
  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);
}
 
 
static void
nat_server_read (void *cls)
{
  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);
}
 
 
static void
restart_nat_server (void *cls)
{
  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 (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);
}
 
 
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)
{
  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;
}
 
 
void
GN_stop_gnunet_nat_server_ (struct HelperContext *h)
{
  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);
}
 
 
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)
{
  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 (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;
}
 
 
/* end of gnunet-service-nat_helper.c */