[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r31876 - in gnunet/src: include transport
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] r31876 - in gnunet/src: include transport |
|
Date: |
Fri, 10 Jan 2014 10:36:58 +0100 |
Author: wachs
Date: 2014-01-10 10:36:58 +0100 (Fri, 10 Jan 2014)
New Revision: 31876
Modified:
gnunet/src/include/gnunet_transport_service.h
gnunet/src/transport/gnunet-service-transport_neighbours.c
gnunet/src/transport/transport_api_monitoring.c
Log:
naming conventions for peer states
Modified: gnunet/src/include/gnunet_transport_service.h
===================================================================
--- gnunet/src/include/gnunet_transport_service.h 2014-01-10 09:11:15 UTC
(rev 31875)
+++ gnunet/src/include/gnunet_transport_service.h 2014-01-10 09:36:58 UTC
(rev 31876)
@@ -108,77 +108,77 @@
enum GNUNET_TRANSPORT_PeerState
{
/**
- * fresh peer or completely disconnected
+ * Fresh peer or completely disconnected
*/
- GNUNET_TRANSPORT_NOT_CONNECTED = 0,
+ GNUNET_TRANSPORT_PS_NOT_CONNECTED = 0,
/**
* Asked to initiate connection, trying to get address from ATS
*/
- GNUNET_TRANSPORT_INIT_ATS,
+ GNUNET_TRANSPORT_PS_INIT_ATS,
/**
* Asked to initiate connection, trying to get address approved
* by blacklist.
*/
- GNUNET_TRANSPORT_INIT_BLACKLIST,
+ GNUNET_TRANSPORT_PS_INIT_BLACKLIST,
/**
* Sent CONNECT message to other peer, waiting for CONNECT_ACK
*/
- GNUNET_TRANSPORT_CONNECT_SENT,
+ GNUNET_TRANSPORT_PS_CONNECT_SENT,
/**
* Received a CONNECT, do a blacklist check for inbound address
*/
- GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST_INBOUND,
+ GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST_INBOUND,
/**
* Received a CONNECT, asking ATS about address suggestions.
*/
- GNUNET_TRANSPORT_CONNECT_RECV_ATS,
+ GNUNET_TRANSPORT_PS_CONNECT_RECV_ATS,
/**
* Received CONNECT from other peer, got an address, checking with blacklist.
*/
- GNUNET_TRANSPORT_CONNECT_RECV_BLACKLIST,
+ GNUNET_TRANSPORT_PS_CONNECT_RECV_BLACKLIST,
/**
* CONNECT request from other peer was SESSION_ACK'ed, waiting for
* SESSION_ACK.
*/
- GNUNET_TRANSPORT_CONNECT_RECV_ACK,
+ GNUNET_TRANSPORT_PS_CONNECT_RECV_ACK,
/**
* Got our CONNECT_ACK/SESSION_ACK, connection is up.
*/
- GNUNET_TRANSPORT_CONNECTED,
+ GNUNET_TRANSPORT_PS_CONNECTED,
/**
* Connection got into trouble, rest of the system still believes
* it to be up, but we're getting a new address from ATS.
*/
- GNUNET_TRANSPORT_RECONNECT_ATS,
+ GNUNET_TRANSPORT_PS_RECONNECT_ATS,
/**
* Connection got into trouble, rest of the system still believes
* it to be up; we are checking the new address against the blacklist.
*/
- GNUNET_TRANSPORT_RECONNECT_BLACKLIST,
+ GNUNET_TRANSPORT_PS_RECONNECT_BLACKLIST,
/**
* Sent CONNECT over new address (either by ATS telling us to switch
* addresses or from RECONNECT_ATS); if this fails, we need to tell
* the rest of the system about a disconnect.
*/
- GNUNET_TRANSPORT_RECONNECT_SENT,
+ GNUNET_TRANSPORT_PS_RECONNECT_SENT,
/**
* We have some primary connection, but ATS suggested we switch
* to some alternative; we're now checking the alternative against
* the blacklist.
*/
- GNUNET_TRANSPORT_CONNECTED_SWITCHING_BLACKLIST,
+ GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_BLACKLIST,
/**
* We have some primary connection, but ATS suggested we switch
@@ -186,13 +186,13 @@
* alternative session to the other peer and waiting for a
* CONNECT_ACK to make this our primary connection.
*/
- GNUNET_TRANSPORT_CONNECTED_SWITCHING_CONNECT_SENT,
+ GNUNET_TRANSPORT_PS_CONNECTED_SWITCHING_CONNECT_SENT,
/**
* Disconnect in progress (we're sending the DISCONNECT message to the
* other peer; after that is finished, the state will be cleaned up).
*/
- GNUNET_TRANSPORT_DISCONNECT,
+ GNUNET_TRANSPORT_PS_DISCONNECT,
/**
* We're finished with the disconnect; and are cleaning up the state
@@ -203,7 +203,7 @@
* in this state virtually always means using memory that has been
* freed (the exception being the cleanup code in #free_neighbour()).
*/
- GNUNET_TRANSPORT_DISCONNECT_FINISHED
+ GNUNET_TRANSPORT_PS_DISCONNECT_FINISHED
};
@@ -286,7 +286,8 @@
* Function to call with information about a peer
*
* If one_shot was set to GNUNET_YES to iterate over all peers once,
- * a final call with NULL for peer and address will follow when done
+ * a final call with NULL for peer and address will follow when done.
+ * In this case state and timeout do not contain valid values.
*
* The #GNUNET_TRANSPORT_monitor_peers_cancel call MUST not be called from
* within this function!
Modified: gnunet/src/transport/gnunet-service-transport_neighbours.c
===================================================================
--- gnunet/src/transport/gnunet-service-transport_neighbours.c 2014-01-10
09:11:15 UTC (rev 31875)
+++ gnunet/src/transport/gnunet-service-transport_neighbours.c 2014-01-10
09:36:58 UTC (rev 31876)
@@ -839,7 +839,7 @@
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 @@
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 @@
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 @@
--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 @@
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 @@
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 @@
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 @@
{
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 @@
}
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
}
/* 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
("# 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 @@
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 @@
{
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 @@
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 @@
}
/* 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 @@
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 @@
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 @@
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;
}
Modified: gnunet/src/transport/transport_api_monitoring.c
===================================================================
--- gnunet/src/transport/transport_api_monitoring.c 2014-01-10 09:11:15 UTC
(rev 31875)
+++ gnunet/src/transport/transport_api_monitoring.c 2014-01-10 09:36:58 UTC
(rev 31876)
@@ -151,24 +151,24 @@
{
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 @@
{
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 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
ntohl(pir_msg->state),
GNUNET_TIME_absolute_ntoh (pir_msg->state_timeout));
GNUNET_HELLO_address_free (address);
+
}
/* expect more replies */
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r31876 - in gnunet/src: include transport,
gnunet <=