indentation

12 files changed, 1594 insertions, 2012 deletions

diff --git a/src/nat/gnunet-helper-nat-client-windows.c b/src/nat/gnunet-helper-nat-client-windows.c
index 0717eecfe..0fa62ff7c 100644
--- a/src/nat/gnunet-helper-nat-client-windows.c
+++ b/src/nat/gnunet-helper-nat-client-windows.c
@@ -193,19 +193,14 @@ static uint16_t port;
  * @return 1 on success
  */
 static int
-inet_pton (int af,
-           const char *cp,
-           struct in_addr *buf)
+inet_pton (int af, const char *cp, struct in_addr *buf)
 {
-  buf->s_addr = inet_addr(cp);
+  buf->s_addr = inet_addr (cp);
   if (buf->s_addr == INADDR_NONE)
-    {
-      fprintf(stderr,
-              "Error %d handling address %s",
-              WSAGetLastError(),
-              cp);
-      return 0;
-    }
+  {
+    fprintf (stderr, "Error %d handling address %s", WSAGetLastError (), cp);
+    return 0;
+  }
   return 1;
 }
 
@@ -218,17 +213,16 @@ inet_pton (int af,
  * @return the CRC 16.
  */
 static uint16_t
-calc_checksum(const uint16_t *data,
-              unsigned int bytes)
+calc_checksum (const uint16_t * data, unsigned int bytes)
 {
   uint32_t sum;
   unsigned int i;
 
   sum = 0;
-  for (i=0;i<bytes/2;i++)
+  for (i = 0; i < bytes / 2; i++)
     sum += data[i];
   sum = (sum & 0xffff) + (sum >> 16);
-  sum = htons(0xffff - sum);
+  sum = htons (0xffff - sum);
   return sum;
 }
 
@@ -240,12 +234,11 @@ calc_checksum(const uint16_t *data,
  * @param other target address
  */
 static void
-send_icmp_udp (const struct in_addr *my_ip,
-               const struct in_addr *other)
+send_icmp_udp (const struct in_addr *my_ip, const struct in_addr *other)
 {
-  char packet[sizeof(struct ip_header) * 2 +
-              sizeof(struct icmp_ttl_exceeded_header) +
-              sizeof(struct udp_header)];
+  char packet[sizeof (struct ip_header) * 2 +
+              sizeof (struct icmp_ttl_exceeded_header) +
+              sizeof (struct udp_header)];
   struct ip_header ip_pkt;
   struct icmp_ttl_exceeded_header icmp_pkt;
   struct udp_header udp_pkt;
@@ -257,86 +250,74 @@ send_icmp_udp (const struct in_addr *my_ip,
   off = 0;
   ip_pkt.vers_ihl = 0x45;
   ip_pkt.tos = 0;
-  ip_pkt.pkt_len = htons(sizeof (packet));
-  ip_pkt.id = htons(256);
+  ip_pkt.pkt_len = htons (sizeof (packet));
+  ip_pkt.id = htons (256);
   ip_pkt.flags_frag_offset = 0;
   ip_pkt.ttl = 128;
   ip_pkt.proto = IPPROTO_ICMP;
   ip_pkt.checksum = 0;
   ip_pkt.src_ip = my_ip->s_addr;
   ip_pkt.dst_ip = other->s_addr;
-  ip_pkt.checksum = htons(calc_checksum((uint16_t*)&ip_pkt,
-                                        sizeof (struct ip_header)));
-  memcpy(&packet[off],
-         &ip_pkt,
-         sizeof(struct ip_header));
-  off += sizeof(struct ip_header);
+  ip_pkt.checksum = htons (calc_checksum ((uint16_t *) & ip_pkt,
+                                          sizeof (struct ip_header)));
+  memcpy (&packet[off], &ip_pkt, sizeof (struct ip_header));
+  off += sizeof (struct ip_header);
 
   icmp_pkt.type = ICMP_TIME_EXCEEDED;
   icmp_pkt.code = 0;
   icmp_pkt.checksum = 0;
   icmp_pkt.unused = 0;
-  memcpy(&packet[off],
-         &icmp_pkt,
-         sizeof(struct icmp_ttl_exceeded_header));
-  off += sizeof(struct icmp_ttl_exceeded_header);
+  memcpy (&packet[off], &icmp_pkt, sizeof (struct icmp_ttl_exceeded_header));
+  off += sizeof (struct icmp_ttl_exceeded_header);
 
   /* ip header of the presumably 'lost' udp packet */
   ip_pkt.vers_ihl = 0x45;
   ip_pkt.tos = 0;
-  ip_pkt.pkt_len = htons(sizeof (struct ip_header) +
-                         sizeof (struct udp_header));
-  ip_pkt.id = htons(0);
+  ip_pkt.pkt_len = htons (sizeof (struct ip_header) +
+                          sizeof (struct udp_header));
+  ip_pkt.id = htons (0);
   ip_pkt.flags_frag_offset = 0;
   ip_pkt.ttl = 128;
   ip_pkt.proto = IPPROTO_UDP;
   ip_pkt.checksum = 0;
   ip_pkt.src_ip = other->s_addr;
   ip_pkt.dst_ip = dummy.s_addr;
-  ip_pkt.checksum = htons(calc_checksum((uint16_t*)&ip_pkt,
-                                        sizeof (struct ip_header)));
-  memcpy(&packet[off],
-         &ip_pkt,
-         sizeof(struct ip_header));
-  off += sizeof(struct ip_header);
+  ip_pkt.checksum = htons (calc_checksum ((uint16_t *) & ip_pkt,
+                                          sizeof (struct ip_header)));
+  memcpy (&packet[off], &ip_pkt, sizeof (struct ip_header));
+  off += sizeof (struct ip_header);
 
   /* build UDP header */
-  udp_pkt.src_port = htons(NAT_TRAV_PORT);
-  udp_pkt.dst_port = htons(NAT_TRAV_PORT);
+  udp_pkt.src_port = htons (NAT_TRAV_PORT);
+  udp_pkt.dst_port = htons (NAT_TRAV_PORT);
   udp_pkt.length = htons (port);
   udp_pkt.crc = 0;
-  memcpy(&packet[off],
-         &udp_pkt,
-         sizeof(struct udp_header));
-  off += sizeof(struct udp_header);
+  memcpy (&packet[off], &udp_pkt, sizeof (struct udp_header));
+  off += sizeof (struct udp_header);
 
   /* no go back to calculate ICMP packet checksum */
-  icmp_pkt.checksum = htons(calc_checksum((uint16_t*)&packet[off],
-                                          sizeof (struct icmp_ttl_exceeded_header) +
-                                          sizeof (struct ip_header) +
-                                          sizeof (struct udp_header)));
-  memcpy (&packet[sizeof (struct ip_header)],
-          &icmp_pkt,
-          sizeof (struct icmp_ttl_exceeded_header));
+  icmp_pkt.checksum = htons (calc_checksum ((uint16_t *) & packet[off],
+                                            sizeof (struct
+                                                    icmp_ttl_exceeded_header) +
+                                            sizeof (struct ip_header) +
+                                            sizeof (struct udp_header)));
+  memcpy (&packet[sizeof (struct ip_header)], &icmp_pkt,
+          sizeof (struct icmp_ttl_exceeded_header));
 
   memset (&dst, 0, sizeof (dst));
   dst.sin_family = AF_INET;
   dst.sin_addr = *other;
-  err = sendto(rawsock,
-               packet,
-               sizeof (packet), 0,
-               (struct sockaddr*)&dst,
-               sizeof(dst));
+  err = sendto (rawsock,
+                packet,
+                sizeof (packet), 0, (struct sockaddr *) &dst, sizeof (dst));
   if (err < 0)
-    {
-      fprintf(stderr,
-              "sendto failed: %s\n", strerror(errno));
-    }
+  {
+    fprintf (stderr, "sendto failed: %s\n", strerror (errno));
+  }
   else if (sizeof (packet) != (size_t) err)
-    {
-      fprintf(stderr,
-              "Error: partial send of ICMP message\n");
-    }
+  {
+    fprintf (stderr, "Error: partial send of ICMP message\n");
+  }
 }
 
 
@@ -347,16 +328,15 @@ send_icmp_udp (const struct in_addr *my_ip,
  * @param other target address
  */
 static void
-send_icmp (const struct in_addr *my_ip,
-           const struct in_addr *other)
+send_icmp (const struct in_addr *my_ip, const struct in_addr *other)
 {
   struct ip_header ip_pkt;
   struct icmp_ttl_exceeded_header icmp_ttl;
   struct icmp_echo_header icmp_echo;
   struct sockaddr_in dst;
   char packet[sizeof (struct ip_header) * 2 +
-              sizeof (struct icmp_ttl_exceeded_header) +
-              sizeof(struct icmp_echo_header)];
+              sizeof (struct icmp_ttl_exceeded_header) +
+              sizeof (struct icmp_echo_header)];
   size_t off;
   int err;
 
@@ -365,88 +345,76 @@ send_icmp (const struct in_addr *my_ip,
   ip_pkt.vers_ihl = 0x45;
   ip_pkt.tos = 0;
   ip_pkt.pkt_len = htons (sizeof (packet));
-  ip_pkt.id = htons(256);
+  ip_pkt.id = htons (256);
   ip_pkt.flags_frag_offset = 0;
   ip_pkt.ttl = IPDEFTTL;
   ip_pkt.proto = IPPROTO_ICMP;
   ip_pkt.checksum = 0;
   ip_pkt.src_ip = my_ip->s_addr;
   ip_pkt.dst_ip = other->s_addr;
-  ip_pkt.checksum = htons(calc_checksum((uint16_t*)&ip_pkt,
-                                        sizeof (struct ip_header)));
-  memcpy (&packet[off],
-          &ip_pkt,
-          sizeof (struct ip_header));
+  ip_pkt.checksum = htons (calc_checksum ((uint16_t *) & ip_pkt,
+                                          sizeof (struct ip_header)));
+  memcpy (&packet[off], &ip_pkt, sizeof (struct ip_header));
   off += sizeof (ip_pkt);
 
   /* icmp reply: time exceeded */
   icmp_ttl.type = ICMP_TIME_EXCEEDED;
   icmp_ttl.code = 0;
   icmp_ttl.checksum = 0;
-  icmp_ttl.unused = 0; 
-  memcpy (&packet[off],
-          &icmp_ttl,
-          sizeof (struct icmp_ttl_exceeded_header));
+  icmp_ttl.unused = 0;
+  memcpy (&packet[off], &icmp_ttl, sizeof (struct icmp_ttl_exceeded_header));
   off += sizeof (struct icmp_ttl_exceeded_header);
 
   /* ip header of the presumably 'lost' udp packet */
   ip_pkt.vers_ihl = 0x45;
   ip_pkt.tos = 0;
-  ip_pkt.pkt_len = htons(sizeof (struct ip_header) + sizeof (struct icmp_echo_header));
+  ip_pkt.pkt_len =
+      htons (sizeof (struct ip_header) + sizeof (struct icmp_echo_header));
   ip_pkt.id = htons (256);
   ip_pkt.flags_frag_offset = 0;
-  ip_pkt.ttl = 1; /* real TTL would be 1 on a time exceeded packet */
+  ip_pkt.ttl = 1;               /* real TTL would be 1 on a time exceeded packet */
   ip_pkt.proto = IPPROTO_ICMP;
   ip_pkt.src_ip = other->s_addr;
   ip_pkt.dst_ip = dummy.s_addr;
   ip_pkt.checksum = 0;
-  ip_pkt.checksum = htons(calc_checksum((uint16_t*)&ip_pkt,
-                                        sizeof (struct ip_header)));
-  memcpy (&packet[off],
-          &ip_pkt,
-          sizeof (struct ip_header));
+  ip_pkt.checksum = htons (calc_checksum ((uint16_t *) & ip_pkt,
+                                          sizeof (struct ip_header)));
+  memcpy (&packet[off], &ip_pkt, sizeof (struct ip_header));
   off += sizeof (struct ip_header);
 
   icmp_echo.type = ICMP_ECHO;
   icmp_echo.code = 0;
-  icmp_echo.reserved = htonl(port);
+  icmp_echo.reserved = htonl (port);
   icmp_echo.checksum = 0;
-  icmp_echo.checksum = htons(calc_checksum((uint16_t*) &icmp_echo,
-                                           sizeof (struct icmp_echo_header)));
-  memcpy (&packet[off],
-          &icmp_echo,
-          sizeof(struct icmp_echo_header));
+  icmp_echo.checksum = htons (calc_checksum ((uint16_t *) & icmp_echo,
+                                             sizeof (struct icmp_echo_header)));
+  memcpy (&packet[off], &icmp_echo, sizeof (struct icmp_echo_header));
 
   /* no go back to calculate ICMP packet checksum */
   off = sizeof (struct ip_header);
-  icmp_ttl.checksum = htons(calc_checksum((uint16_t*) &packet[off],
-                                          sizeof (struct icmp_ttl_exceeded_header) +
-                                          sizeof (struct ip_header) +
-                                          sizeof (struct icmp_echo_header)));
-  memcpy (&packet[off],
-          &icmp_ttl,
-          sizeof (struct icmp_ttl_exceeded_header));
+  icmp_ttl.checksum = htons (calc_checksum ((uint16_t *) & packet[off],
+                                            sizeof (struct
+                                                    icmp_ttl_exceeded_header) +
+                                            sizeof (struct ip_header) +
+                                            sizeof (struct icmp_echo_header)));
+  memcpy (&packet[off], &icmp_ttl, sizeof (struct icmp_ttl_exceeded_header));
 
   memset (&dst, 0, sizeof (dst));
   dst.sin_family = AF_INET;
   dst.sin_addr = *other;
 
-  err = sendto(rawsock,
-               packet,
-               sizeof (packet), 0,
-               (struct sockaddr*)&dst,
-               sizeof(dst));
+  err = sendto (rawsock,
+                packet,
+                sizeof (packet), 0, (struct sockaddr *) &dst, sizeof (dst));
 
   if (err < 0)
-    {
-      fprintf(stderr,
-              "sendto failed: %s\n", strerror(errno));
-    }
+  {
+    fprintf (stderr, "sendto failed: %s\n", strerror (errno));
+  }
   else if (sizeof (packet) != (size_t) err)
-    {
-      fprintf(stderr,
-              "Error: partial send of ICMP message\n");
-    }
+  {
+    fprintf (stderr, "Error: partial send of ICMP message\n");
+  }
 }
 
 
@@ -459,34 +427,30 @@ static SOCKET
 make_raw_socket ()
 {
   DWORD bOptVal = TRUE;
-  int bOptLen = sizeof(bOptVal);
+  int bOptLen = sizeof (bOptVal);
   SOCKET ret;
 
   ret = socket (AF_INET, SOCK_RAW, IPPROTO_RAW);
   if (INVALID_SOCKET == ret)
-    {
-      fprintf (stderr,
-               "Error opening RAW socket: %s\n",
-               strerror (errno));
-      return INVALID_SOCKET;
-    }
-  if (0 != setsockopt(ret, SOL_SOCKET, SO_BROADCAST, (char*)&bOptVal, bOptLen))
-    {
-      fprintf(stderr,
-              "Error setting SO_BROADCAST to ON: %s\n",
-              strerror (errno));
-      closesocket(rawsock);
-      return INVALID_SOCKET;
-    }
-
-  if (0 != setsockopt(ret, IPPROTO_IP, IP_HDRINCL, (char*)&bOptVal, bOptLen))
-    {
-      fprintf(stderr,
-              "Error setting IP_HDRINCL to ON: %s\n",
-              strerror (errno));
-      closesocket(rawsock);
-      return INVALID_SOCKET;
-    }
+  {
+    fprintf (stderr, "Error opening RAW socket: %s\n", strerror (errno));
+    return INVALID_SOCKET;
+  }
+  if (0 !=
+      setsockopt (ret, SOL_SOCKET, SO_BROADCAST, (char *) &bOptVal, bOptLen))
+  {
+    fprintf (stderr,
+             "Error setting SO_BROADCAST to ON: %s\n", strerror (errno));
+    closesocket (rawsock);
+    return INVALID_SOCKET;
+  }
+
+  if (0 != setsockopt (ret, IPPROTO_IP, IP_HDRINCL, (char *) &bOptVal, bOptLen))
+  {
+    fprintf (stderr, "Error setting IP_HDRINCL to ON: %s\n", strerror (errno));
+    closesocket (rawsock);
+    return INVALID_SOCKET;
+  }
   return ret;
 }
 
@@ -501,47 +465,38 @@ main (int argc, char *const *argv)
   unsigned int p;
 
   if (argc != 4)
-    {
-      fprintf (stderr,
-               "This program must be started with our IP, the targets external IP, and our port as arguments.\n");
-      return 1;
-    }
-  if ( (1 != inet_pton (AF_INET, argv[1], &external)) ||
-       (1 != inet_pton (AF_INET, argv[2], &target)) )
-    {
-      fprintf (stderr,
-               "Error parsing IPv4 address: %s\n",
-               strerror (errno));
-      return 1;
-    }
-  if ( (1 != sscanf (argv[3], "%u", &p) ) ||
-       (0 == p) ||
-       (0xFFFF < p) )
-    {
-      fprintf (stderr,
-               "Error parsing port value `%s'\n",
-               argv[3]);
-      return 1;
-    }
+  {
+    fprintf (stderr,
+             "This program must be started with our IP, the targets external IP, and our port as arguments.\n");
+    return 1;
+  }
+  if ((1 != inet_pton (AF_INET, argv[1], &external)) ||
+      (1 != inet_pton (AF_INET, argv[2], &target)))
+  {
+    fprintf (stderr, "Error parsing IPv4 address: %s\n", strerror (errno));
+    return 1;
+  }
+  if ((1 != sscanf (argv[3], "%u", &p)) || (0 == p) || (0xFFFF < p))
+  {
+    fprintf (stderr, "Error parsing port value `%s'\n", argv[3]);
+    return 1;
+  }
   port = (uint16_t) p;
 
   if (0 != WSAStartup (MAKEWORD (2, 1), &wsaData))
-    {
-      fprintf (stderr, "Failed to find Winsock 2.1 or better.\n");
-      return 2;
-    }
+  {
+    fprintf (stderr, "Failed to find Winsock 2.1 or better.\n");
+    return 2;
+  }
   if (1 != inet_pton (AF_INET, DUMMY_IP, &dummy))
-    {
-      fprintf (stderr,
-               "Internal error converting dummy IP to binary.\n");
-      return 2;
-    }
-  if (-1 == (rawsock = make_raw_socket()))
+  {
+    fprintf (stderr, "Internal error converting dummy IP to binary.\n");
+    return 2;
+  }
+  if (-1 == (rawsock = make_raw_socket ()))
     return 3;
-  send_icmp (&external,
-             &target);
-  send_icmp_udp (&external,
-                 &target);
+  send_icmp (&external, &target);
+  send_icmp_udp (&external, &target);
   closesocket (rawsock);
   WSACleanup ();
   return 0;
diff --git a/src/nat/gnunet-helper-nat-client.c b/src/nat/gnunet-helper-nat-client.c
index 10aa2f438..76f405bf1 100644
--- a/src/nat/gnunet-helper-nat-client.c
+++ b/src/nat/gnunet-helper-nat-client.c
@@ -190,17 +190,16 @@ static uint16_t port;
  * @return the CRC 16.
  */
 static uint16_t
-calc_checksum (const uint16_t *data,
-               unsigned int bytes)
+calc_checksum (const uint16_t * data, unsigned int bytes)
 {
   uint32_t sum;
   unsigned int i;
 
   sum = 0;
-  for (i=0;i<bytes/2;i++)
+  for (i = 0; i < bytes / 2; i++)
     sum += data[i];
   sum = (sum & 0xffff) + (sum >> 16);
-  sum = htons(0xffff - sum);
+  sum = htons (0xffff - sum);
   return sum;
 }
 
@@ -212,12 +211,11 @@ calc_checksum (const uint16_t *data,
  * @param other target address
  */
 static void
-send_icmp_udp (const struct in_addr *my_ip,
-               const struct in_addr *other)
+send_icmp_udp (const struct in_addr *my_ip, const struct in_addr *other)
 {
-  char packet[sizeof(struct ip_header) * 2 +
-              sizeof(struct icmp_ttl_exceeded_header) +
-              sizeof(struct udp_header)];
+  char packet[sizeof (struct ip_header) * 2 +
+              sizeof (struct icmp_ttl_exceeded_header) +
+              sizeof (struct udp_header)];
   struct ip_header ip_pkt;
   struct icmp_ttl_exceeded_header icmp_pkt;
   struct udp_header udp_pkt;
@@ -230,66 +228,58 @@ send_icmp_udp (const struct in_addr *my_ip,
   ip_pkt.vers_ihl = 0x45;
   ip_pkt.tos = 0;
   ip_pkt.pkt_len = htons (sizeof (packet));
-  ip_pkt.id = htons(256);
+  ip_pkt.id = htons (256);
   ip_pkt.flags_frag_offset = 0;
   ip_pkt.ttl = 128;
   ip_pkt.proto = IPPROTO_ICMP;
   ip_pkt.checksum = 0;
   ip_pkt.src_ip = my_ip->s_addr;
   ip_pkt.dst_ip = other->s_addr;
-  ip_pkt.checksum = htons(calc_checksum((uint16_t*)&ip_pkt,
-                                        sizeof (struct ip_header)));
-  memcpy(&packet[off],
-         &ip_pkt,
-         sizeof(struct ip_header));
-  off += sizeof(struct ip_header);
+  ip_pkt.checksum = htons (calc_checksum ((uint16_t *) & ip_pkt,
+                                          sizeof (struct ip_header)));
+  memcpy (&packet[off], &ip_pkt, sizeof (struct ip_header));
+  off += sizeof (struct ip_header);
 
   icmp_pkt.type = ICMP_TIME_EXCEEDED;
   icmp_pkt.code = 0;
   icmp_pkt.checksum = 0;
   icmp_pkt.unused = 0;
-  memcpy(&packet[off],
-         &icmp_pkt,
-         sizeof(struct icmp_ttl_exceeded_header));
-  off += sizeof(struct icmp_ttl_exceeded_header);
+  memcpy (&packet[off], &icmp_pkt, sizeof (struct icmp_ttl_exceeded_header));
+  off += sizeof (struct icmp_ttl_exceeded_header);
 
   /* ip header of the presumably 'lost' udp packet */
   ip_pkt.vers_ihl = 0x45;
   ip_pkt.tos = 0;
-  ip_pkt.pkt_len = htons(sizeof (struct ip_header) +
-                         sizeof (struct udp_header));
-  ip_pkt.id = htons(0);
+  ip_pkt.pkt_len = htons (sizeof (struct ip_header) +
+                          sizeof (struct udp_header));
+  ip_pkt.id = htons (0);
   ip_pkt.flags_frag_offset = 0;
   ip_pkt.ttl = 128;
   ip_pkt.proto = IPPROTO_UDP;
   ip_pkt.checksum = 0;
   ip_pkt.src_ip = other->s_addr;
   ip_pkt.dst_ip = dummy.s_addr;
-  ip_pkt.checksum = htons(calc_checksum((uint16_t*)&ip_pkt,
-                                        sizeof (struct ip_header)));
-  memcpy(&packet[off],
-         &ip_pkt,
-         sizeof(struct ip_header));
-  off += sizeof(struct ip_header);
+  ip_pkt.checksum = htons (calc_checksum ((uint16_t *) & ip_pkt,
+                                          sizeof (struct ip_header)));
+  memcpy (&packet[off], &ip_pkt, sizeof (struct ip_header));
+  off += sizeof (struct ip_header);
 
   /* build UDP header */
-  udp_pkt.src_port = htons(NAT_TRAV_PORT);
-  udp_pkt.dst_port = htons(NAT_TRAV_PORT);
+  udp_pkt.src_port = htons (NAT_TRAV_PORT);
+  udp_pkt.dst_port = htons (NAT_TRAV_PORT);
   udp_pkt.length = htons (port);
   udp_pkt.crc = 0;
-  memcpy(&packet[off],
-         &udp_pkt,
-         sizeof(struct udp_header));
-  off += sizeof(struct udp_header);
+  memcpy (&packet[off], &udp_pkt, sizeof (struct udp_header));
+  off += sizeof (struct udp_header);
 
   /* set ICMP checksum */
-  icmp_pkt.checksum = htons(calc_checksum((uint16_t*)&packet[sizeof(struct ip_header)],
-                                          sizeof (struct icmp_ttl_exceeded_header) +
-                                          sizeof (struct ip_header) +
-                                          sizeof (struct udp_header)));
-  memcpy (&packet[sizeof(struct ip_header)],
-          &icmp_pkt,
-          sizeof (struct icmp_ttl_exceeded_header));
+  icmp_pkt.checksum =
+      htons (calc_checksum
+             ((uint16_t *) & packet[sizeof (struct ip_header)],
+              sizeof (struct icmp_ttl_exceeded_header) +
+              sizeof (struct ip_header) + sizeof (struct udp_header)));
+  memcpy (&packet[sizeof (struct ip_header)], &icmp_pkt,
+          sizeof (struct icmp_ttl_exceeded_header));
 
   memset (&dst, 0, sizeof (dst));
   dst.sin_family = AF_INET;
@@ -297,21 +287,17 @@ send_icmp_udp (const struct in_addr *my_ip,
   dst.sin_len = sizeof (struct sockaddr_in);
 #endif
   dst.sin_addr = *other;
-  err = sendto(rawsock,
-               packet,
-               sizeof (packet), 0,
-               (struct sockaddr*)&dst,
-               sizeof(dst));
+  err = sendto (rawsock,
+                packet,
+                sizeof (packet), 0, (struct sockaddr *) &dst, sizeof (dst));
   if (err < 0)
-    {
-      fprintf(stderr,
-              "sendto failed: %s\n", strerror(errno));
-    }
+  {
+    fprintf (stderr, "sendto failed: %s\n", strerror (errno));
+  }
   else if (sizeof (packet) != (size_t) err)
-    {
-      fprintf(stderr,
-              "Error: partial send of ICMP message\n");
-    }
+  {
+    fprintf (stderr, "Error: partial send of ICMP message\n");
+  }
 }
 
 
@@ -322,16 +308,15 @@ send_icmp_udp (const struct in_addr *my_ip,
  * @param other target address
  */
 static void
-send_icmp (const struct in_addr *my_ip,
-           const struct in_addr *other)
+send_icmp (const struct in_addr *my_ip, const struct in_addr *other)
 {
   struct ip_header ip_pkt;
   struct icmp_ttl_exceeded_header icmp_ttl;
   struct icmp_echo_header icmp_echo;
   struct sockaddr_in dst;
   char packet[sizeof (struct ip_header) * 2 +
-              sizeof (struct icmp_ttl_exceeded_header) +
-              sizeof (struct icmp_echo_header)];
+              sizeof (struct icmp_ttl_exceeded_header) +
+              sizeof (struct icmp_echo_header)];
   size_t off;
   int err;
 
@@ -347,11 +332,9 @@ send_icmp (const struct in_addr *my_ip,
   ip_pkt.checksum = 0;
   ip_pkt.src_ip = my_ip->s_addr;
   ip_pkt.dst_ip = other->s_addr;
-  ip_pkt.checksum = htons(calc_checksum((uint16_t*)&ip_pkt,
-                                        sizeof (struct ip_header)));
-  memcpy (&packet[off],
-          &ip_pkt,
-          sizeof (struct ip_header));
+  ip_pkt.checksum = htons (calc_checksum ((uint16_t *) & ip_pkt,
+                                          sizeof (struct ip_header)));
+  memcpy (&packet[off], &ip_pkt, sizeof (struct ip_header));
   off = sizeof (ip_pkt);
 
   /* icmp reply: time exceeded */
@@ -359,48 +342,42 @@ send_icmp (const struct in_addr *my_ip,
   icmp_ttl.code = 0;
   icmp_ttl.checksum = 0;
   icmp_ttl.unused = 0;
-  memcpy (&packet[off],
-          &icmp_ttl,
-          sizeof (struct icmp_ttl_exceeded_header));
+  memcpy (&packet[off], &icmp_ttl, sizeof (struct icmp_ttl_exceeded_header));
   off += sizeof (struct icmp_ttl_exceeded_header);
 
   /* ip header of the presumably 'lost' udp packet */
   ip_pkt.vers_ihl = 0x45;
   ip_pkt.tos = 0;
-  ip_pkt.pkt_len = htons (sizeof (struct ip_header) + sizeof (struct icmp_echo_header));
+  ip_pkt.pkt_len =
+      htons (sizeof (struct ip_header) + sizeof (struct icmp_echo_header));
   ip_pkt.id = htons (256);
   ip_pkt.flags_frag_offset = 0;
-  ip_pkt.ttl = 1; /* real TTL would be 1 on a time exceeded packet */
+  ip_pkt.ttl = 1;               /* real TTL would be 1 on a time exceeded packet */
   ip_pkt.proto = IPPROTO_ICMP;
   ip_pkt.src_ip = other->s_addr;
   ip_pkt.dst_ip = dummy.s_addr;
   ip_pkt.checksum = 0;
-  ip_pkt.checksum = htons(calc_checksum((uint16_t*)&ip_pkt,
-                                        sizeof (struct ip_header)));
-  memcpy (&packet[off],
-          &ip_pkt,
-          sizeof (struct ip_header));
+  ip_pkt.checksum = htons (calc_checksum ((uint16_t *) & ip_pkt,
+                                          sizeof (struct ip_header)));
+  memcpy (&packet[off], &ip_pkt, sizeof (struct ip_header));
   off += sizeof (struct ip_header);
 
   icmp_echo.type = ICMP_ECHO;
   icmp_echo.code = 0;
   icmp_echo.reserved = htonl (port);
   icmp_echo.checksum = 0;
-  icmp_echo.checksum = htons(calc_checksum((uint16_t*) &icmp_echo,
-                                           sizeof (struct icmp_echo_header)));
-  memcpy (&packet[off],
-          &icmp_echo,
-          sizeof(struct icmp_echo_header));
+  icmp_echo.checksum = htons (calc_checksum ((uint16_t *) & icmp_echo,
+                                             sizeof (struct icmp_echo_header)));
+  memcpy (&packet[off], &icmp_echo, sizeof (struct icmp_echo_header));
 
   /* no go back to calculate ICMP packet checksum */
   off = sizeof (struct ip_header);
-  icmp_ttl.checksum = htons(calc_checksum((uint16_t*) &packet[off],
-                                          sizeof (struct icmp_ttl_exceeded_header) +
-                                          sizeof (struct ip_header) +
-                                          sizeof (struct icmp_echo_header)));
-  memcpy (&packet[off],
-          &icmp_ttl,
-          sizeof (struct icmp_ttl_exceeded_header));
+  icmp_ttl.checksum = htons (calc_checksum ((uint16_t *) & packet[off],
+                                            sizeof (struct
+                                                    icmp_ttl_exceeded_header) +
+                                            sizeof (struct ip_header) +
+                                            sizeof (struct icmp_echo_header)));
+  memcpy (&packet[off], &icmp_ttl, sizeof (struct icmp_ttl_exceeded_header));
 
   /* prepare for transmission */
   memset (&dst, 0, sizeof (dst));
@@ -409,21 +386,17 @@ send_icmp (const struct in_addr *my_ip,
   dst.sin_len = sizeof (struct sockaddr_in);
 #endif
   dst.sin_addr = *other;
-  err = sendto(rawsock,
-               packet,
-               sizeof (packet), 0,
-               (struct sockaddr*)&dst,
-               sizeof(dst));
+  err = sendto (rawsock,
+                packet,
+                sizeof (packet), 0, (struct sockaddr *) &dst, sizeof (dst));
   if (err < 0)
-    {
-      fprintf(stderr,
-              "sendto failed: %s\n", strerror(errno));
-    }
+  {
+    fprintf (stderr, "sendto failed: %s\n", strerror (errno));
+  }
   else if (sizeof (packet) != (size_t) err)
-    {
-      fprintf(stderr,
-              "Error: partial send of ICMP message\n");
-    }
+  {
+    fprintf (stderr, "Error: partial send of ICMP message\n");
+  }
 }
 
 
@@ -440,30 +413,24 @@ make_raw_socket ()
 
   ret = socket (AF_INET, SOCK_RAW, IPPROTO_RAW);
   if (-1 == ret)
-    {
-      fprintf (stderr,
-               "Error opening RAW socket: %s\n",
-               strerror (errno));
-      return -1;
-    }
-  if (0 != setsockopt(ret, SOL_SOCKET, SO_BROADCAST,
-                      (char *)&one, sizeof(one)))
-    {
-      fprintf(stderr,
-              "setsockopt failed: %s\n",
-              strerror (errno));
-      close (ret);
-      return -1;
-    }
-  if (0 != setsockopt(ret, IPPROTO_IP, IP_HDRINCL,
-                      (char *)&one, sizeof(one)))
-    {
-      fprintf(stderr,
-              "setsockopt failed: %s\n",
-              strerror (errno));
-      close (ret);
-      return -1;
-    }
+  {
+    fprintf (stderr, "Error opening RAW socket: %s\n", strerror (errno));
+    return -1;
+  }
+  if (0 != setsockopt (ret, SOL_SOCKET, SO_BROADCAST,
+                       (char *) &one, sizeof (one)))
+  {
+    fprintf (stderr, "setsockopt failed: %s\n", strerror (errno));
+    close (ret);
+    return -1;
+  }
+  if (0 != setsockopt (ret, IPPROTO_IP, IP_HDRINCL,
+                       (char *) &one, sizeof (one)))
+  {
+    fprintf (stderr, "setsockopt failed: %s\n", strerror (errno));
+    close (ret);
+    return -1;
+  }
   return ret;
 }
 
@@ -477,49 +444,38 @@ main (int argc, char *const *argv)
   unsigned int p;
 
   if (4 != argc)
-    {
-      fprintf (stderr,
-               "This program must be started with our IP, the targets external IP, and our port as arguments.\n");
-      return 1;
-    }
-  if ( (1 != inet_pton (AF_INET, argv[1], &external)) ||
-       (1 != inet_pton (AF_INET, argv[2], &target)) )
-    {
-      fprintf (stderr,
-               "Error parsing IPv4 address: %s\n",
-               strerror (errno));
-      return 1;
-    }
-  if ( (1 != sscanf (argv[3], "%u", &p) ) ||
-       (0 == p) ||
-       (0xFFFF < p) )
-    {
-      fprintf (stderr,
-               "Error parsing port value `%s'\n",
-               argv[3]);
-      return 1;
-    }
+  {
+    fprintf (stderr,
+             "This program must be started with our IP, the targets external IP, and our port as arguments.\n");
+    return 1;
+  }
+  if ((1 != inet_pton (AF_INET, argv[1], &external)) ||
+      (1 != inet_pton (AF_INET, argv[2], &target)))
+  {
+    fprintf (stderr, "Error parsing IPv4 address: %s\n", strerror (errno));
+    return 1;
+  }
+  if ((1 != sscanf (argv[3], "%u", &p)) || (0 == p) || (0xFFFF < p))
+  {
+    fprintf (stderr, "Error parsing port value `%s'\n", argv[3]);
+    return 1;
+  }
   port = (uint16_t) p;
   if (1 != inet_pton (AF_INET, DUMMY_IP, &dummy))
-    {
-      fprintf (stderr,
-               "Internal error converting dummy IP to binary.\n");
-      return 2;
-    }
-  if (-1 == (rawsock = make_raw_socket()))
+  {
+    fprintf (stderr, "Internal error converting dummy IP to binary.\n");
+    return 2;
+  }
+  if (-1 == (rawsock = make_raw_socket ()))
     return 2;
   uid = getuid ();
   if (0 != setresuid (uid, uid, uid))
-    {
-      fprintf (stderr,
-               "Failed to setresuid: %s\n",
-               strerror (errno));
-      /* not critical, continue anyway */
-    }
-  send_icmp (&external,
-             &target);
-  send_icmp_udp (&external,
-                 &target);
+  {
+    fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno));
+    /* not critical, continue anyway */
+  }
+  send_icmp (&external, &target);
+  send_icmp_udp (&external, &target);
   close (rawsock);
   return 0;
 }
diff --git a/src/nat/gnunet-helper-nat-server-windows.c b/src/nat/gnunet-helper-nat-server-windows.c
index 7a607c62d..727a7be67 100644
--- a/src/nat/gnunet-helper-nat-server-windows.c
+++ b/src/nat/gnunet-helper-nat-server-windows.c
@@ -118,12 +118,12 @@ struct ip_header
   /**
    * Time to live
    */
-  uint8_t  ttl;
+  uint8_t ttl;
 
   /**
    * Protocol
    */
-  uint8_t  proto;
+  uint8_t proto;
 
   /**
    * Header checksum
@@ -133,12 +133,12 @@ struct ip_header
   /**
    * Source address
    */
-  uint32_t  src_ip;
+  uint32_t src_ip;
 
   /**
    * Destination address
    */
-  uint32_t  dst_ip;
+  uint32_t dst_ip;
 };
 
 /**
@@ -211,17 +211,16 @@ static struct in_addr dummy;
  * @return the CRC 16.
  */
 static uint16_t
-calc_checksum(const uint16_t *data,
-              unsigned int bytes)
+calc_checksum (const uint16_t * data, unsigned int bytes)
 {
   uint32_t sum;
   unsigned int i;
 
   sum = 0;
-  for (i=0;i<bytes/2;i++)
+  for (i = 0; i < bytes / 2; i++)
     sum += data[i];
   sum = (sum & 0xffff) + (sum >> 16);
-  sum = htons(0xffff - sum);
+  sum = htons (0xffff - sum);
   return sum;
 }
 
@@ -235,19 +234,14 @@ calc_checksum(const uint16_t *data,
  * @return 1 on success
  */
 static int
-inet_pton (int af,
-           const char *cp,
-           struct in_addr *buf)
+inet_pton (int af, const char *cp, struct in_addr *buf)
 {
-  buf->s_addr = inet_addr(cp);
+  buf->s_addr = inet_addr (cp);
   if (buf->s_addr == INADDR_NONE)
-    {
-      fprintf(stderr,
-              "Error %d handling address %s",
-              WSAGetLastError(),
-              cp);
-      return 0;
-    }
+  {
+    fprintf (stderr, "Error %d handling address %s", WSAGetLastError (), cp);
+    return 0;
+  }
   return 1;
 }
 
@@ -278,43 +272,35 @@ send_icmp_echo (const struct in_addr *my_ip)
   ip_pkt.checksum = 0;
   ip_pkt.src_ip = my_ip->s_addr;
   ip_pkt.dst_ip = dummy.s_addr;
-  ip_pkt.checksum = htons(calc_checksum((uint16_t*)&ip_pkt,
-                                        sizeof (struct ip_header)));
-  memcpy (&packet[off],
-          &ip_pkt,
-          sizeof (struct ip_header));
+  ip_pkt.checksum = htons (calc_checksum ((uint16_t *) & ip_pkt,
+                                          sizeof (struct ip_header)));
+  memcpy (&packet[off], &ip_pkt, sizeof (struct ip_header));
   off += sizeof (struct ip_header);
 
   icmp_echo.type = ICMP_ECHO;
   icmp_echo.code = 0;
   icmp_echo.reserved = 0;
   icmp_echo.checksum = 0;
-  icmp_echo.checksum = htons(calc_checksum((uint16_t*) &icmp_echo,
-                                           sizeof (struct icmp_echo_header)));
-  memcpy (&packet[off],
-          &icmp_echo,
-          sizeof (struct icmp_echo_header));
+  icmp_echo.checksum = htons (calc_checksum ((uint16_t *) & icmp_echo,
+                                             sizeof (struct icmp_echo_header)));
+  memcpy (&packet[off], &icmp_echo, sizeof (struct icmp_echo_header));
   off += sizeof (struct icmp_echo_header);
 
   memset (&dst, 0, sizeof (dst));
   dst.sin_family = AF_INET;
   dst.sin_addr = dummy;
-  err = sendto(rawsock,
-               packet, off, 0,
-               (struct sockaddr*)&dst,
-               sizeof(dst));
+  err = sendto (rawsock,
+                packet, off, 0, (struct sockaddr *) &dst, sizeof (dst));
   if (err < 0)
-    {
+  {
 #if VERBOSE
-      fprintf(stderr,
-              "sendto failed: %s\n", strerror(errno));
+    fprintf (stderr, "sendto failed: %s\n", strerror (errno));
 #endif
-    }
+  }
   else if (err != off)
-    {
-      fprintf(stderr,
-              "Error: partial send of ICMP message\n");
-    }
+  {
+    fprintf (stderr, "Error: partial send of ICMP message\n");
+  }
 }
 
 
@@ -331,22 +317,17 @@ send_udp ()
   dst.sin_family = AF_INET;
   dst.sin_addr = dummy;
   dst.sin_port = htons (NAT_TRAV_PORT);
-  err = sendto(udpsock,
-               NULL, 0, 0,
-               (struct sockaddr*)&dst,
-               sizeof(dst));
+  err = sendto (udpsock, NULL, 0, 0, (struct sockaddr *) &dst, sizeof (dst));
   if (err < 0)
-    {
+  {
 #if VERBOSE
-      fprintf(stderr,
-              "sendto failed: %s\n", strerror(errno));
+    fprintf (stderr, "sendto failed: %s\n", strerror (errno));
 #endif
-    }
+  }
   else if (0 != err)
-    {
-      fprintf(stderr,
-              "Error: partial send of ICMP message\n");
-    }
+  {
+    fprintf (stderr, "Error: partial send of ICMP message\n");
+  }
 }
 
 
@@ -369,96 +350,74 @@ process_icmp_response ()
 
   have = read (icmpsock, buf, sizeof (buf));
   if (have == -1)
-    {
-      fprintf (stderr,
-               "Error reading raw socket: %s\n",
-               strerror (errno));
-      return;
-    }
+  {
+    fprintf (stderr, "Error reading raw socket: %s\n", strerror (errno));
+    return;
+  }
 #if VERBOSE
-  fprintf (stderr,
-           "Received message of %u bytes\n",
-           (unsigned int) have);
+  fprintf (stderr, "Received message of %u bytes\n", (unsigned int) have);
 #endif
-  if (have < (ssize_t) (sizeof (struct ip_header) + sizeof (struct icmp_ttl_exceeded_header) + sizeof (struct ip_header)))
-    {
-      /* malformed */
-      return;
-    }
+  if (have <
+      (ssize_t) (sizeof (struct ip_header) +
+                 sizeof (struct icmp_ttl_exceeded_header) +
+                 sizeof (struct ip_header)))
+  {
+    /* malformed */
+    return;
+  }
   off = 0;
-  memcpy (&ip_pkt,
-          &buf[off],
-          sizeof (struct ip_header));
+  memcpy (&ip_pkt, &buf[off], sizeof (struct ip_header));
   off += sizeof (struct ip_header);
-  memcpy(&source_ip,
-         &ip_pkt.src_ip,
-         sizeof (source_ip));
-  memcpy (&icmp_ttl,
-          &buf[off],
-          sizeof (struct icmp_ttl_exceeded_header));
+  memcpy (&source_ip, &ip_pkt.src_ip, sizeof (source_ip));
+  memcpy (&icmp_ttl, &buf[off], sizeof (struct icmp_ttl_exceeded_header));
   off += sizeof (struct icmp_ttl_exceeded_header);
-  if ( (ICMP_TIME_EXCEEDED != icmp_ttl.type) ||
-       (0 != icmp_ttl.code) )
-    {
-      /* different type than what we want */
-      return;
-    }
+  if ((ICMP_TIME_EXCEEDED != icmp_ttl.type) || (0 != icmp_ttl.code))
+  {
+    /* different type than what we want */
+    return;
+  }
   /* skip 2nd IP header */
-  memcpy (&ip_pkt,
-          &buf[off],
-          sizeof (struct ip_header));
+  memcpy (&ip_pkt, &buf[off], sizeof (struct ip_header));
   off += sizeof (struct ip_header);
 
   switch (ip_pkt.proto)
+  {
+  case IPPROTO_ICMP:
+    if (have != (sizeof (struct ip_header) * 2 +
+                 sizeof (struct icmp_ttl_exceeded_header) +
+                 sizeof (struct icmp_echo_header)))
     {
-    case IPPROTO_ICMP:
-      if (have != (sizeof (struct ip_header) * 2 +
-                   sizeof (struct icmp_ttl_exceeded_header) +
-                   sizeof (struct icmp_echo_header)) )
-        {
-          /* malformed */
-          return;
-        }
-      /* grab ICMP ECHO content */
-      memcpy (&icmp_echo,
-              &buf[off],
-              sizeof (struct icmp_echo_header));
-      port = (uint16_t)  ntohl (icmp_echo.reserved);
-      break;
-    case IPPROTO_UDP:
-      if (have != (sizeof (struct ip_header) * 2 +
-                   sizeof (struct icmp_ttl_exceeded_header) +
-                   sizeof (struct udp_header)) )
-        {
-          /* malformed */
-          return;
-        }
-      /* grab UDP content */
-      memcpy (&udp_pkt,
-              &buf[off],
-              sizeof (struct udp_header));
-      port = ntohs (udp_pkt.length);
-      break;
-    default:
-      /* different type than what we want */
+      /* malformed */
       return;
     }
-
-  ssize = sizeof(buf);
-  WSAAddressToString((LPSOCKADDR)&source_ip,
-                     sizeof(source_ip),
-                     NULL,
-                     buf,
-                     &ssize);
+    /* grab ICMP ECHO content */
+    memcpy (&icmp_echo, &buf[off], sizeof (struct icmp_echo_header));
+    port = (uint16_t) ntohl (icmp_echo.reserved);
+    break;
+  case IPPROTO_UDP:
+    if (have != (sizeof (struct ip_header) * 2 +
+                 sizeof (struct icmp_ttl_exceeded_header) +
+                 sizeof (struct udp_header)))
+    {
+      /* malformed */
+      return;
+    }
+    /* grab UDP content */
+    memcpy (&udp_pkt, &buf[off], sizeof (struct udp_header));
+    port = ntohs (udp_pkt.length);
+    break;
+  default:
+    /* different type than what we want */
+    return;
+  }
+
+  ssize = sizeof (buf);
+  WSAAddressToString ((LPSOCKADDR) & source_ip,
+                      sizeof (source_ip), NULL, buf, &ssize);
   if (port == 0)
-    fprintf (stdout,
-             "%s\n",
-             buf);
+    fprintf (stdout, "%s\n", buf);
   else
-    fprintf (stdout,
-             "%s:%u\n",
-             buf,
-             (unsigned int) port);
+    fprintf (stdout, "%s:%u\n", buf, (unsigned int) port);
   fflush (stdout);
 }
 
@@ -475,12 +434,10 @@ make_icmp_socket ()
 
   ret = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
   if (INVALID_SOCKET == ret)
-    {
-      fprintf (stderr,
-               "Error opening RAW socket: %s\n",
-               strerror (errno));
-      return INVALID_SOCKET;
-    }
+  {
+    fprintf (stderr, "Error opening RAW socket: %s\n", strerror (errno));
+    return INVALID_SOCKET;
+  }
   return ret;
 }
 
@@ -494,39 +451,30 @@ static SOCKET
 make_raw_socket ()
 {
   DWORD bOptVal = TRUE;
-  int bOptLen = sizeof(bOptVal);
+  int bOptLen = sizeof (bOptVal);
 
   rawsock = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
   if (INVALID_SOCKET == rawsock)
-    {
-      fprintf (stderr,
-               "Error opening RAW socket: %s\n",
-               strerror (errno));
-      return INVALID_SOCKET;
-    }
-
-  if (0 != setsockopt(rawsock,
-                      SOL_SOCKET,
-                      SO_BROADCAST,
-                      (char*)&bOptVal, bOptLen))
-    {
-      fprintf(stderr,
-              "Error setting SO_BROADCAST to ON: %s\n",
-              strerror (errno));
-      closesocket(rawsock);
-      return INVALID_SOCKET;
-    }
-  if (0 != setsockopt(rawsock,
-                      IPPROTO_IP,
-                      IP_HDRINCL,
-                      (char*)&bOptVal, bOptLen))
-    {
-      fprintf(stderr,
-              "Error setting IP_HDRINCL to ON: %s\n",
-              strerror (errno));
-      closesocket(rawsock);
-      return INVALID_SOCKET;
-    }
+  {
+    fprintf (stderr, "Error opening RAW socket: %s\n", strerror (errno));
+    return INVALID_SOCKET;
+  }
+
+  if (0 != setsockopt (rawsock,
+                       SOL_SOCKET, SO_BROADCAST, (char *) &bOptVal, bOptLen))
+  {
+    fprintf (stderr,
+             "Error setting SO_BROADCAST to ON: %s\n", strerror (errno));
+    closesocket (rawsock);
+    return INVALID_SOCKET;
+  }
+  if (0 != setsockopt (rawsock,
+                       IPPROTO_IP, IP_HDRINCL, (char *) &bOptVal, bOptLen))
+  {
+    fprintf (stderr, "Error setting IP_HDRINCL to ON: %s\n", strerror (errno));
+    closesocket (rawsock);
+    return INVALID_SOCKET;
+  }
   return rawsock;
 }
 
@@ -545,33 +493,27 @@ make_udp_socket (const struct in_addr *my_ip)
 
   ret = socket (AF_INET, SOCK_DGRAM, 0);
   if (INVALID_SOCKET == ret)
-    {
-      fprintf (stderr,
-               "Error opening UDP socket: %s\n",
-               strerror (errno));
-      return INVALID_SOCKET;
-    }
+  {
+    fprintf (stderr, "Error opening UDP socket: %s\n", strerror (errno));
+    return INVALID_SOCKET;
+  }
   memset (&addr, 0, sizeof (addr));
   addr.sin_family = AF_INET;
   addr.sin_addr = *my_ip;
   addr.sin_port = htons (NAT_TRAV_PORT);
-  if (0 != bind (ret,
-                 (struct sockaddr *)&addr,
-                 sizeof(addr)))
-    {
-      fprintf (stderr,
-               "Error binding UDP socket to port %u: %s\n",
-               NAT_TRAV_PORT,
-               strerror (errno));
-      /* likely problematic, but not certain, try to continue */
-    }
+  if (0 != bind (ret, (struct sockaddr *) &addr, sizeof (addr)))
+  {
+    fprintf (stderr,
+             "Error binding UDP socket to port %u: %s\n",
+             NAT_TRAV_PORT, strerror (errno));
+    /* likely problematic, but not certain, try to continue */
+  }
   return ret;
 }
 
 
 int
-main (int argc,
-      char *const *argv)
+main (int argc, char *const *argv)
 {
   struct in_addr external;
   fd_set rs;
@@ -581,70 +523,67 @@ main (int argc,
 
   alt = 0;
   if (2 != argc)
-    {
-      fprintf (stderr,
-               "This program must be started with our (internal NAT) IP as the only argument.\n");
-      return 1;
-    }
+  {
+    fprintf (stderr,
+             "This program must be started with our (internal NAT) IP as the only argument.\n");
+    return 1;
+  }
   if (1 != inet_pton (AF_INET, argv[1], &external))
-    {
-      fprintf (stderr,
-               "Error parsing IPv4 address: %s, error %s\n",
-               argv[1], strerror (errno));
-      return 1;
-    }
+  {
+    fprintf (stderr,
+             "Error parsing IPv4 address: %s, error %s\n",
+             argv[1], strerror (errno));
+    return 1;
+  }
   if (1 != inet_pton (AF_INET, DUMMY_IP, &dummy))
-    {
-      fprintf (stderr,
-               "Internal error converting dummy IP to binary.\n");
-      return 2;
-    }
+  {
+    fprintf (stderr, "Internal error converting dummy IP to binary.\n");
+    return 2;
+  }
   if (WSAStartup (MAKEWORD (2, 1), &wsaData) != 0)
-    {
-      fprintf (stderr, "Failed to find Winsock 2.1 or better.\n");
-      return 2;
-    }
-  if (INVALID_SOCKET == (icmpsock = make_icmp_socket()))
-    {
-      return 3;
-    }
-  if (INVALID_SOCKET == (make_raw_socket()))
-    {
-      closesocket (icmpsock);
-      return 3;
-    }
-  if (INVALID_SOCKET == (udpsock = make_udp_socket(&external)))
-    {
-      closesocket (icmpsock);
-      closesocket (rawsock);
-      return 3;
-    }
+  {
+    fprintf (stderr, "Failed to find Winsock 2.1 or better.\n");
+    return 2;
+  }
+  if (INVALID_SOCKET == (icmpsock = make_icmp_socket ()))
+  {
+    return 3;
+  }
+  if (INVALID_SOCKET == (make_raw_socket ()))
+  {
+    closesocket (icmpsock);
+    return 3;
+  }
+  if (INVALID_SOCKET == (udpsock = make_udp_socket (&external)))
+  {
+    closesocket (icmpsock);
+    closesocket (rawsock);
+    return 3;
+  }
   while (1)
+  {
+    FD_ZERO (&rs);
+    FD_SET (icmpsock, &rs);
+    tv.tv_sec = 0;
+    tv.tv_usec = ICMP_SEND_FREQUENCY_MS * 1000;
+    if (-1 == select (icmpsock + 1, &rs, NULL, NULL, &tv))
     {
-      FD_ZERO (&rs);
-      FD_SET (icmpsock, &rs);
-      tv.tv_sec = 0;
-      tv.tv_usec = ICMP_SEND_FREQUENCY_MS * 1000;
-      if (-1 == select (icmpsock + 1, &rs, NULL, NULL, &tv))
-        {
-          if (errno == EINTR)
-            continue;
-          fprintf (stderr,
-                   "select failed: %s\n",
-                   strerror (errno));
-          break;
-        }
-      if (FD_ISSET (icmpsock, &rs))
-        process_icmp_response ();
-      if (0 == (++alt % 2))
-        send_icmp_echo (&external);
-      else
-        send_udp ();
+      if (errno == EINTR)
+        continue;
+      fprintf (stderr, "select failed: %s\n", strerror (errno));
+      break;
     }
+    if (FD_ISSET (icmpsock, &rs))
+      process_icmp_response ();
+    if (0 == (++alt % 2))
+      send_icmp_echo (&external);
+    else
+      send_udp ();
+  }
   /* select failed (internal error or OS out of resources) */
-  closesocket(icmpsock);
-  closesocket(rawsock);
-  closesocket(udpsock);
+  closesocket (icmpsock);
+  closesocket (rawsock);
+  closesocket (udpsock);
   WSACleanup ();
   return 4;
 }
diff --git a/src/nat/gnunet-helper-nat-server.c b/src/nat/gnunet-helper-nat-server.c
index 945c98735..636ae6003 100644
--- a/src/nat/gnunet-helper-nat-server.c
+++ b/src/nat/gnunet-helper-nat-server.c
@@ -212,17 +212,16 @@ static struct in_addr dummy;
  * @return the CRC 16.
  */
 static uint16_t
-calc_checksum(const uint16_t *data,
-              unsigned int bytes)
+calc_checksum (const uint16_t * data, unsigned int bytes)
 {
   uint32_t sum;
   unsigned int i;
 
   sum = 0;
-  for (i=0;i<bytes/2;i++)
+  for (i = 0; i < bytes / 2; i++)
     sum += data[i];
   sum = (sum & 0xffff) + (sum >> 16);
-  sum = htons(0xffff - sum);
+  sum = htons (0xffff - sum);
   return sum;
 }
 
@@ -253,22 +252,18 @@ send_icmp_echo (const struct in_addr *my_ip)
   ip_pkt.checksum = 0;
   ip_pkt.src_ip = my_ip->s_addr;
   ip_pkt.dst_ip = dummy.s_addr;
-  ip_pkt.checksum = htons(calc_checksum((uint16_t*)&ip_pkt,
-                                        sizeof (struct ip_header)));
-  memcpy (&packet[off],
-          &ip_pkt,
-          sizeof (struct ip_header));
+  ip_pkt.checksum = htons (calc_checksum ((uint16_t *) & ip_pkt,
+                                          sizeof (struct ip_header)));
+  memcpy (&packet[off], &ip_pkt, sizeof (struct ip_header));
   off += sizeof (struct ip_header);
 
   icmp_echo.type = ICMP_ECHO;
   icmp_echo.code = 0;
   icmp_echo.checksum = 0;
   icmp_echo.reserved = 0;
-  icmp_echo.checksum = htons(calc_checksum((uint16_t*)&icmp_echo,
-                                           sizeof (struct icmp_echo_header)));
-  memcpy (&packet[off],
-          &icmp_echo,
-          sizeof (struct icmp_echo_header));
+  icmp_echo.checksum = htons (calc_checksum ((uint16_t *) & icmp_echo,
+                                             sizeof (struct icmp_echo_header)));
+  memcpy (&packet[off], &icmp_echo, sizeof (struct icmp_echo_header));
   off += sizeof (struct icmp_echo_header);
 
   memset (&dst, 0, sizeof (dst));
@@ -277,22 +272,18 @@ send_icmp_echo (const struct in_addr *my_ip)
   dst.sin_len = sizeof (struct sockaddr_in);
 #endif
   dst.sin_addr = dummy;
-  err = sendto(rawsock,
-               packet, off, 0,
-               (struct sockaddr*)&dst,
-               sizeof(dst));
+  err = sendto (rawsock,
+                packet, off, 0, (struct sockaddr *) &dst, sizeof (dst));
   if (err < 0)
-    {
+  {
 #if VERBOSE
-      fprintf(stderr,
-              "sendto failed: %s\n", strerror(errno));
+    fprintf (stderr, "sendto failed: %s\n", strerror (errno));
 #endif
-    }
+  }
   else if (sizeof (packet) != err)
-    {
-      fprintf(stderr,
-              "Error: partial send of ICMP message\n");
-    }
+  {
+    fprintf (stderr, "Error: partial send of ICMP message\n");
+  }
 }
 
 
@@ -312,22 +303,17 @@ send_udp ()
 #endif
   dst.sin_addr = dummy;
   dst.sin_port = htons (NAT_TRAV_PORT);
-  err = sendto(udpsock,
-               NULL, 0, 0,
-               (struct sockaddr*)&dst,
-               sizeof(dst));
+  err = sendto (udpsock, NULL, 0, 0, (struct sockaddr *) &dst, sizeof (dst));
   if (err < 0)
-    {
+  {
 #if VERBOSE
-      fprintf(stderr,
-              "sendto failed: %s\n", strerror(errno));
+    fprintf (stderr, "sendto failed: %s\n", strerror (errno));
 #endif
-    }
+  }
   else if (0 != err)
-    {
-      fprintf(stderr,
-              "Error: partial send of ICMP message\n");
-    }
+  {
+    fprintf (stderr, "Error: partial send of ICMP message\n");
+  }
 }
 
 
