fixing API and clean up issues in testing

[oweals/gnunet.git] / src / topology / gnunet-daemon-topology.c

diff --git a/src/topology/gnunet-daemon-topology.c b/src/topology/gnunet-daemon-topology.c
index 7ebd43ab9c22f7cf4c585030509ee197c63318bc..55ee36fd2fe1b9e06091466c7bd7195c618893cd 100644 (file)
--- a/src/topology/gnunet-daemon-topology.c
+++ b/src/topology/gnunet-daemon-topology.c
@@ -4,7 +4,7 @@
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
 
      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 2, or (at your
+     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
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but


@@ -35,7 +35,7 @@
 #include "gnunet_util_lib.h"
 
 
 #include "gnunet_util_lib.h"
 
 

-#define DEBUG_TOPOLOGY GNUNET_NO
+#define DEBUG_TOPOLOGY GNUNET_YES

 
 /**
  * For how long do we blacklist a peer after a failed connection
 
 /**
  * For how long do we blacklist a peer after a failed connection


@@ -59,7 +59,7 @@
  * For how long do we blacklist anyone under any cirumstances after a failed connection
  * attempt?
  */
  * For how long do we blacklist anyone under any cirumstances after a failed connection
  * attempt?
  */

-#define GREYLIST_AFTER_ATTEMPT_MAX GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 18)
+#define GREYLIST_AFTER_ATTEMPT_MAX GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 1)

 
 /**
  * How often do we at most advertise any HELLO to a peer?
 
 /**
  * How often do we at most advertise any HELLO to a peer?


@@ -86,13 +86,13 @@ struct Peer
    * Our handle for the request to transmit HELLOs to this peer; NULL
    * if no such request is pending.
    */
    * Our handle for the request to transmit HELLOs to this peer; NULL
    * if no such request is pending.
    */

-  struct GNUNET_CORE_TransmitHandle *hello_req;  
+  struct GNUNET_CORE_TransmitHandle *hello_req;

 
   /**
    * Our handle for the request to connect to this peer; NULL if no
    * such request is pending.
    */
 
   /**
    * Our handle for the request to connect to this peer; NULL if no
    * such request is pending.
    */

-  struct GNUNET_CORE_PeerRequestHandle *connect_req;  
+  struct GNUNET_CORE_PeerRequestHandle *connect_req;

 
   /**
    * Pointer to the HELLO message of this peer; can be NULL.
 
   /**
    * Pointer to the HELLO message of this peer; can be NULL.


@@ -156,11 +156,6 @@ struct Peer
  */
 static struct GNUNET_PEERINFO_NotifyContext *peerinfo_notify;
 
  */
 static struct GNUNET_PEERINFO_NotifyContext *peerinfo_notify;
 

-/**
- * Our scheduler.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
-

 /**
  * Our configuration.
  */
 /**
  * Our configuration.
  */


@@ -198,6 +193,11 @@ static struct GNUNET_STATISTICS_Handle *stats;
  */
 static struct GNUNET_TRANSPORT_Blacklist *blacklist;
 
  */
 static struct GNUNET_TRANSPORT_Blacklist *blacklist;
 

+/**
+ * Task scheduled to try to add peers.
+ */
+static GNUNET_SCHEDULER_TaskIdentifier add_task;
+

 /**
  * Flag to disallow non-friend connections (pure F2F mode).
  */
 /**
  * Flag to disallow non-friend connections (pure F2F mode).
  */


@@ -231,7 +231,7 @@ static int autoconnect;
 
 
 /**
 
 
 /**

- * Function that decides if a connection is acceptable or not.  
+ * Function that decides if a connection is acceptable or not.

  * If we have a blacklist, only friends are allowed, so the check
  * is rather simple.
  *
  * If we have a blacklist, only friends are allowed, so the check
  * is rather simple.
  *


@@ -240,19 +240,15 @@ static int autoconnect;
  * @return GNUNET_OK if the connection is allowed
  */
 static int
  * @return GNUNET_OK if the connection is allowed
  */
 static int

-blacklist_check (void *cls,
-                const struct GNUNET_PeerIdentity *pid)
+blacklist_check (void *cls, const struct GNUNET_PeerIdentity *pid)

 {
   struct Peer *pos;
 
   pos = GNUNET_CONTAINER_multihashmap_get (peers, &pid->hashPubKey);
 {
   struct Peer *pos;
 
   pos = GNUNET_CONTAINER_multihashmap_get (peers, &pid->hashPubKey);

-  if ( (pos != NULL) &&
-       (pos->is_friend == GNUNET_YES) )
+  if ((pos != NULL) && (pos->is_friend == GNUNET_YES))

     return GNUNET_OK;
     return GNUNET_OK;

-  GNUNET_STATISTICS_update (stats,
-                           gettext_noop ("# peers blacklisted"),
-                           1,
-                           GNUNET_NO);
+  GNUNET_STATISTICS_update (stats, gettext_noop ("# peers blacklisted"), 1,
+                            GNUNET_NO);

   return GNUNET_SYSERR;
 }
 
   return GNUNET_SYSERR;
 }
 


@@ -265,22 +261,21 @@ static void
 whitelist_peers ()
 {
   if (blacklist != NULL)
 whitelist_peers ()
 {
   if (blacklist != NULL)

-    {
-      GNUNET_TRANSPORT_blacklist_cancel (blacklist);
-      blacklist = NULL;
-    }
+  {
+    GNUNET_TRANSPORT_blacklist_cancel (blacklist);
+    blacklist = NULL;
+  }

 }
 
 
 /**
 }
 
 
 /**

- * Function called by core when our attempt to connect succeeded.
+ * Function called by core when our request to connect was transmitted.

  *
  * @param cls the 'struct Peer' for which we issued the connect request
  *
  * @param cls the 'struct Peer' for which we issued the connect request

- * @param tc scheduler context
+ * @param success was the request transmitted

  */
 static void
  */
 static void

-connect_completed_callback (void *cls,
-                           const struct GNUNET_SCHEDULER_TaskContext *tc)
+connect_completed_callback (void *cls, int success)

 {
   struct Peer *pos = cls;
 
 {
   struct Peer *pos = cls;
 


@@ -290,35 +285,34 @@ connect_completed_callback (void *cls,
 
 /**
  * Check if an additional connection from the given peer is allowed.
 
 /**
  * Check if an additional connection from the given peer is allowed.

- * 
+ *

  * @param peer connection to check
  * @return GNUNET_OK if the connection is allowed
  */
 static int
 is_connection_allowed (struct Peer *peer)
 {
  * @param peer connection to check
  * @return GNUNET_OK if the connection is allowed
  */
 static int
 is_connection_allowed (struct Peer *peer)
 {

-  if (0 == memcmp (&my_identity, 
-                  &peer->pid, 
-                  sizeof (struct GNUNET_PeerIdentity)))
+  if (0 ==
+      memcmp (&my_identity, &peer->pid, sizeof (struct GNUNET_PeerIdentity)))

     return GNUNET_SYSERR;       /* disallow connections to self */
   if (peer->is_friend)
     return GNUNET_OK;
   if (GNUNET_YES == friends_only)
     return GNUNET_SYSERR;       /* disallow connections to self */
   if (peer->is_friend)
     return GNUNET_OK;
   if (GNUNET_YES == friends_only)

-    {
+  {

 #if DEBUG_TOPOLOGY
 #if DEBUG_TOPOLOGY

-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                 "Determined that `%s' is not allowed to connect (not a friend)\n",
-                 GNUNET_i2s (&peer->pid));
-#endif       
-      return GNUNET_SYSERR;
-    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Determined that `%s' is not allowed to connect (not a friend)\n",
+                GNUNET_i2s (&peer->pid));
+#endif
+    return GNUNET_SYSERR;
+  }

   if (friend_count >= minimum_friend_count)
     return GNUNET_OK;
 #if DEBUG_TOPOLOGY
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
   if (friend_count >= minimum_friend_count)
     return GNUNET_OK;
 #if DEBUG_TOPOLOGY
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-             "Determined that `%s' is not allowed to connect (not enough connected friends)\n",
-             GNUNET_i2s (&peer->pid));
-#endif       
+              "Determined that `%s' is not allowed to connect (not enough connected friends)\n",
+              GNUNET_i2s (&peer->pid));
+#endif

   return GNUNET_SYSERR;
 }
 
   return GNUNET_SYSERR;
 }
 


@@ -332,27 +326,21 @@ is_connection_allowed (struct Peer *peer)
  * @return GNUNET_YES (always: continue to iterate)
  */
 static int
  * @return GNUNET_YES (always: continue to iterate)
  */
 static int

-free_peer (void *cls,
-          const GNUNET_HashCode *pid,
-          void *value)
+free_peer (void *cls, const GNUNET_HashCode * pid, void *value)

 {
   struct Peer *pos = value;
 
 {
   struct Peer *pos = value;
 

-  GNUNET_break (GNUNET_OK == 
-               GNUNET_CONTAINER_multihashmap_remove (peers,
-                                                     pid,
-                                                     pos));
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CONTAINER_multihashmap_remove (peers, pid, pos));

   if (pos->hello_req != NULL)
     GNUNET_CORE_notify_transmit_ready_cancel (pos->hello_req);
   if (pos->connect_req != NULL)
   if (pos->hello_req != NULL)
     GNUNET_CORE_notify_transmit_ready_cancel (pos->hello_req);
   if (pos->connect_req != NULL)

-    GNUNET_CORE_peer_request_connect_cancel (pos->connect_req);              
+    GNUNET_CORE_peer_request_connect_cancel (pos->connect_req);

   if (pos->hello_delay_task != GNUNET_SCHEDULER_NO_TASK)
   if (pos->hello_delay_task != GNUNET_SCHEDULER_NO_TASK)

-    GNUNET_SCHEDULER_cancel (sched,
-                            pos->hello_delay_task);
+    GNUNET_SCHEDULER_cancel (pos->hello_delay_task);

   if (pos->greylist_clean_task != GNUNET_SCHEDULER_NO_TASK)
   if (pos->greylist_clean_task != GNUNET_SCHEDULER_NO_TASK)

-    GNUNET_SCHEDULER_cancel (sched,
-                            pos->greylist_clean_task);
-  GNUNET_free_non_null (pos->hello);   
+    GNUNET_SCHEDULER_cancel (pos->greylist_clean_task);
+  GNUNET_free_non_null (pos->hello);

   if (pos->filter != NULL)
     GNUNET_CONTAINER_bloomfilter_free (pos->filter);
   GNUNET_free (pos);
   if (pos->filter != NULL)
     GNUNET_CONTAINER_bloomfilter_free (pos->filter);
   GNUNET_free (pos);


@@ -368,8 +356,7 @@ free_peer (void *cls,
  * @param tc scheduler context
  */
 static void
  * @param tc scheduler context
  */
 static void

-remove_from_greylist (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc);
+remove_from_greylist (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);

 
 
 /**
 
 
 /**


@@ -381,15 +368,15 @@ static void
 attempt_connect (struct Peer *pos)
 {
   struct GNUNET_TIME_Relative rem;
 attempt_connect (struct Peer *pos)
 {
   struct GNUNET_TIME_Relative rem;

-  
-  if ( (connection_count >= target_connection_count) &&
-       (friend_count >= minimum_friend_count) )
+
+  if ((connection_count >= target_connection_count) &&
+      (friend_count >= minimum_friend_count))

     return;
   if (GNUNET_YES == pos->is_connected)
     return;
   if (GNUNET_OK != is_connection_allowed (pos))
     return;
     return;
   if (GNUNET_YES == pos->is_connected)
     return;
   if (GNUNET_OK != is_connection_allowed (pos))
     return;

-  if (GNUNET_TIME_absolute_get_remaining (pos->greylisted_until).value > 0)
+  if (GNUNET_TIME_absolute_get_remaining (pos->greylisted_until).rel_value > 0)

     return;
   if (GNUNET_YES == pos->is_friend)
     rem = GREYLIST_AFTER_ATTEMPT_FRIEND;
     return;
   if (GNUNET_YES == pos->is_friend)
     rem = GREYLIST_AFTER_ATTEMPT_FRIEND;


@@ -400,33 +387,23 @@ attempt_connect (struct Peer *pos)
   if (pos->connect_attempts > 30)
     pos->connect_attempts = 30;
   rem = GNUNET_TIME_relative_multiply (rem, 1 << (++pos->connect_attempts));
   if (pos->connect_attempts > 30)
     pos->connect_attempts = 30;
   rem = GNUNET_TIME_relative_multiply (rem, 1 << (++pos->connect_attempts));

-  rem = GNUNET_TIME_relative_max (rem,
-                                 GREYLIST_AFTER_ATTEMPT_MIN);
-  rem = GNUNET_TIME_relative_min (rem,
-                                 GREYLIST_AFTER_ATTEMPT_MAX);
+  rem = GNUNET_TIME_relative_max (rem, GREYLIST_AFTER_ATTEMPT_MIN);
+  rem = GNUNET_TIME_relative_min (rem, GREYLIST_AFTER_ATTEMPT_MAX);

   pos->greylisted_until = GNUNET_TIME_relative_to_absolute (rem);
   if (pos->greylist_clean_task != GNUNET_SCHEDULER_NO_TASK)
   pos->greylisted_until = GNUNET_TIME_relative_to_absolute (rem);
   if (pos->greylist_clean_task != GNUNET_SCHEDULER_NO_TASK)

-    GNUNET_SCHEDULER_cancel (sched,
-                            pos->greylist_clean_task);
-  pos->greylist_clean_task 
-    = GNUNET_SCHEDULER_add_delayed (sched,
-                                   rem,
-                                   &remove_from_greylist,
-                                   pos);
+    GNUNET_SCHEDULER_cancel (pos->greylist_clean_task);
+  pos->greylist_clean_task =
+      GNUNET_SCHEDULER_add_delayed (rem, &remove_from_greylist, pos);

 #if DEBUG_TOPOLOGY
 #if DEBUG_TOPOLOGY

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "Asking  to connect to `%s'\n",
-             GNUNET_i2s (&pos->pid));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking  to connect to `%s'\n",
+              GNUNET_i2s (&pos->pid));

 #endif
   GNUNET_STATISTICS_update (stats,
 #endif
   GNUNET_STATISTICS_update (stats,

-                           gettext_noop ("# connect requests issued to core"),
-                           1,
-                           GNUNET_NO);
-  pos->connect_req = GNUNET_CORE_peer_request_connect (sched, cfg,
-                                                      GNUNET_TIME_UNIT_MINUTES,
-                                                      &pos->pid,
-                                                      &connect_completed_callback,
-                                                      pos);
+                            gettext_noop ("# connect requests issued to core"),
+                            1, GNUNET_NO);
+  pos->connect_req =
+      GNUNET_CORE_peer_request_connect (handle, &pos->pid,
+                                        &connect_completed_callback, pos);

 }
 
 
 }
 
 


@@ -438,32 +415,28 @@ attempt_connect (struct Peer *pos)
  * @param tc scheduler context
  */
 static void
  * @param tc scheduler context
  */
 static void

-remove_from_greylist (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+remove_from_greylist (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)

 {
   struct Peer *pos = cls;
   struct GNUNET_TIME_Relative rem;
 
   pos->greylist_clean_task = GNUNET_SCHEDULER_NO_TASK;
   rem = GNUNET_TIME_absolute_get_remaining (pos->greylisted_until);
 {
   struct Peer *pos = cls;
   struct GNUNET_TIME_Relative rem;
 
   pos->greylist_clean_task = GNUNET_SCHEDULER_NO_TASK;
   rem = GNUNET_TIME_absolute_get_remaining (pos->greylisted_until);

-  if (rem.value == 0)
-    {
-      attempt_connect (pos);
-    }
+  if (rem.rel_value == 0)
+  {
+    attempt_connect (pos);
+  }

   else
   else

-    {
-      pos->greylist_clean_task 
-       = GNUNET_SCHEDULER_add_delayed (sched,
-                                       rem,
-                                       &remove_from_greylist,
-                                       pos);
-    }
-  if ( (GNUNET_NO == pos->is_friend) &&
-       (GNUNET_NO == pos->is_connected) )
-    {
-      free_peer (NULL, &pos->pid.hashPubKey, pos);
-      return;
-    }
+  {
+    pos->greylist_clean_task =
+        GNUNET_SCHEDULER_add_delayed (rem, &remove_from_greylist, pos);
+  }
+  if ((GNUNET_NO == pos->is_friend) && (GNUNET_NO == pos->is_connected) &&
+      (NULL == pos->hello))
+  {
+    free_peer (NULL, &pos->pid.hashPubKey, pos);
+    return;
+  }

 }
 
 
 }
 
 


@@ -476,26 +449,23 @@ remove_from_greylist (void *cls,
  * @return the new entry
  */
 static struct Peer *
  * @return the new entry
  */
 static struct Peer *

-make_peer (const struct
-          GNUNET_PeerIdentity * peer,
-          const struct GNUNET_HELLO_Message *hello,
-          int is_friend)
+make_peer (const struct GNUNET_PeerIdentity *peer,
+           const struct GNUNET_HELLO_Message *hello, int is_friend)

 {
   struct Peer *ret;
 {
   struct Peer *ret;

-  
+

   ret = GNUNET_malloc (sizeof (struct Peer));
   ret->pid = *peer;
   ret->is_friend = is_friend;
   if (hello != NULL)
   ret = GNUNET_malloc (sizeof (struct Peer));
   ret->pid = *peer;
   ret->is_friend = is_friend;
   if (hello != NULL)

-    {
-      ret->hello = GNUNET_malloc (GNUNET_HELLO_size (hello));
-      memcpy (ret->hello, hello,
-             GNUNET_HELLO_size (hello));
-    }
-  GNUNET_CONTAINER_multihashmap_put (peers,
-                                    &peer->hashPubKey,
-                                    ret,
-                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  {
+    ret->hello = GNUNET_malloc (GNUNET_HELLO_size (hello));
+    memcpy (ret->hello, hello, GNUNET_HELLO_size (hello));
+  }
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CONTAINER_multihashmap_put (peers, &peer->hashPubKey,
+                                                   ret,
+                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));

   return ret;
 }
 
   return ret;
 }
 


@@ -509,14 +479,16 @@ static void
 setup_filter (struct Peer *peer)
 {
   /* 2^{-5} chance of not sending a HELLO to a peer is
 setup_filter (struct Peer *peer)
 {
   /* 2^{-5} chance of not sending a HELLO to a peer is

-     acceptably small (if the filter is 50% full);
-     64 bytes of memory are small compared to the rest
-     of the data structure and would only really become
-     "useless" once a HELLO has been passed on to ~100
-     other peers, which is likely more than enough in
-     any case; hence 64, 5 as bloomfilter parameters. */
-  peer->filter = GNUNET_CONTAINER_bloomfilter_load (NULL, 64, 5);
-  peer->filter_expiration = GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY);
+   * acceptably small (if the filter is 50% full);
+   * 64 bytes of memory are small compared to the rest
+   * of the data structure and would only really become
+   * "useless" once a HELLO has been passed on to ~100
+   * other peers, which is likely more than enough in
+   * any case; hence 64, 5 as bloomfilter parameters. */
+  peer->filter = GNUNET_CONTAINER_bloomfilter_init (NULL, 64, 5);
+  peer->filter_expiration =
+      GNUNET_TIME_relative_to_absolute
+      (HELLO_ADVERTISEMENT_MIN_REPEAT_FREQUENCY);

   /* never send a peer its own HELLO */
   GNUNET_CONTAINER_bloomfilter_add (peer->filter, &peer->pid.hashPubKey);
 }
   /* never send a peer its own HELLO */
   GNUNET_CONTAINER_bloomfilter_add (peer->filter, &peer->pid.hashPubKey);
 }


@@ -531,17 +503,14 @@ setup_filter (struct Peer *peer)
  * @return number of bytes written to buf
  */
 static size_t
  * @return number of bytes written to buf
  */
 static size_t

-hello_advertising_ready (void *cls,
-                        size_t size,
-                        void *buf);
-
-
+hello_advertising_ready (void *cls, size_t size, void *buf);

 
 
 /**
  * Closure for 'find_advertisable_hello'.
  */
 
 
 /**
  * Closure for 'find_advertisable_hello'.
  */

-struct FindAdvHelloContext {
+struct FindAdvHelloContext
+{

 
   /**
    * Peer we want to advertise to.
 
   /**
    * Peer we want to advertise to.


@@ -567,13 +536,11 @@ struct FindAdvHelloContext {
  *
  * @param cls closure
  * @param pid identity of a peer
  *
  * @param cls closure
  * @param pid identity of a peer

- * @param value 'struct Peer*' for the peer we are considering 
+ * @param value 'struct Peer*' for the peer we are considering

  * @return GNUNET_YES (continue iteration)
  */
 static int
  * @return GNUNET_YES (continue iteration)
  */
 static int

-find_advertisable_hello (void *cls,
-                        const GNUNET_HashCode *pid,
-                        void *value)
+find_advertisable_hello (void *cls, const GNUNET_HashCode * pid, void *value)

 {
   struct FindAdvHelloContext *fah = cls;
   struct Peer *pos = value;
 {
   struct FindAdvHelloContext *fah = cls;
   struct Peer *pos = value;


@@ -585,21 +552,20 @@ find_advertisable_hello (void *cls,
   if (pos->hello == NULL)
     return GNUNET_YES;
   rst_time = GNUNET_TIME_absolute_get_remaining (pos->filter_expiration);
   if (pos->hello == NULL)
     return GNUNET_YES;
   rst_time = GNUNET_TIME_absolute_get_remaining (pos->filter_expiration);

-  if (0 == rst_time.value)
-    {
-      /* time to discard... */
-      GNUNET_CONTAINER_bloomfilter_free (pos->filter);
-      setup_filter (pos);
-    }
-  fah->next_adv = GNUNET_TIME_relative_min (rst_time,
-                                           fah->next_adv);
+  if (0 == rst_time.rel_value)
+  {
+    /* time to discard... */
+    GNUNET_CONTAINER_bloomfilter_free (pos->filter);
+    setup_filter (pos);
+  }
+  fah->next_adv = GNUNET_TIME_relative_min (rst_time, fah->next_adv);

   hs = GNUNET_HELLO_size (pos->hello);
   if (hs > fah->max_size)
     return GNUNET_YES;
   if (GNUNET_NO ==
       GNUNET_CONTAINER_bloomfilter_test (pos->filter,
   hs = GNUNET_HELLO_size (pos->hello);
   if (hs > fah->max_size)
     return GNUNET_YES;
   if (GNUNET_NO ==
       GNUNET_CONTAINER_bloomfilter_test (pos->filter,

-                                        &fah->peer->pid.hashPubKey))
-    fah->result = pos;    
+                                         &fah->peer->pid.hashPubKey))
+    fah->result = pos;

   return GNUNET_YES;
 }
 
   return GNUNET_YES;
 }
 


@@ -612,47 +578,40 @@ find_advertisable_hello (void *cls,
  * @param tc task context
  */
 static void
  * @param tc task context
  */
 static void

-schedule_next_hello (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+schedule_next_hello (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)

 {
   struct Peer *pl = cls;
   struct FindAdvHelloContext fah;
   size_t next_want;
   struct GNUNET_TIME_Relative delay;
 {
   struct Peer *pl = cls;
   struct FindAdvHelloContext fah;
   size_t next_want;
   struct GNUNET_TIME_Relative delay;

- 
+

   pl->hello_delay_task = GNUNET_SCHEDULER_NO_TASK;
   pl->hello_delay_task = GNUNET_SCHEDULER_NO_TASK;

+  GNUNET_assert (GNUNET_YES == pl->is_connected);

   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))

-    return; /* we're out of here */
+    return;                     /* we're out of here */

   if (pl->hello_req != NULL)
   if (pl->hello_req != NULL)

-    return; /* did not finish sending the previous one */
+    return;                     /* did not finish sending the previous one */

   /* find applicable HELLOs */
   fah.peer = pl;
   fah.result = NULL;
   /* find applicable HELLOs */
   fah.peer = pl;
   fah.result = NULL;

-  fah.max_size = GNUNET_SERVER_MAX_MESSAGE_SIZE;
+  fah.max_size = GNUNET_SERVER_MAX_MESSAGE_SIZE - 1;

   fah.next_adv = GNUNET_TIME_UNIT_FOREVER_REL;
   fah.next_adv = GNUNET_TIME_UNIT_FOREVER_REL;

-  GNUNET_CONTAINER_multihashmap_iterate (peers,
-                                        &find_advertisable_hello,
-                                        &fah);
-  pl->hello_delay_task 
-    = GNUNET_SCHEDULER_add_delayed (sched,
-                                   fah.next_adv,
-                                   &schedule_next_hello,
-                                   pl);
+  GNUNET_CONTAINER_multihashmap_iterate (peers, &find_advertisable_hello, &fah);
+  pl->hello_delay_task =
+      GNUNET_SCHEDULER_add_delayed (fah.next_adv, &schedule_next_hello, pl);

   if (fah.result == NULL)
   if (fah.result == NULL)

-    return;   
+    return;

   next_want = GNUNET_HELLO_size (fah.result->hello);
   delay = GNUNET_TIME_absolute_get_remaining (pl->next_hello_allowed);
   next_want = GNUNET_HELLO_size (fah.result->hello);
   delay = GNUNET_TIME_absolute_get_remaining (pl->next_hello_allowed);

-  if (delay.value == 0)
-    {
-      /* now! */
-      pl->hello_req = GNUNET_CORE_notify_transmit_ready (handle, 0,
-                                                        GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                                        &pl->pid,
-                                                        next_want,
-                                                        &hello_advertising_ready,
-                                                        pl);
-      return;
-    }
+  if (delay.rel_value == 0)
+  {
+    /* now! */
+    pl->hello_req =
+        GNUNET_CORE_notify_transmit_ready (handle, GNUNET_YES, 0,
+                                           GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                                           &pl->pid, next_want,
+                                           &hello_advertising_ready, pl);
+  }

 }
 
 
 }
 
 


@@ -667,32 +626,27 @@ schedule_next_hello (void *cls,
  * @return GNUNET_YES (always)
  */
 static int
  * @return GNUNET_YES (always)
  */
 static int

-reschedule_hellos (void *cls,
-                  const GNUNET_HashCode *pid,
-                  void *value)
+reschedule_hellos (void *cls, const GNUNET_HashCode * pid, void *value)

 {
   struct Peer *peer = value;
   struct Peer *skip = cls;
 
   if (skip == peer)
     return GNUNET_YES;
 {
   struct Peer *peer = value;
   struct Peer *skip = cls;
 
   if (skip == peer)
     return GNUNET_YES;

-  if (! peer->is_connected) 
+  if (!peer->is_connected)

     return GNUNET_YES;
   if (peer->hello_req != NULL)
     return GNUNET_YES;
   if (peer->hello_req != NULL)

-    {
-      GNUNET_CORE_notify_transmit_ready_cancel (peer->hello_req);
-      peer->hello_req = NULL;
-    }
+  {
+    GNUNET_CORE_notify_transmit_ready_cancel (peer->hello_req);
+    peer->hello_req = NULL;
+  }

   if (peer->hello_delay_task != GNUNET_SCHEDULER_NO_TASK)
   if (peer->hello_delay_task != GNUNET_SCHEDULER_NO_TASK)

-    {
-      GNUNET_SCHEDULER_cancel (sched,
-                              peer->hello_delay_task);
-      peer->hello_delay_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  peer->hello_delay_task 
-    = GNUNET_SCHEDULER_add_now (sched,
-                               &schedule_next_hello,
-                               peer);
+  {
+    GNUNET_SCHEDULER_cancel (peer->hello_delay_task);
+    peer->hello_delay_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  peer->hello_delay_task =
+      GNUNET_SCHEDULER_add_now (&schedule_next_hello, peer);

   return GNUNET_YES;
 }
 
   return GNUNET_YES;
 }
 


@@ -702,52 +656,47 @@ reschedule_hellos (void *cls,
  *
  * @param cls closure
  * @param peer peer identity this notification is about
  *
  * @param cls closure
  * @param peer peer identity this notification is about

- * @param latency reported latency of the connection with 'other'
- * @param distance reported distance (DV) to 'other' 
+ * @param atsi performance data

  */
  */

-static void 
-connect_notify (void *cls,
-               const struct
-               GNUNET_PeerIdentity * peer,
-               struct GNUNET_TIME_Relative latency,
-               uint32_t distance)
+static void
+connect_notify (void *cls, const struct GNUNET_PeerIdentity *peer,
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)

 {
   struct Peer *pos;
 
 #if DEBUG_TOPOLOGY
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 {
   struct Peer *pos;
 
 #if DEBUG_TOPOLOGY
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-             "Core told us that we are connecting to `%s'\n",
-             GNUNET_i2s (peer));
+              "Core told us that we are connecting to `%s'\n",
+              GNUNET_i2s (peer));

 #endif
 #endif

+  if (0 == memcmp (&my_identity, peer, sizeof (struct GNUNET_PeerIdentity)))
+    return;
+

   connection_count++;
   connection_count++;

-  GNUNET_STATISTICS_set (stats,
-                        gettext_noop ("# peers connected"),
-                        connection_count,
-                        GNUNET_NO);
+  GNUNET_STATISTICS_set (stats, gettext_noop ("# peers connected"),
+                         connection_count, GNUNET_NO);

   pos = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
   pos = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);

-  if (pos == NULL)    
-    {
-      pos = make_peer (peer, NULL, GNUNET_NO);
-      GNUNET_break (GNUNET_OK == is_connection_allowed (pos));
-    }
+  if (pos == NULL)
+  {
+    pos = make_peer (peer, NULL, GNUNET_NO);
+    GNUNET_break (GNUNET_OK == is_connection_allowed (pos));
+  }

   else
   else

-    {
-      GNUNET_assert (GNUNET_NO == pos->is_connected);
-      pos->greylisted_until.value = 0; /* remove greylisting */
-    }
+  {
+    GNUNET_assert (GNUNET_NO == pos->is_connected);
+    pos->greylisted_until.abs_value = 0;        /* remove greylisting */
+  }

   pos->is_connected = GNUNET_YES;
   pos->is_connected = GNUNET_YES;

-  pos->connect_attempts = 0; /* re-set back-off factor */
+  pos->connect_attempts = 0;    /* re-set back-off factor */

   if (pos->is_friend)
   if (pos->is_friend)

-    {
-      if ( (friend_count == minimum_friend_count - 1) &&
-          (GNUNET_YES != friends_only) )       
-       whitelist_peers ();       
-      friend_count++;
-      GNUNET_STATISTICS_set (stats,
-                            gettext_noop ("# friends connected"),
-                            connection_count,
-                            GNUNET_NO);
-    }
+  {
+    if ((friend_count == minimum_friend_count - 1) &&
+        (GNUNET_YES != friends_only))
+      whitelist_peers ();
+    friend_count++;
+    GNUNET_STATISTICS_set (stats, gettext_noop ("# friends connected"),
+                           friend_count, GNUNET_NO);
+  }

   reschedule_hellos (NULL, &peer->hashPubKey, pos);
 }
 
   reschedule_hellos (NULL, &peer->hashPubKey, pos);
 }
 


@@ -761,9 +710,7 @@ connect_notify (void *cls,
  * @return GNUNET_YES (continue to iterate)
  */
 static int
  * @return GNUNET_YES (continue to iterate)
  */
 static int

-try_add_peers (void *cls,
-              const GNUNET_HashCode *pid,
-              void *value)
+try_add_peers (void *cls, const GNUNET_HashCode * pid, void *value)

 {
   struct Peer *pos = value;
 
 {
   struct Peer *pos = value;
 


@@ -772,58 +719,76 @@ try_add_peers (void *cls,
 }
 
 
 }
 
 

+/**
+ * Last task run during shutdown.  Disconnects us from
+ * the transport and core.
+ *
+ * @param cls unused, NULL
+ * @param tc scheduler context
+ */
+static void
+add_peer_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  add_task = GNUNET_SCHEDULER_NO_TASK;
+
+  GNUNET_CONTAINER_multihashmap_iterate (peers, &try_add_peers, NULL);
+}
+

 /**
  * Method called whenever a peer disconnects.
  *
  * @param cls closure
  * @param peer peer identity this notification is about
  */
 /**
  * Method called whenever a peer disconnects.
  *
  * @param cls closure
  * @param peer peer identity this notification is about
  */

-static void 
-disconnect_notify (void *cls,
-                  const struct
-                  GNUNET_PeerIdentity * peer)
+static void
+disconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer)

 {
   struct Peer *pos;
 {
   struct Peer *pos;

- 
+
+  if (0 == memcmp (&my_identity, peer, sizeof (struct GNUNET_PeerIdentity)))
+    return;

 #if DEBUG_TOPOLOGY
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 #if DEBUG_TOPOLOGY
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-             "Core told us that we disconnected from `%s'\n",
-             GNUNET_i2s (peer));
-#endif       
-  pos = GNUNET_CONTAINER_multihashmap_get (peers,
-                                          &peer->hashPubKey);
+              "Core told us that we disconnected from `%s'\n",
+              GNUNET_i2s (peer));
+#endif
+  pos = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);

   if (pos == NULL)
   if (pos == NULL)

-    {
-      GNUNET_break (0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }

   if (pos->is_connected != GNUNET_YES)
   if (pos->is_connected != GNUNET_YES)

-    {
-      GNUNET_break (0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
+  pos->is_connected = GNUNET_NO;

   connection_count--;
   connection_count--;

-  GNUNET_STATISTICS_set (stats,
-                        gettext_noop ("# peers connected"),
-                        connection_count,
-                        GNUNET_NO);
+  if (NULL != pos->hello_req)
+  {
+    GNUNET_CORE_notify_transmit_ready_cancel (pos->hello_req);
+    pos->hello_req = NULL;
+  }
+  if (GNUNET_SCHEDULER_NO_TASK != pos->hello_delay_task)
+  {
+    GNUNET_SCHEDULER_cancel (pos->hello_delay_task);
+    pos->hello_delay_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  GNUNET_STATISTICS_set (stats, gettext_noop ("# peers connected"),
+                         connection_count, GNUNET_NO);

   if (pos->is_friend)
   if (pos->is_friend)

-    {
-      friend_count--; 
-      GNUNET_STATISTICS_set (stats,
-                            gettext_noop ("# friends connected"),
-                            connection_count,
-                            GNUNET_NO);
-    }
-  if ( (connection_count < target_connection_count) ||
-       (friend_count < minimum_friend_count) )
-    GNUNET_CONTAINER_multihashmap_iterate (peers,
-                                          &try_add_peers,
-                                          NULL);
-  if ( (friend_count < minimum_friend_count) &&
-       (blacklist == NULL) )
-    blacklist = GNUNET_TRANSPORT_blacklist (sched, cfg,
-                                           &blacklist_check, NULL);
+  {
+    friend_count--;
+    GNUNET_STATISTICS_set (stats, gettext_noop ("# friends connected"),
+                           friend_count, GNUNET_NO);
+  }
+  if (((connection_count < target_connection_count) ||
+       (friend_count < minimum_friend_count)) &&
+      (GNUNET_SCHEDULER_NO_TASK == add_task))
+    add_task = GNUNET_SCHEDULER_add_now (&add_peer_task, NULL);
+  if ((friend_count < minimum_friend_count) && (blacklist == NULL))
+    blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_check, NULL);

 }
 
 
 }
 
 


@@ -838,12 +803,12 @@ disconnect_notify (void *cls,
  * @return GNUNET_SYSERR always, to terminate iteration
  */
 static int
  * @return GNUNET_SYSERR always, to terminate iteration
  */
 static int

-address_iterator (void *cls,
-                 const char *tname,
-                 struct GNUNET_TIME_Absolute expiration,
-                 const void *addr, size_t addrlen)
+address_iterator (void *cls, const char *tname,
+                  struct GNUNET_TIME_Absolute expiration, const void *addr,
+                  uint16_t addrlen)

 {
   int *flag = cls;
 {
   int *flag = cls;

+

   *flag = GNUNET_YES;
   return GNUNET_SYSERR;
 }
   *flag = GNUNET_YES;
   return GNUNET_SYSERR;
 }


@@ -865,59 +830,52 @@ consider_for_advertising (const struct GNUNET_HELLO_Message *hello)
   struct Peer *peer;
   uint16_t size;
 
   struct Peer *peer;
   uint16_t size;
 

-  GNUNET_break (GNUNET_OK == GNUNET_HELLO_get_id (hello, &pid));
-  if (0 == memcmp (&pid,
-                  &my_identity,
-                  sizeof (struct GNUNET_PeerIdentity)))
-    return; /* that's me! */
+  if (GNUNET_OK != GNUNET_HELLO_get_id (hello, &pid))
+  {
+    GNUNET_break (0);
+    return;
+  }
+  if (0 == memcmp (&pid, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
+    return;                     /* that's me! */

   have_address = GNUNET_NO;
   have_address = GNUNET_NO;

-  GNUNET_HELLO_iterate_addresses (hello,
-                                 GNUNET_NO,
-                                 &address_iterator,
-                                 &have_address);
+  GNUNET_HELLO_iterate_addresses (hello, GNUNET_NO, &address_iterator,
+                                  &have_address);

   if (GNUNET_NO == have_address)
   if (GNUNET_NO == have_address)

-    return; /* no point in advertising this one... */
-  peer = GNUNET_CONTAINER_multihashmap_get (peers,
-                                           &pid.hashPubKey);
+    return;                     /* no point in advertising this one... */
+  peer = GNUNET_CONTAINER_multihashmap_get (peers, &pid.hashPubKey);

   if (peer == NULL)
   if (peer == NULL)

-    {
-      peer = make_peer (&pid, hello, GNUNET_NO);
-    }
+  {
+    peer = make_peer (&pid, hello, GNUNET_NO);
+  }

   else if (peer->hello != NULL)
   else if (peer->hello != NULL)

-    {
-      dt = GNUNET_HELLO_equals (peer->hello,
-                               hello,
-                               GNUNET_TIME_absolute_get());
-      if (dt.value == GNUNET_TIME_UNIT_FOREVER_ABS.value)
-       return; /* nothing new here */
-    }
+  {
+    dt = GNUNET_HELLO_equals (peer->hello, hello, GNUNET_TIME_absolute_get ());
+    if (dt.abs_value == GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
+      return;                   /* nothing new here */
+  }

 #if DEBUG_TOPOLOGY
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 #if DEBUG_TOPOLOGY
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-             "Found `%s' from peer `%s' for advertising\n",
-             "HELLO",
-             GNUNET_i2s (&pid));
-#endif 
+              "Found `%s' from peer `%s' for advertising\n", "HELLO",
+              GNUNET_i2s (&pid));
+#endif

   if (peer->hello != NULL)
   if (peer->hello != NULL)

-    {
-      nh = GNUNET_HELLO_merge (peer->hello,
-                              hello);
-      GNUNET_free (peer->hello);
-      peer->hello = nh;
-    }
+  {
+    nh = GNUNET_HELLO_merge (peer->hello, hello);
+    GNUNET_free (peer->hello);
+    peer->hello = nh;
+  }

   else
   else

-    {
-      size = GNUNET_HELLO_size (hello);
-      peer->hello = GNUNET_malloc (size);
-      memcpy (peer->hello, hello, size);
-    }
+  {
+    size = GNUNET_HELLO_size (hello);
+    peer->hello = GNUNET_malloc (size);
+    memcpy (peer->hello, hello, size);
+  }

   if (peer->filter != NULL)
     GNUNET_CONTAINER_bloomfilter_free (peer->filter);
   setup_filter (peer);
   /* since we have a new HELLO to pick from, re-schedule all
   if (peer->filter != NULL)
     GNUNET_CONTAINER_bloomfilter_free (peer->filter);
   setup_filter (peer);
   /* since we have a new HELLO to pick from, re-schedule all

-     HELLO requests that are not bound by the HELLO send rate! */
-  GNUNET_CONTAINER_multihashmap_iterate (peers,
-                                        &reschedule_hellos,
-                                        peer);
+   * HELLO requests that are not bound by the HELLO send rate! */
+  GNUNET_CONTAINER_multihashmap_iterate (peers, &reschedule_hellos, peer);

 }
 
 
 }
 
 


@@ -928,70 +886,72 @@ consider_for_advertising (const struct GNUNET_HELLO_Message *hello)
  * @param cls closure (not used)
  * @param peer potential peer to connect to
  * @param hello HELLO for this peer (or NULL)
  * @param cls closure (not used)
  * @param peer potential peer to connect to
  * @param hello HELLO for this peer (or NULL)

- * @param trust how much we trust the peer (not used)
+ * @param err_msg NULL if successful, otherwise contains error message

  */
 static void
  */
 static void

-process_peer (void *cls,
-             const struct GNUNET_PeerIdentity *peer,
-             const struct GNUNET_HELLO_Message *hello,
-             uint32_t trust)
+process_peer (void *cls, const struct GNUNET_PeerIdentity *peer,
+              const struct GNUNET_HELLO_Message *hello, const char *err_msg)

 {
   struct Peer *pos;
 
 {
   struct Peer *pos;
 

+  if (err_msg != NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _("Error in communication with PEERINFO service: %s\n"),
+                err_msg);
+    GNUNET_PEERINFO_notify_cancel (peerinfo_notify);
+    peerinfo_notify = GNUNET_PEERINFO_notify (cfg, &process_peer, NULL);
+    return;
+  }

   GNUNET_assert (peer != NULL);
   GNUNET_assert (peer != NULL);

-  if (0 == memcmp (&my_identity,
-                   peer, sizeof (struct GNUNET_PeerIdentity)))
-    return;  /* that's me! */
+  if (0 == memcmp (&my_identity, peer, sizeof (struct GNUNET_PeerIdentity)))
+    return;                     /* that's me! */

   if (hello == NULL)
   if (hello == NULL)

+  {
+    /* free existing HELLO, if any */
+    pos = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
+    if (NULL != pos)

     {
     {

-      /* free existing HELLO, if any */
-      pos = GNUNET_CONTAINER_multihashmap_get (peers,
-                                              &peer->hashPubKey);
-      if (NULL != pos)
-       {
-         GNUNET_free_non_null (pos->hello);
-         pos->hello = NULL;
-         if (pos->filter != NULL)
-           {
-             GNUNET_CONTAINER_bloomfilter_free (pos->filter);
-             pos->filter = NULL;
-           }
-         if ( (! pos->is_connected) &&
-              (! pos->is_friend) &&
-              (0 == GNUNET_TIME_absolute_get_remaining (pos->greylisted_until).value) )
-           free_peer (NULL, &pos->pid.hashPubKey, pos);
-       }
-      return;
+      GNUNET_free_non_null (pos->hello);
+      pos->hello = NULL;
+      if (pos->filter != NULL)
+      {
+        GNUNET_CONTAINER_bloomfilter_free (pos->filter);
+        pos->filter = NULL;
+      }
+      if ((!pos->is_connected) && (!pos->is_friend) &&
+          (0 ==
+           GNUNET_TIME_absolute_get_remaining (pos->
+                                               greylisted_until).rel_value))
+        free_peer (NULL, &pos->pid.hashPubKey, pos);

     }
     }

+    return;
+  }

   consider_for_advertising (hello);
   consider_for_advertising (hello);

-  pos = GNUNET_CONTAINER_multihashmap_get (peers,
-                                          &peer->hashPubKey);
+  pos = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);

   if (pos == NULL)
     pos = make_peer (peer, hello, GNUNET_NO);
   GNUNET_assert (NULL != pos);
   if (GNUNET_YES == pos->is_connected)
   if (pos == NULL)
     pos = make_peer (peer, hello, GNUNET_NO);
   GNUNET_assert (NULL != pos);
   if (GNUNET_YES == pos->is_connected)

-    {
+  {

 #if DEBUG_TOPOLOGY
 #if DEBUG_TOPOLOGY

-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                 "Already connected to peer `%s'\n",
-                 GNUNET_i2s (peer));
-#endif 
-      return;
-    }
-  if (GNUNET_TIME_absolute_get_remaining (pos->greylisted_until).value > 0)
-    {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Already connected to peer `%s'\n",
+                GNUNET_i2s (peer));
+#endif
+    return;
+  }
+  if (GNUNET_TIME_absolute_get_remaining (pos->greylisted_until).rel_value > 0)
+  {

 #if DEBUG_TOPOLOGY
 #if DEBUG_TOPOLOGY

-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                 "Already tried peer `%s' recently\n",
-                 GNUNET_i2s (peer));
-#endif 
-      return; /* peer still greylisted */
-    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Already tried peer `%s' recently\n",
+                GNUNET_i2s (peer));
+#endif
+    return;                     /* peer still greylisted */
+  }

 #if DEBUG_TOPOLOGY
 #if DEBUG_TOPOLOGY

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "Considering connecting to peer `%s'\n",
-             GNUNET_i2s (peer));
-#endif 
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Considering connecting to peer `%s'\n",
+              GNUNET_i2s (peer));
+#endif

   attempt_connect (pos);
 }
 
   attempt_connect (pos);
 }
 


@@ -1006,31 +966,24 @@ process_peer (void *cls,
  * @param publicKey public key of this peer, NULL if we failed
  */
 static void
  * @param publicKey public key of this peer, NULL if we failed
  */
 static void

-core_init (void *cls,
-          struct GNUNET_CORE_Handle * server,
-          const struct GNUNET_PeerIdentity *
-          my_id,
-          const struct
-          GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *
-          publicKey)
+core_init (void *cls, struct GNUNET_CORE_Handle *server,
+           const struct GNUNET_PeerIdentity *my_id,
+           const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)

 {
   if (server == NULL)
 {
   if (server == NULL)

-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to connect to core service, can not manage topology!\n"));
-      GNUNET_SCHEDULER_shutdown (sched);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Failed to connect to core service, can not manage topology!\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }

   handle = server;
   my_identity = *my_id;
 #if DEBUG_TOPOLOGY
   handle = server;
   my_identity = *my_id;
 #if DEBUG_TOPOLOGY

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "I am peer `%s'\n",
-             GNUNET_i2s (my_id));
-#endif         
-  peerinfo_notify = GNUNET_PEERINFO_notify (cfg, sched,
-                                           &process_peer,
-                                           NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "I am peer `%s'\n", GNUNET_i2s (my_id));
+#endif
+  peerinfo_notify = GNUNET_PEERINFO_notify (cfg, &process_peer, NULL);

 }
 
 
 }
 
 


@@ -1050,117 +1003,118 @@ read_friends_file (const struct GNUNET_CONFIGURATION_Handle *cfg)
   struct Peer *fl;
 
   if (GNUNET_OK !=
   struct Peer *fl;
 
   if (GNUNET_OK !=

-      GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                              "TOPOLOGY",
-                                              "FRIENDS",
-                                              &fn))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                 _("Option `%s' in section `%s' not specified!\n"),
-                 "FRIENDS",
-                 "TOPOLOGY");
-      return;
-    }
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "TOPOLOGY", "FRIENDS", &fn))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Option `%s' in section `%s' not specified!\n"), "FRIENDS",
+                "TOPOLOGY");
+    return;
+  }

   if (GNUNET_OK != GNUNET_DISK_file_test (fn))
   if (GNUNET_OK != GNUNET_DISK_file_test (fn))

