mirror of
https://github.com/coredns/coredns.git
synced 2025-10-27 16:24:19 -04:00
5f41d8eb1f
Make normalize return multiple "hosts" (= reverse zones) when a non-octet boundary cidr is given. Added pkg/cidr package that holds the cidr calculation routines; felt they didn't really fit dnsutil. This change means the IPNet return parameter isn't needed, the hosts are all correct. The tests that tests this is also removed: TestSplitHostPortReverse The fallout was that zoneAddr _also_ doesn't need the IPNet member, that in turn make it visible that zoneAddr in address.go duplicated a bunch of stuff from register.go; removed/refactored that too. Created a plugin.OriginsFromArgsOrServerBlock to help plugins do the right things, by consuming ZONE arguments; this now expands reverse zones correctly. This is mostly mechanical. Remove the reverse test in plugin/kubernetes which is a copy-paste from a core test (which has since been fixed). Remove MustNormalize as it has no plugin users. This change is not backwards compatible to plugins that have a ZONE argument that they parse in the setup util. All in-tree plugins have been updated. Signed-off-by: Miek Gieben <miek@miek.nl>
75 lines
1.9 KiB
Go
75 lines
1.9 KiB
Go
// Package cidr contains functions that deal with classless reverse zones in the DNS.
|
|
package cidr
|
|
|
|
import (
|
|
"math"
|
|
"net"
|
|
|
|
"github.com/apparentlymart/go-cidr/cidr"
|
|
"github.com/miekg/dns"
|
|
)
|
|
|
|
// Class return slice of "classful" (/8, /16, /24 or /32 only) CIDR's from the CIDR in net.
|
|
func Class(n *net.IPNet) []string {
|
|
ones, _ := n.Mask.Size()
|
|
if ones%8 == 0 {
|
|
return []string{n.String()}
|
|
}
|
|
|
|
mask := int(math.Ceil(float64(ones)/8)) * 8
|
|
networks := nets(n, mask)
|
|
cidrs := make([]string, len(networks))
|
|
for i := range networks {
|
|
cidrs[i] = networks[i].String()
|
|
}
|
|
return cidrs
|
|
}
|
|
|
|
// nets return a slice of prefixes with the desired mask subnetted from original network.
|
|
func nets(network *net.IPNet, newPrefixLen int) []*net.IPNet {
|
|
prefixLen, _ := network.Mask.Size()
|
|
maxSubnets := int(math.Exp2(float64(newPrefixLen)) / math.Exp2(float64(prefixLen)))
|
|
nets := []*net.IPNet{{network.IP, net.CIDRMask(newPrefixLen, 8*len(network.IP))}}
|
|
|
|
for i := 1; i < maxSubnets; i++ {
|
|
next, exceeds := cidr.NextSubnet(nets[len(nets)-1], newPrefixLen)
|
|
nets = append(nets, next)
|
|
if exceeds {
|
|
break
|
|
}
|
|
}
|
|
|
|
return nets
|
|
}
|
|
|
|
// Reverse return the reverse zones that are authoritative for each net in ns.
|
|
func Reverse(nets []string) []string {
|
|
rev := make([]string, len(nets))
|
|
for i := range nets {
|
|
ip, n, _ := net.ParseCIDR(nets[i])
|
|
r, err1 := dns.ReverseAddr(ip.String())
|
|
if err1 != nil {
|
|
continue
|
|
}
|
|
ones, bits := n.Mask.Size()
|
|
// get the size, in bits, of each portion of hostname defined in the reverse address. (8 for IPv4, 4 for IPv6)
|
|
sizeDigit := 8
|
|
if len(n.IP) == net.IPv6len {
|
|
sizeDigit = 4
|
|
}
|
|
// Get the first lower octet boundary to see what encompassing zone we should be authoritative for.
|
|
mod := (bits - ones) % sizeDigit
|
|
nearest := (bits - ones) + mod
|
|
offset := 0
|
|
var end bool
|
|
for i := 0; i < nearest/sizeDigit; i++ {
|
|
offset, end = dns.NextLabel(r, offset)
|
|
if end {
|
|
break
|
|
}
|
|
}
|
|
rev[i] = r[offset:]
|
|
}
|
|
return rev
|
|
}
|