Merge pull request #2930 from lifenjoiner/rules

Rename PatternMatcher's field names and improve pattern rule examples

Author: jedisct1

dnscrypt-proxy/example-allowed-names.txt

@@ -7,13 +7,14 @@
 ##
 ## Example of valid patterns:
 ##
-## ads.*         | matches anything with an "ads." prefix
-## *.example.com | matches example.com and all names within that zone such as www.example.com
-## example.com   | identical to the above
-## =example.com  | allows example.com but not *.example.com
-## *sex*         | matches any name containing that substring
-## ads[0-9]*     | matches "ads" followed by one or more digits
-## ads*.example* | *, ? and [] can be used anywhere, but prefixes/suffixes are faster
+## ads.*                    | matches anything with an "ads." prefix
+## *.example.com            | matches example.com and all names within that zone such as www.example.com
+## example.com              | identical to the above
+## =example.com             | allows example.com but not *.example.com
+## [a-z0-9\-_]*.example.com | allows *.example.com but not example.com
+## *sex*                    | matches any name containing that substring
+## ads[0-9]*                | matches "ads" followed by one or more digits
+## ads*.example*            | *, ? and [] can be used anywhere, but prefixes/suffixes are faster
 
 
 # That one may be blocked due to 'tracker' being in the name.

dnscrypt-proxy/example-blocked-names.txt

@@ -7,13 +7,14 @@
 ##
 ## Example of valid patterns:
 ##
-## ads.*         | matches anything with an "ads." prefix
-## *.example.com | matches example.com and all names within that zone such as www.example.com
-## example.com   | identical to the above
-## =example.com  | block example.com but not *.example.com
-## *sex*         | matches any name containing that substring
-## ads[0-9]*     | matches "ads" followed by one or more digits
-## ads*.example* | *, ? and [] can be used anywhere, but prefixes/suffixes are faster
+## ads.*                    | matches anything with an "ads." prefix
+## *.example.com            | matches example.com and all names within that zone such as www.example.com
+## example.com              | identical to the above
+## =example.com             | blocks example.com but not *.example.com
+## [a-z0-9\-_]*.example.com | blocks *.example.com but not example.com
+## *sex*                    | matches any name containing that substring
+## ads[0-9]*                | matches "ads" followed by one or more digits
+## ads*.example*            | *, ? and [] can be used anywhere, but prefixes/suffixes are faster
 
 ad.*
 ads.*

dnscrypt-proxy/pattern_matcher.go

@@ -22,20 +22,20 @@ const (
 )
 
 type PatternMatcher struct {
-	blockedPrefixes   *critbitgo.Trie
-	blockedSuffixes   *critbitgo.Trie
-	blockedSubstrings []string
-	blockedPatterns   []string
-	blockedExact      map[string]interface{}
-	indirectVals      map[string]interface{}
+	prefixes     *critbitgo.Trie
+	suffixes     *critbitgo.Trie
+	substrings   []string
+	patterns     []string
+	exact        map[string]interface{}
+	indirectVals map[string]interface{}
 }
 
 func NewPatternMatcher() *PatternMatcher {
 	patternMatcher := PatternMatcher{
-		blockedPrefixes: critbitgo.NewTrie(),
-		blockedSuffixes: critbitgo.NewTrie(),
-		blockedExact:    make(map[string]interface{}),
-		indirectVals:    make(map[string]interface{}),
+		prefixes:     critbitgo.NewTrie(),
+		suffixes:     critbitgo.NewTrie(),
+		exact:        make(map[string]interface{}),
+		indirectVals: make(map[string]interface{}),
 	}
 	return &patternMatcher
 }