-    GNUNET_DISK_fn_write (fn, NULL, 0, GNUNET_DISK_PERM_USER_READ
-        | GNUNET_DISK_PERM_USER_WRITE);
+    GNUNET_DISK_fn_write (fn, NULL, 0,
+                          GNUNET_DISK_PERM_USER_READ |
+                          GNUNET_DISK_PERM_USER_WRITE);

   if (0 != STAT (fn, &frstat))
   if (0 != STAT (fn, &frstat))

-    {
-      if ((friends_only) || (minimum_friend_count > 0))
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                     _("Could not read friends list `%s'\n"), fn);
-         GNUNET_free (fn);
-          return;
-        }
-    }
+  {
+    if ((friends_only) || (minimum_friend_count > 0))
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Could not read friends list `%s'\n"), fn);
+    GNUNET_free (fn);
+    return;
+  }

   if (frstat.st_size == 0)
   if (frstat.st_size == 0)

-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                 _("Friends file `%s' is empty.\n"),
-                 fn);
-      GNUNET_free (fn);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, _("Friends file `%s' is empty.\n"),
+                fn);
+    GNUNET_free (fn);
+    return;
+  }

   data = GNUNET_malloc_large (frstat.st_size);
   data = GNUNET_malloc_large (frstat.st_size);

