This file is part of GNUnet.
Copyright (C) 2016, 2017 GNUnet e.V.
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ 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
- General Public License for more details.
+ 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/>.
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA.
+ SPDX-License-Identifier: AGPL3.0-or-later
*/
/**
* @brief network address translation traversal service
* @author Christian Grothoff
*
- * The purpose of this service is to enable transports to
+ * The purpose of this service is to enable transports to
* traverse NAT routers, by providing traversal options and
* knowledge about the local network topology.
*
* TODO:
- * - test ICMP based NAT traversal
- * - implement "more" autoconfig:
- * re-work gnunet-nat-server & integrate!
+ * - migrate test cases to new NAT service
+ * - add new traceroute-based logic for external IP detection
+ *
* - implement & test STUN processing to classify NAT;
* basically, open port & try different methods.
- * - implement NEW logic for external IP detection
*/
#include "platform.h"
#include <math.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"
#define AUTOCONFIG_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
/**
- * How long do we wait until we re-try running `external-ip` if the
- * command failed to terminate nicely?
- */
-#define EXTERN_IP_RETRY_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
-
-/**
- * How long do we wait until we re-try running `external-ip` if the
- * command failed (but terminated)?
+ * How often do we scan for changes in how our external (dyndns) hostname resolves?
*/
-#define EXTERN_IP_RETRY_FAILURE GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30)
-
-/**
- * How long do we wait until we re-try running `external-ip` if the
- * command succeeded?
- */
-#define EXTERN_IP_RETRY_SUCCESS GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
+#define DYNDNS_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 7)
/**
- * Information we track per client address.
+ * Information we track per client address.
*/
struct ClientAddress
{
* pending.
*/
struct GNUNET_NAT_MiniHandle *mh;
-
+
+};
+
+
+/**
+ * List of local addresses this system has.
+ */
+struct LocalAddressList
+{
+ /**
+ * This is a linked list.
+ */
+ struct LocalAddressList *next;
+
+ /**
+ * Previous entry.
+ */
+ struct LocalAddressList *prev;
+
+ /**
+ * Context for a gnunet-helper-nat-server used to listen
+ * for ICMP messages to this client for connection reversal.
+ */
+ struct HelperContext *hc;
+
+ /**
+ * The address itself (i.e. `struct sockaddr_in` or `struct
+ * sockaddr_in6`, in the respective byte order).
+ */
+ struct sockaddr_storage addr;
+
+ /**
+ * Address family. (FIXME: redundant, addr.ss_family! Remove!?)
+ */
+ int af;
+
+ /**
+ * #GNUNET_YES if we saw this one in the previous iteration,
+ * but not in the current iteration and thus might need to
+ * remove it at the end.
+ */
+ int old;
+
+ /**
+ * What type of address is this?
+ */
+ enum GNUNET_NAT_AddressClass ac;
+
};
* Kept in a DLL.
*/
struct ClientHandle *next;
-
+
/**
* Kept in a DLL.
*/
/**
* Underlying handle for this client with the service.
- */
+ */
struct GNUNET_SERVICE_Client *client;
/**
* Array of addresses used by the service.
*/
struct ClientAddress *caddrs;
-
+
/**
- * What does this client care about?
+ * External DNS name and port given by user due to manual
+ * hole punching. Special DNS name 'AUTO' is used to indicate
+ * desire for automatic determination of the external IP
+ * (instead of DNS or manual configuration, i.e. to be used
+ * if the IP keeps changing and we have no DynDNS, but we do
+ * have a hole punched).
*/
- enum GNUNET_NAT_RegisterFlags flags;
+ char *hole_external;
/**
- * Is any of the @e caddrs in a reserved subnet for NAT?
+ * Name of the configuration section this client cares about.
*/
- int natted_address;
-
+ char *section_name;
+
/**
- * Port we would like as we are configured to use this one for
- * advertising (in addition to the one we are binding to).
+ * Task for periodically re-running the @e ext_dns DNS lookup.
*/
- uint16_t adv_port;
+ struct GNUNET_SCHEDULER_Task *ext_dns_task;
/**
- * Number of addresses that this service is bound to.
- * Length of the @e caddrs array.
+ * Handle for (DYN)DNS lookup of our external IP as given in
+ * @e hole_external.
*/
- uint16_t num_caddrs;
-
+ struct GNUNET_RESOLVER_RequestHandle *ext_dns;
+
/**
- * Client's IPPROTO, e.g. IPPROTO_UDP or IPPROTO_TCP.
+ * Handle for monitoring external IP changes.
*/
- uint8_t proto;
-
-};
+ struct GN_ExternalIPMonitor *external_monitor;
+ /**
+ * DLL of external IP addresses as given in @e hole_external.
+ */
+ struct LocalAddressList *ext_addr_head;
-/**
- * List of local addresses this system has.
- */
-struct LocalAddressList
-{
/**
- * This is a linked list.
+ * DLL of external IP addresses as given in @e hole_external.
*/
- struct LocalAddressList *next;
+ struct LocalAddressList *ext_addr_tail;
/**
- * Previous entry.
+ * Port number we found in @e hole_external.
*/
- struct LocalAddressList *prev;
+ uint16_t ext_dns_port;
/**
- * Context for a gnunet-helper-nat-server used to listen
- * for ICMP messages to this client for connection reversal.
+ * What does this client care about?
*/
- struct HelperContext *hc;
-
+ enum GNUNET_NAT_RegisterFlags flags;
+
/**
- * The address itself (i.e. `struct sockaddr_in` or `struct
- * sockaddr_in6`, in the respective byte order).
+ * Is any of the @e caddrs in a reserved subnet for NAT?
*/
- struct sockaddr_storage addr;
+ int natted_address;
/**
- * Address family.
+ * Number of addresses that this service is bound to.
+ * Length of the @e caddrs array.
*/
- int af;
+ uint16_t num_caddrs;
/**
- * What type of address is this?
+ * Client's IPPROTO, e.g. IPPROTO_UDP or IPPROTO_TCP.
*/
- enum GNUNET_NAT_AddressClass ac;
-
+ uint8_t proto;
+
};
{
/**
* Kept in a DLL.
- */
+ */
struct StunExternalIP *next;
/**
* Kept in a DLL.
- */
+ */
struct StunExternalIP *prev;
/**
struct GNUNET_SCHEDULER_Task *timeout_task;
/**
- * Our external IP address as reported by the
+ * Our external IP address as reported by the
* STUN server.
*/
struct sockaddr_in external_addr;
/**
- * Address of the reporting STUN server. Used to
+ * Address of the reporting STUN server. Used to
* detect when a STUN server changes its opinion
* to more quickly remove stale results.
*/
/**
- * Context for autoconfiguration operations.
- */
-struct AutoconfigContext
-{
- /**
- * Kept in a DLL.
- */
- struct AutoconfigContext *prev;
-
- /**
- * Kept in a DLL.
- */
- struct AutoconfigContext *next;
-
- /**
- * Which client asked the question.
- */
- struct ClientHandle *ch;
-
- /**
- * Configuration we are creating.
- */
- struct GNUNET_CONFIGURATION_Handle *c;
-
- /**
- * Original configuration (for diffing).
- */
- struct GNUNET_CONFIGURATION_Handle *orig;
-
- /**
- * Timeout task to force termination.
- */
- struct GNUNET_SCHEDULER_Task *timeout_task;
-
- /**
- * What type of system are we on?
- */
- char *system_type;
-
- /**
- * Handle to activity to probe for our external IP.
- */
- struct GNUNET_NAT_ExternalHandle *probe_external;
-
- /**
- * #GNUNET_YES if upnpc should be used,
- * #GNUNET_NO if upnpc should not be used,
- * #GNUNET_SYSERR if we should simply not change the option.
- */
- int enable_upnpc;
-
- /**
- * Status code to return to the client.
- */
- enum GNUNET_NAT_StatusCode status_code;
-
- /**
- * NAT type to return to the client.
- */
- enum GNUNET_NAT_Type type;
-};
-
-
-/**
- * DLL of our autoconfiguration operations.
- */
-static struct AutoconfigContext *ac_head;
-
-/**
- * DLL of our autoconfiguration operations.
+ * Timeout to use when STUN data is considered stale.
*/
-static struct AutoconfigContext *ac_tail;
+static struct GNUNET_TIME_Relative stun_stale_timeout;
/**
- * Timeout to use when STUN data is considered stale.
+ * How often do we scan for changes in how our external (dyndns) hostname resolves?
*/
-static struct GNUNET_TIME_Relative stun_stale_timeout;
+static struct GNUNET_TIME_Relative dyndns_frequency;
/**
* Handle to our current configuration.
* Head of client DLL.
*/
static struct ClientHandle *ch_head;
-
+
/**
* Tail of client DLL.
*/
/**
* Kept in a DLL.
- */
+ */
static struct StunExternalIP *se_head;
/**
* Kept in a DLL.
- */
+ */
static struct StunExternalIP *se_tail;
/**
* Is UPnP enabled? #GNUNET_YES if enabled, #GNUNET_NO if disabled,
* #GNUNET_SYSERR if configuration enabled but binary is unavailable.
*/
-static int enable_upnp;
+int enable_upnp;
-/**
- * Task run to obtain our external IP (if #enable_upnp is set
- * and if we find we have a NATed IP address).
- */
-static struct GNUNET_SCHEDULER_Task *probe_external_ip_task;
/**
- * Handle to our operation to run `external-ip`.
+ * Remove and free an entry from the #lal_head DLL.
+ *
+ * @param lal entry to free
*/
-static struct GNUNET_NAT_ExternalHandle *probe_external_ip_op;
+static void
+free_lal (struct LocalAddressList *lal)
+{
+ GNUNET_CONTAINER_DLL_remove (lal_head,
+ lal_tail,
+ lal);
+ if (NULL != lal->hc)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
+ "Lost NATed local address %s, stopping NAT server\n",
+ GNUNET_a2s ((const struct sockaddr *) &lal->addr,
+ sizeof (struct sockaddr_in)));
-/**
- * What is our external IP address as claimed by `external-ip`?
- * 0 for unknown.
- */
-static struct in_addr mini_external_ipv4;
+ GN_stop_gnunet_nat_server_ (lal->hc);
+ lal->hc = NULL;
+ }
+ GNUNET_free (lal);
+}
/**
* Free the DLL starting at #lal_head.
- */
+ */
static void
destroy_lal ()
{
struct LocalAddressList *lal;
while (NULL != (lal = lal_head))
- {
- GNUNET_CONTAINER_DLL_remove (lal_head,
- lal_tail,
- lal);
- if (NULL != lal->hc)
- {
- GN_stop_gnunet_nat_server_ (lal->hc);
- lal->hc = NULL;
- }
- GNUNET_free (lal);
- }
+ free_lal (lal);
}
#endif
default:
GNUNET_break (0);
- return GNUNET_SYSERR;
+ return GNUNET_SYSERR;
}
if (alen > left)
{
GNUNET_break (0);
- return GNUNET_SYSERR;
+ return GNUNET_SYSERR;
}
- }
- return GNUNET_OK;
+ off += alen;
+ left -= alen;
+ }
+ if (left != ntohs (message->str_len))
+ {
+ GNUNET_break (0);
+ return GNUNET_SYSERR;
+ }
+ return GNUNET_OK;
}
struct in6_addr net;
struct in6_addr mask;
unsigned int off;
-
+
if (0 == bits)
return GNUNET_YES;
GNUNET_assert (1 == inet_pton (AF_INET6,
network,
&net));
memset (&mask, 0, sizeof (mask));
- if (0 == memcmp (&mask,
- ip,
- sizeof (mask)))
+ if (0 == GNUNET_memcmp (&mask,
+ ip))
return GNUNET_YES;
off = 0;
while (bits > 8)
struct IfcProcContext
{
- /**
+ /**
* Head of DLL of local addresses.
*/
struct LocalAddressList *lal_head;
{
struct GNUNET_MQ_Envelope *env;
struct GNUNET_NAT_AddressChangeNotificationMessage *msg;
-
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Notifying client about %s of IP %s\n",
+ add ? "addition" : "removal",
+ GNUNET_a2s (addr,
+ addr_len));
env = GNUNET_MQ_msg_extra (msg,
addr_len,
GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE);
addr_len);
GNUNET_MQ_send (ch->mq,
env);
-}
+}
/**
size_t alen;
struct sockaddr_in v4;
struct sockaddr_in6 v6;
-
+
if (0 == (ch->flags & GNUNET_NAT_RF_ADDRESSES))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Not notifying client as it does not care about addresses\n");
return;
+ }
switch (delta->af)
{
case AF_INET:
GNUNET_memcpy (&v4,
&delta->addr,
alen);
-
+
/* Check for client notifications */
for (unsigned int i=0;i<ch->num_caddrs;i++)
{
const struct sockaddr_in *c4;
if (AF_INET != ch->caddrs[i].ss.ss_family)
- return; /* IPv4 not relevant */
+ continue; /* IPv4 not relevant */
c4 = (const struct sockaddr_in *) &ch->caddrs[i].ss;
if ( match_ipv4 ("127.0.0.1", &c4->sin_addr, 8) &&
(0 != c4->sin_addr.s_addr) &&
(! match_ipv4 ("127.0.0.1", &v4.sin_addr, 8)) )
continue; /* bound to loopback, but this is not loopback */
if ( (! match_ipv4 ("127.0.0.1", &c4->sin_addr, 8) ) &&
- (0 != c4->sin_addr.s_addr) &&
match_ipv4 ("127.0.0.1", &v4.sin_addr, 8) )
continue; /* bound to non-loopback, but this is loopback */
- if ( (0 != (ch->flags & GNUNET_NAT_AC_EXTERN)) &&
- (0 != c4->sin_addr.s_addr) &&
- (! is_nat_v4 (&v4.sin_addr)) )
- continue; /* based on external-IP, but this IP is not
- from private address range. */
- if ( (0 != memcmp (&v4.sin_addr,
- &c4->sin_addr,
- sizeof (struct in_addr))) &&
- (0 != c4->sin_addr.s_addr) &&
- ( (! is_nat_v4 (&c4->sin_addr)) ||
- (0 == (ch->flags & GNUNET_NAT_AC_EXTERN))) )
+ if ( (0 != (delta->ac & GNUNET_NAT_AC_EXTERN)) &&
+ (0 != c4->sin_addr.s_addr) &&
+ (! is_nat_v4 (&v4.sin_addr)) )
+ continue; /* based on external-IP, but this IP is not
+ from private address range. */
+ if ( (0 != GNUNET_memcmp (&v4.sin_addr,
+ &c4->sin_addr)) &&
+ (0 != c4->sin_addr.s_addr) &&
+ (! is_nat_v4 (&c4->sin_addr)) )
continue; /* this IP is not from private address range,
and IP does not match. */
/* OK, IP seems relevant, notify client */
- v4.sin_port = c4->sin_port;
+ if (0 == htons (v4.sin_port))
+ v4.sin_port = c4->sin_port;
notify_client (delta->ac,
ch,
add,
for (unsigned int i=0;i<ch->num_caddrs;i++)
{
const struct sockaddr_in6 *c6;
-
+
if (AF_INET6 != ch->caddrs[i].ss.ss_family)
- return; /* IPv4 not relevant */
+ continue; /* IPv4 not relevant */
c6 = (const struct sockaddr_in6 *) &ch->caddrs[i].ss;
if ( match_ipv6 ("::1", &c6->sin6_addr, 128) &&
- (0 != memcmp (&c6->sin6_addr,
- &in6addr_any,
- sizeof (struct in6_addr))) &&
+ (0 != GNUNET_memcmp (&c6->sin6_addr,
+ &in6addr_any)) &&
(! match_ipv6 ("::1", &v6.sin6_addr, 128)) )
continue; /* bound to loopback, but this is not loopback */
if ( (! match_ipv6 ("::1", &c6->sin6_addr, 128) ) &&
- (0 != memcmp (&c6->sin6_addr,
- &in6addr_any,
- sizeof (struct in6_addr))) &&
match_ipv6 ("::1", &v6.sin6_addr, 128) )
continue; /* bound to non-loopback, but this is loopback */
- if ( (0 != (ch->flags & GNUNET_NAT_AC_EXTERN)) &&
- (0 != memcmp (&c6->sin6_addr,
- &in6addr_any,
- sizeof (struct in6_addr))) &&
+ if ( (0 != (delta->ac & GNUNET_NAT_AC_EXTERN)) &&
+ (0 != GNUNET_memcmp (&c6->sin6_addr,
+ &in6addr_any)) &&
(! is_nat_v6 (&v6.sin6_addr)) )
continue; /* based on external-IP, but this IP is not
from private address range. */
- if ( (0 != memcmp (&v6.sin6_addr,
- &c6->sin6_addr,
- sizeof (struct in6_addr))) &&
- (0 != memcmp (&c6->sin6_addr,
- &in6addr_any,
- sizeof (struct in6_addr))) &&
+ if ( (0 != GNUNET_memcmp (&v6.sin6_addr,
+ &c6->sin6_addr)) &&
+ (0 != GNUNET_memcmp (&c6->sin6_addr,
+ &in6addr_any)) &&
(! is_nat_v6 (&c6->sin6_addr)) )
continue; /* this IP is not from private address range,
and IP does not match. */
if ( (match_ipv6 ("fe80::", &c6->sin6_addr, 10)) &&
- (0 != memcmp (&c6->sin6_addr,
- &in6addr_any,
- sizeof (struct in6_addr))) &&
- (0 != memcmp (&v6.sin6_addr,
- &c6->sin6_addr,
- sizeof (struct in6_addr))) &&
+ (0 != GNUNET_memcmp (&c6->sin6_addr,
+ &in6addr_any)) &&
+ (0 != GNUNET_memcmp (&v6.sin6_addr,
+ &c6->sin6_addr)) &&
(0 == (delta->ac & GNUNET_NAT_AC_EXTERN)) )
continue; /* client bound to link-local, and the other address
does not match and is not an external IP */
/* OK, IP seems relevant, notify client */
- v6.sin6_port = c6->sin6_port;
+ if (0 == htons (v6.sin6_port))
+ v6.sin6_port = c6->sin6_port;
notify_client (delta->ac,
ch,
add,
/**
* Tell relevant client about a change in our external
* IPv4 address.
- *
+ *
+ * @param cls client to check if it cares and possibly notify
* @param v4 the external address that changed
- * @param ch client to check if it cares and possibly notify
* @param add #GNUNET_YES to add, #GNUNET_NO to remove
*/
static void
-check_notify_client_external_ipv4_change (const struct in_addr *v4,
- struct ClientHandle *ch,
- int add)
+notify_client_external_ipv4_change (void *cls,
+ const struct in_addr *v4,
+ int add)
{
+ struct ClientHandle *ch = cls;
struct sockaddr_in sa;
- uint16_t port;
- uint16_t bport;
+ int have_v4;
+
+ /* (0) check if this impacts 'hole_external' */
+ if ( (NULL != ch->hole_external) &&
+ (0 == strcasecmp (ch->hole_external,
+ "AUTO")) )
+ {
+ struct LocalAddressList lal;
+ struct sockaddr_in *s4;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Detected eternal IP, can now back-fill AUTO:%u in hole punching specification of `%s'\n",
+ (unsigned int) ch->ext_dns_port,
+ ch->section_name);
+ memset (&lal, 0, sizeof (lal));
+ s4 = (struct sockaddr_in *) &lal.addr;
+ s4->sin_family = AF_INET;
+ s4->sin_port = htons (ch->ext_dns_port);
+ s4->sin_addr = *v4;
+ lal.af = AF_INET;
+ lal.ac = GNUNET_NAT_AC_GLOBAL | GNUNET_NAT_AC_MANUAL;
+ check_notify_client (&lal,
+ ch,
+ add);
+ }
/* (1) check if client cares. */
if (! ch->natted_address)
return;
- if (0 == (GNUNET_NAT_RF_ADDRESSES & ch->flags))
- return;
- bport = 0;
+ have_v4 = GNUNET_NO;
for (unsigned int i=0;i<ch->num_caddrs;i++)
{
const struct sockaddr_storage *ss = &ch->caddrs[i].ss;
if (AF_INET != ss->ss_family)
continue;
- bport = ntohs (((const struct sockaddr_in *) ss)->sin_port);
+ have_v4 = GNUNET_YES;
+ break;
}
- if (0 == bport)
+ if (GNUNET_NO == have_v4)
return; /* IPv6-only */
-
- /* (2) figure out external port, build sockaddr */
- port = ch->adv_port;
- if (0 == port)
- port = bport;
+
+ /* (2) build address info */
memset (&sa,
0,
sizeof (sa));
sa.sin_family = AF_INET;
sa.sin_addr = *v4;
- sa.sin_port = htons (port);
-
+ sa.sin_port = htons (0);
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Detected eternal IP %s, notifying client of external IP (without port)\n",
+ GNUNET_a2s ((const struct sockaddr *) &sa,
+ sizeof (sa)));
/* (3) notify client of change */
notify_client (is_nat_v4 (v4)
- ? GNUNET_NAT_AC_EXTERN | GNUNET_NAT_AC_LAN
+ ? GNUNET_NAT_AC_EXTERN | GNUNET_NAT_AC_LAN
: GNUNET_NAT_AC_EXTERN | GNUNET_NAT_AC_GLOBAL,
ch,
add,
}
-/**
- * Tell relevant clients about a change in our external
- * IPv4 address.
- *
- * @param add #GNUNET_YES to add, #GNUNET_NO to remove
- * @param v4 the external address that changed
- */
-static void
-notify_clients_external_ipv4_change (int add,
- const struct in_addr *v4)
-{
- for (struct ClientHandle *ch = ch_head;
- NULL != ch;
- ch = ch->next)
- check_notify_client_external_ipv4_change (v4,
- ch,
- add);
-}
-
-
-/**
- * Task used to run `external-ip` to get our external IPv4
- * address and pass it to NATed clients if possible.
- *
- * @param cls NULL
- */
-static void
-run_external_ip (void *cls);
-
-
-/**
- * We learn our current external IP address. If it changed,
- * notify all of our applicable clients. Also re-schedule
- * #run_external_ip with an appropriate timeout.
- *
- * @param cls NULL
- * @param addr the address, NULL on errors
- * @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code
- */
-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:
- 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_clients_external_ipv4_change (GNUNET_NO,
- &mini_external_ipv4);
- mini_external_ipv4 = *addr;
- notify_clients_external_ipv4_change (GNUNET_YES,
- &mini_external_ipv4);
- break;
- default:
- if (0 != mini_external_ipv4.s_addr)
- notify_clients_external_ipv4_change (GNUNET_NO,
- &mini_external_ipv4);
- mini_external_ipv4.s_addr = 0;
- break;
- }
-}
-
-
-/**
- * Task used to run `external-ip` to get our external IPv4
- * address and pass it to NATed clients if possible.
- *
- * @param cls NULL
- */
-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);
-}
-
-
/**
* We got a connection reversal request from another peer.
* Notify applicable clients.
*
- * @param cls closure with the `struct LocalAddressList`
- * @param ra IP address of the peer who wants us to connect to it
+ * @param cls closure with the `struct LocalAddressList`
+ * @param ra IP address of the peer who wants us to connect to it
*/
static void
reversal_callback (void *cls,
for (struct ClientHandle *ch = ch_head;
NULL != ch;
ch = ch->next)
- {
+ {
struct GNUNET_NAT_ConnectionReversalRequestedMessage *crrm;
struct GNUNET_MQ_Envelope *env;
int match;
{
struct ClientAddress *ca = &ch->caddrs[i];
const struct sockaddr_in *c4;
-
+
if (AF_INET != ca->ss.ss_family)
continue;
c4 = (const struct sockaddr_in *) &ca->ss;
* Task we run periodically to scan for network interfaces.
*
* @param cls NULL
- */
+ */
static void
run_scan (void *cls)
{
struct IfcProcContext ifc_ctx;
int found;
int have_nat;
-
+ struct LocalAddressList *lnext;
+
scan_task = GNUNET_SCHEDULER_add_delayed (SCAN_FREQ,
&run_scan,
NULL);
/* remove addresses that disappeared */
for (struct LocalAddressList *lal = lal_head;
NULL != lal;
- lal = lal->next)
+ lal = lnext)
{
+ lnext = lal->next;
found = GNUNET_NO;
for (struct LocalAddressList *pos = ifc_ctx.lal_head;
NULL != pos;
: sizeof (struct sockaddr_in6))) )
{
found = GNUNET_YES;
- pos->hc = lal->hc;
- lal->hc = NULL;
}
}
if (GNUNET_NO == found)
+ {
notify_clients (lal,
GNUNET_NO);
+ free_lal (lal);
+ }
}
/* add addresses that appeared */
have_nat = GNUNET_NO;
for (struct LocalAddressList *pos = ifc_ctx.lal_head;
NULL != pos;
- pos = pos->next)
+ pos = ifc_ctx.lal_head)
{
found = GNUNET_NO;
if (GNUNET_NAT_AC_LAN == (GNUNET_NAT_AC_LAN & pos->ac))
: sizeof (struct sockaddr_in6))) )
found = GNUNET_YES;
}
- if (GNUNET_NO == found)
- notify_clients (pos,
- GNUNET_YES);
- if ( (AF_INET == pos->af) &&
- (NULL == pos->hc) &&
- (0 != (GNUNET_NAT_AC_LAN & pos->ac)) )
- {
- const struct sockaddr_in *s4
- = (const struct sockaddr_in *) &pos->addr;
-
- pos->hc = GN_start_gnunet_nat_server_ (&s4->sin_addr,
- &reversal_callback,
- pos);
- }
- }
- if ( (GNUNET_YES == have_nat) &&
- (GNUNET_YES == enable_upnp) &&
- (NULL == probe_external_ip_task) &&
- (NULL == probe_external_ip_op) )
- {
- probe_external_ip_task
- = GNUNET_SCHEDULER_add_now (&run_external_ip,
- NULL);
- }
- if ( (GNUNET_NO == have_nat) &&
- (GNUNET_YES == enable_upnp) )
- {
- if (NULL != probe_external_ip_task)
+ GNUNET_CONTAINER_DLL_remove (ifc_ctx.lal_head,
+ ifc_ctx.lal_tail,
+ pos);
+ if (GNUNET_YES == found)
{
- GNUNET_SCHEDULER_cancel (probe_external_ip_task);
- probe_external_ip_task = NULL;
+ GNUNET_free (pos);
}
- if (NULL != probe_external_ip_op)
+ else
{
- GNUNET_NAT_mini_get_external_ipv4_cancel_ (probe_external_ip_op);
- probe_external_ip_op = NULL;
+ notify_clients (pos,
+ GNUNET_YES);
+ GNUNET_CONTAINER_DLL_insert (lal_head,
+ lal_tail,
+ pos);
+ if ( (AF_INET == pos->af) &&
+ (NULL == pos->hc) &&
+ (0 != (GNUNET_NAT_AC_LAN & pos->ac)) )
+ {
+ const struct sockaddr_in *s4
+ = (const struct sockaddr_in *) &pos->addr;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Found NATed local address %s, starting NAT server\n",
+ GNUNET_a2s ((const struct sockaddr *) &pos->addr,
+ sizeof (*s4)));
+ pos->hc = GN_start_gnunet_nat_server_ (&s4->sin_addr,
+ &reversal_callback,
+ pos);
+ }
}
}
-
- destroy_lal ();
- lal_head = ifc_ctx.lal_head;
- lal_tail = ifc_ctx.lal_tail;
+ GN_nat_status_changed (have_nat);
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"external-ip binary not found\n");
return;
+ case GNUNET_NAT_ERROR_UPNPC_NOT_FOUND:
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "upnpc binary not found\n");
+ return;
case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_FAILED:
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"external-ip binary could not be run\n");
}
+/**
+ * Resolve the `hole_external` name to figure out our
+ * external address from a manually punched hole. The
+ * port number has already been parsed, this task is
+ * responsible for periodically doing a DNS lookup.
+ *
+ * @param ch client handle to act upon
+ */
+static void
+dyndns_lookup (void *cls);
+
+
+/**
+ * Our (external) hostname was resolved. Update lists of
+ * current external IPs (note that DNS may return multiple
+ * addresses!) and notify client accordingly.
+ *
+ * @param cls the `struct ClientHandle`
+ * @param addr NULL on error, otherwise result of DNS lookup
+ * @param addrlen number of bytes in @a addr
+ */
+static void
+process_external_ip (void *cls,
+ const struct sockaddr *addr,
+ socklen_t addrlen)
+{
+ struct ClientHandle *ch = cls;
+ struct LocalAddressList *lal;
+ struct sockaddr_storage ss;
+ struct sockaddr_in *v4;
+ struct sockaddr_in6 *v6;
+
+ if (NULL == addr)
+ {
+ struct LocalAddressList *laln;
+
+ ch->ext_dns = NULL;
+ ch->ext_dns_task
+ = GNUNET_SCHEDULER_add_delayed (dyndns_frequency,
+ &dyndns_lookup,
+ ch);
+ /* Current iteration is over, remove 'old' IPs now */
+ for (lal = ch->ext_addr_head; NULL != lal; lal = laln)
+ {
+ laln = lal->next;
+ if (GNUNET_YES == lal->old)
+ {
+ GNUNET_CONTAINER_DLL_remove (ch->ext_addr_head,
+ ch->ext_addr_tail,
+ lal);
+ check_notify_client (lal,
+ ch,
+ GNUNET_NO);
+ GNUNET_free (lal);
+ }
+ }
+ return;
+ }
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Got IP `%s' for external address `%s'\n",
+ GNUNET_a2s (addr,
+ addrlen),
+ ch->hole_external);
+
+ /* build sockaddr storage with port number */
+ memset (&ss,
+ 0,
+ sizeof (ss));
+ GNUNET_memcpy (&ss,
+ addr,
+ addrlen);
+ switch (addr->sa_family)
+ {
+ case AF_INET:
+ v4 = (struct sockaddr_in *) &ss;
+ v4->sin_port = htons (ch->ext_dns_port);
+ break;
+ case AF_INET6:
+ v6 = (struct sockaddr_in6 *) &ss;
+ v6->sin6_port = htons (ch->ext_dns_port);
+ break;
+ default:
+ GNUNET_break (0);
+ return;
+ }
+ /* See if 'ss' matches any of our known addresses */
+ for (lal = ch->ext_addr_head; NULL != lal; lal = lal->next)
+ {
+ if (GNUNET_NO == lal->old)
+ continue; /* already processed, skip */
+ if ( (addr->sa_family == lal->addr.ss_family) &&
+ (0 == memcmp (&ss,
+ &lal->addr,
+ addrlen)) )
+ {
+ /* Address unchanged, remember so we do not remove */
+ lal->old = GNUNET_NO;
+ return; /* done here */
+ }
+ }
+ /* notify client, and remember IP for later removal! */
+ lal = GNUNET_new (struct LocalAddressList);
+ lal->addr = ss;
+ lal->af = ss.ss_family;
+ lal->ac = GNUNET_NAT_AC_GLOBAL | GNUNET_NAT_AC_MANUAL;
+ GNUNET_CONTAINER_DLL_insert (ch->ext_addr_head,
+ ch->ext_addr_tail,
+ lal);
+ check_notify_client (lal,
+ ch,
+ GNUNET_YES);
+}
+
+
+/**
+ * Resolve the `hole_external` name to figure out our
+ * external address from a manually punched hole. The
+ * port number has already been parsed, this task is
+ * responsible for periodically doing a DNS lookup.
+ *
+ * @param ch client handle to act upon
+ */
+static void
+dyndns_lookup (void *cls)
+{
+ struct ClientHandle *ch = cls;
+ struct LocalAddressList *lal;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Performing DNS lookup for punched hole given for `%s' as `%s:%u'\n",
+ ch->section_name,
+ ch->hole_external,
+ (unsigned int) ch->ext_dns_port);
+ for (lal = ch->ext_addr_head; NULL != lal; lal = lal->next)
+ lal->old = GNUNET_YES;
+ ch->ext_dns_task = NULL;
+ ch->ext_dns = GNUNET_RESOLVER_ip_get (ch->hole_external,
+ AF_UNSPEC,
+ GNUNET_TIME_UNIT_MINUTES,
+ &process_external_ip,
+ ch);
+}
+
+
+/**
+ * Resolve the `hole_external` name to figure out our
+ * external address from a manually punched hole. The
+ * given name may be "AUTO" in which case we should use
+ * the IP address(es) we have from upnpc or other methods.
+ * The name can also be an IP address, in which case we
+ * do not need to do DNS resolution. Finally, we also
+ * need to parse the port number.
+ *
+ * @param ch client handle to act upon
+ */
+static void
+lookup_hole_external (struct ClientHandle *ch)
+{
+ char *port;
+ unsigned int pnum;
+ struct sockaddr_in *s4;
+ struct LocalAddressList *lal;
+
+ port = strrchr (ch->hole_external, ':');
+ if (NULL == port)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Malformed punched hole specification `%s' (lacks port)\n"),
+ ch->hole_external);
+ return;
+ }
+ if ( (1 != sscanf (port + 1,
+ "%u",
+ &pnum)) ||
+ (pnum > 65535) )
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Invalid port number in punched hole specification `%s' (lacks port)\n"),
+ port + 1);
+ return;
+ }
+ ch->ext_dns_port = (uint16_t) pnum;
+ *port = '\0';
+
+ lal = GNUNET_new (struct LocalAddressList);
+ if ('[' == *ch->hole_external)
+ {
+ struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) &lal->addr;
+
+ s6->sin6_family = AF_INET6;
+ if (']' != (ch->hole_external[strlen(ch->hole_external)-1]))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Malformed punched hole specification `%s' (lacks `]')\n"),
+ ch->hole_external);
+ GNUNET_free (lal);
+ return;
+ }
+ ch->hole_external[strlen(ch->hole_external)-1] = '\0';
+ if (1 != inet_pton (AF_INET6,
+ ch->hole_external + 1,
+ &s6->sin6_addr))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Malformed punched hole specification `%s' (IPv6 address invalid)"),
+ ch->hole_external + 1);
+ GNUNET_free (lal);
+ return;
+ }
+ s6->sin6_port = htons (ch->ext_dns_port);
+ lal->af = AF_INET6;
+ lal->ac = GNUNET_NAT_AC_GLOBAL | GNUNET_NAT_AC_MANUAL;
+ GNUNET_CONTAINER_DLL_insert (ch->ext_addr_head,
+ ch->ext_addr_tail,
+ lal);
+ check_notify_client (lal,
+ ch,
+ GNUNET_YES);
+ return;
+ }
+
+ s4 = (struct sockaddr_in *) &lal->addr;
+ s4->sin_family = AF_INET;
+ if (1 == inet_pton (AF_INET,
+ ch->hole_external,
+ &s4->sin_addr))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "IPv4 punched hole given for `%s' via `%s:%u'\n",
+ ch->section_name,
+ ch->hole_external,
+ (unsigned int) ch->ext_dns_port);
+ s4->sin_port = htons (ch->ext_dns_port);
+ lal->af = AF_INET;
+ lal->ac = GNUNET_NAT_AC_GLOBAL | GNUNET_NAT_AC_MANUAL;
+ GNUNET_CONTAINER_DLL_insert (ch->ext_addr_head,
+ ch->ext_addr_tail,
+ lal);
+ check_notify_client (lal,
+ ch,
+ GNUNET_YES);
+ return;
+ }
+ if (0 == strcasecmp (ch->hole_external,
+ "AUTO"))
+ {
+ /* handled in #notify_client_external_ipv4_change() */
+ GNUNET_free (lal);
+ return;
+ }
+ /* got a DNS name, trigger lookup! */
+ GNUNET_free (lal);
+ ch->ext_dns_task
+ = GNUNET_SCHEDULER_add_now (&dyndns_lookup,
+ ch);
+}
+
+
/**
* Handler for #GNUNET_MESSAGE_TYPE_NAT_REGISTER message from client.
* We remember the client for updates upon future NAT events.
GNUNET_SERVICE_client_drop (ch->client);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received REGISTER message from client\n");
ch->flags = message->flags;
ch->proto = message->proto;
- ch->adv_port = ntohs (message->adv_port);
ch->num_caddrs = ntohs (message->num_addrs);
ch->caddrs = GNUNET_new_array (ch->num_caddrs,
struct ClientAddress);
off = (const char *) &message[1];
for (unsigned int i=0;i<ch->num_caddrs;i++)
{
- size_t alen;
const struct sockaddr *sa = (const struct sockaddr *) off;
+ size_t alen;
uint16_t port;
int is_nat;
{
case AF_INET:
{
- const struct sockaddr_in *s4 = (const struct sockaddr_in *) sa;
-
+ struct sockaddr_in s4;
+
+ GNUNET_memcpy (&s4,
+ off,
+ sizeof (struct sockaddr_in));
alen = sizeof (struct sockaddr_in);
- if (is_nat_v4 (&s4->sin_addr))
+ if (is_nat_v4 (&s4.sin_addr))
is_nat = GNUNET_YES;
- port = ntohs (s4->sin_port);
+ port = ntohs (s4.sin_port);
}
break;
case AF_INET6:
{
- const struct sockaddr_in6 *s6 = (const struct sockaddr_in6 *) sa;
-
+ struct sockaddr_in6 s6;
+
+ GNUNET_memcpy (&s6,
+ off,
+ sizeof (struct sockaddr_in6));
alen = sizeof (struct sockaddr_in6);
- if (is_nat_v6 (&s6->sin6_addr))
+ if (is_nat_v6 (&s6.sin6_addr))
is_nat = GNUNET_YES;
- port = ntohs (s6->sin6_port);
+ port = ntohs (s6.sin6_port);
}
break;
#if AF_UNIX
default:
GNUNET_break (0);
GNUNET_SERVICE_client_drop (ch->client);
- return;
+ return;
}
/* store address */
GNUNET_assert (alen <= left);
GNUNET_assert (alen <= sizeof (struct sockaddr_storage));
GNUNET_memcpy (&ch->caddrs[i].ss,
- sa,
- alen);
+ off,
+ alen);
/* If applicable, try UPNPC NAT punching */
if ( (is_nat) &&
off += alen;
}
+
+ ch->section_name
+ = GNUNET_strndup (off,
+ ntohs (message->str_len));
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Received REGISTER message from client for subsystem `%s'\n",
+ ch->section_name);
+ if (GNUNET_OK ==
+ GNUNET_CONFIGURATION_get_value_string (cfg,
+ ch->section_name,
+ "HOLE_EXTERNAL",
+ &ch->hole_external))
+ lookup_hole_external (ch);
+
/* Actually send IP address list to client */
for (struct LocalAddressList *lal = lal_head;
NULL != lal;
GNUNET_YES);
}
/* Also consider IPv4 determined by `external-ip` */
- if (0 != mini_external_ipv4.s_addr)
- {
- check_notify_client_external_ipv4_change (&mini_external_ipv4,
- ch,
- GNUNET_YES);
- }
+ ch->external_monitor
+ = GN_external_ipv4_monitor_start (¬ify_client_external_ipv4_change,
+ ch);
GNUNET_SERVICE_client_continue (ch->client);
}
{
size_t sa_len = ntohs (message->sender_addr_size);
size_t expect = sa_len + ntohs (message->payload_size);
-
+
if (ntohs (message->header.size) - sizeof (*message) != expect)
{
GNUNET_break (0);
struct sockaddr_in v4;
struct GNUNET_NAT_AddressChangeNotificationMessage *msg;
struct GNUNET_MQ_Envelope *env;
-
+
if (! ch->natted_address)
continue;
v4 = *ip;
- v4.sin_port = htons (ch->adv_port);
+ v4.sin_port = htons (0);
env = GNUNET_MQ_msg_extra (msg,
sizeof (v4),
GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE);
GNUNET_NAT_stun_handle_packet_ (payload,
payload_size,
&external_addr))
- {
+ {
/* We now know that a server at "sa" claims that
- we are visible at IP "external_addr".
+ we are visible at IP "external_addr".
We should (for some fixed period of time) tell
all of our clients that listen to a NAT'ed address
&se->stun_server_addr,
sa_len)) )
continue; /* different STUN server */
- if (0 != memcmp (&external_addr,
- &se->external_addr,
- sizeof (struct sockaddr_in)))
+ if (0 != GNUNET_memcmp (&external_addr,
+ &se->external_addr))
{
/* external IP changed, update! */
notify_clients_stun_change (&se->external_addr,
const char *buf = (const char *) &message[1];
size_t local_sa_len = ntohs (message->local_addr_size);
size_t remote_sa_len = ntohs (message->remote_addr_size);
- const struct sockaddr *local_sa = (const struct sockaddr *) &buf[0];
- const struct sockaddr *remote_sa = (const struct sockaddr *) &buf[local_sa_len];
- const struct sockaddr_in *l4 = NULL;
- const struct sockaddr_in *r4;
+ struct sockaddr_in l4;
+ struct sockaddr_in r4;
int ret;
-
+
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received REQUEST CONNECTION REVERSAL message from client\n");
- switch (local_sa->sa_family)
+ if (local_sa_len != sizeof (struct sockaddr_in))
{
- case AF_INET:
- if (local_sa_len != sizeof (struct sockaddr_in))
- {
- GNUNET_break (0);
- GNUNET_SERVICE_client_drop (ch->client);
- return;
- }
- l4 = (const struct sockaddr_in *) local_sa;
- break;
- case AF_INET6:
- if (local_sa_len != sizeof (struct sockaddr_in6))
- {
- GNUNET_break (0);
- GNUNET_SERVICE_client_drop (ch->client);
- return;
- }
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Connection reversal for IPv6 not supported yet\n"));
- ret = GNUNET_SYSERR;
- break;
- default:
- GNUNET_break (0);
+ GNUNET_break_op (0);
GNUNET_SERVICE_client_drop (ch->client);
return;
}
- switch (remote_sa->sa_family)
+ if (remote_sa_len != sizeof (struct sockaddr_in))
{
- case AF_INET:
- if (remote_sa_len != sizeof (struct sockaddr_in))
- {
- GNUNET_break (0);
- GNUNET_SERVICE_client_drop (ch->client);
- return;
- }
- r4 = (const struct sockaddr_in *) remote_sa;
- ret = GN_request_connection_reversal (&l4->sin_addr,
- ntohs (l4->sin_port),
- &r4->sin_addr);
- break;
- case AF_INET6:
- if (remote_sa_len != sizeof (struct sockaddr_in6))
- {
- GNUNET_break (0);
- GNUNET_SERVICE_client_drop (ch->client);
- return;
- }
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Connection reversal for IPv6 not supported yet\n"));
- ret = GNUNET_SYSERR;
- break;
- default:
- GNUNET_break (0);
+ GNUNET_break_op (0);
GNUNET_SERVICE_client_drop (ch->client);
return;
}
+ GNUNET_memcpy (&l4,
+ buf,
+ sizeof (struct sockaddr_in));
+ GNUNET_break_op (AF_INET == l4.sin_family);
+ buf += sizeof (struct sockaddr_in);
+ GNUNET_memcpy (&r4,
+ buf,
+ sizeof (struct sockaddr_in));
+ GNUNET_break_op (AF_INET == r4.sin_family);
+ ret = GN_request_connection_reversal (&l4.sin_addr,
+ ntohs (l4.sin_port),
+ &r4.sin_addr);
if (GNUNET_OK != ret)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Connection reversal request failed\n"));
- GNUNET_SERVICE_client_continue (ch->client);
-}
-
-
-/**
- * Check validity of #GNUNET_MESSAGE_TYPE_NAT_REQUEST_AUTO_CFG message
- * from client.
- *
- * @param cls client who sent the message
- * @param message the message received
- * @return #GNUNET_OK if message is well-formed
- */
-static int
-check_autoconfig_request (void *cls,
- const struct GNUNET_NAT_AutoconfigRequestMessage *message)
-{
- return GNUNET_OK; /* checked later */
-}
-
-
-/**
- * Stop all pending activities with respect to the @a ac
- *
- * @param ac autoconfiguration to terminate activities for
- */
-static void
-terminate_ac_activities (struct AutoconfigContext *ac)
-{
- if (NULL != ac->probe_external)
- {
- GNUNET_NAT_mini_get_external_ipv4_cancel_ (ac->probe_external);
- ac->probe_external = NULL;
- }
- if (NULL != ac->timeout_task)
- {
- GNUNET_SCHEDULER_cancel (ac->timeout_task);
- ac->timeout_task = NULL;
- }
-}
-
-
-/**
- * Finish handling the autoconfiguration request and send
- * the response to the client.
- *
- * @param cls the `struct AutoconfigContext` to conclude
- */
-static void
-conclude_autoconfig_request (void *cls)
-{
- struct AutoconfigContext *ac = cls;
- struct ClientHandle *ch = ac->ch;
- struct GNUNET_NAT_AutoconfigResultMessage *arm;
- struct GNUNET_MQ_Envelope *env;
- size_t c_size;
- char *buf;
- struct GNUNET_CONFIGURATION_Handle *diff;
-
- ac->timeout_task = NULL;
- terminate_ac_activities (ac);
-
- /* Send back response */
- diff = GNUNET_CONFIGURATION_get_diff (ac->orig,
- ac->c);
- buf = GNUNET_CONFIGURATION_serialize (diff,
- &c_size);
- GNUNET_CONFIGURATION_destroy (diff);
- env = GNUNET_MQ_msg_extra (arm,
- c_size,
- GNUNET_MESSAGE_TYPE_NAT_AUTO_CFG_RESULT);
- arm->status_code = htonl ((uint32_t) ac->status_code);
- arm->type = htonl ((uint32_t) ac->type);
- GNUNET_memcpy (&arm[1],
- buf,
- c_size);
- GNUNET_free (buf);
- GNUNET_MQ_send (ch->mq,
- env);
-
- /* clean up */
- GNUNET_free (ac->system_type);
- GNUNET_CONFIGURATION_destroy (ac->orig);
- GNUNET_CONFIGURATION_destroy (ac->c);
- GNUNET_CONTAINER_DLL_remove (ac_head,
- ac_tail,
- ac);
- GNUNET_free (ac);
+ _("Connection reversal request failed\n"));
GNUNET_SERVICE_client_continue (ch->client);
}
-/**
- * Check if all autoconfiguration operations have concluded,
- * and if they have, send the result back to the client.
- *
- * @param ac autoconfiguation context to check
- */
-static void
-check_autoconfig_finished (struct AutoconfigContext *ac)
-{
- if (NULL != ac->probe_external)
- return;
- GNUNET_SCHEDULER_cancel (ac->timeout_task);
- ac->timeout_task
- = GNUNET_SCHEDULER_add_now (&conclude_autoconfig_request,
- ac);
-}
-
-
-/**
- * Update ENABLE_UPNPC configuration option.
- *
- * @param ac autoconfiguration to update
- */
-static void
-update_enable_upnpc_option (struct AutoconfigContext *ac)
-{
- switch (ac->enable_upnpc)
- {
- case GNUNET_YES:
- GNUNET_CONFIGURATION_set_value_string (ac->c,
- "NAT",
- "ENABLE_UPNP",
- "YES");
- break;
- case GNUNET_NO:
- GNUNET_CONFIGURATION_set_value_string (ac->c,
- "NAT",
- "ENABLE_UPNP",
- "NO");
- break;
- case GNUNET_SYSERR:
- /* We are unsure, do not change option */
- break;
- }
-}
-
-
-/**
- * Handle result from external IP address probe during
- * autoconfiguration.
- *
- * @param cls our `struct AutoconfigContext`
- * @param addr the address, NULL on errors
- * @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code
- */
-static void
-auto_external_result_cb (void *cls,
- const struct in_addr *addr,
- enum GNUNET_NAT_StatusCode result)
-{
- struct AutoconfigContext *ac = cls;
-
- ac->probe_external = NULL;
- switch (result)
- {
- case GNUNET_NAT_ERROR_SUCCESS:
- ac->enable_upnpc = GNUNET_YES;
- break;
- case GNUNET_NAT_ERROR_EXTERNAL_IP_UTILITY_OUTPUT_INVALID:
- case GNUNET_NAT_ERROR_EXTERNAL_IP_ADDRESS_INVALID:
- case GNUNET_NAT_ERROR_IPC_FAILURE:
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- "Disabling UPNPC: %d\n",
- (int) result);
- ac->enable_upnpc = GNUNET_NO; /* did not work */
- break;
- default:
- GNUNET_break (0); /* unexpected */
- ac->enable_upnpc = GNUNET_SYSERR;
- break;
- }
- update_enable_upnpc_option (ac);
- check_autoconfig_finished (ac);
-}
-
-
-/**
- * Handler for #GNUNET_MESSAGE_TYPE_NAT_REQUEST_AUTO_CFG message from
- * client.
- *
- * @param cls client who sent the message
- * @param message the message received
- */
-static void
-handle_autoconfig_request (void *cls,
- const struct GNUNET_NAT_AutoconfigRequestMessage *message)
-{
- struct ClientHandle *ch = cls;
- size_t left = ntohs (message->header.size) - sizeof (*message);
- struct LocalAddressList *lal;
- struct AutoconfigContext *ac;
-
- ac = GNUNET_new (struct AutoconfigContext);
- ac->status_code = GNUNET_NAT_ERROR_SUCCESS;
- ac->ch = ch;
- ac->c = GNUNET_CONFIGURATION_create ();
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_deserialize (ac->c,
- (const char *) &message[1],
- left,
- GNUNET_NO))
- {
- GNUNET_break (0);
- GNUNET_SERVICE_client_drop (ch->client);
- GNUNET_CONFIGURATION_destroy (ac->c);
- GNUNET_free (ac);
- return;
- }
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received REQUEST_AUTO_CONFIG message from client\n");
-
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_string (ac->c,
- "PEER",
- "SYSTEM_TYPE",
- &ac->system_type))
- ac->system_type = GNUNET_strdup ("UNKNOWN");
-
- GNUNET_CONTAINER_DLL_insert (ac_head,
- ac_tail,
- ac);
- ac->orig
- = GNUNET_CONFIGURATION_dup (ac->c);
- ac->timeout_task
- = GNUNET_SCHEDULER_add_delayed (AUTOCONFIG_TIMEOUT,
- &conclude_autoconfig_request,
- ac);
- ac->enable_upnpc = GNUNET_SYSERR; /* undecided */
-
- /* Probe for upnpc */
- if (GNUNET_SYSERR ==
- GNUNET_OS_check_helper_binary ("upnpc",
- GNUNET_NO,
- NULL))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("UPnP client `upnpc` command not found, disabling UPnP\n"));
- ac->enable_upnpc = GNUNET_NO;
- }
- else
- {
- for (lal = lal_head; NULL != lal; lal = lal->next)
- if (GNUNET_NAT_AC_LAN == (lal->ac & GNUNET_NAT_AC_LAN))
- /* we are behind NAT, useful to try upnpc */
- ac->enable_upnpc = GNUNET_YES;
- }
- if (GNUNET_YES == ac->enable_upnpc)
- {
- /* If we are a mobile device, always leave it on as the network
- may change to one that supports UPnP anytime. If we are
- stationary, check if our network actually supports UPnP, and if
- not, disable it. */
- if ( (0 == strcasecmp (ac->system_type,
- "INFRASTRUCTURE")) ||
- (0 == strcasecmp (ac->system_type,
- "DESKTOP")) )
- {
- /* Check if upnpc gives us an external IP */
- ac->probe_external
- = GNUNET_NAT_mini_get_external_ipv4_ (&auto_external_result_cb,
- ac);
- }
- }
- if (NULL == ac->probe_external)
- update_enable_upnpc_option (ac);
-
- /* Finally, check if we are already done */
- check_autoconfig_finished (ac);
-}
-
-
/**
* Task run during shutdown.
*
shutdown_task (void *cls)
{
struct StunExternalIP *se;
- struct AutoconfigContext *ac;
- while (NULL != (ac = ac_head))
- {
- GNUNET_CONTAINER_DLL_remove (ac_head,
- ac_tail,
- ac);
- terminate_ac_activities (ac);
- GNUNET_free (ac);
- }
while (NULL != (se = se_head))
{
GNUNET_CONTAINER_DLL_remove (se_head,
GNUNET_SCHEDULER_cancel (se->timeout_task);
GNUNET_free (se);
}
- 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;
- }
+ GN_nat_status_changed (GNUNET_NO);
if (NULL != scan_task)
{
GNUNET_SCHEDULER_cancel (scan_task);
stun_stale_timeout = GNUNET_TIME_UNIT_HOURS;
/* Check for UPnP */
- enable_upnp
+ enable_upnp
= GNUNET_CONFIGURATION_get_value_yesno (cfg,
"NAT",
"ENABLE_UPNP");
enable_upnp = GNUNET_SYSERR;
}
}
-
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_time (cfg,
+ "nat",
+ "DYNDNS_FREQUENCY",
+ &dyndns_frequency))
+ dyndns_frequency = DYNDNS_FREQUENCY;
+
GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
NULL);
stats = GNUNET_STATISTICS_create ("nat",
void *internal_cls)
{
struct ClientHandle *ch = internal_cls;
+ struct LocalAddressList *lal;
GNUNET_CONTAINER_DLL_remove (ch_head,
ch_tail,
}
}
GNUNET_free_non_null (ch->caddrs);
+ while (NULL != (lal = ch->ext_addr_head))
+ {
+ GNUNET_CONTAINER_DLL_remove (ch->ext_addr_head,
+ ch->ext_addr_tail,
+ lal);
+ GNUNET_free (lal);
+ }
+ if (NULL != ch->ext_dns_task)
+ {
+ GNUNET_SCHEDULER_cancel (ch->ext_dns_task);
+ ch->ext_dns_task = NULL;
+ }
+ if (NULL != ch->external_monitor)
+ {
+ GN_external_ipv4_monitor_stop (ch->external_monitor);
+ ch->external_monitor = NULL;
+ }
+ if (NULL != ch->ext_dns)
+ {
+ GNUNET_RESOLVER_request_cancel (ch->ext_dns);
+ ch->ext_dns = NULL;
+ }
+ GNUNET_free_non_null (ch->hole_external);
+ GNUNET_free_non_null (ch->section_name);
GNUNET_free (ch);
}
GNUNET_MESSAGE_TYPE_NAT_REQUEST_CONNECTION_REVERSAL,
struct GNUNET_NAT_RequestConnectionReversalMessage,
NULL),
- GNUNET_MQ_hd_var_size (autoconfig_request,
- GNUNET_MESSAGE_TYPE_NAT_REQUEST_AUTO_CFG,
- struct GNUNET_NAT_AutoconfigRequestMessage,
- NULL),
GNUNET_MQ_handler_end ());