protocols/relay: Implement circuit relay specification (#1838)

This commit implements the [libp2p circuit
relay](https://github.com/libp2p/specs/tree/master/relay) specification. It is
based on previous work from #1134.

Instead of altering the `Transport` trait, the approach taken in this commit
is to wrap an existing implementation of `Transport` allowing one to:

- Intercept `dial` requests with a relayed address.

- Inject incoming relayed connections with the local node being the destination.

- Intercept `listen_on` requests pointing to a relay, ensuring to keep a
  constant connection to the relay, waiting for incoming requests with the local
  node being the destination.

More concretely one would wrap an existing `Transport` implementation as seen
below, allowing the `Relay` behaviour and the `RelayTransport` to communicate
via channels.

### Example

```rust
let (relay_transport, relay_behaviour) = new_transport_and_behaviour(
    RelayConfig::default(),
    MemoryTransport::default(),
);

let transport = relay_transport
    .upgrade(upgrade::Version::V1)
    .authenticate(plaintext)
    .multiplex(YamuxConfig::default())
    .boxed();

let mut swarm = Swarm::new(transport, relay_behaviour, local_peer_id);

let relay_addr = Multiaddr::from_str("/memory/1234").unwrap()
    .with(Protocol::P2p(PeerId::random().into()))
    .with(Protocol::P2pCircuit);
let dst_addr = relay_addr.clone().with(Protocol::Memory(5678));

// Listen for incoming connections via relay node (1234).
Swarm::listen_on(&mut swarm, relay_addr).unwrap();

// Dial node (5678) via relay node (1234).
Swarm::dial_addr(&mut swarm, dst_addr).unwrap();
```

Co-authored-by: Pierre Krieger <[email protected]>
Co-authored-by: Roman Borschel <[email protected]>
Co-authored-by: David Craven <[email protected]>

CHANGELOG.md

@@ -15,6 +15,7 @@
 - [`libp2p-kad` CHANGELOG](protocols/kad/CHANGELOG.md)
 - [`libp2p-mdns` CHANGELOG](protocols/mdns/CHANGELOG.md)
 - [`libp2p-ping` CHANGELOG](protocols/ping/CHANGELOG.md)
+- [`libp2p-relay` CHANGELOG](protocols/relay/CHANGELOG.md)
 - [`libp2p-request-response` CHANGELOG](protocols/request-response/CHANGELOG.md)
 
 ## Transport Protocols & Upgrades
@@ -48,6 +49,8 @@
 - Do not leak default features from libp2p crates.
   [PR 1986](https://github.com/libp2p/rust-libp2p/pull/1986).
 
+- Add `libp2p-relay` to `libp2p` facade crate.
+
 ## Version 0.35.1 [2021-02-17]
 
 - Update `libp2p-yamux` to latest patch version.

Cargo.toml

@@ -23,6 +23,7 @@ default = [
     "ping",
     "plaintext",
     "pnet",
+    "relay",
     "request-response",
     "secp256k1",
     "tcp-async-io",
@@ -43,6 +44,7 @@ noise = ["libp2p-noise"]
 ping = ["libp2p-ping"]
 plaintext = ["libp2p-plaintext"]
 pnet = ["libp2p-pnet"]
+relay = ["libp2p-relay"]
 request-response = ["libp2p-request-response"]
 tcp-async-io = ["libp2p-tcp", "libp2p-tcp/async-io"]
 tcp-tokio = ["libp2p-tcp", "libp2p-tcp/tokio"]
@@ -71,6 +73,7 @@ libp2p-noise = { version = "0.29.0", path = "transports/noise", optional = true
 libp2p-ping = { version = "0.28.0", path = "protocols/ping", optional = true }
 libp2p-plaintext = { version = "0.27.1", path = "transports/plaintext", optional = true }
 libp2p-pnet = { version = "0.20.0", path = "transports/pnet", optional = true }
+libp2p-relay = { version = "0.1.0", path = "protocols/relay", optional = true }
 libp2p-request-response = { version = "0.10.0", path = "protocols/request-response", optional = true }
 libp2p-swarm = { version = "0.28.0", path = "swarm" }
 libp2p-swarm-derive = { version = "0.22.0", path = "swarm-derive" }
@@ -109,6 +112,7 @@ members = [
     "protocols/kad",
     "protocols/mdns",
     "protocols/ping",
+    "protocols/relay",
     "protocols/request-response",
     "swarm",
     "swarm-derive",

protocols/relay/CHANGELOG.md

@@ -0,0 +1,4 @@
+# 0.1.0 [unreleased]
+
+- First release supporting all major features of the circuit relay v1
+  specification. [PR 1838](https://github.com/libp2p/rust-libp2p/pull/1838).

protocols/relay/Cargo.toml

@@ -0,0 +1,38 @@
+[package]
+name = "libp2p-relay"
+edition = "2018"
+description = "Communications relaying for libp2p"
+version = "0.1.0"
+authors = ["Parity Technologies <[email protected]>"]
+license = "MIT"
+repository = "https://github.com/libp2p/rust-libp2p"
+keywords = ["peer-to-peer", "libp2p", "networking"]
+categories = ["network-programming", "asynchronous"]
+
+[dependencies]
+asynchronous-codec = "0.6"
+bytes = "1"
+futures = "0.3.1"
+futures-timer = "3"
+libp2p-core = { version = "0.27", path = "../../core" }
+libp2p-swarm = { version = "0.28", path = "../../swarm" }
+log = "0.4"
+pin-project = "1"
+prost = "0.7"
+rand = "0.7"
+smallvec = "0.6.9"
+unsigned-varint = { version = "0.7", features = ["asynchronous_codec"] }
+void = "1"
+wasm-timer = "0.2"
+
+[build-dependencies]
+prost-build = "0.7"
+
+[dev-dependencies]
+env_logger = "0.7.1"
+libp2p = { path = "../.." }
+libp2p-kad = { path = "../kad" }
+libp2p-ping = { path = "../ping" }
+libp2p-identify = { path = "../identify" }
+libp2p-plaintext = { path = "../../transports/plaintext" }
+libp2p-yamux = { path = "../../muxers/yamux" }

protocols/relay/build.rs

@@ -0,0 +1,23 @@
+// Copyright 2020 Parity Technologies (UK) Ltd.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+fn main() {
+	prost_build::compile_protos(&["src/message.proto"], &["src"]).unwrap();
+}

protocols/relay/examples/relay.rs

@@ -0,0 +1,84 @@
+// Copyright 2020 Parity Technologies (UK) Ltd.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the "Software"),
+// to deal in the Software without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Software, and to permit persons to whom the
+// Software is furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+use futures::executor::block_on;
+use futures::stream::StreamExt;
+use libp2p::core::upgrade;
+use libp2p::plaintext;
+use libp2p::relay::RelayConfig;
+use libp2p::tcp::TcpConfig;
+use libp2p::Transport;
+use libp2p::{identity, PeerId, Swarm};
+use std::error::Error;
+use std::task::{Context, Poll};
+use std::time::Duration;
+
+fn main() -> Result<(), Box<dyn Error>> {
+    env_logger::init();
+
+    // Create a random PeerId
+    let local_key = identity::Keypair::generate_ed25519();
+    let local_peer_id = PeerId::from(local_key.public());
+    println!("Local peer id: {:?}", local_peer_id);
+
+    let tcp_transport = TcpConfig::new();
+
+    let relay_config = RelayConfig {
+        connection_idle_timeout: Duration::from_secs(10 * 60),
+        ..Default::default()
+    };
+    let (relay_wrapped_transport, relay_behaviour) =
+        libp2p_relay::new_transport_and_behaviour(relay_config, tcp_transport);
+
+    let plaintext = plaintext::PlainText2Config {
+        local_public_key: local_key.public(),
+    };
+
+    let transport = relay_wrapped_transport
+        .upgrade(upgrade::Version::V1)
+        .authenticate(plaintext)
+        .multiplex(libp2p_yamux::YamuxConfig::default())
+        .boxed();
+
+    let mut swarm = Swarm::new(transport, relay_behaviour, local_peer_id);
+
+    // Listen on all interfaces and whatever port the OS assigns
+    Swarm::listen_on(&mut swarm, "/ip6/::/tcp/0".parse()?)?;
+
+    let mut listening = false;
+    block_on(futures::future::poll_fn(move |cx: &mut Context<'_>| {
+        loop {
+            match swarm.poll_next_unpin(cx) {
+                Poll::Ready(Some(event)) => println!("{:?}", event),
+                Poll::Ready(None) => return Poll::Ready(Ok(())),
+                Poll::Pending => {
+                    if !listening {
+                        for addr in Swarm::listeners(&swarm) {
+                            println!("Listening on {:?}", addr);
+                            listening = true;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        Poll::Pending
+    }))
+}