Add functionality to exchange global external IPs for natted peers.

8 files changed, 671 insertions, 38 deletions

diff --git a/src/include/gnunet_nat_service.h b/src/include/gnunet_nat_service.h
index f2854a0be..ba9f252a0 100644
--- a/src/include/gnunet_nat_service.h
+++ b/src/include/gnunet_nat_service.h
@@ -345,6 +345,19 @@ GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
 
 /**
+ * Add global address to the list of addresses and notify clients.
+ *
+ * @param nh the handle returned by register
+ * @param addr IP address to add.
+ * @param address_length number of bytes in @a addr
+ */
+void
+GNUNET_NAT_add_global_address (struct GNUNET_NAT_Handle *nh,
+                               char *addr,
+                               unsigned int address_length);
+
+
+/**
  * Test if the given address is (currently) a plausible IP address for
  * this peer.  Mostly a convenience function so that clients do not
  * have to explicitly track all IPs that the #GNUNET_NAT_AddressCallback
diff --git a/src/include/gnunet_protocols.h b/src/include/gnunet_protocols.h
index 8638703db..6ab008d16 100644
--- a/src/include/gnunet_protocols.h
+++ b/src/include/gnunet_protocols.h
@@ -3216,6 +3216,11 @@ extern "C" {
 #define GNUNET_MESSAGE_TYPE_NAT_ADDRESS_CHANGE 1064
 
 /**
+ * Message to ask NAT service to notify all clients about a new global address.
+ */
+#define GNUNET_MESSAGE_TYPE_NAT_ADD_GLOBAL_ADDRESS 1065
+
+/**
  * Message to ask NAT service to request autoconfiguration.
  */
 #define GNUNET_MESSAGE_TYPE_NAT_AUTO_REQUEST_CFG 1067
diff --git a/src/service/nat/gnunet-service-nat.c b/src/service/nat/gnunet-service-nat.c
index 08c87d0be..00584ab8a 100644
--- a/src/service/nat/gnunet-service-nat.c
+++ b/src/service/nat/gnunet-service-nat.c
@@ -1864,6 +1864,132 @@ handle_request_connection_reversal (void *cls,
 
 
 /**
+ * Check validity of #GNUNET_MESSAGE_TYPE_NAT_ADD_GLOBAL_ADDRESS 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_add_global_address(void *cls,
+                         const struct GNUNET_NAT_AddGlobalAddressMessage *message)
+{
+  char *addr = GNUNET_malloc (ntohs (message->address_length));
+  size_t left = ntohs (message->header.size) - sizeof(*message);
+
+  GNUNET_memcpy (addr, (const char *) &message[1], ntohs (message->address_length));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "message size %u natting address %s length %u left %u\n",
+              ntohs (message->header.size),
+              addr,
+              ntohs (message->address_length),
+              left);
+
+  if (left != ntohs (message->address_length))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (addr);
+  return GNUNET_OK;
+}
+
+
+static int
+is_nat_v4 (const struct in_addr *ip);
+
+
+static int
+is_nat_v6 (const struct in6_addr *ip);
+
+
+static void
+notify_client (enum GNUNET_NAT_AddressClass ac,
+               struct ClientHandle *ch,
+               int add,
+               const void *addr,
+               size_t addr_len);
+
+
+/**
+ * Handle #GNUNET_MESSAGE_TYPE_NAT_ADD_GLOBAL_ADDRESS message from
+ * client.
+ *
+ * @param cls client who sent the message
+ * @param message the message received
+ */
+static void
+handle_add_global_address(void *cls,
+                         const struct GNUNET_NAT_AddGlobalAddressMessage *message)
+{
+  struct ClientHandle *ch = cls;
+  char *buf = GNUNET_malloc (ntohs (message->address_length));
+  //= (const char *) &message[1];
+  struct sockaddr *sockaddr = NULL;
+  socklen_t addr_len;
+  struct sockaddr_in *sockaddr_ipv4 = GNUNET_malloc(sizeof(struct sockaddr_in));
+  enum GNUNET_NAT_AddressClass ac;
+
+  GNUNET_memcpy (buf, (const char *) &message[1], ntohs (message->address_length));
+  memset(sockaddr_ipv4, 0, sizeof(struct sockaddr_in));
+  sockaddr_ipv4->sin_family = AF_INET;
+
+  if (1 == inet_pton(AF_INET, buf, &(sockaddr_ipv4->sin_addr)))
+  {
+    sockaddr = (struct sockaddr *)sockaddr_ipv4;
+    addr_len = sizeof(struct sockaddr_in);
+    ac = is_nat_v4 (&((const struct sockaddr_in *)sockaddr_ipv4)->sin_addr)
+         ? GNUNET_NAT_AC_LAN
+          : GNUNET_NAT_AC_EXTERN;
+  }
+  else
+  {
+    GNUNET_free(sockaddr_ipv4);
+    sockaddr_ipv4 = NULL;
+  }
+
+  if (NULL == sockaddr)
+  {
+    struct sockaddr_in6 *sockaddr_ipv6 = malloc(sizeof(struct sockaddr_in6));
+
+    if (sockaddr_ipv6 != NULL)
+    {
+      memset(sockaddr_ipv6, 0, sizeof(struct sockaddr_in6));
+      sockaddr_ipv6->sin6_family = AF_INET6;
+
+      if (1 == inet_pton(AF_INET6, buf, &(sockaddr_ipv6->sin6_addr)))
+      {
+        GNUNET_break (0);
+        GNUNET_SERVICE_client_continue (ch->client);
+        GNUNET_free (buf);
+        return;
+      }
+      else
+      {
+        GNUNET_free(sockaddr_ipv6);
+        sockaddr_ipv6 = NULL;
+      }
+    }
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "3 natting address %s\n",
+              buf);
+  if (NULL == sockaddr)
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_continue (ch->client);
+    GNUNET_free (buf);
+    return;
+  }
+  notify_clients_stun_change (sockaddr_ipv4, GNUNET_YES);
+  GNUNET_SERVICE_client_continue (ch->client);
+  GNUNET_free (buf);
+}
+
+
+/**
  * Task run during shutdown.
  *
  * @param cls unused
@@ -2060,6 +2186,10 @@ GNUNET_SERVICE_MAIN
                          GNUNET_MESSAGE_TYPE_NAT_REQUEST_CONNECTION_REVERSAL,
                          struct GNUNET_NAT_RequestConnectionReversalMessage,
                          NULL),
+  GNUNET_MQ_hd_var_size (add_global_address,
+                         GNUNET_MESSAGE_TYPE_NAT_ADD_GLOBAL_ADDRESS,
+                         struct GNUNET_NAT_AddGlobalAddressMessage,
+                         NULL),
   GNUNET_MQ_handler_end ());
 
 
diff --git a/src/service/nat/nat.h b/src/service/nat/nat.h
index 1d8648aaf..30e6f0901 100644
--- a/src/service/nat/nat.h
+++ b/src/service/nat/nat.h
@@ -218,6 +218,25 @@ struct GNUNET_NAT_AddressChangeNotificationMessage
 };
 
 
+/**
+ * Message sent by client to add a global address.
+ */
+struct GNUNET_NAT_AddGlobalAddressMessage
+{
+  /**
+   * Header with type #GNUNET_MESSAGE_TYPE_NAT_ADD_GLOBAL_ADDRESS
+   */
+  struct GNUNET_MessageHeader header;
+
+  /**
+   * Length of the address following the struct, in NBO.
+   */
+  unsigned int address_length;
+
+  /* Followed by the address to add */
+};
+
+
 GNUNET_NETWORK_STRUCT_END
 
 #endif
