feat: url parsing and dist domains

Cargo.lock

@@ -189,6 +189,7 @@ dependencies = [
  "serde",
  "tar",
  "trie-rs",
+ "url",
 ]
 
 [[package]]

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "blocklist-check"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 
 [dependencies]
@@ -18,6 +18,7 @@ env_logger = "0.11.8"
 reqwest = { version = "0.12.24", features = ["stream", "rustls-tls-webpki-roots"] }
 chrono = { version = "0.4.42", features = ["serde"] }
 rocket-cache-response = "0.6.4"
+url = "2.5.7"
 
 [build-dependencies]
 reqwest = { version = "0.12", features = ["blocking", "json"] }

dist-domains.txt

@@ -0,0 +1,16 @@
+x.com
+youtube.com
+ytimg.com
+googlevideo.com
+youtube.googleapis.com
+youtu.be
+discord.com
+discordapp.com
+discord.dev
+discord.new
+discord.gift
+discordapp.net
+discord.co
+dis.gd
+discord.gg
+discord.media

src/lists.rs

@@ -95,7 +95,7 @@ impl RuBlacklist {
         }
     }
 
-    pub fn update<R: BufRead>(&mut self, ip_reader: R, domain_reader: R) -> Result<(), Error>  {
+    pub fn update<R: BufRead>(&mut self, ip_reader: R, domain_reader: R, custom_domains_reader: R) -> Result<(), Error>  {
         let mut ip_trie = IpnetTrie::new();
         for net in ip_reader.lines() {
             let net = net?;
@@ -109,7 +109,7 @@ impl RuBlacklist {
 
         let mut domain_trie = TrieBuilder::new();
         let mut count = 0;
-        for domain in domain_reader.lines() {
+        for domain in domain_reader.lines().chain(custom_domains_reader.lines()) {
             let domain = domain?;
             domain_trie.insert(Self::domain_chunks(&domain), domain);
             count += 1;
@@ -142,16 +142,18 @@ impl RuBlacklist {
 
 #[async_trait]
 impl Updatable for RuBlacklist {
-    type Base = (VecDeque<u8>, VecDeque<u8>);
+    type Base = (VecDeque<u8>, VecDeque<u8>, VecDeque<u8>);
 
     async fn download() -> Result<Self::Base, Error> {
         Ok((VecDeque::from(
             fetch_db(Self::get_url("RKN_NETS", "https://antifilter.download/list/allyouneed.lst")).await?),
             VecDeque::from(
-            fetch_db(Self::get_url("RKN_DOMAINS", "https://antifilter.download/list/domains.lst")).await?)))
+            fetch_db(Self::get_url("RKN_DOMAINS", "https://antifilter.download/list/domains.lst")).await?),
+            VecDeque::from(include_bytes!("../dist-domains.txt").to_vec())
+        ))
     }
 
-    async fn install(&mut self, (nets, domains): Self::Base) -> Result<(), Error> {
-        self.update(nets, domains)
+    async fn install(&mut self, (nets, domains, custom_domains): Self::Base) -> Result<(), Error> {
+        self.update(nets, domains, custom_domains)
     }
 }

src/main.rs

@@ -61,14 +61,14 @@ async fn check(target: &str, resolver: &State<Resolver>,
                geo_ip: &State<Arc<RwLock<GeoIp>>>,
                cdn: &State<Arc<RwLock<CdnList>>>,
                ru_blacklist: &State<Arc<RwLock<RuBlacklist>>>) -> Result<Template, Status> {
-    let parsed = Target::from(target);
-    let ips = match parsed.resolve(resolver).await {
+    let target = Target::from(target);
+    let ips = match target.resolve(resolver).await {
         Ok(ips) => ips,
         Err(e) if e.kind().is_no_records_found() => {
             return Ok(Template::render("empty", context! {
                 global: GlobalContext::new(),
-                target,
-                target_type: parsed.readable_type(),
+                target: target.to_query(),
+                target_type: target.readable_type(),
             }));
         }
         Err(e) => {
@@ -99,7 +99,7 @@ async fn check(target: &str, resolver: &State<Resolver>,
         });
 
     let ru_blacklist = ru_blacklist.read().await;
-    let domain = match &parsed {
+    let domain = match &target {
         Target::Domain(domain) => ru_blacklist.contains_domain(domain),
         _ => None
     };
@@ -117,8 +117,8 @@ async fn check(target: &str, resolver: &State<Resolver>,
         providers,
         domain,
         blocked_subnets,
-        target,
-        target_type: parsed.readable_type(),
+        target: target.to_query(),
+        target_type: target.readable_type(),
         ips,
         geo,
     }))

src/target.rs

@@ -1,5 +1,6 @@
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 use hickory_resolver::proto::ProtoError;
+use url::Url;
 use crate::resolver::Resolver;
 
 pub enum Target {
@@ -17,6 +18,12 @@ impl From<&str> for Target {
         if let Ok(ipv6) = input.parse::<Ipv6Addr>() {
             return Target::Ipv6(ipv6);
         }
+
+        if let Ok(url) = input.parse::<Url>() {
+            if let Some(host) = url.host_str() {
+                return Target::Domain(host.to_string());
+            }
+        }
         Target::Domain(input.to_string())
     }
 }
@@ -37,4 +44,12 @@ impl Target {
             Target::Ipv6(ipv6) => vec![IpAddr::V6(ipv6.clone())],
         })
     }
+
+    pub fn to_query(&self) -> String {
+        match self {
+            Target::Domain(domain) => domain.clone(),
+            Target::Ipv4(v4) => v4.to_string(),
+            Target::Ipv6(v6) => v6.to_string(),
+        }
+    }
 }