Adding IPv6 to cidr_set and cidr_set_test

pkg/controller/node/cidr_set.go

@@ -35,19 +35,62 @@ type cidrSet struct {
 	subNetMaskSize  int
 }
 
+const (
+	// The subnet mask size cannot be greater than 16 more than the cluster mask size
+	// TODO: https://github.com/kubernetes/kubernetes/issues/44918
+	// clusterSubnetMaxDiff limited to 16 due to the uncompressed bitmap
+	clusterSubnetMaxDiff = 16
+	// maximum 64 bits of prefix
+	maxPrefixLength = 64
+)
+
 func newCIDRSet(clusterCIDR *net.IPNet, subNetMaskSize int) *cidrSet {
 	clusterMask := clusterCIDR.Mask
 	clusterMaskSize, _ := clusterMask.Size()
-	maxCIDRs := 1 << uint32(subNetMaskSize-clusterMaskSize)
+
+	var maxCIDRs int
+	if ((clusterCIDR.IP.To4() == nil) && (subNetMaskSize-clusterMaskSize > clusterSubnetMaxDiff)) || (subNetMaskSize > maxPrefixLength) {
+		maxCIDRs = 0
+	} else {
+		maxCIDRs = 1 << uint32(subNetMaskSize-clusterMaskSize)
+	}
 	return &cidrSet{
 		clusterCIDR:     clusterCIDR,
-		clusterIP:       clusterCIDR.IP.To4(),
+		clusterIP:       clusterCIDR.IP,
 		clusterMaskSize: clusterMaskSize,
 		maxCIDRs:        maxCIDRs,
 		subNetMaskSize:  subNetMaskSize,
 	}
 }
 