diff --git a/src/service/nat/nat_api.c b/src/service/nat/nat_api.c
index 31f8f388d..219a11e81 100644
--- a/src/service/nat/nat_api.c
+++ b/src/service/nat/nat_api.c
@@ -457,6 +457,59 @@ GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
 
 /**
+ * Get the IP address without the port number.
+ *
+ * @param address The string contains a communicator prefix, IP address and port
+ *        like this 'tcp-92.68.150.1:55452'.
+ * @return String with prefix and IP address only.
+ */
+static char *
+get_address_without_port (const char *address)
+{
+  const char *colon;
+  char *colon_rest;
+  size_t colon_rest_length;
+  char *address_without_port;
+
+  colon = strchr (address,':');
+  colon_rest = GNUNET_strndup (address, colon - address);
+  colon_rest_length = strlen (colon_rest);
+  address_without_port = GNUNET_strndup (&colon_rest[4], colon_rest_length - 4);
+  GNUNET_free (colon_rest);
+
+  return address_without_port;
+}
+
+void
+GNUNET_NAT_add_global_address (struct GNUNET_NAT_Handle *nh,
+                               char *addr,
+                               unsigned int address_length)
+{
+  struct GNUNET_NAT_AddGlobalAddressMessage *aam;
+  struct GNUNET_MQ_Envelope *env;
+  //char *address_without_port = get_address_without_port (addr);
+  //unsigned int address_len_without_port = strlen (address_without_port);
+  char *off;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "natting address %s length %u\n",
+              addr,
+              address_length);
+
+  env = GNUNET_MQ_msg_extra (aam,
+                             address_length,
+                             GNUNET_MESSAGE_TYPE_NAT_ADD_GLOBAL_ADDRESS);
+  aam->address_length = htons (address_length);
+  off = (char *) &aam[1];
+  GNUNET_memcpy (off, addr, address_length);
+  GNUNET_MQ_send (nh->mq,
+                   env);
+  //GNUNET_free (address_without_port);
+}
+
+
+
+/**
  * Check if an incoming message is a STUN message.
  *
  * @param data the packet
diff --git a/src/service/topology/gnunet-daemon-topology.c b/src/service/topology/gnunet-daemon-topology.c
index c706e826d..159ba2a07 100644
--- a/src/service/topology/gnunet-daemon-topology.c
+++ b/src/service/topology/gnunet-daemon-topology.c
@@ -452,18 +452,13 @@ schedule_next_hello (void *cls)
   fah.max_size = GNUNET_MAX_MESSAGE_SIZE - 1;
   fah.next_adv = GNUNET_TIME_UNIT_FOREVER_REL;
   GNUNET_CONTAINER_multipeermap_iterate (peers, &find_advertisable_hello, &fah);
-  pl->hello_delay_task =
-    GNUNET_SCHEDULER_add_delayed (fah.next_adv, &schedule_next_hello, pl);
   if (NULL == fah.result)
-    return;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "schedule_next_hello 2\n");
-  delay = GNUNET_TIME_absolute_get_remaining (pl->next_hello_allowed);
-  if (0 != delay.rel_value_us)
-    return;
+  {
+    pl->hello_delay_task =
+      GNUNET_SCHEDULER_add_delayed (fah.next_adv, &schedule_next_hello, pl);
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "schedule_next_hello 3\n");
+    return;
+  }
   want = ntohs (fah.result->hello->size);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Sending HELLO with %u bytes for peer %s\n",
@@ -483,9 +478,8 @@ schedule_next_hello (void *cls)
   /* prepare to send the next one */
   pl->next_hello_allowed =
     GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY);
