Remove p2p crate (and uPnP support)

Cargo.toml

@@ -79,7 +79,6 @@ itertools = "0.7.8"
 libc = "0.2.1"
 log = "0.4.2"
 matches = "0.1.6"
-p2p = "0.5.2"
 pnet_datalink = "0.21.0"
 rand = "0.5.1"
 rayon = "1.0.0"

src/bin/bench-tps.rs

@@ -16,7 +16,7 @@ use solana::fullnode::Config;
 use solana::hash::Hash;
 use solana::logger;
 use solana::metrics;
-use solana::nat::{udp_public_bind, udp_random_bind, UdpSocketPair};
+use solana::nat::{udp_random_bind, UdpSocketPair};
 use solana::ncp::Ncp;
 use solana::service::Service;
 use solana::signature::{read_keypair, GenKeys, Keypair, KeypairUtil};
@@ -640,21 +640,16 @@ fn main() {
 
 fn spy_node(addr: Option<String>) -> (NodeInfo, UdpSocket) {
     let gossip_socket_pair;
-    if let Some(a) = addr {
-        let gossip_socket = udp_random_bind(8000, 10000, 5).unwrap();
-        let gossip_addr = SocketAddr::new(
-            a.parse().unwrap(),
-            gossip_socket.local_addr().unwrap().port(),
-        );
-        gossip_socket_pair = UdpSocketPair {
-            addr: gossip_addr,
-            receiver: gossip_socket.try_clone().unwrap(),
-            sender: gossip_socket,
-        };
-    } else {
-        gossip_socket_pair = udp_public_bind("gossip", 8000, 10000);
-    }
-
+    let gossip_socket = udp_random_bind(8000, 10000, 5).unwrap();
+    let gossip_addr = SocketAddr::new(
+        addr.unwrap().parse().unwrap(),
+        gossip_socket.local_addr().unwrap().port(),
+    );
+    gossip_socket_pair = UdpSocketPair {
+        addr: gossip_addr,
+        receiver: gossip_socket.try_clone().unwrap(),
+        sender: gossip_socket,
+    };
     let pubkey = Keypair::new().pubkey();
     let daddr = "0.0.0.0:0".parse().unwrap();
     assert!(!gossip_socket_pair.addr.ip().is_unspecified());

src/nat.rs

@@ -1,19 +1,14 @@
 //! The `nat` module assists with NAT traversal
 
 extern crate futures;
-extern crate p2p;
 extern crate rand;
 extern crate reqwest;
 extern crate tokio_core;
 
 use std::net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket};
 
-use self::futures::Future;
-use self::p2p::UdpSocketExt;
 use rand::{thread_rng, Rng};
-use std::env;
 use std::io;
-use std::str;
 
 /// A data type representing a public Udp socket
 pub struct UdpSocketPair {
@@ -51,71 +46,3 @@ pub fn udp_random_bind(start: u16, end: u16, tries: u32) -> io::Result<UdpSocket
         }
     }
 }
-
-/// Binds a private Udp address to a public address using UPnP if possible
-pub fn udp_public_bind(label: &str, startport: u16, endport: u16) -> UdpSocketPair {
-    let private_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0);
-
-    let mut core = tokio_core::reactor::Core::new().unwrap();
-    let handle = core.handle();
-    let mc = p2p::P2p::default();
-    let res = core.run({
-        tokio_core::net::UdpSocket::bind_public(&private_addr, &handle, &mc)
-            .map_err(|e| {
-                info!("Failed to bind public socket for {}: {}", label, e);
-            })
-            .and_then(|(socket, public_addr)| Ok((public_addr, socket.local_addr().unwrap())))
-    });
-
-    match res {
-        Ok((public_addr, local_addr)) => {
-            info!(
-                "Using local address {} mapped to UPnP public address {} for {}",
-                local_addr, public_addr, label
-            );
-
-            // NAT should now be forwarding inbound packets directed at
-            // |public_addr| to the local |receiver| socket...
-            let receiver = UdpSocket::bind(local_addr).unwrap();
-
-            // TODO: try to autodetect a broken NAT (issue #496)
-            let sender = if env::var("BROKEN_NAT").is_err() {
-                receiver.try_clone().unwrap()
-            } else {
-                // ... however for outbound packets, some NATs *will not* rewrite the
-                // source port from |receiver.local_addr().port()| to |public_addr.port()|.
-                // This is currently a problem when talking with a fullnode as it
-                // assumes it can send UDP packets back at the source.  This hits the
-                // NAT as a datagram for |receiver.local_addr().port()| on the NAT's public
-                // IP, which the NAT promptly discards.  As a short term hack, create a
-                // local UDP socket, |sender|, with the same port as |public_addr.port()|.
-                //
-                // TODO: Remove the |sender| socket and deal with the downstream changes to
-                //       the UDP signalling
-                let mut local_addr_sender = local_addr;
-                local_addr_sender.set_port(public_addr.port());
-                UdpSocket::bind(local_addr_sender).unwrap()
-            };
-
-            UdpSocketPair {
-                addr: public_addr,
-                receiver,
-                sender,
-            }
-        }
-        Err(_) => {
-            let sender = udp_random_bind(startport, endport, 5).unwrap();
-            let local_addr = sender.local_addr().unwrap();
-
-            let pub_ip = get_public_ip_addr().unwrap();
-            let pub_addr = SocketAddr::new(pub_ip, local_addr.port());
-
-            info!("Using source address {} for {}", pub_addr, label);
-            UdpSocketPair {
-                addr: pub_addr,
-                receiver: sender.try_clone().unwrap(),
-                sender,
-            }
-        }
-    }
-}