ITQC/containernetworking-plugins
24
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 34 Wiki Activity

vendor update

Browse Source
This commit is contained in:
Nathan Gieseker
2019-06-17 21:33:55 -07:00
parent 13fbc4afdf
commit e8c953999e
900 changed files with 36135 additions and 265442 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
vendor/github.com/d2g/dhcp4/option.go generated vendored
View File

@ -11,7 +11,7 @@ type Option struct {
type Options map[OptionCode][]byte
// SelectOrderOrAll has same functionality as SelectOrder, except if the order
// param is nil, whereby all options are added (in arbitrary order).
// param is nil, whereby all options are added (in arbitary order).
func (o Options) SelectOrderOrAll(order []byte) []Option {
if order == nil {
opts := make([]Option, 0, len(o))

5
vendor/github.com/d2g/dhcp4/packet.go generated vendored
View File

@ -127,11 +127,10 @@ func ReplyPacket(req Packet, mt MessageType, serverId, yIAddr net.IP, leaseDurat
p.SetYIAddr(yIAddr)
p.SetGIAddr(req.GIAddr())
p.SetCHAddr(req.CHAddr())
p.SetSecs(req.Secs())
p.AddOption(OptionDHCPMessageType, []byte{byte(mt)})
p.AddOption(OptionServerIdentifier, []byte(serverId))
if leaseDuration > 0 {
p.AddOption(OptionIPAddressLeaseTime, OptionsLeaseTime(leaseDuration))
}
p.AddOption(OptionIPAddressLeaseTime, OptionsLeaseTime(leaseDuration))
for _, o := range options {
p.AddOption(o.Code, o.Value)
}

59
vendor/github.com/d2g/dhcp4server/leasepool/lease.go generated vendored
View File

@ -1,10 +1,7 @@
package leasepool
import (
"bytes"
"encoding/hex"
"encoding/json"
"fmt"
"net"
"time"
)
@ -21,35 +18,37 @@ type Lease struct {
IP net.IP //The IP of the Lease
Status LeaseStatus //Are Reserved, Active or Free
MACAddress net.HardwareAddr //Mac Address of the Device
ClientID []byte //ClientID of the request
Hostname string //Hostname From option 12
Expiry time.Time //Expiry Time
}
//leaseMarshal is a mirror of Lease used for marshalling, since
//net.HardwareAddr has no native marshalling capability.
type leaseMarshal struct {
IP string
Status int
MACAddress string
ClientID string
Hostname string
Expiry time.Time
}
func (this Lease) MarshalJSON() ([]byte, error) {
return json.Marshal(leaseMarshal{
IP: this.IP.String(),
Status: int(this.Status),
MACAddress: this.MACAddress.String(),
ClientID: hex.EncodeToString(this.ClientID),
Hostname: this.Hostname,
Expiry: this.Expiry,
})
stringMarshal := struct {
IP string
Status int
MACAddress string
Hostname string
Expiry time.Time
}{
(this.IP.String()),
int(this.Status),
(this.MACAddress.String()),
this.Hostname,
this.Expiry,
}
return json.Marshal(stringMarshal)
}
func (this *Lease) UnmarshalJSON(data []byte) error {
stringUnMarshal := leaseMarshal{}
stringUnMarshal := struct {
IP string
Status int
MACAddress string
Hostname string
Expiry time.Time
}{}
err := json.Unmarshal(data, &stringUnMarshal)
if err != nil {
return err
@ -59,14 +58,12 @@ func (this *Lease) UnmarshalJSON(data []byte) error {
this.Status = LeaseStatus(stringUnMarshal.Status)
if stringUnMarshal.MACAddress != "" {
this.MACAddress, err = net.ParseMAC(stringUnMarshal.MACAddress)
if err != nil {
return fmt.Errorf("error parsing MAC address: %v", err)
}
}
this.ClientID, err = hex.DecodeString(stringUnMarshal.ClientID)
if err != nil {
return fmt.Errorf("error decoding clientID: %v", err)
return err
}
this.Hostname = stringUnMarshal.Hostname
this.Expiry = stringUnMarshal.Expiry
@ -86,10 +83,6 @@ func (this Lease) Equal(other Lease) bool {
return false
}
if !bytes.Equal(this.ClientID, other.ClientID) {
return false
}
if this.Hostname != other.Hostname {
return false
}

52
vendor/github.com/d2g/dhcp4server/leasepool/lease_test.go generated vendored
View File

@ -1,52 +0,0 @@
package leasepool
import (
"encoding/json"
"net"
"testing"
"time"
)
/*
* The Leases are Marshalled and Unmarshalled for storage.
* I JSON Marshal these for gvklite
*/
func TestMarshaling(test *testing.T) {
var err error
startLease := Lease{}
startLease.IP = net.IPv4(192, 168, 0, 1)
startLease.Hostname = "ExampleHostname"
startLease.Status = Active
startLease.Expiry = time.Now()
startLease.MACAddress, err = net.ParseMAC("01:23:45:67:89:ab")
if err != nil {
test.Error("Error Parsing Mac Address:" + err.Error())
}
startLease.ClientID = []byte("adsfasdfasf")
byteStartLease, err := json.Marshal(startLease)
if err != nil {
test.Error("Error Marshaling to JSON:" + err.Error())
}
test.Log("StartLease As JSON:" + string(byteStartLease))
endLease := Lease{}
err = json.Unmarshal(byteStartLease, &endLease)
if err != nil {
test.Error("Error Unmarshaling to JSON:" + err.Error())
}
test.Logf("End Lease Object:%v\n", endLease)
if !startLease.Equal(endLease) {
byteEndLease, err := json.Marshal(endLease)
if err != nil {
test.Error("Can't Marshal End Lease For Debuging:" + err.Error())
}
test.Log("End Lease as JSON:" + string(byteEndLease))
test.Error("Starting Lease Doesn't Match End Lease")
}
}

4
vendor/github.com/d2g/dhcp4server/leasepool/leasepool.go generated vendored
View File

@ -25,8 +25,8 @@ type LeasePool interface {
*/
GetLease(net.IP) (bool, Lease, error)
//Get the lease already in use by that hardware address and/or client identifier.
GetLeaseForClient(net.HardwareAddr, []byte) (bool, Lease, error)
//Get the lease already in use by that hardware address.
GetLeaseForHardwareAddress(net.HardwareAddr) (bool, Lease, error)
/*
* -Lease Available

17
vendor/github.com/d2g/dhcp4server/leasepool/memorypool/memorypool.go generated vendored
View File

@ -81,23 +81,13 @@ func (t *MemoryPool) GetLease(leaseIP net.IP) (bool, leasepool.Lease, error) {
return false, leasepool.Lease{}, nil
}
func makeKey(macAddress net.HardwareAddr, clientID []byte) []byte {
key := []byte(macAddress)
if len(clientID) > 0 {
key = append(key, clientID...)
}
return key
}
//Get the lease already in use by that hardware address and/or client identifier.
func (t *MemoryPool) GetLeaseForClient(macAddress net.HardwareAddr, clientID []byte) (bool, leasepool.Lease, error) {
//Get the lease already in use by that hardware address.
func (t *MemoryPool) GetLeaseForHardwareAddress(macAddress net.HardwareAddr) (bool, leasepool.Lease, error) {
t.poolLock.Lock()
defer t.poolLock.Unlock()
needleKey := makeKey(macAddress, clientID)
for i := range t.pool {
haystackKey := makeKey(t.pool[i].MACAddress, t.pool[i].ClientID)
if bytes.Equal(needleKey, haystackKey) {
if bytes.Equal(t.pool[i].MACAddress, macAddress) {
return true, t.pool[i], nil
}
}
@ -149,7 +139,6 @@ func (t *MemoryPool) UpdateLease(lease leasepool.Lease) (bool, error) {
if t.pool[i].IP.Equal(lease.IP) {
t.pool[i].MACAddress = lease.MACAddress
t.pool[i].ClientID = lease.ClientID
t.pool[i].Hostname = lease.Hostname
t.pool[i].Expiry = lease.Expiry
t.pool[i].Status = lease.Status

56
vendor/github.com/d2g/dhcp4server/leasepool/memorypool/memorypool_test.go generated vendored
View File

@ -1,56 +0,0 @@
package memorypool
import (
"github.com/d2g/dhcp4"
"github.com/d2g/dhcp4server/leasepool"
"net"
"testing"
)
func TestLeaseCycle(test *testing.T) {
myMemoryLeasePool := MemoryPool{}
//Lets add a list of IPs to the pool these will be served to the clients so make sure they work for you.
// So Create Array of IPs 192.168.1.1 to 192.168.1.30
for i := 0; i < 30; i++ {
err := myMemoryLeasePool.AddLease(leasepool.Lease{IP: dhcp4.IPAdd(net.IPv4(192, 168, 1, 1), i)})
if err != nil {
test.Error("Error Creating Lease:" + err.Error())
}
}
for i := 0; i < 30; i++ {
hasLease, iLease, err := myMemoryLeasePool.GetNextFreeLease()
if err != nil {
test.Error("Error Getting Lease:" + err.Error())
}
if !hasLease {
test.Error("Failed to get get lease (none free?)")
}
if !dhcp4.IPAdd(net.IPv4(192, 168, 1, 1), i).Equal(iLease.IP) {
test.Error("Expected Lease:" + dhcp4.IPAdd(net.IPv4(192, 168, 1, 1), i).String() + " Received:" + iLease.IP.String())
}
}
}
func TestSingleLease(test *testing.T) {
myMemoryLeasePool := MemoryPool{}
err := myMemoryLeasePool.AddLease(leasepool.Lease{IP: dhcp4.IPAdd(net.IPv4(192, 168, 1, 5), 0)})
if err != nil {
test.Error("Error Creating Lease:" + err.Error())
}
hasLease, iLease, err := myMemoryLeasePool.GetNextFreeLease()
if err != nil {
test.Error("Error Getting Lease:" + err.Error())
}
if !hasLease {
test.Error("Failed to get get lease (none free?)")
}
if !dhcp4.IPAdd(net.IPv4(192, 168, 1, 5), 0).Equal(iLease.IP) {
test.Error("Expected Lease:" + dhcp4.IPAdd(net.IPv4(192, 168, 1, 5), 0).String() + " Received:" + iLease.IP.String())
}
}

26
vendor/github.com/d2g/dhcp4server/server.go generated vendored
View File

@ -172,6 +172,9 @@ func (s *Server) ListenAndServe() error {
// return err
//}
//Make Our Buffer (Max Buffer is 574) "I believe this 576 size comes from RFC 791" - Random Mailing list quote of the day.
buffer := make([]byte, 576)
log.Println("Trace: DHCP Server Listening.")
for {
@ -180,9 +183,6 @@ func (s *Server) ListenAndServe() error {
return nil
}
//Make Our Buffer (Max Buffer is 574) "I believe this 576 size comes from RFC 791" - Random Mailing list quote of the day.
buffer := make([]byte, 576)
//Set Read Deadline
s.connection.SetReadDeadline(time.Now().Add(time.Second))
// Read Packet
@ -213,6 +213,7 @@ func (s *Server) ListenAndServe() error {
}
log.Printf("Debug: Unexpect Error from Connection Read From: %v\n", err)
log.Printf("Debug: err type %T %#v\n", err, err)
return err
}
@ -280,13 +281,6 @@ func (s *Server) ListenAndServe() error {
}
}
func getClientID(packetOptions dhcp4.Options) []byte {
if clientID, ok := packetOptions[dhcp4.OptionClientIdentifier]; ok {
return clientID
}
return nil
}
func (s *Server) ServeDHCP(packet dhcp4.Packet) (dhcp4.Packet, error) {
packetOptions := packet.ParseOptions()
@ -313,7 +307,6 @@ func (s *Server) ServeDHCP(packet dhcp4.Packet) (dhcp4.Packet, error) {
lease.Status = leasepool.Reserved
lease.MACAddress = packet.CHAddr()
lease.ClientID = getClientID(packetOptions)
//If the lease expires within the next 5 Mins increase the lease expiary (Giving the Client 5 mins to complete)
if lease.Expiry.Before(time.Now().Add(time.Minute * 5)) {
@ -358,7 +351,6 @@ func (s *Server) ServeDHCP(packet dhcp4.Packet) (dhcp4.Packet, error) {
} else {
lease.Status = leasepool.Active
lease.MACAddress = packet.CHAddr()
lease.ClientID = getClientID(packetOptions)
lease.Expiry = time.Now().Add(s.leaseDuration)
@ -506,8 +498,6 @@ func (s *Server) DeclinePacket(requestPacket dhcp4.Packet) dhcp4.Packet {
func (s *Server) GetLease(packet dhcp4.Packet) (found bool, lease leasepool.Lease, err error) {
packetOptions := packet.ParseOptions()
clientID := getClientID(packetOptions)
//Requested an IP
if (len(packetOptions) > 0) &&
packetOptions[dhcp4.OptionRequestedIPAddress] != nil &&
@ -520,15 +510,11 @@ func (s *Server) GetLease(packet dhcp4.Packet) (found bool, lease leasepool.Leas
}
if found {
//If lease is free, return it to client. If it is not
//free match against the MAC address and client
//identifier.
if lease.Status == leasepool.Free {
//Lease Is Free you Can Have it.
return
}
if bytes.Equal(lease.MACAddress, packet.CHAddr()) &&
bytes.Equal(lease.ClientID, clientID) {
if lease.Status != leasepool.Free && bytes.Equal(lease.MACAddress, packet.CHAddr()) {
//Lease isn't free but it's yours
return
}
@ -536,7 +522,7 @@ func (s *Server) GetLease(packet dhcp4.Packet) (found bool, lease leasepool.Leas
}
//Ok Even if you requested an IP you can't have it.
found, lease, err = s.leasePool.GetLeaseForClient(packet.CHAddr(), clientID)
found, lease, err = s.leasePool.GetLeaseForHardwareAddress(packet.CHAddr())
if found || err != nil {
return
}

490
vendor/github.com/d2g/dhcp4server/server_test.go generated vendored
View File

@ -1,490 +0,0 @@
package dhcp4server_test
import (
"bytes"
"encoding/binary"
"fmt"
"log"
"net"
"sync"
"testing"
"time"
"github.com/d2g/dhcp4"
"github.com/d2g/dhcp4client"
"github.com/d2g/dhcp4server"
"github.com/d2g/dhcp4server/leasepool"
"github.com/d2g/dhcp4server/leasepool/memorypool"
"github.com/d2g/hardwareaddr"
)
/*
* Example Server :D
*/
func ExampleServer() {
//Create a Lease Pool We're going to use a memory pool
//Remember the memory is cleared on restart so you will reissue the same IP Addresses.
myMemoryLeasePool := memorypool.MemoryPool{}
//Lets add a list of IPs to the pool these will be served to the clients so make sure they work for you.
// So Create Array of IPs 192.168.1.1 to 192.168.1.30
for i := 0; i < 30; i++ {
err := myMemoryLeasePool.AddLease(leasepool.Lease{IP: dhcp4.IPAdd(net.IPv4(192, 168, 1, 1), i)})
if err != nil {
log.Fatalln("Error Adding IP to pool:" + err.Error())
}
}
// We set the port numbers to over 1024 (1067 & 1068) as the automated test don't have root access
tServer, err := dhcp4server.New(
net.IPv4(192, 168, 1, 201),
&myMemoryLeasePool,
dhcp4server.SetLocalAddr(net.UDPAddr{IP: net.IPv4(0, 0, 0, 0), Port: 1067}),
dhcp4server.SetRemoteAddr(net.UDPAddr{IP: net.IPv4bcast, Port: 1068}),
)
if err != nil {
log.Fatalln("Error Configuring Server:" + err.Error())
}
//Start the Server...
err = tServer.ListenAndServe()
if err != nil {
log.Fatalln("Error Starting Server:" + err.Error())
}
}
/*
* Test Discovering a Lease That's not Within Our Lease Range.
* This Happens When a devce switches network.
* Example: Mobile Phone on Mobile internet Has IP 100.123.123.123 Switch To Home Wifi
* The device requests 100.123.123.123 on Home Wifi which is out of range...
*/
func TestDiscoverOutOfRangeLease(test *testing.T) {
//Setup the Server
myServer, err := dhcp4server.New(
net.IPv4(192, 168, 1, 201),
getTestLeasePool(),
dhcp4server.SetLocalAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1067}),
dhcp4server.SetRemoteAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1068}),
)
if err != nil {
test.Error("Error: Can't Configure Server " + err.Error())
}
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
err := myServer.ListenAndServe()
if err != nil {
log.Fatalln("Error Starting Server:" + err.Error())
}
}()
time.Sleep(time.Duration(5) * time.Second)
//Generate Hardware Address
HardwareMACAddress, err := hardwareaddr.GenerateEUI48()
if err != nil {
test.Error("Error: Can't Generate Valid MACAddress" + err.Error())
}
//Lets Be A Client
//We need to set the connection ports to 1068 and 1067 so we don't need root access
c, err := dhcp4client.NewInetSock(dhcp4client.SetLocalAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1068}), dhcp4client.SetRemoteAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1067}))
if err != nil {
test.Error("Client Conection Generation:" + err.Error())
}
client, err := dhcp4client.New(dhcp4client.HardwareAddr(HardwareMACAddress), dhcp4client.Connection(c))
defer client.Close()
if err != nil {
test.Error("Conection Error:" + err.Error())
}
discoveryPacket := client.DiscoverPacket()
discoveryPacket.SetCIAddr(net.IPv4(100, 102, 96, 123))
discoveryPacket.PadToMinSize()
err = client.SendPacket(discoveryPacket)
if err != nil {
test.Error("Error: Sending Discover Packet" + err.Error())
}
test.Log("--Discovery Packet--")
test.Logf("Client IP : %v\n", discoveryPacket.CIAddr().String())
test.Logf("Your IP : %v\n", discoveryPacket.YIAddr().String())
test.Logf("Server IP : %v\n", discoveryPacket.SIAddr().String())
test.Logf("Gateway IP: %v\n", discoveryPacket.GIAddr().String())
test.Logf("Client Mac: %v\n", discoveryPacket.CHAddr().String())
if !bytes.Equal(discoveryPacket.CHAddr(), HardwareMACAddress) {
test.Error("MACAddresses Don't Match??")
}
offerPacket, err := client.GetOffer(&discoveryPacket)
if err != nil {
test.Error("Error Getting Offer:" + err.Error())
}
test.Log("--Offer Packet--")
test.Logf("Client IP : %v\n", offerPacket.CIAddr().String())
test.Logf("Your IP : %v\n", offerPacket.YIAddr().String())
test.Logf("Server IP : %v\n", offerPacket.SIAddr().String())
test.Logf("Gateway IP: %v\n", offerPacket.GIAddr().String())
test.Logf("Client Mac: %v\n", offerPacket.CHAddr().String())
requestPacket, err := client.SendRequest(&offerPacket)
if err != nil {
test.Error("Error Sending Request:" + err.Error())
}
test.Log("--Request Packet--")
test.Logf("Client IP : %v\n", requestPacket.CIAddr().String())
test.Logf("Your IP : %v\n", requestPacket.YIAddr().String())
test.Logf("Server IP : %v\n", requestPacket.SIAddr().String())
test.Logf("Gateway IP: %v\n", requestPacket.GIAddr().String())
test.Logf("Client Mac: %v\n", requestPacket.CHAddr().String())
acknowledgement, err := client.GetAcknowledgement(&requestPacket)
if err != nil {
test.Error("Error Getting Acknowledgement:" + err.Error())
}
test.Log("--Acknowledgement Packet--")
test.Logf("Client IP : %v\n", acknowledgement.CIAddr().String())
test.Logf("Your IP : %v\n", acknowledgement.YIAddr().String())
test.Logf("Server IP : %v\n", acknowledgement.SIAddr().String())
test.Logf("Gateway IP: %v\n", acknowledgement.GIAddr().String())
test.Logf("Client Mac: %v\n", acknowledgement.CHAddr().String())
acknowledgementOptions := acknowledgement.ParseOptions()
if dhcp4.MessageType(acknowledgementOptions[dhcp4.OptionDHCPMessageType][0]) != dhcp4.ACK {
test.Error("Didn't get ACK?:" + err.Error())
}
test.Log("Shutting Down Server")
myServer.Shutdown()
wg.Wait()
}
/*
* Try Renewing A Lease From A Different Network.
*/
func TestRequestOutOfRangeLease(test *testing.T) {
//Setup the Server
myServer, err := dhcp4server.New(
net.IPv4(192, 168, 1, 201),
getTestLeasePool(),
dhcp4server.SetLocalAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1067}),
dhcp4server.SetRemoteAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1068}),
)
if err != nil {
test.Error("Error: Can't Configure Server " + err.Error())
}
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
err := myServer.ListenAndServe()
if err != nil {
log.Fatalln("Error Starting Server:" + err.Error())
}
}()
//Sleep some so the server starts....
time.Sleep(time.Duration(5) * time.Second)
//Generate Hardware Address
HardwareMACAddress, err := hardwareaddr.GenerateEUI48()
if err != nil {
test.Error("Error: Can't Generate Valid MACAddress" + err.Error())
}
HardwareMACAddress, err = net.ParseMAC("58-94-6B-73-57-0C")
if err != nil {
log.Printf("MAC Error:%v\n", err)
}
//Lets Be A Client
c, err := dhcp4client.NewInetSock(dhcp4client.SetLocalAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1068}), dhcp4client.SetRemoteAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1067}))
if err != nil {
test.Error("Client Conection Generation:" + err.Error())
}
client, err := dhcp4client.New(dhcp4client.HardwareAddr(HardwareMACAddress), dhcp4client.Connection(c))
defer client.Close()
if err != nil {
test.Error("Conection Error:" + err.Error())
}
//Create a dummy offer packet
offerPacket := client.DiscoverPacket()
offerPacket.SetCIAddr(net.IPv4(100, 102, 96, 123))
offerPacket.SetSIAddr(net.IPv4(192, 168, 1, 201))
offerPacket.SetYIAddr(net.IPv4(100, 102, 96, 123))
offerPacket.AddOption(dhcp4.OptionDHCPMessageType, []byte{byte(dhcp4.Offer)})
requestPacket, err := client.SendRequest(&offerPacket)
if err != nil {
test.Error("Error Sending Request:" + err.Error())
}
test.Log("--Request Packet--")
test.Logf("Client IP : %v\n", requestPacket.CIAddr().String())
test.Logf("Your IP : %v\n", requestPacket.YIAddr().String())
test.Logf("Server IP : %v\n", requestPacket.SIAddr().String())
test.Logf("Gateway IP: %v\n", requestPacket.GIAddr().String())
test.Logf("Client Mac: %v\n", requestPacket.CHAddr().String())
acknowledgement, err := client.GetAcknowledgement(&requestPacket)
if err != nil {
test.Error("Error Getting Acknowledgement:" + err.Error())
}
test.Log("--Acknowledgement Packet--")
test.Logf("Client IP : %v\n", acknowledgement.CIAddr().String())
test.Logf("Your IP : %v\n", acknowledgement.YIAddr().String())
test.Logf("Server IP : %v\n", acknowledgement.SIAddr().String())
test.Logf("Gateway IP: %v\n", acknowledgement.GIAddr().String())
test.Logf("Client Mac: %v\n", acknowledgement.CHAddr().String())
acknowledgementOptions := acknowledgement.ParseOptions()
if len(acknowledgementOptions[dhcp4.OptionDHCPMessageType]) <= 0 || dhcp4.MessageType(acknowledgementOptions[dhcp4.OptionDHCPMessageType][0]) != dhcp4.NAK {
test.Errorf("Didn't get NAK got DHCP4 Message Type:%v\n", dhcp4.MessageType(acknowledgementOptions[dhcp4.OptionDHCPMessageType][0]))
}
test.Log("Shutting Down Server")
myServer.Shutdown()
wg.Wait()
}
/*
*
*/
func TestConsumeLeases(test *testing.T) {
//Setup the Server
myServer, err := dhcp4server.New(
net.IPv4(127, 0, 0, 1),
getTestLeasePool(),
)
if err != nil {
test.Error("Error: Can't Configure Server " + err.Error())
}
// Setup A Client
// Although We Won't send the packets over the network we'll use the client to create the requests.
c, err := dhcp4client.NewInetSock(dhcp4client.SetLocalAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1068}), dhcp4client.SetRemoteAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1067}))
if err != nil {
test.Error("Client Conection Generation:" + err.Error())
}
client, err := dhcp4client.New(dhcp4client.Connection(c))
if err != nil {
test.Error("Error: Can't Configure Client " + err.Error())
}
defer client.Close()
for i := 0; i < 30; i++ {
//Generate Hardware Address
HardwareMACAddress, err := hardwareaddr.GenerateEUI48()
if err != nil {
test.Error("Error: Can't Generate Valid MACAddress" + err.Error())
}
client.SetOption(dhcp4client.HardwareAddr(HardwareMACAddress))
test.Log("MAC:" + HardwareMACAddress.String())
discovery := client.DiscoverPacket()
//Run the Discovery On the Server
offer, err := myServer.ServeDHCP(discovery)
_, err = myServer.ServeDHCP(discovery)
if err != nil {
test.Error("Discovery Error:" + err.Error())
}
request := client.RequestPacket(&offer)
acknowledgement, err := myServer.ServeDHCP(request)
if err != nil {
test.Error("Acknowledge Error:" + err.Error())
}
test.Logf("Received Lease:%v\n", acknowledgement.YIAddr().String())
if !dhcp4.IPAdd(net.IPv4(192, 168, 1, 1), i).Equal(acknowledgement.YIAddr()) {
test.Error("Expected IP:" + dhcp4.IPAdd(net.IPv4(192, 168, 1, 1), i).String() + " Received:" + acknowledgement.YIAddr().String())
}
//How long the lease is for?
acknowledgementOptions := acknowledgement.ParseOptions()
if len(acknowledgementOptions) > 0 {
test.Logf("Lease Options:%v\n", acknowledgementOptions)
if acknowledgementOptions[dhcp4.OptionIPAddressLeaseTime] != nil {
var result uint32
buf := bytes.NewBuffer(acknowledgementOptions[dhcp4.OptionIPAddressLeaseTime])
binary.Read(buf, binary.BigEndian, &result)
test.Logf("Lease Time (Seconds):%d\n", result)
}
} else {
test.Errorf("Lease:\"%v\" Has No Options\n", acknowledgement.YIAddr())
}
}
}
/*
* Benchmark the ServeDHCP Function
*/
func BenchmarkServeDHCP(test *testing.B) {
//Create a Lease Pool We're going to use a memory pool
//Remember the memory is cleared on restart so you will reissue the same IP Addresses.
myMemoryLeasePool := memorypool.MemoryPool{}
//Lets add a list of IPs to the pool these will be served to the clients so make sure they work for you.
// So Create Array of IPs 192.168.1.1 to 192.168.1.30
for i := 0; i < test.N; i++ {
err := myMemoryLeasePool.AddLease(leasepool.Lease{IP: dhcp4.IPAdd(net.IPv4(192, 168, 1, 1), i)})
if err != nil {
log.Fatalln("Error Adding IP to pool:" + err.Error())
}
}
//Setup the Server
myServer, err := dhcp4server.New(
net.IPv4(127, 0, 0, 1),
&myMemoryLeasePool,
)
if err != nil {
test.Error("Error: Can't Configure Server " + err.Error())
}
//Setup A Client
// Although We Won't send the packets over the network we'll use the client to create the requests.
c, err := dhcp4client.NewInetSock(dhcp4client.SetLocalAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1068}), dhcp4client.SetRemoteAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1067}))
if err != nil {
test.Error("Client Conection Generation:" + err.Error())
}
client, err := dhcp4client.New(dhcp4client.Connection(c))
if err != nil {
test.Error("Error: Can't Configure Client " + err.Error())
}
defer client.Close()
test.ResetTimer()
for i := 0; i < test.N; i++ {
test.StopTimer()
//Generate Hardware Address
HardwareMACAddress, err := hardwareaddr.GenerateEUI48()
if err != nil {
test.Error("Error: Can't Generate Valid MACAddress" + err.Error())
}
client.SetOption(dhcp4client.HardwareAddr(HardwareMACAddress))
discovery := client.DiscoverPacket()
//Run the Discovery On the Server
test.StartTimer()
offer, err := myServer.ServeDHCP(discovery)
if err != nil {
test.Error("Discovery Error:" + err.Error())
}
if len(offer) == 0 {
test.Error("No Valid Offer")
} else {
request := client.RequestPacket(&offer)
_, err := myServer.ServeDHCP(request)
if err != nil {
test.Error("Acknowledge Error:" + err.Error())
}
}
}
}
/*
*
*/
func TestLeaseByClientID(test *testing.T) {
//Setup the Server
myServer, err := dhcp4server.New(
net.IPv4(127, 0, 0, 1),
getTestLeasePool(),
)
if err != nil {
test.Error("Error: Can't Configure Server " + err.Error())
}
// Setup A Client
// Although We Won't send the packets over the network we'll use the client to create the requests.
c, err := dhcp4client.NewInetSock(dhcp4client.SetLocalAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1068}), dhcp4client.SetRemoteAddr(net.UDPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 1067}))
if err != nil {
test.Error("Client Conection Generation:" + err.Error())
}
client, err := dhcp4client.New(dhcp4client.Connection(c))
if err != nil {
test.Error("Error: Can't Configure Client " + err.Error())
}
defer client.Close()
//Generate Hardware Address; used by both clients
HardwareMACAddress, err := hardwareaddr.GenerateEUI48()
if err != nil {
test.Error("Error: Can't Generate Valid MACAddress" + err.Error())
}
for i := 0; i < 2; i++ {
client.SetOption(dhcp4client.HardwareAddr(HardwareMACAddress))
test.Log("MAC:" + HardwareMACAddress.String())
clientID := []byte(fmt.Sprintf("clientid-%d", i))
test.Log("ClientID:" + string(clientID))
discovery := client.DiscoverPacket()
discovery.AddOption(dhcp4.OptionClientIdentifier, clientID)
//Run the Discovery On the Server
offer, err := myServer.ServeDHCP(discovery)
_, err = myServer.ServeDHCP(discovery)
if err != nil {
test.Error("Discovery Error:" + err.Error())
}
request := client.RequestPacket(&offer)
request.AddOption(dhcp4.OptionClientIdentifier, clientID)
acknowledgement, err := myServer.ServeDHCP(request)
if err != nil {
test.Error("Acknowledge Error:" + err.Error())
}
test.Logf("Received Lease:%v\n", acknowledgement.YIAddr().String())
if !dhcp4.IPAdd(net.IPv4(192, 168, 1, 1), i).Equal(acknowledgement.YIAddr()) {
test.Error("Expected IP:" + dhcp4.IPAdd(net.IPv4(192, 168, 1, 1), i).String() + " Received:" + acknowledgement.YIAddr().String())
}
}
}
func getTestLeasePool() *memorypool.MemoryPool {
//Create a Lease Pool We're going to use a memory pool
//Remember the memory is cleared on restart so you will reissue the same IP Addresses.
myMemoryLeasePool := memorypool.MemoryPool{}
//Lets add a list of IPs to the pool these will be served to the clients so make sure they work for you.
// So Create Array of IPs 192.168.1.1 to 192.168.1.30
for i := 0; i < 30; i++ {
err := myMemoryLeasePool.AddLease(leasepool.Lease{IP: dhcp4.IPAdd(net.IPv4(192, 168, 1, 1), i)})
if err != nil {
log.Fatalln("Error Adding IP to pool:" + err.Error())
}
}
return &myMemoryLeasePool
}