regex profiler cleanup
[oweals/gnunet.git] / src / nat / nat.c
index ed72be9f8b4b4528714621b33350754f6fa7d190..dd63224c0a425890bc9904a7a3d4e2c91f175af3 100644 (file)
@@ -29,8 +29,9 @@
 #include "gnunet_util_lib.h"
 #include "gnunet_resolver_service.h"
 #include "gnunet_nat_lib.h"
+#include "nat.h"
 
-#define DEBUG_NAT GNUNET_NO
+#define LOG(kind,...) GNUNET_log_from (kind, "nat", __VA_ARGS__)
 
 /**
  * How often do we scan for changes in our IP address from our local
@@ -57,7 +58,7 @@
 
 /**
  * Where did the given local address originate from?
- * To be used for debugging as well as in the future 
+ * To be used for debugging as well as in the future
  * to remove all addresses from a certain source when
  * we reevaluate the source.
  */
@@ -293,7 +294,8 @@ struct GNUNET_NAT_Handle
   unsigned int num_local_addrs;
 
   /**
-   * The our external address (according to config, UPnP may disagree...)
+   * Our external address (according to config, UPnP may disagree...),
+   * in dotted decimal notation, IPv4-only. Or NULL if not known.
    */
   char *external_address;
 
@@ -332,6 +334,11 @@ struct GNUNET_NAT_Handle
    */
   int use_localaddresses;
 
+  /**
+   * Should we return local addresses to clients
+   */
+  int return_localaddress;
+
   /**
    * Should we do a DNS lookup of our hostname to find out our own IP?
    */
@@ -361,14 +368,15 @@ struct GNUNET_NAT_Handle
  *
  * @param h handle to NAT
  */
-static void start_gnunet_nat_server (struct GNUNET_NAT_Handle *h);
+static void
+start_gnunet_nat_server (struct GNUNET_NAT_Handle *h);
 
 
 /**
  * Remove all addresses from the list of 'local' addresses
  * that originated from the given source.
- * 
- * @param plugin the plugin
+ *
+ * @param h handle to NAT
  * @param src source that identifies addresses to remove
  */
 static void