@@ -349,96 +335,75 @@ process_icmp_response ()
 
   have = read (icmpsock, buf, sizeof (buf));
   if (-1 == have)
-    {
-      fprintf (stderr,
-               "Error reading raw socket: %s\n",
-               strerror (errno));
-      return;
-    }
+  {
+    fprintf (stderr, "Error reading raw socket: %s\n", strerror (errno));
+    return;
+  }
 #if VERBOSE
-  fprintf (stderr,
-           "Received message of %u bytes\n",
-           (unsigned int) have);
+  fprintf (stderr, "Received message of %u bytes\n", (unsigned int) have);
 #endif
-  if (have < (ssize_t) (sizeof (struct ip_header) + sizeof (struct icmp_ttl_exceeded_header) + sizeof (struct ip_header)))
-    {
-      /* malformed */
-      return;
-    }
+  if (have <
+      (ssize_t) (sizeof (struct ip_header) +
+                 sizeof (struct icmp_ttl_exceeded_header) +
+                 sizeof (struct ip_header)))
+  {
+    /* malformed */
+    return;
+  }
   off = 0;
-  memcpy (&ip_pkt,
-          &buf[off],
-          sizeof (struct ip_header));
+  memcpy (&ip_pkt, &buf[off], sizeof (struct ip_header));
   off += sizeof (struct ip_header);
