1 files changed, 199 insertions, 217 deletions

diff --git a/src/transport/test_transport_api_reliability.c b/src/transport/test_transport_api_reliability.c
index 37395ad0f..60191394d 100644
--- a/src/transport/test_transport_api_reliability.c
+++ b/src/transport/test_transport_api_reliability.c
@@ -51,17 +51,17 @@
 
 static int ok;
 
-static  GNUNET_SCHEDULER_TaskIdentifier die_task;
+static GNUNET_SCHEDULER_TaskIdentifier die_task;
 
-struct PeerContext * p1;
+struct PeerContext *p1;
 
-struct PeerContext * p2;
+struct PeerContext *p2;
 
-struct GNUNET_TRANSPORT_TransmitHandle * th;
+struct GNUNET_TRANSPORT_TransmitHandle *th;
 
-char * cfg_file_p1;
+char *cfg_file_p1;
 
-char * cfg_file_p2;
+char *cfg_file_p2;
 
 /*
  * Testcase specific declarations
@@ -108,27 +108,27 @@ static void
 end ()
 {
   unsigned long long delta;
+
   //char *value_name;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
 
   delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value;
   fprintf (stderr,
-           "\nThroughput was %llu kb/s\n",
-           total_bytes * 1000 / 1024 / delta);
+           "\nThroughput was %llu kb/s\n", total_bytes * 1000 / 1024 / delta);
   //GNUNET_asprintf(&value_name, "reliable_%s", test_name);
   //GAUGER ("TRANSPORT", value_name, (int)(total_bytes * 1000 / 1024 /delta), "kb/s");
   //GNUNET_free(value_name);
 
   if (die_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel(die_task);
+    GNUNET_SCHEDULER_cancel (die_task);
 
   if (th != NULL)
-    GNUNET_TRANSPORT_notify_transmit_ready_cancel(th);
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
   th = NULL;
 
-  GNUNET_TRANSPORT_TESTING_stop_peer(p1);
-  GNUNET_TRANSPORT_TESTING_stop_peer(p2);
+  GNUNET_TRANSPORT_TESTING_stop_peer (p1);
+  GNUNET_TRANSPORT_TESTING_stop_peer (p2);
 }
 
 static void
@@ -138,13 +138,13 @@ end_badly ()
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
 
   if (th != NULL)
-    GNUNET_TRANSPORT_notify_transmit_ready_cancel(th);
+    GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
   th = NULL;
 
   if (p1 != NULL)
-    GNUNET_TRANSPORT_TESTING_stop_peer(p1);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p1);
   if (p2 != NULL)
-    GNUNET_TRANSPORT_TESTING_stop_peer(p2);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p2);
 
   ok = GNUNET_SYSERR;
 }
@@ -172,75 +172,66 @@ notify_receive (void *cls,
   char cbuf[GNUNET_SERVER_MAX_MESSAGE_SIZE - 1];
   const struct TestMessage *hdr;
 
-  hdr = (const struct TestMessage*) message;
+  hdr = (const struct TestMessage *) message;
   s = get_size (n);
   if (MTYPE != ntohs (message->type))
     return;
   msg_recv_expected = n;
-  msg_recv = ntohl(hdr->num);
+  msg_recv = ntohl (hdr->num);
   if (ntohs (message->size) != (s))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u of size %u, got %u bytes of message %u\n",
-                  n, s,
-                  ntohs (message->size),
-                  ntohl (hdr->num));
-      if (die_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (die_task);
-      test_failed = GNUNET_YES;
-      die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u of size %u, got %u bytes of message %u\n",
+                n, s, ntohs (message->size), ntohl (hdr->num));
+    if (die_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (die_task);
+    test_failed = GNUNET_YES;
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+    return;
+  }
   if (ntohl (hdr->num) != n)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u of size %u, got %u bytes of message %u\n",
-                  n, s,
-                  ntohs (message->size),
-                  ntohl (hdr->num));
-      if (die_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (die_task);
-      test_failed = GNUNET_YES;
-      die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u of size %u, got %u bytes of message %u\n",
+                n, s, ntohs (message->size), ntohl (hdr->num));
+    if (die_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (die_task);
+    test_failed = GNUNET_YES;
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+    return;
+  }
   memset (cbuf, n, s - sizeof (struct TestMessage));
-  if (0 != memcmp (cbuf,
-                   &hdr[1],
-                   s - sizeof (struct TestMessage)))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Expected message %u with bits %u, but body did not match\n",
-                  n, (unsigned char) n);
-      if (die_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (die_task);
-      test_failed = GNUNET_YES;
-      die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
-      return;
-    }
+  if (0 != memcmp (cbuf, &hdr[1], s - sizeof (struct TestMessage)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Expected message %u with bits %u, but body did not match\n",
+                n, (unsigned char) n);
+    if (die_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (die_task);
+    test_failed = GNUNET_YES;
+    die_task = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+    return;
+  }
 #if VERBOSE
-  if (ntohl(hdr->num) % 5000 == 0)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Got message %u of size %u\n",
-                  ntohl (hdr->num),
-                  ntohs (message->size));
-    }
+  if (ntohl (hdr->num) % 5000 == 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Got message %u of size %u\n",
+                ntohl (hdr->num), ntohs (message->size));
+  }
 #endif
   n++;
-  if (0 == (n % (TOTAL_MSGS/100)))
-    {
-      fprintf (stderr, ".");
-      if (die_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (die_task);
-      die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                               &end_badly,
-                                               NULL);
-    }
+  if (0 == (n % (TOTAL_MSGS / 100)))
+  {
+    fprintf (stderr, ".");
+    if (die_task != GNUNET_SCHEDULER_NO_TASK)
+      GNUNET_SCHEDULER_cancel (die_task);
+    die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
+  }
   if (n == TOTAL_MSGS)
   {
     ok = 0;
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"All messages received\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All messages received\n");
     end ();
   }
 }
@@ -256,11 +247,11 @@ notify_ready (void *cls, size_t size, void *buf)
   unsigned int ret;
 
   if (buf == NULL)
-    {
-      GNUNET_break (0);
-      ok = 42;
-      return 0;
-    }
+  {
+    GNUNET_break (0);
+    ok = 42;
+    return 0;
+  }
   th = NULL;
   ret = 0;
   s = get_size (n);
@@ -268,50 +259,46 @@ notify_ready (void *cls, size_t size, void *buf)
   GNUNET_assert (buf != NULL);
   cbuf = buf;
   do
-    {
-      hdr.header.size = htons (s);
-      hdr.header.type = htons (MTYPE);
-      hdr.num = htonl (n);
-      msg_sent = n;
-      memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
-      ret += sizeof (struct TestMessage);
-      memset (&cbuf[ret], n, s - sizeof (struct TestMessage));
-      ret += s - sizeof (struct TestMessage);
+  {
+    hdr.header.size = htons (s);
+    hdr.header.type = htons (MTYPE);
+    hdr.num = htonl (n);
+    msg_sent = n;
+    memcpy (&cbuf[ret], &hdr, sizeof (struct TestMessage));
+    ret += sizeof (struct TestMessage);
+    memset (&cbuf[ret], n, s - sizeof (struct TestMessage));
+    ret += s - sizeof (struct TestMessage);
 #if VERBOSE
-      if (n % 5000 == 0)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Sending message %u of size %u\n",
-                      n,
-                      s);
-        }
-#endif
-      n++;
-      s = get_size (n);
-      if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
-        break; /* sometimes pack buffer full, sometimes not */
+    if (n % 5000 == 0)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Sending message %u of size %u\n", n, s);
     }