-  if (frstat.st_size !=
-      GNUNET_DISK_fn_read (fn, data, frstat.st_size))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to read friends list from `%s'\n"), fn);
-      GNUNET_free (fn);
-      GNUNET_free (data);
-      return;
-    }
+  if (data == NULL)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to read friends list from `%s': out of memory\n"),
+                fn);
+    GNUNET_free (fn);
+    return;
+  }
+  if (frstat.st_size != GNUNET_DISK_fn_read (fn, data, frstat.st_size))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to read friends list from `%s'\n"), fn);
+    GNUNET_free (fn);
+    GNUNET_free (data);
+    return;
+  }

   entries_found = 0;
   pos = 0;
   entries_found = 0;
   pos = 0;

-  while ((pos < frstat.st_size) && isspace (data[pos]))
+  while ((pos < frstat.st_size) && isspace ((unsigned char) data[pos]))

     pos++;
   while ((frstat.st_size >= sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)) &&
     pos++;
   while ((frstat.st_size >= sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)) &&

-        (pos <= frstat.st_size - sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)))
+         (pos <=
+          frstat.st_size - sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)))
+  {
+    memcpy (&enc, &data[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
+    if (!isspace
+        ((unsigned char)
+         enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1]))

     {
     {

-      memcpy (&enc, &data[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
-      if (!isspace (enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1]))
-       {
-         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                     _("Syntax error in topology specification at offset %llu, skipping bytes.\n"),
-                     (unsigned long long) pos);
-         pos++;
-         while ((pos < frstat.st_size) && (!isspace (data[pos])))
-           pos++;
-         continue;
-       }
-      enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
-      if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string ((char *) &enc, &pid.hashPubKey))
-       {
-         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                     _("Syntax error in topology specification at offset %llu, skipping bytes `%s'.\n"),
-                     (unsigned long long) pos,
-                     &enc);
-       }
-      else
-       {
-         if (0 != memcmp (&pid,
-                          &my_identity,
-                          sizeof (struct GNUNET_PeerIdentity)))
-           {
-             entries_found++;
-             fl = make_peer (&pid,
-                             NULL,
-                             GNUNET_YES);
-             GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                         _("Found friend `%s' in configuration\n"),
-                         GNUNET_i2s (&fl->pid));
-           }
-         else
-           {
-             GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                         _("Found myself `%s' in friend list (useless, ignored)\n"),
-                         GNUNET_i2s (&pid));
-           }
-       }
-      pos = pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded);
-      while ((pos < frstat.st_size) && isspace (data[pos]))
-       pos++;
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Syntax error in topology specification at offset %llu, skipping bytes.\n"),
+                  (unsigned long long) pos);
+      pos++;
+      while ((pos < frstat.st_size) && (!isspace ((unsigned char) data[pos])))
+        pos++;
+      continue;

     }
     }

