X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftransport%2Ftest_plugin_transport.c;h=1d92588ea2672a56302def669c1758334797e881;hb=f46c107278b96264b2e5302b4ebb050f73abf869;hp=f0dbc411bbbff63925af1340c45955a94673b54e;hpb=6f191f08a947e08d5d8ff842a29ba6f4b6611603;p=oweals%2Fgnunet.git

diff --git a/src/transport/test_plugin_transport.c b/src/transport/test_plugin_transport.c
index f0dbc411b..1d92588ea 100644
--- a/src/transport/test_plugin_transport.c
+++ b/src/transport/test_plugin_transport.c
@@ -1,22 +1,22 @@
 /*
-     This file is part of GNUnet.
-     (C) 2009 Christian Grothoff (and other contributing authors)
-
-     GNUnet is free software; you can redistribute it and/or modify
-     it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 3, or (at your
-     option) any later version.
-
-     GNUnet is distributed in the hope that it will be useful, but
-     WITHOUT ANY WARRANTY; without even the implied warranty of
-     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-     General Public License for more details.
-
-     You should have received a copy of the GNU General Public License
-     along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-     Boston, MA 02111-1307, USA.
-*/
+ This file is part of GNUnet.
+ Copyright (C) 2009 GNUnet e.V.
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING.  If not, write to the
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+ */
 /**
  * @file transport/test_plugin_transport.c
  * @brief testcase for transport_api.c
@@ -25,16 +25,12 @@
  */
 
 #include "platform.h"
-#include "gnunet_common.h"
-#include "gnunet_constants.h"
 #include "gnunet_util_lib.h"
 #include "gnunet_hello_lib.h"
 #include "gnunet_peerinfo_service.h"
 #include "gnunet_statistics_service.h"
 #include "gnunet_protocols.h"
-#include "gnunet_signatures.h"
 #include "gnunet_transport_plugin.h"
-
 #include "transport.h"
 
 /**
@@ -43,22 +39,17 @@
 #define WAIT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
 
-#define HOSTKEY_FILE "test_plugin_hostkey"
+#define HOSTKEY_FILE "test_plugin_hostkey.ecc"
 
 /**
  * Our public key.
  */
-static struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key;
-
-/**
- * Our identity.
- */
 static struct GNUNET_PeerIdentity my_identity;
 
 /**
  * Our private key.
  */
-static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
+static struct GNUNET_CRYPTO_EddsaPrivateKey *my_private_key;
 
 /**
  * Our configuration.
@@ -98,12 +89,12 @@ struct GNUNET_HELPER_Handle *suid_helper;
 /**
  * Timeout task
  */
-static GNUNET_SCHEDULER_TaskIdentifier timeout_endbadly;
+static struct GNUNET_SCHEDULER_Task * timeout_endbadly;
 
 /**
  * Timeout task
  */
-static GNUNET_SCHEDULER_TaskIdentifier timeout_wait;
+static struct GNUNET_SCHEDULER_Task * timeout_wait;
 
 /**
  * Library name
@@ -129,18 +120,18 @@ unsigned int pretty_printers_running;
  */
 static int ok;
 
-
 struct AddressWrapper
 {
   struct AddressWrapper *next;
 
   struct AddressWrapper *prev;
 
-  void *addr;
-
-  size_t addrlen;
+  struct GNUNET_HELLO_Address *address;
 
   char *addrstring;
+
+  struct GNUNET_SCHEDULER_Task *test_task;
+
 };
 
 
@@ -151,97 +142,101 @@ end ()
   int c = 0;
   ok = 0;
 
-  if (GNUNET_SCHEDULER_NO_TASK != timeout_endbadly)
+  if (NULL != timeout_endbadly)
   {
-      GNUNET_SCHEDULER_cancel (timeout_endbadly);
-      timeout_endbadly = GNUNET_SCHEDULER_NO_TASK;
+    GNUNET_SCHEDULER_cancel (timeout_endbadly);
+    timeout_endbadly = NULL;
   }
   if (NULL != api)
