1 files changed, 351 insertions, 104 deletions

diff --git a/src/transport/gnunet-communicator-tcp.c b/src/transport/gnunet-communicator-tcp.c
index 880145424..59f42496a 100644
--- a/src/transport/gnunet-communicator-tcp.c
+++ b/src/transport/gnunet-communicator-tcp.c
@@ -308,6 +308,38 @@ struct TCPRekey
   struct GNUNET_TIME_AbsoluteNBO monotonic_time;
 };
 
+/**
+ * Signature we use to verify that the ephemeral key was really chosen by
+ * the specified sender.
+ */
+struct TcpRekeySignature
+{
+  /**
+   * Purpose must be #GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY
+   */
+  struct GNUNET_CRYPTO_EccSignaturePurpose purpose;
+
+  /**
+   * Identity of the inititor of the TCP connection (TCP client).
+   */
+  struct GNUNET_PeerIdentity sender;
+
+  /**
+   * Presumed identity of the target of the TCP connection (TCP server)
+   */
+  struct GNUNET_PeerIdentity receiver;
+
+  /**
+   * Ephemeral key used by the @e sender.
+   */
+  struct GNUNET_CRYPTO_EcdhePublicKey ephemeral;
+
+  /**
+   * Monotonic time of @e sender, to possibly help detect replay attacks
+   * (if receiver persists times by sender).
+   */
+  struct GNUNET_TIME_AbsoluteNBO monotonic_time;
+};
 
 /**
  * TCP finish. Sender asks for the connection to be closed.
@@ -362,11 +394,6 @@ struct Queue
   struct GNUNET_PeerIdentity target;
 
   /**
-   * ID of listen task
-   */
-  struct GNUNET_SCHEDULER_Task *listen_task;
-
-  /**
    * Listen socket.
    */
   struct GNUNET_NETWORK_Handle *listen_sock;
@@ -606,11 +633,6 @@ struct ProtoQueue
   struct ProtoQueue *prev;
 
   /**
-   * ID of listen task
-   */
-  struct GNUNET_SCHEDULER_Task *listen_task;
-
-  /**
    * Listen socket.
    */
   struct GNUNET_NETWORK_Handle *listen_sock;
@@ -729,6 +751,11 @@ static struct GNUNET_TRANSPORT_CommunicatorHandle *ch;
 static struct GNUNET_CONTAINER_MultiPeerMap *queue_map;
 
 /**
+ * ListenTasks (map from socket to `struct ListenTask`)
+ */
+static struct GNUNET_CONTAINER_MultiHashMap *lt_map;
+
+/**
  * Our public key.
  */
 static struct GNUNET_PeerIdentity my_identity;
@@ -784,6 +811,16 @@ struct Addresses *addrs_head;
 struct Addresses *addrs_tail;
 
 /**
+ * Head of DLL with ListenTasks.
+ */
+struct ListenTask *lts_head;
+
+/**
+ * Head of DLL with ListenTask.
+ */
+struct ListenTask *lts_tail;
+
+/**
  * Number of addresses in the DLL for register at NAT service.
  */
 int addrs_lens;