@@ -386,8 +394,7 @@ remove_from_address_list_by_source (struct GNUNET_NAT_Handle *h,
       continue;
     GNUNET_CONTAINER_DLL_remove (h->lal_head, h->lal_tail, pos);
     if (NULL != h->address_callback)
-      h->address_callback (h->callback_cls,
-                           GNUNET_NO,
+      h->address_callback (h->callback_cls, GNUNET_NO,
                            (const struct sockaddr *) &pos[1], pos->addrlen);
     GNUNET_free (pos);
   }
@@ -396,9 +403,9 @@ remove_from_address_list_by_source (struct GNUNET_NAT_Handle *h,
 
 /**
  * Add the given address to the list of 'local' addresses, thereby
- * making it a 'legal' address for this peer to have.  
- * 
- * @param plugin the plugin
+ * making it a 'legal' address for this peer to have.
+ *
+ * @param h handle to NAT
  * @param src where did the local address originate from?
  * @param arg the address, some 'struct sockaddr'
  * @param arg_size number of bytes in arg
@@ -415,12 +422,8 @@ add_to_address_list_as_is (struct GNUNET_NAT_Handle *h,
   lal->addrlen = arg_size;
   lal->source = src;
   GNUNET_CONTAINER_DLL_insert (h->lal_head, h->lal_tail, lal);
-#if DEBUG_NAT
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "nat",
-                   "Adding address `%s' from source %d\n",
-                   GNUNET_a2s (arg, arg_size), src);
-#endif
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding address `%s' from source %d\n",
+       GNUNET_a2s (arg, arg_size), src);
   if (NULL != h->address_callback)
     h->address_callback (h->callback_cls, GNUNET_YES, arg, arg_size);
 }
@@ -431,15 +434,14 @@ add_to_address_list_as_is (struct GNUNET_NAT_Handle *h,
  * making it a 'legal' address for this peer to have.   Set the
  * port number in the process to the advertised port and possibly
  * also to zero (if we have the gnunet-helper-nat-server).
- * 
- * @param plugin the plugin
+ *
+ * @param h handle to NAT
  * @param src where did the local address originate from?
  * @param arg the address, some 'struct sockaddr'
  * @param arg_size number of bytes in arg
  */
 static void
-add_to_address_list (struct GNUNET_NAT_Handle *h,
-                     enum LocalAddressSource src,
+add_to_address_list (struct GNUNET_NAT_Handle *h, enum LocalAddressSource src,
                      const struct sockaddr *arg, socklen_t arg_size)
 {
   struct sockaddr_in s4;
@@ -452,17 +454,13 @@ add_to_address_list (struct GNUNET_NAT_Handle *h,
     in4 = (const struct sockaddr_in *) arg;
     s4 = *in4;
     s4.sin_port = htons (h->adv_port);
-    add_to_address_list_as_is (h,
-                               src,
-                               (const struct sockaddr *) &s4,
+    add_to_address_list_as_is (h, src, (const struct sockaddr *) &s4,
                                sizeof (struct sockaddr_in));
     if (GNUNET_YES == h->enable_nat_server)
     {
       /* also add with PORT = 0 to indicate NAT server is enabled */
       s4.sin_port = htons (0);
-      add_to_address_list_as_is (h,
-                                 src,
-                                 (const struct sockaddr *) &s4,
+      add_to_address_list_as_is (h, src, (const struct sockaddr *) &s4,
                                  sizeof (struct sockaddr_in));
     }
   }
@@ -473,9 +471,7 @@ add_to_address_list (struct GNUNET_NAT_Handle *h,
       in6 = (const struct sockaddr_in6 *) arg;
       s6 = *in6;
       s6.sin6_port = htons (h->adv_port);
-      add_to_address_list_as_is (h,
-                                 src,
-                                 (const struct sockaddr *) &s6,
+      add_to_address_list_as_is (h, src, (const struct sockaddr *) &s6,
                                  sizeof (struct sockaddr_in6));
     }
   }
@@ -488,17 +484,17 @@ add_to_address_list (struct GNUNET_NAT_Handle *h,
 
 /**
  * Add the given IP address to the list of 'local' addresses, thereby
- * making it a 'legal' address for this peer to have.  
- * 
- * @param plugin the plugin
+ * making it a 'legal' address for this peer to have.
+ *
+ * @param h handle to NAT
  * @param src where did the local address originate from?
- * @param arg the address, some 'struct in_addr' or 'struct in6_addr'
- * @param arg_size number of bytes in arg
+ * @param addr the address, some 'struct in_addr' or 'struct in6_addr'
+ * @param addrlen number of bytes in addr
  */
 static void
 add_ip_to_address_list (struct GNUNET_NAT_Handle *h,
-                        enum LocalAddressSource src,
-                        const void *addr, socklen_t addrlen)
+                        enum LocalAddressSource src, const void *addr,
+                        socklen_t addrlen)
 {
   struct sockaddr_in s4;
   const struct in_addr *in4;
@@ -515,17 +511,13 @@ add_ip_to_address_list (struct GNUNET_NAT_Handle *h,
     s4.sin_len = (u_char) sizeof (struct sockaddr_in);
 #endif
     s4.sin_addr = *in4;
-    add_to_address_list (h,
-                         src,
-                         (const struct sockaddr *) &s4,
+    add_to_address_list (h, src, (const struct sockaddr *) &s4,
                          sizeof (struct sockaddr_in));
     if (GNUNET_YES == h->enable_nat_server)
     {
       /* also add with PORT = 0 to indicate NAT server is enabled */
       s4.sin_port = htons (0);
-      add_to_address_list (h,
-                           src,
-                           (const struct sockaddr *) &s4,
+      add_to_address_list (h, src, (const struct sockaddr *) &s4,
                            sizeof (struct sockaddr_in));
 
     }
@@ -542,9 +534,7 @@ add_ip_to_address_list (struct GNUNET_NAT_Handle *h,
       s6.sin6_len = (u_char) sizeof (struct sockaddr_in6);
 #endif
       s6.sin6_addr = *in6;
-      add_to_address_list (h,
-                           src,
-                           (const struct sockaddr *) &s6,
+      add_to_address_list (h, src, (const struct sockaddr *) &s6,
                            sizeof (struct sockaddr_in6));
     }
   }
@@ -585,8 +575,8 @@ process_external_ip (void *cls, const struct sockaddr *addr, socklen_t addrlen)
     h->ext_dns = NULL;
     if (1 == inet_pton (AF_INET, h->external_address, &dummy))
       return;                   /* repated lookup pointless: was numeric! */
-    h->dns_task = GNUNET_SCHEDULER_add_delayed (h->dyndns_frequency,
-                                                &resolve_dns, h);
+    h->dns_task =
+        GNUNET_SCHEDULER_add_delayed (h->dyndns_frequency, &resolve_dns, h);
     return;
   }
   add_to_address_list (h, LAL_EXTERNAL_IP, addr, addrlen);
@@ -620,8 +610,9 @@ process_hostname_ip (void *cls, const struct sockaddr *addr, socklen_t addrlen)
   if (addr == NULL)
   {
     h->hostname_dns = NULL;
-    h->hostname_task = GNUNET_SCHEDULER_add_delayed (h->hostname_dns_frequency,
-                                                     &resolve_hostname, h);
+    h->hostname_task =
+        GNUNET_SCHEDULER_add_delayed (h->hostname_dns_frequency,
+                                      &resolve_hostname, h);
     return;
   }
   add_to_address_list (h, LAL_HOSTNAME_DNS, addr, addrlen);
@@ -636,14 +627,16 @@ process_hostname_ip (void *cls, const struct sockaddr *addr, socklen_t addrlen)
  * @param name name of the interface
  * @param isDefault do we think this may be our default interface
  * @param addr address of the interface
+ * @param broadcast_addr the broadcast address (can be NULL for unknown or unassigned)
+ * @param netmask the network mask (can be NULL for unknown or unassigned))
  * @param addrlen number of bytes in addr
  * @return GNUNET_OK to continue iterating
  */
 static int
-process_interfaces (void *cls,
-                    const char *name,
-                    int isDefault,
-                    const struct sockaddr *addr, socklen_t addrlen)
+process_interfaces (void *cls, const char *name, int isDefault,
+                    const struct sockaddr *addr,
+                    const struct sockaddr *broadcast_addr,
+                    const struct sockaddr *netmask, socklen_t addrlen)
 {
   struct GNUNET_NAT_Handle *h = cls;
   const struct sockaddr_in *s4;
@@ -656,10 +649,20 @@ process_interfaces (void *cls,
   case AF_INET:
     s4 = (struct sockaddr_in *) addr;
     ip = &s4->sin_addr;
+
+    /* Check if address is in 127.0.0.0/8 */
+    uint32_t address = ntohl ((uint32_t) (s4->sin_addr.s_addr));
+    uint32_t value = (address & 0xFF000000) ^ 0x7F000000;
+
+    if ((h->return_localaddress == GNUNET_NO) && (value == 0))
+    {
+      return GNUNET_OK;
+    }
     if (GNUNET_YES == h->use_localaddresses)
-      add_ip_to_address_list (h,
-                              LAL_INTERFACE_ADDRESS,
-                              &s4->sin_addr, sizeof (struct in_addr));
+    {
+      add_ip_to_address_list (h, LAL_INTERFACE_ADDRESS, &s4->sin_addr,
+                              sizeof (struct in_addr));
+    }
     break;
   case AF_INET6:
     s6 = (struct sockaddr_in6 *) addr;
@@ -668,26 +671,31 @@ process_interfaces (void *cls,
       /* skip link local addresses */
       return GNUNET_OK;
     }
+    if ((h->return_localaddress == GNUNET_NO) &&
+        (IN6_IS_ADDR_LOOPBACK (&((struct sockaddr_in6 *) addr)->sin6_addr)))
+    {
+      return GNUNET_OK;
+    }
     ip = &s6->sin6_addr;
     if (GNUNET_YES == h->use_localaddresses)
-      add_ip_to_address_list (h,
-                              LAL_INTERFACE_ADDRESS,
-                              &s6->sin6_addr, sizeof (struct in6_addr));
+    {
+      add_ip_to_address_list (h, LAL_INTERFACE_ADDRESS, &s6->sin6_addr,
+                              sizeof (struct in6_addr));
+    }
     break;
   default:
     GNUNET_break (0);
     return GNUNET_OK;
   }
-  if ((h->internal_address == NULL) &&
-      (h->server_proc == NULL) &&
+  if ((h->internal_address == NULL) && (h->server_proc == NULL) &&
       (h->server_read_task == GNUNET_SCHEDULER_NO_TASK) &&
-      (GNUNET_YES == isDefault) &&
-      ((addr->sa_family == AF_INET) || (addr->sa_family == AF_INET6)))
+      (GNUNET_YES == isDefault) && ((addr->sa_family == AF_INET) ||
+                                    (addr->sa_family == AF_INET6)))
   {
     /* no internal address configured, but we found a "default"
      * interface, try using that as our 'internal' address */
-    h->internal_address = GNUNET_strdup (inet_ntop (addr->sa_family,
-                                                    ip, buf, sizeof (buf)));
+    h->internal_address =
+        GNUNET_strdup (inet_ntop (addr->sa_family, ip, buf, sizeof (buf)));
     start_gnunet_nat_server (h);
   }
   return GNUNET_OK;
@@ -736,30 +744,22 @@ nat_server_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
   memset (mybuf, 0, sizeof (mybuf));
-  bytes = GNUNET_DISK_file_read (h->server_stdout_handle,
-                                 mybuf, sizeof (mybuf));
+  bytes =
+      GNUNET_DISK_file_read (h->server_stdout_handle, mybuf, sizeof (mybuf));
   if (bytes < 1)
   {
-#if DEBUG_NAT
-    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                     "nat",
-                     "Finished reading from server stdout with code: %d\n",
-                     bytes);
-#endif
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Finished reading from server stdout with code: %d\n", bytes);
     if (0 != GNUNET_OS_process_kill (h->server_proc, SIGTERM))
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+      GNUNET_log_from_strerror (GNUNET_ERROR_TYPE_WARNING, "nat", "kill");
     GNUNET_OS_process_wait (h->server_proc);
-    GNUNET_OS_process_close (h->server_proc);
+    GNUNET_OS_process_destroy (h->server_proc);
     h->server_proc = NULL;
     GNUNET_DISK_pipe_close (h->server_stdout);
     h->server_stdout = NULL;
     h->server_stdout_handle = NULL;
     /* now try to restart it */
-    h->server_retry_delay =
-        GNUNET_TIME_relative_multiply (h->server_retry_delay, 2);
-    h->server_retry_delay =
-        GNUNET_TIME_relative_max (GNUNET_TIME_UNIT_HOURS,
-                                  h->server_retry_delay);
+    h->server_retry_delay = GNUNET_TIME_STD_BACKOFF (h->server_retry_delay);
     h->server_read_task =
         GNUNET_SCHEDULER_add_delayed (h->server_retry_delay,
                                       &restart_nat_server, h);
@@ -787,16 +787,13 @@ nat_server_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 #if HAVE_SOCKADDR_IN_SIN_LEN
   sin_addr.sin_len = sizeof (sin_addr);
 #endif
-  if ((NULL == port_start) ||
-      (1 != sscanf (port_start, "%d", &port)) ||
+  if ((NULL == port_start) || (1 != SSCANF (port_start, "%d", &port)) ||
       (-1 == inet_pton (AF_INET, mybuf, &sin_addr.sin_addr)))
   {
     /* should we restart gnunet-helper-nat-server? */
-    GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
-                     "nat",
-                     _
-                     ("gnunet-helper-nat-server generated malformed address `%s'\n"),
-                     mybuf);
+    LOG (GNUNET_ERROR_TYPE_WARNING, "nat",
+         _("gnunet-helper-nat-server generated malformed address `%s'\n"),
+         mybuf);
     h->server_read_task =
         GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                         h->server_stdout_handle,
@@ -804,17 +801,14 @@ nat_server_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     return;
   }
   sin_addr.sin_port = htons ((uint16_t) port);
-#if DEBUG_NAT
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "nat",
-                   "gnunet-helper-nat-server read: %s:%d\n", mybuf, port);
-#endif
-  h->reversal_callback (h->callback_cls,
-                        (const struct sockaddr *) &sin_addr, sizeof (sin_addr));
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "gnunet-helper-nat-server read: %s:%d\n", mybuf,
+       port);
+  h->reversal_callback (h->callback_cls, (const struct sockaddr *) &sin_addr,
+                        sizeof (sin_addr));
   h->server_read_task =
       GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                      h->server_stdout_handle,
-                                      &nat_server_read, h);
+                                      h->server_stdout_handle, &nat_server_read,
+                                      h);
 }
 
 
@@ -827,29 +821,28 @@ nat_server_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 start_gnunet_nat_server (struct GNUNET_NAT_Handle *h)
 {
-  if ((h->behind_nat == GNUNET_YES) &&
-      (h->enable_nat_server == GNUNET_YES) &&
+  char *binary;
+
+  if ((h->behind_nat == GNUNET_YES) && (h->enable_nat_server == GNUNET_YES) &&
       (h->internal_address != NULL) &&
-      (NULL != (h->server_stdout = GNUNET_DISK_pipe (GNUNET_YES,
-                                                     GNUNET_NO, GNUNET_YES))))
+      (NULL !=
+       (h->server_stdout =
+        GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES))))
   {
-#if DEBUG_NAT
-    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                     "nat"
-                     "Starting %s at `%s'\n",
-                     "gnunet-helper-nat-server", h->internal_address);
-#endif
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting `%s' at `%s'\n",
+         "gnunet-helper-nat-server", h->internal_address);
     /* Start the server process */
-    h->server_proc = GNUNET_OS_start_process (NULL,
-                                              h->server_stdout,
-                                              "gnunet-helper-nat-server",
-                                              "gnunet-helper-nat-server",
-                                              h->internal_address, NULL);
+    binary = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-server");
+    h->server_proc =
+        GNUNET_OS_start_process (GNUNET_NO, 0, NULL, h->server_stdout,
+                                 binary,
+                                 "gnunet-helper-nat-server",
+                                 h->internal_address, NULL);
+    GNUNET_free (binary);
     if (h->server_proc == NULL)
     {
-      GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
-                       "nat",
-                       _("Failed to start %s\n"), "gnunet-helper-nat-server");
+      LOG (GNUNET_ERROR_TYPE_WARNING, "nat", _("Failed to start %s\n"),
+           "gnunet-helper-nat-server");
       GNUNET_DISK_pipe_close (h->server_stdout);
       h->server_stdout = NULL;
     }
@@ -857,13 +850,12 @@ start_gnunet_nat_server (struct GNUNET_NAT_Handle *h)
     {
       /* Close the write end of the read pipe */
       GNUNET_DISK_pipe_close_end (h->server_stdout, GNUNET_DISK_PIPE_END_WRITE);
-      h->server_stdout_handle
-          = GNUNET_DISK_pipe_handle (h->server_stdout,
-                                     GNUNET_DISK_PIPE_END_READ);
-      h->server_read_task
-          = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                            h->server_stdout_handle,
-                                            &nat_server_read, h);
+      h->server_stdout_handle =
+          GNUNET_DISK_pipe_handle (h->server_stdout, GNUNET_DISK_PIPE_END_READ);
+      h->server_read_task =
+          GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                          h->server_stdout_handle,
+                                          &nat_server_read, h);
     }
   }
 }