-      GNUNET_PLUGIN_unload (libname, api);
+    GNUNET_PLUGIN_unload (libname, api);
 
   while (NULL != head)
   {
-      w = head;
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Plugin did not remove address `%s' \n"), w->addrstring);
-      GNUNET_CONTAINER_DLL_remove (head, tail, w);
-      c ++;
-      GNUNET_free (w->addr);
-      GNUNET_free (w->addrstring);
-      GNUNET_free (w);
+    w = head;
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Plugin did not remove address `%s'\n",
+                w->addrstring);
+    GNUNET_CONTAINER_DLL_remove(head, tail, w);
+    c++;
+    GNUNET_HELLO_address_free(w->address);
+    GNUNET_free(w->addrstring);
+    GNUNET_free(w);
   }
   if (c > 0)
   {
-    GNUNET_break (0);
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Plugin did not remove %u addresses \n"), c);
+    GNUNET_break(0);
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Plugin did not remove %u addresses \n",
+        c);
     ok = 1;
   }
 
-
-  GNUNET_free (libname);
+  GNUNET_free(libname);
   libname = NULL;
   GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
   stats = NULL;
 
   if (NULL != suid_helper)
   {
-    GNUNET_HELPER_stop (suid_helper);
+    GNUNET_HELPER_stop (suid_helper, GNUNET_NO);
     suid_helper = NULL;
   }
 }
 
 
 static void
-end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+end_badly (void *cls)
 {
   struct AddressWrapper *w;
   int c = 0;
-  timeout_endbadly = GNUNET_SCHEDULER_NO_TASK;
-  if (GNUNET_SCHEDULER_NO_TASK != timeout_wait)
+
+  timeout_endbadly = NULL;
+  if (NULL != timeout_wait)
   {
-      GNUNET_SCHEDULER_cancel (timeout_wait);
-      timeout_wait = GNUNET_SCHEDULER_NO_TASK;
+    GNUNET_SCHEDULER_cancel (timeout_wait);
+    timeout_wait = NULL;
   }
 
   if (pretty_printers_running > 0)
   {
-      timeout_endbadly = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS, &end_badly, &ok);
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                _("Have pending calls to pretty_printer ... deferring shutdown\n"));
-      return;
+    timeout_endbadly = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+        &end_badly, &ok);
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+        "Have pending calls to pretty_printer ... deferring shutdown\n");
+    return;
   }
 
   if (NULL != cls)
   {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Test took too long to execute, timeout .... \n"));
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+        "Test took too long to execute, timeout .... \n");
   }
 
   if (NULL != libname)
   {
     if (NULL != api)
       GNUNET_PLUGIN_unload (libname, api);
-    GNUNET_free (libname);
+    GNUNET_free(libname);
     libname = NULL;
   }
 
   while (NULL != head)
   {
-      w = head;
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Plugin did not remove address `%s' \n"), w->addrstring);
-      GNUNET_CONTAINER_DLL_remove (head, tail, w);
-      c ++;
-      GNUNET_free (w->addr);
-      GNUNET_free (w->addrstring);
-      GNUNET_free (w);
+    w = head;
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Plugin did not remove address `%s'\n",
+        w->addrstring);
+    GNUNET_CONTAINER_DLL_remove(head, tail, w);
+    c++;
+    GNUNET_HELLO_address_free(w->address);
+    if (NULL != w->test_task)
+      GNUNET_SCHEDULER_cancel (w->test_task);
+    GNUNET_free(w->addrstring);
+    GNUNET_free(w);
   }
   if (c > 0)
   {
-    GNUNET_break (0);
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              _("Plugin did not remove %u addresses \n"), c);
+    GNUNET_break(0);
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Plugin did not remove %u addresses\n",
+        c);
   }
 
   if (NULL != stats)
@@ -252,21 +247,20 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   if (NULL != suid_helper)
   {
-    GNUNET_HELPER_stop (suid_helper);
+    GNUNET_HELPER_stop (suid_helper, GNUNET_NO);
     suid_helper = NULL;
   }
 
   ok = 1;
 }
 
-
 static void
-wait_end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+wait_end (void *cls)
 {
-  timeout_wait = GNUNET_SCHEDULER_NO_TASK;
+  timeout_wait = NULL;
   if (0 == addresses_reported)
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              _("Plugin did not report any addresses, could not check address conversion functions\n"));
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+        "Plugin did not report any addresses, could not check address conversion functions\n");
   end ();
 }
 