@@ -799,6 +836,16 @@ size_t unverified_size;
 static struct GNUNET_PEERSTORE_Handle *peerstore;
 
 /**
+ * A flag indicating we are already doing a shutdown.
+ */
+int shutdown_running = GNUNET_NO;
+
+/**
+ * The port the communicator should be assigned to.
+ */
+unsigned int bind_port;
+
+/**
  * We have been notified that our listen socket has something to
  * read. Do the read and reschedule this function to be called again
  * once more is available.
@@ -808,7 +855,6 @@ static struct GNUNET_PEERSTORE_Handle *peerstore;
 static void
 listen_cb (void *cls);
 
-
 /**
  * Functions with this signature are called whenever we need
  * to close a queue due to a disconnect or failure to
@@ -819,11 +865,14 @@ listen_cb (void *cls);
 static void
 queue_destroy (struct Queue *queue)
 {
-  struct GNUNET_MQ_Handle *mq;
-  struct ListenTask *lt;
-  lt = GNUNET_new (struct ListenTask);
-  lt->listen_sock = queue->listen_sock;
-  lt->listen_task = queue->listen_task;
+  struct ListenTask *lt = NULL;
+  struct GNUNET_HashCode h_sock;
+
+  GNUNET_CRYPTO_hash (queue->listen_sock,
+                      sizeof(queue->listen_sock),
+                      &h_sock);
+
+  lt =   GNUNET_CONTAINER_multihashmap_get (lt_map, &h_sock);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Disconnecting queue for peer `%s'\n",
@@ -858,11 +907,6 @@ queue_destroy (struct Queue *queue)
     GNUNET_PEERSTORE_iterate_cancel (queue->handshake_ack_monotime_get);
     queue->handshake_ack_monotime_get = NULL;
   }
-  if (NULL != (mq = queue->mq))
-  {
-    queue->mq = NULL;
-    GNUNET_MQ_destroy (mq);
-  }
   if (NULL != queue->qh)
   {
     GNUNET_TRANSPORT_communicator_mq_del (queue->qh);
@@ -885,7 +929,11 @@ queue_destroy (struct Queue *queue)
     GNUNET_SCHEDULER_cancel (queue->write_task);
     queue->write_task = NULL;
   }
-  GNUNET_NETWORK_socket_close (queue->sock);
+  if (GNUNET_SYSERR == GNUNET_NETWORK_socket_close (queue->sock))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "closing socket failed\n");
+  }
   gcry_cipher_close (queue->in_cipher);
   gcry_cipher_close (queue->out_cipher);
   GNUNET_free (queue->address);
@@ -894,12 +942,18 @@ queue_destroy (struct Queue *queue)
   else
     GNUNET_free (queue);
 
-  if (NULL == lt->listen_task)
+  if ((! shutdown_running) && (NULL == lt->listen_task))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "add read net listen\n");
     lt->listen_task = GNUNET_SCHEDULER_add_read_net (
       GNUNET_TIME_UNIT_FOREVER_REL,
       lt->listen_sock,
       &listen_cb,
       lt);
+  }
+  else
+    GNUNET_free (lt);
 }
 
 
@@ -1001,6 +1055,13 @@ core_read_finished_cb (void *cls, int success)
                               "# messages lost in communicator API towards CORE",
                               1,
                               GNUNET_NO);
+  if (NULL == queue)
+    return;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "backpressure %u\n",
+              queue->backpressure);
+
   queue->backpressure--;
   /* handle deferred queue destruction */
   if ((queue->destroyed) && (0 == queue->backpressure))
@@ -1008,15 +1069,18 @@ core_read_finished_cb (void *cls, int success)
     GNUNET_free (queue);
     return;
   }
-  reschedule_queue_timeout (queue);
-  /* possibly unchoke reading, now that CORE made progress */
-  if (NULL == queue->read_task)
-    queue->read_task =
-      GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining (
-                                       queue->timeout),
-                                     queue->sock,
-                                     &queue_read,
-                                     queue);
+  else if (GNUNET_YES != queue->destroyed)
+  {
+    reschedule_queue_timeout (queue);
+    /* possibly unchoke reading, now that CORE made progress */
+    if (NULL == queue->read_task)
+      queue->read_task =
+        GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining (
+                                         queue->timeout),
+                                       queue->sock,
+                                       &queue_read,
+                                       queue);
+  }
 }
 
 
@@ -1219,13 +1283,34 @@ rekey_monotime_cb (void *cls,
 static void
 do_rekey (struct Queue *queue, const struct TCPRekey *rekey)
 {
-  struct TcpHandshakeSignature thp;
+  struct TcpRekeySignature thp;
+
   thp.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY);
   thp.purpose.size = htonl (sizeof(thp));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "do_rekey size %u\n",
+              thp.purpose.size);
   thp.sender = queue->target;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sender %s\n",