-  if (NULL != pl->hello_delay_task)
-    GNUNET_SCHEDULER_cancel (pl->hello_delay_task);
-  pl->hello_delay_task = GNUNET_SCHEDULER_add_now (&schedule_next_hello, pl);
+  delay = GNUNET_TIME_absolute_get_remaining (pl->next_hello_allowed);
+  pl->hello_delay_task = GNUNET_SCHEDULER_add_delayed (delay, &schedule_next_hello, pl);
 }
 
 
@@ -937,7 +931,7 @@ handle_hello (void *cls, const struct GNUNET_MessageHeader *message)
     message);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received encrypted HELLO from peer `%s'",
+              "Received encrypted HELLO from peer `%s'\n",
               GNUNET_i2s (other));
   GNUNET_STATISTICS_update (stats,
                             gettext_noop ("# HELLO messages received"),
@@ -1012,6 +1006,7 @@ cleaning_task (void *cls)
     GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
     stats = NULL;
   }
+  GNUNET_free (my_private_key);
 }
 
 
diff --git a/src/service/transport/Makefile.am b/src/service/transport/Makefile.am
index af7ea8771..56ed8fc13 100644
--- a/src/service/transport/Makefile.am
+++ b/src/service/transport/Makefile.am
@@ -184,6 +184,7 @@ gnunet_service_transport_LDADD = \
   $(top_builddir)/src/service/peerstore/libgnunetpeerstore.la \
   $(top_builddir)/src/lib/hello/libgnunethello.la \
   $(top_builddir)/src/service/statistics/libgnunetstatistics.la \
+  $(top_builddir)/src/service/nat/libgnunetnatnew.la \
   $(top_builddir)/src/lib/util/libgnunetutil.la \
   $(LIBGCRYPT_LIBS) \
   $(GN_LIBINTL)
diff --git a/src/service/transport/gnunet-service-transport.c b/src/service/transport/gnunet-service-transport.c
index ca191d49d..f4be5e759 100644
--- a/src/service/transport/gnunet-service-transport.c
+++ b/src/service/transport/gnunet-service-transport.c
@@ -77,6 +77,7 @@
 #include "gnunet_statistics_service.h"
 #include "gnunet_transport_monitor_service.h"
 #include "gnunet_peerstore_service.h"
+#include "gnunet_nat_service.h"
 #include "gnunet_hello_uri_lib.h"
 #include "gnunet_signatures.h"
 #include "transport.h"
@@ -916,6 +917,15 @@ struct TransportValidationResponseMessage
   struct GNUNET_TIME_RelativeNBO validity_duration;
 };
 
+struct TransportGlobalNattedAddress
+{
+  /**
+   * Length of the address following the struct.
+   */
+  unsigned int address_length;
+
+  /* Followed by @e address_length bytes of the address. */
+};
 
 /**
  * Message for Transport-to-Transport Flow control. Specifies the size
@@ -973,9 +983,21 @@ struct TransportFlowControlMessage
    * reset the counters for the number of bytes sent!
    */
   struct GNUNET_TIME_AbsoluteNBO sender_time;
