cargo fmt

pzmarzly · Jul 23, 2024 · 40b311d · 40b311d
1 parent ec002ed
commit 40b311d
Show file tree

Hide file tree

Showing 3 changed files with 98 additions and 60 deletions.
diff --git a/src/bin/pf.rs b/src/bin/pf.rs
@@ -1,90 +1,104 @@
 // Copyright (c) 2018 Paweł Zmarzły
-// 
+//
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
-extern crate portforwarder_rs;
 extern crate ctrlc;
+extern crate portforwarder_rs;
 
 use portforwarder_rs::*;
 use std::net::Ipv4Addr;
 
 enum InterfaceStrategy {
     Any,
-    Explicit(Ipv4Addr)
+    Explicit(Ipv4Addr),
 }
 
 fn main() {
     let mut iter = std::env::args().skip(1);
     let interface = match iter.next() {
         Some(ref i) if i == "any" => InterfaceStrategy::Any,
         Some(i) => {
-            if let Ok(x) = i.parse::<Ipv4Addr>() { InterfaceStrategy::Explicit(x) }
-            else {
+            if let Ok(x) = i.parse::<Ipv4Addr>() {
+                InterfaceStrategy::Explicit(x)
+            } else {
                 eprintln!("Error! First argument must be a network interface IP or `any`!");
                 return;
             }
-        },
+        }
         _ => {
             eprintln!("Error! First argument must be a network interface IP or `any`!");
             return;
-        },
+        }
     };
     if iter.len() == 0 {
         eprintln!("Error! No ports specified!");
         return;
     }
     let mut parsed_ports = Vec::with_capacity(iter.len());
     for port in iter {
-      let port_split = port.split('/').collect::<Vec<_>>();
-      match &port_split[..] {
-          [protocol, internal, external] => {
-            let proto = match &protocol.to_lowercase()[..] {
-              "tcp" => port_forwarder::PortMappingProtocol::TCP,
-              "udp" => port_forwarder::PortMappingProtocol::UDP,
-              _ => {
-                  eprintln!("Error! Unrecognized protocol: {} (in {})", protocol, port);
-                  return;
-              },
-          };
-          let internal = match internal.parse::<u16>() {
-              Ok(num) => num,
-              Err(err) => {
-                  eprintln!("Error! Invalid internal port number: {} (in {}) - {}", internal, port, err);
-                  return;
-              },
-          };
-          let external = match external.parse::<u16>() {
-              Ok(num) => num,
-              Err(err) => {
-                  eprintln!("Error! Invalid external port number: {} (in {}) - {}", external, port, err);
-                  return;
-              },
-          };
-          parsed_ports.push((proto, internal, external));
-          },
-          _ => {
-            eprintln!("Error! Port not in {{TCP,UDP}}/INTERNAL/EXTERNAL format: {}", port);
-            return;
-          },
+        let port_split = port.split('/').collect::<Vec<_>>();
+        match &port_split[..] {
+            [protocol, internal, external] => {
+                let proto = match &protocol.to_lowercase()[..] {
+                    "tcp" => port_forwarder::PortMappingProtocol::TCP,
+                    "udp" => port_forwarder::PortMappingProtocol::UDP,
+                    _ => {
+                        eprintln!("Error! Unrecognized protocol: {} (in {})", protocol, port);
+                        return;
+                    }
+                };
+                let internal = match internal.parse::<u16>() {
+                    Ok(num) => num,
+                    Err(err) => {
+                        eprintln!(
+                            "Error! Invalid internal port number: {} (in {}) - {}",
+                            internal, port, err
+                        );
+                        return;
+                    }
+                };
+                let external = match external.parse::<u16>() {
+                    Ok(num) => num,
+                    Err(err) => {
+                        eprintln!(
+                            "Error! Invalid external port number: {} (in {}) - {}",
+                            external, port, err
+                        );
+                        return;
+                    }
+                };
+                parsed_ports.push((proto, internal, external));
+            }
+            _ => {
+                eprintln!(
+                    "Error! Port not in {{TCP,UDP}}/INTERNAL/EXTERNAL format: {}",
+                    port
+                );
+                return;
+            }
         }
     }
 
     let forwarder = match interface {
         InterfaceStrategy::Any => {
-            let interfaces = query_interfaces::get_network_interfaces().expect("Failed to load network interfaces");
+            let interfaces = query_interfaces::get_network_interfaces()
+                .expect("Failed to load network interfaces");
             let interface_ips = interfaces.iter().map(|i| i.addr);
             port_forwarder::create_forwarder_from_any(interface_ips)
-        },
+        }
         InterfaceStrategy::Explicit(i) => port_forwarder::create_forwarder(i).map_err(|e| vec![e]),
     };
 
     let mut forwarder = match forwarder {
         Ok(f) => f,
         Err(err) => {
-            eprintln!("Error! Failed to connect to UPnP-enabled device! List of errors: {:?}", err);
+            eprintln!(
+                "Error! Failed to connect to UPnP-enabled device! List of errors: {:?}",
+                err
+            );
             return;
-        },
+        }
     };
 
     use std::sync::atomic::{AtomicBool, Ordering};
