ping: Conform to the spec & exclude from connection keep-alive

src/error.rs

@@ -188,6 +188,7 @@ pub enum ParseError {
 
 #[derive(Debug, thiserror::Error)]
 pub enum SubstreamError {
+    // Note: this can mean as well `SubstreamClosed`.
     #[error("Connection closed")]
     ConnectionClosed,
     #[error("Connection channel clogged")]

src/lib.rs

@@ -38,6 +38,7 @@ use crate::{
         mdns::Mdns,
         notification::NotificationProtocol,
         request_response::RequestResponseProtocol,
+        SubstreamKeepAlive,
     },
     transport::{
         manager::{SupportedTransport, TransportManager, TransportManagerBuilder},
@@ -198,6 +199,7 @@ impl Litep2p {
                 config.fallback_names.clone(),
                 config.codec,
                 litep2p_config.keep_alive_timeout,
+                SubstreamKeepAlive::Yes,
             );
             let executor = Arc::clone(&litep2p_config.executor);
             litep2p_config.executor.run(Box::pin(async move {
@@ -218,6 +220,7 @@ impl Litep2p {
                 config.fallback_names.clone(),
                 config.codec,
                 litep2p_config.keep_alive_timeout,
+                SubstreamKeepAlive::Yes,
             );
             litep2p_config.executor.run(Box::pin(async move {
                 RequestResponseProtocol::new(service, config).run().await
@@ -233,6 +236,8 @@ impl Litep2p {
                 Vec::new(),
                 protocol.codec(),
                 litep2p_config.keep_alive_timeout,
+                // TODO: make configurable by user.
+                SubstreamKeepAlive::Yes,
             );
             litep2p_config.executor.run(Box::pin(async move {
                 let _ = protocol.run(service).await;
@@ -252,6 +257,7 @@ impl Litep2p {
                 Vec::new(),
                 ping_config.codec,
                 litep2p_config.keep_alive_timeout,
+                SubstreamKeepAlive::No,
             );
             litep2p_config.executor.run(Box::pin(async move {
                 Ping::new(service, ping_config).run().await
@@ -275,6 +281,7 @@ impl Litep2p {
                 fallback_names,
                 kademlia_config.codec,
                 litep2p_config.keep_alive_timeout,
+                SubstreamKeepAlive::Yes,
             );
             litep2p_config.executor.run(Box::pin(async move {
                 let _ = Kademlia::new(service, kademlia_config).run().await;
@@ -296,6 +303,7 @@ impl Litep2p {
                     Vec::new(),
                     identify_config.codec,
                     litep2p_config.keep_alive_timeout,
+                    SubstreamKeepAlive::No,
                 );
                 identify_config.public = Some(litep2p_config.keypair.public().into());
 
@@ -316,6 +324,7 @@ impl Litep2p {
                 Vec::new(),
                 bitswap_config.codec,
                 litep2p_config.keep_alive_timeout,
+                SubstreamKeepAlive::Yes,
             );
             litep2p_config.executor.run(Box::pin(async move {
                 Bitswap::new(service, bitswap_config).run().await

src/multistream_select/listener_select.rs

@@ -348,8 +348,8 @@ pub enum ListenerSelectResult {
 /// Parse protocols offered by the remote peer and check if any of the offered protocols match
 /// locally available protocols. If a match is found, return an encoded multistream-select
 /// response and the negotiated protocol. If parsing fails or no match is found, return an error.
-pub fn webrtc_listener_negotiate<'a>(
-    supported_protocols: &'a mut impl Iterator<Item = &'a ProtocolName>,
+pub fn webrtc_listener_negotiate(
+    supported_protocols: Vec<ProtocolName>,
     mut payload: Bytes,
 ) -> crate::Result<ListenerSelectResult> {
     let protocols = drain_trailing_protocols(payload)?;
@@ -370,7 +370,7 @@ pub fn webrtc_listener_negotiate<'a>(
             "listener: checking protocol",
         );
 
-        for supported in &mut *supported_protocols {
+        for supported in supported_protocols.iter() {
             if protocol.as_ref() == supported.as_bytes() {
                 return Ok(ListenerSelectResult::Accepted {
                     protocol: supported.clone(),
@@ -400,7 +400,7 @@ mod tests {
 
     #[test]
     fn webrtc_listener_negotiate_works() {
-        let mut local_protocols = [
+        let local_protocols = vec![
             ProtocolName::from("/13371338/proto/1"),
             ProtocolName::from("/sup/proto/1"),
             ProtocolName::from("/13371338/proto/2"),
@@ -414,7 +414,7 @@ mod tests {
         .unwrap()
         .freeze();
 
-        match webrtc_listener_negotiate(&mut local_protocols.iter(), message) {
+        match webrtc_listener_negotiate(local_protocols, message) {
             Err(error) => panic!("error received: {error:?}"),
             Ok(ListenerSelectResult::Rejected { .. }) => panic!("message rejected"),
             Ok(ListenerSelectResult::Accepted { protocol, message }) => {
@@ -425,7 +425,7 @@ mod tests {
 
     #[test]
     fn invalid_message() {
-        let mut local_protocols = [
+        let local_protocols = vec![
             ProtocolName::from("/13371338/proto/1"),
             ProtocolName::from("/sup/proto/1"),
             ProtocolName::from("/13371338/proto/2"),
@@ -454,7 +454,7 @@ mod tests {
         .unwrap()
         .freeze();
 
-        match webrtc_listener_negotiate(&mut local_protocols.iter(), message) {
+        match webrtc_listener_negotiate(local_protocols, message) {
             Err(error) => assert!(std::matches!(
                 error,
                 // something has gone off the rails here...
@@ -468,7 +468,7 @@ mod tests {
 
     #[test]
     fn only_header_line_received() {
-        let mut local_protocols = [
+        let local_protocols = vec![
             ProtocolName::from("/13371338/proto/1"),
             ProtocolName::from("/sup/proto/1"),
             ProtocolName::from("/13371338/proto/2"),
@@ -481,7 +481,7 @@ mod tests {
         let message = Message::Header(HeaderLine::V1);
         message.encode(&mut bytes).map_err(|_| Error::InvalidData).unwrap();
 
-        match webrtc_listener_negotiate(&mut local_protocols.iter(), bytes.freeze()) {
+        match webrtc_listener_negotiate(local_protocols, bytes.freeze()) {
             Err(error) => assert!(std::matches!(
                 error,
                 Error::NegotiationError(error::NegotiationError::ParseError(
@@ -494,7 +494,7 @@ mod tests {
 
     #[test]
     fn header_line_missing() {
-        let mut local_protocols = [
+        let local_protocols = vec![
             ProtocolName::from("/13371338/proto/1"),
             ProtocolName::from("/sup/proto/1"),
             ProtocolName::from("/13371338/proto/2"),
@@ -514,7 +514,7 @@ mod tests {
                     .unwrap();
             });
 
-        match webrtc_listener_negotiate(&mut local_protocols.iter(), bytes.freeze()) {
+        match webrtc_listener_negotiate(local_protocols, bytes.freeze()) {
             Err(error) => assert!(std::matches!(
                 error,
                 Error::NegotiationError(error::NegotiationError::MultistreamSelectError(
@@ -527,7 +527,7 @@ mod tests {
 
     #[test]
     fn protocol_not_supported() {
-        let mut local_protocols = [
+        let mut local_protocols = vec![
             ProtocolName::from("/13371338/proto/1"),
             ProtocolName::from("/sup/proto/1"),
             ProtocolName::from("/13371338/proto/2"),
@@ -540,7 +540,7 @@ mod tests {
         .unwrap()
         .freeze();
 
-        match webrtc_listener_negotiate(&mut local_protocols.iter(), message) {
+        match webrtc_listener_negotiate(local_protocols, message) {
             Err(error) => panic!("error received: {error:?}"),
             Ok(ListenerSelectResult::Rejected { message }) => {
                 assert_eq!(

src/protocol/connection.rs

@@ -22,7 +22,7 @@
 
 use crate::{
     error::{Error, SubstreamError},
-    protocol::protocol_set::ProtocolCommand,
+    protocol::{protocol_set::ProtocolCommand, transport_service::SubstreamKeepAlive},
     types::{protocol::ProtocolName, ConnectionId, SubstreamId},
 };
 
@@ -119,6 +119,7 @@ impl ConnectionHandle {
         fallback_names: Vec<ProtocolName>,
         substream_id: SubstreamId,
         permit: Permit,
+        keep_alive: SubstreamKeepAlive,
     ) -> Result<(), SubstreamError> {
         match &self.connection {
             ConnectionType::Active(active) => active.clone(),
@@ -131,6 +132,7 @@ impl ConnectionHandle {
             substream_id,
             connection_id: self.connection_id,
             permit,
+            keep_alive,
         })
         .map_err(|error| match error {
             TrySendError::Full(_) => SubstreamError::ChannelClogged,
@@ -158,7 +160,18 @@ impl ConnectionHandle {
     }
 }
 
-/// Type which allows the connection to be kept open.
+/// Type which allows to keep the connection opened and not allow the keep-alive mechanism to close
+/// it.
+///
+/// The [`Permit`] is created when beginning to open a substream and passed on until it reaches
+/// [`TransportService`](crate::protocol::TransportService), where the connection is upgraded
+/// (which means it won't be closed) and the permit is not needed anymore and dropped.
+///
+/// The [`Permit`] as also stored in the context of substreams that need to keep the connection
+/// alive while they exist (i.e., marked with [`SubstreamKeepAlive::Yes`]).
+///
+/// The permit is designed to be short-lived, please ensure it is dropped as soon as it is no longer
+/// relevant
 #[derive(Debug, Clone)]
 pub struct Permit {
     /// Active connection.
@@ -205,6 +218,7 @@ mod tests {
             Vec::new(),
             SubstreamId::new(),
             permit,
+            SubstreamKeepAlive::Yes,
         );
 
         assert!(result.is_ok());
@@ -224,6 +238,7 @@ mod tests {
             Vec::new(),
             SubstreamId::new(),
             permit,
+            SubstreamKeepAlive::Yes,
         );
 
         assert!(result.is_err());
@@ -241,6 +256,7 @@ mod tests {
             Vec::new(),
             SubstreamId::new(),
             permit,
+            SubstreamKeepAlive::Yes,
         );
         assert!(result.is_ok());
 
@@ -250,6 +266,7 @@ mod tests {
             Vec::new(),
             SubstreamId::new(),
             permit,
+            SubstreamKeepAlive::Yes,
         ) {
             Err(SubstreamError::ChannelClogged) => {}
             error => panic!("invalid error: {error:?}"),

src/protocol/libp2p/kademlia/mod.rs

@@ -1417,7 +1417,7 @@ mod tests {
     use crate::{
         codec::ProtocolCodec,
         transport::{
-            manager::{TransportManager, TransportManagerBuilder},
+            manager::{SubstreamKeepAlive, TransportManager, TransportManagerBuilder},
             KEEP_ALIVE_TIMEOUT,
         },
         types::protocol::ProtocolName,
@@ -1445,6 +1445,7 @@ mod tests {
             Default::default(),
             manager.transport_manager_handle(),
             KEEP_ALIVE_TIMEOUT,
+            SubstreamKeepAlive::Yes,
         );
         let (event_tx, event_rx) = channel(64);
         let (_cmd_tx, cmd_rx) = channel(64);

src/protocol/libp2p/ping/config.rs

@@ -22,6 +22,7 @@ use crate::{
     codec::ProtocolCodec, protocol::libp2p::ping::PingEvent, types::protocol::ProtocolName,
     DEFAULT_CHANNEL_SIZE,
 };
+use std::time::Duration;
 
 use futures::Stream;
 use tokio::sync::mpsc::{channel, Sender};
@@ -36,6 +37,11 @@ const PING_PAYLOAD_SIZE: usize = 32;
 /// Maximum PING failures.
 const MAX_FAILURES: usize = 3;
 
+/// Ping interval must be set to < 10 secs, because litep2p versions before
+/// <https://github.com/paritytech/litep2p/pull/416> reset the inbound substream if not receive
+/// the payload within 10 seconds of opening the substream.
+pub const PING_INTERVAL: Duration = Duration::from_secs(5);
+
 /// Ping configuration.
 pub struct Config {
     /// Protocol name.
@@ -49,6 +55,8 @@ pub struct Config {
 
     /// TX channel for sending events to the user protocol.
     pub(crate) tx_event: Sender<PingEvent>,
+
+    pub(crate) ping_interval: Duration,
 }
 
 impl Config {
@@ -61,6 +69,7 @@ impl Config {
         (
             Self {
                 tx_event,
+                ping_interval: PING_INTERVAL,
                 max_failures: MAX_FAILURES,
                 protocol: ProtocolName::from(PROTOCOL_NAME),
                 codec: ProtocolCodec::Identity(PING_PAYLOAD_SIZE),
@@ -80,6 +89,9 @@ pub struct ConfigBuilder {
 
     /// Maximum failures before the peer is considered unreachable.
     max_failures: usize,
+
+    /// Interval between outbound pings.
+    ping_interval: Duration,
 }
 
 impl Default for ConfigBuilder {
@@ -92,6 +104,7 @@ impl ConfigBuilder {
     /// Create new default [`Config`] which can be modified by the user.
     pub fn new() -> Self {
         Self {
+            ping_interval: PING_INTERVAL,
             max_failures: MAX_FAILURES,
             protocol: ProtocolName::from(PROTOCOL_NAME),
             codec: ProtocolCodec::Identity(PING_PAYLOAD_SIZE),
@@ -104,13 +117,23 @@ impl ConfigBuilder {
         self
     }
 
+    /// Set ping interval.
+    ///
+    /// The default is 5 seconds and should be kept like this for compatibility
+    /// with litep2p <= v0.13.0.
+    pub fn with_ping_interval(mut self, ping_interval: Duration) -> Self {
+        self.ping_interval = ping_interval;
+        self
+    }
+
     /// Build [`Config`].
     pub fn build(self) -> (Config, Box<dyn Stream<Item = PingEvent> + Send + Unpin>) {
         let (tx_event, rx_event) = channel(DEFAULT_CHANNEL_SIZE);
 
         (
             Config {
                 tx_event,
+                ping_interval: self.ping_interval,
                 max_failures: self.max_failures,
                 protocol: self.protocol,
                 codec: self.codec,