Add minimal perfect hash domain matcher

[darsvador]

As you can see, the mph domain matcher is 30% faster than the original domain matcher, which is comparable to the pure ac automata.

related issue: XTLS/Xray-core#192

• convert domain names to lowercase when matching domain (app/router/condition.go)
• rename domain matcher config hybrid to mph
• add a minimal perfect hash domain matcher
• remove the hybrid domain matcher

Note: The place where app/dns/dns.go involves domain name matching has not been modified.

[dyhkwong]

need strings.ToLower() here as well

v2ray-core/app/dns/dns.go

Line 145 in 867bbb4

func (s *DNS) LookupIP(domain string, option dns.IPOption) ([]net.IP, error) {

[kslr]

Are you ready?

[darsvador]

I will provide a new domain matcher implementation in this pr, which can achieve the same speed as pure AC automata but save more memory than hybrid matcher. Stay tuned.

[darsvador]

Implementation detail

The MphDomainMatcher is divided into three parts:

1. full and domain patterns are matched by Rabin-Karp algorithm and minimal perfect hash table;
2. substr patterns are matched by ac automaton;
3. regex patterns are matched with the regex library.

Matching problem definition:

• a domain rule baidu.com can be seen as exact match moc.udiab and moc.udiab. when traversing the domain names in reverse order. And moc.udiab and moc.udiab. should not appear in the middle of the string.
• a full rule baidu.com can be seen as exact match moc.udiab when traversing the domain names in reverse order. And moc.udiab should not appear in the middle of the string.
• a substr rule baidu.com is a matching problem that checks if baidu.com is a substring of the given domain names. substr rules can be matched by ACAutomaton.

Through the above definition, we can merge the full and domain rules together to match. The simplest way is to store these rules in the HashMap. However, when we query, we need to calculate the hash value of the same string and its substrings. This additional overhead can be reduced by rolling hash.
We choose 32bit FNV-prime 16777619 to calculate our rolling hash.

Inspired by "Hash, displace, and compress" algorithm, we can design a minimal perfect hash table through two rounds hashes. The first round of hash is rolling hash, which we get directly from the process of traversing the string. The second round of hash is memhash in the golang source code.

In this way, when checking whether the rule is hit, we only need to calculate the hash and compare it once.

func (g *MphMatcherGroup) Lookup(rollingHashValue uint32, s string) bool {
	i0 := int(rollingHashValue) & g.level0Mask
	seed := g.level0[i0]
	i1 := int(memhash(s,seed)) & g.level1Mask
	n := g.level1[i1]
	return s == g.rules[int(n)]
}

[kslr]

Thanks for your work. This is great!