mirrors/netboot
1
0
Fork 0
mirror of https://github.com/danderson/netboot.git synced 2025-10-16 10:01:20 +02:00
Code Issues Packages Projects Releases Wiki Activity

More coding-style related changes

Browse Source
This commit is contained in:
Dmitri Dolguikh 2017-11-01 12:42:53 -07:00 committed by Dave Anderson
parent 8725ede99b
commit aa977487cd
2 changed files with 22 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
dhcp6/packet_builder_test.go
View File

@ -14,13 +14,13 @@ func TestMakeMsgAdvertise(t *testing.T) {
transactionID := [3]byte{'1', '2', '3'}
expectedIP := net.ParseIP("2001:db8:f00f:cafe::1")
expectedBootFileURL := []byte("http://bootfileurl")
expectedDnsServerIP := net.ParseIP("2001:db8:f00f:cafe::99")
expectedDNSServerIP := net.ParseIP("2001:db8:f00f:cafe::99")
identityAssociation := &IdentityAssociation{IPAddress: expectedIP, InterfaceID: expectedInterfaceID}
builder := MakePacketBuilder(90, 100)
msg := builder.MakeMsgAdvertise(transactionID, expectedServerID, expectedClientID, 0x11,
[]*IdentityAssociation{identityAssociation}, expectedBootFileURL, nil, []net.IP{expectedDnsServerIP})
[]*IdentityAssociation{identityAssociation}, expectedBootFileURL, nil, []net.IP{expectedDNSServerIP})
if msg.Type != MsgAdvertise {
t.Fatalf("Expected message type %d, got %d", MsgAdvertise, msg.Type)
@ -67,8 +67,8 @@ func TestMakeMsgAdvertise(t *testing.T) {
if dnsServersOption == nil {
t.Fatalf("DNS servers option should be set")
}
if string(dnsServersOption[0].Value) != string(expectedDnsServerIP) {
t.Fatalf("Expected dns server %v, got %v", expectedDnsServerIP, net.IP(dnsServersOption[0].Value))
if string(dnsServersOption[0].Value) != string(expectedDNSServerIP) {
t.Fatalf("Expected dns server %v, got %v", expectedDNSServerIP, net.IP(dnsServersOption[0].Value))
}
}
@ -186,13 +186,13 @@ func TestMakeMsgReply(t *testing.T) {
transactionID := [3]byte{'1', '2', '3'}
expectedIP := net.ParseIP("2001:db8:f00f:cafe::1")
expectedBootFileURL := []byte("http://bootfileurl")
expectedDnsServerIP := net.ParseIP("2001:db8:f00f:cafe::99")
expectedDNSServerIP := net.ParseIP("2001:db8:f00f:cafe::99")
identityAssociation := &IdentityAssociation{IPAddress: expectedIP, InterfaceID: []byte("id-1")}
builder := MakePacketBuilder(90, 100)
msg := builder.MakeMsgReply(transactionID, expectedServerID, expectedClientID, 0x11,
[]*IdentityAssociation{identityAssociation}, make([][]byte, 0), expectedBootFileURL, []net.IP{expectedDnsServerIP}, nil)
[]*IdentityAssociation{identityAssociation}, make([][]byte, 0), expectedBootFileURL, []net.IP{expectedDNSServerIP}, nil)
if msg.Type != MsgReply {
t.Fatalf("Expected message type %d, got %d", MsgAdvertise, msg.Type)
@ -240,8 +240,8 @@ func TestMakeMsgReply(t *testing.T) {
if dnsServersOption == nil {
t.Fatalf("DNS servers option should be set")
}
if string(dnsServersOption[0].Value) != string(expectedDnsServerIP) {
t.Fatalf("Expected dns server %v, got %v", expectedDnsServerIP, net.IP(dnsServersOption[0].Value))
if string(dnsServersOption[0].Value) != string(expectedDNSServerIP) {
t.Fatalf("Expected dns server %v, got %v", expectedDNSServerIP, net.IP(dnsServersOption[0].Value))
}
}
@ -349,12 +349,12 @@ func TestMakeMsgInformationRequestReply(t *testing.T) {
expectedServerID := []byte("serverid")
transactionID := [3]byte{'1', '2', '3'}
expectedBootFileURL := []byte("http://bootfileurl")
expectedDnsServerIP := net.ParseIP("2001:db8:f00f:cafe::99")
expectedDNSServerIP := net.ParseIP("2001:db8:f00f:cafe::99")
builder := MakePacketBuilder(90, 100)
msg := builder.MakeMsgInformationRequestReply(transactionID, expectedServerID, expectedClientID, 0x11,
expectedBootFileURL, []net.IP{expectedDnsServerIP})
expectedBootFileURL, []net.IP{expectedDNSServerIP})
if msg.Type != MsgReply {
t.Fatalf("Expected message type %d, got %d", MsgAdvertise, msg.Type)
@ -397,8 +397,8 @@ func TestMakeMsgInformationRequestReply(t *testing.T) {
if dnsServersOption == nil {
t.Fatalf("DNS servers option should be set")
}
if string(dnsServersOption[0].Value) != string(expectedDnsServerIP) {
t.Fatalf("Expected dns server %v, got %v", expectedDnsServerIP, net.IP(dnsServersOption[0].Value))
if string(dnsServersOption[0].Value) != string(expectedDNSServerIP) {
t.Fatalf("Expected dns server %v, got %v", expectedDNSServerIP, net.IP(dnsServersOption[0].Value))
}
}
@ -493,10 +493,10 @@ func TestExtractLLAddressOrIdWithDUIDLLT(t *testing.T) {
func TestExtractLLAddressOrIdWithDUIDEN(t *testing.T) {
builder := &PacketBuilder{}
expectedId := []byte{0x0, 0x1, 0x2, 0x3, 0xac, 0xbc, 0x32, 0xae, 0x86, 0x37}
expectedID := []byte{0x0, 0x1, 0x2, 0x3, 0xac, 0xbc, 0x32, 0xae, 0x86, 0x37}
id := builder.ExtractLLAddressOrID([]byte{0x0, 0x2, 0x0, 0x1, 0x2, 0x3, 0xac, 0xbc, 0x32, 0xae, 0x86, 0x37})
if string(expectedId) != string(id) {
t.Fatalf("Expected id %x, got: %x", expectedId, id)
if string(expectedID) != string(id) {
t.Fatalf("Expected id %x, got: %x", expectedID, id)
}
}

14
dhcp6/random_address_pool.go
View File

@ -97,16 +97,16 @@ func (p *RandomAddressPool) ReserveAddresses(clientID []byte, interfaceIDs [][]b
for {
// we assume that ip addresses adhere to high 64 bits for net and subnet ids, low 64 bits are for host id rule
hostOffset := randomUint64(rng) % p.poolSize
newIp := big.NewInt(0).Add(p.poolStartAddress, big.NewInt(0).SetUint64(hostOffset))
_, exists := p.usedIps[newIp.Uint64()];
newIP := big.NewInt(0).Add(p.poolStartAddress, big.NewInt(0).SetUint64(hostOffset))
_, exists := p.usedIps[newIP.Uint64()];
if !exists {
timeNow := p.timeNow()
association := &IdentityAssociation{ClientID: clientID,
InterfaceID: interfaceID,
IPAddress: newIp.Bytes(),
IPAddress: newIP.Bytes(),
CreatedAt: timeNow}
p.identityAssociations[clientIDHash] = association
p.usedIps[newIp.Uint64()] = struct{}{}
p.usedIps[newIP.Uint64()] = struct{}{}
p.identityAssociationExpirations.Push(&AssociationExpiration{expiresAt: p.calculateAssociationExpiration(timeNow), ia: association})
ret = append(ret, association)
break
@ -121,13 +121,13 @@ func (p *RandomAddressPool) ReleaseAddresses(clientID []byte, interfaceIDs [][]
p.lock.Lock()
defer p.lock.Unlock()
for _, interfaceId := range(interfaceIDs) {
association, exists := p.identityAssociations[p.calculateIAIDHash(clientID, interfaceId)]
for _, interfaceID := range(interfaceIDs) {
association, exists := p.identityAssociations[p.calculateIAIDHash(clientID, interfaceID)]
if !exists {
continue
}
delete(p.usedIps, big.NewInt(0).SetBytes(association.IPAddress).Uint64())
delete(p.identityAssociations, p.calculateIAIDHash(clientID, interfaceId))
delete(p.identityAssociations, p.calculateIAIDHash(clientID, interfaceID))
}
}