@@ -883,8 +875,8 @@ list_interfaces (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   h->ifc_task = GNUNET_SCHEDULER_NO_TASK;
   remove_from_address_list_by_source (h, LAL_INTERFACE_ADDRESS);
   GNUNET_OS_network_interfaces_list (&process_interfaces, h);
-  h->ifc_task = GNUNET_SCHEDULER_add_delayed (h->ifc_scan_frequency,
-                                              &list_interfaces, h);
+  h->ifc_task =
+      GNUNET_SCHEDULER_add_delayed (h->ifc_scan_frequency, &list_interfaces, h);
 }
 
 
@@ -901,9 +893,9 @@ resolve_hostname (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   h->hostname_task = GNUNET_SCHEDULER_NO_TASK;
   remove_from_address_list_by_source (h, LAL_HOSTNAME_DNS);
-  h->hostname_dns = GNUNET_RESOLVER_hostname_resolve (AF_UNSPEC,
-                                                      HOSTNAME_RESOLVE_TIMEOUT,
-                                                      &process_hostname_ip, h);
+  h->hostname_dns =
+      GNUNET_RESOLVER_hostname_resolve (AF_UNSPEC, HOSTNAME_RESOLVE_TIMEOUT,
+                                        &process_hostname_ip, h);
 }
 
 