+#endif
+    n++;
+    s = get_size (n);
+    if (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 16))
+      break;                    /* sometimes pack buffer full, sometimes not */
+  }
   while (size - ret >= s);
   if (n < TOTAL_MSGS)
   {
     if (th == NULL)
       th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th,
-                                            &p1->id,
-                                            s, 0, TIMEOUT,
-                                            &notify_ready,
-                                            NULL);
+                                                   &p1->id,
+                                                   s, 0, TIMEOUT,
+                                                   &notify_ready, NULL);
     msg_scheduled = n;
   }
   if (n % 5000 == 0)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Returning total message block of size %u\n",
-                  ret);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Returning total message block of size %u\n", ret);
+  }
   total_bytes += ret;
   if (n == TOTAL_MSGS)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,"All messages sent\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All messages sent\n");
   }
   return ret;
 }
@@ -325,34 +312,34 @@ notify_connect (void *cls,
 {
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' connected to us (%p)!\n",
-              GNUNET_i2s (peer),
-              cls);
+              "Peer `%4s' connected to us (%p)!\n", GNUNET_i2s (peer), cls);
 
   if (cls == p1)
-    {
-      GNUNET_TRANSPORT_set_quota (p1->th,
-                                  &p2->id,
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024),
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024));
-    }
-  else  if (cls == p2)
-    {
-      GNUNET_TRANSPORT_set_quota (p2->th,
-                                  &p1->id,
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024),
-                                  GNUNET_BANDWIDTH_value_init (1024 * 1024 * 1024));
-    }
+  {
+    GNUNET_TRANSPORT_set_quota (p1->th,
+                                &p2->id,
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024),
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024));
+  }
+  else if (cls == p2)
+  {
+    GNUNET_TRANSPORT_set_quota (p2->th,
+                                &p1->id,
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024),
+                                GNUNET_BANDWIDTH_value_init (1024 * 1024 *
+                                                             1024));
+  }
 }
 
 
 static void