+func (s *cidrSet) indexToCIDRBlock(index int) *net.IPNet {
+	var ip []byte
+	var mask int
+	switch /*v4 or v6*/ {
+	case s.clusterIP.To4() != nil:
+		{
+			j := uint32(index) << uint32(32-s.subNetMaskSize)
+			ipInt := (binary.BigEndian.Uint32(s.clusterIP)) | j
+			ip = make([]byte, 4)
+			binary.BigEndian.PutUint32(ip, ipInt)
+			mask = 32
+
+		}
+	case s.clusterIP.To16() != nil:
+		{
+			j := uint64(index) << uint64(64-s.subNetMaskSize)
+			ipInt := (binary.BigEndian.Uint64(s.clusterIP)) | j
+			ip = make([]byte, 16)
+			binary.BigEndian.PutUint64(ip, ipInt)
+			mask = 128
+		}
+	}
+	return &net.IPNet{
+		IP:   ip,
+		Mask: net.CIDRMask(s.subNetMaskSize, mask),
+	}
+}
+
 func (s *cidrSet) allocateNext() (*net.IPNet, error) {
 	s.Lock()
 	defer s.Unlock()
@@ -67,41 +110,47 @@ func (s *cidrSet) allocateNext() (*net.IPNet, error) {
 
 	s.used.SetBit(&s.used, nextUnused, 1)
 
-	j := uint32(nextUnused) << uint32(32-s.subNetMaskSize)
-	ipInt := (binary.BigEndian.Uint32(s.clusterIP)) | j
-	ip := make([]byte, 4)
-	binary.BigEndian.PutUint32(ip, ipInt)
-
-	return &net.IPNet{
-		IP:   ip,
-		Mask: net.CIDRMask(s.subNetMaskSize, 32),
-	}, nil
+	return s.indexToCIDRBlock(nextUnused), nil
 }
 
 func (s *cidrSet) getBeginingAndEndIndices(cidr *net.IPNet) (begin, end int, err error) {
 	begin, end = 0, s.maxCIDRs-1
 	cidrMask := cidr.Mask
 	maskSize, _ := cidrMask.Size()
+	var ipSize int
+
+	if cidr == nil {
+		return -1, -1, fmt.Errorf("Error getting indices for cluster cidr %v, cidr is nil", s.clusterCIDR)
+	}
 
 	if !s.clusterCIDR.Contains(cidr.IP.Mask(s.clusterCIDR.Mask)) && !cidr.Contains(s.clusterCIDR.IP.Mask(cidr.Mask)) {
 		return -1, -1, fmt.Errorf("cidr %v is out the range of cluster cidr %v", cidr, s.clusterCIDR)
 	}
 
 	if s.clusterMaskSize < maskSize {
-		subNetMask := net.CIDRMask(s.subNetMaskSize, 32)
+
+		ipSize = net.IPv4len
+		if cidr.IP.To4() == nil {
+			ipSize = net.IPv6len
+		}
+		subNetMask := net.CIDRMask(s.subNetMaskSize, ipSize*8)
 		begin, err = s.getIndexForCIDR(&net.IPNet{
-			IP:   cidr.IP.To4().Mask(subNetMask),
+			IP:   cidr.IP.Mask(subNetMask),
 			Mask: subNetMask,
 		})
 		if err != nil {
 			return -1, -1, err
 		}
-
-		ip := make([]byte, 4)
-		ipInt := binary.BigEndian.Uint32(cidr.IP) | (^binary.BigEndian.Uint32(cidr.Mask))
-		binary.BigEndian.PutUint32(ip, ipInt)
+		ip := make([]byte, ipSize)
+		if cidr.IP.To4() != nil {
+			ipInt := binary.BigEndian.Uint32(cidr.IP) | (^binary.BigEndian.Uint32(cidr.Mask))
+			binary.BigEndian.PutUint32(ip, ipInt)
+		} else {
+			ipInt := binary.BigEndian.Uint64(cidr.IP) | (^binary.BigEndian.Uint64(cidr.Mask))
+			binary.BigEndian.PutUint64(ip, ipInt)
+		}
 		end, err = s.getIndexForCIDR(&net.IPNet{
-			IP:   net.IP(ip).To4().Mask(subNetMask),
+			IP:   net.IP(ip).Mask(subNetMask),
 			Mask: subNetMask,
 		})
 		if err != nil {
@@ -140,11 +189,21 @@ func (s *cidrSet) occupy(cidr *net.IPNet) (err error) {
 }
 
 func (s *cidrSet) getIndexForCIDR(cidr *net.IPNet) (int, error) {
-	cidrIndex := (binary.BigEndian.Uint32(s.clusterIP) ^ binary.BigEndian.Uint32(cidr.IP.To4())) >> uint32(32-s.subNetMaskSize)
+	var cidrIndex uint32
+	if cidr.IP.To4() != nil {
+		cidrIndex = (binary.BigEndian.Uint32(s.clusterIP) ^ binary.BigEndian.Uint32(cidr.IP.To4())) >> uint32(32-s.subNetMaskSize)
+		if cidrIndex >= uint32(s.maxCIDRs) {
+			return 0, fmt.Errorf("CIDR: %v is out of the range of CIDR allocator", cidr)
+		}
+	} else if cidr.IP.To16() != nil {
+		cidrIndex64 := (binary.BigEndian.Uint64(s.clusterIP) ^ binary.BigEndian.Uint64(cidr.IP.To16())) >> uint64(64-s.subNetMaskSize)
 
-	if cidrIndex >= uint32(s.maxCIDRs) {
-		return 0, fmt.Errorf("CIDR: %v is out of the range of CIDR allocator", cidr)
+		if cidrIndex64 >= uint64(s.maxCIDRs) {
+			return 0, fmt.Errorf("CIDR: %v is out of the range of CIDR allocator", cidr)
+		}
+		cidrIndex = uint32(cidrIndex64)
+	} else {
+		return 0, fmt.Errorf("invalid CIDR block: %v", cidr)
 	}
-
 	return int(cidrIndex), nil
 }