fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-08-01 01:11:58 +00:00
Code Issues Projects Releases Wiki Activity

Remove Transport::nat_traversal and refactor multiaddr. (#1052)

Browse Source 
The functionality is available through `Multiaddr::replace`.
What we currently call "nat_traversal" is merley a replacement of an IP
address prefix in a `Multiaddr`, hence it can be done directly on
`Multiaddr` values instead of having to go through a `Transport`.

In addition this PR consolidates changes made to `Multiaddr` in
previous commits which resulted in lots of deprecations. It adds some
more (see below for the complete list of API changes) and removes all
deprecated functionality, requiring a minor version bump.

Here are the changes to `multiaddr` compared to the currently published
version:

1.  Removed `into_bytes` (use `to_vec` instead).
2.  Renamed `to_bytes` to `to_vec`.
3.  Removed `from_bytes` (use the `TryFrom` impl instead).
4.  Added `with_capacity`.
5.  Added `len`.
6.  Removed `as_slice` (use `AsRef` impl instead).
7.  Removed `encapsulate` (use `push` or `with` instead).
8.  Removed `decapsulate` (use `pop` instead).
9.  Renamed `append` to `push`.
10. Added `with`.
11. Added `replace`.
12. Removed `ToMultiaddr` trait (use `TryFrom` instead).
This commit is contained in:
Toralf Wittner
2019-04-17 20:12:31 +02:00
committed by GitHub
parent a4173705db
commit ca58f8029c
33 changed files with 494 additions and 803 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
transports/websocket/src/browser.rs
View File

@@ -59,7 +59,6 @@ impl Transport for BrowserWsConfig {
type ListenerUpgrade = future::Empty<Self::Output, IoError>;
type Dial = Box<Future<Item = Self::Output, Error = IoError> + Send>;
#[inline]
fn listen_on(self, a: Multiaddr) -> Result<Self::Listener, TransportError<Self::Error>> {
// Listening is never supported.
Err(TransportError::MultiaddrNotSupported(a))
@@ -208,43 +207,6 @@ impl Transport for BrowserWsConfig {
}
})) as Box<_>)
}
fn nat_traversal(&self, server: &Multiaddr, observed: &Multiaddr) -> Option<Multiaddr> {
let mut address = Multiaddr::empty();
let mut iter = server.iter().zip(observed.iter());
// Use the observed IP address.
match iter.next() {
Some((Protocol::Ip4(_), x@Protocol::Ip4(_))) => address.append(x),
Some((Protocol::Ip6(_), x@Protocol::Ip6(_))) => address.append(x),
_ => return None
}
// Skip over next protocol (assumed to contain port information).
if iter.next().is_none() {
return None
}
// Check for WS/WSS.
//
// Note that it will still work if the server uses WSS while the client uses
// WS, or vice-versa.
match iter.next() {
Some((x@Protocol::Ws, Protocol::Ws)) => address.append(x),
Some((x@Protocol::Ws, Protocol::Wss)) => address.append(x),
Some((x@Protocol::Wss, Protocol::Ws)) => address.append(x),
Some((x@Protocol::Wss, Protocol::Wss)) => address.append(x),
_ => return None
}
// Carry over everything else from the server address.
for proto in server.iter().skip(3) {
address.append(proto)
}
Some(address)
}
}
pub struct BrowserWsConn {

69
transports/websocket/src/desktop.rs
View File

@@ -87,17 +87,17 @@ where
let listen = inner_listen.map_err(WsError::Underlying).map(|event| {
match event {
ListenerEvent::NewAddress(mut a) => {
a.append(Protocol::Ws);
a = a.with(Protocol::Ws);
debug!("Listening on {}", a);
ListenerEvent::NewAddress(a)
}
ListenerEvent::AddressExpired(mut a) => {
a.append(Protocol::Ws);
a = a.with(Protocol::Ws);
ListenerEvent::AddressExpired(a)
}
ListenerEvent::Upgrade { upgrade, mut listen_addr, mut remote_addr } => {
listen_addr.append(Protocol::Ws);
remote_addr.append(Protocol::Ws);
listen_addr = listen_addr.with(Protocol::Ws);
remote_addr = remote_addr.with(Protocol::Ws);
// Upgrade the listener to websockets like the websockets library requires us to do.
let upgraded = upgrade.map_err(WsError::Underlying).and_then(move |stream| {
@@ -206,10 +206,6 @@ where
Ok(Box::new(dial) as Box<_>)
}
fn nat_traversal(&self, server: &Multiaddr, observed: &Multiaddr) -> Option<Multiaddr> {
self.transport.nat_traversal(server, observed)
}
}
/// Error in WebSockets.
@@ -352,61 +348,4 @@ mod tests {
let mut rt = Runtime::new().unwrap();
let _ = rt.block_on(future).unwrap();
}
#[test]
fn nat_traversal() {
let ws_config = WsConfig::new(tcp::TcpConfig::new());
{
let server = "/ip4/127.0.0.1/tcp/10000/ws".parse::<Multiaddr>().unwrap();
let observed = "/ip4/80.81.82.83/tcp/25000/ws"
.parse::<Multiaddr>()
.unwrap();
assert_eq!(
ws_config.nat_traversal(&server, &observed).unwrap(),
"/ip4/80.81.82.83/tcp/10000/ws"
.parse::<Multiaddr>()
.unwrap()
);
}
{
let server = "/ip4/127.0.0.1/tcp/10000/wss".parse::<Multiaddr>().unwrap();
let observed = "/ip4/80.81.82.83/tcp/25000/wss"
.parse::<Multiaddr>()
.unwrap();
assert_eq!(
ws_config.nat_traversal(&server, &observed).unwrap(),
"/ip4/80.81.82.83/tcp/10000/wss"
.parse::<Multiaddr>()
.unwrap()
);
}
{
let server = "/ip4/127.0.0.1/tcp/10000/ws".parse::<Multiaddr>().unwrap();
let observed = "/ip4/80.81.82.83/tcp/25000/wss"
.parse::<Multiaddr>()
.unwrap();
assert_eq!(
ws_config.nat_traversal(&server, &observed).unwrap(),
"/ip4/80.81.82.83/tcp/10000/ws"
.parse::<Multiaddr>()
.unwrap()
);
}
{
let server = "/ip4/127.0.0.1/tcp/10000/wss".parse::<Multiaddr>().unwrap();
let observed = "/ip4/80.81.82.83/tcp/25000/ws"
.parse::<Multiaddr>()
.unwrap();
assert_eq!(
ws_config.nat_traversal(&server, &observed).unwrap(),
"/ip4/80.81.82.83/tcp/10000/wss"
.parse::<Multiaddr>()
.unwrap()
);
}
}
}