@@ -921,10 +913,10 @@ resolve_dns (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   h->dns_task = GNUNET_SCHEDULER_NO_TASK;
   remove_from_address_list_by_source (h, LAL_EXTERNAL_IP);
-  h->ext_dns = GNUNET_RESOLVER_ip_get (h->external_address,
-                                       AF_INET,
-                                       GNUNET_TIME_UNIT_MINUTES,
-                                       &process_external_ip, h);
+  h->ext_dns =
+      GNUNET_RESOLVER_ip_get (h->external_address, AF_INET,
+                              GNUNET_TIME_UNIT_MINUTES, &process_external_ip,
+                              h);
 }
 
 
@@ -938,8 +930,8 @@ resolve_dns (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param addrlen actual lenght of the address
  */
 static void
-upnp_add (void *cls,
-          int add_remove, const struct sockaddr *addr, socklen_t addrlen)
+upnp_add (void *cls, int add_remove, const struct sockaddr *addr,
+          socklen_t addrlen)
 {
   struct GNUNET_NAT_Handle *h = cls;
   struct LocalAddressList *pos;
@@ -955,13 +947,12 @@ upnp_add (void *cls,
   while (NULL != (pos = next))
   {
     next = pos->next;
-    if ((pos->source != LAL_UPNP) ||
-        (pos->addrlen != addrlen) || (0 != memcmp (&pos[1], addr, addrlen)))
+    if ((pos->source != LAL_UPNP) || (pos->addrlen != addrlen) ||
+        (0 != memcmp (&pos[1], addr, addrlen)))
       continue;
     GNUNET_CONTAINER_DLL_remove (h->lal_head, h->lal_tail, pos);
     if (NULL != h->address_callback)
-      h->address_callback (h->callback_cls,
-                           GNUNET_NO,
+      h->address_callback (h->callback_cls, GNUNET_NO,
                            (const struct sockaddr *) &pos[1], pos->addrlen);
     GNUNET_free (pos);
     return;                     /* only remove once */
@@ -1036,8 +1027,9 @@ add_from_bind (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
         GNUNET_break (0);
         break;
       }
-      if (0 != memcmp (&((const struct sockaddr_in6 *) sa)->sin6_addr,
-                       &any, sizeof (struct in6_addr)))
+      if (0 !=
+          memcmp (&((const struct sockaddr_in6 *) sa)->sin6_addr, &any,
+                  sizeof (struct in6_addr)))
         add_to_address_list (h, LAL_BINDTO_ADDRESS, sa,
                              sizeof (struct sockaddr_in6));
       break;
@@ -1060,20 +1052,17 @@ add_from_bind (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param adv_port advertised port (port we are either bound to or that our OS
  *                 locally performs redirection from to our bound port).
  * @param num_addrs number of addresses in 'addrs'
- * @param addr the local address packets should be redirected to
- * @param addrlen actual lenght of the address
+ * @param addrs the local addresses packets should be redirected to
+ * @param addrlens actual lengths of the addresses
  * @param address_callback function to call everytime the public IP address changes
  * @param reversal_callback function to call if someone wants connection reversal from us
  * @param callback_cls closure for callbacks
- * @return NULL on error, otherwise handle that can be used to unregister 
+ * @return NULL on error, otherwise handle that can be used to unregister
  */
 struct GNUNET_NAT_Handle *
-GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                     int is_tcp,
-                     uint16_t adv_port,
-                     unsigned int num_addrs,
-                     const struct sockaddr **addrs,
-                     const socklen_t * addrlens,
+GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg, int is_tcp,
+                     uint16_t adv_port, unsigned int num_addrs,
+                     const struct sockaddr **addrs, const socklen_t * addrlens,
                      GNUNET_NAT_AddressCallback address_callback,
                      GNUNET_NAT_ReversalCallback reversal_callback,
                      void *callback_cls)
@@ -1081,13 +1070,11 @@ GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg,
   struct GNUNET_NAT_Handle *h;
   struct in_addr in_addr;
   unsigned int i;
+  char *binary;
 
-#if DEBUG_NAT
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "nat",
-                   "Registered with NAT service at port %u with %u IP bound local addresses\n",
-                   (unsigned int) adv_port, num_addrs);
-#endif
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Registered with NAT service at port %u with %u IP bound local addresses\n",
+       (unsigned int) adv_port, num_addrs);
   h = GNUNET_malloc (sizeof (struct GNUNET_NAT_Handle));
   h->server_retry_delay = GNUNET_TIME_UNIT_SECONDS;
   h->cfg = cfg;
@@ -1114,18 +1101,16 @@ GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg,
   if (GNUNET_OK ==
       GNUNET_CONFIGURATION_have_value (cfg, "nat", "INTERNAL_ADDRESS"))
   {
-    (void) GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                  "nat",
+    (void) GNUNET_CONFIGURATION_get_value_string (cfg, "nat",
                                                   "INTERNAL_ADDRESS",
                                                   &h->internal_address);
   }
   if ((h->internal_address != NULL) &&
       (inet_pton (AF_INET, h->internal_address, &in_addr) != 1))
   {
-    GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
-                     "nat",
-                     _("Malformed %s `%s' given in configuration!\n"),
-                     "INTERNAL_ADDRESS", h->internal_address);
+    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING, 
+                              "nat", "INTERNAL_ADDRESS",
+                              _("malformed"));
     GNUNET_free (h->internal_address);
     h->internal_address = NULL;
   }
@@ -1133,57 +1118,40 @@ GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg,
   if (GNUNET_OK ==
       GNUNET_CONFIGURATION_have_value (cfg, "nat", "EXTERNAL_ADDRESS"))
   {
-    (void) GNUNET_CONFIGURATION_get_value_string (cfg,
-                                                  "nat",
+    (void) GNUNET_CONFIGURATION_get_value_string (cfg, "nat",
                                                   "EXTERNAL_ADDRESS",
                                                   &h->external_address);
   }
-  if ((h->external_address != NULL) &&
-      (inet_pton (AF_INET, h->external_address, &in_addr) != 1))
-  {
-    GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
-                     "nat",
-                     _("Malformed %s `%s' given in configuration!\n"),
-                     "EXTERNAL_ADDRESS", h->external_address);
-    GNUNET_free (h->external_address);
-    h->external_address = NULL;
-  }
-  h->behind_nat = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                        "nat", "BEHIND_NAT");
-  h->nat_punched = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                         "nat", "PUNCHED_NAT");
-  h->enable_nat_client = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                               "nat",
-                                                               "ENABLE_NAT_CLIENT");
-  h->enable_nat_server = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                               "nat",
-                                                               "ENABLE_NAT_SERVER");
-  h->enable_upnp = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                         "nat", "ENABLE_UPNP");
-  h->use_localaddresses = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                                "nat",
-                                                                "USE_LOCALADDR");
-  h->use_hostname = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                          "nat",
-                                                          "USE_HOSTNAME");
-  h->disable_ipv6 = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                          "nat", "DISABLEV6");
+  h->behind_nat =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "nat", "BEHIND_NAT");
+  h->nat_punched =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "nat", "PUNCHED_NAT");
+  h->enable_nat_client =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "nat", "ENABLE_ICMP_CLIENT");
+  h->enable_nat_server =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "nat", "ENABLE_ICMP_SERVER");
+  h->enable_upnp =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "nat", "ENABLE_UPNP");
+  h->use_localaddresses =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "nat", "USE_LOCALADDR");
+  h->return_localaddress =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "nat",
+                                            "RETURN_LOCAL_ADDRESSES");
+
+  h->use_hostname =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "nat", "USE_HOSTNAME");
+  h->disable_ipv6 =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "nat", "DISABLEV6");
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_time (cfg,
-                                           "nat",
-                                           "DYNDNS_FREQUENCY",
+      GNUNET_CONFIGURATION_get_value_time (cfg, "nat", "DYNDNS_FREQUENCY",
                                            &h->dyndns_frequency))
     h->dyndns_frequency = DYNDNS_FREQUENCY;
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_time (cfg,
-                                           "nat",
-                                           "IFC_SCAN_FREQUENCY",
+      GNUNET_CONFIGURATION_get_value_time (cfg, "nat", "IFC_SCAN_FREQUENCY",
                                            &h->ifc_scan_frequency))
     h->ifc_scan_frequency = IFC_SCAN_FREQUENCY;
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_time (cfg,
-                                           "nat",
-                                           "HOSTNAME_DNS_FREQUENCY",
+      GNUNET_CONFIGURATION_get_value_time (cfg, "nat", "HOSTNAME_DNS_FREQUENCY",
                                            &h->hostname_dns_frequency))
     h->hostname_dns_frequency = HOSTNAME_DNS_FREQUENCY;
 
