146 lines
3.1 KiB
Go
146 lines
3.1 KiB
Go
package reverse
|
|
|
|
import (
|
|
"net"
|
|
"sort"
|
|
"strings"
|
|
"strconv"
|
|
"regexp"
|
|
|
|
"github.com/miekg/coredns/core/dnsserver"
|
|
"github.com/miekg/coredns/middleware"
|
|
|
|
"github.com/mholt/caddy"
|
|
)
|
|
|
|
func init() {
|
|
caddy.RegisterPlugin("reverse", caddy.Plugin{
|
|
ServerType: "dns",
|
|
Action: setupReverse,
|
|
})
|
|
}
|
|
|
|
func setupReverse(c *caddy.Controller) error {
|
|
networks, err := reverseParse(c)
|
|
if err != nil {
|
|
return middleware.Error("reverse", err)
|
|
}
|
|
|
|
dnsserver.GetConfig(c).AddMiddleware(func(next middleware.Handler) middleware.Handler {
|
|
return Reverse{Next: next, Networks:networks}
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
func reverseParse(c *caddy.Controller) (networks, error) {
|
|
var err error
|
|
|
|
// normalize zones, validation is almost done by dnsserver
|
|
zones := make([]string, len(c.ServerBlockKeys))
|
|
for i, str := range c.ServerBlockKeys {
|
|
host, _, _ := net.SplitHostPort(str)
|
|
zones[i] = strings.ToLower(host)
|
|
}
|
|
|
|
networks := networks{}
|
|
for c.Next() {
|
|
if c.Val() == "reverse" {
|
|
|
|
var cidrs []*net.IPNet
|
|
|
|
// parse all networks
|
|
for _, cidr := range c.RemainingArgs() {
|
|
if cidr == "{" {
|
|
break
|
|
}
|
|
_, ipnet, err := net.ParseCIDR(cidr)
|
|
if err != nil {
|
|
return nil, c.Errf("%v needs to be an CIDR formatted Network\n", cidr)
|
|
}
|
|
cidrs = append(cidrs, ipnet)
|
|
}
|
|
if len(cidrs) == 0 {
|
|
return nil, c.ArgErr()
|
|
}
|
|
|
|
// set defaults
|
|
var (
|
|
template = "ip-" + templateNameIP + ".{zone[0]}"
|
|
ttl = 60
|
|
fall = false
|
|
)
|
|
for c.NextBlock() {
|
|
switch c.Val() {
|
|
case "hostname":
|
|
if !c.NextArg() {
|
|
return nil, c.ArgErr()
|
|
}
|
|
template = c.Val()
|
|
|
|
case "ttl":
|
|
if !c.NextArg() {
|
|
return nil, c.ArgErr()
|
|
}
|
|
ttl, err = strconv.Atoi(c.Val())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
case "fallthrough":
|
|
fall = true
|
|
|
|
default:
|
|
return nil, c.ArgErr()
|
|
}
|
|
}
|
|
|
|
// prepare template
|
|
// replace {zone[index]} by the listen zone/domain of this config block
|
|
for i, zone := range zones {
|
|
template = strings.Replace(template, "{zone[" + string(i + 48) + "]}", zone, 1)
|
|
}
|
|
if !strings.HasSuffix(template, ".") {
|
|
template += "."
|
|
}
|
|
|
|
// extract zone from template
|
|
templateZone := strings.SplitAfterN(template, ".", 2)
|
|
if len(templateZone) != 2 || templateZone[1] == "" {
|
|
return nil, c.Errf("Cannot find domain in template '%v'", template)
|
|
}
|
|
|
|
// Create for each configured network in this stanza
|
|
for _, ipnet := range cidrs {
|
|
// precompile regex for hostname to ip matching
|
|
regexIP := regexMatchV4
|
|
if ipnet.IP.To4() == nil {
|
|
regexIP = regexMatchV6
|
|
}
|
|
regex, err := regexp.Compile(
|
|
"^" + strings.Replace( // inject ip regex into template
|
|
regexp.QuoteMeta(template), // escape dots
|
|
regexp.QuoteMeta(templateNameIP),
|
|
regexIP,
|
|
1, ) + "$")
|
|
if err != nil {
|
|
// invalid regex
|
|
return nil, err
|
|
}
|
|
|
|
networks = append(networks, network{
|
|
IPnet: ipnet,
|
|
Zone: templateZone[1],
|
|
Template: template,
|
|
RegexMatchIP: regex,
|
|
TTL: uint32(ttl),
|
|
Fallthrough: fall,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// sort by cidr
|
|
sort.Sort(networks)
|
|
return networks, nil
|
|
}
|