-  memcpy(&source_ip,
-         &ip_pkt.src_ip,
-         sizeof (source_ip));
-  memcpy (&icmp_ttl,
-          &buf[off],
-          sizeof (struct icmp_ttl_exceeded_header));
+  memcpy (&source_ip, &ip_pkt.src_ip, sizeof (source_ip));
+  memcpy (&icmp_ttl, &buf[off], sizeof (struct icmp_ttl_exceeded_header));
   off += sizeof (struct icmp_ttl_exceeded_header);
-  if ( (ICMP_TIME_EXCEEDED != icmp_ttl.type) ||
-       (0 != icmp_ttl.code) )
-    {
-      /* different type than what we want */
-      return;
-    }
+  if ((ICMP_TIME_EXCEEDED != icmp_ttl.type) || (0 != icmp_ttl.code))
+  {
+    /* different type than what we want */
+    return;
+  }
   /* skip 2nd IP header */
-  memcpy (&ip_pkt,
-          &buf[off],
-          sizeof (struct ip_header));
+  memcpy (&ip_pkt, &buf[off], sizeof (struct ip_header));
   off += sizeof (struct ip_header);
 
   switch (ip_pkt.proto)
+  {
+  case IPPROTO_ICMP:
+    if (have != (sizeof (struct ip_header) * 2 +
+                 sizeof (struct icmp_ttl_exceeded_header) +
+                 sizeof (struct icmp_echo_header)))
     {
-    case IPPROTO_ICMP:
-      if (have != (sizeof (struct ip_header) * 2 +
-                   sizeof (struct icmp_ttl_exceeded_header) +
-                   sizeof (struct icmp_echo_header)) )
-        {
-          /* malformed */
-          return;
-        }
-      /* grab ICMP ECHO content */
-      memcpy (&icmp_echo,
-              &buf[off],
-              sizeof (struct icmp_echo_header));
-      port = (uint16_t)  ntohl (icmp_echo.reserved);
-      break;
-    case IPPROTO_UDP:
-      if (have != (sizeof (struct ip_header) * 2 +
-                   sizeof (struct icmp_ttl_exceeded_header) +
-                   sizeof (struct udp_header)) )
-        {
-          /* malformed */
-          return;
-        }
-      /* grab UDP content */
-      memcpy (&udp_pkt,
-              &buf[off],
-              sizeof (struct udp_header));
-      port = ntohs (udp_pkt.length);
-      break;
-    default:
-      /* different type than what we want */
+      /* malformed */
       return;
     }
+    /* grab ICMP ECHO content */
+    memcpy (&icmp_echo, &buf[off], sizeof (struct icmp_echo_header));
+    port = (uint16_t) ntohl (icmp_echo.reserved);
+    break;
+  case IPPROTO_UDP:
+    if (have != (sizeof (struct ip_header) * 2 +
+                 sizeof (struct icmp_ttl_exceeded_header) +
+                 sizeof (struct udp_header)))
+    {
+      /* malformed */
+      return;
+    }
+    /* grab UDP content */
+    memcpy (&udp_pkt, &buf[off], sizeof (struct udp_header));
+    port = ntohs (udp_pkt.length);
+    break;
+  default:
+    /* different type than what we want */
+    return;
+  }
 
   if (port == 0)
     fprintf (stdout,
-             "%s\n",
-             inet_ntop (AF_INET,
-                        &source_ip,
-                        buf,
-                        sizeof (buf)));
+             "%s\n", inet_ntop (AF_INET, &source_ip, buf, sizeof (buf)));
   else
     fprintf (stdout,
-             "%s:%u\n",
-             inet_ntop (AF_INET,
-                        &source_ip,
-                        buf,
-                        sizeof (buf)),
-             (unsigned int) port);
+             "%s:%u\n",
+             inet_ntop (AF_INET,
+                        &source_ip, buf, sizeof (buf)), (unsigned int) port);
   fflush (stdout);
 }
 