-notify_disconnect (void *cls,
-                   const struct GNUNET_PeerIdentity *peer)
+notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peer `%4s' disconnected (%p)!\n",
-              GNUNET_i2s (peer), cls);
+              "Peer `%4s' disconnected (%p)!\n", GNUNET_i2s (peer), cls);
 }
 
 static void
@@ -360,23 +347,22 @@ sendtask ()
 {
   start_time = GNUNET_TIME_absolute_get ();
   th = GNUNET_TRANSPORT_notify_transmit_ready (p2->th,
-                                          &p1->id,
-                                          get_size (0), 0, TIMEOUT,
-                                          &notify_ready,
-                                          NULL);
+                                               &p1->id,
+                                               get_size (0), 0, TIMEOUT,
+                                               &notify_ready, NULL);
 }
 
 static void
-testing_connect_cb (struct PeerContext * p1, struct PeerContext * p2, void *cls)
+testing_connect_cb (struct PeerContext *p1, struct PeerContext *p2, void *cls)
 {
-  char * p1_c = strdup (GNUNET_i2s(&p1->id));
+  char *p1_c = strdup (GNUNET_i2s (&p1->id));
+
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected: %s <-> %s\n",
-       p1_c,
-       GNUNET_i2s (&p2->id));
+              p1_c, GNUNET_i2s (&p2->id));
   GNUNET_free (p1_c);
 
   // FIXME: THIS IS REQUIRED! SEEMS TO BE A BUG!
-  GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &sendtask, NULL);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &sendtask, NULL);
 }
 
 static void
@@ -384,21 +370,18 @@ run (void *cls,
      char *const *args,
      const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                           &end_badly, NULL);
-
-  p1 = GNUNET_TRANSPORT_TESTING_start_peer(cfg_file_p1,
-      &notify_receive,
-      &notify_connect,
-      &notify_disconnect,
-      NULL);
-  p2 = GNUNET_TRANSPORT_TESTING_start_peer(cfg_file_p2,
-      &notify_receive,
-      &notify_connect,
-      &notify_disconnect,
-      NULL);
-
-  GNUNET_TRANSPORT_TESTING_connect_peers(p1, p2, &testing_connect_cb, NULL);
+  die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
+
+  p1 = GNUNET_TRANSPORT_TESTING_start_peer (cfg_file_p1,
+                                            &notify_receive,
+                                            &notify_connect,
+                                            &notify_disconnect, NULL);
+  p2 = GNUNET_TRANSPORT_TESTING_start_peer (cfg_file_p2,
+                                            &notify_receive,
+                                            &notify_connect,
+                                            &notify_disconnect, NULL);
+
+  GNUNET_TRANSPORT_TESTING_connect_peers (p1, p2, &testing_connect_cb, NULL);
 }
 
 static int
@@ -417,12 +400,11 @@ check ()
   };
 
 #if WRITECONFIG
-  setTransportOptions("test_transport_api_data.conf");
+  setTransportOptions ("test_transport_api_data.conf");
 #endif
   ok = 1;
   GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-transport-api", "nohelp",
-                      options, &run, &ok);
+                      argv, "test-transport-api", "nohelp", options, &run, &ok);
 
   return ok;
 }
@@ -444,32 +426,32 @@ get_path_from_PATH (char *binary)
 
   p = getenv ("PATH");
   if (p == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("PATH environment variable is unset.\n"));
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("PATH environment variable is unset.\n"));
+    return NULL;
+  }
   path = GNUNET_strdup (p);     /* because we write on it */
   buf = GNUNET_malloc (strlen (path) + 20);
   pos = path;
 
   while (NULL != (end = strchr (pos, PATH_SEPARATOR)))
-    {
-      *end = '\0';
-      sprintf (buf, "%s/%s", pos, binary);
-      if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
-        {
-          GNUNET_free (path);
-          return buf;
-        }
-      pos = end + 1;
-    }
-  sprintf (buf, "%s/%s", pos, binary);
-  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  {
+    *end = '\0';
+    sprintf (buf, "%s/%s", pos, binary);
+    if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
     {
       GNUNET_free (path);
       return buf;
     }
+    pos = end + 1;
+  }
+  sprintf (buf, "%s/%s", pos, binary);
+  if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
+  {
+    GNUNET_free (path);
+    return buf;
+  }
   GNUNET_free (buf);
   GNUNET_free (path);
   return NULL;
@@ -486,16 +468,18 @@ get_path_from_PATH (char *binary)
  *         can be run properly, GNUNET_NO otherwise
  */
 static int
