From 540f57f7c2591e8a571aa41dc70de7ab8ea17454 Mon Sep 17 00:00:00 2001 From: Tomasz Grzegowski Date: Mon, 13 Apr 2026 13:41:19 +0200 Subject: [PATCH 1/2] Bump rand version --- Cargo.toml | 2 +- src/common/mod.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index bc11ca89..a8ef79bc 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,7 +21,7 @@ http-body-util = "0.1" hyper = { version = "1", features = ["http1", "client"] } hyper-util = { version = "0.1", features = ["http1", "client"] } log = "0.4" -rand = "0.8" +rand = "0.9" reqwest = { version = "0.12.9", default-features = false, features = ["blocking", "rustls-tls"] } thiserror = "2.0.4" tokio = {version = "1", optional = true, features = ["net", "macros"]} diff --git a/src/common/mod.rs b/src/common/mod.rs index 876ff53f..b400a9d5 100644 --- a/src/common/mod.rs +++ b/src/common/mod.rs @@ -9,5 +9,5 @@ pub use self::options::SearchOptions; use rand::{self, Rng}; pub fn random_port() -> u16 { - rand::thread_rng().gen_range(32_768_u16..65_535_u16) + rand::rng().random_range(32_768_u16..65_535_u16) } From 68c3dfded9aa8b9ff6ef4efb07b4e78ee93b47a0 Mon Sep 17 00:00:00 2001 From: Tomasz Grzegowski Date: Mon, 13 Apr 2026 13:48:26 +0200 Subject: [PATCH 2/2] Fix cargo clippy --- examples/add_any_port.rs | 6 +++--- examples/add_port.rs | 4 ++-- examples/add_remove.rs | 8 ++++---- examples/aio.rs | 10 +++++----- examples/external_ip.rs | 6 +++--- examples/remove_port.rs | 4 ++-- src/aio/gateway.rs | 2 +- src/aio/search.rs | 24 ++++++++++-------------- src/common/messages.rs | 40 ++++++++++++---------------------------- src/common/parsing.rs | 5 +---- src/common/tests.rs | 14 +++++++------- src/errors.rs | 8 ++++---- src/search.rs | 22 +++++++++------------- 13 files changed, 63 insertions(+), 90 deletions(-) diff --git a/examples/add_any_port.rs b/examples/add_any_port.rs index 9cfc66dd..9e44d645 100644 --- a/examples/add_any_port.rs +++ b/examples/add_any_port.rs @@ -4,7 +4,7 @@ extern crate igd; fn main() { match igd::search_gateway(Default::default()) { - Err(ref err) => println!("Error: {}", err), + Err(ref err) => println!("Error: {err}"), Ok(gateway) => { let local_addr = match std::env::args().nth(1) { Some(local_addr) => local_addr, @@ -15,10 +15,10 @@ fn main() { match gateway.add_any_port(igd::PortMappingProtocol::TCP, local_addr, 60, "add_port example") { Err(ref err) => { - println!("There was an error! {}", err); + println!("There was an error! {err}"); } Ok(port) => { - println!("It worked! Got port {}", port); + println!("It worked! Got port {port}"); } } } diff --git a/examples/add_port.rs b/examples/add_port.rs index 6f7166dc..9d584b7e 100644 --- a/examples/add_port.rs +++ b/examples/add_port.rs @@ -4,7 +4,7 @@ extern crate igd; fn main() { match igd::search_gateway(Default::default()) { - Err(ref err) => println!("Error: {}", err), + Err(ref err) => println!("Error: {err}"), Ok(gateway) => { let local_addr = match std::env::args().nth(1) { Some(local_addr) => local_addr, @@ -15,7 +15,7 @@ fn main() { match gateway.add_port(igd::PortMappingProtocol::TCP, 80, local_addr, 60, "add_port example") { Err(ref err) => { - println!("There was an error! {}", err); + println!("There was an error! {err}"); } Ok(()) => { println!("It worked"); diff --git a/examples/add_remove.rs b/examples/add_remove.rs index a787b5ee..468c923d 100644 --- a/examples/add_remove.rs +++ b/examples/add_remove.rs @@ -6,8 +6,8 @@ extern crate igd; fn main() { match igd::search_gateway(Default::default()) { Err(ref err) => match *err { - igd::SearchError::IoError(ref ioe) => println!("IoError: {}", ioe), - _ => println!("{:?}", err), + igd::SearchError::IoError(ref ioe) => println!("IoError: {ioe}"), + _ => println!("{err:?}"), }, Ok(gateway) => { let args: Vec<_> = env::args().collect(); @@ -22,11 +22,11 @@ fn main() { let local_addr = SocketAddrV4::new(local_ip, local_port); match gateway.add_port(igd::PortMappingProtocol::TCP, remote_port, local_addr, 60, "crust") { - Err(ref err) => println!("{:?}", err), + Err(ref err) => println!("{err:?}"), Ok(()) => { println!("AddPortMapping successful."); match gateway.remove_port(igd::PortMappingProtocol::TCP, remote_port) { - Err(ref err) => println!("Error removing: {:?}", err), + Err(ref err) => println!("Error removing: {err:?}"), Ok(_) => println!("DeletePortMapping successful."), } } diff --git a/examples/aio.rs b/examples/aio.rs index 8b21eca8..19d22926 100644 --- a/examples/aio.rs +++ b/examples/aio.rs @@ -33,18 +33,18 @@ async fn main() { let gateway = match search_gateway(Default::default()).await { Ok(g) => g, - Err(err) => return println!("Faild to find IGD: {}", err), + Err(err) => return println!("Faild to find IGD: {err}"), }; let pub_ip = match gateway.get_external_ip().await { Ok(ip) => ip, - Err(err) => return println!("Failed to get external IP: {}", err), + Err(err) => return println!("Failed to get external IP: {err}"), }; - println!("Our public IP is {}", pub_ip); + println!("Our public IP is {pub_ip}"); if let Err(e) = gateway .add_port(PortMappingProtocol::TCP, 1234, ip, 120, "rust-igd-async-example") .await { - println!("Failed to add port mapping: {}", e); + println!("Failed to add port mapping: {e}"); } println!("New port mapping was successfully added."); @@ -52,7 +52,7 @@ async fn main() { .add_port(PortMappingProtocol::TCP, 2345, ip, 120, "rust-igd-async-example") .await { - println!("Failed to add port mapping: {}", e); + println!("Failed to add port mapping: {e}"); } println!("New port mapping was successfully added."); diff --git a/examples/external_ip.rs b/examples/external_ip.rs index 067990a9..b29e6974 100644 --- a/examples/external_ip.rs +++ b/examples/external_ip.rs @@ -2,13 +2,13 @@ extern crate igd; fn main() { match igd::search_gateway(Default::default()) { - Err(ref err) => println!("Error: {}", err), + Err(ref err) => println!("Error: {err}"), Ok(gateway) => match gateway.get_external_ip() { Err(ref err) => { - println!("There was an error! {}", err); + println!("There was an error! {err}"); } Ok(ext_addr) => { - println!("Local gateway: {}, External ip address: {}", gateway, ext_addr); + println!("Local gateway: {gateway}, External ip address: {ext_addr}"); } }, } diff --git a/examples/remove_port.rs b/examples/remove_port.rs index e4690af2..64d1d39b 100644 --- a/examples/remove_port.rs +++ b/examples/remove_port.rs @@ -2,10 +2,10 @@ extern crate igd; fn main() { match igd::search_gateway(Default::default()) { - Err(ref err) => println!("Error: {}", err), + Err(ref err) => println!("Error: {err}"), Ok(gateway) => match gateway.remove_port(igd::PortMappingProtocol::TCP, 80) { Err(ref err) => { - println!("There was an error! {}", err); + println!("There was an error! {err}"); } Ok(()) => { println!("It worked"); diff --git a/src/aio/gateway.rs b/src/aio/gateway.rs index c3fb29ac..faabb914 100644 --- a/src/aio/gateway.rs +++ b/src/aio/gateway.rs @@ -26,7 +26,7 @@ pub struct Gateway { impl Gateway { async fn perform_request(&self, header: &str, body: &str, ok: &str) -> Result { - let url = format!("{}", self); + let url = format!("{self}"); let text = soap::send_async(&url, soap::Action::new(header), body).await?; parsing::parse_response(text, ok) } diff --git a/src/aio/search.rs b/src/aio/search.rs index 82adbb62..d92b70e3 100644 --- a/src/aio/search.rs +++ b/src/aio/search.rs @@ -39,7 +39,7 @@ pub async fn search_gateway(options: SearchOptions) -> Result Ok(a), _ => { - warn!("unsupported IPv6 gateway response from addr: {}", addr); + warn!("unsupported IPv6 gateway response from addr: {addr}"); Err(SearchError::InvalidResponse) } }?; @@ -85,13 +85,13 @@ async fn send_search_request(socket: &mut UdpSocket, addr: SocketAddr) -> Result async fn receive_search_response(socket: &mut UdpSocket) -> Result<(Vec, SocketAddr), SearchError> { let mut buff = [0u8; MAX_RESPONSE_SIZE]; let (n, from) = socket.recv_from(&mut buff).await?; - debug!("received broadcast response from: {}", from); + debug!("received broadcast response from: {from}"); Ok((buff[..n].to_vec(), from)) } // Handle a UDP response message fn handle_broadcast_resp(from: &SocketAddr, data: &[u8]) -> Result<(SocketAddr, String), SearchError> { - debug!("handling broadcast response from: {}", from); + debug!("handling broadcast response from: {from}"); // Convert response to text let text = std::str::from_utf8(data).map_err(SearchError::from)?; @@ -103,9 +103,9 @@ fn handle_broadcast_resp(from: &SocketAddr, data: &[u8]) -> Result<(SocketAddr, } async fn get_control_urls(addr: &SocketAddr, path: &str) -> Result<(String, String), SearchError> { - debug!("requesting control url from: http://{}{}", addr, path); + debug!("requesting control url from: http://{addr}{path}"); let body = http_get_bounded(addr, path, MAX_HTTP_RESPONSE_SIZE).await?; - debug!("handling control response from: {}", addr); + debug!("handling control response from: {addr}"); parsing::parse_control_urls(std::io::Cursor::new(body)) } @@ -113,9 +113,9 @@ async fn get_control_schemas( addr: &SocketAddr, control_schema_url: &str, ) -> Result>, SearchError> { - debug!("requesting control schema from: http://{}{}", addr, control_schema_url); + debug!("requesting control schema from: http://{addr}{control_schema_url}"); let body = http_get_bounded(addr, control_schema_url, MAX_HTTP_RESPONSE_SIZE).await?; - debug!("handling schema response from: {}", addr); + debug!("handling schema response from: {addr}"); parsing::parse_schemas(std::io::Cursor::new(body)) } @@ -123,7 +123,7 @@ async fn http_get_bounded(addr: &SocketAddr, path: &str, memory_upper_bound: usi use http_body_util::BodyExt; let authority = addr.to_string(); - let uri: Uri = format!("http://{}{}", addr, path).parse()?; + let uri: Uri = format!("http://{addr}{path}").parse()?; let url: url::Url = uri.to_string().parse()?; validate_url(addr.ip(), &url)?; @@ -188,18 +188,14 @@ mod tests { service::service_fn, }; use hyper_util::rt::TokioIo; - use rand::{distributions::Alphanumeric, thread_rng, Rng}; + use rand::{distr::Alphanumeric, rng, Rng}; use tokio::net::TcpListener; use tokio_stream::wrappers::ReceiverStream; use super::*; fn generate_random_body(n: usize) -> Vec { - let s: String = thread_rng() - .sample_iter(&Alphanumeric) - .take(n) - .map(char::from) - .collect(); + let s: String = rng().sample_iter(&Alphanumeric).take(n).map(char::from).collect(); s.into_bytes() } diff --git a/src/common/messages.rs b/src/common/messages.rs index 8df3f74d..4f71cdd4 100644 --- a/src/common/messages.rs +++ b/src/common/messages.rs @@ -27,7 +27,7 @@ const MESSAGE_TAIL: &str = r#" "#; fn format_message(body: String) -> String { - format!("{}{}{}", MESSAGE_HEAD, body, MESSAGE_TAIL) + format!("{MESSAGE_HEAD}{body}{MESSAGE_TAIL}") } pub fn format_get_external_ip_message() -> String { @@ -62,24 +62,19 @@ pub fn format_add_any_port_mapping_message( "NewProtocol" => protocol.to_string(), "NewRemoteHost" => "".to_string(), unknown => { - warn!("Unknown argument: {}", unknown); + warn!("Unknown argument: {unknown}"); return None; } }; - Some(format!( - "<{argument}>{value}", - argument = argument, - value = value - )) + Some(format!("<{argument}>{value}")) }) .collect::>() .join("\n"); format_message(format!( r#" - {} + {args} "#, - args, )) } @@ -104,24 +99,19 @@ pub fn format_add_port_mapping_message( "NewProtocol" => protocol.to_string(), "NewRemoteHost" => "".to_string(), unknown => { - warn!("Unknown argument: {}", unknown); + warn!("Unknown argument: {unknown}"); return None; } }; - Some(format!( - "<{argument}>{value}", - argument = argument, - value = value - )) + Some(format!("<{argument}>{value}")) }) .collect::>() .join("\n"); format_message(format!( r#" - {} + {args} "#, - args, )) } @@ -134,32 +124,26 @@ pub fn format_delete_port_message(schema: &[String], protocol: PortMappingProtoc "NewProtocol" => protocol.to_string(), "NewRemoteHost" => "".to_string(), unknown => { - warn!("Unknown argument: {}", unknown); + warn!("Unknown argument: {unknown}"); return None; } }; - Some(format!( - "<{argument}>{value}", - argument = argument, - value = value - )) + Some(format!("<{argument}>{value}")) }) .collect::>() .join("\n"); format_message(format!( r#" - {} + {args} "#, - args, )) } pub fn formate_get_generic_port_mapping_entry_message(port_mapping_index: u32) -> String { format_message(format!( r#" - {} - "#, - port_mapping_index + {port_mapping_index} + "# )) } diff --git a/src/common/parsing.rs b/src/common/parsing.rs index 8df5ec5a..850e3971 100644 --- a/src/common/parsing.rs +++ b/src/common/parsing.rs @@ -329,10 +329,7 @@ pub fn parse_get_generic_port_mapping_entry( let response = result?; let xml = response.xml; let make_err = |msg: String| || GetGenericPortMappingEntryError::RequestError(RequestError::InvalidResponse(msg)); - let extract_field = |field: &str| { - xml.get_child(field) - .ok_or_else(make_err(format!("{} is missing", field))) - }; + let extract_field = |field: &str| xml.get_child(field).ok_or_else(make_err(format!("{field} is missing"))); let remote_host = extract_field("NewRemoteHost")? .get_text() .map(|c| c.into_owned()) diff --git a/src/common/tests.rs b/src/common/tests.rs index 8840de49..161eece0 100644 --- a/src/common/tests.rs +++ b/src/common/tests.rs @@ -15,8 +15,8 @@ use tokio::net::{TcpListener, UdpSocket}; async fn find_free_port(ip: IpAddr) -> u16 { // Not 100% reliable way to find a free port number, but should be good enough let sock = UdpSocket::bind((ip, 0)).await.unwrap(); - let ret = sock.local_addr().unwrap().port(); - ret + + sock.local_addr().unwrap().port() } pub async fn start_broadcast_reply_sender(location: String) -> u16 { @@ -56,7 +56,7 @@ pub async fn default_options_with_using_free_port(port: u16) -> SearchOptions { } } -const RESP_SPOOFED_SCPDURL: &'static str = r#" +const RESP_SPOOFED_SCPDURL: &str = r#" @@ -78,7 +78,7 @@ const RESP_SPOOFED_SCPDURL: &'static str = r#" "#; -const RESP_SPOOFED_CONTROL_URL: &'static str = r#" +const RESP_SPOOFED_CONTROL_URL: &str = r#" @@ -100,7 +100,7 @@ const RESP_SPOOFED_CONTROL_URL: &'static str = r#" "#; -const RESP: &'static str = r#" +const RESP: &str = r#" @@ -122,7 +122,7 @@ const RESP: &'static str = r#" "#; -const RESP_CONTROL_SCHEMA: &'static str = r#" +const RESP_CONTROL_SCHEMA: &str = r#" @@ -151,7 +151,7 @@ async fn start_http_server(responses: Vec) -> u16 { .serve_connection(io, service_fn(|r| async { handler(r) })) .await { - eprintln!("Error serving connection: {:?}", err); + eprintln!("Error serving connection: {err:?}"); } } }); diff --git a/src/errors.rs b/src/errors.rs index fa94d609..df4a73f9 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -120,7 +120,7 @@ impl fmt::Display for GetExternalIpError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { GetExternalIpError::ActionNotAuthorized => write!(f, "The client is not authorized to remove the port"), - GetExternalIpError::RequestError(ref e) => write!(f, "Request Error. {}", e), + GetExternalIpError::RequestError(ref e) => write!(f, "Request Error. {e}"), } } } @@ -142,7 +142,7 @@ impl fmt::Display for RemovePortError { match *self { RemovePortError::ActionNotAuthorized => write!(f, "The client is not authorized to remove the port"), RemovePortError::NoSuchPortMapping => write!(f, "The port was not mapped"), - RemovePortError::RequestError(ref e) => write!(f, "Request error. {}", e), + RemovePortError::RequestError(ref e) => write!(f, "Request error. {e}"), } } } @@ -180,7 +180,7 @@ impl fmt::Display for AddAnyPortError { AddAnyPortError::DescriptionTooLong => { write!(f, "The description was too long for the gateway to handle.") } - AddAnyPortError::RequestError(ref e) => write!(f, "Request error. {}", e), + AddAnyPortError::RequestError(ref e) => write!(f, "Request error. {e}"), } } } @@ -213,7 +213,7 @@ impl fmt::Display for AddPortError { "The gateway only supports permanent leases (ie. a `lease_duration` of 0)," ), AddPortError::DescriptionTooLong => write!(f, "The description was too long for the gateway to handle."), - AddPortError::RequestError(ref e) => write!(f, "Request error. {}", e), + AddPortError::RequestError(ref e) => write!(f, "Request error. {e}"), } } } diff --git a/src/search.rs b/src/search.rs index 146f5f3b..0560503d 100644 --- a/src/search.rs +++ b/src/search.rs @@ -38,17 +38,13 @@ pub fn search_gateway(options: SearchOptions) -> Result { check_is_ip_spoofed(&from, &addr.into())?; let (control_schema_url, control_url) = get_control_urls(&addr, &root_url).map_err(|e| { - debug!( - "Error has occurred while getting control urls. error: {}, addr: {}, root_url: {}", - e, addr, root_url - ); + debug!("Error has occurred while getting control urls. error: {e}, addr: {addr}, root_url: {root_url}"); e })?; let control_schema = get_control_schemas(&addr, &control_schema_url).map_err(|e| { debug!( - "Error has occurred while getting schemas. error: {}, addr: {}, control_schema_url: {}", - e, addr, control_schema_url + "Error has occurred while getting schemas. error: {e}, addr: {addr}, control_schema_url: {control_schema_url}" ); e })?; @@ -65,19 +61,19 @@ pub fn search_gateway(options: SearchOptions) -> Result { validate_url((*addr.ip()).into(), &gateway_url)?; - return Ok(gateway); + Ok(gateway) } fn get_control_urls(addr: &SocketAddrV4, path: &str) -> Result<(String, String), SearchError> { - let url: reqwest::Url = format!("http://{}{}", addr, path).parse()?; + let url: reqwest::Url = format!("http://{addr}{path}").parse()?; validate_url((*addr.ip()).into(), &url)?; - debug!("requesting control url from: {:?}", url); + debug!("requesting control url from: {url:?}"); let client = reqwest::blocking::Client::new(); let resp = client.get(url).send()?; - debug!("handling control response from: {}", addr); + debug!("handling control response from: {addr}"); let body = resp.bytes()?; parsing::parse_control_urls(body.as_ref()) } @@ -86,15 +82,15 @@ fn get_control_schemas( addr: &SocketAddrV4, control_schema_url: &str, ) -> Result>, SearchError> { - let url: reqwest::Url = format!("http://{}{}", addr, control_schema_url).parse()?; + let url: reqwest::Url = format!("http://{addr}{control_schema_url}").parse()?; validate_url((*addr.ip()).into(), &url)?; - debug!("requesting control schema from: {}", url); + debug!("requesting control schema from: {url}"); let client = reqwest::blocking::Client::new(); let resp = client.get(url).send()?; - debug!("handling schema response from: {}", addr); + debug!("handling schema response from: {addr}"); let body = resp.bytes()?; parsing::parse_schemas(body.as_ref())