@@ -94,12 +108,28 @@ fn main() {
 
     ctrlc::set_handler(move || {
         r.store(false, Ordering::SeqCst);
-    }).expect("Error setting Ctrl-C handler");
+    })
+    .expect("Error setting Ctrl-C handler");
 
     for port in parsed_ports {
         match forwarder.forward_port(port.1, port.2, port.0, "PortForwardRs") {
-            Ok(_) => println!("{} {}:{} -> {}:{}", port.0, forwarder.gateway.addr.ip(), port.2, forwarder.network_interface, port.1),
-            Err(err) => eprintln!("Error! Could map {} {}:{} -> {}:{} - {}", port.0, forwarder.gateway.addr.ip(), port.2, forwarder.network_interface, port.1, err),
+            Ok(_) => println!(
+                "{} {}:{} -> {}:{}",
+                port.0,
+                forwarder.gateway.addr.ip(),
+                port.2,
+                forwarder.network_interface,
+                port.1
+            ),
+            Err(err) => eprintln!(
+                "Error! Could map {} {}:{} -> {}:{} - {}",
+                port.0,
+                forwarder.gateway.addr.ip(),
+                port.2,
+                forwarder.network_interface,
+                port.1,
+                err
+            ),
         }
     }
 

diff --git a/src/lib.rs b/src/lib.rs
@@ -1,10 +1,10 @@
 // Copyright (c) 2018 Paweł Zmarzły
-// 
+//
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
-extern crate igd;
 extern crate get_if_addrs;
+extern crate igd;
 
 pub mod port_forwarder;
 pub mod query_interfaces;
diff --git a/src/query_interfaces.rs b/src/query_interfaces.rs
@@ -1,28 +1,36 @@
 // Copyright (c) 2018 Paweł Zmarzły
-// 
+//
 // This software is released under the MIT License.
 // https://opensource.org/licenses/MIT
 
-use get_if_addrs::{ get_if_addrs, IfAddr };
+use get_if_addrs::{get_if_addrs, IfAddr};
 
 use std::io;
 use std::net::Ipv4Addr;
 
 #[derive(Debug)]
 pub struct Interface {
     pub name: String,
-    pub addr: Ipv4Addr
+    pub addr: Ipv4Addr,
 }
 
 pub fn get_network_interfaces() -> Result<Vec<Interface>, io::Error> {
-    get_if_addrs().map(|interfaces|
-        interfaces.into_iter().filter_map(|interface|
-            if let IfAddr::V4(ref addr) = interface.addr {
-                if addr.is_loopback() { return None }
-                Some(Interface { name: interface.name, addr: addr.ip })
-            } else {
-                None
-            }
-        ).collect()
-    )
+    get_if_addrs().map(|interfaces| {
+        interfaces
+            .into_iter()
+            .filter_map(|interface| {
+                if let IfAddr::V4(ref addr) = interface.addr {
+                    if addr.is_loopback() {
+                        return None;
+                    }
+                    Some(Interface {
+                        name: interface.name,
+                        addr: addr.ip,
+                    })
+                } else {
+                    None
+                }
+            })
+            .collect()
+    })
 }