-check_gnunet_nat_binary(char *binary)
+check_gnunet_nat_binary (char *binary)
 {
   struct stat statbuf;
   char *p;
+
 #ifdef MINGW
   SOCKET rawsock;
 #endif
 
 #ifdef MINGW
   char *binaryexe;
+
   GNUNET_asprintf (&binaryexe, "%s.exe", binary);
   p = get_path_from_PATH (binaryexe);
   free (binaryexe);
@@ -503,36 +487,34 @@ check_gnunet_nat_binary(char *binary)
   p = get_path_from_PATH (binary);
 #endif
   if (p == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not find binary `%s' in PATH!\n"),
-                  binary);
-      return GNUNET_NO;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not find binary `%s' in PATH!\n"), binary);
+    return GNUNET_NO;
+  }
   if (0 != STAT (p, &statbuf))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("stat (%s) failed: %s\n"),
-                  p,
-                  STRERROR (errno));
-      GNUNET_free (p);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("stat (%s) failed: %s\n"), p, STRERROR (errno));
+    GNUNET_free (p);
+    return GNUNET_SYSERR;
+  }
   GNUNET_free (p);
 #ifndef MINGW
-  if ( (0 != (statbuf.st_mode & S_ISUID)) &&
-       (statbuf.st_uid == 0) )
+  if ((0 != (statbuf.st_mode & S_ISUID)) && (statbuf.st_uid == 0))
     return GNUNET_YES;
   return GNUNET_NO;
 #else
   rawsock = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
   if (INVALID_SOCKET == rawsock)
-    {
-      DWORD err = GetLastError ();
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "socket (AF_INET, SOCK_RAW, IPPROTO_ICMP) have failed! GLE = %d\n", err);
-      return GNUNET_NO; /* not running as administrator */
-    }
+  {
+    DWORD err = GetLastError ();
+
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "socket (AF_INET, SOCK_RAW, IPPROTO_ICMP) have failed! GLE = %d\n",
+                err);
+    return GNUNET_NO;           /* not running as administrator */
+  }
   closesocket (rawsock);
   return GNUNET_YES;
 #endif
@@ -551,13 +533,13 @@ main (int argc, char *argv[])
 #endif
                     NULL);
 
-  char * pch = strdup(argv[0]);
-  char * backup = pch;
-  char * filename = NULL;
+  char *pch = strdup (argv[0]);
+  char *backup = pch;
+  char *filename = NULL;
   char *dotexe;
 
   /* get executable filename */
-  pch = strtok (pch,"/");
+  pch = strtok (pch, "/");
   while (pch != NULL)
   {
     pch = strtok (NULL, "/");
@@ -565,35 +547,35 @@ main (int argc, char *argv[])
       filename = pch;
   }
   /* remove "lt-" */
-  filename = strstr(filename, "tes");
+  filename = strstr (filename, "tes");
   if (NULL != (dotexe = strstr (filename, ".exe")))
     dotexe[0] = '\0';
 
   /* create cfg filename */
-  GNUNET_asprintf(&cfg_file_p1, "%s_peer1.conf",filename);
-  GNUNET_asprintf(&cfg_file_p2, "%s_peer2.conf", filename);
+  GNUNET_asprintf (&cfg_file_p1, "%s_peer1.conf", filename);
+  GNUNET_asprintf (&cfg_file_p2, "%s_peer2.conf", filename);
   GNUNET_free (backup);
 
-  if (strstr(argv[0], "tcp_nat") != NULL)
+  if (strstr (argv[0], "tcp_nat") != NULL)
+  {
+    if (GNUNET_YES != check_gnunet_nat_binary ("gnunet-nat-server"))
     {
-      if (GNUNET_YES != check_gnunet_nat_binary("gnunet-nat-server"))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      "`%s' not properly installed, cannot run NAT test!\n",
-                      "gnunet-nat-server");
-          return 0;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "`%s' not properly installed, cannot run NAT test!\n",
+                  "gnunet-nat-server");
+      return 0;
     }
-  else if (strstr(argv[0], "udp_nat") != NULL)
+  }
+  else if (strstr (argv[0], "udp_nat") != NULL)
+  {
+    if (GNUNET_YES != check_gnunet_nat_binary ("gnunet-nat-server"))
     {
-      if (GNUNET_YES != check_gnunet_nat_binary("gnunet-nat-server"))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      "`%s' not properly installed, cannot run NAT test!\n",
-                      "gnunet-nat-server");
-          return 0;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  "`%s' not properly installed, cannot run NAT test!\n",
+                  "gnunet-nat-server");
+      return 0;
     }
+  }
 
   ret = check ();