150 lines
4.6 KiB
Go
150 lines
4.6 KiB
Go
package dhcp4
|
|
|
|
import (
|
|
"net"
|
|
"time"
|
|
)
|
|
|
|
// A DHCP packet
|
|
type Packet []byte
|
|
|
|
func (p Packet) OpCode() OpCode { return OpCode(p[0]) }
|
|
func (p Packet) HType() byte { return p[1] }
|
|
func (p Packet) HLen() byte { return p[2] }
|
|
func (p Packet) Hops() byte { return p[3] }
|
|
func (p Packet) XId() []byte { return p[4:8] }
|
|
func (p Packet) Secs() []byte { return p[8:10] } // Never Used?
|
|
func (p Packet) Flags() []byte { return p[10:12] }
|
|
func (p Packet) CIAddr() net.IP { return net.IP(p[12:16]) }
|
|
func (p Packet) YIAddr() net.IP { return net.IP(p[16:20]) }
|
|
func (p Packet) SIAddr() net.IP { return net.IP(p[20:24]) }
|
|
func (p Packet) GIAddr() net.IP { return net.IP(p[24:28]) }
|
|
func (p Packet) CHAddr() net.HardwareAddr {
|
|
hLen := p.HLen()
|
|
if hLen > 16 { // Prevent chaddr exceeding p boundary
|
|
hLen = 16
|
|
}
|
|
return net.HardwareAddr(p[28 : 28+hLen]) // max endPos 44
|
|
}
|
|
|
|
// 192 bytes of zeros BOOTP legacy
|
|
func (p Packet) Cookie() []byte { return p[236:240] }
|
|
func (p Packet) Options() []byte {
|
|
if len(p) > 240 {
|
|
return p[240:]
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p Packet) Broadcast() bool { return p.Flags()[0] > 127 }
|
|
|
|
func (p Packet) SetBroadcast(broadcast bool) {
|
|
if p.Broadcast() != broadcast {
|
|
p.Flags()[0] ^= 128
|
|
}
|
|
}
|
|
|
|
func (p Packet) SetOpCode(c OpCode) { p[0] = byte(c) }
|
|
func (p Packet) SetCHAddr(a net.HardwareAddr) {
|
|
copy(p[28:44], a)
|
|
p[2] = byte(len(a))
|
|
}
|
|
func (p Packet) SetHType(hType byte) { p[1] = hType }
|
|
func (p Packet) SetCookie(cookie []byte) { copy(p.Cookie(), cookie) }
|
|
func (p Packet) SetHops(hops byte) { p[3] = hops }
|
|
func (p Packet) SetXId(xId []byte) { copy(p.XId(), xId) }
|
|
func (p Packet) SetSecs(secs []byte) { copy(p.Secs(), secs) }
|
|
func (p Packet) SetFlags(flags []byte) { copy(p.Flags(), flags) }
|
|
func (p Packet) SetCIAddr(ip net.IP) { copy(p.CIAddr(), ip.To4()) }
|
|
func (p Packet) SetYIAddr(ip net.IP) { copy(p.YIAddr(), ip.To4()) }
|
|
func (p Packet) SetSIAddr(ip net.IP) { copy(p.SIAddr(), ip.To4()) }
|
|
func (p Packet) SetGIAddr(ip net.IP) { copy(p.GIAddr(), ip.To4()) }
|
|
|
|
// Parses the packet's options into an Options map
|
|
func (p Packet) ParseOptions() Options {
|
|
opts := p.Options()
|
|
options := make(Options, 10)
|
|
for len(opts) >= 2 && OptionCode(opts[0]) != End {
|
|
if OptionCode(opts[0]) == Pad {
|
|
opts = opts[1:]
|
|
continue
|
|
}
|
|
size := int(opts[1])
|
|
if len(opts) < 2+size {
|
|
break
|
|
}
|
|
options[OptionCode(opts[0])] = opts[2 : 2+size]
|
|
opts = opts[2+size:]
|
|
}
|
|
return options
|
|
}
|
|
|
|
func NewPacket(opCode OpCode) Packet {
|
|
p := make(Packet, 241)
|
|
p.SetOpCode(opCode)
|
|
p.SetHType(1) // Ethernet
|
|
p.SetCookie([]byte{99, 130, 83, 99})
|
|
p[240] = byte(End)
|
|
return p
|
|
}
|
|
|
|
// Appends a DHCP option to the end of a packet
|
|
func (p *Packet) AddOption(o OptionCode, value []byte) {
|
|
*p = append((*p)[:len(*p)-1], []byte{byte(o), byte(len(value))}...) // Strip off End, Add OptionCode and Length
|
|
*p = append(*p, value...) // Add Option Value
|
|
*p = append(*p, byte(End)) // Add on new End
|
|
}
|
|
|
|
// Removes all options from packet.
|
|
func (p *Packet) StripOptions() {
|
|
*p = append((*p)[:240], byte(End))
|
|
}
|
|
|
|
// Creates a request packet that a Client would send to a server.
|
|
func RequestPacket(mt MessageType, chAddr net.HardwareAddr, cIAddr net.IP, xId []byte, broadcast bool, options []Option) Packet {
|
|
p := NewPacket(BootRequest)
|
|
p.SetCHAddr(chAddr)
|
|
p.SetXId(xId)
|
|
if cIAddr != nil {
|
|
p.SetCIAddr(cIAddr)
|
|
}
|
|
p.SetBroadcast(broadcast)
|
|
p.AddOption(OptionDHCPMessageType, []byte{byte(mt)})
|
|
for _, o := range options {
|
|
p.AddOption(o.Code, o.Value)
|
|
}
|
|
p.PadToMinSize()
|
|
return p
|
|
}
|
|
|
|
// ReplyPacket creates a reply packet that a Server would send to a client.
|
|
// It uses the req Packet param to copy across common/necessary fields to
|
|
// associate the reply the request.
|
|
func ReplyPacket(req Packet, mt MessageType, serverId, yIAddr net.IP, leaseDuration time.Duration, options []Option) Packet {
|
|
p := NewPacket(BootReply)
|
|
p.SetXId(req.XId())
|
|
p.SetFlags(req.Flags())
|
|
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))
|
|
p.AddOption(OptionIPAddressLeaseTime, OptionsLeaseTime(leaseDuration))
|
|
for _, o := range options {
|
|
p.AddOption(o.Code, o.Value)
|
|
}
|
|
p.PadToMinSize()
|
|
return p
|
|
}
|
|
|
|
// PadToMinSize pads a packet so that when sent over UDP, the entire packet,
|
|
// is 300 bytes (BOOTP min), to be compatible with really old devices.
|
|
var padder [272]byte
|
|
|
|
func (p *Packet) PadToMinSize() {
|
|
if n := len(*p); n < 272 {
|
|
*p = append(*p, padder[:272-n]...)
|
|
}
|
|
}
|