-  GNUNET_free (data);
-  GNUNET_free (fn);
-  GNUNET_STATISTICS_update (stats,
-                           gettext_noop ("# friends in configuration"),
-                           entries_found,
-                           GNUNET_NO);
-  if ( (minimum_friend_count > entries_found) &&
-       (friends_only == GNUNET_NO) )
+    enc.encoding[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
+    if (GNUNET_OK !=
+        GNUNET_CRYPTO_hash_from_string ((char *) &enc, &pid.hashPubKey))

     {
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
     {
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,

-                 _("Fewer friends specified than required by minimum friend count. Will only connect to friends.\n"));
+                  _
+                  ("Syntax error in topology specification at offset %llu, skipping bytes `%s'.\n"),
+                  (unsigned long long) pos, &enc);

     }
     }

-  if ( (minimum_friend_count > target_connection_count) &&
-       (friends_only == GNUNET_NO) )
+    else

     {
     {

-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                 _("More friendly connections required than target total number of connections.\n"));
+      if (0 != memcmp (&pid, &my_identity, sizeof (struct GNUNET_PeerIdentity)))
+      {
+        entries_found++;
+        fl = make_peer (&pid, NULL, GNUNET_YES);
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                    _("Found friend `%s' in configuration\n"),
+                    GNUNET_i2s (&fl->pid));
+      }
+      else
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    _("Found myself `%s' in friend list (useless, ignored)\n"),
+                    GNUNET_i2s (&pid));
+      }

     }
     }