-};
 
 
+  /**
+   * Number of TransportGlobalNattedAddress following the struct.
+   */
+  unsigned int number_of_addresses;
+
+  /**
+   * Size of all the addresses attached to all TransportGlobalNattedAddress.
+   */
+  size_t size_of_addresses;
+
+  /* Followed by @e number_of_addresses struct TransportGlobalNattedAddress. */
+};
+
 GNUNET_NETWORK_STRUCT_END
 
 
@@ -1921,6 +1943,12 @@ struct Queue
   struct PerformanceData pd;
 
   /**
+   * Handle for an operation to iterate through all hellos to compare the hello
+   * addresses with @e address which might be a natted one.
+   */
+  struct GNUNET_PEERSTORE_Monitor *mo;
+
+  /**
    * Message ID generator for transmissions on this queue to the
    * communicator.
    */
@@ -1976,6 +2004,11 @@ struct Queue
    * virtual link to give it a pending message.
    */
   int idle;
+
+  /**
+   * Set to GNUNET_yes, if this queues address is not a global natted one.
+   */
+  enum GNUNET_GenericReturnValue is_global_natted;
 };
 
 
@@ -2040,6 +2073,26 @@ struct Neighbour
    * PEERSTORE yet, or are we still waiting for a reply of PEERSTORE?
    */
   int dv_monotime_available;
+
+  /**
+   * Map of struct TransportGlobalNattedAddress for this neighbour.
+   */
+  struct GNUNET_CONTAINER_MultiPeerMap *natted_addresses;
+
+  /**
+   * Number of global natted addresses for this neighbour.
+   */
+  unsigned int number_of_addresses;
+
+  /**
+   * Size of all global natted addresses for this neighbour.
+   */
+  size_t size_of_global_addresses;
+
+  /**
+   * A queue of this neighbour has a global natted address.
+   */
+  enum GNUNET_GenericReturnValue is_global_natted;
 };
 
 
@@ -2760,7 +2813,6 @@ struct Backtalker
   size_t body_size;
 };
 
-
 /**
  * Ring buffer for a CORE message we did not deliver to CORE, because of missing virtual link to sender.
  */
@@ -2897,6 +2949,11 @@ static struct LearnLaunchEntry *lle_tail = NULL;
 static struct GNUNET_CONTAINER_Heap *validation_heap;
 
 /**
+ * Handle for connect to the NAT service.
+ */
+struct GNUNET_NAT_Handle *nh;
+
+/**
  * Database for peer's HELLOs.
  */
 static struct GNUNET_PEERSTORE_Handle *peerstore;
@@ -3591,6 +3648,18 @@ client_connect_cb (void *cls,
 }
 
 
