mirror of
https://github.com/moby/moby.git
synced 2022-11-09 12:21:53 -05:00
bitseq to only handle and return unsigned types
Signed-off-by: Alessandro Boch <aboch@docker.com>
This commit is contained in:
Alessandro Boch
parent
467876e723
commit
ee31009744
5 changed files with 92 additions and 92 deletions
|
|
@ -14,10 +14,11 @@ import (
|
|||
// block sequence constants
|
||||
// If needed we can think of making these configurable
|
||||
const (
|
||||
blockLen = 32
|
||||
blockLen = uint32(32)
|
||||
blockBytes = blockLen / 8
|
||||
blockMAX = 1<<blockLen - 1
|
||||
blockFirstBit = 1 << (blockLen - 1)
|
||||
blockMAX = uint32(1<<blockLen - 1)
|
||||
blockFirstBit = uint32(1) << (blockLen - 1)
|
||||
invalidPos = blockMAX
|
||||
)
|
||||
|
||||
// Handle contains the sequece representing the bitmask and its identifier
|
||||
|
|
@ -81,17 +82,17 @@ func (s *sequence) toString() string {
|
|||
}
|
||||
|
||||
// GetAvailableBit returns the position of the first unset bit in the bitmask represented by this sequence
|
||||
func (s *sequence) getAvailableBit() (bytePos, bitPos int) {
|
||||
func (s *sequence) getAvailableBit() (uint32, uint32, error) {
|
||||
if s.block == blockMAX || s.count == 0 {
|
||||
return -1, -1
|
||||
return invalidPos, invalidPos, fmt.Errorf("no available bit")
|
||||
}
|
||||
bits := 0
|
||||
bitSel := uint32(blockFirstBit)
|
||||
bits := uint32(0)
|
||||
bitSel := blockFirstBit
|
||||
for bitSel > 0 && s.block&bitSel != 0 {
|
||||
bitSel >>= 1
|
||||
bits++
|
||||
}
|
||||
return bits / 8, bits % 8
|
||||
return bits / 8, bits % 8, nil
|
||||
}
|
||||
|
||||
// GetCopy returns a copy of the linked list rooted at this node
|
||||
|
|
@ -168,7 +169,7 @@ func (s *sequence) fromByteArray(data []byte) error {
|
|||
}
|
||||
|
||||
// GetFirstAvailable returns the byte and bit position of the first unset bit
|
||||
func (h *Handle) GetFirstAvailable() (int, int, error) {
|
||||
func (h *Handle) GetFirstAvailable() (uint32, uint32, error) {
|
||||
h.Lock()
|
||||
defer h.Unlock()
|
||||
return getFirstAvailable(h.head)
|
||||
|
|
@ -176,14 +177,14 @@ func (h *Handle) GetFirstAvailable() (int, int, error) {
|
|||
|
||||
// CheckIfAvailable checks if the bit correspondent to the specified ordinal is unset
|
||||
// If the ordinal is beyond the sequence limits, a negative response is returned
|
||||
func (h *Handle) CheckIfAvailable(ordinal int) (int, int, error) {
|
||||
func (h *Handle) CheckIfAvailable(ordinal uint32) (uint32, uint32, error) {
|
||||
h.Lock()
|
||||
defer h.Unlock()
|
||||
return checkIfAvailable(h.head, ordinal)
|
||||
}
|
||||
|
||||
// PushReservation pushes the bit reservation inside the bitmask.
|
||||
func (h *Handle) PushReservation(bytePos, bitPos int, release bool) error {
|
||||
func (h *Handle) PushReservation(bytePos, bitPos uint32, release bool) error {
|
||||
// Create a copy of the current handler
|
||||
h.Lock()
|
||||
nh := &Handle{
|
||||
|
|
@ -273,63 +274,62 @@ func (h *Handle) Unselected() uint32 {
|
|||
}
|
||||
|
||||
// getFirstAvailable looks for the first unset bit in passed mask
|
||||
func getFirstAvailable(head *sequence) (int, int, error) {
|
||||
byteIndex := 0
|
||||
func getFirstAvailable(head *sequence) (uint32, uint32, error) {
|
||||
byteIndex := uint32(0)
|
||||
current := head
|
||||
for current != nil {
|
||||
if current.block != blockMAX {
|
||||
bytePos, bitPos := current.getAvailableBit()
|
||||
return byteIndex + bytePos, bitPos, nil
|
||||
bytePos, bitPos, err := current.getAvailableBit()
|
||||
return byteIndex + bytePos, bitPos, err
|
||||
}
|
||||
byteIndex += int(current.count * blockBytes)
|
||||
byteIndex += current.count * blockBytes
|
||||
current = current.next
|
||||
}
|
||||
return -1, -1, fmt.Errorf("no bit available")
|
||||
return invalidPos, invalidPos, fmt.Errorf("no bit available")
|
||||
}
|
||||
|
||||
// checkIfAvailable checks if the bit correspondent to the specified ordinal is unset
|
||||
// If the ordinal is beyond the sequence limits, a negative response is returned
|
||||
func checkIfAvailable(head *sequence, ordinal int) (int, int, error) {
|
||||
func checkIfAvailable(head *sequence, ordinal uint32) (uint32, uint32, error) {
|
||||
bytePos := ordinal / 8
|
||||
bitPos := ordinal % 8
|
||||
|
||||
// Find the sequence containing this byte
|
||||
current, _, _, inBlockBytePos := findSequence(head, bytePos)
|
||||
|
||||
if current != nil {
|
||||
// Check whether the bit corresponding to the ordinal address is unset
|
||||
bitSel := uint32(blockFirstBit >> uint(inBlockBytePos*8+bitPos))
|
||||
bitSel := blockFirstBit >> (inBlockBytePos*8 + bitPos)
|
||||
if current.block&bitSel == 0 {
|
||||
return bytePos, bitPos, nil
|
||||
}
|
||||
}
|
||||
|
||||
return -1, -1, fmt.Errorf("requested bit is not available")
|
||||
return invalidPos, invalidPos, fmt.Errorf("requested bit is not available")
|
||||
}
|
||||
|
||||
// Given the byte position and the sequences list head, return the pointer to the
|
||||
// sequence containing the byte (current), the pointer to the previous sequence,
|
||||
// the number of blocks preceding the block containing the byte inside the current sequence.
|
||||
// If bytePos is outside of the list, function will return (nil, nil, 0, -1)
|
||||
func findSequence(head *sequence, bytePos int) (*sequence, *sequence, uint32, int) {
|
||||
// If bytePos is outside of the list, function will return (nil, nil, 0, invalidPos)
|
||||
func findSequence(head *sequence, bytePos uint32) (*sequence, *sequence, uint32, uint32) {
|
||||
// Find the sequence containing this byte
|
||||
previous := head
|
||||
current := head
|
||||
n := bytePos
|
||||
for current.next != nil && n >= int(current.count*blockBytes) { // Nil check for less than 32 addresses masks
|
||||
n -= int(current.count * blockBytes)
|
||||
for current.next != nil && n >= (current.count*blockBytes) { // Nil check for less than 32 addresses masks
|
||||
n -= (current.count * blockBytes)
|
||||
previous = current
|
||||
current = current.next
|
||||
}
|
||||
|
||||
// If byte is outside of the list, let caller know
|
||||
if n >= int(current.count*blockBytes) {
|
||||
return nil, nil, 0, -1
|
||||
if n >= (current.count * blockBytes) {
|
||||
return nil, nil, 0, invalidPos
|
||||
}
|
||||
|
||||
// Find the byte position inside the block and the number of blocks
|
||||
// preceding the block containing the byte inside this sequence
|
||||
precBlocks := uint32(n / blockBytes)
|
||||
precBlocks := n / blockBytes
|
||||
inBlockBytePos := bytePos % blockBytes
|
||||
|
||||
return current, previous, precBlocks, inBlockBytePos
|
||||
|
|
@ -352,7 +352,7 @@ func findSequence(head *sequence, bytePos int) (*sequence, *sequence, uint32, in
|
|||
// A) block is first in current: [prev seq] [new] [modified current seq] [next seq]
|
||||
// B) block is last in current: [prev seq] [modified current seq] [new] [next seq]
|
||||
// C) block is in the middle of current: [prev seq] [curr pre] [new] [curr post] [next seq]
|
||||
func pushReservation(bytePos, bitPos int, head *sequence, release bool) *sequence {
|
||||
func pushReservation(bytePos, bitPos uint32, head *sequence, release bool) *sequence {
|
||||
// Store list's head
|
||||
newHead := head
|
||||
|
||||
|
|
|
|||
|
|
@ -9,58 +9,58 @@ import (
|
|||
func TestSequenceGetAvailableBit(t *testing.T) {
|
||||
input := []struct {
|
||||
head *sequence
|
||||
bytePos int
|
||||
bitPos int
|
||||
bytePos uint32
|
||||
bitPos uint32
|
||||
}{
|
||||
{&sequence{block: 0x0, count: 0}, -1, -1},
|
||||
{&sequence{block: 0x0, count: 0}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0x0, count: 1}, 0, 0},
|
||||
{&sequence{block: 0x0, count: 100}, 0, 0},
|
||||
|
||||
{&sequence{block: 0x80000000, count: 0}, -1, -1},
|
||||
{&sequence{block: 0x80000000, count: 0}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0x80000000, count: 1}, 0, 1},
|
||||
{&sequence{block: 0x80000000, count: 100}, 0, 1},
|
||||
|
||||
{&sequence{block: 0xFF000000, count: 0}, -1, -1},
|
||||
{&sequence{block: 0xFF000000, count: 0}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xFF000000, count: 1}, 1, 0},
|
||||
{&sequence{block: 0xFF000000, count: 100}, 1, 0},
|
||||
|
||||
{&sequence{block: 0xFF800000, count: 0}, -1, -1},
|
||||
{&sequence{block: 0xFF800000, count: 0}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xFF800000, count: 1}, 1, 1},
|
||||
{&sequence{block: 0xFF800000, count: 100}, 1, 1},
|
||||
|
||||
{&sequence{block: 0xFFC0FF00, count: 0}, -1, -1},
|
||||
{&sequence{block: 0xFFC0FF00, count: 0}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xFFC0FF00, count: 1}, 1, 2},
|
||||
{&sequence{block: 0xFFC0FF00, count: 100}, 1, 2},
|
||||
|
||||
{&sequence{block: 0xFFE0FF00, count: 0}, -1, -1},
|
||||
{&sequence{block: 0xFFE0FF00, count: 0}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xFFE0FF00, count: 1}, 1, 3},
|
||||
{&sequence{block: 0xFFE0FF00, count: 100}, 1, 3},
|
||||
|
||||
{&sequence{block: 0xFFFEFF00, count: 0}, -1, -1},
|
||||
{&sequence{block: 0xFFFEFF00, count: 0}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xFFFEFF00, count: 1}, 1, 7},
|
||||
{&sequence{block: 0xFFFEFF00, count: 100}, 1, 7},
|
||||
|
||||
{&sequence{block: 0xFFFFC0FF, count: 0}, -1, -1},
|
||||
{&sequence{block: 0xFFFFC0FF, count: 0}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xFFFFC0FF, count: 1}, 2, 2},
|
||||
{&sequence{block: 0xFFFFC0FF, count: 100}, 2, 2},
|
||||
|
||||
{&sequence{block: 0xFFFFFF00, count: 0}, -1, -1},
|
||||
{&sequence{block: 0xFFFFFF00, count: 0}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xFFFFFF00, count: 1}, 3, 0},
|
||||
{&sequence{block: 0xFFFFFF00, count: 100}, 3, 0},
|
||||
|
||||
{&sequence{block: 0xFFFFFFFE, count: 0}, -1, -1},
|
||||
{&sequence{block: 0xFFFFFFFE, count: 0}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xFFFFFFFE, count: 1}, 3, 7},
|
||||
{&sequence{block: 0xFFFFFFFE, count: 100}, 3, 7},
|
||||
|
||||
{&sequence{block: 0xFFFFFFFF, count: 0}, -1, -1},
|
||||
{&sequence{block: 0xFFFFFFFF, count: 1}, -1, -1},
|
||||
{&sequence{block: 0xFFFFFFFF, count: 100}, -1, -1},
|
||||
{&sequence{block: 0xFFFFFFFF, count: 0}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xFFFFFFFF, count: 1}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xFFFFFFFF, count: 100}, invalidPos, invalidPos},
|
||||
}
|
||||
|
||||
for n, i := range input {
|
||||
b, bb := i.head.getAvailableBit()
|
||||
b, bb, err := i.head.getAvailableBit()
|
||||
if b != i.bytePos || bb != i.bitPos {
|
||||
t.Fatalf("Error in sequence.getAvailableBit() (%d).\nExp: (%d, %d)\nGot: (%d, %d),", n, i.bytePos, i.bitPos, b, bb)
|
||||
t.Fatalf("Error in sequence.getAvailableBit() (%d).\nExp: (%d, %d)\nGot: (%d, %d), err: %v", n, i.bytePos, i.bitPos, b, bb, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -144,10 +144,10 @@ func TestSequenceCopy(t *testing.T) {
|
|||
func TestGetFirstAvailable(t *testing.T) {
|
||||
input := []struct {
|
||||
mask *sequence
|
||||
bytePos int
|
||||
bitPos int
|
||||
bytePos uint32
|
||||
bitPos uint32
|
||||
}{
|
||||
{&sequence{block: 0xffffffff, count: 2048}, -1, -1},
|
||||
{&sequence{block: 0xffffffff, count: 2048}, invalidPos, invalidPos},
|
||||
{&sequence{block: 0x0, count: 8}, 0, 0},
|
||||
{&sequence{block: 0x80000000, count: 8}, 0, 1},
|
||||
{&sequence{block: 0xC0000000, count: 8}, 0, 2},
|
||||
|
|
@ -191,18 +191,18 @@ func TestGetFirstAvailable(t *testing.T) {
|
|||
func TestFindSequence(t *testing.T) {
|
||||
input := []struct {
|
||||
head *sequence
|
||||
bytePos int
|
||||
bytePos uint32
|
||||
precBlocks uint32
|
||||
inBlockBytePos int
|
||||
inBlockBytePos uint32
|
||||
}{
|
||||
{&sequence{block: 0xffffffff, count: 0}, 0, 0, -1},
|
||||
{&sequence{block: 0xffffffff, count: 0}, 31, 0, -1},
|
||||
{&sequence{block: 0xffffffff, count: 0}, 100, 0, -1},
|
||||
{&sequence{block: 0xffffffff, count: 0}, 0, 0, invalidPos},
|
||||
{&sequence{block: 0xffffffff, count: 0}, 31, 0, invalidPos},
|
||||
{&sequence{block: 0xffffffff, count: 0}, 100, 0, invalidPos},
|
||||
|
||||
{&sequence{block: 0x0, count: 1}, 0, 0, 0},
|
||||
{&sequence{block: 0x0, count: 1}, 1, 0, 1},
|
||||
{&sequence{block: 0x0, count: 1}, 31, 0, -1},
|
||||
{&sequence{block: 0x0, count: 1}, 60, 0, -1},
|
||||
{&sequence{block: 0x0, count: 1}, 31, 0, invalidPos},
|
||||
{&sequence{block: 0x0, count: 1}, 60, 0, invalidPos},
|
||||
|
||||
{&sequence{block: 0xffffffff, count: 10}, 0, 0, 0},
|
||||
{&sequence{block: 0xffffffff, count: 10}, 3, 0, 3},
|
||||
|
|
@ -212,7 +212,7 @@ func TestFindSequence(t *testing.T) {
|
|||
{&sequence{block: 0xffffffff, count: 10}, 39, 9, 3},
|
||||
|
||||
{&sequence{block: 0xffffffff, count: 10, next: &sequence{block: 0xcc000000, count: 10}}, 79, 9, 3},
|
||||
{&sequence{block: 0xffffffff, count: 10, next: &sequence{block: 0xcc000000, count: 10}}, 80, 0, -1},
|
||||
{&sequence{block: 0xffffffff, count: 10, next: &sequence{block: 0xcc000000, count: 10}}, 80, 0, invalidPos},
|
||||
}
|
||||
|
||||
for n, i := range input {
|
||||
|
|
@ -226,38 +226,38 @@ func TestFindSequence(t *testing.T) {
|
|||
func TestCheckIfAvailable(t *testing.T) {
|
||||
input := []struct {
|
||||
head *sequence
|
||||
ordinal int
|
||||
bytePos int
|
||||
bitPos int
|
||||
ordinal uint32
|
||||
bytePos uint32
|
||||
bitPos uint32
|
||||
}{
|
||||
{&sequence{block: 0xffffffff, count: 0}, 0, -1, -1},
|
||||
{&sequence{block: 0xffffffff, count: 0}, 31, -1, -1},
|
||||
{&sequence{block: 0xffffffff, count: 0}, 100, -1, -1},
|
||||
{&sequence{block: 0xffffffff, count: 0}, 0, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xffffffff, count: 0}, 31, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xffffffff, count: 0}, 100, invalidPos, invalidPos},
|
||||
|
||||
{&sequence{block: 0x0, count: 1}, 0, 0, 0},
|
||||
{&sequence{block: 0x0, count: 1}, 1, 0, 1},
|
||||
{&sequence{block: 0x0, count: 1}, 31, 3, 7},
|
||||
{&sequence{block: 0x0, count: 1}, 60, -1, -1},
|
||||
{&sequence{block: 0x0, count: 1}, 60, invalidPos, invalidPos},
|
||||
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0x800000ff, count: 1}}, 31, -1, -1},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0x800000ff, count: 1}}, 32, -1, -1},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0x800000ff, count: 1}}, 31, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0x800000ff, count: 1}}, 32, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0x800000ff, count: 1}}, 33, 4, 1},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0xC00000ff, count: 1}}, 33, -1, -1},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0xC00000ff, count: 1}}, 33, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0xC00000ff, count: 1}}, 34, 4, 2},
|
||||
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0xC00000ff, count: 1, next: &sequence{block: 0x0, count: 1}}}, 55, 6, 7},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0xC00000ff, count: 1, next: &sequence{block: 0x0, count: 1}}}, 56, -1, -1},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0xC00000ff, count: 1, next: &sequence{block: 0x0, count: 1}}}, 63, -1, -1},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0xC00000ff, count: 1, next: &sequence{block: 0x0, count: 1}}}, 56, invalidPos, invalidPos},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0xC00000ff, count: 1, next: &sequence{block: 0x0, count: 1}}}, 63, invalidPos, invalidPos},
|
||||
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0xC00000ff, count: 1, next: &sequence{block: 0x0, count: 1}}}, 64, 8, 0},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0xC00000ff, count: 1, next: &sequence{block: 0x0, count: 1}}}, 95, 11, 7},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0xC00000ff, count: 1, next: &sequence{block: 0x0, count: 1}}}, 96, -1, -1},
|
||||
{&sequence{block: 0xffffffff, count: 1, next: &sequence{block: 0xC00000ff, count: 1, next: &sequence{block: 0x0, count: 1}}}, 96, invalidPos, invalidPos},
|
||||
}
|
||||
|
||||
for n, i := range input {
|
||||
bytePos, bitPos, _ := checkIfAvailable(i.head, i.ordinal)
|
||||
bytePos, bitPos, err := checkIfAvailable(i.head, i.ordinal)
|
||||
if bytePos != i.bytePos || bitPos != i.bitPos {
|
||||
t.Fatalf("Error in (%d) checkIfAvailable(ord:%d). Expected (%d, %d). Got (%d, %d)", n, i.ordinal, i.bytePos, i.bitPos, bytePos, bitPos)
|
||||
t.Fatalf("Error in (%d) checkIfAvailable(ord:%d). Expected (%d, %d). Got (%d, %d). err: %v", n, i.ordinal, i.bytePos, i.bitPos, bytePos, bitPos, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -298,8 +298,8 @@ func TestMergeSequences(t *testing.T) {
|
|||
func TestPushReservation(t *testing.T) {
|
||||
input := []struct {
|
||||
mask *sequence
|
||||
bytePos int
|
||||
bitPos int
|
||||
bytePos uint32
|
||||
bitPos uint32
|
||||
newMask *sequence
|
||||
}{
|
||||
// Create first sequence and fill in 8 addresses starting from address 0
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ func (i *Idm) GetSpecificID(id uint32) error {
|
|||
}
|
||||
|
||||
for {
|
||||
bytePos, bitPos, err := i.handle.CheckIfAvailable(int(id - i.start))
|
||||
bytePos, bitPos, err := i.handle.CheckIfAvailable(id - i.start)
|
||||
if err != nil {
|
||||
return fmt.Errorf("requested id is not available")
|
||||
}
|
||||
|
|
@ -90,5 +90,5 @@ func (i *Idm) GetSpecificID(id uint32) error {
|
|||
// Release releases the specified id
|
||||
func (i *Idm) Release(id uint32) {
|
||||
ordinal := id - i.start
|
||||
i.handle.PushReservation(int(ordinal/8), int(ordinal%8), true)
|
||||
i.handle.PushReservation(ordinal/8, ordinal%8, true)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -297,7 +297,7 @@ func getInternalSubnets(inSubnet *net.IPNet, internalHostSize int) ([]*net.IPNet
|
|||
for i := 0; i < numIntSubs; i++ {
|
||||
intIP := make([]byte, len(subnet.IP))
|
||||
copy(intIP, subnet.IP) // IPv6 is too big, just work on the extra portion
|
||||
addIntToIP(intIP, i<<uint(internalHostSize))
|
||||
addIntToIP(intIP, uint32(i<<uint(internalHostSize)))
|
||||
subnetList[i] = &net.IPNet{IP: intIP, Mask: intMask}
|
||||
}
|
||||
}
|
||||
|
|
@ -431,7 +431,7 @@ func (a *Allocator) Release(addrSpace AddressSpace, address net.IP) {
|
|||
sub := subKey.canonicalChildSubnet()
|
||||
if sub.Contains(address) {
|
||||
// Retrieve correspondent ordinal in the subnet
|
||||
ordinal := ipToInt(getHostPortionIP(address, sub))
|
||||
ordinal := ipToUint32(getHostPortionIP(address, sub))
|
||||
// Release it
|
||||
for {
|
||||
var err error
|
||||
|
|
@ -509,8 +509,8 @@ func (a *Allocator) getSubnetList(addrSpace AddressSpace, ver ipVersion) []subne
|
|||
|
||||
func (a *Allocator) getAddress(subnet *net.IPNet, bitmask *bitseq.Handle, prefAddress net.IP, ver ipVersion) (net.IP, error) {
|
||||
var (
|
||||
bytePos, bitPos int
|
||||
ordinal int
|
||||
bytePos, bitPos uint32
|
||||
ordinal uint32
|
||||
err error
|
||||
)
|
||||
|
||||
|
|
@ -522,7 +522,7 @@ func (a *Allocator) getAddress(subnet *net.IPNet, bitmask *bitseq.Handle, prefAd
|
|||
if prefAddress == nil {
|
||||
bytePos, bitPos, err = bitmask.GetFirstAvailable()
|
||||
} else {
|
||||
ordinal = ipToInt(getHostPortionIP(prefAddress, subnet))
|
||||
ordinal = ipToUint32(getHostPortionIP(prefAddress, subnet))
|
||||
bytePos, bitPos, err = bitmask.CheckIfAvailable(ordinal)
|
||||
}
|
||||
if err != nil {
|
||||
|
|
@ -568,7 +568,7 @@ func (a *Allocator) DumpDatabase() {
|
|||
|
||||
// It generates the ip address in the passed subnet specified by
|
||||
// the passed host address ordinal
|
||||
func generateAddress(ordinal int, network *net.IPNet) net.IP {
|
||||
func generateAddress(ordinal uint32, network *net.IPNet) net.IP {
|
||||
var address [16]byte
|
||||
|
||||
// Get network portion of IP
|
||||
|
|
@ -592,14 +592,14 @@ func getAddressVersion(ip net.IP) ipVersion {
|
|||
}
|
||||
|
||||
// .0 and .255 will return false
|
||||
func isValidIP(i int) bool {
|
||||
func isValidIP(i uint32) bool {
|
||||
lastByte := i & 0xff
|
||||
return lastByte != 0xff && lastByte != 0
|
||||
}
|
||||
|
||||
// Adds the ordinal IP to the current array
|
||||
// 192.168.0.0 + 53 => 192.168.53
|
||||
func addIntToIP(array []byte, ordinal int) {
|
||||
func addIntToIP(array []byte, ordinal uint32) {
|
||||
for i := len(array) - 1; i >= 0; i-- {
|
||||
array[i] |= (byte)(ordinal & 0xff)
|
||||
ordinal >>= 8
|
||||
|
|
@ -607,11 +607,11 @@ func addIntToIP(array []byte, ordinal int) {
|
|||
}
|
||||
|
||||
// Convert an ordinal to the respective IP address
|
||||
func ipToInt(ip []byte) int {
|
||||
value := 0
|
||||
func ipToUint32(ip []byte) uint32 {
|
||||
value := uint32(0)
|
||||
for i := 0; i < len(ip); i++ {
|
||||
j := len(ip) - 1 - i
|
||||
value += int(ip[i]) << uint(j*8)
|
||||
value += uint32(ip[i]) << uint(j*8)
|
||||
}
|
||||
return value
|
||||
}
|
||||
|
|
|
|||
|
|
@ -20,10 +20,10 @@ func getAllocator(t *testing.T, subnet *net.IPNet) *Allocator {
|
|||
}
|
||||
|
||||
func TestInt2IP2IntConversion(t *testing.T) {
|
||||
for i := 0; i < 256*256*256; i++ {
|
||||
for i := uint32(0); i < 256*256*256; i++ {
|
||||
var array [4]byte // new array at each cycle
|
||||
addIntToIP(array[:], i)
|
||||
j := ipToInt(array[:])
|
||||
j := ipToUint32(array[:])
|
||||
if j != i {
|
||||
t.Fatalf("Failed to convert ordinal %d to IP % x and back to ordinal. Got %d", i, array, j)
|
||||
}
|
||||
|
|
@ -31,14 +31,14 @@ func TestInt2IP2IntConversion(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestIsValid(t *testing.T) {
|
||||
list := []int{0, 255, 256, 511, 512, 767, 768}
|
||||
list := []uint32{0, 255, 256, 511, 512, 767, 768}
|
||||
for _, i := range list {
|
||||
if isValidIP(i) {
|
||||
t.Fatalf("Failed to detect invalid IPv4 ordinal: %d", i)
|
||||
}
|
||||
}
|
||||
|
||||
list = []int{1, 254, 257, 258, 510, 513, 769, 770}
|
||||
list = []uint32{1, 254, 257, 258, 510, 513, 769, 770}
|
||||
for _, i := range list {
|
||||
if !isValidIP(i) {
|
||||
t.Fatalf("Marked valid ipv4 as invalid: %d", i)
|
||||
|
|
@ -474,7 +474,7 @@ func assertInternalSubnet(t *testing.T, hostSize int, bigSubnet, firstSmall, las
|
|||
list, _ := getInternalSubnets(subnet, hostSize)
|
||||
count := 1
|
||||
ones, bits := subnet.Mask.Size()
|
||||
diff := bits - ones - hostSize
|
||||
diff := bits - ones - int(hostSize)
|
||||
if diff > 0 {
|
||||
count <<= uint(diff)
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue