naming conventions for peer states

2 files changed, 259 insertions, 248 deletions

diff --git a/src/transport/gnunet-service-transport_neighbours.c b/src/transport/gnunet-service-transport_neighbours.c
index f5d44fa1d..a386d7de0 100644
--- a/src/transport/gnunet-service-transport_neighbours.c
+++ b/src/transport/gnunet-service-transport_neighbours.c
@@ -839,7 +839,7 @@ free_neighbour (struct NeighbourMapEntry *n,
                            GNUNET_NO);
     disconnect_notify_cb (callback_cls, &n->id);
   }
-  set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
+  set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED);
 
   if (NULL != n->primary_address.address)
   {
@@ -968,7 +968,7 @@ send_disconnect_cont (void *cls, const struct GNUNET_PeerIdentity *target,
   n = lookup_neighbour (target);
   if (NULL == n)
     return; /* already gone */
-  if (GNUNET_TRANSPORT_DISCONNECT != n->state)
+  if (GNUNET_TRANSPORT_PS_DISCONNECT != n->state)
     return; /* have created a fresh entry since */
   if (GNUNET_SCHEDULER_NO_TASK != n->task)
     GNUNET_SCHEDULER_cancel (n->task);
@@ -1034,34 +1034,34 @@ disconnect_neighbour (struct NeighbourMapEntry *n)
      about disconnect */
   switch (n->state)
   {
-  case GNUNET_TRANSPORT_NOT_CONNECTED:
-  case GNUNET_TRANSPORT_INIT_ATS:
-  case GNUNET_TRANSPORT_INIT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_INIT_ATS:
+  case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
     /* other peer is completely unaware of us, no need to send DISCONNECT */
-    set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
+    set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED);
     free_neighbour (n, GNUNET_NO);
     return;
-  case GNUNET_TRANSPORT_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECT_SENT:
     send_disconnect (n);
-    set_state (n, GNUNET_TRANSPORT_DISCONNECT);
+    set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT);
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
-  case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
     /* we never ACK'ed the other peer's request, no need to send DISCONNECT */
-    set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
+    set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED);
     free_neighbour (n, GNUNET_NO);
     return;
-  case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
     /* we DID ACK the other peer's request, must send DISCONNECT */
     send_disconnect (n);
-    set_state (n, GNUNET_TRANSPORT_DISCONNECT);
+    set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT);
     break;
-  case GNUNET_TRANSPORT_CONNECTED:
-  case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
-  case GNUNET_TRANSPORT_RECONNECT_SENT:
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECTED:
+  case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
     /* we are currently connected, need to send disconnect and do
        internal notifications and update statistics */
     send_disconnect (n);
@@ -1070,21 +1070,21 @@ disconnect_neighbour (struct NeighbourMapEntry *n)
                            --neighbours_connected,
                            GNUNET_NO);
     disconnect_notify_cb (callback_cls, &n->id);
-    set_state (n, GNUNET_TRANSPORT_DISCONNECT);
+    set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT);
     break;
-  case GNUNET_TRANSPORT_RECONNECT_ATS:
+  case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
     /* ATS address request timeout, disconnect without sending disconnect message */
     GNUNET_STATISTICS_set (GST_stats,
                            gettext_noop ("# peers connected"),
                            --neighbours_connected,
                            GNUNET_NO);
     disconnect_notify_cb (callback_cls, &n->id);
-    set_state (n, GNUNET_TRANSPORT_DISCONNECT);
+    set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT);
     break;
-  case GNUNET_TRANSPORT_DISCONNECT:
+  case GNUNET_TRANSPORT_PS_DISCONNECT:
     /* already disconnected, ignore */
     break;
-  case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
+  case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     /* already cleaned up, how did we get here!? */
     GNUNET_assert (0);
     break;
@@ -1250,9 +1250,9 @@ send_keepalive (struct NeighbourMapEntry *n)
   struct GNUNET_TIME_Relative timeout;
   uint32_t nonce;
 
-  GNUNET_assert ((GNUNET_TRANSPORT_CONNECTED == n->state) ||
-                 (GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
-                 (GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT));
+  GNUNET_assert ((GNUNET_TRANSPORT_PS_CONNECTED == n->state) ||
+                 (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
+                 (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT));
   if (GNUNET_TIME_absolute_get_remaining (n->keep_alive_time).rel_value_us > 0)
     return; /* no keepalive needed at this time */
 
@@ -1365,7 +1365,7 @@ GST_neighbours_keepalive_response (const struct GNUNET_PeerIdentity *neighbour,
                               1, GNUNET_NO);
     return;
   }
-  if ( (GNUNET_TRANSPORT_CONNECTED != n->state) ||
+  if ( (GNUNET_TRANSPORT_PS_CONNECTED != n->state) ||
        (GNUNET_YES != n->expect_latency_response) )
   {
     GNUNET_STATISTICS_update (GST_stats,
@@ -1707,7 +1707,7 @@ setup_neighbour (const struct GNUNET_PeerIdentity *peer)
                                  GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT,
                                  MAX_BANDWIDTH_CARRY_S);
   n->task = GNUNET_SCHEDULER_add_now (&master_task, n);
-  set_state_and_timeout (n, GNUNET_TRANSPORT_NOT_CONNECTED, GNUNET_TIME_UNIT_FOREVER_ABS);
+  set_state_and_timeout (n, GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_FOREVER_ABS);
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONTAINER_multipeermap_put (neighbours,
                                                     &n->id, n,
@@ -1780,37 +1780,37 @@ GST_neighbours_try_connect (const struct GNUNET_PeerIdentity *target)
   {
     switch (n->state)
     {
-    case GNUNET_TRANSPORT_NOT_CONNECTED:
+    case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
       /* this should not be possible */
       GNUNET_break (0);
       free_neighbour (n, GNUNET_NO);
       break;
-    case GNUNET_TRANSPORT_INIT_ATS:
-    case GNUNET_TRANSPORT_INIT_BLACKLIST:
-    case GNUNET_TRANSPORT_CONNECT_SENT:
-    case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
-    case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
-    case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
-    case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
+    case GNUNET_TRANSPORT_PS_INIT_ATS:
+    case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
+    case GNUNET_TRANSPORT_PS_CONNECT_SENT:
+    case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
+    case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
+    case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
+    case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Ignoring request to try to connect to `%s', already trying!\n",
                   GNUNET_i2s (target));
       return; /* already trying */
-    case GNUNET_TRANSPORT_CONNECTED:
-    case GNUNET_TRANSPORT_RECONNECT_ATS:
-    case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
-    case GNUNET_TRANSPORT_RECONNECT_SENT:
-    case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
-    case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
+    case GNUNET_TRANSPORT_PS_CONNECTED:
+    case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
+    case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
+    case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
+    case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
+    case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Ignoring request to try to connect, already connected to `%s'!\n",
                   GNUNET_i2s (target));
       return; /* already connected */
-    case GNUNET_TRANSPORT_DISCONNECT:
+    case GNUNET_TRANSPORT_PS_DISCONNECT:
       /* get rid of remains, ready to re-try immediately */
       free_neighbour (n, GNUNET_NO);
       break;
-    case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
+    case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
       /* should not be possible */
       GNUNET_assert (0);
     default:
@@ -1823,7 +1823,7 @@ GST_neighbours_try_connect (const struct GNUNET_PeerIdentity *target)
     }
   }
   n = setup_neighbour (target);
-  set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+  set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
 
   GNUNET_ATS_reset_backoff (GST_ats, target);
   n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, target, &address_suggest_cont, n);
@@ -1880,16 +1880,16 @@ handle_test_blacklist_cont (void *cls,
               n->send_connect_ack);
   switch (n->state)
   {
-  case GNUNET_TRANSPORT_NOT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
     /* this should not be possible */
     GNUNET_break (0);
     free_neighbour (n, GNUNET_NO);
     break;
-  case GNUNET_TRANSPORT_INIT_ATS:
+  case GNUNET_TRANSPORT_PS_INIT_ATS:
     /* waiting on ATS suggestion; still, pass address to ATS as a
        possibility */
     break;
-  case GNUNET_TRANSPORT_INIT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
     /* check if the address the blacklist was fine with matches
        ATS suggestion, if so, we can move on! */
     if ( (GNUNET_OK == result) &&
@@ -1909,16 +1909,16 @@ handle_test_blacklist_cont (void *cls,
     }
     if (GNUNET_OK == result)
     {
-      set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECT_SENT, GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
+      set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_SENT, GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
       send_session_connect (&n->primary_address);
     }
     else
     {
       free_address (&n->primary_address);
-      set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+      set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
     }
     break;
-  case GNUNET_TRANSPORT_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECT_SENT:
     /* waiting on CONNECT_ACK, send ACK if one is pending */
     if ( (GNUNET_OK == result) &&
          (1 == n->send_connect_ack) )
@@ -1929,18 +1929,18 @@ handle_test_blacklist_cont (void *cls,
                                         n->connect_ack_timestamp);
     }
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
-    set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECT_RECV_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
     GNUNET_ATS_reset_backoff (GST_ats, peer);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Suggesting address for peer %s to ATS\n",
                 GNUNET_i2s (peer));
     n->suggest_handle = GNUNET_ATS_suggest_address (GST_ats, peer, &address_suggest_cont, n);
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
     /* waiting on ATS suggestion, don't care about blacklist */
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
     if (GNUNET_YES != address_matches (&bcc->na, &n->primary_address))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -1949,7 +1949,7 @@ handle_test_blacklist_cont (void *cls,
     }
     if (GNUNET_OK == result)
     {
-      set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECT_RECV_ACK, GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
+      set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK, GNUNET_TIME_relative_to_absolute (SETUP_CONNECTION_TIMEOUT));
       send_session_connect_ack_message (bcc->na.address,
                                         bcc->na.session,
                                         n->connect_ack_timestamp);
@@ -1970,11 +1970,11 @@ handle_test_blacklist_cont (void *cls,
       }
       GNUNET_break (NULL != plugin);
       free_address (&n->primary_address);
-      set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+      set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
       GNUNET_ATS_reset_backoff (GST_ats, peer);
     }
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
     /* waiting on SESSION_ACK, send ACK if one is pending */
     if ( (GNUNET_OK == result) &&
          (1 == n->send_connect_ack) )
@@ -1985,13 +1985,13 @@ handle_test_blacklist_cont (void *cls,
                                         n->connect_ack_timestamp);
     }
     break;