@@ -455,21 +420,18 @@ make_icmp_socket ()
 
   ret = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
   if (-1 == ret)
-    {
-      fprintf (stderr,
-               "Error opening RAW socket: %s\n",
-               strerror (errno));
-      return -1;
-    }
+  {
+    fprintf (stderr, "Error opening RAW socket: %s\n", strerror (errno));
+    return -1;
+  }
   if (ret >= FD_SETSIZE)
-    {
-      fprintf (stderr,
-               "Socket number too large (%d > %u)\n",
-               ret,
-               (unsigned int) FD_SETSIZE);
-      close (ret);
-      return -1;
-    }
+  {
+    fprintf (stderr,
+             "Socket number too large (%d > %u)\n",
+             ret, (unsigned int) FD_SETSIZE);
+    close (ret);
+    return -1;
+  }
   return ret;
 }
 
@@ -487,34 +449,24 @@ make_raw_socket ()
 
   ret = socket (AF_INET, SOCK_RAW, IPPROTO_RAW);
   if (-1 == ret)
-    {
-      fprintf (stderr,
-               "Error opening RAW socket: %s\n",
-               strerror (errno));
-      return -1;
-    }
-  if (-1 == setsockopt(ret,
-                       SOL_SOCKET,
-                       SO_BROADCAST,
-                       (char *)&one, sizeof(one)))
-    {
-      fprintf(stderr,
-              "setsockopt failed: %s\n",
-              strerror (errno));
-      close (ret);
-      return -1;
-    }
-  if (-1 == setsockopt(ret,
-                       IPPROTO_IP,
-                       IP_HDRINCL,
-                       (char *)&one, sizeof(one)))
-    {
-      fprintf(stderr,
-              "setsockopt failed: %s\n",
-              strerror (errno));
-      close (ret);
-      return -1;
-    }
+  {
+    fprintf (stderr, "Error opening RAW socket: %s\n", strerror (errno));
+    return -1;
+  }
+  if (-1 == setsockopt (ret,
+                        SOL_SOCKET, SO_BROADCAST, (char *) &one, sizeof (one)))
+  {
+    fprintf (stderr, "setsockopt failed: %s\n", strerror (errno));
+    close (ret);
+    return -1;
+  }
+  if (-1 == setsockopt (ret,
+                        IPPROTO_IP, IP_HDRINCL, (char *) &one, sizeof (one)))
+  {
+    fprintf (stderr, "setsockopt failed: %s\n", strerror (errno));
+    close (ret);
+    return -1;
+  }
   return ret;
 }
 
@@ -533,15 +485,11 @@ make_udp_socket (const struct in_addr *my_ip)
 
   ret = socket (AF_INET, SOCK_DGRAM, 0);
   if (-1 == ret)
-    {
-      fprintf (stderr,
-               "Error opening UDP socket: %s\n",
-               strerror (errno));
-      return -1;
-    }
-  memset (&addr,
-          0,
-          sizeof (addr));
+  {
+    fprintf (stderr, "Error opening UDP socket: %s\n", strerror (errno));
+    return -1;
+  }
+  memset (&addr, 0, sizeof (addr));
   addr.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
   addr.sin_len = sizeof (struct sockaddr_in);
@@ -549,23 +497,19 @@ make_udp_socket (const struct in_addr *my_ip)
   addr.sin_addr = *my_ip;
   addr.sin_port = htons (NAT_TRAV_PORT);
 
-  if (0 != bind (ret,
-                 &addr,
-                 sizeof(addr)))
-    {
-      fprintf (stderr,
-               "Error binding UDP socket to port %u: %s\n",
-               NAT_TRAV_PORT,
-               strerror (errno));
-      /* likely problematic, but not certain, try to continue */
-    }
+  if (0 != bind (ret, &addr, sizeof (addr)))
+  {
+    fprintf (stderr,
+             "Error binding UDP socket to port %u: %s\n",
+             NAT_TRAV_PORT, strerror (errno));
+    /* likely problematic, but not certain, try to continue */
+  }
   return ret;
 }
 
 
 int
-main (int argc,
-      char *const *argv)
+main (int argc, char *const *argv)
 {
   struct in_addr external;
   fd_set rs;
@@ -574,72 +518,65 @@ main (int argc,
   unsigned int alt;
 
   if (2 != argc)
-    {
-      fprintf (stderr,
-               "This program must be started with our (internal NAT) IP as the only argument.\n");
-      return 1;
-    }
+  {
+    fprintf (stderr,
+             "This program must be started with our (internal NAT) IP as the only argument.\n");
+    return 1;
+  }
   if (1 != inet_pton (AF_INET, argv[1], &external))
-    {
-      fprintf (stderr,
-              "Error parsing IPv4 address: %s\n",
-              strerror (errno));
-      return 1;
-    }
+  {
+    fprintf (stderr, "Error parsing IPv4 address: %s\n", strerror (errno));
+    return 1;
+  }
   if (1 != inet_pton (AF_INET, DUMMY_IP, &dummy))
-    {
-      fprintf (stderr,
-               "Internal error converting dummy IP to binary.\n");
-      return 2;
-    }
-  if (-1 == (icmpsock = make_icmp_socket()))
-    {
-      return 3;
-    }
-  if (-1 == (rawsock = make_raw_socket()))
-    {
-      close (icmpsock);
-      return 3;
-    }
+  {
+    fprintf (stderr, "Internal error converting dummy IP to binary.\n");
+    return 2;
+  }
+  if (-1 == (icmpsock = make_icmp_socket ()))
+  {
+    return 3;
+  }
+  if (-1 == (rawsock = make_raw_socket ()))
+  {
+    close (icmpsock);
+    return 3;
+  }
   uid = getuid ();
   if (0 != setresuid (uid, uid, uid))
-    {
-      fprintf (stderr,
-               "Failed to setresuid: %s\n",
-               strerror (errno));
-      /* not critical, continue anyway */
-    }
-  if (-1 == (udpsock = make_udp_socket(&external)))
-    {
-      close (icmpsock);
-      close (rawsock);
-      return 3;
-    }
+  {
+    fprintf (stderr, "Failed to setresuid: %s\n", strerror (errno));
+    /* not critical, continue anyway */
+  }
+  if (-1 == (udpsock = make_udp_socket (&external)))
+  {
+    close (icmpsock);
+    close (rawsock);
+    return 3;
+  }
   alt = 0;
   while (1)
+  {
+    FD_ZERO (&rs);
+    FD_SET (icmpsock, &rs);
+    tv.tv_sec = 0;
+    tv.tv_usec = ICMP_SEND_FREQUENCY_MS * 1000;
+    if (-1 == select (icmpsock + 1, &rs, NULL, NULL, &tv))
     {
-      FD_ZERO (&rs);
-      FD_SET (icmpsock, &rs);
-      tv.tv_sec = 0;
-      tv.tv_usec = ICMP_SEND_FREQUENCY_MS * 1000;
-      if (-1 == select (icmpsock + 1, &rs, NULL, NULL, &tv))
-        {
-          if (errno == EINTR)
-            continue;
-          fprintf (stderr,
-                   "select failed: %s\n",
-                   strerror (errno));
-          break;
-        }
-      if (1 == getppid()) /* Check the parent process id, if 1 the parent has died, so we should die too */
-        break;
-      if (FD_ISSET (icmpsock, &rs))
-        process_icmp_response ();
-      if (0 == (++alt % 2))
-        send_icmp_echo (&external);
-      else
-        send_udp ();
+      if (errno == EINTR)
+        continue;
+      fprintf (stderr, "select failed: %s\n", strerror (errno));
+      break;
     }
+    if (1 == getppid ())        /* Check the parent process id, if 1 the parent has died, so we should die too */
+      break;
+    if (FD_ISSET (icmpsock, &rs))
+      process_icmp_response ();
+    if (0 == (++alt % 2))
+      send_icmp_echo (&external);
+    else
+      send_udp ();
+  }
   /* select failed (internal error or OS out of resources) */
   close (icmpsock);
   close (rawsock);
diff --git a/src/nat/gnunet-nat-server.c b/src/nat/gnunet-nat-server.c
index bf4318a91..3b4ec2293 100644
--- a/src/nat/gnunet-nat-server.c
+++ b/src/nat/gnunet-nat-server.c
@@ -51,30 +51,23 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
  * @param is_tcp mark for TCP (GNUNET_YES)  or UDP (GNUNET_NO)
  */
 static void
-try_anat (uint32_t dst_ipv4,
-          uint16_t dport,
-          int is_tcp)
+try_anat (uint32_t dst_ipv4, uint16_t dport, int is_tcp)
 {
   struct GNUNET_NAT_Handle *h;
   struct sockaddr_in sa;
 
 #if DEBUG_NAT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking for connection reversal with %x and code %u\n",
-              (unsigned int) dst_ipv4,
-              (unsigned int) dport);
+              "Asking for connection reversal with %x and code %u\n",
+              (unsigned int) dst_ipv4, (unsigned int) dport);
 #endif
-  h = GNUNET_NAT_register (cfg,
-                           is_tcp,
-                           dport,
-                           0, NULL, NULL,
-                           NULL, NULL, NULL);
+  h = GNUNET_NAT_register (cfg, is_tcp, dport, 0, NULL, NULL, NULL, NULL, NULL);
   memset (&sa, 0, sizeof (sa));
   sa.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
   sa.sin_len = sizeof (sa);
 #endif
-  sa.sin_addr.s_addr = dst_ipv4; 
+  sa.sin_addr.s_addr = dst_ipv4;
   GNUNET_NAT_run_client (h, &sa);
   GNUNET_NAT_unregister (h);
 }
@@ -83,7 +76,7 @@ try_anat (uint32_t dst_ipv4,
 /**
  * Closure for 'tcp_send'.
  */
-struct TcpContext 
+struct TcpContext
 {
   /**
    * TCP  socket.
@@ -92,7 +85,7 @@ struct TcpContext
 
   /** 
    * Data to transmit.
-   */  
+   */
   uint16_t data;
 };
 
@@ -105,23 +98,22 @@ struct TcpContext
  * @param tc scheduler context
  */
 static void
-tcp_send (void *cls,
-          const struct GNUNET_SCHEDULER_TaskContext *tc)
+tcp_send (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct TcpContext *ctx = cls;
 
-  if ( (NULL != tc->write_ready) &&
-       (GNUNET_NETWORK_fdset_isset (tc->write_ready, 
-                                    ctx->s)) )
+  if ((NULL != tc->write_ready) &&
+      (GNUNET_NETWORK_fdset_isset (tc->write_ready, ctx->s)))
+  {
+    if (-1 ==
+        GNUNET_NETWORK_socket_send (ctx->s, &ctx->data, sizeof (ctx->data)))
     {
-      if (-1 == GNUNET_NETWORK_socket_send (ctx->s, &ctx->data, sizeof (ctx->data)))
-        {
 #if DEBUG_NAT
-          GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "send");
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_DEBUG, "send");
 #endif
-        }
-      GNUNET_NETWORK_socket_shutdown (ctx->s, SHUT_RDWR);
     }
+    GNUNET_NETWORK_socket_shutdown (ctx->s, SHUT_RDWR);
+  }
   GNUNET_NETWORK_socket_close (ctx->s);
   GNUNET_free (ctx);
 }
@@ -136,9 +128,7 @@ tcp_send (void *cls,
  * @param data data to send
  */
 static void
-try_send_tcp (uint32_t dst_ipv4,
-              uint16_t dport,
-              uint16_t data)
+try_send_tcp (uint32_t dst_ipv4, uint16_t dport, uint16_t data)
 {
   struct GNUNET_NETWORK_Handle *s;
   struct sockaddr_in sa;
@@ -146,37 +136,35 @@ try_send_tcp (uint32_t dst_ipv4,
 
   s = GNUNET_NETWORK_socket_create (AF_INET, SOCK_STREAM, 0);
   if (NULL == s)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
-      return;
-    }
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
+    return;
+  }
   memset (&sa, 0, sizeof (sa));
   sa.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
   sa.sin_len = sizeof (sa);
 #endif
-  sa.sin_addr.s_addr = dst_ipv4; 
+  sa.sin_addr.s_addr = dst_ipv4;
   sa.sin_port = htons (dport);
 #if DEBUG_NAT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending TCP message to `%s'\n",
-              GNUNET_a2s ((struct sockaddr*) &sa, sizeof (sa)));
+              "Sending TCP message to `%s'\n",
+              GNUNET_a2s ((struct sockaddr *) &sa, sizeof (sa)));
 #endif
-  if ( (GNUNET_OK != 
-        GNUNET_NETWORK_socket_connect (s, 
-                                       (const struct sockaddr*) &sa, sizeof (sa))) &&
-       (errno != EINPROGRESS) )
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "connect");
-      GNUNET_NETWORK_socket_close (s);
-      return;
-    }
+  if ((GNUNET_OK !=
+       GNUNET_NETWORK_socket_connect (s,
+                                      (const struct sockaddr *) &sa,
+                                      sizeof (sa))) && (errno != EINPROGRESS))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "connect");
+    GNUNET_NETWORK_socket_close (s);
+    return;
+  }
   ctx = GNUNET_malloc (sizeof (struct TcpContext));
   ctx->s = s;
   ctx->data = data;
-  GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_SECONDS,
-                                  s,
-                                  &tcp_send, ctx);
+  GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_UNIT_SECONDS, s, &tcp_send, ctx);
 }
 
 
@@ -189,34 +177,33 @@ try_send_tcp (uint32_t dst_ipv4,
  * @param data data to send
  */
 static void
-try_send_udp (uint32_t dst_ipv4,
-              uint16_t dport,
-              uint16_t data)
+try_send_udp (uint32_t dst_ipv4, uint16_t dport, uint16_t data)
 {
   struct GNUNET_NETWORK_Handle *s;
   struct sockaddr_in sa;
 
   s = GNUNET_NETWORK_socket_create (AF_INET, SOCK_DGRAM, 0);
   if (NULL == s)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
-      return;
-    }
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "socket");
+    return;
+  }
   memset (&sa, 0, sizeof (sa));
   sa.sin_family = AF_INET;
 #if HAVE_SOCKADDR_IN_SIN_LEN
   sa.sin_len = sizeof (sa);
 #endif
-  sa.sin_addr.s_addr = dst_ipv4; 
+  sa.sin_addr.s_addr = dst_ipv4;
   sa.sin_port = htons (dport);
 #if DEBUG_NAT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending UDP packet to `%s'\n",
-              GNUNET_a2s ((struct sockaddr*) &sa, sizeof (sa)));
+              "Sending UDP packet to `%s'\n",
+              GNUNET_a2s ((struct sockaddr *) &sa, sizeof (sa)));
 #endif
-  if (-1 == GNUNET_NETWORK_socket_sendto (s, 
-                                          &data, sizeof(data),
-                                          (const struct sockaddr*) &sa, sizeof (sa)))
+  if (-1 == GNUNET_NETWORK_socket_sendto (s,
+                                          &data, sizeof (data),
+                                          (const struct sockaddr *) &sa,
+                                          sizeof (sa)))
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "sendto");
   GNUNET_NETWORK_socket_close (s);
 }
@@ -239,21 +226,17 @@ test (void *cls,
   uint16_t dport;
 
 #if DEBUG_NAT
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received test request\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received test request\n");
 #endif
-  tm = (const struct GNUNET_NAT_TestMessage*) msg;
+  tm = (const struct GNUNET_NAT_TestMessage *) msg;
   dport = ntohs (tm->dport);
   if (0 == dport)
-    try_anat (tm->dst_ipv4,
-              ntohs (tm->data),
-              (int) ntohl (tm->is_tcp));
+    try_anat (tm->dst_ipv4, ntohs (tm->data), (int) ntohl (tm->is_tcp));
   else if (GNUNET_YES == ntohl (tm->is_tcp))
     try_send_tcp (tm->dst_ipv4, dport, tm->data);
   else
     try_send_udp (tm->dst_ipv4, dport, tm->data);
-  GNUNET_SERVER_receive_done (client,
-                              GNUNET_NO);
+  GNUNET_SERVER_receive_done (client, GNUNET_NO);
 }
 
 
@@ -264,8 +247,7 @@ test (void *cls,
  * @param tc scheduler context
  */
 static void
-shutdown_task (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_SERVER_destroy (server);
   server = NULL;
@@ -283,43 +265,40 @@ shutdown_task (void *cls,
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  static const struct GNUNET_SERVER_MessageHandler handlers[] =
-      {
-        { &test, NULL, GNUNET_MESSAGE_TYPE_NAT_TEST, sizeof (struct GNUNET_NAT_TestMessage) },
-        { NULL, NULL, 0, 0 }
-      };
+  static const struct GNUNET_SERVER_MessageHandler handlers[] = {
+    {&test, NULL, GNUNET_MESSAGE_TYPE_NAT_TEST,
+     sizeof (struct GNUNET_NAT_TestMessage)},
+    {NULL, NULL, 0, 0}
+  };
   unsigned int port;
   struct sockaddr_in in4;
   struct sockaddr_in6 in6;
-  socklen_t slen[] =
-    {
-      sizeof (in4),
-      sizeof (in6), 
-      0
-    };
-  struct sockaddr *sa[] =
-    {
-      (struct sockaddr*) &in4,
-      (struct sockaddr*) &in6,
-      NULL
-    };
+
+  socklen_t slen[] = {
+    sizeof (in4),
+    sizeof (in6),
+    0
+  };
+  struct sockaddr *sa[] = {
+    (struct sockaddr *) &in4,
+    (struct sockaddr *) &in6,
+    NULL
+  };
 
   cfg = c;
-  if ( (args[0] == NULL) || 
-       (1 != SSCANF (args[0], "%u", &port)) ||
-       (0 == port) ||
-       (65536 <= port) )
-    {
-      fprintf (stderr,
-               _("Please pass valid port number as the first argument! (got `%s')\n"),
-               args[0]);
-      return;
-    }
-  memset (&in4, 0, sizeof (in4)); 
-  memset (&in6, 0, sizeof (in6)); 
+  if ((args[0] == NULL) ||
+      (1 != SSCANF (args[0], "%u", &port)) || (0 == port) || (65536 <= port))
+  {
+    fprintf (stderr,
+             _
+             ("Please pass valid port number as the first argument! (got `%s')\n"),
+             args[0]);
+    return;
+  }
+  memset (&in4, 0, sizeof (in4));
+  memset (&in6, 0, sizeof (in6));
   in4.sin_family = AF_INET;
   in4.sin_port = htons ((uint16_t) port);
   in6.sin6_family = AF_INET6;
@@ -329,15 +308,11 @@ run (void *cls,
   in6.sin6_len = sizeof (in6);
 #endif
   server = GNUNET_SERVER_create (NULL, NULL,
-                                 (struct sockaddr*const*) sa,
-                                 slen,
-                                 GNUNET_TIME_UNIT_SECONDS,
-                                 GNUNET_YES);
-  GNUNET_SERVER_add_handlers (server,
-                              handlers);
+                                 (struct sockaddr * const *) sa,
+                                 slen, GNUNET_TIME_UNIT_SECONDS, GNUNET_YES);
+  GNUNET_SERVER_add_handlers (server, handlers);
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                &shutdown_task,
-                                NULL);
+                                &shutdown_task, NULL);
 }
 
 