+    pos = pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded);
+    while ((pos < frstat.st_size) && isspace ((unsigned char) data[pos]))
+      pos++;
+  }
+  GNUNET_free (data);
+  GNUNET_free (fn);
+  GNUNET_STATISTICS_update (stats, gettext_noop ("# friends in configuration"),
+                            entries_found, GNUNET_NO);
+  if ((minimum_friend_count > entries_found) && (friends_only == GNUNET_NO))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                ("Fewer friends specified than required by minimum friend count. Will only connect to friends.\n"));
+  }
+  if ((minimum_friend_count > target_connection_count) &&
+      (friends_only == GNUNET_NO))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                ("More friendly connections required than target total number of connections.\n"));
+  }

 }
 
 
 }
 
 


@@ -1172,59 +1126,46 @@ read_friends_file (const struct GNUNET_CONFIGURATION_Handle *cfg)
  * @param other the other peer involved (sender or receiver, NULL
  *        for loopback messages where we are both sender and receiver)
  * @param message the actual HELLO message
  * @param other the other peer involved (sender or receiver, NULL
  *        for loopback messages where we are both sender and receiver)
  * @param message the actual HELLO message

- * @param latency reported latency of the connection with 'other'
- * @param distance reported distance (DV) to 'other' 
+ * @param atsi performance data

  * @return GNUNET_OK to keep the connection open,
  *         GNUNET_SYSERR to close it (signal serious error)
  */
 static int
  * @return GNUNET_OK to keep the connection open,
  *         GNUNET_SYSERR to close it (signal serious error)
  */
 static int