@@ -274,35 +268,30 @@ wait_end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 end_badly_now ()
 {
-  if (GNUNET_SCHEDULER_NO_TASK != timeout_wait)
+  if (NULL != timeout_wait)
   {
-      GNUNET_SCHEDULER_cancel (timeout_wait);
-      timeout_wait = GNUNET_SCHEDULER_NO_TASK;
+    GNUNET_SCHEDULER_cancel (timeout_wait);
+    timeout_wait = NULL;
   }
-  if (GNUNET_SCHEDULER_NO_TASK != timeout_endbadly)
+  if (NULL != timeout_endbadly)
   {
-      GNUNET_SCHEDULER_cancel (timeout_endbadly);
-      timeout_endbadly = GNUNET_SCHEDULER_NO_TASK;
+    GNUNET_SCHEDULER_cancel (timeout_endbadly);
+    timeout_endbadly = NULL;
   }
-  timeout_endbadly = GNUNET_SCHEDULER_add_now (&end_badly, NULL);
+  timeout_endbadly = GNUNET_SCHEDULER_add_now (&end_badly, NULL );
 }
 
 
 static struct GNUNET_TIME_Relative
 env_receive (void *cls,
-            const struct GNUNET_PeerIdentity *peer,
-            const struct GNUNET_MessageHeader *message,
-            const struct GNUNET_ATS_Information *ats,
-            uint32_t ats_count,
-            struct Session * session,
-            const char *sender_address,
-            uint16_t sender_address_len)
+             const struct GNUNET_HELLO_Address *address,
+             struct GNUNET_ATS_Session *session,
+             const struct GNUNET_MessageHeader *message)
 {
   /* do nothing */
-  return GNUNET_TIME_relative_get_zero_();
+  return GNUNET_TIME_relative_get_zero_ ();
 }
 
-
 static int got_reply;
 
 
@@ -310,162 +299,214 @@ static int got_reply;
  * Take the given address and append it to the set of results sent back to
  * the client.
  *
- * @param cls the transmission context used ('struct GNUNET_SERVER_TransmitContext*')
- * @param buf text to transmit
+ * @param cls closure
+ * @param address the address to print
+ * @param res result code
  */
 static void
