func RequestIP(exampleClient *dhcp4client.Client) dhcp4.Packet {
// discoveryPacket, _ := exampleClient.SendDiscoverPacket()
// log.Println("Packet:%v\n", discoveryPacket)
// offerPacket, _ := exampleClient.GetOffer(&discoveryPacket)
// log.Println("Packet:%v\n", offerPacket)
// log.Println("OFFERED:" + offerPacket.YIAddr().String())
//return offerPacket.YIAddr().String()
//requestPacket, _ := exampleClient.SendRequest(&offerPacket)
//log.Println("Packet:%v\n", requestPacket)
success, acknowledgementpacket, err := exampleClient.Request()
if err != nil {
networkError, ok := err.(*net.OpError)
if ok && networkError.Timeout() {
log.Println("Test Skipping as it didn't find a DHCP Server")
}
log.Println("Error:%v\n", err)
}
log.Println("Success:%v\n", success)
log.Println("Packet:%v\n", acknowledgementpacket)
return acknowledgementpacket
// if !success {
// log.Fatalln("We didn't sucessfully get a DHCP Lease?")
// } else {
// log.Printf("IP Received:%v\n", acknowledgementpacket.YIAddr().String())
// return acknowledgementpacket.YIAddr().String()
// }
}
func (c *client) renew(cl *dhcp4client.Client) (dhcp4.Packet, error) {
defer trace.End(trace.Begin(""))
rp := cl.RenewalRequestPacket(&c.ack)
rp, err := c.setOptions(rp)
if err != nil {
return nil, err
}
rp.PadToMinSize()
if err = cl.SendPacket(rp); err != nil {
return nil, err
}
newack, err := cl.GetAcknowledgement(&rp)
if err != nil {
return nil, err
}
opts := newack.ParseOptions()
if dhcp4.MessageType(opts[dhcp4.OptionDHCPMessageType][0]) == dhcp4.NAK {
return nil, fmt.Errorf("received NAK from DHCP server")
}
return newack, nil
}
func (c *client) request(cl *dhcp4client.Client) (bool, dhcp4.Packet, error) {
defer trace.End(trace.Begin(""))
dp, err := c.discoverPacket(cl)
if err != nil {
return false, nil, err
}
dp.PadToMinSize()
if err = cl.SendPacket(dp); err != nil {
return false, nil, err
}
var op dhcp4.Packet
for {
op, err = cl.GetOffer(&dp)
if err != nil {
return false, nil, err
}
if c.isCompletePacket(dhcp.NewPacket([]byte(op))) {
break
}
}
rp, err := c.requestPacket(cl, &op)
if err != nil {
return false, nil, err
}
rp.PadToMinSize()
if err = cl.SendPacket(rp); err != nil {
return false, nil, err
}
ack, err := cl.GetAcknowledgement(&rp)
if err != nil {
return false, nil, err
}
opts := ack.ParseOptions()
if dhcp4.MessageType(opts[dhcp4.OptionDHCPMessageType][0]) == dhcp4.NAK {
return false, nil, fmt.Errorf("Got NAK from DHCP server")
}
return true, ack, nil
}
func (c *client) renew(id ID, ack dhcp4.Packet, cl *dhcp4client.Client) (dhcp4.Packet, error) {
rp := cl.RenewalRequestPacket(&ack)
_, err := c.appendOptions(&rp, id)
if err != nil {
return nil, err
}
rp.PadToMinSize()
if err = cl.SendPacket(rp); err != nil {
return nil, err
}
newack, err := cl.GetAcknowledgement(&rp)
if err != nil {
return nil, err
}
opts := newack.ParseOptions()
if dhcp4.MessageType(opts[dhcp4.OptionDHCPMessageType][0]) == dhcp4.NAK {
return nil, fmt.Errorf("received NAK from DHCP server")
}
return newack, nil
}
func SendDHCPDeclinePacket(c *dhcp4client.Client, hw net.HardwareAddr, ip net.IP, acknowledgement dhcp4.Packet) (dhcp4.Packet, error) {
DeclinePacket := DHCPDeclinePacket(hw, ip, acknowledgement)
DeclinePacket.PadToMinSize()
return DeclinePacket, c.SendPacket(DeclinePacket)
}
func (c *client) requestPacket(cl *dhcp4client.Client, op *dhcp4.Packet) (dhcp4.Packet, error) {
defer trace.End(trace.Begin(""))
rp := cl.RequestPacket(op)
return c.setOptions(rp)
}
func (c *client) discoverPacket(cl *dhcp4client.Client) (dhcp4.Packet, error) {
defer trace.End(trace.Begin(""))
dp := cl.DiscoverPacket()
return c.setOptions(dp)
}
func (c *client) requestPacket(id ID, cl *dhcp4client.Client, op *dhcp4.Packet) (*dhcp4.Packet, error) {
rp := cl.RequestPacket(op)
return c.appendOptions(&rp, id)
}
func (c *client) discoverPacket(id ID, cl *dhcp4client.Client) (*dhcp4.Packet, error) {
dp := cl.DiscoverPacket()
return c.appendOptions(&dp, id)
}
