hostmask.go

@@ -16,7 +16,7 @@ import (
 // which the final 64bits of the address are used to construct a unique host
 // identifier and the allocator only has control of the first 64bits. So the
 // next IP from 2001:db8:1234:5678:: would be 2001:db8:1234:5679 instead of
-// 2001:db8:1234:5678::1. Here is a Net6 object eing initialized without a
+// 2001:db8:1234:5678::1. Here is a Net6 object being initialized without a
 // hostmask:
 //
 //	n := NewNet6(2001:db8::, 56, 0)

net.go

@@ -81,15 +81,15 @@ func AllNetsBetween(a, b net.IP) ([]Net, error) {
 // will be false. If no fit can be found (probably because a >= b) an
 // ErrNoValidRange will be returned
 func NewNetBetween(a, b net.IP) (Net, bool, error) {
-	if CompareIPs(a, b) == 1 { // != -1 {
+	if CompareIPs(a, b) == 1 {
 		return nil, false, ErrNoValidRange
 	}
 
 	if EffectiveVersion(a) != EffectiveVersion(b) {
 		return nil, false, ErrNoValidRange
 	}
 
-	return fitNetworkBetween(a, b, 1)
+	return fitNetworkBetween(a, b, 0)
 }
 
 // ByNet implements sort.Interface for iplib.Net based on the

net6.go

@@ -130,7 +130,7 @@ func (n Net6) Enumerate(size, offset int) []net.IP {
 		return nil
 	}
 
-	count := getEnumerationCount(size, offset, n.Count())
+	count := getEnumerationCount(uint(size), uint(offset), n.Count())
 
 	// Handle edge-case mask sizes
 	ones, _ := n.Mask().Size()
@@ -155,21 +155,21 @@ func (n Net6) Enumerate(size, offset int) []net.IP {
 	// our worker-pool based on request size; and [b] don't have to worry
 	// about exhausting some upper bound of goroutines -- enumerate requests
 	// are limited to MaxUint32, so we won't generate more than 65536
-	limit := 65535
-	pos := 0
+	var limit uint = 65535
+	var pos uint = 0
 	wg := sync.WaitGroup{}
 	for pos < count {
 		incr := limit
 		if limit > count-pos {
 			incr = count - pos
 		}
 		wg.Add(1)
-		go func(fip net.IP, pos, count int) {
+		go func(fip net.IP, pos, count uint) {
 			defer wg.Done()
 			firstip := CopyIP(fip)
 			lpos := pos
 			addrs[lpos], _ = IncrementIP6WithinHostmask(firstip, n.Hostmask, uint128.New(uint64(lpos), 0))
-			for i := 1; i < count; i++ {
+			for i := uint(1); i < count; i++ {
 				lpos++
 				addrs[lpos], _ = NextIP6WithinHostmask(addrs[lpos-1], n.Hostmask)
 			}
@@ -360,13 +360,13 @@ func (n Net6) wildcard() net.IPMask {
 
 // getEnumerationCount returns the size of the array needed to satisfy an
 // Enumerate request. Mostly split out to ease testing of larger values
-func getEnumerationCount(reqSize, offset int, count uint128.Uint128) int {
-	sizes := []int{math.MaxUint32}
+func getEnumerationCount(reqSize, offset uint, count uint128.Uint128) uint {
+	sizes := []uint{math.MaxUint32}
 
 	if count.Cmp64(math.MaxUint32) <= 0 {
-		realCount := 0
-		if int(count.Lo) > offset {
-			realCount = int(count.Lo) - offset
+		var realCount uint = 0
+		if uint(count.Lo) > offset {
+			realCount = uint(count.Lo) - offset
 		}
 		sizes = append(sizes, realCount)
 	}