-address_pretty_printer_cb (void *cls, const char *buf)
+address_pretty_printer_cb (void *cls, const char *address, int res)
 {
-  if (NULL != buf)
+  if (NULL != address)
   {
     got_reply = GNUNET_YES;
-    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                "Pretty address : `%s'\n", buf);
-    pretty_printers_running --;
+    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Pretty address : `%s'\n", address);
+    pretty_printers_running--;
   }
   else
   {
-      if (GNUNET_NO == got_reply)
-      {
-          pretty_printers_running --;
-          GNUNET_break (0);
-          end_badly_now ();
-      }
+    if (GNUNET_NO == got_reply)
+    {
+      pretty_printers_running--;
+      GNUNET_break(0);
+      end_badly_now ();
+    }
   }
 }
 
 
 static void
-env_notify_address (void *cls,
-                    int add_remove,
-                    const void *addr,
-                    size_t addrlen,
-                    const char *plugin)
+test_addr_string (void *cls)
 {
-  struct AddressWrapper *w;
-  char *a2s;
+  struct AddressWrapper *w = cls;
   void *s2a;
   size_t s2a_len;
 
-  if (GNUNET_YES == add_remove)
+  w->test_task = NULL;
+
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Testing: address_to_string \n");
+  w->addrstring = GNUNET_strdup (api->address_to_string (api,
+                                                         w->address->address,
+                                                         w->address->address_length));
+  if (NULL == w->addrstring)
   {
-      addresses_reported ++;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Adding address of length %u\n"), addrlen);
-
-      w = GNUNET_malloc (sizeof (struct AddressWrapper));
-      w->addr = GNUNET_malloc (addrlen);
-      w->addrlen = addrlen;
-      memcpy (w->addr, addr, addrlen);
-      GNUNET_CONTAINER_DLL_insert(head, tail, w);
-      got_reply = GNUNET_NO;
-      pretty_printers_running ++;
-      api->address_pretty_printer (api->cls, plugin, addr, addrlen,
-                                    GNUNET_YES, GNUNET_TIME_UNIT_MINUTES,
-                                    &address_pretty_printer_cb,
-                                    w);
-
-      a2s = strdup (api->address_to_string (api, w->addr, w->addrlen));
-      if (NULL == a2s)
-      {
-          GNUNET_break (0);
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Plugin cannot convert address to string!\n"));
-          end_badly_now();
-          return;
-      }
-      w->addrstring = strdup (api->address_to_string (api, w->addr, w->addrlen));
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Plugin added address `%s'\n"), a2s);
+    GNUNET_break(0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Plugin cannot convert address to string!\n");
+    end_badly_now ();
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Plugin added address `%s'\n",
+              w->addrstring);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Testing address_to_string: OK\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "Testing: string_to_address \n");
+  s2a = NULL;
+  s2a_len = 0;
+  if ((GNUNET_OK !=
+       api->string_to_address (api, w->addrstring,
+                               strlen (w->addrstring) + 1,
+                               &s2a, &s2a_len)) ||
+      (NULL == s2a))
+  {
+    GNUNET_break(0);
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+               "Plugin cannot convert string to address!\n");
+    end_badly_now ();
+    return;
+  }
 
-      if ((GNUNET_OK != api->string_to_address (api, a2s, strlen (a2s)+1, &s2a, &s2a_len)) || (NULL == s2a))
-      {
-          GNUNET_break (0);
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Plugin cannot convert string to address!\n"));
-          end_badly_now();
-          return;
-      }
+  /*
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+    "Plugin creates `%s' %u\n",api->address_to_string (api, s2a, s2a_len), s2a_len);
 
-      if (s2a_len != w->addrlen)
-      {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Plugin creates different address length when converting address->string->address: %u != %u\n"), w->addrlen, s2a_len);
-      }
-      else
-      {
-          if (0 != memcmp (s2a, w->addr, s2a_len))
-            GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                        _("Plugin creates different address length when connecting back and forth!\n"));
-      }
-      GNUNET_free (s2a);
-      GNUNET_free (a2s);
-      if (GNUNET_OK != api->check_address (api->cls, w->addr, w->addrlen))
-      {
-          GNUNET_break (0);
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Plugin refuses added address!\n"));
-          end_badly_now();
-          return;
-      }
-      if (GNUNET_SCHEDULER_NO_TASK != timeout_wait)
-      {
-          GNUNET_SCHEDULER_cancel (timeout_wait);
-          timeout_wait = GNUNET_SCHEDULER_NO_TASK;
-      }
+    int c1;
+    for (c1 = 0; c1 < s2a_len; c1++ )
+    fprintf (stderr, "%u == %u\n", ((char *) s2a)[c1], ((char *) w->addr)[c1]);
+  */
+  if (s2a_len != w->address->address_length)
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+               "Plugin creates different address length when converting address->string->address: %u != %u\n",
+               (unsigned int) w->address->address_length,
+               (unsigned int) s2a_len);
+  }
+  else if (0 != memcmp (s2a, w->address->address, s2a_len))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Plugin creates different address length when converting back and forth %i!\n",
+                memcmp (s2a,
+                        w->address->address,
+                        s2a_len));
+  }
+  else
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                "Testing string_to_address: OK\n");
+  }
+  GNUNET_free(s2a);
 
-      timeout_wait = GNUNET_SCHEDULER_add_delayed (WAIT, &wait_end, NULL);
+  pretty_printers_running++;
+  api->address_pretty_printer (api->cls,
+                               w->address->transport_name,
+                               w->address->address,
+                               w->address->address_length,
+                               GNUNET_YES,
+                               GNUNET_TIME_UNIT_MINUTES,
+                               &address_pretty_printer_cb, w);
 
+  if (GNUNET_OK !=
+      api->check_address (api->cls,
+                          w->address->address,
+                          w->address->address_length))
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Plugin refuses added address!\n");
+    end_badly_now ();
+    return;
   }
-  else if (GNUNET_NO == add_remove)
+  if (NULL != timeout_wait)
   {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  _("Removing address of length %u\n"), addrlen);
+    GNUNET_SCHEDULER_cancel (timeout_wait);
+    timeout_wait = NULL;
+  }
+  timeout_wait = GNUNET_SCHEDULER_add_delayed (WAIT, &wait_end, NULL);
+}
 
-      w = head;
-      while (NULL != w)
-      {
-          if ((addrlen == w->addrlen) && (0 == memcmp (w->addr, addr, addrlen)))
-          {
-            break;
-          }
-          w = w->next;
-      }
 