@@ -356,11 +331,10 @@ main (int argc, char *const argv[])
   };
 
   if (GNUNET_OK !=
-      GNUNET_PROGRAM_run (argc, argv, 
-                          "gnunet-nat-server [options] PORT", 
-                          _("GNUnet NAT traversal test helper daemon"), 
-                          options,
-                          &run, NULL))
+      GNUNET_PROGRAM_run (argc, argv,
+                          "gnunet-nat-server [options] PORT",
+                          _("GNUnet NAT traversal test helper daemon"),
+                          options, &run, NULL))
     return 1;
   return 0;
 }
diff --git a/src/nat/nat.c b/src/nat/nat.c
index a4efb7084..ed72be9f8 100644
--- a/src/nat/nat.c
+++ b/src/nat/nat.c
@@ -62,40 +62,39 @@
  * we reevaluate the source.
  */
 enum LocalAddressSource
-  {
+{
     /**
      * Address was obtained by DNS resolution of the external hostname
      * given in the configuration (i.e. hole-punched DynDNS setup).
      */
-    LAL_EXTERNAL_IP,
+  LAL_EXTERNAL_IP,
 
     /**
      * Address was obtained by looking up our own hostname in DNS.
      */
-    LAL_HOSTNAME_DNS,
+  LAL_HOSTNAME_DNS,
 
     /**
      * Address was obtained by scanning our hosts's network interfaces
      * and taking their address (no DNS involved).
      */
-    LAL_INTERFACE_ADDRESS,
-    
+  LAL_INTERFACE_ADDRESS,
+
     /**
      * Addresses we were explicitly bound to.
      */
-    LAL_BINDTO_ADDRESS,
+  LAL_BINDTO_ADDRESS,
 
     /**
      * Addresses from UPnP or PMP
      */
-    LAL_UPNP,
+  LAL_UPNP,
 
     /**
      * End of the list.
      */
-    LAL_END
-    
-  };
+  LAL_END
+};
 
 
 /**
@@ -114,7 +113,7 @@ struct LocalAddressList
 
   /**
    * Previous entry.
-   */ 
+   */
   struct LocalAddressList *prev;
 
   /**
@@ -168,7 +167,7 @@ struct GNUNET_NAT_Handle
    * Configuration to use.
    */
   const struct GNUNET_CONFIGURATION_Handle *cfg;
-  
+
   /**
    * Function to call when we learn about a new address.
    */
@@ -345,7 +344,7 @@ struct GNUNET_NAT_Handle
 
   /**
    * Is this TCP or UDP?
-   */ 
+   */
   int is_tcp;
 
   /**
@@ -362,8 +361,7 @@ 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);
 
 
 /**
@@ -375,27 +373,24 @@ start_gnunet_nat_server (struct GNUNET_NAT_Handle *h);
  */
 static void
 remove_from_address_list_by_source (struct GNUNET_NAT_Handle *h,
-                                    enum LocalAddressSource src)
+                                    enum LocalAddressSource src)
 {
   struct LocalAddressList *pos;
   struct LocalAddressList *next;
 
   next = h->lal_head;
   while (NULL != (pos = next))
-    {
-      next = pos->next;
-      if (pos->source != src)
-        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,
-                             (const struct sockaddr* ) &pos[1],
-                             pos->addrlen);
-      GNUNET_free (pos);
-    }
+  {
+    next = pos->next;
+    if (pos->source != src)
+      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,
+                           (const struct sockaddr *) &pos[1], pos->addrlen);
+    GNUNET_free (pos);
+  }
 }
 
 
@@ -410,9 +405,8 @@ remove_from_address_list_by_source (struct GNUNET_NAT_Handle *h,
  */
 static void
 add_to_address_list_as_is (struct GNUNET_NAT_Handle *h,
-                           enum LocalAddressSource src,
-                           const struct sockaddr *arg,
-                           socklen_t arg_size)
+                           enum LocalAddressSource src,
+                           const struct sockaddr *arg, socklen_t arg_size)
 {
   struct LocalAddressList *lal;
 
@@ -420,21 +414,15 @@ add_to_address_list_as_is (struct GNUNET_NAT_Handle *h,
   memcpy (&lal[1], arg, arg_size);
   lal->addrlen = arg_size;
   lal->source = src;
-  GNUNET_CONTAINER_DLL_insert (h->lal_head,
-                               h->lal_tail,
-                               lal);
+  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);
+                   "nat",
+                   "Adding address `%s' from source %d\n",
+                   GNUNET_a2s (arg, arg_size), src);
 #endif
   if (NULL != h->address_callback)
-    h->address_callback (h->callback_cls,
-                         GNUNET_YES,
-                         arg,
-                         arg_size);
+    h->address_callback (h->callback_cls, GNUNET_YES, arg, arg_size);
 }
 
 
@@ -451,9 +439,8 @@ add_to_address_list_as_is (struct GNUNET_NAT_Handle *h,
  */
 static void
 add_to_address_list (struct GNUNET_NAT_Handle *h,
-                     enum LocalAddressSource src,
-                     const struct sockaddr *arg,
-                     socklen_t arg_size)
+                     enum LocalAddressSource src,
+                     const struct sockaddr *arg, socklen_t arg_size)
 {
   struct sockaddr_in s4;
   const struct sockaddr_in *in4;
@@ -461,41 +448,41 @@ add_to_address_list (struct GNUNET_NAT_Handle *h,
   const struct sockaddr_in6 *in6;
 
   if (arg_size == sizeof (struct sockaddr_in))
+  {
+    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,
+                               sizeof (struct sockaddr_in));
+    if (GNUNET_YES == h->enable_nat_server)
     {
-      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,
-                                 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,
-                                     sizeof (struct sockaddr_in));        
-        }
+      /* 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,
+                                 sizeof (struct sockaddr_in));
     }
+  }
   else if (arg_size == sizeof (struct sockaddr_in6))
+  {
+    if (GNUNET_YES != h->disable_ipv6)
     {
-      if (GNUNET_YES != h->disable_ipv6)
-        {
-          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,
-                                     sizeof (struct sockaddr_in6));
-        }
+      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,
+                                 sizeof (struct sockaddr_in6));
     }
+  }
   else
-    {
-      GNUNET_assert (0);
-    }
+  {
+    GNUNET_assert (0);
+  }
 }
 
 
@@ -510,9 +497,8 @@ add_to_address_list (struct GNUNET_NAT_Handle *h,
  */
 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;
@@ -520,52 +506,52 @@ add_ip_to_address_list (struct GNUNET_NAT_Handle *h,
   const struct in6_addr *in6;
 
   if (addrlen == sizeof (struct in_addr))
-    {
-      in4 = (const struct in_addr *) addr;
-      memset (&s4, 0, sizeof (s4));
-      s4.sin_family = AF_INET;
-      s4.sin_port = 0;
+  {
+    in4 = (const struct in_addr *) addr;
+    memset (&s4, 0, sizeof (s4));
+    s4.sin_family = AF_INET;
+    s4.sin_port = 0;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-      s4.sin_len = (u_char) sizeof (struct sockaddr_in);
+    s4.sin_len = (u_char) sizeof (struct sockaddr_in);
 #endif
-      s4.sin_addr = *in4;
-      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,
-                               sizeof (struct sockaddr_in));
-
-        }
+    s4.sin_addr = *in4;
+    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,
+                           sizeof (struct sockaddr_in));
+
     }
+  }
   else if (addrlen == sizeof (struct in6_addr))
+  {
+    if (GNUNET_YES != h->disable_ipv6)
     {
-      if (GNUNET_YES != h->disable_ipv6)
-        {
-          in6 = (const struct in6_addr *) addr;
-          memset (&s6, 0, sizeof (s6));
-          s6.sin6_family = AF_INET6;
-          s6.sin6_port = htons(h->adv_port);
+      in6 = (const struct in6_addr *) addr;
+      memset (&s6, 0, sizeof (s6));
+      s6.sin6_family = AF_INET6;
+      s6.sin6_port = htons (h->adv_port);
 #if HAVE_SOCKADDR_IN_SIN_LEN
-          s6.sin6_len = (u_char) sizeof (struct sockaddr_in6);
+      s6.sin6_len = (u_char) sizeof (struct sockaddr_in6);
 #endif
-          s6.sin6_addr = *in6;
-          add_to_address_list (h, 
-                               src,
-                               (const struct sockaddr*) &s6,
-                               sizeof (struct sockaddr_in6));
-        }
+      s6.sin6_addr = *in6;
+      add_to_address_list (h,
+                           src,
+                           (const struct sockaddr *) &s6,
+                           sizeof (struct sockaddr_in6));
     }
+  }
   else
-    {
-      GNUNET_assert (0);
-    }
+  {
+    GNUNET_assert (0);
+  }
 }
 
 
@@ -577,8 +563,7 @@ add_ip_to_address_list (struct GNUNET_NAT_Handle *h,
  * @param tc scheduler context
  */
 static void
-resolve_dns (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc);
+resolve_dns (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -590,24 +575,20 @@ resolve_dns (void *cls,
  * @param addrlen number of bytes in addr
  */
 static void
-process_external_ip (void *cls,
-                     const struct sockaddr *addr,
-                     socklen_t addrlen)
+process_external_ip (void *cls, const struct sockaddr *addr, socklen_t addrlen)
 {
   struct GNUNET_NAT_Handle *h = cls;
   struct in_addr dummy;
 
   if (addr == NULL)
-    {    
-      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);
-      return;
-    }
+  {
+    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);
+    return;
+  }
   add_to_address_list (h, LAL_EXTERNAL_IP, addr, addrlen);
 }
 
@@ -619,8 +600,7 @@ process_external_ip (void *cls,
  * @param tc scheduler context
  */
 static void
-resolve_hostname (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc);
+resolve_hostname (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -633,18 +613,17 @@ resolve_hostname (void *cls,
  * @param addrlen length of the address
  */
 static void
-process_hostname_ip (void *cls,
-                      const struct sockaddr *addr, socklen_t addrlen)
+process_hostname_ip (void *cls, const struct sockaddr *addr, socklen_t addrlen)
 {
   struct GNUNET_NAT_Handle *h = cls;
- 
+
   if (addr == NULL)
-    {
-      h->hostname_dns = NULL;
-      h->hostname_task = GNUNET_SCHEDULER_add_delayed (h->hostname_dns_frequency,
-                                                       &resolve_hostname, h);
-      return;
-    }
+  {
+    h->hostname_dns = NULL;
+    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);
 }
 
@@ -673,48 +652,44 @@ process_interfaces (void *cls,
   char buf[INET6_ADDRSTRLEN];
 
   switch (addr->sa_family)
+  {
+  case AF_INET:
+    s4 = (struct sockaddr_in *) addr;
+    ip = &s4->sin_addr;
+    if (GNUNET_YES == h->use_localaddresses)
+      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;
+    if (IN6_IS_ADDR_LINKLOCAL (&((struct sockaddr_in6 *) addr)->sin6_addr))
     {
-    case AF_INET:
-      s4 = (struct sockaddr_in *) addr;
-      ip = &s4->sin_addr;
-      if (GNUNET_YES == h->use_localaddresses)
-        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;
-      if (IN6_IS_ADDR_LINKLOCAL (&((struct sockaddr_in6 *) addr)->sin6_addr))
-        {
-          /* skip link local addresses */
-          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));
-      break;
-    default:
-      GNUNET_break (0);
+      /* skip link local addresses */
       return GNUNET_OK;
     }
-  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) ) )
-    {
-      /* 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)));
-      start_gnunet_nat_server (h);
-    }
+    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));
+    break;
+  default:
+    GNUNET_break (0);
+    return GNUNET_OK;
+  }
+  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)))
+  {
+    /* 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)));
+    start_gnunet_nat_server (h);
+  }
   return GNUNET_OK;
 }
 
@@ -725,16 +700,15 @@ process_interfaces (void *cls,
  *
  * @param cls the 'struct GNUNET_NAT_Handle'
  * @param tc scheduler context
- */ 
+ */
 static void
-restart_nat_server (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_nat_server (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_NAT_Handle *h = cls;
 
   h->server_read_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-    return;  
+  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+    return;
   start_gnunet_nat_server (h);
 }
 
@@ -748,8 +722,7 @@ restart_nat_server (void *cls,
  * @param tc the scheduling context
  */
 static void
-nat_server_read (void *cls, 
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+nat_server_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_NAT_Handle *h = cls;
   char mybuf[40];
@@ -760,52 +733,53 @@ nat_server_read (void *cls,
   struct sockaddr_in sin_addr;
 
   h->server_read_task = GNUNET_SCHEDULER_NO_TASK;
-  if ( (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
+  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));
+  memset (mybuf, 0, 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);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "nat",
+                     "Finished reading from server stdout with code: %d\n",
+                     bytes);
 #endif
-      if (0 != GNUNET_OS_process_kill (h->server_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      GNUNET_OS_process_wait (h->server_proc);
-      GNUNET_OS_process_close (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_read_task = GNUNET_SCHEDULER_add_delayed (h->server_retry_delay,
-                                                          &restart_nat_server,
-                                                          h);
-      return;
-    }
+    if (0 != GNUNET_OS_process_kill (h->server_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    GNUNET_OS_process_wait (h->server_proc);
+    GNUNET_OS_process_close (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_read_task =
+        GNUNET_SCHEDULER_add_delayed (h->server_retry_delay,
+                                      &restart_nat_server, h);
+    return;
+  }
 
   port_start = NULL;
-  for (i = 0; i < sizeof(mybuf); i++)
+  for (i = 0; i < sizeof (mybuf); i++)
+  {
+    if (mybuf[i] == '\n')
+    {
+      mybuf[i] = '\0';
+      break;
+    }
+    if ((mybuf[i] == ':') && (i + 1 < sizeof (mybuf)))
     {
-      if (mybuf[i] == '\n')
-        {
-          mybuf[i] = '\0';
-          break;
-        }
-      if ( (mybuf[i] == ':') && (i + 1 < sizeof(mybuf)) )
-        {
-          mybuf[i] = '\0';
-          port_start = &mybuf[i + 1];
-        }
+      mybuf[i] = '\0';
+      port_start = &mybuf[i + 1];
     }
+  }
 
   /* construct socket address of sender */
   memset (&sin_addr, 0, sizeof (sin_addr));
@@ -813,37 +787,34 @@ nat_server_read (void *cls,
 #if HAVE_SOCKADDR_IN_SIN_LEN
   sin_addr.sin_len = sizeof (sin_addr);
 #endif
-  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);
-      h->server_read_task 
-        = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
-                                          h->server_stdout_handle,
-                                          &nat_server_read, 
-                                          h);
-      return;
-    }
-  sin_addr.sin_port = htons((uint16_t) 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);
+    h->server_read_task =
+        GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                        h->server_stdout_handle,
+                                        &nat_server_read, h);
+    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);
+                   "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));
+                        (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);
+      GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                      h->server_stdout_handle,
+                                      &nat_server_read, h);
 }
 
 
@@ -856,51 +827,45 @@ nat_server_read (void *cls,
 static void
 start_gnunet_nat_server (struct GNUNET_NAT_Handle *h)
 {
-  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))) )
-    {
+  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))))
+  {
 #if DEBUG_NAT
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "nat"
-                       "Starting %s at `%s'\n",
-                       "gnunet-helper-nat-server", 
-                       h->internal_address);
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "nat"
+                     "Starting %s at `%s'\n",
+                     "gnunet-helper-nat-server", h->internal_address);
 #endif
-      /* 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);
-      if (h->server_proc == NULL)
-        {
-          GNUNET_log_from (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;
-        }
-      else
-        {
-          /* 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);
-        }
-    }  
+    /* 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);
+    if (h->server_proc == NULL)
+    {
+      GNUNET_log_from (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;
+    }
+    else
+    {
+      /* 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);
+    }
+  }
 }
 
 
@@ -911,16 +876,15 @@ start_gnunet_nat_server (struct GNUNET_NAT_Handle *h)
  * @param tc scheduler context
  */
 static void
-list_interfaces (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+list_interfaces (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_NAT_Handle *h = cls;
 
   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); 
+  GNUNET_OS_network_interfaces_list (&process_interfaces, h);
   h->ifc_task = GNUNET_SCHEDULER_add_delayed (h->ifc_scan_frequency,
-                                              &list_interfaces, h);
+                                              &list_interfaces, h);
 }
 
 
@@ -931,17 +895,15 @@ list_interfaces (void *cls,
  * @param tc scheduler context
  */
 static void
-resolve_hostname (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+resolve_hostname (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_NAT_Handle *h = cls;
- 
+
   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);
+                                                      HOSTNAME_RESOLVE_TIMEOUT,
+                                                      &process_hostname_ip, h);
 }
 
 
@@ -953,18 +915,16 @@ resolve_hostname (void *cls,
  * @param tc scheduler context
  */
 static void
-resolve_dns (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+resolve_dns (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_NAT_Handle *h = cls;
- 
+
   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);
+                                       AF_INET,
+                                       GNUNET_TIME_UNIT_MINUTES,
+                                       &process_external_ip, h);
 }
 
 
@@ -977,45 +937,35 @@ resolve_dns (void *cls,
  * @param addr either the previous or the new public IP address
  * @param addrlen actual lenght of the address
  */
-static void 
-upnp_add (void *cls, 
-          int add_remove,
-          const struct sockaddr *addr,
-          socklen_t addrlen)
+static void
+upnp_add (void *cls,
+          int add_remove, const struct sockaddr *addr, socklen_t addrlen)
 {
   struct GNUNET_NAT_Handle *h = cls;
   struct LocalAddressList *pos;
   struct LocalAddressList *next;
 
   if (GNUNET_YES == add_remove)
-    {
-      add_to_address_list (h, 
-                           LAL_UPNP,
-                           addr, addrlen);
-      return;
-    }
+  {
+    add_to_address_list (h, LAL_UPNP, addr, addrlen);
+    return;
+  }
   /* remove address */
   next = h->lal_head;
   while (NULL != (pos = next))
-    {
-      next = pos->next;
-      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,
-                             (const struct sockaddr* ) &pos[1],
-                             pos->addrlen);
-      GNUNET_free (pos);
-      return; /* only remove once */
-    } 
+  {
+    next = pos->next;
+    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,
+                           (const struct sockaddr *) &pos[1], pos->addrlen);
+    GNUNET_free (pos);
+    return;                     /* only remove once */
+  }
   /* asked to remove address that does not exist */
   GNUNET_break (0);
 }