+              GNUNET_p2s (&thp.sender.public_key));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sender %s\n",
+              GNUNET_p2s (&queue->target.public_key));
   thp.receiver = my_identity;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "receiver %s\n",
+              GNUNET_p2s (&thp.receiver.public_key));
   thp.ephemeral = rekey->ephemeral;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "ephemeral %s\n",
+              GNUNET_e2s (&thp.ephemeral));
   thp.monotonic_time = rekey->monotonic_time;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "time %s\n",
+              GNUNET_STRINGS_absolute_time_to_string (
+                GNUNET_TIME_absolute_ntoh (thp.monotonic_time)));
+  GNUNET_assert (ntohl ((&thp)->purpose.size) == sizeof (*(&thp)));
   if (GNUNET_OK !=
       GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY,
                                   &thp,
@@ -1359,7 +1444,7 @@ try_handle_plaintext (struct Queue *queue)
   if ((-1 != unverified_size) && (unverified_size > INITIAL_CORE_KX_SIZE))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Already received data of size %u bigger than KX size %u!\n",
+                "Already received data of size %lu bigger than KX size %lu!\n",
                 unverified_size,
                 INITIAL_CORE_KX_SIZE);
     GNUNET_break_op (0);
@@ -1636,6 +1721,8 @@ tcp_address_to_sockaddr_numeric_v6 (socklen_t *sock_len, struct sockaddr_in6 v6,
 #if HAVE_SOCKADDR_IN_SIN_LEN
   v6.sin6_len = sizeof(sizeof(struct sockaddr_in6));
 #endif
+  v6.sin6_flowinfo = 0;
+  v6.sin6_scope_id = 0;
   in = GNUNET_memdup (&v6, sizeof(v6));
   *sock_len = sizeof(struct sockaddr_in6);
 
@@ -1739,11 +1826,19 @@ extract_address (const char *bindto)
   char *cp;
   char *rest = NULL;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "extract address with bindto %s\n",
+              bindto);
+
   if (NULL == bindto)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "bindto is NULL\n");
 
   cp = GNUNET_strdup (bindto);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "extract address 2\n");
+
   start = cp;
   if (('[' == *cp) && (']' == cp[strlen (cp) - 1]))
   {
@@ -1763,7 +1858,11 @@ extract_address (const char *bindto)
     }
   }
 
-  GNUNET_free (cp);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "extract address 3\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "extract address with start %s\n",
+              start);
 
   return start;
 }
@@ -1865,10 +1964,25 @@ tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
   // cp = GNUNET_strdup (bindto);
   start = extract_address (bindto);
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "start %s\n",
+              start);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "!bindto %s\n",
+              bindto);
+
+
+
   if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
   {
     // colon = strrchr (cp, ':');
     port = extract_port (bindto);
+
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "port %u\n",
+                port);
+
     in = tcp_address_to_sockaddr_numeric_v4 (sock_len, v4, port);
   }
   else if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
@@ -1877,6 +1991,11 @@ tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
     port = extract_port (bindto);
     in = tcp_address_to_sockaddr_numeric_v6 (sock_len, v6, port);
   }
+  else{
+    GNUNET_assert (0);
+  }
+
+  // GNUNET_free (start);
 
   return in;
 }
@@ -1913,7 +2032,7 @@ static void
 inject_rekey (struct Queue *queue)
 {
   struct TCPRekey rekey;
-  struct TcpHandshakeSignature thp;
+  struct TcpRekeySignature thp;
 
   GNUNET_assert (0 == queue->pwrite_off);
   memset (&rekey, 0, sizeof(rekey));
@@ -1925,10 +2044,26 @@ inject_rekey (struct Queue *queue)
     GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get_monotonic (cfg));
   thp.purpose.purpose = htonl (GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY);
   thp.purpose.size = htonl (sizeof(thp));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "inject_rekey size %u\n",
+              thp.purpose.size);
   thp.sender = my_identity;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "sender %s\n",
