plugin/metadata: add metadata plugin (#1894)

* plugin/metadata: add metadata plugin

* plugin/metadata: Add MD struct, refactor code, fix doc

* plugin/metadata: simplify metadata key

* plugin/metadata: improve setup_test

* Support of metadata by rewrite plugin. Move calculated variables to metadata.

* Move variables from metadata to pkg, add UTs, READMEs change, metadata small fixes

* Add client port validation to variables_test

* plugin/metadata: improve README

* plugin/metadata: rename methods

* plugin/metadata: Update Metadataer interface, update doc, cosmetic code changes

* plugin/metadata: move colllisions check to OnStartup(). Fix default variables metadataer.

* plugin/metadata: Fix comment for method setValue

* plugin/metadata: change variables order to fix linter warning

* plugin/metadata: rename Metadataer to Provider

plugin/rewrite/README.md

@@ -206,13 +206,17 @@ rewrites the first local option with code 0xffee, setting the data to "abcd". Eq
 }
 ~~~
 
-* A variable data is specified with a pair of curly brackets `{}`. Following are the supported variables:
+* A variable data is specified with a pair of curly brackets `{}`. Following are the supported variables by default:
   {qname}, {qtype}, {client_ip}, {client_port}, {protocol}, {server_ip}, {server_port}.
+Any plugin that can provide it's own additional variables by implementing metadata.Provider interface. If you are going to use metadata variables then metadata plugin must be enabled.
 
 Example:
 
-~~~
-rewrite edns0 local set 0xffee {client_ip}
+~~~ corefile
+. {
+    metadata
+    rewrite edns0 local set 0xffee {client_ip}
+}
 ~~~
 
 ### EDNS0_NSID

plugin/rewrite/class.go

