3e196a6d57
* middleware/reverse: random updates Make the documentation somewhat shorter (and hopefully clearer in the process). Also to be on-par with the *auto* middleware, start counting the referenced zones from 1 (instead of 0). Some variable cleanups and use the NextOrFailure in the ServeDNS function. * More TODOs
110 lines
2.7 KiB
Go
110 lines
2.7 KiB
Go
package reverse
|
|
|
|
import (
|
|
"bytes"
|
|
"net"
|
|
"regexp"
|
|
"strings"
|
|
)
|
|
|
|
type network struct {
|
|
IPnet *net.IPNet
|
|
Zone string // forward lookup zone
|
|
Template string
|
|
TTL uint32
|
|
RegexMatchIP *regexp.Regexp
|
|
Fallthrough bool
|
|
}
|
|
|
|
// TODO: we might want to get rid of these regexes.
|
|
const hexDigit = "0123456789abcdef"
|
|
const templateNameIP = "{ip}"
|
|
const regexMatchV4 = "((?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\-){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))"
|
|
const regexMatchV6 = "([0-9a-fA-F]{32})"
|
|
|
|
// hostnameToIP converts the hostname back to an ip, based on the template
|
|
// returns nil if there is no IP found.
|
|
func (network *network) hostnameToIP(rname string) net.IP {
|
|
var matchedIP net.IP
|
|
|
|
match := network.RegexMatchIP.FindStringSubmatch(rname)
|
|
if len(match) != 2 {
|
|
return nil
|
|
}
|
|
|
|
if network.IPnet.IP.To4() != nil {
|
|
matchedIP = net.ParseIP(strings.Replace(match[1], "-", ".", 4))
|
|
} else {
|
|
// TODO: can probably just allocate a []byte and use that.
|
|
var buf bytes.Buffer
|
|
// convert back to an valid ipv6 string with colons
|
|
for i := 0; i < 8*4; i += 4 {
|
|
buf.WriteString(match[1][i : i+4])
|
|
if i < 28 {
|
|
buf.WriteString(":")
|
|
}
|
|
}
|
|
matchedIP = net.ParseIP(buf.String())
|
|
}
|
|
|
|
// No valid ip or it does not belong to this network
|
|
if matchedIP == nil || !network.IPnet.Contains(matchedIP) {
|
|
return nil
|
|
}
|
|
|
|
return matchedIP
|
|
}
|
|
|
|
// ipToHostname converts an IP to an DNS compatible hostname and injects it into the template.domain.
|
|
func (network *network) ipToHostname(ip net.IP) (name string) {
|
|
if ipv4 := ip.To4(); ipv4 != nil {
|
|
// replace . to -
|
|
name = uitoa(ipv4[0]) + "-" +
|
|
uitoa(ipv4[1]) + "-" +
|
|
uitoa(ipv4[2]) + "-" +
|
|
uitoa(ipv4[3])
|
|
} else {
|
|
// assume v6
|
|
// ensure zeros are present in string
|
|
buf := make([]byte, 0, len(ip)*4)
|
|
for i := 0; i < len(ip); i++ {
|
|
v := ip[i]
|
|
buf = append(buf, hexDigit[v>>4])
|
|
buf = append(buf, hexDigit[v&0xF])
|
|
}
|
|
name = string(buf)
|
|
}
|
|
// inject the converted ip into the fqdn template
|
|
return strings.Replace(network.Template, templateNameIP, name, 1)
|
|
}
|
|
|
|
// just the same from net.ip package, but with uint8
|
|
func uitoa(val uint8) string {
|
|
if val == 0 {
|
|
// avoid string allocation
|
|
return "0"
|
|
}
|
|
var buf [20]byte // big enough for 64bit value base 10
|
|
i := len(buf) - 1
|
|
for val >= 10 {
|
|
q := val / 10
|
|
buf[i] = byte('0' + val - q*10)
|
|
i--
|
|
val = q
|
|
}
|
|
// val < 10
|
|
buf[i] = byte('0' + val)
|
|
return string(buf[i:])
|
|
}
|
|
|
|
type networks []network
|
|
|
|
func (n networks) Len() int { return len(n) }
|
|
func (n networks) Swap(i, j int) { n[i], n[j] = n[j], n[i] }
|
|
|
|
// cidr closer to the ip wins (by netmask)
|
|
func (n networks) Less(i, j int) bool {
|
|
isize, _ := n[i].IPnet.Mask.Size()
|
|
jsize, _ := n[j].IPnet.Mask.Size()
|
|
return isize > jsize
|
|
}
|