+              GNUNET_p2s (&thp.sender.public_key));
   thp.receiver = queue->target;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "receiver %s\n",
+              GNUNET_p2s (&thp.receiver.public_key));
   thp.ephemeral = rekey.ephemeral;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "ephemeral %s\n",
+              GNUNET_e2s (&thp.ephemeral));
   thp.monotonic_time = rekey.monotonic_time;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "time %s\n",
+              GNUNET_STRINGS_absolute_time_to_string (
+                GNUNET_TIME_absolute_ntoh (thp.monotonic_time)));
   GNUNET_CRYPTO_eddsa_sign (my_private_key,
                             &thp,
                             &rekey.sender_sig);
@@ -2004,10 +2139,11 @@ queue_write (void *cls)
     queue->cwrite_off += queue->pwrite_off;
     queue->pwrite_off = 0;
   }
-  if ((0 == queue->pwrite_off) &&
-      ((0 == queue->rekey_left_bytes) ||
-       (0 ==
-        GNUNET_TIME_absolute_get_remaining (queue->rekey_time).rel_value_us)))
+  if ((-1 != unverified_size)&& ((0 == queue->pwrite_off) &&
+                                 ((0 == queue->rekey_left_bytes) ||
+                                  (0 ==
+                                   GNUNET_TIME_absolute_get_remaining (
+                                     queue->rekey_time).rel_value_us))))
   {
     inject_rekey (queue);
   }
@@ -2403,11 +2539,6 @@ decrypt_and_check_tc (struct Queue *queue,
 static void
 free_proto_queue (struct ProtoQueue *pq)
 {
-  if (NULL != pq->listen_task)
-  {
-    GNUNET_SCHEDULER_cancel (pq->listen_task);
-    pq->listen_task = NULL;
-  }
   if (NULL != pq->listen_sock)
   {
     GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pq->listen_sock));
@@ -2526,7 +2657,6 @@ proto_read_kx (void *cls)
   queue->address = pq->address; /* steals reference */
   queue->address_len = pq->address_len;
   queue->target = tc.sender;
-  queue->listen_task = pq->listen_task;
   queue->listen_sock = pq->listen_sock;
   queue->sock = pq->sock;
 
@@ -2569,6 +2699,9 @@ listen_cb (void *cls)
   struct ProtoQueue *pq;
   struct ListenTask *lt;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "listen_cb\n");
+
   lt = cls;
 
   lt->listen_task = NULL;
@@ -2707,7 +2840,7 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
   struct Queue *queue;
   const char *path;
   struct sockaddr *in;