@@ -1191,8 +1159,8 @@ GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg,
     h->enable_nat_server = GNUNET_NO;
 
   /* Check if NAT was hole-punched */
-  if ((NULL != h->address_callback) &&
-      (h->external_address != NULL) && (h->nat_punched == GNUNET_YES))
+  if ((NULL != h->address_callback) && (h->external_address != NULL) &&
+      (h->nat_punched == GNUNET_YES))
   {
     h->dns_task = GNUNET_SCHEDULER_add_now (&resolve_dns, h);
     h->enable_nat_server = GNUNET_NO;
@@ -1200,28 +1168,30 @@ GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg,
   }
 
   /* Test for SUID binaries */
-  if ((h->behind_nat == GNUNET_YES) &&
-      (GNUNET_YES == h->enable_nat_server) &&
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-server");
+  if ((h->behind_nat == GNUNET_YES) && (GNUNET_YES == h->enable_nat_server) &&
       (GNUNET_YES !=
-       GNUNET_OS_check_helper_binary ("gnunet-helper-nat-server")))
+       GNUNET_OS_check_helper_binary (binary)))
   {
     h->enable_nat_server = GNUNET_NO;
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _
-                ("Configuration requires `%s', but binary is not installed properly (SUID bit not set).  Option disabled.\n"),
-                "gnunet-helper-nat-server");
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         _
+         ("Configuration requires `%s', but binary is not installed properly (SUID bit not set).  Option disabled.\n"),
+         "gnunet-helper-nat-server");
   }
