Quic attempt 4

Cargo.toml

@@ -62,6 +62,7 @@ ping = ["dep:libp2p-ping", "libp2p-metrics?/ping"]
 plaintext = ["dep:libp2p-plaintext"]
 pnet = ["dep:libp2p-pnet"]
 relay = ["dep:libp2p-relay", "libp2p-metrics?/relay"]
+quic = ["dep:libp2p-quic"]
 request-response = ["dep:libp2p-request-response"]
 rendezvous = ["dep:libp2p-rendezvous"]
 tcp = ["dep:libp2p-tcp"]
@@ -98,6 +99,7 @@ libp2p-noise = { version = "0.40.0", path = "transports/noise", optional = true
 libp2p-ping = { version = "0.40.1", path = "protocols/ping", optional = true }
 libp2p-plaintext = { version = "0.37.0", path = "transports/plaintext", optional = true }
 libp2p-pnet = { version = "0.22.1", path = "transports/pnet", optional = true }
+libp2p-quic = { version = "0.8.0", path = "transports/quic", optional = true }
 libp2p-relay = { version = "0.13.0", path = "protocols/relay", optional = true }
 libp2p-rendezvous = { version = "0.10.0", path = "protocols/rendezvous", optional = true }
 libp2p-request-response = { version = "0.22.1", path = "protocols/request-response", optional = true }

src/lib.rs

@@ -93,6 +93,10 @@ pub use libp2p_plaintext as plaintext;
 #[cfg(feature = "pnet")]
 #[doc(inline)]
 pub use libp2p_pnet as pnet;
+#[cfg(feature = "quic")]
+#[cfg_attr(docsrs, doc(cfg(feature = "quic")))]
+#[doc(inline)]
+pub use libp2p_quic as quic;
 #[cfg(feature = "relay")]
 #[doc(inline)]
 pub use libp2p_relay as relay;

transports/quic/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "libp2p-quic"
+version = "0.8.0"
+authors = ["Parity Technologies <admin@parity.io>"]
+edition = "2021"
+description = "TLS based QUIC transport implementation for libp2p"
+repository = "https://github.com/libp2p/rust-libp2p"
+license = "MIT"
+
+[dependencies]
+if-watch = "2.0.0"
+libp2p-core = { version = "0.37.0", path = "../../core" }
+libp2p-tls = { version = "0.1.0-alpha", path = "../../transports/tls" }
+quinn = { version = "0.9.0", features = ["tls-rustls", "futures-io", "runtime-async-std"] }
+futures = "0.3.21"
+thiserror = "1.0.26"
+tracing = "0.1"
+rand = "0.8.5"
+rustls = "0.20.2"
+
+[dev-dependencies]
+anyhow = "1.0.41"
+async-std = { version = "1.12.0", features = ["attributes"] }
+async-trait = "0.1.50"
+libp2p = { version = "0.50.0", default-features = false, features = ["request-response"], path = "../.." }
+tracing-subscriber = {version = "0.3.8", features = ["env-filter"] }

transports/quic/src/in_addr.rs

@@ -0,0 +1,66 @@
+use if_watch::{IfEvent, IfWatcher};
+
+use futures::stream::Stream;
+
+use std::{
+    io::Result,
+    net::IpAddr,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+/// Watches for interface changes.
+#[derive(Debug)]
+pub enum InAddr {
+    /// The socket accepts connections on a single interface.
+    One { ip: Option<IpAddr> },
+    /// The socket accepts connections on all interfaces.
+    Any { if_watch: Box<IfWatcher> },
+}
+
+impl InAddr {
+    /// If ip is specified then only one `IfEvent::Up` with IpNet(ip)/32 will be generated.
+    /// If ip is unspecified then `IfEvent::Up/Down` events will be generated for all interfaces.
+    pub fn new(ip: IpAddr) -> Result<Self> {
+        let result = if ip.is_unspecified() {
+            let watcher = IfWatcher::new()?;
+            InAddr::Any {
+                if_watch: Box::new(watcher),
+            }
+        } else {
+            InAddr::One { ip: Some(ip) }
+        };
+        Ok(result)
+    }
+}
+
+impl Stream for InAddr {
+    type Item = Result<IfEvent>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
+        let me = Pin::into_inner(self);
+        match me {
+            // If the listener is bound to a single interface, make sure the
+            // address is reported once.
+            InAddr::One { ip } => {
+                if let Some(ip) = ip.take() {
+                    return Poll::Ready(Some(Ok(IfEvent::Up(ip.into()))));
+                }
+            }
+            InAddr::Any { if_watch } => {
+                // Consume all events for up/down interface changes.
+                if let Poll::Ready(ev) = if_watch.poll_if_event(cx) {
+                    match ev {
+                        Ok(event) => {
+                            return Poll::Ready(Some(Ok(event)));
+                        }
+                        Err(err) => {
+                            return Poll::Ready(Some(Err(err)));
+                        }
+                    }
+                }
+            }
+        }
+        Poll::Pending
+    }
+}