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 */