Clean up formatting.

src/network/address.rs

@@ -33,7 +33,6 @@ pub enum AddressConversionError {
     CouldntConvertName,
 }
 
-
 impl From<IpAddr> for SOCKSv5Address {
     fn from(x: IpAddr) -> SOCKSv5Address {
         match x {
@@ -57,7 +56,7 @@ impl TryFrom<SOCKSv5Address> for IpAddr {
 
 impl From<Ipv4Addr> for SOCKSv5Address {
     fn from(x: Ipv4Addr) -> Self {
-       SOCKSv5Address::IP4(x) 
+        SOCKSv5Address::IP4(x)
     }
 }
 
@@ -75,7 +74,7 @@ impl TryFrom<SOCKSv5Address> for Ipv4Addr {
 
 impl From<Ipv6Addr> for SOCKSv5Address {
     fn from(x: Ipv6Addr) -> Self {
-       SOCKSv5Address::IP6(x) 
+        SOCKSv5Address::IP6(x)
     }
 }
 
@@ -245,10 +244,16 @@ fn domain_name_sanity() {
     let addr2 = SOCKSv5Address::from(strname);
 
     assert_eq!(addr1, addr2);
-    assert_eq!(Err(AddressConversionError::CouldntConvertName),
+    assert_eq!(
-               IpAddr::try_from(addr1.clone()));
+        Err(AddressConversionError::CouldntConvertName),
-    assert_eq!(Err(AddressConversionError::CouldntConvertName),
+        IpAddr::try_from(addr1.clone())
-               Ipv4Addr::try_from(addr1.clone()));
+    );
-    assert_eq!(Err(AddressConversionError::CouldntConvertName),
+    assert_eq!(
-               Ipv6Addr::try_from(addr1.clone()));
+        Err(AddressConversionError::CouldntConvertName),
+        Ipv4Addr::try_from(addr1.clone())
+    );
+    assert_eq!(
+        Err(AddressConversionError::CouldntConvertName),
+        Ipv6Addr::try_from(addr1.clone())
+    );
 }

src/network/generic.rs

@@ -6,7 +6,6 @@ use crate::network::stream::GenericStream;
 use async_trait::async_trait;
 use std::fmt::Display;
 
-
 #[async_trait]
 pub trait Networklike {
     /// The error type for things that fail on this network. Apologies in advance

src/network/standard.rs

@@ -145,13 +145,25 @@ fn check_sanity() {
         // going to get any dropped data along here ... which is a very questionable
         // assumption, morally speaking, but probably fine for most purposes.
         let mut network = Builtin::new();
-        let receiver = network.bind("localhost", 0).await.expect("Failed to bind receiver socket.");
+        let receiver = network
-        let sender = network.bind("localhost", 0).await.expect("Failed to bind sender socket.");
+            .bind("localhost", 0)
+            .await
+            .expect("Failed to bind receiver socket.");
+        let sender = network
+            .bind("localhost", 0)
+            .await
+            .expect("Failed to bind sender socket.");
         let buffer = [0xde, 0xea, 0xbe, 0xef];
         let (receiver_addr, receiver_port) = receiver.local_addr();
-        sender.send_to(&buffer, receiver_addr, receiver_port).await.expect("Failure sending datagram!");
+        sender
+            .send_to(&buffer, receiver_addr, receiver_port)
+            .await
+            .expect("Failure sending datagram!");
         let mut recvbuffer = [0; 4];
-        let (s, f, p) = receiver.recv_from(&mut recvbuffer).await.expect("Didn't receive UDP message?");
+        let (s, f, p) = receiver
+            .recv_from(&mut recvbuffer)
+            .await
+            .expect("Didn't receive UDP message?");
         let (sender_addr, sender_port) = sender.local_addr();
         assert_eq!(s, 4);
         assert_eq!(f, sender_addr);
@@ -163,24 +175,40 @@ fn check_sanity() {
     // on is in a pretty weird place.
     let mut network = Builtin::new();
 
-    let listener = async_std::task::block_on(network.listen("localhost", 0)).expect("Couldn't set up listener on localhost");
+    let listener = async_std::task::block_on(network.listen("localhost", 0))
+        .expect("Couldn't set up listener on localhost");
     let (listener_address, listener_port) = listener.local_addr();
 
     let listener_task_handle = async_std::task::spawn(async move {
         let (mut stream, addr, port) = listener.accept().await.expect("Didn't get connection");
         let mut result_buffer = [0u8; 4];
         println!("Starting read!");
-        stream.read_exact(&mut result_buffer).await.expect("Read failure in TCP test");
+        stream
+            .read_exact(&mut result_buffer)
+            .await
+            .expect("Read failure in TCP test");
         (result_buffer, addr, port)
     });
 
     let sender_task_handle = async_std::task::spawn(async move {
-        let mut sender = network.connect(listener_address, listener_port).await.expect("Coudln't connect to listener?");
+        let mut sender = network
+            .connect(listener_address, listener_port)
+            .await
+            .expect("Coudln't connect to listener?");
         let (sender_address, sender_port) = sender.local_addr();
         let send_buffer = [0xa, 0xff, 0xab, 0x1e];
-        sender.write_all(&send_buffer).await.expect("Couldn't send the write buffer");
+        sender
-        sender.flush().await.expect("Couldn't flush the write buffer");
+            .write_all(&send_buffer)
-        sender.close().await.expect("Couldn't close the write buffer");
+            .await
+            .expect("Couldn't send the write buffer");
+        sender
+            .flush()
+            .await
+            .expect("Couldn't flush the write buffer");
+        sender
+            .close()
+            .await
+            .expect("Couldn't close the write buffer");
         (sender_address, sender_port)
     });
 

src/network/stream.rs

@@ -1,6 +1,6 @@
+use crate::network::SOCKSv5Address;
 use async_std::task::{Context, Poll};
 use futures::io;
-use crate::network::SOCKSv5Address;
 use futures::io::{AsyncRead, AsyncWrite};
 use std::pin::Pin;
 use std::sync::{Arc, Mutex};
@@ -16,8 +16,8 @@ pub struct GenericStream {
 
 impl GenericStream {
     pub fn new<T: Streamlike + 'static>(x: T) -> GenericStream {
-        GenericStream{ 
+        GenericStream {
-            internal: Arc::new(Mutex::new(x))
+            internal: Arc::new(Mutex::new(x)),
         }
     }
 }