-  socklen_t in_len;
+  socklen_t in_len = 0;
   struct GNUNET_NETWORK_Handle *sock;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -2729,6 +2862,10 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
     return GNUNET_SYSERR;
   }
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "in %s\n",
+              GNUNET_a2s (in, in_len));
+
   sock = GNUNET_NETWORK_socket_create (in->sa_family, SOCK_STREAM, IPPROTO_TCP);
   if (NULL == sock)
   {
@@ -2778,6 +2915,36 @@ mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
 }
 
 /**
+ * Iterator over all ListenTasks to clean up.
+ *
+ * @param cls NULL
+ * @param key unused
+ * @param value the ListenTask to cancel.
+ * @return #GNUNET_OK to continue to iterate
+ */
+static int
+get_lt_delete_it (void *cls,
+                  const struct GNUNET_HashCode *key,
+                  void *value)
+{
+  struct ListenTask *lt = value;
+
+  (void) cls;
+  (void) key;
+  if (NULL != lt->listen_task)
+  {
+    GNUNET_SCHEDULER_cancel (lt->listen_task);
+    lt->listen_task = NULL;
+  }
+  if (NULL != lt->listen_sock)
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (lt->listen_sock));
+    lt->listen_sock = NULL;
+  }
+  return GNUNET_OK;
+}
+
+/**
  * Iterator over all message queues to clean up.
  *
  * @param cls NULL
@@ -2798,7 +2965,6 @@ get_queue_delete_it (void *cls,
   return GNUNET_OK;
 }
 
-
 /**
  * Shutdown the UNIX communicator.
  *
@@ -2807,6 +2973,15 @@ get_queue_delete_it (void *cls,
 static void
 do_shutdown (void *cls)
 {
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutdown %s!\n",
+              shutdown_running ? "running" : "not running");
+
+  if (GNUNET_YES == shutdown_running)
+    return;
+  else
+    shutdown_running = GNUNET_YES;
+
   while (NULL != proto_head)
     free_proto_queue (proto_head);
   if (NULL != nat)
@@ -2814,8 +2989,10 @@ do_shutdown (void *cls)
     GNUNET_NAT_unregister (nat);
     nat = NULL;
   }
+  GNUNET_CONTAINER_multihashmap_iterate (lt_map, &get_lt_delete_it, NULL);
   GNUNET_CONTAINER_multipeermap_iterate (queue_map, &get_queue_delete_it, NULL);
   GNUNET_CONTAINER_multipeermap_destroy (queue_map);
+  GNUNET_TRANSPORT_communicator_address_remove_all (ch);
   if (NULL != ch)
   {
     GNUNET_TRANSPORT_communicator_disconnect (ch);
@@ -2836,6 +3013,18 @@ do_shutdown (void *cls)
     GNUNET_NT_scanner_done (is);
     is = NULL;
   }
+  if (NULL != peerstore)
+  {
+    GNUNET_PEERSTORE_disconnect (peerstore, GNUNET_NO);
+    peerstore = NULL;
+  }
+  if (NULL != resolve_request_handle)
+  {
+    GNUNET_RESOLVER_request_cancel (resolve_request_handle);
+    resolve_request_handle = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutdown done!\n");
 }
 
 
@@ -2886,6 +3075,11 @@ nat_address_cb (void *cls,
   char *my_addr;
   struct GNUNET_TRANSPORT_AddressIdentifier *ai;
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "nat address cb %s %s\n",
+              add_remove ? "add" : "remove",
+              GNUNET_a2s (addr, addrlen));
+
   if (GNUNET_YES == add_remove)
   {
     enum GNUNET_NetworkType nt;
@@ -2912,6 +3106,35 @@ nat_address_cb (void *cls,
 }
 
 /**
+ * This method adds addresses to the DLL, that are later register at the NAT service.
+ */
+static void
+add_addr (struct sockaddr *in, socklen_t in_len)
+{
+
+  struct Addresses *saddrs;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "add address %s\n",
+              GNUNET_a2s (in, in_len));
+
+  saddrs = GNUNET_new (struct Addresses);
+  saddrs->addr = in;
+  saddrs->addr_len = in_len;
+  GNUNET_CONTAINER_DLL_insert (addrs_head, addrs_tail, saddrs);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "after add address %s\n",
+              GNUNET_a2s (in, in_len));
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "add address %s\n",
+              GNUNET_a2s (saddrs->addr, saddrs->addr_len));
+
+  addrs_lens++;
+}
+
+/**
  * This method launch network interactions for each address we like to bind to.
  *
  * @param addr The address we will listen to.
@@ -2919,13 +3142,14 @@ nat_address_cb (void *cls,
  * @return GNUNET_SYSERR in case of error. GNUNET_OK in case we are successfully listen to the address.
  */
 static int