@@ -1028,26 +978,21 @@ upnp_add (void *cls,
  * @param port port to map with UPnP
  */
 static void
-add_minis (struct GNUNET_NAT_Handle *h,
-           uint16_t port)
+add_minis (struct GNUNET_NAT_Handle *h, uint16_t port)
 {
   struct MiniList *ml;
 
   ml = h->mini_head;
   while (NULL != ml)
-    {
-      if (port == ml->port)
-        return; /* already got this port */
-      ml = ml->next;
-    }
+  {
+    if (port == ml->port)
+      return;                   /* already got this port */
+    ml = ml->next;
+  }
   ml = GNUNET_malloc (sizeof (struct MiniList));
   ml->port = port;
-  ml->mini = GNUNET_NAT_mini_map_start (port,
-                                        h->is_tcp,
-                                        &upnp_add, h);
-  GNUNET_CONTAINER_DLL_insert (h->mini_head,
-                               h->mini_tail,
-                               ml);                                     
+  ml->mini = GNUNET_NAT_mini_map_start (port, h->is_tcp, &upnp_add, h);
+  GNUNET_CONTAINER_DLL_insert (h->mini_head, h->mini_tail, ml);
 }
 
 
@@ -1058,8 +1003,7 @@ add_minis (struct GNUNET_NAT_Handle *h,
  * @param tc scheduler context
  */
 static void
-add_from_bind (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+add_from_bind (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   static struct in6_addr any = IN6ADDR_ANY_INIT;
   struct GNUNET_NAT_Handle *h = cls;
@@ -1068,38 +1012,39 @@ add_from_bind (void *cls,
   const struct sockaddr_in *v4;
 
   h->bind_task = GNUNET_SCHEDULER_NO_TASK;
-  for (i=0;i<h->num_local_addrs;i++)
+  for (i = 0; i < h->num_local_addrs; i++)
+  {
+    sa = h->local_addrs[i];
+    switch (sa->sa_family)
     {
-      sa = h->local_addrs[i];
-      switch (sa->sa_family)
-        {
-        case AF_INET:
-          if (sizeof (struct sockaddr_in) != h->local_addrlens[i])
-            {
-              GNUNET_break (0);
-              break;
-            }
-          v4 = (const struct sockaddr_in*) sa;
-          if (0 != v4->sin_addr.s_addr)
-            add_to_address_list (h, LAL_BINDTO_ADDRESS, sa, sizeof (struct sockaddr_in));
-          if (h->enable_upnp)
-            add_minis (h, ntohs (v4->sin_port));
-          break;
-        case AF_INET6:
-          if (sizeof (struct sockaddr_in6) != h->local_addrlens[i])
-            {
-              GNUNET_break (0);
-              break;
-            }
-          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;
-        default:
-          break;
-        }       
+    case AF_INET:
+      if (sizeof (struct sockaddr_in) != h->local_addrlens[i])
+      {
+        GNUNET_break (0);
+        break;
+      }
+      v4 = (const struct sockaddr_in *) sa;
+      if (0 != v4->sin_addr.s_addr)
+        add_to_address_list (h, LAL_BINDTO_ADDRESS, sa,
+                             sizeof (struct sockaddr_in));
+      if (h->enable_upnp)
+        add_minis (h, ntohs (v4->sin_port));
+      break;
+    case AF_INET6:
+      if (sizeof (struct sockaddr_in6) != h->local_addrlens[i])
+      {
+        GNUNET_break (0);
+        break;
+      }
+      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;
+    default:
+      break;
     }
+  }
 }
 
 
@@ -1124,14 +1069,14 @@ add_from_bind (void *cls,
  */
 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_AddressCallback address_callback, 
-                     GNUNET_NAT_ReversalCallback reversal_callback,
-                     void *callback_cls)
+                     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)
 {
   struct GNUNET_NAT_Handle *h;
   struct in_addr in_addr;
@@ -1139,10 +1084,9 @@ GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg,
 
 #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);
+                   "nat",
+                   "Registered with NAT service at port %u with %u IP bound local addresses\n",
+                   (unsigned int) adv_port, num_addrs);
 #endif
   h = GNUNET_malloc (sizeof (struct GNUNET_NAT_Handle));
   h->server_retry_delay = GNUNET_TIME_UNIT_SECONDS;
@@ -1154,147 +1098,140 @@ GNUNET_NAT_register (const struct GNUNET_CONFIGURATION_Handle *cfg,
   h->num_local_addrs = num_addrs;
   h->adv_port = adv_port;
   if (num_addrs != 0)
+  {
+    h->local_addrs = GNUNET_malloc (num_addrs * sizeof (struct sockaddr *));
+    h->local_addrlens = GNUNET_malloc (num_addrs * sizeof (socklen_t));
+    for (i = 0; i < num_addrs; i++)
     {
-      h->local_addrs = GNUNET_malloc (num_addrs * sizeof (struct sockaddr*));
-      h->local_addrlens = GNUNET_malloc (num_addrs * sizeof (socklen_t));
-      for (i=0;i<num_addrs;i++)
-        {
-          GNUNET_assert (addrlens[i] > 0);
-          GNUNET_assert (addrs[i] != NULL);
-          h->local_addrlens[i] = addrlens[i];
-          h->local_addrs[i] = GNUNET_malloc (addrlens[i]);
-          memcpy (h->local_addrs[i], addrs[i], addrlens[i]);
-        }
+      GNUNET_assert (addrlens[i] > 0);
+      GNUNET_assert (addrs[i] != NULL);
+      h->local_addrlens[i] = addrlens[i];
+      h->local_addrs[i] = GNUNET_malloc (addrlens[i]);
+      memcpy (h->local_addrs[i], addrs[i], addrlens[i]);
     }
+  }
   h->bind_task = GNUNET_SCHEDULER_add_now (&add_from_bind, h);
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_have_value (cfg,
-                                       "nat",
-                                       "INTERNAL_ADDRESS"))
-    {
-      (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_free (h->internal_address);
-      h->internal_address = NULL;
-    }
+      GNUNET_CONFIGURATION_have_value (cfg, "nat", "INTERNAL_ADDRESS"))
+  {
+    (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_free (h->internal_address);
+    h->internal_address = NULL;
+  }
 
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_have_value (cfg,
-                                       "nat",
-                                       "EXTERNAL_ADDRESS"))
-    {
-      (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;
-    }
+      GNUNET_CONFIGURATION_have_value (cfg, "nat", "EXTERNAL_ADDRESS"))
+  {
+    (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");
+                                                        "nat", "BEHIND_NAT");
   h->nat_punched = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                         "nat",
-                                                         "PUNCHED_NAT");
+                                                         "nat", "PUNCHED_NAT");
   h->enable_nat_client = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                               "nat",
-                                                               "ENABLE_NAT_CLIENT");
+                                                               "nat",
+                                                               "ENABLE_NAT_CLIENT");
   h->enable_nat_server = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                               "nat",
-                                                               "ENABLE_NAT_SERVER");
+                                                               "nat",
+                                                               "ENABLE_NAT_SERVER");
   h->enable_upnp = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                         "nat",
-                                                         "ENABLE_UPNP");
+                                                         "nat", "ENABLE_UPNP");
   h->use_localaddresses = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                                "nat",
-                                                                "USE_LOCALADDR");
+                                                                "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");
+                                                          "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",
-                                           &h->dyndns_frequency))
+                                           "nat",
+                                           "DYNDNS_FREQUENCY",
+                                           &h->dyndns_frequency))
     h->dyndns_frequency = DYNDNS_FREQUENCY;
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_time (cfg,
-                                           "nat",
-                                           "IFC_SCAN_FREQUENCY",
-                                           &h->ifc_scan_frequency))
+                                           "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",
-                                           &h->hostname_dns_frequency))
+                                           "nat",
+                                           "HOSTNAME_DNS_FREQUENCY",
+                                           &h->hostname_dns_frequency))
     h->hostname_dns_frequency = HOSTNAME_DNS_FREQUENCY;
 
   if (NULL == reversal_callback)
     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) )
-    {
-      h->dns_task = GNUNET_SCHEDULER_add_now (&resolve_dns, h);
-      h->enable_nat_server = GNUNET_NO;
-      h->enable_upnp = GNUNET_NO;
-    }
+  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;
+    h->enable_upnp = GNUNET_NO;
+  }
 
   /* Test for SUID binaries */
-  if ( (h->behind_nat == GNUNET_YES) &&
-       (GNUNET_YES == h->enable_nat_server) &&
-       (GNUNET_YES != GNUNET_OS_check_helper_binary("gnunet-helper-nat-server")) )
-    {
-      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");        
-    }
-  if ( (GNUNET_YES == h->enable_nat_client) &&
-       (GNUNET_YES != GNUNET_OS_check_helper_binary("gnunet-helper-nat-client")) )
-    {
-      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");  
-    }
+  if ((h->behind_nat == GNUNET_YES) &&
+      (GNUNET_YES == h->enable_nat_server) &&
+      (GNUNET_YES !=
+       GNUNET_OS_check_helper_binary ("gnunet-helper-nat-server")))
+  {
+    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");
+  }
+  if ((GNUNET_YES == h->enable_nat_client) &&
+      (GNUNET_YES !=
+       GNUNET_OS_check_helper_binary ("gnunet-helper-nat-client")))
+  {
+    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");
+  }
 
   start_gnunet_nat_server (h);
 
   /* FIXME: add support for UPnP, etc */
 
   if (NULL != h->address_callback)
-    {
-      h->ifc_task = GNUNET_SCHEDULER_add_now (&list_interfaces, h);    
-      if (GNUNET_YES == h->use_hostname)
-        h->hostname_task = GNUNET_SCHEDULER_add_now (&resolve_hostname, h);
-    }
+  {
+    h->ifc_task = GNUNET_SCHEDULER_add_now (&list_interfaces, h);
+    if (GNUNET_YES == h->use_hostname)
+      h->hostname_task = GNUNET_SCHEDULER_add_now (&resolve_hostname, h);
+  }
 
   return h;
 }
@@ -1314,84 +1251,79 @@ GNUNET_NAT_unregister (struct GNUNET_NAT_Handle *h)
   struct MiniList *ml;
 
   while (NULL != (ml = h->mini_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (h->mini_head,
-                                   h->mini_tail,
-                                   ml);
-      if (NULL != ml->mini)
-        GNUNET_NAT_mini_map_stop (ml->mini);
-      GNUNET_free (ml);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (h->mini_head, h->mini_tail, ml);
+    if (NULL != ml->mini)
+      GNUNET_NAT_mini_map_stop (ml->mini);
+    GNUNET_free (ml);
+  }
   if (h->ext_dns != NULL)
-    {
-      GNUNET_RESOLVER_request_cancel (h->ext_dns);
-      h->ext_dns = NULL;
-    }
+  {
+    GNUNET_RESOLVER_request_cancel (h->ext_dns);
+    h->ext_dns = NULL;
+  }
   if (NULL != h->hostname_dns)
-    {
-      GNUNET_RESOLVER_request_cancel (h->hostname_dns);
-      h->hostname_dns = NULL;
-    }
+  {
+    GNUNET_RESOLVER_request_cancel (h->hostname_dns);
+    h->hostname_dns = NULL;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != h->server_read_task)
-    {
-      GNUNET_SCHEDULER_cancel (h->server_read_task);
-      h->server_read_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (h->server_read_task);
+    h->server_read_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != h->bind_task)
-    {
-      GNUNET_SCHEDULER_cancel (h->bind_task);
-      h->bind_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (h->bind_task);
+    h->bind_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != h->ifc_task)
-    {
-      GNUNET_SCHEDULER_cancel (h->ifc_task);
-      h->ifc_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (h->ifc_task);
+    h->ifc_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != h->hostname_task)
-    {
-      GNUNET_SCHEDULER_cancel (h->hostname_task);
-      h->hostname_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (h->hostname_task);
+    h->hostname_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != h->dns_task)
-    {
-      GNUNET_SCHEDULER_cancel (h->dns_task);
-      h->dns_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (h->dns_task);
+    h->dns_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL != h->server_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (h->server_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      GNUNET_OS_process_wait (h->server_proc);
-      GNUNET_OS_process_close (h->server_proc);
-      h->server_proc = NULL;
-      GNUNET_DISK_pipe_close (h->server_stdout);
-      h->server_stdout = NULL;
-      h->server_stdout_handle = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (h->server_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    GNUNET_OS_process_wait (h->server_proc);
+    GNUNET_OS_process_close (h->server_proc);
+    h->server_proc = NULL;
+    GNUNET_DISK_pipe_close (h->server_stdout);
+    h->server_stdout = NULL;
+    h->server_stdout_handle = NULL;
+  }
   if (NULL != h->server_stdout)
-    {
-      GNUNET_DISK_pipe_close (h->server_stdout);
-      h->server_stdout = NULL;
-      h->server_stdout_handle = NULL;
-    }
+  {
+    GNUNET_DISK_pipe_close (h->server_stdout);
+    h->server_stdout = NULL;
+    h->server_stdout_handle = NULL;
+  }
   while (NULL != (lal = h->lal_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (h->lal_head,
-                                   h->lal_tail,
-                                   lal);
-      if (NULL != h->address_callback)
-        h->address_callback (h->callback_cls,
-                             GNUNET_NO,
-                             (const struct sockaddr*) &lal[1],
-                             lal->addrlen);
-      GNUNET_free (lal);
-    }
-  for (i=0;i<h->num_local_addrs;i++)   
+  {
+    GNUNET_CONTAINER_DLL_remove (h->lal_head, h->lal_tail, lal);
+    if (NULL != h->address_callback)
+      h->address_callback (h->callback_cls,
+                           GNUNET_NO,
+                           (const struct sockaddr *) &lal[1], lal->addrlen);
+    GNUNET_free (lal);
+  }
+  for (i = 0; i < h->num_local_addrs; i++)
     GNUNET_free (h->local_addrs[i]);
   GNUNET_free_non_null (h->local_addrs);
   GNUNET_free_non_null (h->local_addrlens);
   GNUNET_free_non_null (h->external_address);
-  GNUNET_free_non_null (h->internal_address);  
+  GNUNET_free_non_null (h->internal_address);
   GNUNET_free (h);
 }
 
@@ -1406,54 +1338,46 @@ GNUNET_NAT_unregister (struct GNUNET_NAT_Handle *h)
  */
 void
 GNUNET_NAT_run_client (struct GNUNET_NAT_Handle *h,
-                       const struct sockaddr_in *sa)
+                       const struct sockaddr_in *sa)
 {
   char inet4[INET_ADDRSTRLEN];
   char port_as_string[6];
   struct GNUNET_OS_Process *proc;
 
-  if (GNUNET_YES != h->enable_nat_client) 
-    return; /* not permitted / possible */
+  if (GNUNET_YES != h->enable_nat_client)
+    return;                     /* 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;
-    }
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING,
+                     "nat",
+                     _
+                     ("Internal IP address not known, cannot use ICMP NAT traversal method\n"));
+    return;
+  }
   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_snprintf (port_as_string, 
-                   sizeof (port_as_string),
-                   "%d", 
-                   h->adv_port);
+  if (NULL == inet_ntop (AF_INET, &sa->sin_addr, inet4, INET_ADDRSTRLEN))
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
+    return;
+  }
+  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);
+                   "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);
+  proc = GNUNET_OS_start_process (NULL,
+                                  NULL,
+                                  "gnunet-helper-nat-client",
+                                  "gnunet-helper-nat-client",
+                                  h->internal_address,
+                                  inet4, port_as_string, NULL);
   if (NULL == proc)
     return;
   /* we know that the gnunet-helper-nat-client will terminate virtually
-     instantly */
+   * instantly */
   GNUNET_OS_process_wait (proc);
   GNUNET_OS_process_close (proc);
 }
@@ -1471,44 +1395,43 @@ GNUNET_NAT_run_client (struct GNUNET_NAT_Handle *h,
  */
 int
 GNUNET_NAT_test_address (struct GNUNET_NAT_Handle *h,
-                         const void *addr,
-                         socklen_t addrlen)
+                         const void *addr, socklen_t addrlen)
 {
   struct LocalAddressList *pos;
   const struct sockaddr_in *in4;
   const struct sockaddr_in6 *in6;
-  
-  if ( (addrlen != sizeof (struct in_addr)) &&
-       (addrlen != sizeof (struct in6_addr)) )
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
+
+  if ((addrlen != sizeof (struct in_addr)) &&
+      (addrlen != sizeof (struct in6_addr)))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   pos = h->lal_head;
   while (NULL != pos)
+  {
+    if (pos->addrlen == sizeof (struct sockaddr_in))
     {
-      if (pos->addrlen == sizeof (struct sockaddr_in))
-        {
-          in4 = (struct sockaddr_in* ) &pos[1];
-          if ( (addrlen == sizeof (struct in_addr)) &&
-               (0 == memcmp (&in4->sin_addr, addr, sizeof (struct in_addr))) )
-            return GNUNET_YES;
-        }
-      else if (pos->addrlen == sizeof (struct sockaddr_in6))
-        {
-          in6 = (struct sockaddr_in6* ) &pos[1];
-          if ( (addrlen == sizeof (struct in6_addr)) &&
-               (0 == memcmp (&in6->sin6_addr, addr, sizeof (struct in6_addr))) )
-            return GNUNET_YES;
-        }
-      else
-        {
-          GNUNET_assert (0);      
-        }
-      pos = pos->next;
+      in4 = (struct sockaddr_in *) &pos[1];
+      if ((addrlen == sizeof (struct in_addr)) &&
+          (0 == memcmp (&in4->sin_addr, addr, sizeof (struct in_addr))))
+        return GNUNET_YES;
+    }
+    else if (pos->addrlen == sizeof (struct sockaddr_in6))
+    {
+      in6 = (struct sockaddr_in6 *) &pos[1];
+      if ((addrlen == sizeof (struct in6_addr)) &&
+          (0 == memcmp (&in6->sin6_addr, addr, sizeof (struct in6_addr))))
+        return GNUNET_YES;
+    }
+    else
+    {
+      GNUNET_assert (0);
     }
+    pos = pos->next;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              "Asked to validate one of my addresses and validation failed!\n");
+              "Asked to validate one of my addresses and validation failed!\n");
   return GNUNET_NO;
 }
 
diff --git a/src/nat/nat.h b/src/nat/nat.h
index bff444e6d..bb13e5274 100644
--- a/src/nat/nat.h
+++ b/src/nat/nat.h
@@ -35,17 +35,17 @@ struct GNUNET_NAT_TestMessage
 {
   /**
    * Header with type "GNUNET_MESSAGE_TYPE_NAT_TEST"
-   */ 
+   */
   struct GNUNET_MessageHeader header;
 
   /**
    * IPv4 target IP address
-   */ 
+   */
   uint32_t dst_ipv4;
 
   /**
    * Port to use, 0 to send dummy ICMP response.
-   */ 
+   */
   uint16_t dport;
 
   /**
diff --git a/src/nat/nat_mini.c b/src/nat/nat_mini.c
index 058e8dda2..c40231067 100644
--- a/src/nat/nat_mini.c
+++ b/src/nat/nat_mini.c
@@ -109,8 +109,7 @@ struct GNUNET_NAT_ExternalHandle
  * @param tc scheduler context
  */
 static void
-read_external_ipv4 (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+read_external_ipv4 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_NAT_ExternalHandle *eh = cls;
   ssize_t ret;
@@ -118,39 +117,34 @@ read_external_ipv4 (void *cls,
   int iret;
 
   eh->task = GNUNET_SCHEDULER_NO_TASK;
-  if (GNUNET_YES ==
-      GNUNET_NETWORK_fdset_handle_isset (tc->read_ready,
-                                         eh->r))
+  if (GNUNET_YES == GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, eh->r))
     ret = GNUNET_DISK_file_read (eh->r,
-                                 &eh->buf[eh->off], 
-                                 sizeof (eh->buf)-eh->off);
+                                 &eh->buf[eh->off], sizeof (eh->buf) - eh->off);
   else
-    ret = -1; /* error reading, timeout, etc. */
+    ret = -1;                   /* error reading, timeout, etc. */
   if (ret > 0)
-    {
-      /* try to read more */
-      eh->off += ret;
-      eh->task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_absolute_get_remaining (eh->timeout),
-                                                 eh->r,
-                                                 &read_external_ipv4,
-                                                 eh);
-      return;
-    }
+  {
+    /* try to read more */
+    eh->off += ret;
+    eh->task =
+        GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_absolute_get_remaining
+                                        (eh->timeout), eh->r,
+                                        &read_external_ipv4, eh);
+    return;
+  }
   iret = GNUNET_NO;
-  if ( (eh->off > 7) &&    
-       (eh->buf[eh->off-1] == '\n') )    
+  if ((eh->off > 7) && (eh->buf[eh->off - 1] == '\n'))
+  {
+    eh->buf[eh->off - 1] = '\0';
+    if (1 == inet_pton (AF_INET, eh->buf, &addr))
     {
-      eh->buf[eh->off-1] = '\0';
-      if (1 == inet_pton (AF_INET, eh->buf, &addr))
-        {
-          if (addr.s_addr == 0)
-            iret = GNUNET_NO; /* got 0.0.0.0 */
-          else
-            iret = GNUNET_OK;
-        }
+      if (addr.s_addr == 0)
+        iret = GNUNET_NO;       /* got 0.0.0.0 */
+      else
+        iret = GNUNET_OK;
     }
-  eh->cb (eh->cb_cls,
-          (iret == GNUNET_OK) ? &addr : NULL);
+  }
+  eh->cb (eh->cb_cls, (iret == GNUNET_OK) ? &addr : NULL);
   GNUNET_NAT_mini_get_external_ipv4_cancel (eh);
 }
 