-  case GNUNET_TRANSPORT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_CONNECTED:
     /* already connected, don't care about blacklist */
     break;
-  case GNUNET_TRANSPORT_RECONNECT_ATS:
+  case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
     /* still waiting on ATS suggestion, don't care about blacklist */
     break;
-  case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
     if ( (GNUNET_OK == result) &&
          (1 == n->send_connect_ack) )
     {
@@ -2008,15 +2008,15 @@ handle_test_blacklist_cont (void *cls,
     }
     if (GNUNET_OK == result)
     {
-      set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_SENT, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
+      set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_SENT, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
       send_session_connect (&n->primary_address);
     }
     else
     {
-      set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+      set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
     }
     break;
-  case GNUNET_TRANSPORT_RECONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     /* waiting on CONNECT_ACK, don't care about blacklist */
     if ( (GNUNET_OK == result) &&
          (1 == n->send_connect_ack) )
@@ -2027,7 +2027,7 @@ handle_test_blacklist_cont (void *cls,
                                         n->connect_ack_timestamp);
     }
     break;
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
     if (GNUNET_YES != address_matches (&bcc->na, &n->alternative_address))
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -2037,15 +2037,15 @@ handle_test_blacklist_cont (void *cls,
     if (GNUNET_OK == result)
     {
       send_session_connect (&n->alternative_address);
-      set_state (n, GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT);
+      set_state (n, GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT);
     }
     else
     {
-      set_state(n, GNUNET_TRANSPORT_CONNECTED);
+      set_state(n, GNUNET_TRANSPORT_PS_CONNECTED);
       free_address (&n->alternative_address);
     }
     break;
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
     /* waiting on CONNECT_ACK, don't care about blacklist */
     if ( (GNUNET_OK == result) &&
          (1 == n->send_connect_ack) )
@@ -2056,10 +2056,10 @@ handle_test_blacklist_cont (void *cls,
                                         n->connect_ack_timestamp);
     }
     break;
-  case GNUNET_TRANSPORT_DISCONNECT:
+  case GNUNET_TRANSPORT_PS_DISCONNECT:
     /* Nothing to do here, ATS will already do what can be done */
     break;
-  case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
+  case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     /* should not be possible */
     GNUNET_assert (0);
     break;