-handle_encrypted_hello (void *cls,
-                       const struct GNUNET_PeerIdentity * other,
-                       const struct GNUNET_MessageHeader *
-                       message,
-                       struct GNUNET_TIME_Relative latency,
-                       uint32_t distance)
+handle_encrypted_hello (void *cls, const struct GNUNET_PeerIdentity *other,
+                        const struct GNUNET_MessageHeader *message,
+                        const struct GNUNET_TRANSPORT_ATS_Information *atsi)

 {
   struct Peer *peer;
   struct GNUNET_PeerIdentity pid;
 
 #if DEBUG_TOPOLOGY
 {
   struct Peer *peer;
   struct GNUNET_PeerIdentity pid;
 
 #if DEBUG_TOPOLOGY

-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-             "Received encrypted `%s' from peer `%s'",
-             "HELLO",
-             GNUNET_i2s (other));
-#endif         
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received encrypted `%s' from peer `%s'",
+              "HELLO", GNUNET_i2s (other));
+#endif

   if (GNUNET_OK !=
   if (GNUNET_OK !=

-      GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message*) message,
-                          &pid))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_STATISTICS_update (stats,
-                           gettext_noop ("# HELLO messages received"),
-                           1,
-                           GNUNET_NO);
-  peer = GNUNET_CONTAINER_multihashmap_get (peers,
-                                           &pid.hashPubKey);
+      GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) message, &pid))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_STATISTICS_update (stats, gettext_noop ("# HELLO messages received"),
+                            1, GNUNET_NO);
+  peer = GNUNET_CONTAINER_multihashmap_get (peers, &pid.hashPubKey);

   if (peer == NULL)
   if (peer == NULL)