@@ -165,40 +159,33 @@ read_external_ipv4 (void *cls,
  */
 struct GNUNET_NAT_ExternalHandle *
 GNUNET_NAT_mini_get_external_ipv4 (struct GNUNET_TIME_Relative timeout,
-                                   GNUNET_NAT_IPCallback cb,
-                                   void *cb_cls)
+                                   GNUNET_NAT_IPCallback cb, void *cb_cls)
 {
   struct GNUNET_NAT_ExternalHandle *eh;
 
   eh = GNUNET_malloc (sizeof (struct GNUNET_NAT_ExternalHandle));
   eh->cb = cb;
   eh->cb_cls = cb_cls;
-  eh->opipe = GNUNET_DISK_pipe (GNUNET_YES,
-                                GNUNET_NO,
-                                GNUNET_YES);
+  eh->opipe = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_NO, GNUNET_YES);
   if (NULL == eh->opipe)
-    {
-      GNUNET_free (eh);
-      return NULL;
-    }
+  {
+    GNUNET_free (eh);
+    return NULL;
+  }
   eh->eip = GNUNET_OS_start_process (NULL,
-                                     eh->opipe,
-                                     "external-ip",
-                                     "external-ip", NULL);
+                                     eh->opipe,
+                                     "external-ip", "external-ip", NULL);
   if (NULL == eh->eip)
-    {
-      GNUNET_DISK_pipe_close (eh->opipe);
-      GNUNET_free (eh);
-      return NULL;
-    }
+  {
+    GNUNET_DISK_pipe_close (eh->opipe);
+    GNUNET_free (eh);
+    return NULL;
+  }
   GNUNET_DISK_pipe_close_end (eh->opipe, GNUNET_DISK_PIPE_END_WRITE);
   eh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
-  eh->r = GNUNET_DISK_pipe_handle (eh->opipe,
-                                   GNUNET_DISK_PIPE_END_READ);
+  eh->r = GNUNET_DISK_pipe_handle (eh->opipe, GNUNET_DISK_PIPE_END_READ);
   eh->task = GNUNET_SCHEDULER_add_read_file (timeout,
-                                             eh->r,
-                                             &read_external_ipv4,
-                                             eh);
+                                             eh->r, &read_external_ipv4, eh);
   return eh;
 }
 
@@ -222,7 +209,7 @@ GNUNET_NAT_mini_get_external_ipv4_cancel (struct GNUNET_NAT_ExternalHandle *eh)
 
 /**
  * Handle to a mapping created with upnpc.
- */ 
+ */
 struct GNUNET_NAT_MiniHandle
 {
 
@@ -274,7 +261,7 @@ struct GNUNET_NAT_MiniHandle
 
   /**
    * Did we find our mapping during refresh scan?
-   */ 
+   */
   int found;
 
   /**
@@ -292,8 +279,7 @@ struct GNUNET_NAT_MiniHandle
  * @param tc scheduler context
  */
 static void
-do_refresh (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc);
+do_refresh (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -302,9 +288,7 @@ do_refresh (void *cls,
  * @param cls the 'struct GNUNET_NAT_MiniHandle'
  * @param line line of output, NULL at the end
  */
-static void
-process_map_output (void *cls,
-                    const char *line);
+static void process_map_output (void *cls, const char *line);
 
 
 /**
@@ -315,8 +299,7 @@ process_map_output (void *cls,
  * @param line line of output, NULL at the end
  */
 static void
-process_refresh_output (void *cls,
-                        const char *line)
+process_refresh_output (void *cls, const char *line)
 {
   struct GNUNET_NAT_MiniHandle *mini = cls;
   char pstr[9];
@@ -325,99 +308,92 @@ process_refresh_output (void *cls,
   struct in_addr exip;
 
   if (NULL == line)
+  {
+    GNUNET_OS_command_stop (mini->refresh_cmd);
+    mini->refresh_cmd = NULL;
+    if (mini->found == GNUNET_NO)
     {
-      GNUNET_OS_command_stop (mini->refresh_cmd);
-      mini->refresh_cmd = NULL;
-      if (mini->found == GNUNET_NO)
-        {
-          /* mapping disappeared, try to re-create */
-          if (mini->did_map)
-            {
-              mini->ac (mini->ac_cls, GNUNET_NO,
-                        (const struct sockaddr*) &mini->current_addr,
-                        sizeof (mini->current_addr));
-              mini->did_map = GNUNET_NO;
-            }
-          GNUNET_snprintf (pstr, sizeof (pstr),
-                           "%u",
-                           (unsigned int) mini->port);
-          mini->map_cmd = GNUNET_OS_command_run (&process_map_output,
-                                                 mini,
-                                                 MAP_TIMEOUT,
-                                                 "upnpc",
-                                                 "upnpc",
-                                                 "-r", pstr, 
-                                                 mini->is_tcp ? "tcp" : "udp",
-                                                 NULL);
-          if (NULL != mini->map_cmd)
-            return;
-        }
-      mini->refresh_task = GNUNET_SCHEDULER_add_delayed (MAP_REFRESH_FREQ,
-                                                         &do_refresh,
-                                                         mini);
-      return;
+      /* mapping disappeared, try to re-create */
+      if (mini->did_map)
+      {
+        mini->ac (mini->ac_cls, GNUNET_NO,
+                  (const struct sockaddr *) &mini->current_addr,
+                  sizeof (mini->current_addr));
+        mini->did_map = GNUNET_NO;
+      }
+      GNUNET_snprintf (pstr, sizeof (pstr), "%u", (unsigned int) mini->port);
+      mini->map_cmd = GNUNET_OS_command_run (&process_map_output,
+                                             mini,
+                                             MAP_TIMEOUT,
+                                             "upnpc",
+                                             "upnpc",
+                                             "-r", pstr,
+                                             mini->is_tcp ? "tcp" : "udp",
+                                             NULL);
+      if (NULL != mini->map_cmd)
+        return;
     }
-  if (! mini->did_map)
-    return; /* never mapped, won't find our mapping anyway */
+    mini->refresh_task = GNUNET_SCHEDULER_add_delayed (MAP_REFRESH_FREQ,
+                                                       &do_refresh, mini);
+    return;
+  }
+  if (!mini->did_map)
+    return;                     /* never mapped, won't find our mapping anyway */
 
   /* we're looking for output of the form:
-     "ExternalIPAddress = 12.134.41.124" */
+   * "ExternalIPAddress = 12.134.41.124" */
 
   s = strstr (line, "ExternalIPAddress = ");
   if (NULL != s)
-    {
-      s += strlen ("ExternalIPAddress = ");
-      if (1 != inet_pton (AF_INET,
-                          s, &exip))
-        return; /* skip */
-      if (exip.s_addr == mini->current_addr.sin_addr.s_addr)
-        return; /* no change */
-      /* update mapping */
-      mini->ac (mini->ac_cls, GNUNET_NO,
-                (const struct sockaddr*) &mini->current_addr,
-                sizeof (mini->current_addr));
-      mini->current_addr.sin_addr = exip;
-      mini->ac (mini->ac_cls, GNUNET_YES,
-                (const struct sockaddr*) &mini->current_addr,
-                sizeof (mini->current_addr));     
-      return;
-    }
+  {
+    s += strlen ("ExternalIPAddress = ");
+    if (1 != inet_pton (AF_INET, s, &exip))
+      return;                   /* skip */
+    if (exip.s_addr == mini->current_addr.sin_addr.s_addr)
+      return;                   /* no change */
+    /* update mapping */
+    mini->ac (mini->ac_cls, GNUNET_NO,
+              (const struct sockaddr *) &mini->current_addr,
+              sizeof (mini->current_addr));
+    mini->current_addr.sin_addr = exip;
+    mini->ac (mini->ac_cls, GNUNET_YES,
+              (const struct sockaddr *) &mini->current_addr,
+              sizeof (mini->current_addr));
+    return;
+  }
   /*
-    we're looking for output of the form:
-     
-     "0 TCP  3000->192.168.2.150:3000  'libminiupnpc' ''"
-     "1 UDP  3001->192.168.2.150:3001  'libminiupnpc' ''"
-
-    the pattern we look for is:
-
-     "%s TCP  PORT->STRING:OURPORT *" or
-     "%s UDP  PORT->STRING:OURPORT *"
-  */
-  GNUNET_snprintf (pstr, sizeof (pstr),
-                   ":%u ",
-                   mini->port);
+   * we're looking for output of the form:
+   * 
+   * "0 TCP  3000->192.168.2.150:3000  'libminiupnpc' ''"
+   * "1 UDP  3001->192.168.2.150:3001  'libminiupnpc' ''"
+   * 
+   * the pattern we look for is:
+   * 
+   * "%s TCP  PORT->STRING:OURPORT *" or
+   * "%s UDP  PORT->STRING:OURPORT *"
+   */
+  GNUNET_snprintf (pstr, sizeof (pstr), ":%u ", mini->port);
   if (NULL == (s = strstr (line, "->")))
-    return; /* skip */
+    return;                     /* skip */
   if (NULL == strstr (s, pstr))
-    return; /* skip */
+    return;                     /* skip */
   if (1 != sscanf (line,
-                   (mini->is_tcp) 
-                   ? "%*u TCP  %u->%*s:%*u %*s" 
-                   : "%*u UDP  %u->%*s:%*u %*s",
-                   &nport))
-    return; /* skip */
+                   (mini->is_tcp)
+                   ? "%*u TCP  %u->%*s:%*u %*s"
+                   : "%*u UDP  %u->%*s:%*u %*s", &nport))
+    return;                     /* skip */
   mini->found = GNUNET_YES;
   if (nport == ntohs (mini->current_addr.sin_port))
-    return; /* no change */    
+    return;                     /* no change */
 
   /* external port changed, update mapping */
   mini->ac (mini->ac_cls, GNUNET_NO,
-            (const struct sockaddr*) &mini->current_addr,
-            sizeof (mini->current_addr));
+            (const struct sockaddr *) &mini->current_addr,
+            sizeof (mini->current_addr));
   mini->current_addr.sin_port = htons ((uint16_t) nport);
   mini->ac (mini->ac_cls, GNUNET_YES,
-            (const struct sockaddr*) &mini->current_addr,
-            sizeof (mini->current_addr));     
+            (const struct sockaddr *) &mini->current_addr,
+            sizeof (mini->current_addr));
 }
 
 
@@ -428,20 +404,16 @@ process_refresh_output (void *cls,
  * @param tc scheduler context
  */
 static void
-do_refresh (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_refresh (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_NAT_MiniHandle *mini = cls;
 
   mini->refresh_task = GNUNET_SCHEDULER_NO_TASK;
   mini->found = GNUNET_NO;
   mini->refresh_cmd = GNUNET_OS_command_run (&process_refresh_output,
-                                             mini,
-                                             MAP_TIMEOUT,
-                                             "upnpc",
-                                             "upnpc",
-                                             "-l",
-                                             NULL);
+                                             mini,
+                                             MAP_TIMEOUT,
+                                             "upnpc", "upnpc", "-l", NULL);
 }
 
 
@@ -452,8 +424,7 @@ do_refresh (void *cls,
  * @param line line of output, NULL at the end
  */
 static void
-process_map_output (void *cls,
-                    const char *line)
+process_map_output (void *cls, const char *line)
 {
   struct GNUNET_NAT_MiniHandle *mini = cls;
   const char *ipaddr;
@@ -462,35 +433,32 @@ process_map_output (void *cls,
   unsigned int port;
 
   if (NULL == line)
-    {
-      GNUNET_OS_command_stop (mini->map_cmd);
-      mini->map_cmd = NULL;
-      mini->refresh_task = GNUNET_SCHEDULER_add_delayed (MAP_REFRESH_FREQ,
-                                                         &do_refresh,
-                                                         mini);
-      return;
-    }
+  {
+    GNUNET_OS_command_stop (mini->map_cmd);
+    mini->map_cmd = NULL;
+    mini->refresh_task = GNUNET_SCHEDULER_add_delayed (MAP_REFRESH_FREQ,
+                                                       &do_refresh, mini);
+    return;
+  }
   /*
-    The upnpc output we're after looks like this:
-
-     "external 87.123.42.204:3000 TCP is redirected to internal 192.168.2.150:3000"
-  */
-  if ( (NULL == (ipaddr = strstr (line, " "))) ||
-       (NULL == (pstr = strstr (ipaddr, ":"))) ||
-       (1 != sscanf (pstr + 1, "%u", &port)) )
-    {
-      return; /* skip line */
-    }
+   * The upnpc output we're after looks like this:
+   * 
+   * "external 87.123.42.204:3000 TCP is redirected to internal 192.168.2.150:3000"
+   */
+  if ((NULL == (ipaddr = strstr (line, " "))) ||
+      (NULL == (pstr = strstr (ipaddr, ":"))) ||
+      (1 != sscanf (pstr + 1, "%u", &port)))
+  {
+    return;                     /* skip line */
+  }
   ipa = GNUNET_strdup (ipaddr + 1);
   strstr (ipa, ":")[0] = '\0';
-  if (1 != inet_pton (AF_INET,
-                      ipa, 
-                      &mini->current_addr.sin_addr))
-    {
-      GNUNET_free (ipa);
-      return; /* skip line */
-    }
-  GNUNET_free (ipa);          
+  if (1 != inet_pton (AF_INET, ipa, &mini->current_addr.sin_addr))
+  {
+    GNUNET_free (ipa);
+    return;                     /* skip line */
+  }
+  GNUNET_free (ipa);
 
   mini->current_addr.sin_port = htons (port);
   mini->current_addr.sin_family = AF_INET;
@@ -499,8 +467,8 @@ process_map_output (void *cls,
 #endif
   mini->did_map = GNUNET_YES;
   mini->ac (mini->ac_cls, GNUNET_YES,
-            (const struct sockaddr*) &mini->current_addr,
-            sizeof (mini->current_addr));
+            (const struct sockaddr *) &mini->current_addr,
+            sizeof (mini->current_addr));
 }
 
 
@@ -519,37 +487,31 @@ process_map_output (void *cls,
  */
 struct GNUNET_NAT_MiniHandle *
 GNUNET_NAT_mini_map_start (uint16_t port,
-                           int is_tcp,
-                           GNUNET_NAT_AddressCallback ac,
-                           void *ac_cls)
+                           int is_tcp,
+                           GNUNET_NAT_AddressCallback ac, void *ac_cls)
 {
   struct GNUNET_NAT_MiniHandle *ret;
   char pstr[6];
 
-  if (GNUNET_SYSERR ==
-      GNUNET_OS_check_helper_binary ("upnpc"))
+  if (GNUNET_SYSERR == GNUNET_OS_check_helper_binary ("upnpc"))
     return NULL;
   ret = GNUNET_malloc (sizeof (struct GNUNET_NAT_MiniHandle));
   ret->ac = ac;
   ret->ac_cls = ac_cls;
   ret->is_tcp = is_tcp;
   ret->port = port;
-  GNUNET_snprintf (pstr, sizeof (pstr),
-                   "%u",
-                   (unsigned int) port);
+  GNUNET_snprintf (pstr, sizeof (pstr), "%u", (unsigned int) port);
   ret->map_cmd = GNUNET_OS_command_run (&process_map_output,
-                                        ret,
-                                        MAP_TIMEOUT,
-                                        "upnpc",
-                                        "upnpc",
-                                        "-r", pstr, 
-                                        is_tcp ? "tcp" : "udp",
-                                        NULL);
+                                        ret,
+                                        MAP_TIMEOUT,
+                                        "upnpc",
+                                        "upnpc",
+                                        "-r", pstr,
+                                        is_tcp ? "tcp" : "udp", NULL);
   if (NULL != ret->map_cmd)
     return ret;
   ret->refresh_task = GNUNET_SCHEDULER_add_delayed (MAP_REFRESH_FREQ,
-                                                    &do_refresh,
-                                                    ret);
+                                                    &do_refresh, ret);
 
   return ret;
 }
@@ -562,23 +524,20 @@ GNUNET_NAT_mini_map_start (uint16_t port,
  * @param line line of output, NULL at the end
  */
 static void
-process_unmap_output (void *cls,
-                      const char *line)
+process_unmap_output (void *cls, const char *line)
 {
   struct GNUNET_NAT_MiniHandle *mini = cls;
 
   if (NULL == line)
-    {
+  {
 #if DEBUG_NAT
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "nat",
-                       "UPnP unmap done\n");
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "nat", "UPnP unmap done\n");
 #endif
-      GNUNET_OS_command_stop (mini->unmap_cmd);
-      mini->unmap_cmd = NULL;
-      GNUNET_free (mini);
-      return;
-    }
+    GNUNET_OS_command_stop (mini->unmap_cmd);
+    mini->unmap_cmd = NULL;
+    GNUNET_free (mini);
+    return;
+  }
   /* we don't really care about the output... */
 }
 
@@ -597,48 +556,46 @@ GNUNET_NAT_mini_map_stop (struct GNUNET_NAT_MiniHandle *mini)
   char pstr[6];
 
   if (GNUNET_SCHEDULER_NO_TASK != mini->refresh_task)
-    {
-      GNUNET_SCHEDULER_cancel (mini->refresh_task);
-      mini->refresh_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (mini->refresh_task);
+    mini->refresh_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (mini->refresh_cmd != NULL)
+  {
+    GNUNET_OS_command_stop (mini->refresh_cmd);
+    mini->refresh_cmd = NULL;
+  }
+  if (!mini->did_map)
+  {
+    if (mini->map_cmd != NULL)
     {
-      GNUNET_OS_command_stop (mini->refresh_cmd);
-      mini->refresh_cmd = NULL;
-    }
-  if (! mini->did_map)
-    {
-      if (mini->map_cmd != NULL)
-        {
-          GNUNET_OS_command_stop (mini->map_cmd);
-          mini->map_cmd = NULL;
-        }
-      GNUNET_free (mini);
-      return;
+      GNUNET_OS_command_stop (mini->map_cmd);
+      mini->map_cmd = NULL;
     }
+    GNUNET_free (mini);
+    return;
+  }
   mini->ac (mini->ac_cls, GNUNET_NO,
-            (const struct sockaddr*) &mini->current_addr,
-            sizeof (mini->current_addr));
+            (const struct sockaddr *) &mini->current_addr,
+            sizeof (mini->current_addr));
   /* Note: oddly enough, deletion uses the external port whereas
-     addition uses the internal port; this rarely matters since they
-     often are the same, but it might... */
+   * addition uses the internal port; this rarely matters since they
+   * often are the same, but it might... */
   GNUNET_snprintf (pstr, sizeof (pstr),
-                   "%u",
-                   (unsigned int) ntohs (mini->current_addr.sin_port));
+                   "%u", (unsigned int) ntohs (mini->current_addr.sin_port));
 #if DEBUG_NAT
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "nat",
-                   "Unmapping port %u with UPnP\n",
-                   ntohs (mini->current_addr.sin_port));
+                   "nat",
+                   "Unmapping port %u with UPnP\n",
+                   ntohs (mini->current_addr.sin_port));
 #endif
   mini->unmap_cmd = GNUNET_OS_command_run (&process_unmap_output,
-                                           mini,
-                                           UNMAP_TIMEOUT,
-                                           "upnpc",
-                                           "upnpc",
-                                           "-d", pstr, 
-                                           mini->is_tcp ? "tcp" : "udp",
-                                           NULL);
+                                           mini,
+                                           UNMAP_TIMEOUT,
+                                           "upnpc",
+                                           "upnpc",
+                                           "-d", pstr,
+                                           mini->is_tcp ? "tcp" : "udp", NULL);
 }
 
 
diff --git a/src/nat/nat_test.c b/src/nat/nat_test.c
index 8c9933cdb..30db00803 100644
--- a/src/nat/nat_test.c
+++ b/src/nat/nat_test.c
@@ -99,7 +99,7 @@ struct GNUNET_NAT_Test
    * Function to call with success report
    */
   GNUNET_NAT_TestCallback report;
-  
+
   /**
    * Closure for 'report'.
    */
@@ -167,9 +167,7 @@ struct GNUNET_NAT_Test
  * @param addrlen actual lenght of the address
  */
 static void
-reversal_cb (void *cls, 
-             const struct sockaddr *addr,
-             socklen_t addrlen)
+reversal_cb (void *cls, const struct sockaddr *addr, socklen_t addrlen)
 {
   struct GNUNET_NAT_Test *h = cls;
   const struct sockaddr_in *sa;
@@ -178,14 +176,14 @@ reversal_cb (void *cls,
     return;
   sa = (const struct sockaddr_in *) addr;
   if (h->data != sa->sin_port)
-    {
+  {
 #if DEBUG_NAT
-      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                       "nat",
-                       "Received connection reversal request for wrong port\n");
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                     "nat",
+                     "Received connection reversal request for wrong port\n");
 #endif
-      return; /* wrong port */
-    }
+    return;                     /* wrong port */
+  }
   /* report success */
   h->report (h->report_cls, GNUNET_OK);
 }