-      if (w == NULL)
+static void
+env_notify_address (void *cls,
+                    int add_remove,
+                    const struct GNUNET_HELLO_Address *address)
+{
+  struct AddressWrapper *w;
+  struct AddressWrapper *wtmp;
+
+  if (GNUNET_YES == add_remove)
+  {
+    addresses_reported++;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+               "Adding address of length %u\n",
+                (unsigned int) address->address_length);
+
+    for (wtmp = head; NULL != wtmp; wtmp = wtmp->next)
+    {
+      if ((address->address_length == wtmp->address->address_length) &&
+          (0 == memcmp (address->address, wtmp->address->address, address->address_length)))
       {
-          GNUNET_break (0);
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Plugin removes address never added!\n"));
-          end_badly_now();
-          return;
+        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                   "Duplicate address notification .... \n");
+        return;
       }
-
-      GNUNET_CONTAINER_DLL_remove (head, tail, w);
-      GNUNET_free (w->addr);
-      GNUNET_free (w->addrstring);
-      GNUNET_free (w);
+    }
+
+    w = GNUNET_new (struct AddressWrapper);
+    w->address = GNUNET_HELLO_address_copy (address);
+    GNUNET_CONTAINER_DLL_insert (head, tail, w);
+    got_reply = GNUNET_NO;
+    w->test_task = GNUNET_SCHEDULER_add_now (&test_addr_string,
+                                             w);
+    return;
   }
-  else
+
+  if (GNUNET_NO == add_remove)
   {
-      GNUNET_break (0);
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Invalid operation: %u \n"), add_remove);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Removing address of length %u\n",
+                (unsigned int) address->address_length);
+    w = head;
+    while (NULL != w)
+    {
+      if ((address->address_length == w->address->address_length) &&
+          (0 == memcmp (w->address->address, address->address, address->address_length)))
+      {
+        break;
+      }
+      w = w->next;
+    }
+
+    if (w == NULL)
+    {
+      GNUNET_break(0);
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+          "Plugin removes address never added!\n");
       end_badly_now ();
       return;
+    }
+
+    GNUNET_CONTAINER_DLL_remove(head, tail, w);
+    GNUNET_HELLO_address_free (w->address);
+    GNUNET_free(w->addrstring);
+    GNUNET_free(w);
+    return;
   }
+  GNUNET_break(0);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Invalid operation: %u\n",
+              add_remove);
+  end_badly_now ();
 }
 
 
-static struct GNUNET_ATS_Information
+static enum GNUNET_ATS_Network_Type
 env_get_address_type (void *cls,
-                     const struct sockaddr *addr,
-                     size_t addrlen)
+                      const struct sockaddr *addr,
+                      size_t addrlen)
 {
-  struct GNUNET_ATS_Information ats;
-  ats.type = htonl (GNUNET_ATS_NETWORK_TYPE);
-  ats.value = htonl (GNUNET_ATS_NET_LOOPBACK);
-  return ats;
+  return GNUNET_ATS_NET_LOOPBACK;
 }
 
 
@@ -476,10 +517,19 @@ env_get_our_hello ()
 }
 
 
-static void 
+static void
 env_session_end (void *cls,
-		 const struct GNUNET_PeerIdentity *peer,
-		 struct Session * session)
+                 const struct GNUNET_HELLO_Address *address,
+                 struct GNUNET_ATS_Session *session)
+{
+
+}
+
+
+static void
+env_update_distance (void *cls,
+                     const struct GNUNET_HELLO_Address *address,
+                     uint32_t distance)
 {
 }
 
@@ -492,16 +542,17 @@ setup_plugin_environment ()
   env.my_identity = &my_identity;
   env.max_connections = max_connect_per_transport;
   env.stats = stats;
-
   env.receive = &env_receive;
   env.notify_address = &env_notify_address;
   env.get_address_type = &env_get_address_type;
+  env.update_address_distance = &env_update_distance;
   env.get_our_hello = &env_get_our_hello;
   env.session_end = &env_session_end;
 }
 
+
 static int
