Calculate host position relative to network address in given CIDR, using golang?

How can I calculate the position of a host IP address, relative the network address it belongs to, using golang?

In other words, if you were to enumerate in numerical order all the addresses in a given subnet, how many would you enumerate to encounter the given address? This helps understand how many addresses have been assigned in the subnet prior to the given address.

# Example 1:
IP - 172.16.7.173  
Subnet - 172.16.4.0/22  
Expected host position - 941


# Example 2:
IP - 192.168.0.10  
Subnet - 192.168.0.0/24  
Expected host position - 10

The two examples provide redundant information.
Both the IP address, the network address and its associated mask can be encoded in the same CIDR. e.g:

Given this CIDR: 192.168.0.10/24

all the following can be inferred:

NetworkAddress: 192.168.0.0
NetworkMask: 24
IP Address: 192.168.0.10

To calculate position of the host IP address, relative to the network address IP, just parse the CIDR using the standard library. This will return all the information need to reduce the question to an arithmetic problem:

func GetHostPosition(cidr string) uint32 {
	ip, net, err := net.ParseCIDR(cidr)
	if err != nil {
		panic("invalid CIDR")
	}
	hostPosition := ip2int(ip.To4()) - ip2int(net.IP)
	return hostPosition
}

func ip2int(ip net.IP) uint32 {
	if len(ip) == 16 {
		panic("cannot convert IPv6 into uint32")
	}
	return binary.BigEndian.Uint32(ip)
}

package main

import (
	"encoding/binary"
	"fmt"
	"net"
)

func main() {
	ip := "172.16.7.173/22"
	ipAddr, ipNet, _ := net.ParseCIDR(ip)

ipInt := binary.BigEndian.Uint32(ipAddr.To4())

fmt.Println(ipInt)

hostmask := net.IPv4(^ipNet.Mask[0], ^ipNet.Mask[1], ^ipNet.Mask[2], ^ipNet.Mask[3])
fmt.Println(hostmask)

maskInt := binary.BigEndian.Uint32(hostmask.To4())
fmt.Println(maskInt)

fmt.Println(ipInt & maskInt)
hostPosition := int(ipInt) & int(maskInt)
fmt.Println(hostPosition)
}

Here you get the position of given CIDR.

Here is some code that shows how to do this using the ipaddress-go library. Disclaimer: I am the project manager of the library. This first function works with both IPv6 and IPv4. The returned position must be a big int since IPv6 addresses are 128 bits.

func position(subnetStr, ipStr string) *big.Int {
	subnet := ipaddr.NewIPAddressString(subnetStr).GetAddress()
	ip := ipaddr.NewIPAddressString(ipStr).GetAddress()
	return new(big.Int).Sub(ip.GetValue(), subnet.GetValue())
}

If you are dealing with IPv4 addresses only, which are 32 bits, you can use uint32 instead, as shown in the following code.

func positionIPv4(subnetStr, ipStr string) uint32 {
	subnet := ipaddr.NewIPAddressString(subnetStr).GetAddress().ToIPv4()
	ip := ipaddr.NewIPAddressString(ipStr).GetAddress().ToIPv4()
	return ip.Uint32Value() - subnet.Uint32Value()
}

Using your example addresses:

package main

import (
	"fmt"
	"math/big"
	"github.com/seancfoley/ipaddress-go/ipaddr"
)

func main() {
	fmt.Println(position("172.16.4.0/22", "172.16.7.173"))
	fmt.Println(positionIPv4("172.16.4.0/22", "172.16.7.173"))
	fmt.Println(position("192.168.0.0/24", "192.168.0.10"))
	fmt.Println(positionIPv4("192.168.0.0/24", "192.168.0.10"))
	fmt.Println(position("2001:db8::1a20/124", "2001:db8::1a2b"))
}

Output:

941
941
10
10
11