@@ -1,6 +1,7 @@
 package rewrite
 
 import (
+	"context"
 	"fmt"
 	"strings"
 
@@ -27,7 +28,7 @@ func newClassRule(nextAction string, args ...string) (Rule, error) {
 }
 
 // Rewrite rewrites the the current request.
-func (rule *classRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
+func (rule *classRule) Rewrite(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) Result {
 	if rule.fromClass > 0 && rule.toClass > 0 {
 		if r.Question[0].Qclass == rule.fromClass {
 			r.Question[0].Qclass = rule.toClass

plugin/rewrite/edns0.go

@@ -2,13 +2,15 @@
 package rewrite
 
 import (
-	"encoding/binary"
+	"context"
 	"encoding/hex"
 	"fmt"
 	"net"
 	"strconv"
 	"strings"
 
+	"github.com/coredns/coredns/plugin/metadata"
+	"github.com/coredns/coredns/plugin/pkg/variables"
 	"github.com/coredns/coredns/request"
 	"github.com/miekg/dns"
 )
@@ -46,7 +48,7 @@ func setupEdns0Opt(r *dns.Msg) *dns.OPT {
 }
 
 // Rewrite will alter the request EDNS0 NSID option
-func (rule *edns0NsidRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
+func (rule *edns0NsidRule) Rewrite(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) Result {
 	result := RewriteIgnored
 	o := setupEdns0Opt(r)
 	found := false
@@ -83,7 +85,7 @@ func (rule *edns0NsidRule) GetResponseRule() ResponseRule {
 }
 
 // Rewrite will alter the request EDNS0 local options
-func (rule *edns0LocalRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
+func (rule *edns0LocalRule) Rewrite(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) Result {
 	result := RewriteIgnored
 	o := setupEdns0Opt(r)
 	found := false
@@ -146,7 +148,9 @@ func newEdns0Rule(mode string, args ...string) (Rule, error) {
 		}
 		//Check for variable option
 		if strings.HasPrefix(args[3], "{") && strings.HasSuffix(args[3], "}") {
-			return newEdns0VariableRule(mode, action, args[2], args[3])
+			// Remove first and last runes
+			variable := args[3][1 : len(args[3])-1]
+			return newEdns0VariableRule(mode, action, args[2], variable)
 		}
 		return newEdns0LocalRule(mode, action, args[2], args[3])
 	case "nsid":
@@ -186,102 +190,28 @@ func newEdns0VariableRule(mode, action, code, variable string) (*edns0VariableRu
 	if err != nil {
 		return nil, err
 	}
-	//Validate
-	if !isValidVariable(variable) {
-		return nil, fmt.Errorf("unsupported variable name %q", variable)
-	}
 	return &edns0VariableRule{mode: mode, action: action, code: uint16(c), variable: variable}, nil
 }
 
-// ipToWire writes IP address to wire/binary format, 4 or 16 bytes depends on IPV4 or IPV6.
-func (rule *edns0VariableRule) ipToWire(family int, ipAddr string) ([]byte, error) {
-
-	switch family {
-	case 1:
-		return net.ParseIP(ipAddr).To4(), nil
-	case 2:
-		return net.ParseIP(ipAddr).To16(), nil
-	}
-	return nil, fmt.Errorf("invalid IP address family (i.e. version) %d", family)
-}
-
-// uint16ToWire writes unit16 to wire/binary format
-func (rule *edns0VariableRule) uint16ToWire(data uint16) []byte {
-	buf := make([]byte, 2)
-	binary.BigEndian.PutUint16(buf, uint16(data))
-	return buf
-}
-
-// portToWire writes port to wire/binary format, 2 bytes
-func (rule *edns0VariableRule) portToWire(portStr string) ([]byte, error) {
-
-	port, err := strconv.ParseUint(portStr, 10, 16)
-	if err != nil {
-		return nil, err
-	}
-	return rule.uint16ToWire(uint16(port)), nil
-}
-
-// Family returns the family of the transport, 1 for IPv4 and 2 for IPv6.
-func (rule *edns0VariableRule) family(ip net.Addr) int {
-	var a net.IP
-	if i, ok := ip.(*net.UDPAddr); ok {
-		a = i.IP
-	}
-	if i, ok := ip.(*net.TCPAddr); ok {
-		a = i.IP
-	}
-	if a.To4() != nil {
-		return 1
-	}
-	return 2
-}
-
 // ruleData returns the data specified by the variable
-func (rule *edns0VariableRule) ruleData(w dns.ResponseWriter, r *dns.Msg) ([]byte, error) {
-
-	req := request.Request{W: w, Req: r}
-	switch rule.variable {
-	case queryName:
-		//Query name is written as ascii string
-		return []byte(req.QName()), nil
-
-	case queryType:
-		return rule.uint16ToWire(req.QType()), nil
-
-	case clientIP:
-		return rule.ipToWire(req.Family(), req.IP())
-
-	case clientPort:
-		return rule.portToWire(req.Port())
-
-	case protocol:
-		// Proto is written as ascii string
-		return []byte(req.Proto()), nil
-
-	case serverIP:
-		ip, _, err := net.SplitHostPort(w.LocalAddr().String())
-		if err != nil {
-			ip = w.RemoteAddr().String()
+func (rule *edns0VariableRule) ruleData(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) ([]byte, error) {
+	if md, ok := metadata.FromContext(ctx); ok {
+		if value, ok := md.Value(rule.variable); ok {
+			if v, ok := value.([]byte); ok {
+				return v, nil
+			}
 		}
-		return rule.ipToWire(rule.family(w.RemoteAddr()), ip)
-
-	case serverPort:
-		_, port, err := net.SplitHostPort(w.LocalAddr().String())
-		if err != nil {
-			port = "0"
-		}
-		return rule.portToWire(port)
+	} else { // No metadata available means metadata plugin is disabled. Try to get the value directly.
+		return variables.GetValue(rule.variable, w, r)
 	}
-
 	return nil, fmt.Errorf("unable to extract data for variable %s", rule.variable)
 }
 
 // Rewrite will alter the request EDNS0 local options with specified variables
-func (rule *edns0VariableRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
+func (rule *edns0VariableRule) Rewrite(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) Result {
 	result := RewriteIgnored
 
-	data, err := rule.ruleData(w, r)
+	data, err := rule.ruleData(ctx, w, r)
 	if err != nil || data == nil {
 		return result
 	}
@@ -324,21 +254,6 @@ func (rule *edns0VariableRule) GetResponseRule() ResponseRule {
 	return ResponseRule{}
 }
 
-func isValidVariable(variable string) bool {
-	switch variable {
-	case
-		queryName,
-		queryType,
-		clientIP,
-		clientPort,
-		protocol,
-		serverIP,
-		serverPort:
-		return true
-	}
-	return false
-}
-
 // ends0SubnetRule is a rewrite rule for EDNS0 subnet options
 type edns0SubnetRule struct {
 	mode         string
@@ -400,7 +315,7 @@ func (rule *edns0SubnetRule) fillEcsData(w dns.ResponseWriter, r *dns.Msg,
 }
 
 // Rewrite will alter the request EDNS0 subnet option
-func (rule *edns0SubnetRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
+func (rule *edns0SubnetRule) Rewrite(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) Result {
 	result := RewriteIgnored
 	o := setupEdns0Opt(r)
 	found := false
@@ -446,17 +361,6 @@ const (
 	Append  = "append"
 )
 
-// Supported local EDNS0 variables
-const (
-	queryName  = "{qname}"
-	queryType  = "{qtype}"
-	clientIP   = "{client_ip}"
-	clientPort = "{client_port}"
-	protocol   = "{protocol}"
-	serverIP   = "{server_ip}"
-	serverPort = "{server_port}"
-)
-
 // Subnet maximum bit mask length
 const (
 	maxV4BitMaskLen = 32

plugin/rewrite/name.go

@@ -1,6 +1,7 @@
 package rewrite
 
 import (
+	"context"
 	"fmt"
 	"regexp"
 	"strconv"
@@ -56,7 +57,7 @@ const (
 
 // Rewrite rewrites the current request based upon exact match of the name
 // in the question section of the request
-func (rule *nameRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
+func (rule *nameRule) Rewrite(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) Result {
 	if rule.From == r.Question[0].Name {
 		r.Question[0].Name = rule.To
 		return RewriteDone
@@ -65,7 +66,7 @@ func (rule *nameRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
 }
 
 // Rewrite rewrites the current request when the name begins with the matching string
-func (rule *prefixNameRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
+func (rule *prefixNameRule) Rewrite(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) Result {
 	if strings.HasPrefix(r.Question[0].Name, rule.Prefix) {
 		r.Question[0].Name = rule.Replacement + strings.TrimLeft(r.Question[0].Name, rule.Prefix)
 		return RewriteDone
@@ -74,7 +75,7 @@ func (rule *prefixNameRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
 }
 
 // Rewrite rewrites the current request when the name ends with the matching string
-func (rule *suffixNameRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
+func (rule *suffixNameRule) Rewrite(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) Result {
 	if strings.HasSuffix(r.Question[0].Name, rule.Suffix) {
 		r.Question[0].Name = strings.TrimRight(r.Question[0].Name, rule.Suffix) + rule.Replacement
 		return RewriteDone
@@ -84,7 +85,7 @@ func (rule *suffixNameRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
 
 // Rewrite rewrites the current request based upon partial match of the
 // name in the question section of the request
-func (rule *substringNameRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
+func (rule *substringNameRule) Rewrite(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) Result {
 	if strings.Contains(r.Question[0].Name, rule.Substring) {
 		r.Question[0].Name = strings.Replace(r.Question[0].Name, rule.Substring, rule.Replacement, -1)
 		return RewriteDone
@@ -94,7 +95,7 @@ func (rule *substringNameRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result
 
 // Rewrite rewrites the current request when the name in the question
 // section of the request matches a regular expression
-func (rule *regexNameRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
+func (rule *regexNameRule) Rewrite(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) Result {
 	regexGroups := rule.Pattern.FindStringSubmatch(r.Question[0].Name)
 	if len(regexGroups) == 0 {
 		return RewriteIgnored

plugin/rewrite/rewrite.go

@@ -42,7 +42,7 @@ type Rewrite struct {
 func (rw Rewrite) ServeDNS(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) (int, error) {
 	wr := NewResponseReverter(w, r)
 	for _, rule := range rw.Rules {
-		switch result := rule.Rewrite(w, r); result {
+		switch result := rule.Rewrite(ctx, w, r); result {
 		case RewriteDone:
 			respRule := rule.GetResponseRule()
 			if respRule.Active == true {
@@ -76,7 +76,7 @@ func (rw Rewrite) Name() string { return "rewrite" }
 // Rule describes a rewrite rule.
 type Rule interface {
 	// Rewrite rewrites the current request.
-	Rewrite(dns.ResponseWriter, *dns.Msg) Result
+	Rewrite(context.Context, dns.ResponseWriter, *dns.Msg) Result
 	// Mode returns the processing mode stop or continue.
 	Mode() string
 	// GetResponseRule returns the rule to rewrite response with, if any.

plugin/rewrite/rewrite_test.go

@@ -71,7 +71,7 @@ func TestNewRule(t *testing.T) {
 		{[]string{"edns0", "nsid", "append"}, false, reflect.TypeOf(&edns0NsidRule{})},
 		{[]string{"edns0", "nsid", "replace"}, false, reflect.TypeOf(&edns0NsidRule{})},
 		{[]string{"edns0", "nsid", "foo"}, true, nil},
-		{[]string{"edns0", "local", "set", "0xffee", "{dummy}"}, true, nil},
+		{[]string{"edns0", "local", "set", "0xffee", "{dummy}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "set", "0xffee", "{qname}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "set", "0xffee", "{qtype}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "set", "0xffee", "{client_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})},
@@ -79,7 +79,7 @@ func TestNewRule(t *testing.T) {
 		{[]string{"edns0", "local", "set", "0xffee", "{protocol}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "set", "0xffee", "{server_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "set", "0xffee", "{server_port}"}, false, reflect.TypeOf(&edns0VariableRule{})},
-		{[]string{"edns0", "local", "append", "0xffee", "{dummy}"}, true, nil},
+		{[]string{"edns0", "local", "append", "0xffee", "{dummy}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "append", "0xffee", "{qname}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "append", "0xffee", "{qtype}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "append", "0xffee", "{client_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})},
@@ -87,7 +87,7 @@ func TestNewRule(t *testing.T) {
 		{[]string{"edns0", "local", "append", "0xffee", "{protocol}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "append", "0xffee", "{server_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "append", "0xffee", "{server_port}"}, false, reflect.TypeOf(&edns0VariableRule{})},
-		{[]string{"edns0", "local", "replace", "0xffee", "{dummy}"}, true, nil},
+		{[]string{"edns0", "local", "replace", "0xffee", "{dummy}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "replace", "0xffee", "{qname}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "replace", "0xffee", "{qtype}"}, false, reflect.TypeOf(&edns0VariableRule{})},
 		{[]string{"edns0", "local", "replace", "0xffee", "{client_ip}"}, false, reflect.TypeOf(&edns0VariableRule{})},

plugin/rewrite/type.go

@@ -2,6 +2,7 @@
 package rewrite
 
 import (
+	"context"
 	"fmt"
 	"strings"
 
@@ -28,7 +29,7 @@ func newTypeRule(nextAction string, args ...string) (Rule, error) {
 }
 
 // Rewrite rewrites the the current request.
-func (rule *typeRule) Rewrite(w dns.ResponseWriter, r *dns.Msg) Result {
+func (rule *typeRule) Rewrite(ctx context.Context, w dns.ResponseWriter, r *dns.Msg) Result {
 	if rule.fromType > 0 && rule.toType > 0 {
 		if r.Question[0].Qtype == rule.fromType {
 			r.Question[0].Qtype = rule.toType