+  GNUNET_free (binary);
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-client");
   if ((GNUNET_YES == h->enable_nat_client) &&
       (GNUNET_YES !=
-       GNUNET_OS_check_helper_binary ("gnunet-helper-nat-client")))
+       GNUNET_OS_check_helper_binary (binary)))
   {
     h->enable_nat_client = GNUNET_NO;
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _
-                ("Configuration requires `%s', but binary is not installed properly (SUID bit not set).  Option disabled.\n"),
-                "gnunet-helper-nat-client");
+    LOG (GNUNET_ERROR_TYPE_WARNING,
+         _
+         ("Configuration requires `%s', but binary is not installed properly (SUID bit not set).  Option disabled.\n"),
+         "gnunet-helper-nat-client");
   }
-
+  GNUNET_free (binary);
   start_gnunet_nat_server (h);
 
   /* FIXME: add support for UPnP, etc */
@@ -1295,9 +1265,9 @@ GNUNET_NAT_unregister (struct GNUNET_NAT_Handle *h)
   if (NULL != h->server_proc)
   {
     if (0 != GNUNET_OS_process_kill (h->server_proc, SIGTERM))
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+      GNUNET_log_from_strerror (GNUNET_ERROR_TYPE_WARNING, "nat", "kill");
     GNUNET_OS_process_wait (h->server_proc);
-    GNUNET_OS_process_close (h->server_proc);
+    GNUNET_OS_process_destroy (h->server_proc);
     h->server_proc = NULL;
     GNUNET_DISK_pipe_close (h->server_stdout);
     h->server_stdout = NULL;
@@ -1313,8 +1283,7 @@ GNUNET_NAT_unregister (struct GNUNET_NAT_Handle *h)
   {
     GNUNET_CONTAINER_DLL_remove (h->lal_head, h->lal_tail, lal);
     if (NULL != h->address_callback)
-      h->address_callback (h->callback_cls,
-                           GNUNET_NO,
+      h->address_callback (h->callback_cls, GNUNET_NO,
                            (const struct sockaddr *) &lal[1], lal->addrlen);
     GNUNET_free (lal);
   }
@@ -1333,53 +1302,54 @@ GNUNET_NAT_unregister (struct GNUNET_NAT_Handle *h)
  * gnunet-helper-nat-client to send dummy ICMP responses to cause
  * that peer to connect to us (connection reversal).
  *
- * @param h NAT handle for us (largely used for configuration)
- * @param sa the address of the peer (IPv4-only)
+ * @return GNUNET_SYSERR on error, GNUNET_NO if nat client is disabled,
+ *         GNUNET_OK otherwise
  */
-void
+int
 GNUNET_NAT_run_client (struct GNUNET_NAT_Handle *h,
                        const struct sockaddr_in *sa)
+
+
 {
   char inet4[INET_ADDRSTRLEN];
   char port_as_string[6];
   struct GNUNET_OS_Process *proc;
+  char *binary;
 
   if (GNUNET_YES != h->enable_nat_client)
-    return;                     /* not permitted / possible */
+    return GNUNET_NO;                     /* not permitted / possible */
 
   if (h->internal_address == NULL)
   {
-    GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
-                     "nat",
-                     _
-                     ("Internal IP address not known, cannot use ICMP NAT traversal method\n"));
-    return;
+    LOG (GNUNET_ERROR_TYPE_WARNING, "nat",
+         _
+         ("Internal IP address not known, cannot use ICMP NAT traversal method\n"));
+    return GNUNET_SYSERR;
   }
   GNUNET_assert (sa->sin_family == AF_INET);
   if (NULL == inet_ntop (AF_INET, &sa->sin_addr, inet4, INET_ADDRSTRLEN))
   {
-    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
-    return;
+    GNUNET_log_from_strerror (GNUNET_ERROR_TYPE_WARNING, "nat", "inet_ntop");
+    return GNUNET_SYSERR;
   }
   GNUNET_snprintf (port_as_string, sizeof (port_as_string), "%d", h->adv_port);
-#if DEBUG_NAT
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "nat",
-                   _("Running gnunet-helper-nat-client %s %s %u\n"),
-                   h->internal_address, inet4, (unsigned int) h->adv_port);
-#endif
-  proc = GNUNET_OS_start_process (NULL,
-                                  NULL,
-                                  "gnunet-helper-nat-client",
-                                  "gnunet-helper-nat-client",
-                                  h->internal_address,
-                                  inet4, port_as_string, NULL);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       _("Running gnunet-helper-nat-client %s %s %u\n"), h->internal_address,
+       inet4, (unsigned int) h->adv_port);
+  binary = GNUNET_OS_get_libexec_binary_path ("gnunet-helper-nat-client");
+  proc =
+      GNUNET_OS_start_process (GNUNET_NO, 0, NULL, NULL,
+                               binary,
+                               "gnunet-helper-nat-client", h->internal_address,
+                               inet4, port_as_string, NULL);
+  GNUNET_free (binary);
   if (NULL == proc)