+static enum GNUNET_GenericReturnValue
+remove_global_addresses (void *cls,
+                         const struct GNUNET_PeerIdentity *pid,
+                         void *value)
+{
+  (void) cls;
+  struct TransportGlobalNattedAddress *tgna = value;
+
+  GNUNET_free (tgna);
+}
+
+
 /**
  * Release memory used by @a neighbour.
  *
@@ -3609,6 +3678,9 @@ free_neighbour (struct Neighbour *neighbour)
                                                        neighbour));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Freeing neighbour\n");
+  GNUNET_CONTAINER_multipeermap_iterate (neighbour->natted_addresses,
+                                         &remove_global_addresses,
+                                         NULL);
   while (NULL != (dvh = neighbour->dv_head))
   {
     struct DistanceVector *dv = dvh->dv;
@@ -3878,6 +3950,11 @@ free_queue (struct Queue *queue)
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Cleaning up queue %u\n", queue->qid);
+  if (NULL != queue->mo)
+  {
+    GNUNET_PEERSTORE_monitor_stop (queue->mo);
+    queue->mo = NULL;
+  }
   if (NULL != queue->transmit_task)
   {
     GNUNET_SCHEDULER_cancel (queue->transmit_task);
@@ -5263,6 +5340,34 @@ task_consider_sending_fc (void *cls)
 }
 
 
+static char *
+get_address_without_port (const char *address);
+
+
+static enum GNUNET_GenericReturnValue
+add_global_addresses (void *cls,
+                      const struct GNUNET_PeerIdentity *pid,
+                      void *value)
+{
+  char *tgnas = cls;
+  struct TransportGlobalNattedAddress *tgna = value;
+  char *addr = (char *) &tgna[1];
+  size_t address_len = strlen (addr);
+  unsigned int off = 0;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sending address %s length %u\n",
+              addr,
+              address_len);
+  tgna = GNUNET_malloc (sizeof (struct TransportGlobalNattedAddress) + address_len);
+  tgna->address_length = htonl (address_len);
+  GNUNET_memcpy (&tgna[1], addr, address_len);
+  GNUNET_memcpy (&tgnas[off], tgna, sizeof (struct TransportGlobalNattedAddress) + address_len);
+  GNUNET_free (tgna);
+  off += sizeof(struct TransportGlobalNattedAddress) + address_len;
+}
+
+
 /**
  * Something changed on the virtual link with respect to flow
  * control. Consider retransmitting the FC window size.
@@ -5274,9 +5379,32 @@ consider_sending_fc (void *cls)
 {
   struct VirtualLink *vl = cls;
   struct GNUNET_TIME_Absolute monotime;
-  struct TransportFlowControlMessage fc;
+  struct TransportFlowControlMessage *fc;
   struct GNUNET_TIME_Relative duration;
   struct GNUNET_TIME_Relative rtt;
+  struct Neighbour *n = vl->n;
+
+  if (0 < n->number_of_addresses)
+  {
+    char *tgnas = GNUNET_malloc (n->number_of_addresses * sizeof (struct TransportGlobalNattedAddress) + n->size_of_global_addresses);
+    size_t addresses_size;
+
+    addresses_size = n->number_of_addresses * sizeof (struct TransportGlobalNattedAddress) + n->size_of_global_addresses;
+    fc = GNUNET_malloc (sizeof (struct TransportFlowControlMessage) + addresses_size);
+    fc->header.size = htons (sizeof(struct TransportFlowControlMessage) + addresses_size);
+    fc->size_of_addresses = htonl (n->size_of_global_addresses);
+    fc->number_of_addresses = htonl (n->number_of_addresses);
+    GNUNET_CONTAINER_multipeermap_iterate (n->natted_addresses,
+                                           &add_global_addresses,
+                                           tgnas);
+    GNUNET_memcpy (&fc[1], tgnas, addresses_size);
+    GNUNET_free (tgnas);
+  }
+  else
+  {
+    fc = GNUNET_malloc (sizeof (struct TransportFlowControlMessage));
+    fc->header.size = htons (sizeof(struct TransportFlowControlMessage));
+  }
 
   duration = GNUNET_TIME_absolute_get_duration (vl->last_fc_transmission);
   /* OPTIMIZE-FC-BDP: decide sane criteria on when to do this, instead of doing
@@ -5295,16 +5423,15 @@ consider_sending_fc (void *cls)
               (unsigned long long) vl->incoming_fc_window_size);
   monotime = GNUNET_TIME_absolute_get_monotonic (GST_cfg);
   vl->last_fc_transmission = monotime;
-  fc.header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL);
-  fc.header.size = htons (sizeof(fc));
-  fc.seq = htonl (vl->fc_seq_gen++);
-  fc.inbound_window_size = GNUNET_htonll (vl->incoming_fc_window_size
+  fc->header.type = htons (GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL);
+  fc->seq = htonl (vl->fc_seq_gen++);
+  fc->inbound_window_size = GNUNET_htonll (vl->incoming_fc_window_size
                                           + vl->incoming_fc_window_size_used
                                           + vl->incoming_fc_window_size_loss);
-  fc.outbound_sent = GNUNET_htonll (vl->outbound_fc_window_size_used);
-  fc.outbound_window_size = GNUNET_htonll (vl->outbound_fc_window_size);
-  fc.sender_time = GNUNET_TIME_absolute_hton (monotime);
-  rtt = route_control_message_without_fc (vl, &fc.header, RMO_DV_ALLOWED);
+  fc->outbound_sent = GNUNET_htonll (vl->outbound_fc_window_size_used);
+  fc->outbound_window_size = GNUNET_htonll (vl->outbound_fc_window_size);
+  fc->sender_time = GNUNET_TIME_absolute_hton (monotime);
+  rtt = route_control_message_without_fc (vl, &fc->header, RMO_DV_ALLOWED);
   if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us == rtt.rel_value_us)
   {
     rtt = GNUNET_TIME_UNIT_SECONDS;
@@ -5329,6 +5456,7 @@ consider_sending_fc (void *cls)
   vl->fc_retransmit_task =
     GNUNET_SCHEDULER_add_delayed (rtt, &task_consider_sending_fc, vl);
   vl->fc_retransmit_count++;
+  GNUNET_free (fc);
 }
 
 
@@ -5775,6 +5903,29 @@ store_pi (void *cls)
 }
 
 
+static struct AddressListEntry *
+create_address_entry (struct TransportClient *tc,
+                      struct GNUNET_TIME_Relative expiration,
+                      enum GNUNET_NetworkType nt,
+                      const char *address,
+                      uint32_t aid,
+                      size_t slen)
+{
+  struct AddressListEntry *ale;
+
+  ale = GNUNET_malloc (sizeof(struct AddressListEntry) + slen);
+  ale->tc = tc;
+  ale->address = (const char *) &ale[1];
+  ale->expiration = expiration;
+  ale->aid = aid;
+  ale->nt = nt;
+  memcpy (&ale[1], address, slen);
+  ale->st = GNUNET_SCHEDULER_add_now (&store_pi, ale);
+
+  return ale;
+}
+
+
 /**
  * Address of our peer added.  Process the request.
  *
@@ -5788,23 +5939,24 @@ handle_add_address (void *cls,
   struct TransportClient *tc = cls;
   struct AddressListEntry *ale;
   size_t slen;
+  char *address;
 
   /* 0-termination of &aam[1] was checked in #check_add_address */
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Communicator added address `%s'!\n",
               (const char *) &aam[1]);
   slen = ntohs (aam->header.size) - sizeof(*aam);
-  ale = GNUNET_malloc (sizeof(struct AddressListEntry) + slen);
-  ale->tc = tc;
-  ale->address = (const char *) &ale[1];
-  ale->expiration = GNUNET_TIME_relative_ntoh (aam->expiration);
-  ale->aid = aam->aid;
-  ale->nt = (enum GNUNET_NetworkType) ntohl (aam->nt);
-  memcpy (&ale[1], &aam[1], slen);
+  address = GNUNET_malloc (slen);
+  memcpy (address, &aam[1], slen);
+  ale = create_address_entry (tc,
+                        GNUNET_TIME_relative_ntoh (aam->expiration),
+                        (enum GNUNET_NetworkType) ntohl (aam->nt),
+                        address,
+                        aam->aid,
+                        slen);
   GNUNET_CONTAINER_DLL_insert (tc->details.communicator.addr_head,
                                tc->details.communicator.addr_tail,
                                ale);
-  ale->st = GNUNET_SCHEDULER_add_now (&store_pi, ale);
   GNUNET_SERVICE_client_continue (tc->client);
 }
 
@@ -9446,6 +9598,37 @@ handle_incoming_msg (void *cls,
   demultiplex_with_cmc (cmc);
 }
 
+/**
+ * Communicator gave us a transport address validation response.  Check the
+ * request.
+ *
+ * @param cls a `struct CommunicatorMessageContext`
+ * @param fc the message that was received
+ * @return #GNUNET_YES if message is well-formed
+ */
+static int
+check_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
+{
+  (void) cls;
+  struct TransportGlobalNattedAddress *addresses = (struct TransportGlobalNattedAddress *) &fc[1];
+  unsigned int number_of_addresses = ntohl (fc->number_of_addresses);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Flow control header size %u size of addresses %u number of addresses %u size of message struct %u second struct %u\n",
+              ntohs (fc->header.size),
+              ntohl (fc->size_of_addresses),
+              ntohl (fc->number_of_addresses),
+              sizeof(struct TransportFlowControlMessage),
+              sizeof (struct TransportGlobalNattedAddress));
+
+  if (0 == number_of_addresses || ntohs (fc->header.size) == sizeof(struct TransportFlowControlMessage) + ntohl (fc->number_of_addresses) * sizeof (struct TransportGlobalNattedAddress) + ntohl (fc->size_of_addresses))
+    return GNUNET_OK;
+  else
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+}
 
 /**
  * Communicator gave us a transport address validation response.  Process the
@@ -9490,6 +9673,31 @@ handle_flow_control (void *cls, const struct TransportFlowControlMessage *fc)
                     vl,
                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   }
+  if (0 != ntohl (fc->number_of_addresses))
+  {
+    unsigned int number_of_addresses = ntohl (fc->number_of_addresses);
+    const char *tgnas;
+    unsigned int off = 0;
+
+    tgnas = (const char *) &fc[1];
+
+    for (int i = 1; i <= number_of_addresses; i++)
+    {
+      struct TransportGlobalNattedAddress *tgna = (struct TransportGlobalNattedAddress *) &tgnas[off];
+      char *addr = (char *) &tgna[1];
+      unsigned int address_length;
+
+      address_length = ntohl (tgna->address_length);
+      off += sizeof(struct TransportGlobalNattedAddress) + address_length;
+
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "received address %s length %u\n",
+              addr,
+              ntohl (tgna->address_length));
+
+      GNUNET_NAT_add_global_address (nh, addr, ntohl (tgna->address_length));
+    }
+  }
   st = GNUNET_TIME_absolute_ntoh (fc->sender_time);
   if (st.abs_value_us < vl->last_fc_timestamp.abs_value_us)
   {
@@ -9596,15 +9804,15 @@ demultiplex_with_cmc (struct CommunicatorMessageContext *cmc)
                            GNUNET_MESSAGE_TYPE_TRANSPORT_DV_BOX,
                            struct TransportDVBoxMessage,
                            cmc),
+    GNUNET_MQ_hd_var_size (flow_control,
+                           GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL,
+                           struct TransportFlowControlMessage,
+                           cmc),
     GNUNET_MQ_hd_fixed_size (
       validation_challenge,
       GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_CHALLENGE,
       struct TransportValidationChallengeMessage,
       cmc),
-    GNUNET_MQ_hd_fixed_size (flow_control,
-                             GNUNET_MESSAGE_TYPE_TRANSPORT_FLOW_CONTROL,
-                             struct TransportFlowControlMessage,
-                             cmc),
     GNUNET_MQ_hd_fixed_size (
       validation_response,
       GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_VALIDATION_RESPONSE,
@@ -11317,6 +11525,7 @@ check_validation_request_pending (void *cls,
   char *address_without_port_q;
   int success = GNUNET_YES;
 
+  //TODO Check if this is really necessary.
   address_without_port_vs = get_address_without_port (vs->address);
   address_without_port_q = get_address_without_port (q->address);
 
@@ -11380,6 +11589,192 @@ neighbour_dv_monotime_cb (void *cls,
 }
 
 
+static void
+iterate_address_and_compare_cb (void *cls,
+                                const struct GNUNET_PeerIdentity *pid,
+                                const char *uri)
+{
+  struct Queue *queue = cls;
+  struct Neighbour *neighbour = queue->neighbour;
+  const char *dash;
+  const char *slash;
+  char *address_uri;
+  char *prefix;
+  char *uri_without_port;
+  char *address_uri_without_port = get_address_without_port (queue->address); 
+
+  slash = strrchr (uri, '/');
+  prefix = GNUNET_strndup (uri, (slash - uri) - 2); 
+  GNUNET_assert (NULL != slash);
+  slash++;
+  GNUNET_asprintf (&address_uri,
+                   "%s-%s",
+                   prefix,
+                   slash);
+
+  address_uri_without_port = get_address_without_port (queue->address);
+  uri_without_port = get_address_without_port (address_uri);
+  if (0 == strcmp (uri_without_port, address_uri_without_port))
+  {
+    queue->is_global_natted = GNUNET_NO;
+  }
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "not global natted %u %s %s %s %s %s %u\n",
+              queue->is_global_natted,
+              uri,
+              queue->address,
+              uri_without_port,
+              address_uri_without_port,
+              prefix,
+              GNUNET_NO);
+  GNUNET_free (prefix);
+  GNUNET_free (address_uri);
+  GNUNET_free (address_uri_without_port);
+  GNUNET_free (uri_without_port);
+}
+
+
+static void
+check_for_global_natted_error_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Error in PEERSTORE monitoring for checking global natted\n");
+}
+
+
+static void
+check_for_global_natted_sync_cb (void *cls)
+{
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              "Done with initial PEERSTORE iteration during monitoring  for checking global natted\n");
+}
+
+
+struct TransportGlobalNattedAddressClosure
+{
+  /**
+   * The address to search for.
+   */
+  char *addr;
+
+  /**
+   * The struct TransportGlobalNattedAddress to set.
+   */
+  struct TransportGlobalNattedAddress *tgna;
+};
+
+
+static enum GNUNET_GenericReturnValue
+contains_address (void *cls,
+                  const struct GNUNET_PeerIdentity *pid,
+                  void *value)
+{
+  struct TransportGlobalNattedAddressClosure *tgna_cls = cls;
+  struct TransportGlobalNattedAddress *tgna = value;
+  char *addr = (char *) &tgna[1];
+
+  if (0 == GNUNET_memcmp (addr, tgna_cls->addr))
+  {
+    tgna_cls->tgna = tgna;
+    return GNUNET_NO;
+  }
+  return GNUNET_YES;
+}
+
+
+static void
+check_for_global_natted (void *cls,
+                         const struct GNUNET_PEERSTORE_Record *record,
+                         const char *emsg)
+{
+  struct Queue *queue = cls;
+  struct Neighbour *neighbour = queue->neighbour;
+  struct GNUNET_HELLO_Builder *builder;
+  struct GNUNET_MessageHeader *hello;
+  struct TransportGlobalNattedAddressClosure tgna_cls;
+  size_t address_len_without_port;
+
+  if (NULL != emsg)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+         "Got failure from PEERSTORE: %s\n",
+         emsg);
+    return;
+  }
+  if (NULL == record)
+  {
+    queue->mo = NULL;
+    return;
+  }
+  if (0 == record->value_size)
+  {
+    GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
+    GNUNET_break (0);
+    return;
+  }
+  queue->is_global_natted = GNUNET_YES;
+  hello = record->value;
+  builder = GNUNET_HELLO_builder_from_msg (hello);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "before not global natted %u\n",
+              queue->is_global_natted);
+  GNUNET_HELLO_builder_iterate (builder,
+                                &iterate_address_and_compare_cb,
+                                queue);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "after not global natted %u\n",
+              queue->is_global_natted);
+  GNUNET_HELLO_builder_free (builder);
+
+  tgna_cls.addr = get_address_without_port (queue->address);
+  address_len_without_port = strlen (tgna_cls.addr);
+  GNUNET_CONTAINER_multipeermap_get_multiple (neighbour->natted_addresses,
+                                              &neighbour->pid,
+                                              &contains_address,
+                                              &tgna_cls);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              " tgna_cls.tgna tgna %p %u %u %u\n",
+              tgna_cls.tgna,
+              neighbour->size_of_global_addresses,
+              tgna_cls.tgna->address_length,
+              neighbour->number_of_addresses);
+  if (0 == tgna_cls.tgna->address_length && GNUNET_YES == queue->is_global_natted)
+  {
+    struct TransportGlobalNattedAddress *tgna;
+
+    tgna = GNUNET_malloc (sizeof (struct TransportGlobalNattedAddress) + address_len_without_port);
+    tgna->address_length = htonl (address_len_without_port);
+    GNUNET_memcpy (&tgna[1], tgna_cls.addr, address_len_without_port);
+    GNUNET_CONTAINER_multipeermap_put (neighbour->natted_addresses,
+                                       &neighbour->pid,
+                                       tgna,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+    neighbour->number_of_addresses++;
+    neighbour->size_of_global_addresses += address_len_without_port;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Created tgna %p\n",
+                tgna);
+  }
+  else if (0 != tgna_cls.tgna->address_length && GNUNET_NO == queue->is_global_natted)
+  {
+    GNUNET_CONTAINER_multipeermap_remove (neighbour->natted_addresses,
+                                          &neighbour->pid,
+                                          tgna_cls.tgna);
+    GNUNET_assert (neighbour->size_of_global_addresses >= ntohl (tgna_cls.tgna->address_length));
+    neighbour->size_of_global_addresses -= ntohl (tgna_cls.tgna->address_length);
+    GNUNET_assert (0 < neighbour->number_of_addresses);
+    neighbour->number_of_addresses--;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "removed tgna %p\n",
+                tgna_cls.tgna);
+    GNUNET_free (tgna_cls.tgna);
+  }
+  GNUNET_free (tgna_cls.addr);
+  GNUNET_PEERSTORE_monitor_next (queue->mo, 1);
+}
+
+
 /**
  * New queue became available.  Process the request.
  *
@@ -11426,6 +11821,7 @@ handle_add_queue_message (void *cls,
     if (NULL == neighbour)
     {
       neighbour = GNUNET_new (struct Neighbour);
+      neighbour->natted_addresses = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_YES);
       neighbour->pid = aqm->receiver;
       GNUNET_assert (GNUNET_OK ==
                      GNUNET_CONTAINER_multipeermap_put (
@@ -11488,6 +11884,17 @@ handle_add_queue_message (void *cls,
   queue->nt = (enum GNUNET_NetworkType) ntohl (aqm->nt);
   queue->cs = (enum GNUNET_TRANSPORT_ConnectionStatus) ntohl (aqm->cs);
   queue->idle = GNUNET_YES;
+  queue->mo = GNUNET_PEERSTORE_monitor_start (GST_cfg,
+                                    GNUNET_YES,
+                                    "peerstore",
+                                    &neighbour->pid,
+                                    GNUNET_PEERSTORE_HELLO_KEY,
+                                    &check_for_global_natted_error_cb,
+                                    NULL,
+                                    &check_for_global_natted_sync_cb,
+                                    NULL,
+                                    &check_for_global_natted,
+                                    queue);
   /* check if valdiations are waiting for the queue */
   if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (validation_map,
                                                             &aqm->receiver))
@@ -11977,10 +12384,11 @@ static void
 do_shutdown (void *cls)
 {
   struct LearnLaunchEntry *lle;
+  (void) cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "shutdown logic\n");
-  (void) cls;
+  GNUNET_NAT_unregister (nh);
   GNUNET_CONTAINER_multipeermap_iterate (neighbours,
                                          &free_neighbour_cb, NULL);
   if (NULL != validation_task)
@@ -12134,6 +12542,15 @@ run (void *cls,
   GST_stats = GNUNET_STATISTICS_create ("transport", GST_cfg);
   GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
   peerstore = GNUNET_PEERSTORE_connect (GST_cfg);
+  nh = GNUNET_NAT_register (GST_cfg,
+                            "transport",
+                            0,
+                            0,
+                            NULL,
+                            0,
+                            NULL,
+                            NULL,
+                            NULL);
   if (NULL == peerstore)
   {
     GNUNET_break (0);