ProfessionalUwU/echoip-slatecave
1
0
Fork 0
mirror of https://codeberg.org/slatian/service.echoip-slatecave.git synced 2025-07-17 22:43:33 +02:00
Code Issues Packages Projects Releases Wiki Activity

Make clippy happy

Browse Source 
Mostly cleaning up type system crimes from when I was still learning rust:
* Abuse of `match` and loops
* Non-use of helper functions (`is_empty`, `is_none`)
* Use of borrowed owned types (`&String`)
* Implementing `Into` instead of `From`
This commit is contained in:
Slatian
2025-02-09 15:43:09 +01:00
parent d902dae35d
commit b98bb67b4c
5 changed files with 63 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
src/main.rs
View File

@ -1,3 +1,7 @@
#![allow(clippy::redundant_field_names)]
#![allow(clippy::needless_return)]
use axum::{
body::Body,
extract::{
@ -61,7 +65,7 @@ use crate::idna::IdnaName;
use crate::simple_dns::DnsLookupResult;
use crate::settings::*;
use crate::view::View;
use crate::ipinfo::{AddressCast,AddressInfo,AddressScope};
use crate::ipinfo::{AddressInfo,AddressScope};
type TemplatingEngine = HumusEngine<View,QuerySettings,ResponseFormat>;
@ -133,7 +137,7 @@ struct CliArgs {
static_location: Option<String>,
}
fn match_domain_hidden_list(domain: &String, hidden_list: &Vec<String>) -> bool {
fn match_domain_hidden_list(domain: &str, hidden_list: &Vec<String>) -> bool {
let name = domain.trim_end_matches(".");
for suffix in hidden_list {
if name.ends_with(suffix) {
@ -265,7 +269,7 @@ async fn main() {
});
dns_resolver_selectables.sort_by(|a,b| b.weight.cmp(&a.weight));
let default_resolver = dns_resolver_selectables.get(0)
let default_resolver = dns_resolver_selectables.first()
.map(|s| s.id.clone() )
.unwrap_or("none".into());
let derived_config = DerivedConfiguration {
@ -286,7 +290,7 @@ async fn main() {
}
};
loop {
if None == signal_stream.recv().await { return; }
if signal_stream.recv().await.is_none() { return; }
info!("Received signal USR1, reloading geoip databses!");
signal_usr1_handlers_state.location_db.reload_database().ok();
signal_usr1_handlers_state.asn_db.reload_database().ok();
@ -436,10 +440,8 @@ async fn handle_default_route(
&state,
).await;
let user_agent: Option<String> = match user_agent_header {
Some(TypedHeader(user_agent)) => Some(user_agent.to_string()),
None => None,
};
let user_agent: Option<String> = user_agent_header
.map(|TypedHeader(user_agent)| user_agent.to_string());
state.templating_engine.render_view(
&settings,
@ -466,7 +468,7 @@ async fn handle_search_request(
//If someone asked for an asn, give an asn answer
if let Some(asn_cap) = ASN_REGEX.captures(&search_query) {
if let Some(asn) = asn_cap.get(1).map_or(None, |m| m.as_str().parse::<u32>().ok()) {
if let Some(asn) = asn_cap.get(1).and_then(|m| m.as_str().parse::<u32>().ok()) {
// Render a dummy template that can at least link to other pages
let state = Arc::clone(&arc_state);
return state.templating_engine.render_view(
@ -571,7 +573,7 @@ async fn handle_ip_request(
async fn get_ip_result(
address: &IpAddr,
lang: &String,
lang: &str,
dns_resolver_name: &Arc<str>,
dns_disable_self_lookup: bool,
client_ip: &IpAddr,
@ -580,34 +582,36 @@ async fn get_ip_result(
let mut reverse_dns_disabled_for_privacy = false;
if state.config.dns.allow_reverse_lookup {
if address == client_ip && dns_disable_self_lookup {
reverse_dns_disabled_for_privacy = true;
}
if state.config.dns.allow_reverse_lookup &&
address == client_ip &&
dns_disable_self_lookup
{
reverse_dns_disabled_for_privacy = true;
}
let ip_info = AddressInfo::new(&address);
let ip_info = AddressInfo::new(address);
if !(ip_info.scope == AddressScope::Global || ip_info.scope == AddressScope::Shared) || ip_info.cast != AddressCast::Unicast {
if !((ip_info.scope == AddressScope::Private || ip_info.scope == AddressScope::LinkLocal) && state.config.server.allow_private_ip_lookup) {
return IpResult {
address: *address,
hostname: None,
asn: None,
location: None,
ip_info: ip_info,
used_dns_resolver: None,
reverse_dns_disabled_for_privacy: reverse_dns_disabled_for_privacy,
}
// Return dummy result if:
//
// The address falls into a private range and lookup of private addresses is not allowed.
if (!state.config.server.allow_private_ip_lookup) && (ip_info.scope == AddressScope::Private || ip_info.scope == AddressScope::LinkLocal) {
return IpResult {
address: *address,
hostname: None,
asn: None,
location: None,
ip_info: ip_info,
used_dns_resolver: None,
reverse_dns_disabled_for_privacy: reverse_dns_disabled_for_privacy,
}
}
}
// do reverse lookup
let mut hostname: Option<String> = None;
let mut used_dns_resolver: Option<Arc<str>> = None;
if state.config.dns.allow_reverse_lookup && !reverse_dns_disabled_for_privacy {
if let Some(dns_resolver) = &state.dns_resolvers.get(dns_resolver_name) {
hostname = simple_dns::reverse_lookup(&dns_resolver, &address).await;
hostname = simple_dns::reverse_lookup(dns_resolver, address).await;
used_dns_resolver = Some(dns_resolver_name.clone());
}
}
@ -618,12 +622,12 @@ async fn get_ip_result(
// location lookup
let location_result = state.location_db.query_location_for_ip(
address,
&vec![lang, &"en".to_string()]
&[lang, "en"]
);
// filter reverse lookup
if let Some(name) = &hostname {
if match_domain_hidden_list(&name, &state.config.dns.hidden_suffixes) {
if match_domain_hidden_list(name, &state.config.dns.hidden_suffixes) {
hostname = None;
used_dns_resolver = None;
}
@ -672,21 +676,21 @@ async fn handle_dig_request(
}
async fn get_dig_result(
dig_query: &String,
dig_query: &str,
dns_resolver_name: &Arc<str>,
state: &ServiceSharedState,
do_full_lookup: bool,
) -> DigResult {
let name = &dig_query.trim().trim_end_matches(".").to_string();
let idna_name = IdnaName::from_string(&name);
let idna_name = IdnaName::from_str(name);
if let Some(dns_resolver) = state.dns_resolvers.get(dns_resolver_name) {
if let Ok(domain_name) = Name::from_str_relaxed(name.to_owned()+".") {
if match_domain_hidden_list(&name, &state.config.dns.hidden_suffixes) {
if match_domain_hidden_list(name, &state.config.dns.hidden_suffixes) {
// Try to hide the fact that we didn't do dns resolution at all
// We resolve example.org as basic avoidance of timing sidechannels.
// WARNING: this timing sidechannel avoidance is very crude.
simple_dns::lookup(
&dns_resolver,
dns_resolver,
&Name::from_ascii("example.org.").expect("Static Dummy Name"),
do_full_lookup).await;
return DigResult {
@ -698,7 +702,7 @@ async fn get_dig_result(
} else {
return DigResult {
records: simple_dns::lookup(
&dns_resolver,
dns_resolver,
&domain_name,
do_full_lookup).await,
idn: idna_name,