@@ -2171,26 +2171,26 @@ GST_neighbours_handle_connect (const struct GNUNET_MessageHeader *message,
               n->send_connect_ack);
   switch (n->state)
   {
-  case GNUNET_TRANSPORT_NOT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
     /* Do a blacklist check for the new address */
-    set_state (n, GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND);
+    set_state (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND);
     check_blacklist (peer, ts, address, session);
     break;
-  case GNUNET_TRANSPORT_INIT_ATS:
+  case GNUNET_TRANSPORT_PS_INIT_ATS:
     /* CONNECT message takes priority over us asking ATS for address */
-    set_state (n, GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND);
+    set_state (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND);
     /* fallthrough */
-  case GNUNET_TRANSPORT_INIT_BLACKLIST:
-  case GNUNET_TRANSPORT_CONNECT_SENT:
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
-  case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
-  case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
+  case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
     /* It can never hurt to have an alternative address in the above cases,
        see if it is allowed */
     check_blacklist (peer, ts, address, session);
     break;
-  case GNUNET_TRANSPORT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_CONNECTED:
     /* we are already connected and can thus send the ACK immediately;
        still, it can never hurt to have an alternative address, so also
        tell ATS  about it */
@@ -2201,15 +2201,15 @@ GST_neighbours_handle_connect (const struct GNUNET_MessageHeader *message,
                                       n->primary_address.session, ts);
     check_blacklist (peer, ts, address, session);
     break;
-  case GNUNET_TRANSPORT_RECONNECT_ATS:
-  case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
-  case GNUNET_TRANSPORT_RECONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
+  case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     /* It can never hurt to have an alternative address in the above cases,
        see if it is allowed */
     check_blacklist (peer, ts, address, session);
     break;
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
     /* we are already connected and can thus send the ACK immediately;
        still, it can never hurt to have an alternative address, so also
        tell ATS  about it */
@@ -2220,14 +2220,14 @@ GST_neighbours_handle_connect (const struct GNUNET_MessageHeader *message,
                                       n->primary_address.session, ts);
     check_blacklist (peer, ts, address, session);
     break;
-  case GNUNET_TRANSPORT_DISCONNECT:
+  case GNUNET_TRANSPORT_PS_DISCONNECT:
     /* get rid of remains without terminating sessions, ready to re-try */
     free_neighbour (n, GNUNET_YES);
     n = setup_neighbour (peer);
-    set_state (n, GNUNET_TRANSPORT_CONNECT_RECV_ATS);
+    set_state (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS);
     GNUNET_ATS_reset_backoff (GST_ats, peer);
     break;
-  case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
+  case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     /* should not be possible */
     GNUNET_assert (0);
     break;
@@ -2329,18 +2329,18 @@ GST_neighbours_switch_to_address (const struct GNUNET_PeerIdentity *peer,
   }
   switch (n->state)
   {
-  case GNUNET_TRANSPORT_NOT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
     GNUNET_break (0);
     free_neighbour (n, GNUNET_NO);
     return;
-  case GNUNET_TRANSPORT_INIT_ATS:
+  case GNUNET_TRANSPORT_PS_INIT_ATS:
     set_primary_address (n, address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
-    set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
     check_blacklist (&n->id,
                      n->connect_ack_timestamp,
                      address, session);
     break;
-  case GNUNET_TRANSPORT_INIT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
     /* ATS suggests a different address, switch again */
     set_primary_address (n,
                  address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
@@ -2349,40 +2349,40 @@ GST_neighbours_switch_to_address (const struct GNUNET_PeerIdentity *peer,
                      n->connect_ack_timestamp,
                      address, session);
     break;
-  case GNUNET_TRANSPORT_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECT_SENT:
     /* ATS suggests a different address, switch again */
     set_primary_address (n, address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
-    set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
     check_blacklist (&n->id,
                      n->connect_ack_timestamp,
                      address, session);
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
     set_primary_address (n,
                  address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
-    set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
     check_blacklist (&n->id,
                      n->connect_ack_timestamp,
                      address, session);
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
     set_timeout (n, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
     check_blacklist (&n->id,
                      n->connect_ack_timestamp,
                      address, session);
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
-  case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
     /* ATS asks us to switch while we were trying to connect; switch to new
        address and check blacklist again */
     set_primary_address (n,
                  address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
-    set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
     check_blacklist (&n->id,
                      n->connect_ack_timestamp,
                      address, session);
     break;
-  case GNUNET_TRANSPORT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_CONNECTED:
     GNUNET_assert (NULL != n->primary_address.address);
     GNUNET_assert (NULL != n->primary_address.session);
     if (n->primary_address.session == session)
@@ -2394,21 +2394,21 @@ GST_neighbours_switch_to_address (const struct GNUNET_PeerIdentity *peer,
     }
     /* ATS asks us to switch a life connection; see if we can get
        a CONNECT_ACK on it before we actually do this! */
-    set_state (n, GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST);
+    set_state (n, GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST);
     set_alternative_address (n, address, session, bandwidth_in, bandwidth_out);
     check_blacklist (&n->id,
                      GNUNET_TIME_absolute_get (),
                      address, session);
     break;
-  case GNUNET_TRANSPORT_RECONNECT_ATS:
+  case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
     set_primary_address (n,
                  address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
-    set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
     check_blacklist (&n->id,
                      n->connect_ack_timestamp,
                      address, session);
     break;
-  case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
     /* ATS asks us to switch while we were trying to reconnect; switch to new
        address and check blacklist again */
     set_primary_address (n,
@@ -2418,21 +2418,21 @@ GST_neighbours_switch_to_address (const struct GNUNET_PeerIdentity *peer,
                      n->connect_ack_timestamp,
                      address, session);
     break;
-  case GNUNET_TRANSPORT_RECONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     /* ATS asks us to switch while we were trying to reconnect; switch to new
        address and check blacklist again */
     set_primary_address (n,
                  address, session, bandwidth_in, bandwidth_out, GNUNET_NO);
-    set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (BLACKLIST_RESPONSE_TIMEOUT));
     check_blacklist (&n->id,
                      n->connect_ack_timestamp,
                      address, session);
     break;
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
     if (n->primary_address.session == session)
     {
       /* ATS switches back to still-active session */
-      set_state(n, GNUNET_TRANSPORT_CONNECTED);
+      set_state(n, GNUNET_TRANSPORT_PS_CONNECTED);
       free_address (&n->alternative_address);
       break;
     }
@@ -2443,25 +2443,25 @@ GST_neighbours_switch_to_address (const struct GNUNET_PeerIdentity *peer,
                      GNUNET_TIME_absolute_get (),
                      address, session);
     break;
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
     if (n->primary_address.session == session)
     {
       /* ATS switches back to still-active session */
       free_address (&n->alternative_address);
-      set_state (n, GNUNET_TRANSPORT_CONNECTED);
+      set_state (n, GNUNET_TRANSPORT_PS_CONNECTED);
       break;
     }
     /* ATS asks us to switch a life connection, update blacklist check */
-    set_state (n, GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST);
+    set_state (n, GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST);
     set_alternative_address (n, address, session, bandwidth_in, bandwidth_out);
     check_blacklist (&n->id,
                      GNUNET_TIME_absolute_get (),
                      address, session);
     break;
-  case GNUNET_TRANSPORT_DISCONNECT:
+  case GNUNET_TRANSPORT_PS_DISCONNECT:
     /* not going to switch addresses while disconnecting */
     return;
-  case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
+  case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     GNUNET_assert (0);
     break;
   default:
@@ -2639,35 +2639,35 @@ master_task (void *cls,
                                                       GNUNET_YES));
   switch (n->state)
   {
-  case GNUNET_TRANSPORT_NOT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
     /* invalid state for master task, clean up */
     GNUNET_break (0);
-    set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
+    set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED);
     free_neighbour (n, GNUNET_NO);
     return;
-  case GNUNET_TRANSPORT_INIT_ATS:
+  case GNUNET_TRANSPORT_PS_INIT_ATS:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "Connection to `%s' timed out waiting for ATS to provide address\n",
                   GNUNET_i2s (&n->id));
-      set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
+      set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED);
       free_neighbour (n, GNUNET_NO);
       return;
     }
     break;
-  case GNUNET_TRANSPORT_INIT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Connection to `%s' timed out waiting for BLACKLIST to approve address\n",
                   GNUNET_i2s (&n->id));
-      set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
+      set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED);
       free_neighbour (n, GNUNET_NO);
       return;
     }
     break;
-  case GNUNET_TRANSPORT_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECT_SENT:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
@@ -2683,40 +2683,40 @@ master_task (void *cls,
       return;
     }
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Connection to `%s' timed out waiting BLACKLIST to approve address to use for received CONNECT\n",
                   GNUNET_i2s (&n->id));
-      set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
+      set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED);
       free_neighbour (n, GNUNET_NO);
       return;
     }
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Connection to `%s' timed out waiting ATS to provide address to use for CONNECT_ACK\n",
                   GNUNET_i2s (&n->id));
-      set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
+      set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED);
       free_neighbour (n, GNUNET_NO);
       return;
     }
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Connection to `%s' timed out waiting BLACKLIST to approve address to use for CONNECT_ACK\n",
                   GNUNET_i2s (&n->id));
-      set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
+      set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED);
       free_neighbour (n, GNUNET_NO);
       return;
     }
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -2726,7 +2726,7 @@ master_task (void *cls,
       return;
     }
     break;
