129 lines
2.7 KiB
Go
129 lines
2.7 KiB
Go
package cidr
|
|
|
|
import (
|
|
"fmt"
|
|
"net"
|
|
|
|
"git.loafle.net/overflow/util-go/net/converter"
|
|
)
|
|
|
|
type cidrRangeIPv4 struct {
|
|
cidrNet *net.IPNet
|
|
}
|
|
|
|
func (cr *cidrRangeIPv4) Contains(ip net.IP) bool {
|
|
return cr.cidrNet.Contains(ip)
|
|
}
|
|
|
|
func (cr *cidrRangeIPv4) First() net.IP {
|
|
nIP := cr.Network()
|
|
return cr.Next(nIP)
|
|
}
|
|
|
|
func (cr *cidrRangeIPv4) Last() net.IP {
|
|
bIP := cr.Broadcast()
|
|
return cr.Previous(bIP)
|
|
}
|
|
|
|
func (cr *cidrRangeIPv4) Range() []net.IP {
|
|
fIP := cr.First()
|
|
if nil == fIP {
|
|
return nil
|
|
}
|
|
lIP := cr.Last()
|
|
if nil == lIP {
|
|
return nil
|
|
}
|
|
fNum := converter.IPv4ToInt(fIP.To4())
|
|
lNum := converter.IPv4ToInt(lIP.To4())
|
|
|
|
r := make([]net.IP, 0)
|
|
for i := fNum; i <= lNum; i++ {
|
|
r = append(r, converter.IntToIPv4(i))
|
|
}
|
|
return r
|
|
}
|
|
|
|
// (!Contains(startIP) || !Contains(endIP)) return nil
|
|
// (startIP > endIP) return nil
|
|
// (nil != startIP && nil != endIP) return (startIP ~ endIP) + include - exclude
|
|
// (nil == startIP || nil == endIP) return include - exclude
|
|
func (cr *cidrRangeIPv4) Ranges(startIP net.IP, endIP net.IP, include []net.IP, exclude []net.IP) ([]net.IP, error) {
|
|
|
|
res := make(map[int32]bool)
|
|
|
|
if nil != startIP && nil != endIP {
|
|
if !cr.Contains(startIP) {
|
|
return nil, fmt.Errorf("CIDR Range: CIDR not contains start ip[%v]", startIP)
|
|
}
|
|
if !cr.Contains(endIP) {
|
|
return nil, fmt.Errorf("CIDR Range: CIDR not contains end ip[%v]", endIP)
|
|
}
|
|
sNum := converter.IPv4ToInt(startIP.To4())
|
|
eNum := converter.IPv4ToInt(endIP.To4())
|
|
if sNum > eNum {
|
|
return nil, fmt.Errorf("CIDR Range: Start IP[%v] must smaller then End IP[%v]", startIP, endIP)
|
|
}
|
|
for i := sNum; i <= eNum; i++ {
|
|
res[i] = true
|
|
}
|
|
}
|
|
|
|
if nil != include {
|
|
for _, in := range include {
|
|
iNum := converter.IPv4ToInt(in.To4())
|
|
if _, ok := res[iNum]; !ok {
|
|
res[iNum] = true
|
|
}
|
|
}
|
|
}
|
|
|
|
if nil != exclude {
|
|
for _, ex := range exclude {
|
|
iNum := converter.IPv4ToInt(ex.To4())
|
|
if _, ok := res[iNum]; ok {
|
|
delete(res, iNum)
|
|
}
|
|
}
|
|
}
|
|
|
|
r := make([]net.IP, 0)
|
|
for k, _ := range res {
|
|
r = append(r, converter.IntToIPv4(k))
|
|
}
|
|
|
|
return r, nil
|
|
}
|
|
|
|
func (cr *cidrRangeIPv4) Broadcast() net.IP {
|
|
ip := cr.cidrNet.IP.To4()
|
|
bIP := net.IPv4(0, 0, 0, 0).To4()
|
|
for i := 0; i < len(bIP); i++ {
|
|
bIP[i] = ip[i] | ^cr.cidrNet.Mask[i]
|
|
}
|
|
return bIP
|
|
}
|
|
|
|
func (cr *cidrRangeIPv4) Network() net.IP {
|
|
ip := cr.cidrNet.IP.To4()
|
|
return ip.Mask(cr.cidrNet.Mask)
|
|
}
|
|
|
|
func (cr *cidrRangeIPv4) Next(ip net.IP) net.IP {
|
|
nNum := converter.IPv4ToInt(ip.To4()) + 1
|
|
nIP := converter.IntToIPv4(nNum)
|
|
if cr.Contains(nIP) {
|
|
return nIP
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (cr *cidrRangeIPv4) Previous(ip net.IP) net.IP {
|
|
nNum := converter.IPv4ToInt(ip.To4()) - 1
|
|
nIP := converter.IntToIPv4(nNum)
|
|
if cr.Contains(nIP) {
|
|
return nIP
|
|
}
|
|
return nil
|
|
}
|