Accept hostnames for tcp:, tcp-listen:, udp:, udp-listen:

Signed-off-by: Anders Kaseorg <[email protected]>

Author: andersk

src/net_peer.rs

@@ -1,13 +1,13 @@
 extern crate net2;
 
 use futures;
-use futures::future::Future;
+use futures::future::{Future, IntoFuture};
 use futures::stream::Stream;
 use futures::unsync::oneshot::{channel, Receiver, Sender};
 use std;
 use std::io::Result as IoResult;
 use std::io::{Read, Write};
-use std::net::SocketAddr;
+use std::net::{SocketAddr, ToSocketAddrs};
 use tokio_io::{AsyncRead, AsyncWrite};
 
 use std::cell::RefCell;
@@ -17,11 +17,11 @@ use tokio_tcp::{TcpListener, TcpStream};
 use tokio_udp::UdpSocket;
 
 use super::L2rUser;
-use super::{box_up_err, peer_err_s, wouldblock, BoxedNewPeerFuture, BoxedNewPeerStream, Peer};
+use super::{box_up_err, wouldblock, BoxedNewPeerFuture, BoxedNewPeerStream, Peer};
 use super::{multi, once, ConstructParams, Options, PeerConstructor, Specifier};
 
 #[derive(Debug, Clone)]
-pub struct TcpConnect(pub SocketAddr);
+pub struct TcpConnect(pub String);
 impl Specifier for TcpConnect {
     fn construct(&self, _: ConstructParams) -> PeerConstructor {
         once(tcp_connect_peer(&self.0))
@@ -50,7 +50,7 @@ Example: redirect websocket connections to local SSH server over IPv6
 );
 
 #[derive(Debug, Clone)]
-pub struct TcpListen(pub SocketAddr);
+pub struct TcpListen(pub String);
 impl Specifier for TcpListen {
     fn construct(&self, p: ConstructParams) -> PeerConstructor {
         multi(tcp_listen_peer(&self.0, p.left_to_right))
@@ -79,10 +79,10 @@ Example: redirect TCP to a websocket
 );
 
 #[derive(Debug, Clone)]
-pub struct UdpConnect(pub SocketAddr);
+pub struct UdpConnect(pub String);
 impl Specifier for UdpConnect {
     fn construct(&self, p: ConstructParams) -> PeerConstructor {
-        once(udp_connect_peer(&self.0, &p.program_options))
+        once(udp_connect_peer(&self.0, p.program_options))
     }
     specifier_boilerplate!(noglobalstate singleconnect no_subspec );
 }
@@ -100,10 +100,10 @@ Send and receive packets to specified UDP socket, from random UDP port
 );
 
 #[derive(Debug, Clone)]
-pub struct UdpListen(pub SocketAddr);
+pub struct UdpListen(pub String);
 impl Specifier for UdpListen {
     fn construct(&self, p: ConstructParams) -> PeerConstructor {
-        once(udp_listen_peer(&self.0, &p.program_options))
+        once(udp_listen_peer(&self.0, p.program_options))
     }
     specifier_boilerplate!(noglobalstate singleconnect no_subspec );
 }
@@ -192,25 +192,39 @@ impl Drop for MyTcpStream {
     }
 }
 
-pub fn tcp_connect_peer(addr: &SocketAddr) -> BoxedNewPeerFuture {
-    Box::new(
+pub fn resolve_addr(
+    addr_str: &str,
+) -> impl Future<Item = SocketAddr, Error = Box<dyn std::error::Error + 'static>> {
+    // TODO: resolve asynchronously
+    addr_str
+        .to_socket_addrs()
+        .and_then(|mut addrs| {
+            addrs
+                .next()
+                .ok_or_else(|| ::simple_err(format!("No address for {}", addr_str)))
+        })
+        .map_err(box_up_err)
+        .into_future()
+}
+
+pub fn tcp_connect_peer(addr_str: &str) -> BoxedNewPeerFuture {
+    Box::new(resolve_addr(addr_str).and_then(|addr| {
         TcpStream::connect(&addr)
             .map(|x| {
                 info!("Connected to TCP");
                 let x = Rc::new(x);
                 Peer::new(MyTcpStream(x.clone(), true), MyTcpStream(x.clone(), false))
             })
-            .map_err(box_up_err),
-    ) as BoxedNewPeerFuture
+            .map_err(box_up_err)
+    })) as BoxedNewPeerFuture
 }
 