-handle_helper_message (void *cls, void *client,
+handle_helper_message (void *cls,
                        const struct GNUNET_MessageHeader *hdr)
 {
   return GNUNET_OK;
@@ -515,10 +566,10 @@ handle_helper_message (void *cls, void *client,
  * @param c configuration to use
  */
 static void
-run (void *cls, char *const *args, const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+run (void *cls, char * const *args, const char *cfgfile,
+    const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  char *const *argv = cls;
+  char * const *argv = cls;
   unsigned long long tneigh;
   char *keyfile;
   char *plugin;
@@ -528,85 +579,84 @@ run (void *cls, char *const *args, const char *cfgfile,
 
   cfg = c;
   /* parse configuration */
-  if ( (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (c,
-							    "TRANSPORT",
-							    "NEIGHBOUR_LIMIT",
-							    &tneigh)) ||
-       (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (c,
-							      "GNUNETD", "HOSTKEY",
-							      &keyfile)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Transport service is lacking key configuration settings.  Exiting.\n"));
+  if ((GNUNET_OK
+      != GNUNET_CONFIGURATION_get_value_number (c, "TRANSPORT",
+          "NEIGHBOUR_LIMIT", &tneigh))
+      || (GNUNET_OK
+          != GNUNET_CONFIGURATION_get_value_filename (c, "PEER", "PRIVATE_KEY",
+              &keyfile)))
+  {
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+        "Transport service is lacking key configuration settings.  Exiting.\n");
     return;
   }
 
   if (NULL == (stats = GNUNET_STATISTICS_create ("transport", cfg)))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-		_("Could not create statistics.  Exiting.\n"));
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+        "Could not create statistics.  Exiting.\n");
+    GNUNET_free(keyfile);
     end_badly_now ();
     return;
   }
 
   if (GNUNET_OK != GNUNET_DISK_file_test (HOSTKEY_FILE))
   {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Hostkey `%s' missing.  Exiting.\n"),
-                  HOSTKEY_FILE);
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Hostkey `%s' missing.  Exiting.\n",
+        HOSTKEY_FILE);
+    GNUNET_free(keyfile);
+    end_badly_now ();
+    return;
   }
 
   if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (keyfile))
   {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not create a directory for hostkey `%s'.  Exiting.\n"),
-                  keyfile);
-      end_badly_now ();
-      return;
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+        "Could not create a directory for hostkey `%s'.  Exiting.\n", keyfile);
+    GNUNET_free(keyfile);
+    end_badly_now ();
+    return;
   }
 
-  if (GNUNET_OK !=  GNUNET_DISK_file_copy (HOSTKEY_FILE, keyfile))
+  if (GNUNET_OK != GNUNET_DISK_file_copy (HOSTKEY_FILE, keyfile))
   {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not copy hostkey `%s' to destination `%s'.  Exiting.\n"),
-                  HOSTKEY_FILE, keyfile);
-      end_badly_now ();
-      return;
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+        "Could not copy hostkey `%s' to destination `%s'.  Exiting.\n",
+        HOSTKEY_FILE, keyfile);
+    GNUNET_free(keyfile);
+    end_badly_now ();
+    return;
   }
 
-
   max_connect_per_transport = (uint32_t) tneigh;
-  my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
-  GNUNET_free (keyfile);
+  my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile);
+  GNUNET_free(keyfile);
   if (NULL == my_private_key)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Transport service could not access hostkey.  Exiting.\n"));
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+        "Could not access hostkey.  Exiting.\n");
     end_badly_now ();
     return;
   }
-  GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
-  GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key),
-                      &my_identity.hashPubKey);
+  GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_identity.public_key);
 
-
-  hello = GNUNET_HELLO_create(&my_public_key, NULL, NULL);
+  hello = GNUNET_HELLO_create (&my_identity.public_key, NULL, NULL, GNUNET_NO);
 
   /* load plugins... */
   setup_plugin_environment ();
 
-  GNUNET_assert (strlen (argv[0]) > strlen ("test_plugin_"));
-  plugin = strstr(argv[0],"test_plugin_");
-  sep = strrchr(argv[0],'.');
+  GNUNET_assert(strlen (argv[0]) > strlen ("test_plugin_"));
+  plugin = strstr (argv[0], "test_plugin_");
+  sep = strrchr (argv[0], '.');
   if (NULL == plugin)
   {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Not a valid test name\n"));
-      end_badly_now ();
-      return;
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Not a valid test name\n");
+    end_badly_now ();
+    return;
   }
   plugin += strlen ("test_plugin_");
   if (NULL != sep)
-      sep[0] = '\0';
+    sep[0] = '\0';
 
   /* Hack for WLAN: start a second helper */
   if (0 == strcmp (plugin, "wlan"))