-    {
-      if ( (GNUNET_YES == friends_only) ||
-          (friend_count < minimum_friend_count) )
-       return GNUNET_OK;      
-    }
+  {
+    if ((GNUNET_YES == friends_only) || (friend_count < minimum_friend_count))
+      return GNUNET_OK;
+  }

   else
   else

-    {
-      if ( (GNUNET_YES != peer->is_friend) &&
-          (GNUNET_YES == friends_only) )
-       return GNUNET_OK;
-      if ( (GNUNET_YES != peer->is_friend) &&
-          (friend_count < minimum_friend_count) )
-       return GNUNET_OK;      
-    }
+  {
+    if ((GNUNET_YES != peer->is_friend) && (GNUNET_YES == friends_only))
+      return GNUNET_OK;
+    if ((GNUNET_YES != peer->is_friend) &&
+        (friend_count < minimum_friend_count))
+      return GNUNET_OK;
+  }

   if (transport != NULL)
   if (transport != NULL)

-    GNUNET_TRANSPORT_offer_hello (transport,
-                                 message);
+    GNUNET_TRANSPORT_offer_hello (transport, message, NULL, NULL);

   return GNUNET_OK;
 }
 
   return GNUNET_OK;
 }
 


@@ -1238,47 +1179,41 @@ handle_encrypted_hello (void *cls,
  * @return number of bytes written to buf
  */
 static size_t
  * @return number of bytes written to buf
  */
 static size_t

-hello_advertising_ready (void *cls,
-                        size_t size,
-                        void *buf)
+hello_advertising_ready (void *cls, size_t size, void *buf)

 {
   struct Peer *pl = cls;
   struct FindAdvHelloContext fah;
   size_t want;
 
   pl->hello_req = NULL;
 {
   struct Peer *pl = cls;
   struct FindAdvHelloContext fah;
   size_t want;
 
   pl->hello_req = NULL;

+  GNUNET_assert (GNUNET_YES == pl->is_connected);

   /* find applicable HELLOs */
   fah.peer = pl;
   fah.result = NULL;
   fah.max_size = size;
   fah.next_adv = GNUNET_TIME_UNIT_FOREVER_REL;
   /* find applicable HELLOs */
   fah.peer = pl;
   fah.result = NULL;
   fah.max_size = size;
   fah.next_adv = GNUNET_TIME_UNIT_FOREVER_REL;

-  GNUNET_CONTAINER_multihashmap_iterate (peers,
-                                        &find_advertisable_hello,
-                                        &fah);
+  GNUNET_CONTAINER_multihashmap_iterate (peers, &find_advertisable_hello, &fah);

   want = 0;
   if (fah.result != NULL)
   want = 0;
   if (fah.result != NULL)

-    {
-      want = GNUNET_HELLO_size (fah.result->hello);
-      GNUNET_assert (want <= size);
-      memcpy (buf, fah.result->hello, want);
-      GNUNET_CONTAINER_bloomfilter_add (fah.result->filter,
-                                       &pl->pid.hashPubKey);
+  {
+    want = GNUNET_HELLO_size (fah.result->hello);
+    GNUNET_assert (want <= size);
+    memcpy (buf, fah.result->hello, want);
+    GNUNET_CONTAINER_bloomfilter_add (fah.result->filter, &pl->pid.hashPubKey);

 #if DEBUG_TOPOLOGY
 #if DEBUG_TOPOLOGY

-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                 "Sending `%s' with %u bytes",
-                 "HELLO"
-                 (unsigned int) want);
-#endif         
-      GNUNET_STATISTICS_update (stats,
-                               gettext_noop ("# HELLO messages gossipped"),
-                               1,
-                               GNUNET_NO);    
-    }
-  pl->next_hello_allowed = GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY);
-  pl->hello_delay_task 
-    = GNUNET_SCHEDULER_add_now (sched,
-                               &schedule_next_hello,
-                               pl);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending `%s' with %u bytes", "HELLO",
+                (unsigned int) want);
+#endif
+    GNUNET_STATISTICS_update (stats,
+                              gettext_noop ("# HELLO messages gossipped"), 1,
+                              GNUNET_NO);
+  }
+
+  if (pl->hello_delay_task != GNUNET_SCHEDULER_NO_TASK)
+    GNUNET_SCHEDULER_cancel (pl->hello_delay_task);
+  pl->next_hello_allowed =
+      GNUNET_TIME_relative_to_absolute (HELLO_ADVERTISEMENT_MIN_FREQUENCY);
+  pl->hello_delay_task = GNUNET_SCHEDULER_add_now (&schedule_next_hello, pl);

   return want;
 }
 
   return want;
 }
 


@@ -1291,31 +1226,33 @@ hello_advertising_ready (void *cls,
  * @param tc scheduler context
  */
 static void
  * @param tc scheduler context
  */
 static void

-cleaning_task (void *cls, 
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)

 {
   if (NULL != peerinfo_notify)
 {
   if (NULL != peerinfo_notify)

-    {
-      GNUNET_PEERINFO_notify_cancel (peerinfo_notify);
-      peerinfo_notify = NULL;
-    }
+  {
+    GNUNET_PEERINFO_notify_cancel (peerinfo_notify);
+    peerinfo_notify = NULL;
+  }
+  if (GNUNET_SCHEDULER_NO_TASK != add_task)
+  {
+    GNUNET_SCHEDULER_cancel (add_task);
+    add_task = GNUNET_SCHEDULER_NO_TASK;
+  }

   GNUNET_TRANSPORT_disconnect (transport);
   transport = NULL;
   GNUNET_TRANSPORT_disconnect (transport);
   transport = NULL;

-  GNUNET_CONTAINER_multihashmap_iterate (peers,
-                                        &free_peer,
-                                        NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (peers, &free_peer, NULL);

   GNUNET_CONTAINER_multihashmap_destroy (peers);
   if (handle != NULL)
   GNUNET_CONTAINER_multihashmap_destroy (peers);
   if (handle != NULL)

-    {
-      GNUNET_CORE_disconnect (handle);
-      handle = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (handle);
+    handle = NULL;
+  }

   whitelist_peers ();
   if (stats != NULL)
   whitelist_peers ();
   if (stats != NULL)

-    {
-      GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
-      stats = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+    stats = NULL;
+  }

 }
 
 
 }
 
 


@@ -1323,109 +1260,72 @@ cleaning_task (void *cls,
  * Main function that will be run.
  *
  * @param cls closure
  * Main function that will be run.
  *
  * @param cls closure

- * @param s the scheduler to use

  * @param args remaining command-line arguments
  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
  * @param c configuration
  */
 static void
  * @param args remaining command-line arguments
  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
  * @param c configuration
  */
 static void

-run (void *cls,
-     struct GNUNET_SCHEDULER_Handle * s,
-     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)

 {
 {

-  struct GNUNET_CORE_MessageHandler handlers[] =
-    {
-      { &handle_encrypted_hello, GNUNET_MESSAGE_TYPE_HELLO, 0},
-      { NULL, 0, 0 }
-    };
+  static struct GNUNET_CORE_MessageHandler handlers[] = {
+    {&handle_encrypted_hello, GNUNET_MESSAGE_TYPE_HELLO, 0},
+    {NULL, 0, 0}
+  };

   unsigned long long opt;
 
   unsigned long long opt;
 

-  sched = s;

   cfg = c;
   cfg = c;

-  stats = GNUNET_STATISTICS_create (sched, "topology", cfg);
-  autoconnect = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                     "TOPOLOGY",
-                                                     "AUTOCONNECT");
-  friends_only = GNUNET_CONFIGURATION_get_value_yesno (cfg,
-                                                      "TOPOLOGY",
-                                                      "FRIENDS-ONLY");
+  stats = GNUNET_STATISTICS_create ("topology", cfg);
+  autoconnect =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "TOPOLOGY", "AUTOCONNECT");
+  friends_only =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "TOPOLOGY", "FRIENDS-ONLY");

   if (GNUNET_OK !=
   if (GNUNET_OK !=

-      GNUNET_CONFIGURATION_get_value_number (cfg,
-                                            "TOPOLOGY",
-                                            "MINIMUM-FRIENDS",
-                                            &opt))
+      GNUNET_CONFIGURATION_get_value_number (cfg, "TOPOLOGY", "MINIMUM-FRIENDS",
+                                             &opt))

     opt = 0;
   minimum_friend_count = (unsigned int) opt;
   if (GNUNET_OK !=
     opt = 0;
   minimum_friend_count = (unsigned int) opt;
   if (GNUNET_OK !=

-      GNUNET_CONFIGURATION_get_value_number (cfg,
-                                            "TOPOLOGY",
-                                            "TARGET-CONNECTION-COUNT",
-                                            &opt))
+      GNUNET_CONFIGURATION_get_value_number (cfg, "TOPOLOGY",
+                                             "TARGET-CONNECTION-COUNT", &opt))

     opt = 16;
   target_connection_count = (unsigned int) opt;
   peers = GNUNET_CONTAINER_multihashmap_create (target_connection_count * 2);
 
     opt = 16;
   target_connection_count = (unsigned int) opt;
   peers = GNUNET_CONTAINER_multihashmap_create (target_connection_count * 2);
 

-  if ( (friends_only == GNUNET_YES) ||
-       (minimum_friend_count > 0) )
+  if ((friends_only == GNUNET_YES) || (minimum_friend_count > 0))

     read_friends_file (cfg);
 #if DEBUG_TOPOLOGY
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
     read_friends_file (cfg);
 #if DEBUG_TOPOLOGY
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,

-             "Topology would like %u connections with at least %u friends (%s)\n",
-             target_connection_count,
-             minimum_friend_count,
-             autoconnect ? "autoconnect enabled" : "autoconnect disabled");
-#endif       
-  if (friend_count < minimum_friend_count) 
-    blacklist = GNUNET_TRANSPORT_blacklist (sched, cfg,
-                                           &blacklist_check, NULL);
-  transport = GNUNET_TRANSPORT_connect (sched,
-                                       cfg,
-                                       NULL,
-                                       NULL,
-                                       NULL,
-                                       NULL);
-  handle = GNUNET_CORE_connect (sched,
-                               cfg,
-                               GNUNET_TIME_UNIT_FOREVER_REL,
-                               NULL,
-                               &core_init,
-                               &connect_notify,
-                               &disconnect_notify,
-                               NULL, GNUNET_NO,
-                               NULL, GNUNET_NO,
-                               handlers);
-  GNUNET_SCHEDULER_add_delayed (sched,
-                                GNUNET_TIME_UNIT_FOREVER_REL,
-                                &cleaning_task, NULL);
+              "Topology would like %u connections with at least %u friends (%s)\n",
+              target_connection_count, minimum_friend_count,
+              autoconnect ? "autoconnect enabled" : "autoconnect disabled");
+#endif
+  if ((friend_count < minimum_friend_count) && (blacklist == NULL))
+    blacklist = GNUNET_TRANSPORT_blacklist (cfg, &blacklist_check, NULL);
+  transport = GNUNET_TRANSPORT_connect (cfg, NULL, NULL, NULL, NULL, NULL);
+  handle =
+      GNUNET_CORE_connect (cfg, 1, NULL, &core_init, &connect_notify,
+                           &disconnect_notify, NULL, NULL, GNUNET_NO, NULL,
+                           GNUNET_NO, handlers);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &cleaning_task,
+                                NULL);

   if (NULL == transport)
   if (NULL == transport)

-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to connect to `%s' service.\n"),
-                 "transport");
-      GNUNET_SCHEDULER_shutdown (sched);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to connect to `%s' service.\n"), "transport");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }

   if (NULL == handle)
   if (NULL == handle)

-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to connect to `%s' service.\n"),
-                 "core");
-      GNUNET_SCHEDULER_shutdown (sched);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to connect to `%s' service.\n"), "core");
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }

 }
 
 
 }
 
 

-/**
- * gnunet-daemon-topology command line options.
- */
-static struct GNUNET_GETOPT_CommandLineOption options[] = {
-  GNUNET_GETOPT_OPTION_END
-};
-
-

 /**
  * The main function for the topology daemon.
  *
 /**
  * The main function for the topology daemon.
  *


@@ -1436,15 +1336,17 @@ static struct GNUNET_GETOPT_CommandLineOption options[] = {
 int
 main (int argc, char *const *argv)
 {
 int
 main (int argc, char *const *argv)
 {

+  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
+    GNUNET_GETOPT_OPTION_END
+  };

   int ret;
 
   int ret;
 

-  ret = (GNUNET_OK ==
-         GNUNET_PROGRAM_run (argc,
-                             argv,
-                             "topology",
-                            _("GNUnet topology control (maintaining P2P mesh and F2F constraints)"),
-                            options,
-                            &run, NULL)) ? 0 : 1;
+  ret =
+      (GNUNET_OK ==
+       GNUNET_PROGRAM_run (argc, argv, "gnunet-daemon-topology",
+                           _
+                           ("GNUnet topology control (maintaining P2P mesh and F2F constraints)"),
+                           options, &run, NULL)) ? 0 : 1;

   return ret;
 }
 
   return ret;
 }