@@ -199,38 +197,31 @@ reversal_cb (void *cls,
  * @param tc scheduler context
  */
 static void
-do_udp_read (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_udp_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_NAT_Test *tst = cls;
   uint16_t data;
 
   tst->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                              tst->lsock,
-                                              &do_udp_read,
-                                              tst);
-  if ( (NULL != tc->write_ready) &&
-       (GNUNET_NETWORK_fdset_isset (tc->read_ready, 
-                                    tst->lsock)) &&
-       (sizeof (data) ==
-        GNUNET_NETWORK_socket_recv (tst->lsock,
-                                    &data,
-                                    sizeof (data))) )
-    {
-      if (data == tst->data)
-        tst->report (tst->report_cls, GNUNET_OK);
+                                              tst->lsock, &do_udp_read, tst);
+  if ((NULL != tc->write_ready) &&
+      (GNUNET_NETWORK_fdset_isset (tc->read_ready,
+                                   tst->lsock)) &&
+      (sizeof (data) ==
+       GNUNET_NETWORK_socket_recv (tst->lsock, &data, sizeof (data))))
+  {
+    if (data == tst->data)
+      tst->report (tst->report_cls, GNUNET_OK);
 #if DEBUG_NAT
-      else
-        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                         "nat",
-                         "Received data mismatches expected value\n");
+    else
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                       "nat", "Received data mismatches expected value\n");
 #endif
-    }
+  }
 #if DEBUG_NAT
   else
     GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                     "nat",
-                     "Failed to receive data from inbound connection\n");
+                     "nat", "Failed to receive data from inbound connection\n");
 #endif
 }
 
@@ -243,8 +234,7 @@ do_udp_read (void *cls,
  * @param tc scheduler context
  */
 static void
-do_read (void *cls,
-         const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_read (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct NatActivity *na = cls;
   struct GNUNET_NAT_Test *tst;
@@ -252,31 +242,25 @@ do_read (void *cls,
 
   na->rtask = GNUNET_SCHEDULER_NO_TASK;
   tst = na->h;
-  GNUNET_CONTAINER_DLL_remove (tst->na_head,
-                               tst->na_tail,
-                               na);
-  if ( (NULL != tc->write_ready) &&
-       (GNUNET_NETWORK_fdset_isset (tc->read_ready, 
-                                    na->sock)) &&
-       (sizeof (data) ==
-        GNUNET_NETWORK_socket_recv (na->sock,
-                                    &data,
-                                    sizeof (data))) )
-    {
-      if (data == tst->data)
-        tst->report (tst->report_cls, GNUNET_OK);
+  GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, na);
+  if ((NULL != tc->write_ready) &&
+      (GNUNET_NETWORK_fdset_isset (tc->read_ready,
+                                   na->sock)) &&
+      (sizeof (data) ==
+       GNUNET_NETWORK_socket_recv (na->sock, &data, sizeof (data))))
+  {
+    if (data == tst->data)
+      tst->report (tst->report_cls, GNUNET_OK);
 #if DEBUG_NAT
-      else
-        GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                         "nat"
-                         "Received data mismatches expected value\n");
+    else
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
+                       "nat" "Received data mismatches expected value\n");
 #endif
-    }
+  }
 #if DEBUG_NAT
   else
     GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                     "nat",
-                     "Failed to receive data from inbound connection\n");
+                     "nat", "Failed to receive data from inbound connection\n");
 #endif
   GNUNET_NETWORK_socket_close (na->sock);
   GNUNET_free (na);
@@ -291,8 +275,7 @@ do_read (void *cls,
  * @param tc scheduler context
  */
 static void
-do_accept (void *cls,
-           const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_NAT_Test *tst = cls;
   struct GNUNET_NETWORK_Handle *s;
@@ -300,32 +283,25 @@ do_accept (void *cls,
 
   tst->ltask = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-    return; 
+    return;
   tst->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                              tst->lsock,
-                                              &do_accept,
-                                              tst);
+                                              tst->lsock, &do_accept, tst);
   s = GNUNET_NETWORK_socket_accept (tst->lsock, NULL, NULL);
   if (NULL == s)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "accept");
-      return; /* odd error */
-    }
-#if DEBUG_NAT 
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO, "accept");
+    return;                     /* odd error */
+  }
+#if DEBUG_NAT
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "nat",
-                   "Got an inbound connection, waiting for data\n");
+                   "nat", "Got an inbound connection, waiting for data\n");
 #endif
   wl = GNUNET_malloc (sizeof (struct NatActivity));
   wl->sock = s;
   wl->h = tst;
   wl->rtask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                             wl->sock,
-                                             &do_read,
-                                             wl);
-  GNUNET_CONTAINER_DLL_insert (tst->na_head,
-                               tst->na_tail,
-                               wl);
+                                             wl->sock, &do_read, wl);
+  GNUNET_CONTAINER_DLL_insert (tst->na_head, tst->na_tail, wl);
 }
 
 
@@ -338,11 +314,9 @@ do_accept (void *cls,
  * @param addr either the previous or the new public IP address
  * @param addrlen actual lenght of the address
  */
-static void 
+static void
 addr_cb (void *cls,
-         int add_remove,
-         const struct sockaddr *addr,
-         socklen_t addrlen)
+         int add_remove, const struct sockaddr *addr, socklen_t addrlen)
 {
   struct GNUNET_NAT_Test *h = cls;
   struct ClientActivity *ca;
@@ -353,40 +327,37 @@ addr_cb (void *cls,
   if (GNUNET_YES != add_remove)
     return;
   if (addrlen != sizeof (struct sockaddr_in))
-    return; /* ignore IPv6 here */
+    return;                     /* ignore IPv6 here */
 #if DEBUG_NAT
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG,
-                   "nat",
-                   "Asking gnunet-nat-server to connect to `%s'\n",
-                   GNUNET_a2s (addr, addrlen));
+                   "nat",
+                   "Asking gnunet-nat-server to connect to `%s'\n",
+                   GNUNET_a2s (addr, addrlen));
 #endif
-  sa = (const struct sockaddr_in*) addr;
-  msg.header.size = htons (sizeof(struct GNUNET_NAT_TestMessage));
+  sa = (const struct sockaddr_in *) addr;
+  msg.header.size = htons (sizeof (struct GNUNET_NAT_TestMessage));
   msg.header.type = htons (GNUNET_MESSAGE_TYPE_NAT_TEST);
   msg.dst_ipv4 = sa->sin_addr.s_addr;
   msg.dport = sa->sin_port;
   msg.data = h->data;
   msg.is_tcp = htonl ((uint32_t) h->is_tcp);
 
-  client = GNUNET_CLIENT_connect ("gnunet-nat-server",
-                                  h->cfg);
+  client = GNUNET_CLIENT_connect ("gnunet-nat-server", h->cfg);
   if (NULL == client)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to connect to `gnunet-nat-server'\n"));
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to connect to `gnunet-nat-server'\n"));
+    return;
+  }
   ca = GNUNET_malloc (sizeof (struct ClientActivity));
   ca->client = client;
-  GNUNET_CONTAINER_DLL_insert (h->ca_head,
-                               h->ca_tail,
-                               ca);
+  GNUNET_CONTAINER_DLL_insert (h->ca_head, h->ca_tail, ca);
   GNUNET_break (GNUNET_OK ==
-                GNUNET_CLIENT_transmit_and_get_response (client,
-                                                         &msg.header,
-                                                         GNUNET_TIME_UNIT_SECONDS,
-                                                         GNUNET_YES,
-                                                         NULL, NULL));
+                GNUNET_CLIENT_transmit_and_get_response (client,
+                                                         &msg.header,
+                                                         GNUNET_TIME_UNIT_SECONDS,
+                                                         GNUNET_YES,
+                                                         NULL, NULL));
 }
 
 
@@ -404,15 +375,14 @@ addr_cb (void *cls,
  */
 struct GNUNET_NAT_Test *
 GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
-                       int is_tcp,
-                       uint16_t bnd_port,
-                       uint16_t adv_port,
-                       GNUNET_NAT_TestCallback report,
-                       void *report_cls)
+                       int is_tcp,
+                       uint16_t bnd_port,
+                       uint16_t adv_port,
+                       GNUNET_NAT_TestCallback report, void *report_cls)
 {
   struct GNUNET_NAT_Test *ret;
   struct sockaddr_in sa;
-  const struct sockaddr *addrs[] = { (const struct sockaddr*) &sa };
+  const struct sockaddr *addrs[] = { (const struct sockaddr *) &sa };
   const socklen_t addrlens[] = { sizeof (sa) };
 
   memset (&sa, 0, sizeof (sa));
@@ -421,7 +391,7 @@ GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
 #if HAVE_SOCKADDR_IN_SIN_LEN
   sa.sin_len = sizeof (sa);
 #endif
-  
+
   ret = GNUNET_malloc (sizeof (struct GNUNET_NAT_Test));
   ret->cfg = cfg;
   ret->is_tcp = is_tcp;
@@ -430,54 +400,47 @@ GNUNET_NAT_test_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
   ret->report = report;
   ret->report_cls = report_cls;
   if (bnd_port == 0)
-    {      
-      ret->nat = GNUNET_NAT_register (cfg, is_tcp,
-                                      0, 
-                                      0, NULL, NULL,
-                                      &addr_cb, &reversal_cb, ret);
-    }
+  {
+    ret->nat = GNUNET_NAT_register (cfg, is_tcp,
+                                    0,
+                                    0, NULL, NULL, &addr_cb, &reversal_cb, ret);
+  }
   else
+  {
+    ret->lsock = GNUNET_NETWORK_socket_create (AF_INET,
+                                               (is_tcp == GNUNET_YES)
+                                               ? SOCK_STREAM : SOCK_DGRAM, 0);
+    if ((ret->lsock == NULL) ||
+        (GNUNET_OK != GNUNET_NETWORK_socket_bind (ret->lsock,
+                                                  (const struct sockaddr *) &sa,
+                                                  sizeof (sa))))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _
+                  ("Failed to create listen socket bound to `%s' for NAT test: %s\n"),
+                  GNUNET_a2s ((const struct sockaddr *) &sa, sizeof (sa)),
+                  STRERROR (errno));
+      if (NULL != ret->lsock)
+        GNUNET_NETWORK_socket_close (ret->lsock);
+      GNUNET_free (ret);
+      return NULL;
+    }
+    if (GNUNET_YES == is_tcp)
+    {
+      GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_listen (ret->lsock, 5));
+      ret->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                                  ret->lsock, &do_accept, ret);
+    }
+    else
     {
-      ret->lsock = GNUNET_NETWORK_socket_create (AF_INET, 
-                                                 (is_tcp==GNUNET_YES) 
-                                                 ? SOCK_STREAM 
-                                                 : SOCK_DGRAM, 0);
-      if ( (ret->lsock == NULL) ||
-           (GNUNET_OK != GNUNET_NETWORK_socket_bind (ret->lsock,
-                                                     (const struct sockaddr*) &sa,
-                                                     sizeof (sa))) )
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Failed to create listen socket bound to `%s' for NAT test: %s\n"),
-                      GNUNET_a2s ((const struct sockaddr*)&sa,
-                                  sizeof(sa)),
-                      STRERROR (errno));
-          if (NULL != ret->lsock)
-            GNUNET_NETWORK_socket_close (ret->lsock);
-          GNUNET_free (ret);
-          return NULL;
-        }
-      if (GNUNET_YES == is_tcp)
-        {
-          GNUNET_break (GNUNET_OK ==
-                        GNUNET_NETWORK_socket_listen (ret->lsock, 5));
-          ret->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                                      ret->lsock,
-                                                      &do_accept,
-                                                      ret);
-        }
-      else
-        {
-          ret->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
-                                                     ret->lsock,
-                                                     &do_udp_read,
-                                                     ret);
-        }
-      ret->nat = GNUNET_NAT_register (cfg, is_tcp,
-                                      adv_port, 
-                                      1, addrs, addrlens,
-                                      &addr_cb, NULL, ret);
+      ret->ltask = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
+                                                  ret->lsock,
+                                                  &do_udp_read, ret);
     }
+    ret->nat = GNUNET_NAT_register (cfg, is_tcp,
+                                    adv_port,
+                                    1, addrs, addrlens, &addr_cb, NULL, ret);
+  }
   return ret;
 }
 
@@ -494,22 +457,18 @@ GNUNET_NAT_test_stop (struct GNUNET_NAT_Test *tst)
   struct ClientActivity *cpos;
 
   while (NULL != (cpos = tst->ca_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (tst->ca_head,
-                                   tst->ca_tail,
-                                   cpos);
-      GNUNET_CLIENT_disconnect (cpos->client, GNUNET_NO);  
-      GNUNET_free (cpos);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (tst->ca_head, tst->ca_tail, cpos);
+    GNUNET_CLIENT_disconnect (cpos->client, GNUNET_NO);
+    GNUNET_free (cpos);
+  }
   while (NULL != (pos = tst->na_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (tst->na_head,
-                                   tst->na_tail,
-                                   pos);
-      GNUNET_SCHEDULER_cancel (pos->rtask);
-      GNUNET_NETWORK_socket_close (pos->sock);
-      GNUNET_free (pos);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (tst->na_head, tst->na_tail, pos);
+    GNUNET_SCHEDULER_cancel (pos->rtask);
+    GNUNET_NETWORK_socket_close (pos->sock);
+    GNUNET_free (pos);
+  }
   if (GNUNET_SCHEDULER_NO_TASK != tst->ltask)
     GNUNET_SCHEDULER_cancel (tst->ltask);
   if (NULL != tst->lsock)
diff --git a/src/nat/test_nat.c b/src/nat/test_nat.c
index c58d83224..12ff30cac 100644
--- a/src/nat/test_nat.c
+++ b/src/nat/test_nat.c
@@ -58,11 +58,10 @@ static void
 addr_callback (void *cls, int add_remove,
                const struct sockaddr *addr, socklen_t addrlen)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
-              "Address changed: %s `%s' (%u bytes)\n",
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Address changed: %s `%s' (%u bytes)\n",
               add_remove == GNUNET_YES ? "added" : "removed",
-              GNUNET_a2s (addr, addrlen),
-              (unsigned int) addrlen);
+              GNUNET_a2s (addr, addrlen), (unsigned int) addrlen);
 }
 
 
@@ -74,8 +73,7 @@ stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_NAT_Handle *nat = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
-              "Stopping NAT and quitting...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping NAT and quitting...\n");
   GNUNET_NAT_unregister (nat);
 }
 
@@ -132,11 +130,11 @@ run (void *cls,
   data.addr = NULL;
   GNUNET_OS_network_interfaces_list (process_if, &data);
   if (NULL == data.addr)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Could not find a valid interface address!\n");
-      exit (GNUNET_SYSERR);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not find a valid interface address!\n");
+    exit (GNUNET_SYSERR);
+  }
   addr = data.addr;
   GNUNET_assert (addr->sa_family == AF_INET || addr->sa_family == AF_INET6);
   if (addr->sa_family == AF_INET)
@@ -148,13 +146,11 @@ run (void *cls,
               "Requesting NAT redirection from address %s...\n",
               GNUNET_a2s (addr, data.addrlen));
 
-  nat = GNUNET_NAT_register (cfg, 
-                             GNUNET_YES /* tcp */,
-                             2086,
-                             1,
-                             (const struct sockaddr**) &addr, 
-                             &data.addrlen, 
-                             &addr_callback, NULL, NULL);
+  nat = GNUNET_NAT_register (cfg, GNUNET_YES /* tcp */ ,
+                             2086,
+                             1,
+                             (const struct sockaddr **) &addr,
+                             &data.addrlen, &addr_callback, NULL, NULL);
   GNUNET_free (addr);
   GNUNET_SCHEDULER_add_delayed (TIMEOUT, &stop, nat);
 }
diff --git a/src/nat/test_nat_mini.c b/src/nat/test_nat_mini.c
index a8381e497..8f689d6bc 100644
--- a/src/nat/test_nat_mini.c
+++ b/src/nat/test_nat_mini.c
@@ -50,10 +50,9 @@ addr_callback (void *cls, int add_remove,
                const struct sockaddr *addr, socklen_t addrlen)
 {
   fprintf (stderr,
-           "Address changed: %s `%s' (%u bytes)\n",
-           add_remove == GNUNET_YES ? "added" : "removed",
-           GNUNET_a2s (addr, addrlen),
-           (unsigned int) addrlen);
+           "Address changed: %s `%s' (%u bytes)\n",
+           add_remove == GNUNET_YES ? "added" : "removed",
+           GNUNET_a2s (addr, addrlen), (unsigned int) addrlen);
 }
 
 
@@ -65,8 +64,7 @@ stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_NAT_MiniHandle *mini = cls;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, 
-              "Stopping NAT and quitting...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping NAT and quitting...\n");
   GNUNET_NAT_mini_map_stop (mini);
 }
 
@@ -83,17 +81,14 @@ run (void *cls,
   struct GNUNET_NAT_MiniHandle *mini;
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Requesting NAT redirection for port %u...\n",
-              PORT);
-  mini = GNUNET_NAT_mini_map_start (PORT,
-                                    GNUNET_YES /* tcp */,
-                                    &addr_callback, NULL);
+              "Requesting NAT redirection for port %u...\n", PORT);
+  mini = GNUNET_NAT_mini_map_start (PORT, GNUNET_YES /* tcp */ ,
+                                    &addr_callback, NULL);
   if (NULL == mini)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  "Could not start UPnP interaction\n");
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Could not start UPnP interaction\n");
+    return;
+  }
   GNUNET_SCHEDULER_add_delayed (TIMEOUT, &stop, mini);
 }
 
@@ -127,9 +122,10 @@ main (int argc, char *const argv[])
                     NULL);
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "UPnP test for NAT library, timeout set to %d seconds\n", TIMEOUT);
-  GNUNET_PROGRAM_run (5, argv_prog, "test-nat-mini",
-                      "nohelp", options, &run, NULL);
+              "UPnP test for NAT library, timeout set to %d seconds\n",
+              TIMEOUT);
+  GNUNET_PROGRAM_run (5, argv_prog, "test-nat-mini", "nohelp", options, &run,
+                      NULL);
   return 0;
 }
 
diff --git a/src/nat/test_nat_test.c b/src/nat/test_nat_test.c
index 32c4fb2d8..520d82d92 100644
--- a/src/nat/test_nat_test.c
+++ b/src/nat/test_nat_test.c
@@ -47,15 +47,13 @@ static struct GNUNET_NAT_Test *tst;
 static GNUNET_SCHEDULER_TaskIdentifier end;
 
 static void
-end_test (void *cls,
-          const struct GNUNET_SCHEDULER_TaskContext *tc)
+end_test (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_NAT_test_stop (tst);
 }
 
 static void
-report_success (void *cls,
-                int success)
+report_success (void *cls, int success)
 {
   GNUNET_assert (GNUNET_OK == success);
   ret = 0;
@@ -72,13 +70,10 @@ run (void *cls,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   tst = GNUNET_NAT_test_start (cfg, GNUNET_YES,
-                               1285, 1285,
-                               &report_success, NULL);
+                               1285, 1285, &report_success, NULL);
   if (NULL == tst)
     return;
-  end  = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                       &end_test,
-                                       NULL);
+  end = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_test, NULL);
 }
 
 
@@ -89,6 +84,7 @@ main (int argc, char *const argv[])
     GNUNET_GETOPT_OPTION_END
   };
   struct GNUNET_OS_Process *gns;
+
   char *const argv_prog[] = {
     "test-nat-test",
     "-c",
@@ -110,23 +106,17 @@ main (int argc, char *const argv[])
 #endif
                     NULL);
   gns = GNUNET_OS_start_process (NULL, NULL,
-                                 "gnunet-nat-server",
-                                 "gnunet-nat-server",
+                                 "gnunet-nat-server", "gnunet-nat-server",
 #if VERBOSE
-                                 "-L",
-                                 "DEBUG",
+                                 "-L", "DEBUG",
 #endif
-                                 "-c", "test_nat_test_data.conf",
-                                 "12345",
-                                 NULL);
+                                 "-c", "test_nat_test_data.conf",
+                                 "12345", NULL);
   GNUNET_assert (NULL != gns);
-  GNUNET_PROGRAM_run (5, argv_prog, 
-                      "test-nat-test", "nohelp", 
-                      options, 
-                      &run, NULL);
+  GNUNET_PROGRAM_run (5, argv_prog,
+                      "test-nat-test", "nohelp", options, &run, NULL);
   GNUNET_break (0 == GNUNET_OS_process_kill (gns, SIGTERM));
-  GNUNET_break (GNUNET_OK ==
-                GNUNET_OS_process_wait (gns));
+  GNUNET_break (GNUNET_OK == GNUNET_OS_process_wait (gns));
   GNUNET_OS_process_close (gns);
   return ret;
 }