-pub fn tcp_listen_peer(addr: &SocketAddr, l2r: L2rUser) -> BoxedNewPeerStream {
-    let bound = match TcpListener::bind(&addr) {
-        Ok(x) => x,
-        Err(e) => return peer_err_s(e),
-    };
+pub fn tcp_listen_peer(addr_str: &str, l2r: L2rUser) -> BoxedNewPeerStream {
     use tk_listen::ListenExt;
-    Box::new(
+    Box::new(resolve_addr(addr_str).and_then(|addr| {
+        TcpListener::bind(&addr).map_err(box_up_err)
+    }).into_stream().map(move |bound| {
+        let l2r = l2r.clone();
         bound
             .incoming()
             .sleep_on_error(::std::time::Duration::from_millis(500))
@@ -229,8 +243,8 @@ pub fn tcp_listen_peer(addr: &SocketAddr, l2r: L2rUser) -> BoxedNewPeerStream {
                 let x = Rc::new(x);
                 Peer::new(MyTcpStream(x.clone(), true), MyTcpStream(x.clone(), false))
             })
-            .map_err(|()| ::simple_err2("unreachable error?")),
-    ) as BoxedNewPeerStream
+            .map_err(|()| ::simple_err2("unreachable error?"))
+    }).flatten()) as BoxedNewPeerStream
 }
 
 #[derive(Debug)]
@@ -323,14 +337,14 @@ pub fn get_udp(addr: &SocketAddr, opts: &Rc<Options>) -> IoResult<UdpSocket> {
     UdpSocket::from_std(u, &tokio_reactor::Handle::default())
 }
 
-pub fn udp_connect_peer(addr: &SocketAddr, opts: &Rc<Options>) -> BoxedNewPeerFuture {
-    let za = get_zero_address(addr);
+pub fn udp_connect_peer(addr_str: &str, opts: Rc<Options>) -> BoxedNewPeerFuture {
+    Box::new(resolve_addr(addr_str).and_then(move |addr| {
+        let za = get_zero_address(&addr);
 
-    Box::new(futures::future::result(
-        get_udp(&za, opts)
+        get_udp(&za, &opts)
             .and_then(|x| {
-                x.connect(addr)?;
-                apply_udp_options(&x, opts)?;
+                x.connect(&addr)?;
+                apply_udp_options(&x, &opts)?;
 
                 let h1 = UdpPeerHandle(Rc::new(RefCell::new(UdpPeer {
                     s: x,
@@ -340,15 +354,15 @@ pub fn udp_connect_peer(addr: &SocketAddr, opts: &Rc<Options>) -> BoxedNewPeerFu
                 let h2 = h1.clone();
                 Ok(Peer::new(h1, h2))
             })
-            .map_err(box_up_err),
-    )) as BoxedNewPeerFuture
+            .map_err(box_up_err)
+    })) as BoxedNewPeerFuture
 }
 
-pub fn udp_listen_peer(addr: &SocketAddr, opts: &Rc<Options>) -> BoxedNewPeerFuture {
-    Box::new(futures::future::result(
-        get_udp(addr, opts)
+pub fn udp_listen_peer(addr_str: &str, opts: Rc<Options>) -> BoxedNewPeerFuture {
+    Box::new(resolve_addr(addr_str).and_then(move |addr| {
+        get_udp(&addr, &opts)
             .and_then(|x| {
-                apply_udp_options(&x, opts)?;
+                apply_udp_options(&x, &opts)?;
                 let h1 = UdpPeerHandle(Rc::new(RefCell::new(UdpPeer {
                     s: x,
                     state: Some(UdpPeerState::WaitingForAddress(channel())),
@@ -357,8 +371,8 @@ pub fn udp_listen_peer(addr: &SocketAddr, opts: &Rc<Options>) -> BoxedNewPeerFut
                 let h2 = h1.clone();
                 Ok(Peer::new(h1, h2))
             })
-            .map_err(box_up_err),
-    )) as BoxedNewPeerFuture
+            .map_err(box_up_err)
+    })) as BoxedNewPeerFuture
 }
 
 impl Read for UdpPeerHandle {