match-domain 0.1.3

Rapid checker for the prefix and suffix matching of domain names
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

# `match-domain`: Rapid checker for the prefix and suffix matching of domain names, written in Rust

[![match-domain](https://img.shields.io/crates/v/match-domain.svg)](https://crates.io/crates/match-domain)
[![match-domain](https://docs.rs/match-domain/badge.svg)](https://docs.rs/match-domain)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
![Unit Test](https://github.com/junkurihara/doh-auth-proxy/actions/workflows/test.yml/badge.svg)

Double-array trie based domain matcher, written in Rust.

This enables you to check if the given domain name matches the prefix or suffix of the domain name in the trie.

## Usage

### Basic Domain Matching

```rust
use match_domain::DomainMatchingRule;

let domain_matching_rule = DomainMatchingRule::try_from(vec![
    "www.google.com".to_string(),
    "*.google.com".to_string(),
    "yahoo.co.*".to_string(),
  ])
  .unwrap();

assert!(domain_matching_rule.is_matched("wwxx.google.com"));
assert!(domain_matching_rule.is_matched("yahoo.co.jp"));

assert!(!domain_matching_rule.is_matched("www.yahoo.com"));
assert!(!domain_matching_rule.is_matched("www.yahoo.co.jp"));
```

### Advanced Matching APIs

The library provides several APIs for more granular matching:

#### Suffix Matching

```rust
use match_domain::DomainMatchingRule;

let rule = DomainMatchingRule::try_from(vec![
    "google.com".to_string(),
    "*.google.com".to_string(),
    "com".to_string(),
])
.unwrap();

// Check if any suffix matches
assert!(rule.find_suffix_match("api.google.com"));

// Get all matching suffixes
let all_matches = rule.find_suffix_match_all("api.google.com");
// Returns reversed strings: ["moc.elgoog", "moc"]

// Get the longest matching suffix
let longest_match = rule.find_suffix_match_longest("api.google.com");
assert_eq!(longest_match, Some("moc.elgoog".to_string())); // "google.com" is longer than "com"
```

#### Prefix Matching

```rust
use match_domain::DomainMatchingRule;

let rule = DomainMatchingRule::try_from(vec![
    "www.example.*".to_string(),
    "www.*".to_string(),
    "api.service.*".to_string(),
])
.unwrap();

// Check if any prefix matches
assert!(rule.find_prefix_match("www.example.com"));

// Get all matching prefixes
let all_matches = rule.find_prefix_match_all("www.example.com");
// Returns: ["www.example", "www"]

// Get the longest matching prefix
let longest_match = rule.find_prefix_match_longest("www.example.com");
assert_eq!(longest_match, Some("www.example".to_string())); // "www.example" is longer than "www"
```

#### Comprehensive Example

```rust
use match_domain::DomainMatchingRule;

let rule = DomainMatchingRule::try_from(vec![
    "*.google.com".to_string(),      // Suffix pattern
    "www.example.*".to_string(),     // Prefix pattern
    "exact.domain.net".to_string(),  // Exact match
])
.unwrap();

// Test different domain matching scenarios
assert!(rule.is_matched("api.google.com"));        // Matches suffix pattern
assert!(rule.is_matched("www.example.org"));       // Matches prefix pattern
assert!(rule.is_matched("exact.domain.net"));      // Exact match

// Get detailed matching information
let suffix_matches = rule.find_suffix_match_all("mail.google.com");
let prefix_matches = rule.find_prefix_match_all("www.example.co.uk");

// Find longest matches for better specificity
let longest_suffix = rule.find_suffix_match_longest("subdomain.google.com");
let longest_prefix = rule.find_prefix_match_longest("www.example.multiple.tlds");
```

### Important Notes

For all matching methods:

- The argument `domain_name` should be in lowercase
- The argument `domain_name` should not contain a leading dot
- Suffix matching returns reversed strings (for internal implementation efficiency)
- Longest match functions return the most specific match when multiple patterns apply