gnunet-service-nat_externalip.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2009, 2015, 2016, 2017 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 <math.h>
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_statistics_service.h"
#include "gnunet_resolver_service.h"
#include "gnunet_nat_service.h"
#include "gnunet-service-nat.h"
#include "gnunet-service-nat_externalip.h"
#include "gnunet-service-nat_stun.h"
#include "gnunet-service-nat_mini.h"
#include "gnunet-service-nat_helper.h"
#include "nat.h"
#include <gcrypt.h>


#define EXTERN_IP_RETRY_TIMEOUT GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_MINUTES, 15)

#define EXTERN_IP_RETRY_FAILURE GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_MINUTES, 30)

#define EXTERN_IP_RETRY_SUCCESS GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_MINUTES, 5)


struct GN_ExternalIPMonitor
{
  struct GN_ExternalIPMonitor *next;

  struct GN_ExternalIPMonitor *prev;

  GN_NotifyExternalIPv4Change cb;

  void *cb_cls;
};


static struct GN_ExternalIPMonitor *mon_head;

static struct GN_ExternalIPMonitor *mon_tail;

static struct GNUNET_SCHEDULER_Task *probe_external_ip_task;

static struct GNUNET_NAT_ExternalHandle *probe_external_ip_op;

static struct in_addr mini_external_ipv4;


static void
notify_monitors_external_ipv4_change (int add,
                                      const struct in_addr *v4)
{
  for (struct GN_ExternalIPMonitor *mon = mon_head;
       NULL != mon;
       mon = mon->next)
    mon->cb (mon->cb_cls,
             v4,
             add);
}


static void
run_external_ip (void *cls);


static void
handle_external_ip (void *cls,
                    const struct in_addr *addr,
                    enum GNUNET_NAT_StatusCode result)
{
  char buf[INET_ADDRSTRLEN];

  probe_external_ip_op = NULL;
  GNUNET_SCHEDULER_cancel (probe_external_ip_task);
  probe_external_ip_task
    = GNUNET_SCHEDULER_add_delayed ((NULL == addr)
                                    ? EXTERN_IP_RETRY_FAILURE
                                    : EXTERN_IP_RETRY_SUCCESS,
                                    &run_external_ip,
                                    NULL);
  switch (result)
  {
  case GNUNET_NAT_ERROR_SUCCESS:
    GNUNET_assert (NULL != addr);
    if (addr->s_addr == mini_external_ipv4.s_addr)
      return;   /* not change */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Our external IP is now %s\n",
                inet_ntop (AF_INET,
                           addr,
                           buf,
                           sizeof(buf)));
    if (0 != mini_external_ipv4.s_addr)
      notify_monitors_external_ipv4_change (GNUNET_NO,
                                            &mini_external_ipv4);
    mini_external_ipv4 = *addr;
    notify_monitors_external_ipv4_change (GNUNET_YES,
                                          &mini_external_ipv4);
    break;

  default:
    if (0 != mini_external_ipv4.s_addr)
      notify_monitors_external_ipv4_change (GNUNET_NO,
                                            &mini_external_ipv4);
    mini_external_ipv4.s_addr = 0;
    break;
  }
}


static void
run_external_ip (void *cls)
{
  probe_external_ip_task
    = GNUNET_SCHEDULER_add_delayed (EXTERN_IP_RETRY_TIMEOUT,
                                    &run_external_ip,
                                    NULL);
  if (NULL != probe_external_ip_op)
  {
    GNUNET_NAT_mini_get_external_ipv4_cancel_ (probe_external_ip_op);
    probe_external_ip_op = NULL;
  }
  probe_external_ip_op
    = GNUNET_NAT_mini_get_external_ipv4_ (&handle_external_ip,
                                          NULL);
}


void
GN_nat_status_changed (int have_nat)
{
  if (GNUNET_YES != enable_upnp)
    return;
  if ((GNUNET_YES == have_nat) &&
      (NULL == probe_external_ip_task) &&
      (NULL == probe_external_ip_op))
  {
    probe_external_ip_task
      = GNUNET_SCHEDULER_add_now (&run_external_ip,
                                  NULL);
    return;
  }
  if (GNUNET_NO == have_nat)
  {
    if (NULL != probe_external_ip_task)
    {
      GNUNET_SCHEDULER_cancel (probe_external_ip_task);
      probe_external_ip_task = NULL;
    }
    if (NULL != probe_external_ip_op)
    {
      GNUNET_NAT_mini_get_external_ipv4_cancel_ (probe_external_ip_op);
      probe_external_ip_op = NULL;
    }
  }
}


struct GN_ExternalIPMonitor *
GN_external_ipv4_monitor_start (GN_NotifyExternalIPv4Change cb,
                                void *cb_cls)
{
  struct GN_ExternalIPMonitor *mon;

  mon = GNUNET_new (struct GN_ExternalIPMonitor);
  mon->cb = cb;
  mon->cb_cls = cb_cls;
  GNUNET_CONTAINER_DLL_insert (mon_head,
                               mon_tail,
                               mon);
  if (0 != mini_external_ipv4.s_addr)
    cb (cb_cls,
        &mini_external_ipv4,
        GNUNET_YES);
  return mon;
}


void
GN_external_ipv4_monitor_stop (struct GN_ExternalIPMonitor *mon)
{
  GNUNET_CONTAINER_DLL_remove (mon_head,
                               mon_tail,
                               mon);
  GNUNET_free (mon);
}


/* end of gnunet-service-nat_externalip.c */