-  case GNUNET_TRANSPORT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_CONNECTED:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -2738,7 +2738,7 @@ master_task (void *cls,
     try_transmission_to_peer (n);
     send_keepalive (n);
     break;
-  case GNUNET_TRANSPORT_RECONNECT_ATS:
+  case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -2748,7 +2748,7 @@ master_task (void *cls,
       return;
     }
     break;
-  case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -2758,7 +2758,7 @@ master_task (void *cls,
       return;
     }
     break;
-  case GNUNET_TRANSPORT_RECONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -2768,7 +2768,7 @@ master_task (void *cls,
       return;
     }
     break;
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -2780,7 +2780,7 @@ master_task (void *cls,
     try_transmission_to_peer (n);
     send_keepalive (n);
     break;
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
     if (0 == delay.rel_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -2792,13 +2792,13 @@ master_task (void *cls,
     try_transmission_to_peer (n);
     send_keepalive (n);
     break;
-  case GNUNET_TRANSPORT_DISCONNECT:
+  case GNUNET_TRANSPORT_PS_DISCONNECT:
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Cleaning up connection to `%s' after sending DISCONNECT\n",
                 GNUNET_i2s (&n->id));
     free_neighbour (n, GNUNET_NO);
     return;
-  case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
+  case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     /* how did we get here!? */
     GNUNET_assert (0);
     break;
@@ -2809,9 +2809,9 @@ master_task (void *cls,
     GNUNET_break (0);
     break;
   }
-  if ( (GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT == n->state) ||
-       (GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
-       (GNUNET_TRANSPORT_CONNECTED == n->state) )
+  if ( (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT == n->state) ||
+       (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
+       (GNUNET_TRANSPORT_PS_CONNECTED == n->state) )
   {
     /* if we are *now* in one of these three states, we're sending
        keep alive messages, so we need to consider the keepalive
@@ -2893,25 +2893,25 @@ GST_neighbours_handle_connect_ack (const struct GNUNET_MessageHeader *message,
   ts = GNUNET_TIME_absolute_ntoh (scm->timestamp);
   switch (n->state)
   {
-  case GNUNET_TRANSPORT_NOT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
     GNUNET_break (0);
     free_neighbour (n, GNUNET_NO);
     return GNUNET_SYSERR;
-  case GNUNET_TRANSPORT_INIT_ATS:
-  case GNUNET_TRANSPORT_INIT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_INIT_ATS:
+  case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop
                               ("# unexpected CONNECT_ACK messages (not ready)"),
                               1, GNUNET_NO);
     break;
-  case GNUNET_TRANSPORT_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECT_SENT:
     if (ts.abs_value_us != n->primary_address.connect_timestamp.abs_value_us)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   "CONNECT_ACK ignored as the timestamp does not match our CONNECT request\n");
       return GNUNET_OK;
     }
-    set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
     GNUNET_STATISTICS_set (GST_stats,
                            gettext_noop ("# peers connected"),
                            ++neighbours_connected,
@@ -2931,21 +2931,21 @@ GST_neighbours_handle_connect_ack (const struct GNUNET_MessageHeader *message,
                  GNUNET_YES);
     send_session_ack_message (n);
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
-  case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
-  case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop
                               ("# unexpected CONNECT_ACK messages (not ready)"),
                               1, GNUNET_NO);
     break;
-  case GNUNET_TRANSPORT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_CONNECTED:
     /* duplicate CONNECT_ACK, let's answer by duplciate SESSION_ACK just in case */
     send_session_ack_message (n);
     break;
-  case GNUNET_TRANSPORT_RECONNECT_ATS:
-  case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
+  case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
     /* we didn't expect any CONNECT_ACK, as we are waiting for ATS
        to give us a new address... */
     GNUNET_STATISTICS_update (GST_stats,
@@ -2953,18 +2953,18 @@ GST_neighbours_handle_connect_ack (const struct GNUNET_MessageHeader *message,
                               ("# unexpected CONNECT_ACK messages (waiting on ATS)"),
                               1, GNUNET_NO);
     break;
-  case GNUNET_TRANSPORT_RECONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     /* new address worked; go back to connected! */
-    set_state (n, GNUNET_TRANSPORT_CONNECTED);
+    set_state (n, GNUNET_TRANSPORT_PS_CONNECTED);
     send_session_ack_message (n);
     break;
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
     /* duplicate CONNECT_ACK, let's answer by duplciate SESSION_ACK just in case */
     send_session_ack_message (n);
     break;
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
     /* new address worked; adopt it and go back to connected! */
-    set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
     GNUNET_break (GNUNET_NO == n->alternative_address.ats_active);
 
     GST_ats_add_address (n->alternative_address.address,
@@ -2977,13 +2977,13 @@ GST_neighbours_handle_connect_ack (const struct GNUNET_MessageHeader *message,
     free_address (&n->alternative_address);
     send_session_ack_message (n);
     break;
-  case GNUNET_TRANSPORT_DISCONNECT:
+  case GNUNET_TRANSPORT_PS_DISCONNECT:
     GNUNET_STATISTICS_update (GST_stats,
                               gettext_noop
                               ("# unexpected CONNECT_ACK messages (disconnecting)"),
                               1, GNUNET_NO);
     return GNUNET_SYSERR;
-  case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
+  case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     GNUNET_assert (0);
     break;
   default:
@@ -3036,9 +3036,9 @@ GST_neighbours_session_terminated (const struct GNUNET_PeerIdentity *peer,
   {
     if (session == n->alternative_address.session)
     {
-      if ( (GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
-           (GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT == n->state) )
-        set_state (n, GNUNET_TRANSPORT_CONNECTED);
+      if ( (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST == n->state) ||
+           (GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT == n->state) )
+        set_state (n, GNUNET_TRANSPORT_PS_CONNECTED);
       else
         GNUNET_break (0);
       free_address (&n->alternative_address);
@@ -3049,59 +3049,59 @@ GST_neighbours_session_terminated (const struct GNUNET_PeerIdentity *peer,
   n->expect_latency_response = GNUNET_NO;
   switch (n->state)
   {
-  case GNUNET_TRANSPORT_NOT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
     GNUNET_break (0);
     free_neighbour (n, GNUNET_NO);
     return GNUNET_YES;
-  case GNUNET_TRANSPORT_INIT_ATS:
+  case GNUNET_TRANSPORT_PS_INIT_ATS:
     GNUNET_break (0);
     free_neighbour (n, GNUNET_NO);
     return GNUNET_YES;
-  case GNUNET_TRANSPORT_INIT_BLACKLIST:
-  case GNUNET_TRANSPORT_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_SENT:
     free_address (&n->primary_address);
-    set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
     break;
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
-  case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
-  case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
     /* error on inbound session; free neighbour entirely */
     free_address (&n->primary_address);
     free_neighbour (n, GNUNET_NO);
     return GNUNET_YES;
-  case GNUNET_TRANSPORT_CONNECTED:
-    set_state_and_timeout (n, GNUNET_TRANSPORT_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+  case GNUNET_TRANSPORT_PS_CONNECTED:
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_INIT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
     free_address (&n->primary_address);
     break;
-  case GNUNET_TRANSPORT_RECONNECT_ATS:
+  case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
     /* we don't have an address, how can it go down? */
     GNUNET_break (0);
     break;
-  case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
-  case GNUNET_TRANSPORT_RECONNECT_SENT:
-    set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
+  case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_ATS, GNUNET_TIME_relative_to_absolute (ATS_RESPONSE_TIMEOUT));
     break;
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
     /* primary went down while we were checking secondary against
        blacklist, adopt secondary as primary */
     free_address (&n->primary_address);
-    set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
     n->primary_address = n->alternative_address;
     memset (&n->alternative_address, 0, sizeof (struct NeighbourAddress));
     break;
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
     /* primary went down while we were waiting for CONNECT_ACK on secondary;
        secondary as primary */
     free_address (&n->primary_address);
     n->primary_address = n->alternative_address;
     memset (&n->alternative_address, 0, sizeof (struct NeighbourAddress));
-    set_state_and_timeout (n, GNUNET_TRANSPORT_RECONNECT_SENT, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
+    set_state_and_timeout (n, GNUNET_TRANSPORT_PS_RECONNECT_SENT, GNUNET_TIME_relative_to_absolute (FAST_RECONNECT_TIMEOUT));
     break;
-  case GNUNET_TRANSPORT_DISCONNECT:
+  case GNUNET_TRANSPORT_PS_DISCONNECT:
     free_address (&n->primary_address);
     break;
-  case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
+  case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     /* neighbour was freed and plugins told to terminate session */
     return GNUNET_NO;
     break;
@@ -3158,8 +3158,8 @@ GST_neighbours_handle_session_ack (const struct GNUNET_MessageHeader *message,
   }
   /* check if we are in a plausible state for having sent
      a CONNECT_ACK.  If not, return, otherwise break */
-  if ( ( (GNUNET_TRANSPORT_CONNECT_RECV_ACK != n->state) &&
-         (GNUNET_TRANSPORT_CONNECT_SENT != n->state) ) ||
+  if ( ( (GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK != n->state) &&
+         (GNUNET_TRANSPORT_PS_CONNECT_SENT != n->state) ) ||
        (2 != n->send_connect_ack) )
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -3172,7 +3172,7 @@ GST_neighbours_handle_session_ack (const struct GNUNET_MessageHeader *message,
                               GNUNET_NO);
     return GNUNET_OK;
   }
-  set_state_and_timeout (n, GNUNET_TRANSPORT_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
+  set_state_and_timeout (n, GNUNET_TRANSPORT_PS_CONNECTED, GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT));
   GNUNET_STATISTICS_set (GST_stats,
                          gettext_noop ("# peers connected"),
                          ++neighbours_connected,
@@ -3442,23 +3442,23 @@ GST_neighbour_get_latency (const struct GNUNET_PeerIdentity *peer)
     return GNUNET_TIME_UNIT_FOREVER_REL;
   switch (n->state)
   {
-  case GNUNET_TRANSPORT_CONNECTED:
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
-  case GNUNET_TRANSPORT_RECONNECT_SENT:
-  case GNUNET_TRANSPORT_RECONNECT_ATS:
-  case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECTED:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
+  case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
     return n->latency;
-  case GNUNET_TRANSPORT_NOT_CONNECTED:
-  case GNUNET_TRANSPORT_INIT_BLACKLIST:
-  case GNUNET_TRANSPORT_INIT_ATS:
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
-  case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
-  case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
-  case GNUNET_TRANSPORT_CONNECT_SENT:
-  case GNUNET_TRANSPORT_DISCONNECT:
-  case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
+  case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_INIT_ATS:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
+  case GNUNET_TRANSPORT_PS_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_DISCONNECT:
+  case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     return GNUNET_TIME_UNIT_FOREVER_REL;
   default:
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -3534,7 +3534,7 @@ disconnect_all_neighbours (void *cls,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Disconnecting peer `%4s', %s\n",
               GNUNET_i2s (&n->id), "SHUTDOWN_TASK");
-  set_state (n, GNUNET_TRANSPORT_DISCONNECT_FINISHED);
+  set_state (n, GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED);
   free_neighbour (n, GNUNET_NO);
   return GNUNET_OK;
 }
diff --git a/src/transport/transport_api_monitoring.c b/src/transport/transport_api_monitoring.c
index 92ab2042c..ef7a01040 100644
--- a/src/transport/transport_api_monitoring.c
+++ b/src/transport/transport_api_monitoring.c
@@ -151,24 +151,24 @@ GNUNET_TRANSPORT_is_connected (enum GNUNET_TRANSPORT_PeerState state)
 {
   switch (state)
   {
-  case GNUNET_TRANSPORT_NOT_CONNECTED:
-  case GNUNET_TRANSPORT_INIT_ATS:
-  case GNUNET_TRANSPORT_INIT_BLACKLIST:
-  case GNUNET_TRANSPORT_CONNECT_SENT:
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
-  case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
-  case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
+  case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_INIT_ATS:
+  case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
     return GNUNET_NO;
-  case GNUNET_TRANSPORT_CONNECTED:
-  case GNUNET_TRANSPORT_RECONNECT_ATS:
-  case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
-  case GNUNET_TRANSPORT_RECONNECT_SENT:
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECTED:
+  case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
+  case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
     return GNUNET_YES;
-  case GNUNET_TRANSPORT_DISCONNECT:
-  case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
+  case GNUNET_TRANSPORT_PS_DISCONNECT:
+  case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     return GNUNET_NO;
   default:
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -191,37 +191,37 @@ GNUNET_TRANSPORT_p2s (enum GNUNET_TRANSPORT_PeerState state)
 {
   switch (state)
   {
-  case GNUNET_TRANSPORT_NOT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_NOT_CONNECTED:
     return "S_NOT_CONNECTED";
-  case GNUNET_TRANSPORT_INIT_ATS:
+  case GNUNET_TRANSPORT_PS_INIT_ATS:
     return "S_INIT_ATS";
-  case GNUNET_TRANSPORT_INIT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_INIT_BLACKLIST:
     return "S_INIT_BLACKLIST";
-  case GNUNET_TRANSPORT_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECT_SENT:
     return "S_CONNECT_SENT";
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND:
     return "S_CONNECT_RECV_BLACKLIST_INBOUND";
-  case GNUNET_TRANSPORT_CONNECT_RECV_ATS:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS:
     return "S_CONNECT_RECV_ATS";
-  case GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST:
     return "S_CONNECT_RECV_BLACKLIST";
-  case GNUNET_TRANSPORT_CONNECT_RECV_ACK:
+  case GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK:
     return "S_CONNECT_RECV_ACK";
-  case GNUNET_TRANSPORT_CONNECTED:
+  case GNUNET_TRANSPORT_PS_CONNECTED:
     return "S_CONNECTED";
-  case GNUNET_TRANSPORT_RECONNECT_ATS:
+  case GNUNET_TRANSPORT_PS_RECONNECT_ATS:
     return "S_RECONNECT_ATS";
-  case GNUNET_TRANSPORT_RECONNECT_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST:
     return "S_RECONNECT_BLACKLIST";
-  case GNUNET_TRANSPORT_RECONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_RECONNECT_SENT:
     return "S_RECONNECT_SENT";
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST:
     return "S_CONNECTED_SWITCHING_BLACKLIST";
-  case GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT:
+  case GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT:
     return "S_CONNECTED_SWITCHING_CONNECT_SENT";
-  case GNUNET_TRANSPORT_DISCONNECT:
+  case GNUNET_TRANSPORT_PS_DISCONNECT:
     return "S_DISCONNECT";
-  case GNUNET_TRANSPORT_DISCONNECT_FINISHED:
+  case GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED:
     return "S_DISCONNECT_FINISHED";
   default:
     GNUNET_break (0);
@@ -327,8 +327,9 @@ peer_response_processor (void *cls,
   {
     if (pal_ctx->one_shot)
     {
+      /* Disconnect */
       pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
-          GNUNET_TRANSPORT_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
+          GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
       GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
     }
     else
@@ -342,11 +343,11 @@ peer_response_processor (void *cls,
       GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_RESPONSE);
   if (size == sizeof (struct GNUNET_MessageHeader))
   {
-    /* done! */
+    /* Done! */
     if (pal_ctx->one_shot)
     {
       pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
-          GNUNET_TRANSPORT_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
+          GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
       GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
     }
     else
@@ -364,7 +365,7 @@ peer_response_processor (void *cls,
     if (pal_ctx->one_shot)
     {
       pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
-          GNUNET_TRANSPORT_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
+          GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
       GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
     }
     else
@@ -384,7 +385,7 @@ peer_response_processor (void *cls,
     if (pal_ctx->one_shot)
     {
       pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
-          GNUNET_TRANSPORT_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
+          GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
       GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
     }
     else
@@ -394,28 +395,37 @@ peer_response_processor (void *cls,
     return;
   }
 
-  if (alen == 0 && tlen == 0)
+
+  if ( (0 == tlen) && (0 == alen) )
   {
+    /* No address available */
     pal_ctx->cb (pal_ctx->cb_cls, &pir_msg->peer, NULL,
-        GNUNET_TRANSPORT_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
+        ntohl(pir_msg->state),
+        GNUNET_TIME_absolute_ntoh (pir_msg->state_timeout));
   }
   else
   {
+    if (0 == tlen)
+    {
+      GNUNET_break (0); /* This must not happen: address without plugin */
+      return;
+    }
     addr = (const char *) &pir_msg[1];
     transport_name = &addr[alen];
 
     if (transport_name[tlen - 1] != '\0')
     {
+      /* Corrupt plugin name */
       GNUNET_break (0);
-      if (pal_ctx->one_shot)    
+      if (pal_ctx->one_shot)
       {
-        pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
-            GNUNET_TRANSPORT_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
-        GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
+        pal_ctx->cb (pal_ctx->cb_cls, NULL, NULL,
+            GNUNET_TRANSPORT_PS_NOT_CONNECTED, GNUNET_TIME_UNIT_ZERO_ABS);
+        GNUNET_TRANSPORT_monitor_peers_cancel (pal_ctx);
       }
       else
       {
-        reconnect (pal_ctx);
+        reconnect (pal_ctx);
       }
       return;
     }
@@ -427,6 +437,7 @@ peer_response_processor (void *cls,
         ntohl(pir_msg->state),
         GNUNET_TIME_absolute_ntoh (pir_msg->state_timeout));
     GNUNET_HELLO_address_free (address);
+
   }
 
   /* expect more replies */