-    return;
+    return GNUNET_SYSERR;
   /* we know that the gnunet-helper-nat-client will terminate virtually
    * instantly */
   GNUNET_OS_process_wait (proc);
-  GNUNET_OS_process_close (proc);
+  GNUNET_OS_process_destroy (proc);
+  return GNUNET_OK;
 }
 
 
@@ -1394,8 +1364,8 @@ GNUNET_NAT_run_client (struct GNUNET_NAT_Handle *h,
  *         GNUNET_SYSERR if the address is malformed
  */
 int
-GNUNET_NAT_test_address (struct GNUNET_NAT_Handle *h,
-                         const void *addr, socklen_t addrlen)
+GNUNET_NAT_test_address (struct GNUNET_NAT_Handle *h, const void *addr,
+                         socklen_t addrlen)
 {
   struct LocalAddressList *pos;
   const struct sockaddr_in *in4;
@@ -1430,8 +1400,8 @@ GNUNET_NAT_test_address (struct GNUNET_NAT_Handle *h,
     }
     pos = pos->next;
   }
-  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "Asked to validate one of my addresses and validation failed!\n");
+  LOG (GNUNET_ERROR_TYPE_WARNING,
+       "Asked to validate one of my addresses and validation failed!\n");
   return GNUNET_NO;
 }