-init_socket (const struct sockaddr *addr,
+init_socket (struct sockaddr *addr,
              socklen_t in_len)
 {
   struct sockaddr_storage in_sto;
   socklen_t sto_len;
   struct GNUNET_NETWORK_Handle *listen_sock;
   struct ListenTask *lt;
+  struct GNUNET_HashCode h_sock;
 
   if (NULL == addr)
   {
@@ -2977,13 +3201,12 @@ init_socket (const struct sockaddr *addr,
     sto_len = in_len;
   }
 
-  addr = (struct sockaddr *) &in_sto;
+  // addr = (struct sockaddr *) &in_sto;
   in_len = sto_len;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Bound to `%s'\n",
               GNUNET_a2s ((const struct sockaddr *) &in_sto, sto_len));
   stats = GNUNET_STATISTICS_create ("C-TCP", cfg);
-  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 
   if (NULL == is)
     is = GNUNET_NT_scanner_init ();
@@ -3012,6 +3235,27 @@ init_socket (const struct sockaddr *addr,
                                                    &listen_cb,
                                                    lt);
 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "creating hash\n");
+  GNUNET_CRYPTO_hash (lt->listen_sock,
+                      sizeof(lt->listen_sock),
+                      &h_sock);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "creating map\n");
+  if (NULL == lt_map)
+    lt_map = GNUNET_CONTAINER_multihashmap_create (2, GNUNET_NO);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "creating map entry\n");
+  GNUNET_CONTAINER_multihashmap_put (lt_map,
+                                     &h_sock,
+                                     lt,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "map entry created\n");
+
   if (NULL == queue_map)
     queue_map = GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
 
@@ -3034,6 +3278,7 @@ init_socket (const struct sockaddr *addr,
     return GNUNET_SYSERR;
   }
 
+  add_addr (addr, in_len);
   return GNUNET_OK;
 
 }
@@ -3050,6 +3295,10 @@ nat_register ()
   int i;
   struct Addresses *pos;
 
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "starting nat register!\n");
+
   i = 0;
   saddrs = GNUNET_malloc ((addrs_lens + 1) * sizeof(struct sockaddr *));
 
@@ -3058,9 +3307,12 @@ nat_register ()
   for (pos = addrs_head; NULL != pos; pos = pos->next)
   {
 
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "registering address %s\n",
+                GNUNET_a2s (addrs_head->addr, addrs_head->addr_len));
+
     saddr_lens[i] = addrs_head->addr_len;
-    saddrs[i] = GNUNET_malloc (saddr_lens[i]);
-    saddrs[i] = addrs_head->addr;
+    saddrs[i] = GNUNET_memdup (addrs_head->addr, saddr_lens[i]);
 
     i++;
 
@@ -3078,8 +3330,8 @@ nat_register ()
 
   i = 0;
 
-  /*for (i = addrs_lens - 1; i >= 0; i--)
-    GNUNET_free (saddrs[i]);*/
+  for (i = addrs_lens - 1; i >= 0; i--)
+    GNUNET_free (saddrs[i]);
   GNUNET_free (saddrs);
   GNUNET_free (saddr_lens);
 
@@ -3093,22 +3345,6 @@ nat_register ()
 }
 
 /**
- * This method adds addresses to the DLL, that are later register at the NAT service.
- */
-static void
-add_addr (struct sockaddr *in, socklen_t in_len)
-{
-
-  struct Addresses *saddrs;
-
-  saddrs = GNUNET_new (struct Addresses);
-  saddrs->addr = in;
-  saddrs->addr_len = in_len;
-  GNUNET_CONTAINER_DLL_insert (addrs_head, addrs_tail, saddrs);
-  addrs_lens++;
-}
-
-/**
  * This method is the callback called by the resolver API, and wraps method init_socket.
  *
  * @param cls The port we will bind to.
@@ -3123,22 +3359,19 @@ init_socket_resolv (void *cls,
   struct sockaddr_in *v4;
   struct sockaddr_in6 *v6;
   struct sockaddr *in;
-  unsigned int *port;
 
-  port = cls;
+  (void) cls;
   if (NULL  != addr)
   {
     if (AF_INET == addr->sa_family)
     {
       v4 = (struct sockaddr_in *) addr;
-      in = tcp_address_to_sockaddr_numeric_v4 (&in_len, *v4, *port);// _global);
-      add_addr (in, in_len);
+      in = tcp_address_to_sockaddr_numeric_v4 (&in_len, *v4, bind_port);// _global);
     }
     else if (AF_INET6 == addr->sa_family)
     {
       v6 = (struct sockaddr_in6 *) addr;
-      in = tcp_address_to_sockaddr_numeric_v6 (&in_len, *v6, *port);// _global);
-      add_addr (in, in_len);
+      in = tcp_address_to_sockaddr_numeric_v6 (&in_len, *v6, bind_port);// _global);
     }
     else
     {
@@ -3149,14 +3382,20 @@ init_socket_resolv (void *cls,
                   AF_INET6);
       return;
     }
-    init_socket (in,
-                 in_len);
+    init_socket (in, in_len);
   }
   else
   {
     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                 "Address is NULL. This might be an error or the resolver finished resolving.\n");
+    if (NULL == addrs_head)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "Resolver finished resolving, but we do not listen to an address!.\n");
+      return;
+    }
     nat_register ();
+
   }
 }
 
@@ -3221,12 +3460,11 @@ run (void *cls,
     return;
   }
 
-  // cp = GNUNET_strdup (bindto);
-  start = extract_address (bindto);
+  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
 
-  if (1 == sscanf (bindto, "%u%1s", &port, dummy))
+  if (1 == sscanf (bindto, "%u%1s", &bind_port, dummy))
   {
-    po = tcp_address_to_sockaddr_port_only (bindto, &port);
+    po = tcp_address_to_sockaddr_port_only (bindto, &bind_port);
 
     addr_len_ipv4 = po->addr_len_ipv4;
 
@@ -3238,46 +3476,55 @@ run (void *cls,
     if (NULL != po->addr_ipv4)
     {
       init_socket (po->addr_ipv4, addr_len_ipv4);
-      add_addr (po->addr_ipv4, addr_len_ipv4);
     }
 
     if (NULL != po->addr_ipv6)
     {
       addr_len_ipv6 = po->addr_len_ipv6;
       init_socket (po->addr_ipv6, addr_len_ipv6);
-      add_addr (po->addr_ipv6, addr_len_ipv6);
     }
 
+    GNUNET_free (po);
     nat_register ();
+    GNUNET_free (bindto);
+
+    return;
   }
-  else if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
+
+  start = extract_address (bindto);
+
+  if (1 == inet_pton (AF_INET, start, &v4.sin_addr))
   {
-    port = extract_port (bindto);
+    bind_port = extract_port (bindto);
 
-    in = tcp_address_to_sockaddr_numeric_v4 (&in_len, v4, port);
+    in = tcp_address_to_sockaddr_numeric_v4 (&in_len, v4, bind_port);
     init_socket (in, in_len);
-    add_addr (in, in_len);
     nat_register ();
+    GNUNET_free (bindto);
+
+    return;
   }
-  else if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
+
+  if (1 == inet_pton (AF_INET6, start, &v6.sin6_addr))
   {
-    port = extract_port (bindto);
-    in = tcp_address_to_sockaddr_numeric_v6 (&in_len, v6, port);
+    bind_port = extract_port (bindto);
+    in = tcp_address_to_sockaddr_numeric_v6 (&in_len, v6, bind_port);
     init_socket (in, in_len);
-    add_addr (in, in_len);
     nat_register ();
-  }
-  else
-  {
-    port = extract_port (bindto);
+    GNUNET_free (bindto);
 
-    resolve_request_handle = GNUNET_RESOLVER_ip_get (strtok_r (bindto, ":",
-                                                               &rest),
-                                                     AF_UNSPEC,
-                                                     GNUNET_TIME_UNIT_MINUTES,
-                                                     &init_socket_resolv,
-                                                     &port);
+    return;
   }
+
+
+  bind_port = extract_port (bindto);
+
+  resolve_request_handle = GNUNET_RESOLVER_ip_get (strtok_r (bindto, ":",
+                                                             &rest),
+                                                   AF_UNSPEC,
+                                                   GNUNET_TIME_UNIT_MINUTES,
+                                                   &init_socket_resolv,
+                                                   &port);
   GNUNET_free (bindto);
 }