Added to= option matching.

Author: boocmp

src/data_format/mod.rs

@@ -19,7 +19,7 @@ const ADBLOCK_RUST_DAT_MAGIC: [u8; 4] = [0xd1, 0xd9, 0x3a, 0xaf];
 
 /// The version of the data format.
 /// If the data format version is incremented, the data is considered as incompatible.
-const ADBLOCK_RUST_DAT_VERSION: u8 = 7;
+const ADBLOCK_RUST_DAT_VERSION: u8 = 8;
 
 /// The total length of the header prefix (magic + version + seahash)
 const HEADER_PREFIX_LENGTH: usize = 4 + 1 + 8;

src/filters/fb_network.rs

@@ -143,6 +143,20 @@ impl<'a> FlatNetworkFilter<'a> {
             .map(|data| fb_vector_to_slice(data))
     }
 
+    #[inline(always)]
+    pub fn include_to_domains(&self) -> Option<&[u32]> {
+        self.fb_filter
+            .opt_to_domains()
+            .map(|data| fb_vector_to_slice(data))
+    }
+
+    #[inline(always)]
+    pub fn exclude_to_domains(&self) -> Option<&[u32]> {
+        self.fb_filter
+            .opt_to_not_domains()
+            .map(|data| fb_vector_to_slice(data))
+    }
+
     #[inline(always)]
     pub fn hostname(&self) -> Option<&'a str> {
         if self.mask.is_hostname_anchor() {
@@ -260,14 +274,28 @@ impl NetworkMatchable for FlatNetworkFilter<'_> {
         }
         if !check_included_domains_mapped(
             self.include_domains(),
-            request,
+            request.source_hostname_hashes.as_deref(),
             &self.filter_data_context.unique_domains_hashes_map,
         ) {
             return false;
         }
         if !check_excluded_domains_mapped(
             self.exclude_domains(),
-            request,
+            request.source_hostname_hashes.as_deref(),
+            &self.filter_data_context.unique_domains_hashes_map,
+        ) {
+            return false;
+        }
+        if !check_included_domains_mapped(
+            self.include_to_domains(),
+            request.hostname_hashes.as_deref(),
+            &self.filter_data_context.unique_domains_hashes_map,
+        ) {
+            return false;
+        }
+        if !check_excluded_domains_mapped(
+            self.exclude_to_domains(),
+            request.hostname_hashes.as_deref(),
             &self.filter_data_context.unique_domains_hashes_map,
         ) {
             return false;

src/filters/fb_network_builder.rs

@@ -53,6 +53,7 @@ impl Default for NetworkFilterDebugData {
 struct NetworkFilterListBuilder<'a, 'f> {
     filter_map_builder: FlatMultiMapBuilder<ShortHash, NetworkFilterFlatEntry<'a>>,
     opt_domains_map_builder: FlatMultiMapBuilder<ShortHash, NetworkFilterFlatEntry<'a>>,
+    opt_to_domains_map_builder: FlatMultiMapBuilder<ShortHash, NetworkFilterFlatEntry<'a>>,
     token_frequencies: TokenSelector,
     filters_to_optimize: HashMap<ShortHash, Vec<NetworkFilter<'f>>>,
     tokens_buffer: TokensBuffer,
@@ -173,6 +174,7 @@ impl<'a, 'f> NetworkFilterListBuilder<'a, 'f> {
         Self {
             filter_map_builder: FlatMultiMapBuilder::with_capacity(1024),
             opt_domains_map_builder: FlatMultiMapBuilder::with_capacity(256),
+            opt_to_domains_map_builder: FlatMultiMapBuilder::with_capacity(256),
             token_frequencies: TokenSelector::new(1024),
             filters_to_optimize: HashMap::new(),
             tokens_buffer: TokensBuffer::default(),
@@ -216,6 +218,12 @@ impl<'a, 'f> NetworkFilterListBuilder<'a, 'f> {
                             .insert(to_short_hash(*token), NetworkFilterFlatEntry { filter, id });
                     }
                 }
+                FilterTokens::OptToDomains => {
+                    for token in &self.tokens_buffer {
+                        self.opt_to_domains_map_builder
+                            .insert(to_short_hash(*token), NetworkFilterFlatEntry { filter, id });
+                    }
+                }
             }
         } else {
             // Defer serialization to the optimizer (pattern map only).
@@ -257,11 +265,6 @@ impl<'a, 'f> NetworkRulesBuilder<'a, 'f> {
             return;
         }
 
-        // For now, filters with $to options are parsed but ignored
-        // to preserve existing matching behavior.
-        if filter.has_to_option() {
-            return;
-        }
 
         // Redirects are independent of blocking behavior.
         if filter.is_redirect() {
@@ -354,11 +357,16 @@ impl<'a, 'f> FlatSerialize<'a, EngineFlatBuilder<'a>> for NetworkRulesBuilder<'a
             rule_list
                 .opt_domains_map_builder
                 .retain_by_value(|entry| !value.bad_filter_ids.contains(&entry.id));
+            rule_list
+                .opt_to_domains_map_builder
+                .retain_by_value(|entry| !value.bad_filter_ids.contains(&entry.id));
 
             let flat_filter_map =
                 FlatMultiMapBuilder::finish(rule_list.filter_map_builder, builder);
             let flat_opt_domains_map =
                 FlatMultiMapBuilder::finish(rule_list.opt_domains_map_builder, builder);
+            let flat_opt_to_domains_map =
+                FlatMultiMapBuilder::finish(rule_list.opt_to_domains_map_builder, builder);
 
             serialized_lists.push(fb::NetworkFilterList::create(
                 builder.raw_builder(),
@@ -367,6 +375,8 @@ impl<'a, 'f> FlatSerialize<'a, EngineFlatBuilder<'a>> for NetworkRulesBuilder<'a
                     filter_map_values: Some(flat_filter_map.values),
                     opt_domains_map_index: Some(flat_opt_domains_map.keys),
                     opt_domains_map_values: Some(flat_opt_domains_map.values),
+                    opt_to_domains_map_index: Some(flat_opt_to_domains_map.keys),
+                    opt_to_domains_map_values: Some(flat_opt_to_domains_map.values),
                 },
             ));
         }

src/filters/network.rs

@@ -333,6 +333,7 @@ pub enum FilterPart<'a> {
 pub(crate) enum FilterTokens {
     Empty,
     OptDomains,
+    OptToDomains,
     Other,
 }
 
@@ -974,6 +975,8 @@ impl<'a> NetworkFilter<'a> {
             self.hostname.as_deref(),
             self.opt_domains.as_ref(),
             self.opt_not_domains.as_ref(),
+            self.opt_to_domains.as_ref(),
+            self.opt_to_not_domains.as_ref(),
         )
     }
 
@@ -992,6 +995,15 @@ impl<'a> NetworkFilter<'a> {
             return FilterTokens::OptDomains;
         }
 
+        // A single positive `$to=` is the next most selective key.
+        if self.opt_to_not_domains.is_none()
+            && let Some(domains) = self.opt_to_domains.as_ref()
+            && let [domain] = domains.as_slice()
+        {
+            tokens_buffer.push(*domain);
+            return FilterTokens::OptToDomains;
+        }
+
         // Get tokens from filter
         match &self.filter {
             FilterPart::Simple(f) if !self.is_complete_regex() => {
@@ -1046,6 +1058,14 @@ impl<'a> NetworkFilter<'a> {
                 }
                 // Too many domains to bucket individually; fall back to the catch-all
                 // bucket (token 0).
+            } else if let Some(opt_to_domains) = self.opt_to_domains.as_ref()
+                && !opt_to_domains.is_empty()
+            {
+                let cap = tokens_buffer.remaining_capacity();
+                if opt_to_domains.len() <= cap {
+                    tokens_buffer.extend(opt_to_domains.iter().copied());
+                    return FilterTokens::OptToDomains;
+                }
             }
             FilterTokens::Empty
         } else {
@@ -1146,6 +1166,8 @@ fn compute_filter_id(
     hostname: Option<&str>,
     opt_domains: Option<&Vec<Hash>>,
     opt_not_domains: Option<&Vec<Hash>>,
+    opt_to_domains: Option<&Vec<Hash>>,
+    opt_to_not_domains: Option<&Vec<Hash>>,
 ) -> Hash {
     let mut hasher = FxHasher::default();
 
@@ -1171,6 +1193,18 @@ fn compute_filter_id(
         }
     }
 
+    if let Some(domains) = opt_to_domains {
+        for d in domains {
+            hasher.write_u64(*d);
+        }
+    }
+
+    if let Some(domains) = opt_to_not_domains {
+        for d in domains {
+            hasher.write_u64(*d);
+        }
+    }
+
     match filter {
         FilterPart::Empty => {}
         FilterPart::Simple(s) => write_str_to_hasher(&mut hasher, s.as_ref()),

src/filters/network_matchers.rs

@@ -421,21 +421,21 @@ pub fn check_options(mask: NetworkFilterMask, request: &request::Request) -> boo
 #[inline]
 pub fn check_included_domains_mapped(
     opt_domains: Option<&[u32]>,
-    request: &request::Request,
+    hostname_hashes: Option<&[Hash]>,
     mapping: &HashMap<Hash, u32>,
 ) -> bool {
-    // Source URL must be among these domains to match
+    // Hostname must be among these domains to match
     if let Some(included_domains) = opt_domains.as_ref() {
-        if let Some(source_hashes) = request.source_hostname_hashes.as_ref() {
-            if source_hashes.iter().all(|h| {
+        if let Some(hashes) = hostname_hashes {
+            if hashes.iter().all(|h| {
                 mapping
                     .get(h)
                     .is_none_or(|index| !utils::bin_lookup(included_domains, *index))
             }) {
                 return false;
             }
         } else {
-            // If there are domain restrictions but no source hostname, we can't apply the rule
+            // If there are domain restrictions but no hostname, we can't apply the rule
             return false;
         }
     }
@@ -445,21 +445,21 @@ pub fn check_included_domains_mapped(
 #[inline]
 pub fn check_excluded_domains_mapped(
     opt_not_domains: Option<&[u32]>,
-    request: &request::Request,
+    hostname_hashes: Option<&[Hash]>,
     mapping: &HashMap<Hash, u32>,
 ) -> bool {
     if let Some(excluded_domains) = opt_not_domains.as_ref() {
-        if let Some(source_hashes) = request.source_hostname_hashes.as_ref() {
-            if source_hashes.iter().any(|h| {
+        if let Some(hashes) = hostname_hashes {
+            if hashes.iter().any(|h| {
                 mapping
                     .get(h)
                     .is_some_and(|index| utils::bin_lookup(excluded_domains, *index))
             }) {
                 return false;
             }
         } else {
-            // If there are domain restrictions but no source hostname
-            // (i.e. about:blank), apply the rule anyway.
+            // If there are domain restrictions but no hostname
+            // (i.e. about:blank for source), apply the rule anyway.
             return true;
         }
     }

src/flatbuffers/fb_network_filter.fbs

@@ -47,6 +47,10 @@ table NetworkFilterList {
   /// `$domain=` / `$from=` token buckets.
   opt_domains_map_index: [uint32] (required);
   opt_domains_map_values: [NetworkFilter] (required);
+
+  /// `$to=` token buckets.
+  opt_to_domains_map_index: [uint32] (required);
+  opt_to_domains_map_values: [NetworkFilter] (required);
 }
 
 /// A table to store the most host-specific cosmetic rules.