@@ -616,77 +666,73 @@ run (void *cls, char *const *args, const char *cfgfile,
     helper_argv[1] = (char *) "2";
     helper_argv[2] = NULL;
     suid_helper = GNUNET_HELPER_start (GNUNET_NO,
-				       "gnunet-helper-transport-wlan-dummy",
-                                       helper_argv,
-                                       &handle_helper_message,
-                                       NULL,
-                                       NULL);
+        "gnunet-helper-transport-wlan-dummy", helper_argv,
+        &handle_helper_message, NULL, NULL );
   }
 
   /* Loading plugin */
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Loading transport plugin %s\n"), plugin);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Loading transport plugin %s\n", plugin);
   GNUNET_asprintf (&libname, "libgnunet_plugin_transport_%s", plugin);
   api = GNUNET_PLUGIN_load (libname, &env);
-  if (api == NULL)
+  if (NULL == api)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to load transport plugin for %s\n"), plugin);
+    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+        "Failed to load transport plugin for %s\n", plugin);
     end_badly_now ();
     return;
   }
 
-  timeout_wait = GNUNET_SCHEDULER_add_delayed (WAIT, &wait_end, NULL);
+  timeout_wait = GNUNET_SCHEDULER_add_delayed (WAIT, &wait_end, NULL );
 
   /* Check if all functions are implemented */
   if (NULL == api->address_pretty_printer)
   {
-      GNUNET_break (0);
-      end_badly_now ();
-      return;
+    GNUNET_break(0);
+    end_badly_now ();
+    return;
   }
   if (NULL == api->address_to_string)
   {
-      GNUNET_break (0);
-      end_badly_now ();
-      return;
+    GNUNET_break(0);
+    end_badly_now ();
+    return;
   }
-  GNUNET_assert (NULL != api->check_address);
+  GNUNET_assert(NULL != api->check_address);
   if (NULL == api->check_address)
   {
-      GNUNET_break (0);
-      end_badly_now ();
-      return;
+    GNUNET_break(0);
+    end_badly_now ();
+    return;
   }
-  GNUNET_assert (NULL != api->disconnect);
-  if (NULL == api->disconnect)
+  GNUNET_assert(NULL != api->disconnect_peer);
+  if (NULL == api->disconnect_peer)
   {
-      GNUNET_break (0);
-      end_badly_now ();
-      return;
+    GNUNET_break(0);
+    end_badly_now ();
+    return;
   }
-  GNUNET_assert (NULL != api->get_session);
+  GNUNET_assert(NULL != api->get_session);
   if (NULL == api->get_session)
   {
-      GNUNET_break (0);
-      end_badly_now ();
-      return;
+    GNUNET_break(0);
+    end_badly_now ();
+    return;
   }
   if (NULL == api->address_pretty_printer)
   {
-      GNUNET_break (0);
-      end_badly_now ();
-      return;
+    GNUNET_break(0);
+    end_badly_now ();
+    return;
   }
   if (NULL == api->string_to_address)
   {
-      GNUNET_break (0);
-      end_badly_now ();
-      return;
+    GNUNET_break(0);
+    end_badly_now ();
+    return;
   }
 
 }
 
-
 /**
  * The main function for the test
  *
@@ -695,32 +741,22 @@ run (void *cls, char *const *args, const char *cfgfile,
  * @return 0 ok, 1 on error
  */
 int
-main (int argc, char *const *argv)
+main (int argc, char * const *argv)
 {
   static struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_OPTION_END
-  };
+      GNUNET_GETOPT_OPTION_END };
   int ret;
 
   GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-plugin-transport");
 
-  char *const argv_prog[] = {
-    "test_plugin_transport",
-    "-c",
-    "test_plugin_transport_data.conf",
-    NULL
-  };
-  GNUNET_log_setup ("test-plugin-transport",
-                    "WARNING",
-                    NULL);
-  ok = 1;                       /* set to fail */
-  ret = (GNUNET_OK == GNUNET_PROGRAM_run (3,
-					  argv_prog,
-					  "test-plugin-transport",
-					  "testcase",
-					  options,
-					  &run,
-					  (void *) argv)) ? ok : 1;
+  char * const argv_prog[] = { "test_plugin_transport", "-c",
+      "test_plugin_transport_data.conf", NULL };
+  GNUNET_log_setup ("test-plugin-transport", "WARNING", NULL );
+  ok = 1; /* set to fail */
+  ret =
+      (GNUNET_OK
+          == GNUNET_PROGRAM_run (3, argv_prog, "test-plugin-transport",
+              "testcase", options, &run, (void *) argv)) ? ok : 1;
   GNUNET_DISK_directory_remove ("/tmp/test-gnunetd-plugin-transport");
   return ret;
 }