Removed `net.StdParse*` methods. Add support for `net/netip.Prefix` type parsing. Convert return types to use `inet.af/netaddr` types.

2 files changed, 70 insertions, 60 deletions

diff --git a/funcs/net.go b/funcs/net.go
index e61be41a..7af81180 100644
--- a/funcs/net.go
+++ b/funcs/net.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"math/big"
 	stdnet "net"
+	"net/netip"
 
 	"github.com/apparentlymart/go-cidr/cidr"
 	"github.com/hairyhenderson/gomplate/v3/conv"
@@ -84,58 +85,64 @@ func (f NetFuncs) ParseIPRange(iprange interface{}) (netaddr.IPRange, error) {
 	return netaddr.ParseIPRange(conv.ToString(iprange))
 }
 
-// StdParseIP -
-func (f NetFuncs) StdParseIP(ip interface{}) (stdnet.IP, error) {
-	i := stdnet.ParseIP(conv.ToString(ip))
-	if i == nil {
-		return nil, errors.Errorf("invalid IP address")
-	}
-	return i, nil
-}
-
-func (f NetFuncs) stdParseCIDR(prefix interface{}) (*stdnet.IPNet, error) {
+func (f NetFuncs) parseStdnetIPNet(prefix interface{}) (*stdnet.IPNet, error) {
 	if n, ok := prefix.(*stdnet.IPNet); ok {
 		return n, nil
 	}
+	if n, ok := prefix.(netaddr.IPPrefix); ok {
+		return n.Masked().IPNet(), nil
+	}
+	if n, ok := prefix.(netip.Prefix); ok {
+		net := &stdnet.IPNet{
+			IP:   n.Masked().Addr().AsSlice(),
+			Mask: stdnet.CIDRMask(n.Bits(), n.Addr().BitLen()),
+		}
+		return net, nil
+	}
 
 	_, network, err := stdnet.ParseCIDR(conv.ToString(prefix))
 	return network, err
 }
 
-// StdParseCIDR -
-func (f NetFuncs) StdParseCIDR(prefix interface{}) (*stdnet.IPNet, error) {
-	return f.stdParseCIDR(prefix)
+func (f NetFuncs) ipFromNetIp(n stdnet.IP) netaddr.IP {
+	ip, _ := netaddr.FromStdIP(n)
+	return ip
+}
+
+func (f NetFuncs) ipPrefixFromIpNet(n *stdnet.IPNet) netaddr.IPPrefix {
+	prefix, _ := netaddr.FromStdIPNet(n)
+	return prefix
 }
 
 // CidrHost -
-func (f NetFuncs) CidrHost(hostnum interface{}, prefix interface{}) (*stdnet.IP, error) {
-	network, err := f.stdParseCIDR(prefix)
+func (f NetFuncs) CidrHost(hostnum interface{}, prefix interface{}) (netaddr.IP, error) {
+	network, err := f.parseStdnetIPNet(prefix)
 	if err != nil {
-		return nil, err
+		return netaddr.IP{}, err
 	}
 
 	ip, err := cidr.HostBig(network, big.NewInt(conv.ToInt64(hostnum)))
-	return &ip, err
+	return f.ipFromNetIp(ip), err
 }
 
 // CidrNetmask -
-func (f NetFuncs) CidrNetmask(prefix interface{}) (*stdnet.IP, error) {
-	network, err := f.stdParseCIDR(prefix)
+func (f NetFuncs) CidrNetmask(prefix interface{}) (netaddr.IP, error) {
+	network, err := f.parseStdnetIPNet(prefix)
 	if err != nil {
-		return nil, err
+		return netaddr.IP{}, err
 	}
 
 	if len(network.IP) != stdnet.IPv4len {
-		return nil, errors.Errorf("only IPv4 networks are supported")
+		return netaddr.IP{}, errors.Errorf("only IPv4 networks are supported")
 	}
 
 	netmask := stdnet.IP(network.Mask)
-	return &netmask, nil
+	return f.ipFromNetIp(netmask), nil
 }
 
 // CidrSubnets -
-func (f NetFuncs) CidrSubnets(newbits interface{}, prefix interface{}) ([]*stdnet.IPNet, error) {
-	network, err := f.stdParseCIDR(prefix)
+func (f NetFuncs) CidrSubnets(newbits interface{}, prefix interface{}) ([]netaddr.IPPrefix, error) {
+	network, err := f.parseStdnetIPNet(prefix)
 	if err != nil {
 		return nil, err
 	}
@@ -146,25 +153,25 @@ func (f NetFuncs) CidrSubnets(newbits interface{}, prefix interface{}) ([]*stdne
 	}
 
 	maxNetNum := int64(1 << uint64(nBits))
-	retValues := make([]*stdnet.IPNet, maxNetNum)
+	retValues := make([]netaddr.IPPrefix, maxNetNum)
 	for i := int64(0); i < maxNetNum; i++ {
 		subnet, err := cidr.SubnetBig(network, nBits, big.NewInt(i))
 		if err != nil {
 			return nil, err
 		}
-		retValues[i] = subnet
+		retValues[i] = f.ipPrefixFromIpNet(subnet)
 	}
 
 	return retValues, nil
 }
 
 // CidrSubnetSizes -
-func (f NetFuncs) CidrSubnetSizes(args ...interface{}) ([]*stdnet.IPNet, error) {
+func (f NetFuncs) CidrSubnetSizes(args ...interface{}) ([]netaddr.IPPrefix, error) {
 	if len(args) < 2 {
 		return nil, errors.Errorf("wrong number of args: want 2 or more, got %d", len(args))
 	}
 
-	network, err := f.stdParseCIDR(args[len(args)-1])
+	network, err := f.parseStdnetIPNet(args[len(args)-1])
 	if err != nil {
 		return nil, err
 	}
@@ -174,7 +181,7 @@ func (f NetFuncs) CidrSubnetSizes(args ...interface{}) ([]*stdnet.IPNet, error)
 	firstLength := newbits[0]
 
 	firstLength += startPrefixLen
-	retValues := make([]*stdnet.IPNet, len(newbits))
+	retValues := make([]netaddr.IPPrefix, len(newbits))
 
 	current, _ := cidr.PreviousSubnet(network, firstLength)
 
@@ -211,7 +218,7 @@ func (f NetFuncs) CidrSubnetSizes(args ...interface{}) ([]*stdnet.IPNet, error)
 			return nil, errors.Errorf("not enough remaining address space for a subnet with a prefix of %d bits after %s", length, current.String())
 		}
 		current = next
-		retValues[i] = current
+		retValues[i] = f.ipPrefixFromIpNet(current)
 	}
 
 	return retValues, nil
diff --git a/funcs/net_test.go b/funcs/net_test.go
index eaa4ea65..02ec5928 100644
--- a/funcs/net_test.go
+++ b/funcs/net_test.go
@@ -3,6 +3,7 @@ package funcs
 import (
 	"context"
 	stdnet "net"
+	"net/netip"
 	"strconv"
 	"testing"
 
@@ -71,52 +72,54 @@ func TestParseIPRange(t *testing.T) {
 	assert.Equal(t, "192.168.0.2-192.168.23.255", iprange.String())
 }
 
-func TestStdParseIP(t *testing.T) {
+func TestCidrHost(t *testing.T) {
 	n := NetFuncs{}
-	ip, err := n.StdParseIP("not an IP")
-	assert.Nil(t, ip)
-	assert.Error(t, err)
 
-	ip, err = n.StdParseIP("10.12.113.12")
+	// net.IPNet
+	_, netIP, _ := stdnet.ParseCIDR("10.12.127.0/20")
+
+	ip, err := n.CidrHost(16, netIP)
 	assert.NoError(t, err)
-	assert.Equal(t, stdnet.IPv4(0x0A, 0x0C, 0x71, 0x0C), ip)
+	assert.Equal(t, "10.12.112.16", ip.String())
 
-	ip, err = n.StdParseIP("2001:470:20::2")
+	ip, err = n.CidrHost(268, netIP)
 	assert.NoError(t, err)
-	assert.Equal(t, stdnet.IP{
-		0x20, 0x01, 0x04, 0x70,
-		0, 0x20, 0, 0,
-		0, 0, 0, 0,
-		0, 0, 0, 0x02,
-	}, ip)
-}
-func TestStdParseCIDR(t *testing.T) {
-	n := NetFuncs{}
-	_, err := n.StdParseCIDR("not an IP")
-	assert.Error(t, err)
+	assert.Equal(t, "10.12.113.12", ip.String())
 
-	_, err = n.StdParseCIDR("1.1.1.1")
-	assert.Error(t, err)
+	_, netIP, _ = stdnet.ParseCIDR("fd00:fd12:3456:7890:00a2::/72")
+	ip, err = n.CidrHost(34, netIP)
+	assert.NoError(t, err)
+	assert.Equal(t, "fd00:fd12:3456:7890::22", ip.String())
 
-	cidr, err := n.StdParseCIDR("192.168.0.2/28")
+	// inet.af/netaddr.IPPrefix
+	ipPrefix, _ := n.ParseIPPrefix("10.12.127.0/20")
+
+	ip, err = n.CidrHost(16, ipPrefix)
 	assert.NoError(t, err)
-	assert.Equal(t, "192.168.0.0/28", cidr.String())
-}
+	assert.Equal(t, "10.12.112.16", ip.String())
 
-func TestCidrHost(t *testing.T) {
-	n := NetFuncs{}
-	_, network, _ := stdnet.ParseCIDR("10.12.127.0/20")
+	ip, err = n.CidrHost(268, ipPrefix)
+	assert.NoError(t, err)
+	assert.Equal(t, "10.12.113.12", ip.String())
+
+	ipPrefix, _ = n.ParseIPPrefix("fd00:fd12:3456:7890:00a2::/72")
+	ip, err = n.CidrHost(34, ipPrefix)
+	assert.NoError(t, err)
+	assert.Equal(t, "fd00:fd12:3456:7890::22", ip.String())
+
+	// net/netip.Prefix
+	prefix, _ := netip.ParsePrefix("10.12.127.0/20")
 
-	ip, err := n.CidrHost(16, network)
+	ip, err = n.CidrHost(16, prefix)
 	assert.NoError(t, err)
 	assert.Equal(t, "10.12.112.16", ip.String())
 
-	ip, err = n.CidrHost(268, network)
+	ip, err = n.CidrHost(268, prefix)
 	assert.NoError(t, err)
 	assert.Equal(t, "10.12.113.12", ip.String())
 
-	_, network, _ = stdnet.ParseCIDR("fd00:fd12:3456:7890:00a2::/72")
-	ip, err = n.CidrHost(34, network)
+	prefix, _ = netip.ParsePrefix("fd00:fd12:3456:7890:00a2::/72")
+	ip, err = n.CidrHost(34, prefix)
 	assert.NoError(t, err)
 	assert.Equal(t, "fd00:fd12:3456:7890::22", ip.String())
 }