@@ -63,27 +63,27 @@ func (patternMatcher *PatternMatcher) Add(pattern string, val interface{}, posit
 		patternType = PatternTypePattern
 		_, err := filepath.Match(pattern, "example.com") // Validate pattern syntax
 		if len(pattern) < 2 || err != nil {
-			return fmt.Errorf("Syntax error in block rules at pattern %d", position)
+			return fmt.Errorf("Syntax error in the rule file at line %d", position)
 		}
 	} else if leadingStar && trailingStar {
 		// Substring match (*contains*)
 		patternType = PatternTypeSubstring
 		if len(pattern) < 3 {
-			return fmt.Errorf("Syntax error in block rules at pattern %d", position)
+			return fmt.Errorf("Syntax error in the rule file at line %d", position)
 		}
 		pattern = pattern[1 : len(pattern)-1] // Remove stars
 	} else if trailingStar {
 		// Prefix match (starts*)
 		patternType = PatternTypePrefix
 		if len(pattern) < 2 {
-			return fmt.Errorf("Syntax error in block rules at pattern %d", position)
+			return fmt.Errorf("Syntax error in the rule file at line %d", position)
 		}
 		pattern = pattern[:len(pattern)-1] // Remove trailing star
 	} else if exact {
 		// Exact match (=example.com)
 		patternType = PatternTypeExact
 		if len(pattern) < 2 {
-			return fmt.Errorf("Syntax error in block rules at pattern %d", position)
+			return fmt.Errorf("Syntax error in the rule file at line %d", position)
 		}
 		pattern = pattern[1:] // Remove = prefix
 	} else {
@@ -95,29 +95,29 @@ func (patternMatcher *PatternMatcher) Add(pattern string, val interface{}, posit
 		pattern = strings.TrimPrefix(pattern, ".") // Remove leading dot if present
 	}
 	if len(pattern) == 0 {
-		dlog.Errorf("Syntax error in block rule at line %d", position)
+		dlog.Errorf("Syntax error in the rule file at line %d", position)
 	}
 
 	pattern = strings.ToLower(pattern)
 	switch patternType {
 	case PatternTypeSubstring:
-		patternMatcher.blockedSubstrings = append(patternMatcher.blockedSubstrings, pattern)
+		patternMatcher.substrings = append(patternMatcher.substrings, pattern)
 		if val != nil {
 			patternMatcher.indirectVals[pattern] = val
 		}
 	case PatternTypePattern:
-		patternMatcher.blockedPatterns = append(patternMatcher.blockedPatterns, pattern)
+		patternMatcher.patterns = append(patternMatcher.patterns, pattern)
 		if val != nil {
 			patternMatcher.indirectVals[pattern] = val
 		}
 	case PatternTypePrefix:
-		patternMatcher.blockedPrefixes.Insert([]byte(pattern), val)
+		patternMatcher.prefixes.Insert([]byte(pattern), val)
 	case PatternTypeSuffix:
-		patternMatcher.blockedSuffixes.Insert([]byte(StringReverse(pattern)), val)
+		patternMatcher.suffixes.Insert([]byte(StringReverse(pattern)), val)
 	case PatternTypeExact:
-		patternMatcher.blockedExact[pattern] = val
+		patternMatcher.exact[pattern] = val
 	default:
-		dlog.Fatal("Unexpected block type")
+		dlog.Fatal("Unexpected rule pattern type")
 	}
 	return nil
 }
@@ -127,19 +127,19 @@ func (patternMatcher *PatternMatcher) Eval(qName string) (reject bool, reason st
 		return false, "", nil
 	}
 
-	if xval := patternMatcher.blockedExact[qName]; xval != nil {
+	if xval := patternMatcher.exact[qName]; xval != nil {
 		return true, qName, xval
 	}
 
 	revQname := StringReverse(qName)
-	if match, xval, found := patternMatcher.blockedSuffixes.LongestPrefix([]byte(revQname)); found {
+	if match, xval, found := patternMatcher.suffixes.LongestPrefix([]byte(revQname)); found {
 		if len(match) == len(revQname) || revQname[len(match)] == '.' {
 			return true, "*." + StringReverse(string(match)), xval
 		}
 		if len(match) < len(revQname) && len(revQname) > 0 {
 			if i := strings.LastIndex(revQname, "."); i > 0 {
 				pName := revQname[:i]
-				if match, _, found := patternMatcher.blockedSuffixes.LongestPrefix([]byte(pName)); found {
+				if match, _, found := patternMatcher.suffixes.LongestPrefix([]byte(pName)); found {
 					if len(match) == len(pName) || pName[len(match)] == '.' {
 						return true, "*." + StringReverse(string(match)), xval
 					}
@@ -148,17 +148,17 @@ func (patternMatcher *PatternMatcher) Eval(qName string) (reject bool, reason st
 		}
 	}
 
-	if match, xval, found := patternMatcher.blockedPrefixes.LongestPrefix([]byte(qName)); found {
+	if match, xval, found := patternMatcher.prefixes.LongestPrefix([]byte(qName)); found {
 		return true, string(match) + "*", xval
 	}
 
-	for _, substring := range patternMatcher.blockedSubstrings {
+	for _, substring := range patternMatcher.substrings {
 		if strings.Contains(qName, substring) {
 			return true, "*" + substring + "*", patternMatcher.indirectVals[substring]
 		}
 	}
 
-	for _, pattern := range patternMatcher.blockedPatterns {
+	for _, pattern := range patternMatcher.patterns {
 		if found, _ := filepath.Match(pattern, qName); found {
 			return true, pattern, patternMatcher.indirectVals[pattern]
 		}