diff options
76 files changed, 1593 insertions, 442 deletions
diff --git a/dhcpv4/client.go b/dhcpv4/client.go index 4b10240..8a44338 100644 --- a/dhcpv4/client.go +++ b/dhcpv4/client.go @@ -124,8 +124,8 @@ func MakeListeningSocket(ifname string) (int, error) { // ordered as Discovery, Offer, Request and Acknowledge. In case of errors, an // error is returned, and the list of DHCPv4 objects will be shorted than 4, // containing all the sent and received DHCPv4 messages. -func (c *Client) Exchange(ifname string, discover *DHCPv4) ([]DHCPv4, error) { - conversation := make([]DHCPv4, 1) +func (c *Client) Exchange(ifname string, discover *DHCPv4, modifiers ...Modifier) ([]*DHCPv4, error) { + conversation := make([]*DHCPv4, 1) var err error // Get our file descriptor for the broadcast socket. @@ -149,28 +149,31 @@ func (c *Client) Exchange(ifname string, discover *DHCPv4) ([]DHCPv4, error) { return conversation, err } } - conversation[0] = *discover + for _, mod := range modifiers { + discover = mod(discover) + } + conversation[0] = discover // Offer offer, err := BroadcastSendReceive(sfd, rfd, discover, c.ReadTimeout, c.WriteTimeout, MessageTypeOffer) if err != nil { return conversation, err } - conversation = append(conversation, *offer) + conversation = append(conversation, offer) // Request - request, err := RequestFromOffer(*offer) + request, err := NewRequestFromOffer(offer, modifiers...) if err != nil { return conversation, err } - conversation = append(conversation, *request) + conversation = append(conversation, request) // Ack ack, err := BroadcastSendReceive(sfd, rfd, request, c.ReadTimeout, c.WriteTimeout, MessageTypeAck) if err != nil { return conversation, err } - conversation = append(conversation, *ack) + conversation = append(conversation, ack) return conversation, nil } diff --git a/dhcpv4/dhcpv4.go b/dhcpv4/dhcpv4.go index eb0f467..d452f6e 100644 --- a/dhcpv4/dhcpv4.go +++ b/dhcpv4/dhcpv4.go @@ -38,6 +38,10 @@ type DHCPv4 struct { options []Option } +// Modifier defines the signature for functions that can modify DHCPv4 +// structures. This is used to simplify packet manipulation +type Modifier func(d *DHCPv4) *DHCPv4 + // GetExternalIPv4Addrs obtains the currently-configured, non-loopback IPv4 // addresses from `addrs` coming from a particular interface (e.g. // net.Interface.Addrs). @@ -157,8 +161,8 @@ func NewInform(hwaddr net.HardwareAddr, localIP net.IP) (*DHCPv4, error) { return d, nil } -// RequestFromOffer builds a DHCPv4 request from an offer. -func RequestFromOffer(offer DHCPv4) (*DHCPv4, error) { +// NewRequestFromOffer builds a DHCPv4 request from an offer. +func NewRequestFromOffer(offer *DHCPv4, modifiers ...Modifier) (*DHCPv4, error) { d, err := New() if err != nil { return nil, err @@ -188,11 +192,14 @@ func RequestFromOffer(offer DHCPv4) (*DHCPv4, error) { d.AddOption(&OptMessageType{MessageType: MessageTypeRequest}) d.AddOption(&OptRequestedIPAddress{RequestedAddr: offer.YourIPAddr()}) d.AddOption(&OptServerIdentifier{ServerID: serverIP}) + for _, mod := range modifiers { + d = mod(d) + } return d, nil } // NewReplyFromRequest builds a DHCPv4 reply from a request. -func NewReplyFromRequest(request *DHCPv4) (*DHCPv4, error) { +func NewReplyFromRequest(request *DHCPv4, modifiers ...Modifier) (*DHCPv4, error) { reply, err := New() if err != nil { return nil, err @@ -205,6 +212,9 @@ func NewReplyFromRequest(request *DHCPv4) (*DHCPv4, error) { reply.SetTransactionID(request.TransactionID()) reply.SetFlags(request.Flags()) reply.SetGatewayIPAddr(request.GatewayIPAddr()) + for _, mod := range modifiers { + reply = mod(reply) + } return reply, nil } @@ -664,10 +674,10 @@ func (d *DHCPv4) ToBytes() []byte { ret = append(ret, u16...) binary.BigEndian.PutUint16(u16, d.flags) ret = append(ret, u16...) - ret = append(ret, d.clientIPAddr[:4]...) - ret = append(ret, d.yourIPAddr[:4]...) - ret = append(ret, d.serverIPAddr[:4]...) - ret = append(ret, d.gatewayIPAddr[:4]...) + ret = append(ret, d.clientIPAddr.To4()...) + ret = append(ret, d.yourIPAddr.To4()...) + ret = append(ret, d.serverIPAddr.To4()...) + ret = append(ret, d.gatewayIPAddr.To4()...) ret = append(ret, d.clientHwAddr[:16]...) ret = append(ret, d.serverHostName[:64]...) ret = append(ret, d.bootFileName[:128]...) diff --git a/dhcpv4/dhcpv4_test.go b/dhcpv4/dhcpv4_test.go index e0afaba..fe9fe0d 100644 --- a/dhcpv4/dhcpv4_test.go +++ b/dhcpv4/dhcpv4_test.go @@ -389,19 +389,19 @@ func TestStrippedOptions(t *testing.T) { } } -func TestRequestFromOffer(t *testing.T) { +func TestDHCPv4NewRequestFromOffer(t *testing.T) { offer, err := New() require.NoError(t, err) offer.SetBroadcast() offer.AddOption(&OptMessageType{MessageType: MessageTypeOffer}) - req, err := RequestFromOffer(*offer) + req, err := NewRequestFromOffer(offer) require.Error(t, err) // Now add the option so it doesn't error out. offer.AddOption(&OptServerIdentifier{ServerID: net.IPv4(192, 168, 0, 1)}) // Broadcast request - req, err = RequestFromOffer(*offer) + req, err = NewRequestFromOffer(offer) require.NoError(t, err) require.NotNil(t, req.MessageType()) require.Equal(t, MessageTypeRequest, *req.MessageType()) @@ -410,12 +410,25 @@ func TestRequestFromOffer(t *testing.T) { // Unicast request offer.SetUnicast() - req, err = RequestFromOffer(*offer) + req, err = NewRequestFromOffer(offer) require.NoError(t, err) require.True(t, req.IsUnicast()) require.False(t, req.IsBroadcast()) } +func TestDHCPv4NewRequestFromOfferWithModifier(t *testing.T) { + offer, err := New() + require.NoError(t, err) + offer.AddOption(&OptMessageType{MessageType: MessageTypeOffer}) + offer.AddOption(&OptServerIdentifier{ServerID: net.IPv4(192, 168, 0, 1)}) + userClass := WithUserClass([]byte("linuxboot"), false) + req, err := NewRequestFromOffer(offer, userClass) + require.NoError(t, err) + require.NotEqual(t, (*MessageType)(nil), *req.MessageType()) + require.Equal(t, MessageTypeRequest, *req.MessageType()) + require.Equal(t, "User Class Information -> linuxboot", req.options[3].String()) +} + func TestNewReplyFromRequest(t *testing.T) { discover, err := New() require.NoError(t, err) @@ -426,7 +439,19 @@ func TestNewReplyFromRequest(t *testing.T) { require.Equal(t, discover.GatewayIPAddr(), reply.GatewayIPAddr()) } -func TestMessageTypeNil(t *testing.T) { +func TestNewReplyFromRequestWithModifier(t *testing.T) { + discover, err := New() + require.NoError(t, err) + discover.SetGatewayIPAddr(net.IPv4(192, 168, 0, 1)) + userClass := WithUserClass([]byte("linuxboot"), false) + reply, err := NewReplyFromRequest(discover, userClass) + require.NoError(t, err) + require.Equal(t, discover.TransactionID(), reply.TransactionID()) + require.Equal(t, discover.GatewayIPAddr(), reply.GatewayIPAddr()) + require.Equal(t, "User Class Information -> linuxboot", reply.options[0].String()) +} + +func TestDHCPv4MessageTypeNil(t *testing.T) { m, err := New() require.NoError(t, err) require.Nil(t, m.MessageType()) diff --git a/dhcpv4/modifiers.go b/dhcpv4/modifiers.go new file mode 100644 index 0000000..3b6ce70 --- /dev/null +++ b/dhcpv4/modifiers.go @@ -0,0 +1,49 @@ +package dhcpv4 + +// WithUserClass adds a user class option to the packet. +// The rfc parameter allows you to specify if the userclass should be +// rfc compliant or not. More details in issue #113 +func WithUserClass(uc []byte, rfc bool) Modifier { + // TODO let the user specify multiple user classes + return func(d *DHCPv4) *DHCPv4 { + ouc := OptUserClass{ + UserClasses: [][]byte{uc}, + Rfc3004: rfc, + } + d.AddOption(&ouc) + return d + } +} + +// WithNetboot adds bootfile URL and bootfile param options to a DHCPv4 packet. +func WithNetboot(d *DHCPv4) *DHCPv4 { + params := d.GetOneOption(OptionParameterRequestList) + + var ( + OptParams *OptParameterRequestList + foundOptionTFTPServerName bool + foundOptionBootfileName bool + ) + if params != nil { + OptParams = params.(*OptParameterRequestList) + for _, option := range OptParams.RequestedOpts { + if option == OptionTFTPServerName { + foundOptionTFTPServerName = true + } else if option == OptionBootfileName { + foundOptionBootfileName = true + } + } + if !foundOptionTFTPServerName { + OptParams.RequestedOpts = append(OptParams.RequestedOpts, OptionTFTPServerName) + } + if !foundOptionBootfileName { + OptParams.RequestedOpts = append(OptParams.RequestedOpts, OptionBootfileName) + } + } else { + OptParams = &OptParameterRequestList{ + RequestedOpts: []OptionCode{OptionTFTPServerName, OptionBootfileName}, + } + d.AddOption(OptParams) + } + return d +} diff --git a/dhcpv4/modifiers_test.go b/dhcpv4/modifiers_test.go new file mode 100644 index 0000000..2f0e1ed --- /dev/null +++ b/dhcpv4/modifiers_test.go @@ -0,0 +1,69 @@ +package dhcpv4 + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestUserClassModifier(t *testing.T) { + d, _ := New() + userClass := WithUserClass([]byte("linuxboot"), false) + d = userClass(d) + expected := []byte{ + 77, // OptionUserClass + 9, // length + 'l', 'i', 'n', 'u', 'x', 'b', 'o', 'o', 't', + } + require.Equal(t, "User Class Information -> linuxboot", d.options[0].String()) + require.Equal(t, expected, d.options[0].ToBytes()) +} + +func TestUserClassModifierRFC(t *testing.T) { + d, _ := New() + userClass := WithUserClass([]byte("linuxboot"), true) + d = userClass(d) + expected := []byte{ + 77, // OptionUserClass + 10, // length + 9, 'l', 'i', 'n', 'u', 'x', 'b', 'o', 'o', 't', + } + require.Equal(t, "User Class Information -> linuxboot", d.options[0].String()) + require.Equal(t, expected, d.options[0].ToBytes()) +} + +func TestWithNetboot(t *testing.T) { + d, _ := New() + d = WithNetboot(d) + require.Equal(t, "Parameter Request List -> [TFTP Server Name, Bootfile Name]", d.options[0].String()) +} + +func TestWithNetbootExistingTFTP(t *testing.T) { + d, _ := New() + OptParams := &OptParameterRequestList{ + RequestedOpts: []OptionCode{OptionTFTPServerName}, + } + d.AddOption(OptParams) + d = WithNetboot(d) + require.Equal(t, "Parameter Request List -> [TFTP Server Name, Bootfile Name]", d.options[0].String()) +} + +func TestWithNetbootExistingBootfileName(t *testing.T) { + d, _ := New() + OptParams := &OptParameterRequestList{ + RequestedOpts: []OptionCode{OptionBootfileName}, + } + d.AddOption(OptParams) + d = WithNetboot(d) + require.Equal(t, "Parameter Request List -> [Bootfile Name, TFTP Server Name]", d.options[0].String()) +} + +func TestWithNetbootExistingBoth(t *testing.T) { + d, _ := New() + OptParams := &OptParameterRequestList{ + RequestedOpts: []OptionCode{OptionBootfileName, OptionTFTPServerName}, + } + d.AddOption(OptParams) + d = WithNetboot(d) + require.Equal(t, "Parameter Request List -> [Bootfile Name, TFTP Server Name]", d.options[0].String()) +} diff --git a/dhcpv4/option_archtype.go b/dhcpv4/option_archtype.go new file mode 100644 index 0000000..16ca98d --- /dev/null +++ b/dhcpv4/option_archtype.go @@ -0,0 +1,109 @@ +package dhcpv4 + +// This option implements the Client System Architecture Type option +// https://tools.ietf.org/html/rfc4578 + +import ( + "encoding/binary" + "fmt" +) + +//ArchType encodes an architecture type in an uint16 +type ArchType uint16 + +// see rfc4578 +const ( + INTEL_X86PC ArchType = 0 + NEC_PC98 ArchType = 1 + EFI_ITANIUM ArchType = 2 + DEC_ALPHA ArchType = 3 + ARC_X86 ArchType = 4 + INTEL_LEAN_CLIENT ArchType = 5 + EFI_IA32 ArchType = 6 + EFI_BC ArchType = 7 + EFI_XSCALE ArchType = 8 + EFI_X86_64 ArchType = 9 +) + +// ArchTypeToStringMap maps an ArchType to a mnemonic name +var ArchTypeToStringMap = map[ArchType]string{ + INTEL_X86PC: "Intel x86PC", + NEC_PC98: "NEC/PC98", + EFI_ITANIUM: "EFI Itanium", + DEC_ALPHA: "DEC Alpha", + ARC_X86: "Arc x86", + INTEL_LEAN_CLIENT: "Intel Lean Client", + EFI_IA32: "EFI IA32", + EFI_BC: "EFI BC", + EFI_XSCALE: "EFI Xscale", + EFI_X86_64: "EFI x86-64", +} + +// OptClientArchType represents an option encapsulating the Client System +// Architecture Type option Definition. +type OptClientArchType struct { + ArchTypes []ArchType +} + +// Code returns the option code. +func (o *OptClientArchType) Code() OptionCode { + return OptionClientSystemArchitectureType +} + +// ToBytes returns a serialized stream of bytes for this option. +func (o *OptClientArchType) ToBytes() []byte { + ret := []byte{byte(o.Code()), byte(o.Length())} + for _, at := range o.ArchTypes { + buf := make([]byte, 2) + binary.BigEndian.PutUint16(buf[0:2], uint16(at)) + ret = append(ret, buf...) + } + return ret +} + +// Length returns the length of the data portion (excluding option code an byte +// length). +func (o *OptClientArchType) Length() int { + return 2*len(o.ArchTypes) +} + +// String returns a human-readable string. +func (o *OptClientArchType) String() string { + var archTypes string + for idx, at := range o.ArchTypes { + name, ok := ArchTypeToStringMap[at] + if !ok { + name = "Unknown" + } + archTypes += name + if idx < len(o.ArchTypes)-1 { + archTypes += ", " + } + } + return fmt.Sprintf("Client System Architecture Type -> %v", archTypes) +} + +// ParseOptClientArchType returns a new OptClientArchType from a byte stream, +// or error if any. +func ParseOptClientArchType(data []byte) (*OptClientArchType, error) { + if len(data) < 2 { + return nil, ErrShortByteStream + } + code := OptionCode(data[0]) + if code != OptionClientSystemArchitectureType { + return nil, fmt.Errorf("expected code %v, got %v", OptionClientSystemArchitectureType, code) + } + length := int(data[1]) + if length == 0 || length%2 != 0 { + return nil, fmt.Errorf("Invalid length: expected multiple of 2 larger than 2, got %v", length) + } + if len(data) < 2+length { + return nil, ErrShortByteStream + } + archTypes := make([]ArchType, 0, length%2) + for idx := 0; idx < length; idx += 2 { + b := data[2+idx : 2+idx+2] + archTypes = append(archTypes, ArchType(binary.BigEndian.Uint16(b))) + } + return &OptClientArchType{ArchTypes: archTypes}, nil +} diff --git a/dhcpv4/option_archtype_test.go b/dhcpv4/option_archtype_test.go new file mode 100644 index 0000000..cb9bc3f --- /dev/null +++ b/dhcpv4/option_archtype_test.go @@ -0,0 +1,68 @@ +package dhcpv4 + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestParseOptClientArchType(t *testing.T) { + data := []byte{ + 93, // OptionClientSystemArchitectureType + 2, // Length + 0, 6, // EFI_IA32 + } + opt, err := ParseOptClientArchType(data) + require.NoError(t, err) + require.Equal(t, opt.ArchTypes[0], EFI_IA32) +} + +func TestParseOptClientArchTypeMultiple(t *testing.T) { + data := []byte{ + 93, // OptionClientSystemArchitectureType + 4, // Length + 0, 6, // EFI_IA32 + 0, 2, // EFI_ITANIUM + } + opt, err := ParseOptClientArchType(data) + require.NoError(t, err) + require.Equal(t, opt.ArchTypes[0], EFI_IA32) + require.Equal(t, opt.ArchTypes[1], EFI_ITANIUM) +} + +func TestParseOptClientArchTypeInvalid(t *testing.T) { + data := []byte{42} + _, err := ParseOptClientArchType(data) + require.Error(t, err) +} + +func TestOptClientArchTypeParseAndToBytes(t *testing.T) { + data := []byte{ + 93, // OptionClientSystemArchitectureType + 2, // Length + 0, 8, // EFI_XSCALE + } + opt, err := ParseOptClientArchType(data) + require.NoError(t, err) + require.Equal(t, opt.ToBytes(), data) +} + +func TestOptClientArchTypeParseAndToBytesMultiple(t *testing.T) { + data := []byte{ + 93, // OptionClientSystemArchitectureType + 4, // Length + 0, 8, // EFI_XSCALE + 0, 6, // EFI_IA32 + } + opt, err := ParseOptClientArchType(data) + require.NoError(t, err) + require.Equal(t, opt.ToBytes(), data) +} + +func TestOptClientArchType(t *testing.T) { + opt := OptClientArchType{ + ArchTypes: []ArchType{EFI_ITANIUM}, + } + require.Equal(t, opt.Length(), 2) + require.Equal(t, opt.Code(), OptionClientSystemArchitectureType) +} diff --git a/dhcpv4/option_bootfile_name.go b/dhcpv4/option_bootfile_name.go index 73ea625..ca9317b 100644 --- a/dhcpv4/option_bootfile_name.go +++ b/dhcpv4/option_bootfile_name.go @@ -28,7 +28,7 @@ func (op *OptBootfileName) Length() int { } func (op *OptBootfileName) String() string { - return fmt.Sprintf("OptBootfileName{BootfileName=%s}", op.BootfileName) + return fmt.Sprintf("Bootfile Name -> %s", op.BootfileName) } diff --git a/dhcpv4/option_bootfile_name_test.go b/dhcpv4/option_bootfile_name_test.go index 1f66807..0c7c200 100644 --- a/dhcpv4/option_bootfile_name_test.go +++ b/dhcpv4/option_bootfile_name_test.go @@ -58,3 +58,8 @@ func TestParseOptBootfileNameShortLength(t *testing.T) { require.NoError(t, err) require.Equal(t, []byte("linu"), opt.BootfileName) } + +func TestOptBootfileNameString(t *testing.T) { + o := OptBootfileName{BootfileName: []byte("testy test")} + require.Equal(t, "Bootfile Name -> testy test", o.String()) +} diff --git a/dhcpv4/option_domain_name.go b/dhcpv4/option_domain_name.go index 71d7ef1..e876b05 100644 --- a/dhcpv4/option_domain_name.go +++ b/dhcpv4/option_domain_name.go @@ -2,10 +2,10 @@ package dhcpv4 import "fmt" -// This option implements the server domani name option +// This option implements the domain name option // https://tools.ietf.org/html/rfc2132 -// OptDomainName represents an option encapsulating the server identifier. +// OptDomainName represents an option encapsulating the domain name. type OptDomainName struct { DomainName string } @@ -13,7 +13,7 @@ type OptDomainName struct { // ParseOptDomainName returns a new OptDomainName from a byte // stream, or error if any. func ParseOptDomainName(data []byte) (*OptDomainName, error) { - if len(data) < 2 { + if len(data) < 3 { return nil, ErrShortByteStream } code := OptionCode(data[0]) diff --git a/dhcpv4/option_domain_name_server.go b/dhcpv4/option_domain_name_server.go index 78aaf90..470eaa0 100644 --- a/dhcpv4/option_domain_name_server.go +++ b/dhcpv4/option_domain_name_server.go @@ -48,7 +48,7 @@ func (o *OptDomainNameServer) Code() OptionCode { func (o *OptDomainNameServer) ToBytes() []byte { ret := []byte{byte(o.Code()), byte(o.Length())} for _, ns := range o.NameServers { - ret = append(ret, ns...) + ret = append(ret, ns.To4()...) } return ret } diff --git a/dhcpv4/option_domain_search.go b/dhcpv4/option_domain_search.go new file mode 100644 index 0000000..daade0a --- /dev/null +++ b/dhcpv4/option_domain_search.go @@ -0,0 +1,63 @@ +package dhcpv4 + +// This module defines the OptDomainSearch structure. +// https://tools.ietf.org/html/rfc3397 + +import ( + "fmt" + + "github.com/insomniacslk/dhcp/rfc1035label" +) + +// OptDomainSearch represents an option encapsulating a domain search list. +type OptDomainSearch struct { + DomainSearch []string +} + +// Code returns the option code. +func (op *OptDomainSearch) Code() OptionCode { + return OptionDNSDomainSearchList +} + +// ToBytes returns a serialized stream of bytes for this option. +func (op *OptDomainSearch) ToBytes() []byte { + buf := []byte{byte(op.Code()), byte(op.Length())} + buf = append(buf, rfc1035label.LabelsToBytes(op.DomainSearch)...) + return buf +} + +// Length returns the length of the data portion (excluding option code an byte +// length). +func (op *OptDomainSearch) Length() int { + var length int + for _, label := range op.DomainSearch { + length += len(label) + 2 // add the first and the last length bytes + } + return length +} + +// String returns a human-readable string. +func (op *OptDomainSearch) String() string { + return fmt.Sprintf("DNS Domain Search List -> %v", op.DomainSearch) +} + +// ParseOptDomainSearch returns a new OptDomainSearch from a byte stream, or +// error if any. +func ParseOptDomainSearch(data []byte) (*OptDomainSearch, error) { + if len(data) < 2 { + return nil, ErrShortByteStream + } + code := OptionCode(data[0]) + if code != OptionDNSDomainSearchList { + return nil, fmt.Errorf("expected code %v, got %v", OptionDNSDomainSearchList, code) + } + length := int(data[1]) + if len(data) < 2+length { + return nil, ErrShortByteStream + } + domainSearch, err := rfc1035label.LabelsFromBytes(data[2:length+2]) + if err != nil { + return nil, err + } + return &OptDomainSearch{DomainSearch: domainSearch}, nil +} diff --git a/dhcpv4/option_domain_search_test.go b/dhcpv4/option_domain_search_test.go new file mode 100644 index 0000000..4848a83 --- /dev/null +++ b/dhcpv4/option_domain_search_test.go @@ -0,0 +1,37 @@ +package dhcpv4 + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestParseOptDomainSearch(t *testing.T) { + data := []byte{ + 119, // OptionDNSDomainSearchList + 33, // length + 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0, + 6, 's', 'u', 'b', 'n', 'e', 't', 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'o', 'r', 'g', 0, + } + opt, err := ParseOptDomainSearch(data) + require.NoError(t, err) + require.Equal(t, len(opt.DomainSearch), 2) + require.Equal(t, opt.DomainSearch[0], "example.com") + require.Equal(t, opt.DomainSearch[1], "subnet.example.org") +} + +func TestOptDomainSearchToBytes(t *testing.T) { + expected := []byte{ + 119, // OptionDNSDomainSearchList + 33, // length + 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0, + 6, 's', 'u', 'b', 'n', 'e', 't', 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'o', 'r', 'g', 0, + } + opt := OptDomainSearch{ + DomainSearch: []string{ + "example.com", + "subnet.example.org", + }, + } + require.Equal(t, opt.ToBytes(), expected) +} diff --git a/dhcpv4/option_host_name.go b/dhcpv4/option_host_name.go new file mode 100644 index 0000000..a922a2b --- /dev/null +++ b/dhcpv4/option_host_name.go @@ -0,0 +1,49 @@ +package dhcpv4 + +import "fmt" + +// This option implements the host name option +// https://tools.ietf.org/html/rfc2132 + +// OptHostName represents an option encapsulating the host name. +type OptHostName struct { + HostName string +} + +// ParseOptHostName returns a new OptHostName from a byte stream, or error if +// any. +func ParseOptHostName(data []byte) (*OptHostName, error) { + if len(data) < 3 { + return nil, ErrShortByteStream + } + code := OptionCode(data[0]) + if code != OptionHostName { + return nil, fmt.Errorf("expected code %v, got %v", OptionHostName, code) + } + length := int(data[1]) + if len(data) < 2+length { + return nil, ErrShortByteStream + } + return &OptHostName{HostName: string(data[2 : 2+length])}, nil +} + +// Code returns the option code. +func (o *OptHostName) Code() OptionCode { + return OptionHostName +} + +// ToBytes returns a serialized stream of bytes for this option. +func (o *OptHostName) ToBytes() []byte { + return append([]byte{byte(o.Code()), byte(o.Length())}, []byte(o.HostName)...) +} + +// String returns a human-readable string. +func (o *OptHostName) String() string { + return fmt.Sprintf("Host Name -> %v", o.HostName) +} + +// Length returns the length of the data portion (excluding option code an byte +// length). +func (o *OptHostName) Length() int { + return len(o.HostName) +} diff --git a/dhcpv4/option_host_name_test.go b/dhcpv4/option_host_name_test.go new file mode 100644 index 0000000..7f99100 --- /dev/null +++ b/dhcpv4/option_host_name_test.go @@ -0,0 +1,41 @@ +package dhcpv4 + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestOptHostNameInterfaceMethods(t *testing.T) { + o := OptHostName{HostName: "foo"} + require.Equal(t, OptionHostName, o.Code(), "Code") + require.Equal(t, 3, o.Length(), "Length") + require.Equal(t, []byte{byte(OptionHostName), 3, 'f', 'o', 'o'}, o.ToBytes(), "ToBytes") +} + +func TestParseOptHostName(t *testing.T) { + data := []byte{byte(OptionHostName), 4, 't', 'e', 's', 't'} + o, err := ParseOptHostName(data) + require.NoError(t, err) + require.Equal(t, &OptHostName{HostName: "test"}, o) + + // Short byte stream + data = []byte{byte(OptionHostName)} + _, err = ParseOptHostName(data) + require.Error(t, err, "should get error from short byte stream") + + // Wrong code + data = []byte{54, 2, 1, 1} + _, err = ParseOptHostName(data) + require.Error(t, err, "should get error from wrong code") + + // Bad length + data = []byte{byte(OptionHostName), 6, 1, 1, 1} + _, err = ParseOptHostName(data) + require.Error(t, err, "should get error from bad length") +} + +func TestOptHostNameString(t *testing.T) { + o := OptHostName{HostName: "testy test"} + require.Equal(t, "Host Name -> testy test", o.String()) +} diff --git a/dhcpv4/option_ip_address_lease_time.go b/dhcpv4/option_ip_address_lease_time.go new file mode 100644 index 0000000..7562c58 --- /dev/null +++ b/dhcpv4/option_ip_address_lease_time.go @@ -0,0 +1,57 @@ +package dhcpv4 + +import ( + "encoding/binary" + "fmt" +) + +// This option implements the IP Address Lease Time option +// https://tools.ietf.org/html/rfc2132 + +// OptIPAddressLeaseTime represents the IP Address Lease Time option. +type OptIPAddressLeaseTime struct { + LeaseTime uint32 +} + +// ParseOptIPAddressLeaseTime constructs an OptIPAddressLeaseTime struct from a +// sequence of bytes and returns it, or an error. +func ParseOptIPAddressLeaseTime(data []byte) (*OptIPAddressLeaseTime, error) { + // Should at least have code, length, and lease time. + if len(data) < 6 { + return nil, ErrShortByteStream + } + code := OptionCode(data[0]) + if code != OptionIPAddressLeaseTime { + return nil, fmt.Errorf("expected option %v, got %v instead", OptionIPAddressLeaseTime, code) + } + length := int(data[1]) + if length != 4 { + return nil, fmt.Errorf("expected length 4, got %v instead", length) + } + leaseTime := binary.BigEndian.Uint32(data[2:6]) + return &OptIPAddressLeaseTime{LeaseTime: leaseTime}, nil +} + +// Code returns the option code. +func (o *OptIPAddressLeaseTime) Code() OptionCode { + return OptionIPAddressLeaseTime +} + +// ToBytes returns a serialized stream of bytes for this option. +func (o *OptIPAddressLeaseTime) ToBytes() []byte { + serializedTime := make([]byte, 4) + binary.BigEndian.PutUint32(serializedTime, o.LeaseTime) + serializedOpt := []byte{byte(o.Code()), byte(o.Length())} + return append(serializedOpt, serializedTime...) +} + +// String returns a human-readable string for this option. +func (o *OptIPAddressLeaseTime) String() string { + return fmt.Sprintf("IP Addresses Lease Time -> %v", o.LeaseTime) +} + +// Length returns the length of the data portion (excluding option code and byte +// for length, if any). +func (o *OptIPAddressLeaseTime) Length() int { + return 4 +} diff --git a/dhcpv4/option_ip_address_lease_time_test.go b/dhcpv4/option_ip_address_lease_time_test.go new file mode 100644 index 0000000..7d507bf --- /dev/null +++ b/dhcpv4/option_ip_address_lease_time_test.go @@ -0,0 +1,41 @@ +package dhcpv4 + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestOptIPAddressLeaseTimeInterfaceMethods(t *testing.T) { + o := OptIPAddressLeaseTime{LeaseTime: 43200} + require.Equal(t, OptionIPAddressLeaseTime, o.Code(), "Code") + require.Equal(t, 4, o.Length(), "Length") + require.Equal(t, []byte{51, 4, 0, 0, 168, 192}, o.ToBytes(), "ToBytes") +} + +func TestParseOptIPAddressLeaseTime(t *testing.T) { + data := []byte{51, 4, 0, 0, 168, 192} + o, err := ParseOptIPAddressLeaseTime(data) + require.NoError(t, err) + require.Equal(t, &OptIPAddressLeaseTime{LeaseTime: 43200}, o) + + // Short byte stream + data = []byte{51, 4, 168, 192} + _, err = ParseOptIPAddressLeaseTime(data) + require.Error(t, err, "should get error from short byte stream") + + // Wrong code + data = []byte{54, 4, 0, 0, 168, 192} + _, err = ParseOptIPAddressLeaseTime(data) + require.Error(t, err, "should get error from wrong code") + + // Bad length + data = []byte{51, 5, 1, 1, 1, 1, 1} + _, err = ParseOptIPAddressLeaseTime(data) + require.Error(t, err, "should get error from bad length") +} + +func TestOptIPAddressLeaseTimeString(t *testing.T) { + o := OptIPAddressLeaseTime{LeaseTime: 43200} + require.Equal(t, "IP Addresses Lease Time -> 43200", o.String()) +} diff --git a/dhcpv4/option_maximum_dhcp_message_size.go b/dhcpv4/option_maximum_dhcp_message_size.go index 05186f5..e5fedc6 100644 --- a/dhcpv4/option_maximum_dhcp_message_size.go +++ b/dhcpv4/option_maximum_dhcp_message_size.go @@ -8,7 +8,7 @@ import ( // This option implements the Maximum DHCP Message size option // https://tools.ietf.org/html/rfc2132 -// OptMaximumDHCPMessageSize represents the DHCP message type option. +// OptMaximumDHCPMessageSize represents the Maximum DHCP Message size option. type OptMaximumDHCPMessageSize struct { Size uint16 } @@ -16,7 +16,7 @@ type OptMaximumDHCPMessageSize struct { // ParseOptMaximumDHCPMessageSize constructs an OptMaximumDHCPMessageSize struct from a sequence of // bytes and returns it, or an error. func ParseOptMaximumDHCPMessageSize(data []byte) (*OptMaximumDHCPMessageSize, error) { - // Should at least have code, length, and message type. + // Should at least have code, length, and message size. if len(data) < 4 { return nil, ErrShortByteStream } diff --git a/dhcpv4/option_maximum_dhcp_message_size_test.go b/dhcpv4/option_maximum_dhcp_message_size_test.go index 65a26fc..f24b499 100644 --- a/dhcpv4/option_maximum_dhcp_message_size_test.go +++ b/dhcpv4/option_maximum_dhcp_message_size_test.go @@ -14,7 +14,7 @@ func TestOptMaximumDHCPMessageSizeInterfaceMethods(t *testing.T) { } func TestParseOptMaximumDHCPMessageSize(t *testing.T) { - data := []byte{57, 2, 5, 220} // DISCOVER + data := []byte{57, 2, 5, 220} o, err := ParseOptMaximumDHCPMessageSize(data) require.NoError(t, err) require.Equal(t, &OptMaximumDHCPMessageSize{Size: 1500}, o) diff --git a/dhcpv4/option_ntp_servers.go b/dhcpv4/option_ntp_servers.go new file mode 100644 index 0000000..39881d6 --- /dev/null +++ b/dhcpv4/option_ntp_servers.go @@ -0,0 +1,70 @@ +package dhcpv4 + +import ( + "fmt" + "net" +) + +// This option implements the network time protocol servers option +// https://tools.ietf.org/html/rfc2132 + +// OptNTPServers represents an option encapsulating the NTP servers. +type OptNTPServers struct { + NTPServers []net.IP +} + +// ParseOptNTPServers returns a new OptNTPServers from a byte stream, or error if any. +func ParseOptNTPServers(data []byte) (*OptNTPServers, error) { + if len(data) < 2 { + return nil, ErrShortByteStream + } + code := OptionCode(data[0]) + if code != OptionNTPServers { + return nil, fmt.Errorf("expected code %v, got %v", OptionNTPServers, code) + } + length := int(data[1]) + if length == 0 || length%4 != 0 { + return nil, fmt.Errorf("Invalid length: expected multiple of 4 larger than 4, got %v", length) + } + if len(data) < 2+length { + return nil, ErrShortByteStream + } + ntpServers := make([]net.IP, 0, length%4) + for idx := 0; idx < length; idx += 4 { + b := data[2+idx : 2+idx+4] + ntpServers = append(ntpServers, net.IPv4(b[0], b[1], b[2], b[3])) + } + return &OptNTPServers{NTPServers: ntpServers}, nil +} + +// Code returns the option code. +func (o *OptNTPServers) Code() OptionCode { + return OptionNTPServers +} + +// ToBytes returns a serialized stream of bytes for this option. +func (o *OptNTPServers) ToBytes() []byte { + ret := []byte{byte(o.Code()), byte(o.Length())} + for _, ntp := range o.NTPServers { + ret = append(ret, ntp.To4()...) + } + return ret +} + +// String returns a human-readable string. +func (o *OptNTPServers) String() string { + var ntpServers string + for idx, ntp := range o.NTPServers { + ntpServers += ntp.String() + if idx < len(o.NTPServers)-1 { + ntpServers += ", " + } + } + return fmt.Sprintf("NTP Servers -> %v", ntpServers) +} + +// Length returns the length of the data portion (excluding option code an byte +// length). +func (o *OptNTPServers) Length() int { + return len(o.NTPServers) * 4 +} diff --git a/dhcpv4/option_ntp_servers_test.go b/dhcpv4/option_ntp_servers_test.go new file mode 100644 index 0000000..e7bcefd --- /dev/null +++ b/dhcpv4/option_ntp_servers_test.go @@ -0,0 +1,65 @@ +package dhcpv4 + +import ( + "net" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestOptNTPServersInterfaceMethods(t *testing.T) { + ntpServers := []net.IP{ + net.IPv4(192, 168, 0, 10), + net.IPv4(192, 168, 0, 20), + } + o := OptNTPServers{NTPServers: ntpServers} + require.Equal(t, OptionNTPServers, o.Code(), "Code") + require.Equal(t, net.IPv4len*len(ntpServers), o.Length(), "Length") + require.Equal(t, ntpServers, o.NTPServers, "NTPServers") +} + +func TestParseOptNTPServers(t *testing.T) { + data := []byte{ + byte(OptionNTPServers), + 8, // Length + 192, 168, 0, 10, // NTP server #1 + 192, 168, 0, 20, // NTP server #2 + } + o, err := ParseOptNTPServers(data) + require.NoError(t, err) + ntpServers := []net.IP{ + net.IPv4(192, 168, 0, 10), + net.IPv4(192, 168, 0, 20), + } + require.Equal(t, &OptNTPServers{NTPServers: ntpServers}, o) + + // Short byte stream + data = []byte{byte(OptionNTPServers)} + _, err = ParseOptNTPServers(data) + require.Error(t, err, "should get error from short byte stream") + + // Wrong code + data = []byte{54, 2, 1, 1} + _, err = ParseOptNTPServers(data) + require.Error(t, err, "should get error from wrong code") + + // Bad length + data = []byte{byte(OptionNTPServers), 6, 1, 1, 1} + _, err = ParseOptNTPServers(data) + require.Error(t, err, "should get error from bad length") +} + +func TestParseOptNTPserversNoNTPServers(t *testing.T) { + // RFC2132 requires that at least one NTP server IP is specified + data := []byte{ + byte(OptionNTPServers), + 0, // Length + } + _, err := ParseOptNTPServers(data) + require.Error(t, err) +} + +func TestOptNTPServersString(t *testing.T) { + o := OptNTPServers{NTPServers: []net.IP{net.IPv4(192, 168, 0, 1), net.IPv4(192, 168, 0, 10)}} + require.Equal(t, "NTP Servers -> 192.168.0.1, 192.168.0.10", o.String()) +} diff --git a/dhcpv4/option_router.go b/dhcpv4/option_router.go new file mode 100644 index 0000000..3154edd --- /dev/null +++ b/dhcpv4/option_router.go @@ -0,0 +1,70 @@ +package dhcpv4 + +import ( + "fmt" + "net" +) + +// This option implements the router option +// https://tools.ietf.org/html/rfc2132 + +// OptRouter represents an option encapsulating the routers. +type OptRouter struct { + Routers []net.IP +} + +// ParseOptRouter returns a new OptRouter from a byte stream, or error if any. +func ParseOptRouter(data []byte) (*OptRouter, error) { + if len(data) < 2 { + return nil, ErrShortByteStream + } + code := OptionCode(data[0]) + if code != OptionRouter { + return nil, fmt.Errorf("expected code %v, got %v", OptionRouter, code) + } + length := int(data[1]) + if length == 0 || length%4 != 0 { + return nil, fmt.Errorf("Invalid length: expected multiple of 4 larger than 4, got %v", length) + } + if len(data) < 2+length { + return nil, ErrShortByteStream + } + routers := make([]net.IP, 0, length%4) + for idx := 0; idx < length; idx += 4 { + b := data[2+idx : 2+idx+4] + routers = append(routers, net.IPv4(b[0], b[1], b[2], b[3])) + } + return &OptRouter{Routers: routers}, nil +} + +// Code returns the option code. +func (o *OptRouter) Code() OptionCode { + return OptionRouter +} + +// ToBytes returns a serialized stream of bytes for this option. +func (o *OptRouter) ToBytes() []byte { + ret := []byte{byte(o.Code()), byte(o.Length())} + for _, router := range o.Routers { + ret = append(ret, router.To4()...) + } + return ret +} + +// String returns a human-readable string. +func (o *OptRouter) String() string { + var routers string + for idx, router := range o.Routers { + routers += router.String() + if idx < len(o.Routers)-1 { + routers += ", " + } + } + return fmt.Sprintf("Routers -> %v", routers) +} + +// Length returns the length of the data portion (excluding option code an byte +// length). +func (o *OptRouter) Length() int { + return len(o.Routers) * 4 +} diff --git a/dhcpv4/option_router_test.go b/dhcpv4/option_router_test.go new file mode 100644 index 0000000..f492c22 --- /dev/null +++ b/dhcpv4/option_router_test.go @@ -0,0 +1,65 @@ +package dhcpv4 + +import ( + "net" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestOptRoutersInterfaceMethods(t *testing.T) { + routers := []net.IP{ + net.IPv4(192, 168, 0, 10), + net.IPv4(192, 168, 0, 20), + } + o := OptRouter{Routers: routers} + require.Equal(t, OptionRouter, o.Code(), "Code") + require.Equal(t, net.IPv4len*len(routers), o.Length(), "Length") + require.Equal(t, routers, o.Routers, "Routers") +} + +func TestParseOptRouter(t *testing.T) { + data := []byte{ + byte(OptionRouter), + 8, // Length + 192, 168, 0, 10, // Router #1 + 192, 168, 0, 20, // Router #2 + } + o, err := ParseOptRouter(data) + require.NoError(t, err) + routers := []net.IP{ + net.IPv4(192, 168, 0, 10), + net.IPv4(192, 168, 0, 20), + } + require.Equal(t, &OptRouter{Routers: routers}, o) + + // Short byte stream + data = []byte{byte(OptionRouter)} + _, err = ParseOptRouter(data) + require.Error(t, err, "should get error from short byte stream") + + // Wrong code + data = []byte{54, 2, 1, 1} + _, err = ParseOptRouter(data) + require.Error(t, err, "should get error from wrong code") + + // Bad length + data = []byte{byte(OptionRouter), 6, 1, 1, 1} + _, err = ParseOptRouter(data) + require.Error(t, err, "should get error from bad length") +} + +func TestParseOptRouterNoRouters(t *testing.T) { + // RFC2132 requires that at least one Router IP is specified + data := []byte{ + byte(OptionRouter), + 0, // Length + } + _, err := ParseOptRouter(data) + require.Error(t, err) +} + +func TestOptRouterString(t *testing.T) { + o := OptRouter{Routers: []net.IP{net.IPv4(192, 168, 0, 1), net.IPv4(192, 168, 0, 10)}} + require.Equal(t, "Routers -> 192.168.0.1, 192.168.0.10", o.String()) +} diff --git a/dhcpv4/option_subnet_mask.go b/dhcpv4/option_subnet_mask.go new file mode 100644 index 0000000..f1ff4a4 --- /dev/null +++ b/dhcpv4/option_subnet_mask.go @@ -0,0 +1,56 @@ +package dhcpv4 + +import ( + "fmt" + "net" +) + +// This option implements the subnet mask option +// https://tools.ietf.org/html/rfc2132 + +// OptSubnetMask represents an option encapsulating the subnet mask. +type OptSubnetMask struct { + SubnetMask net.IPMask +} + +// ParseOptSubnetMask returns a new OptSubnetMask from a byte +// stream, or error if any. +func ParseOptSubnetMask(data []byte) (*OptSubnetMask, error) { + if len(data) < 2 { + return nil, ErrShortByteStream + } + code := OptionCode(data[0]) + if code != OptionSubnetMask { + return nil, fmt.Errorf("expected code %v, got %v", OptionSubnetMask, code) + } + length := int(data[1]) + if length != 4 { + return nil, fmt.Errorf("unexepcted length: expected 4, got %v", length) + } + if len(data) < 6 { + return nil, ErrShortByteStream + } + return &OptSubnetMask{SubnetMask: net.IPMask(data[2 : 2+length])}, nil +} + +// Code returns the option code. +func (o *OptSubnetMask) Code() OptionCode { + return OptionSubnetMask +} + +// ToBytes returns a serialized stream of bytes for this option. +func (o *OptSubnetMask) ToBytes() []byte { + ret := []byte{byte(o.Code()), byte(o.Length())} + return append(ret, o.SubnetMask[:4]...) +} + +// String returns a human-readable string. +func (o *OptSubnetMask) String() string { + return fmt.Sprintf("Subnet Mask -> %v", o.SubnetMask.String()) +} + +// Length returns the length of the data portion (excluding option code an byte +// length). +func (o *OptSubnetMask) Length() int { + return 4 +} diff --git a/dhcpv4/option_subnet_mask_test.go b/dhcpv4/option_subnet_mask_test.go new file mode 100644 index 0000000..4cb8819 --- /dev/null +++ b/dhcpv4/option_subnet_mask_test.go @@ -0,0 +1,44 @@ +package dhcpv4 + +import ( + "net" + "testing" + + "github.com/stretchr/testify/require" +) + +func TestOptSubnetMaskInterfaceMethods(t *testing.T) { + mask := net.IPMask{255, 255, 255, 0} + o := OptSubnetMask{SubnetMask: mask} + + require.Equal(t, OptionSubnetMask, o.Code(), "Code") + + expectedBytes := []byte{1, 4, 255, 255, 255, 0} + require.Equal(t, expectedBytes, o.ToBytes(), "ToBytes") + + require.Equal(t, 4, o.Length(), "Length") + + require.Equal(t, "Subnet Mask -> ffffff00", o.String(), "String") +} + +func TestParseOptSubnetMask(t *testing.T) { + var ( + o *OptSubnetMask + err error + ) + o, err = ParseOptSubnetMask([]byte{}) + require.Error(t, err, "empty byte stream") + + o, err = ParseOptSubnetMask([]byte{1, 4, 255}) + require.Error(t, err, "short byte stream") + + o, err = ParseOptSubnetMask([]byte{1, 3, 255, 255, 255, 0}) + require.Error(t, err, "wrong IP length") + + o, err = ParseOptSubnetMask([]byte{2, 4, 255, 255, 255}) + require.Error(t, err, "wrong option code") + + o, err = ParseOptSubnetMask([]byte{1, 4, 255, 255, 255, 0}) + require.NoError(t, err) + require.Equal(t, net.IPMask{255, 255, 255, 0}, o.SubnetMask) +} diff --git a/dhcpv4/option_tftp_server_name.go b/dhcpv4/option_tftp_server_name.go index b4029e1..19dde21 100644 --- a/dhcpv4/option_tftp_server_name.go +++ b/dhcpv4/option_tftp_server_name.go @@ -28,7 +28,7 @@ func (op *OptTFTPServerName) Length() int { } func (op *OptTFTPServerName) String() string { - return fmt.Sprintf("OptTFTPServerName{TFTPServerName=%s}", op.TFTPServerName) + return fmt.Sprintf("TFTP Server Name -> %s", op.TFTPServerName) } // ParseOptTFTPServerName returns a new OptTFTPServerName fomr a byte stream or error if any diff --git a/dhcpv4/option_tftp_server_name_test.go b/dhcpv4/option_tftp_server_name_test.go index caddf95..812210f 100644 --- a/dhcpv4/option_tftp_server_name_test.go +++ b/dhcpv4/option_tftp_server_name_test.go @@ -58,3 +58,8 @@ func TestParseOptTFTPServerNameShortLength(t *testing.T) { require.NoError(t, err) require.Equal(t, []byte("linu"), opt.TFTPServerName) } + +func TestOptTFTPServerNameString(t *testing.T) { + o := OptTFTPServerName{TFTPServerName: []byte("testy test")} + require.Equal(t, "TFTP Server Name -> testy test", o.String()) +} diff --git a/dhcpv4/option_userclass.go b/dhcpv4/option_userclass.go index 1505dbb..d6ddabc 100644 --- a/dhcpv4/option_userclass.go +++ b/dhcpv4/option_userclass.go @@ -12,6 +12,7 @@ import ( // OptUserClass represents an option encapsulating User Classes. type OptUserClass struct { UserClasses [][]byte + Rfc3004 bool } // Code returns the option code @@ -22,6 +23,9 @@ func (op *OptUserClass) Code() OptionCode { // ToBytes serializes the option and returns it as a sequence of bytes func (op *OptUserClass) ToBytes() []byte { buf := []byte{byte(op.Code()), byte(op.Length())} + if !op.Rfc3004 { + return append(buf, op.UserClasses[0]...) + } for _, uc := range op.UserClasses { buf = append(buf, byte(len(uc))) buf = append(buf, uc...) @@ -32,6 +36,9 @@ func (op *OptUserClass) ToBytes() []byte { // Length returns the option length func (op *OptUserClass) Length() int { ret := 0 + if !op.Rfc3004 { + return len(op.UserClasses[0]) + } for _, uc := range op.UserClasses { ret += 1 + len(uc) } @@ -39,11 +46,15 @@ func (op *OptUserClass) Length() int { } func (op *OptUserClass) String() string { - ucStrings := make([]string, len(op.UserClasses)) - for _, uc := range op.UserClasses { - ucStrings = append(ucStrings, string(uc)) + ucStrings := make([]string, 0, len(op.UserClasses)) + if !op.Rfc3004 { + ucStrings = append(ucStrings, string(op.UserClasses[0])) + } else { + for _, uc := range op.UserClasses { + ucStrings = append(ucStrings, string(uc)) + } } - return fmt.Sprintf("OptUserClass{userclass=[%s]}", strings.Join(ucStrings, ", ")) + return fmt.Sprintf("User Class Information -> %v", strings.Join(ucStrings, ", ")) } // ParseOptUserClass returns a new OptUserClass from a byte stream or @@ -51,7 +62,7 @@ func (op *OptUserClass) String() string { func ParseOptUserClass(data []byte) (*OptUserClass, error) { opt := OptUserClass{} - if len(data) < 4 { + if len(data) < 3 { return nil, ErrShortByteStream } code := OptionCode(data[0]) @@ -66,6 +77,23 @@ func ParseOptUserClass(data []byte) (*OptUserClass, error) { totalLength, len(data)) } + // Check if option is Microsoft style instead of RFC compliant, issue #113 + + // User-class options are, according to RFC3004, supposed to contain a set + // of strings each with length UC_Len_i. Here we check that this is so, + // by seeing if all the UC_Len_i lengths are consistent with the overall + // option length. If the lengths don't add up, we assume that the option + // is a single string and non RFC3004 compliant + var counting int + for counting < totalLength { + // UC_Len_i does not include itself so add 1 + counting += int(data[counting]) + 1 + } + if counting != totalLength { + opt.UserClasses = append(opt.UserClasses, data[:totalLength]) + return &opt, nil + } + opt.Rfc3004 = true for i := 0; i < totalLength; { ucLen := int(data[i]) if ucLen == 0 { diff --git a/dhcpv4/option_userclass_test.go b/dhcpv4/option_userclass_test.go index 5b71ea5..f6039df 100644 --- a/dhcpv4/option_userclass_test.go +++ b/dhcpv4/option_userclass_test.go @@ -9,16 +9,30 @@ import ( func TestOptUserClassToBytes(t *testing.T) { opt := OptUserClass{ UserClasses: [][]byte{[]byte("linuxboot")}, + Rfc3004: true, } data := opt.ToBytes() expected := []byte{ - 77, // OPTION_USER_CLASS + 77, // OptionUserClass 10, // length 9, 'l', 'i', 'n', 'u', 'x', 'b', 'o', 'o', 't', } require.Equal(t, expected, data) } +func TestOptUserClassMicrosoftToBytes(t *testing.T) { + opt := OptUserClass{ + UserClasses: [][]byte{[]byte("linuxboot")}, + } + data := opt.ToBytes() + expected := []byte{ + 77, // OptionUserClass + 9, // length + 'l', 'i', 'n', 'u', 'x', 'b', 'o', 'o', 't', + } + require.Equal(t, expected, data) +} + func TestParseOptUserClassMultiple(t *testing.T) { expected := []byte{ 77, 15, @@ -38,6 +52,36 @@ func TestParseOptUserClassNone(t *testing.T) { require.Error(t, err) } +func TestParseOptUserClassMicrosoft(t *testing.T) { + expected := []byte{ + 77, 9, 'l', 'i', 'n', 'u', 'x', 'b', 'o', 'o', 't', + } + opt, err := ParseOptUserClass(expected) + require.NoError(t, err) + require.Equal(t, 1, len(opt.UserClasses)) + require.Equal(t, []byte("linuxboot"), opt.UserClasses[0]) +} + +func TestParseOptUserClassMicrosoftShort(t *testing.T) { + expected := []byte{ + 77, 1, 'l', + } + opt, err := ParseOptUserClass(expected) + require.NoError(t, err) + require.Equal(t, 1, len(opt.UserClasses)) + require.Equal(t, []byte("l"), opt.UserClasses[0]) +} + +func TestParseOptUserClassMicrosoftLongerThanLength(t *testing.T) { + expected := []byte{ + 77, 9, 'l', 'i', 'n', 'u', 'x', 'b', 'o', 'o', 't', 'X', + } + opt, err := ParseOptUserClass(expected) + require.NoError(t, err) + require.Equal(t, 1, len(opt.UserClasses)) + require.Equal(t, []byte("linuxboot"), opt.UserClasses[0]) +} + func TestParseOptUserClass(t *testing.T) { expected := []byte{ 77, 10, 9, 'l', 'i', 'n', 'u', 'x', 'b', 'o', 'o', 't', @@ -54,10 +98,11 @@ func TestOptUserClassToBytesMultiple(t *testing.T) { []byte("linuxboot"), []byte("test"), }, + Rfc3004: true, } data := opt.ToBytes() expected := []byte{ - 77, // OPTION_USER_CLASS + 77, // OptionUserClass 15, // length 9, 'l', 'i', 'n', 'u', 'x', 'b', 'o', 'o', 't', 4, 't', 'e', 's', 't', @@ -75,14 +120,6 @@ func TestParseOptUserClassLongerThanLength(t *testing.T) { require.Equal(t, []byte("linuxboot"), opt.UserClasses[0]) } -func TestParseOptUserClassShorterThanLength(t *testing.T) { - expected := []byte{ - 77, 10, 10, 'l', 'i', 'n', 'u', 'x', 'b', 'o', 'o', 't', - } - _, err := ParseOptUserClass(expected) - require.Error(t, err) -} - func TestParseOptUserClassShorterTotalLength(t *testing.T) { expected := []byte{ 77, 11, 10, 'l', 'i', 'n', 'u', 'x', 'b', 'o', 'o', 't', diff --git a/dhcpv4/options.go b/dhcpv4/options.go index 5e6da80..d869b7d 100644 --- a/dhcpv4/options.go +++ b/dhcpv4/options.go @@ -40,32 +40,46 @@ func ParseOption(data []byte) (Option, error) { err error ) switch OptionCode(data[0]) { - case OptionDHCPMessageType: - opt, err = ParseOptMessageType(data) - case OptionParameterRequestList: - opt, err = ParseOptParameterRequestList(data) + case OptionSubnetMask: + opt, err = ParseOptSubnetMask(data) + case OptionRouter: + opt, err = ParseOptRouter(data) + case OptionDomainNameServer: + opt, err = ParseOptDomainNameServer(data) + case OptionHostName: + opt, err = ParseOptHostName(data) + case OptionDomainName: + opt, err = ParseOptDomainName(data) + case OptionBroadcastAddress: + opt, err = ParseOptBroadcastAddress(data) + case OptionNTPServers: + opt, err = ParseOptNTPServers(data) case OptionRequestedIPAddress: opt, err = ParseOptRequestedIPAddress(data) + case OptionIPAddressLeaseTime: + opt, err = ParseOptIPAddressLeaseTime(data) + case OptionDHCPMessageType: + opt, err = ParseOptMessageType(data) case OptionServerIdentifier: opt, err = ParseOptServerIdentifier(data) - case OptionBroadcastAddress: - opt, err = ParseOptBroadcastAddress(data) + case OptionParameterRequestList: + opt, err = ParseOptParameterRequestList(data) case OptionMaximumDHCPMessageSize: opt, err = ParseOptMaximumDHCPMessageSize(data) case OptionClassIdentifier: opt, err = ParseOptClassIdentifier(data) - case OptionDomainName: - opt, err = ParseOptDomainName(data) - case OptionDomainNameServer: - opt, err = ParseOptDomainNameServer(data) - case OptionVendorIdentifyingVendorClass: - opt, err = ParseOptVIVC(data) case OptionTFTPServerName: opt, err = ParseOptTFTPServerName(data) case OptionBootfileName: opt, err = ParseOptBootfileName(data) case OptionUserClassInformation: opt, err = ParseOptUserClass(data) + case OptionClientSystemArchitectureType: + opt, err = ParseOptClientArchType(data) + case OptionVendorIdentifyingVendorClass: + opt, err = ParseOptVIVC(data) + case OptionDNSDomainSearchList: + opt, err = ParseOptDomainSearch(data) default: opt, err = ParseOptionGeneric(data) } diff --git a/dhcpv4/options_test.go b/dhcpv4/options_test.go index 41ef415..0268483 100644 --- a/dhcpv4/options_test.go +++ b/dhcpv4/options_test.go @@ -17,20 +17,52 @@ func TestParseOption(t *testing.T) { require.Equal(t, 4, generic.Length()) require.Equal(t, "Name Server -> [192 168 1 254]", generic.String()) - // Message type - option = []byte{53, 1, 1} + // Option subnet mask + option = []byte{1, 4, 255, 255, 255, 0} opt, err = ParseOption(option) require.NoError(t, err) - require.Equal(t, OptionDHCPMessageType, opt.Code(), "Code") - require.Equal(t, 1, opt.Length(), "Length") + require.Equal(t, OptionSubnetMask, opt.Code(), "Code") + require.Equal(t, 4, opt.Length(), "Length") require.Equal(t, option, opt.ToBytes(), "ToBytes") - // Parameter request list - option = []byte{55, 3, 5, 53, 61} + // Option router + option = []byte{3, 4, 192, 168, 1, 1} opt, err = ParseOption(option) require.NoError(t, err) - require.Equal(t, OptionParameterRequestList, opt.Code(), "Code") - require.Equal(t, 3, opt.Length(), "Length") + require.Equal(t, OptionRouter, opt.Code(), "Code") + require.Equal(t, 4, opt.Length(), "Length") + require.Equal(t, option, opt.ToBytes(), "ToBytes") + + // Option domain name server + option = []byte{6, 4, 192, 168, 1, 1} + opt, err = ParseOption(option) + require.NoError(t, err) + require.Equal(t, OptionDomainNameServer, opt.Code(), "Code") + require.Equal(t, 4, opt.Length(), "Length") + require.Equal(t, option, opt.ToBytes(), "ToBytes") + + // Option host name + option = []byte{12, 4, 't', 'e', 's', 't'} + opt, err = ParseOption(option) + require.NoError(t, err) + require.Equal(t, OptionHostName, opt.Code(), "Code") + require.Equal(t, 4, opt.Length(), "Length") + require.Equal(t, option, opt.ToBytes(), "ToBytes") + + // Option domain name + option = []byte{15, 4, 't', 'e', 's', 't'} + opt, err = ParseOption(option) + require.NoError(t, err) + require.Equal(t, OptionDomainName, opt.Code(), "Code") + require.Equal(t, 4, opt.Length(), "Length") + require.Equal(t, option, opt.ToBytes(), "ToBytes") + + // Option NTP servers + option = []byte{42, 4, 10, 10, 10, 10} + opt, err = ParseOption(option) + require.NoError(t, err) + require.Equal(t, OptionNTPServers, opt.Code(), "Code") + require.Equal(t, 4, opt.Length(), "Length") require.Equal(t, option, opt.ToBytes(), "ToBytes") // Requested IP address @@ -41,6 +73,14 @@ func TestParseOption(t *testing.T) { require.Equal(t, 4, opt.Length(), "Length") require.Equal(t, option, opt.ToBytes(), "ToBytes") + // Message type + option = []byte{53, 1, 1} + opt, err = ParseOption(option) + require.NoError(t, err) + require.Equal(t, OptionDHCPMessageType, opt.Code(), "Code") + require.Equal(t, 1, opt.Length(), "Length") + require.Equal(t, option, opt.ToBytes(), "ToBytes") + // Option server ID option = []byte{54, 4, 1, 2, 3, 4} opt, err = ParseOption(option) @@ -49,6 +89,14 @@ func TestParseOption(t *testing.T) { require.Equal(t, 4, opt.Length(), "Length") require.Equal(t, option, opt.ToBytes(), "ToBytes") + // Parameter request list + option = []byte{55, 3, 5, 53, 61} + opt, err = ParseOption(option) + require.NoError(t, err) + require.Equal(t, OptionParameterRequestList, opt.Code(), "Code") + require.Equal(t, 3, opt.Length(), "Length") + require.Equal(t, option, opt.ToBytes(), "ToBytes") + // Option max message size option = []byte{57, 2, 1, 2} opt, err = ParseOption(option) @@ -88,6 +136,14 @@ func TestParseOption(t *testing.T) { require.Equal(t, OptionUserClassInformation, opt.Code(), "Code") require.Equal(t, 5, opt.Length(), "Length") require.Equal(t, option, opt.ToBytes(), "ToBytes") + + // Option client system architecture type option + option = []byte{93, 4, 't', 'e', 's', 't'} + opt, err = ParseOption(option) + require.NoError(t, err) + require.Equal(t, OptionClientSystemArchitectureType, opt.Code(), "Code") + require.Equal(t, 4, opt.Length(), "Length") + require.Equal(t, option, opt.ToBytes(), "ToBytes") } func TestParseOptionZeroLength(t *testing.T) { diff --git a/dhcpv6/client.go b/dhcpv6/client.go index 8431482..3492a47 100644 --- a/dhcpv6/client.go +++ b/dhcpv6/client.go @@ -81,16 +81,16 @@ func (c *Client) sendReceive(ifname string, packet DHCPv6, expectedType MessageT if packet == nil { return nil, fmt.Errorf("Packet to send cannot be nil") } - if expectedType == MSGTYPE_NONE { + if expectedType == MessageTypeNone { // infer the expected type from the packet being sent - if packet.Type() == SOLICIT { - expectedType = ADVERTISE - } else if packet.Type() == REQUEST { - expectedType = REPLY - } else if packet.Type() == RELAY_FORW { - expectedType = RELAY_REPL - } else if packet.Type() == LEASEQUERY { - expectedType = LEASEQUERY_REPLY + if packet.Type() == MessageTypeSolicit { + expectedType = MessageTypeAdvertise + } else if packet.Type() == MessageTypeRequest { + expectedType = MessageTypeReply + } else if packet.Type() == MessageTypeRelayForward { + expectedType = MessageTypeRelayReply + } else if packet.Type() == MessageTypeLeaseQuery { + expectedType = MessageTypeLeaseQueryReply } // and probably more } // if no LocalAddr is specified, get the interface's link-local address @@ -167,7 +167,7 @@ func (c *Client) sendReceive(ifname string, packet DHCPv6, expectedType MessageT continue } } - if expectedType == MSGTYPE_NONE { + if expectedType == MessageTypeNone { // just take whatever arrived break } else if adv.Type() == expectedType { @@ -190,7 +190,7 @@ func (c *Client) Solicit(ifname string, solicit DHCPv6, modifiers ...Modifier) ( for _, mod := range modifiers { solicit = mod(solicit) } - advertise, err := c.sendReceive(ifname, solicit, MSGTYPE_NONE) + advertise, err := c.sendReceive(ifname, solicit, MessageTypeNone) return solicit, advertise, err } @@ -207,6 +207,6 @@ func (c *Client) Request(ifname string, advertise, request DHCPv6, modifiers ... for _, mod := range modifiers { request = mod(request) } - reply, err := c.sendReceive(ifname, request, MSGTYPE_NONE) + reply, err := c.sendReceive(ifname, request, MessageTypeNone) return request, reply, err } diff --git a/dhcpv6/dhcpv6.go b/dhcpv6/dhcpv6.go index b424101..0dabca5 100644 --- a/dhcpv6/dhcpv6.go +++ b/dhcpv6/dhcpv6.go @@ -30,7 +30,7 @@ func FromBytes(data []byte) (DHCPv6, error) { headerSize int messageType = MessageType(data[0]) ) - if messageType == RELAY_FORW || messageType == RELAY_REPL { + if messageType == MessageTypeRelayForward || messageType == MessageTypeRelayReply { isRelay = true } if isRelay { @@ -85,7 +85,7 @@ func NewMessage(modifiers ...Modifier) (DHCPv6, error) { return nil, err } msg := DHCPv6Message{ - messageType: SOLICIT, + messageType: MessageTypeSolicit, transactionID: *tid, } // apply modifiers @@ -134,7 +134,7 @@ func DecapsulateRelay(l DHCPv6) (DHCPv6, error) { if !l.IsRelay() { return l, nil } - opt := l.GetOneOption(OPTION_RELAY_MSG) + opt := l.GetOneOption(OptionRelayMsg) if opt == nil { return nil, fmt.Errorf("No OptRelayMsg found") } @@ -181,7 +181,7 @@ func DecapsulateRelayIndex(l DHCPv6, index int) (DHCPv6, error) { // message as payload. The passed message type must be either RELAY_FORW or // RELAY_REPL func EncapsulateRelay(d DHCPv6, mType MessageType, linkAddr, peerAddr net.IP) (DHCPv6, error) { - if mType != RELAY_FORW && mType != RELAY_REPL { + if mType != MessageTypeRelayForward && mType != MessageTypeRelayReply { return nil, fmt.Errorf("Message type must be either RELAY_FORW or RELAY_REPL") } outer := DHCPv6Relay{ diff --git a/dhcpv6/dhcpv6_test.go b/dhcpv6/dhcpv6_test.go index 3e2b6bc..4a44e0e 100644 --- a/dhcpv6/dhcpv6_test.go +++ b/dhcpv6/dhcpv6_test.go @@ -33,18 +33,18 @@ func TestNewMessage(t *testing.T) { d, err := NewMessage() require.NoError(t, err) require.NotNil(t, d) - require.Equal(t, SOLICIT, d.Type()) + require.Equal(t, MessageTypeSolicit, d.Type()) require.NotEqual(t, 0, d.(*DHCPv6Message).transactionID) require.Empty(t, d.(*DHCPv6Message).options) } func TestDecapsulateRelayIndex(t *testing.T) { m := DHCPv6Message{} - r1, err := EncapsulateRelay(&m, RELAY_FORW, net.IPv6linklocalallnodes, net.IPv6interfacelocalallnodes) + r1, err := EncapsulateRelay(&m, MessageTypeRelayForward, net.IPv6linklocalallnodes, net.IPv6interfacelocalallnodes) require.NoError(t, err) - r2, err := EncapsulateRelay(r1, RELAY_FORW, net.IPv6loopback, net.IPv6linklocalallnodes) + r2, err := EncapsulateRelay(r1, MessageTypeRelayForward, net.IPv6loopback, net.IPv6linklocalallnodes) require.NoError(t, err) - r3, err := EncapsulateRelay(r2, RELAY_FORW, net.IPv6unspecified, net.IPv6linklocalallrouters) + r3, err := EncapsulateRelay(r2, MessageTypeRelayForward, net.IPv6unspecified, net.IPv6linklocalallrouters) require.NoError(t, err) first, err := DecapsulateRelayIndex(r3, 0) @@ -83,10 +83,10 @@ func TestDecapsulateRelayIndex(t *testing.T) { func TestSettersAndGetters(t *testing.T) { d := DHCPv6Message{} // Message - d.SetMessage(SOLICIT) - require.Equal(t, SOLICIT, d.Type()) - d.SetMessage(ADVERTISE) - require.Equal(t, ADVERTISE, d.Type()) + d.SetMessage(MessageTypeSolicit) + require.Equal(t, MessageTypeSolicit, d.Type()) + d.SetMessage(MessageTypeAdvertise) + require.Equal(t, MessageTypeAdvertise, d.Type()) // TransactionID d.SetTransactionID(12345) @@ -109,7 +109,7 @@ func TestAddOption(t *testing.T) { func TestToBytes(t *testing.T) { d := DHCPv6Message{} - d.SetMessage(SOLICIT) + d.SetMessage(MessageTypeSolicit) d.SetTransactionID(0xabcdef) opt := OptionGeneric{OptionCode: 0, OptionData: []byte{}} d.AddOption(&opt) @@ -128,7 +128,7 @@ func TestFromAndToBytes(t *testing.T) { func TestNewAdvertiseFromSolicit(t *testing.T) { s := DHCPv6Message{} - s.SetMessage(SOLICIT) + s.SetMessage(MessageTypeSolicit) s.SetTransactionID(0xabcdef) cid := OptClientId{} s.AddOption(&cid) @@ -137,7 +137,7 @@ func TestNewAdvertiseFromSolicit(t *testing.T) { a, err := NewAdvertiseFromSolicit(&s, WithServerID(duid)) require.NoError(t, err) require.Equal(t, a.(*DHCPv6Message).TransactionID(), s.TransactionID()) - require.Equal(t, a.Type(), ADVERTISE) + require.Equal(t, a.Type(), MessageTypeAdvertise) } func TestNewReplyFromDHCPv6Message(t *testing.T) { @@ -150,31 +150,31 @@ func TestNewReplyFromDHCPv6Message(t *testing.T) { sid.Sid = duid msg.AddOption(&sid) - msg.SetMessage(CONFIRM) + msg.SetMessage(MessageTypeConfirm) rep, err := NewReplyFromDHCPv6Message(&msg, WithServerID(duid)) require.NoError(t, err) require.Equal(t, rep.(*DHCPv6Message).TransactionID(), msg.TransactionID()) - require.Equal(t, rep.Type(), REPLY) + require.Equal(t, rep.Type(), MessageTypeReply) - msg.SetMessage(RENEW) + msg.SetMessage(MessageTypeRenew) rep, err = NewReplyFromDHCPv6Message(&msg, WithServerID(duid)) require.NoError(t, err) require.Equal(t, rep.(*DHCPv6Message).TransactionID(), msg.TransactionID()) - require.Equal(t, rep.Type(), REPLY) + require.Equal(t, rep.Type(), MessageTypeReply) - msg.SetMessage(REBIND) + msg.SetMessage(MessageTypeRebind) rep, err = NewReplyFromDHCPv6Message(&msg, WithServerID(duid)) require.NoError(t, err) require.Equal(t, rep.(*DHCPv6Message).TransactionID(), msg.TransactionID()) - require.Equal(t, rep.Type(), REPLY) + require.Equal(t, rep.Type(), MessageTypeReply) - msg.SetMessage(RELEASE) + msg.SetMessage(MessageTypeRelease) rep, err = NewReplyFromDHCPv6Message(&msg, WithServerID(duid)) require.NoError(t, err) require.Equal(t, rep.(*DHCPv6Message).TransactionID(), msg.TransactionID()) - require.Equal(t, rep.Type(), REPLY) + require.Equal(t, rep.Type(), MessageTypeReply) - msg.SetMessage(SOLICIT) + msg.SetMessage(MessageTypeSolicit) rep, err = NewReplyFromDHCPv6Message(&msg) require.Error(t, err) @@ -183,7 +183,7 @@ func TestNewReplyFromDHCPv6Message(t *testing.T) { require.Error(t, err) } -func TestNewSolicitWithCID(t *testing.T) { +func TestNewMessageTypeSolicitWithCID(t *testing.T) { hwAddr, err := net.ParseMAC("24:0A:9E:9F:EB:2B") require.NoError(t, err) @@ -196,24 +196,24 @@ func TestNewSolicitWithCID(t *testing.T) { s, err := NewSolicitWithCID(duid) require.NoError(t, err) - require.Equal(t, s.Type(), SOLICIT) + require.Equal(t, s.Type(), MessageTypeSolicit) // Check CID - cidOption := s.GetOneOption(OPTION_CLIENTID) + cidOption := s.GetOneOption(OptionClientID) require.NotNil(t, cidOption) cid, ok := cidOption.(*OptClientId) require.True(t, ok) require.Equal(t, cid.Cid, duid) // Check ORO - oroOption := s.GetOneOption(OPTION_ORO) + oroOption := s.GetOneOption(OptionORO) require.NotNil(t, oroOption) oro, ok := oroOption.(*OptRequestedOption) require.True(t, ok) opts := oro.RequestedOptions() - require.Contains(t, opts, DNS_RECURSIVE_NAME_SERVER) - require.Contains(t, opts, DOMAIN_SEARCH_LIST) + require.Contains(t, opts, OptionDNSRecursiveNameServer) + require.Contains(t, opts, OptionDomainSearchList) require.Equal(t, len(opts), 2) } -// TODO test NewSolicit +// TODO test NewMessageTypeSolicit // test String and Summary diff --git a/dhcpv6/dhcpv6message.go b/dhcpv6/dhcpv6message.go index 0b84dae..e601932 100644 --- a/dhcpv6/dhcpv6message.go +++ b/dhcpv6/dhcpv6message.go @@ -71,12 +71,12 @@ func NewSolicitWithCID(duid Duid, modifiers ...Modifier) (DHCPv6, error) { if err != nil { return nil, err } - d.(*DHCPv6Message).SetMessage(SOLICIT) + d.(*DHCPv6Message).SetMessage(MessageTypeSolicit) d.AddOption(&OptClientId{Cid: duid}) oro := new(OptRequestedOption) oro.SetRequestedOptions([]OptionCode{ - DNS_RECURSIVE_NAME_SERVER, - DOMAIN_SEARCH_LIST, + OptionDNSRecursiveNameServer, + OptionDomainSearchList, }) d.AddOption(oro) d.AddOption(&OptElapsedTime{}) @@ -114,7 +114,7 @@ func NewAdvertiseFromSolicit(solicit DHCPv6, modifiers ...Modifier) (DHCPv6, err if solicit == nil { return nil, errors.New("SOLICIT cannot be nil") } - if solicit.Type() != SOLICIT { + if solicit.Type() != MessageTypeSolicit { return nil, errors.New("The passed SOLICIT must have SOLICIT type set") } sol, ok := solicit.(*DHCPv6Message) @@ -123,10 +123,10 @@ func NewAdvertiseFromSolicit(solicit DHCPv6, modifiers ...Modifier) (DHCPv6, err } // build ADVERTISE from SOLICIT adv := DHCPv6Message{} - adv.SetMessage(ADVERTISE) + adv.SetMessage(MessageTypeAdvertise) adv.SetTransactionID(sol.TransactionID()) // add Client ID - cid := sol.GetOneOption(OPTION_CLIENTID) + cid := sol.GetOneOption(OptionClientID) if cid == nil { return nil, errors.New("Client ID cannot be nil in SOLICIT when building ADVERTISE") } @@ -146,7 +146,7 @@ func NewRequestFromAdvertise(advertise DHCPv6, modifiers ...Modifier) (DHCPv6, e if advertise == nil { return nil, fmt.Errorf("ADVERTISE cannot be nil") } - if advertise.Type() != ADVERTISE { + if advertise.Type() != MessageTypeAdvertise { return nil, fmt.Errorf("The passed ADVERTISE must have ADVERTISE type set") } adv, ok := advertise.(*DHCPv6Message) @@ -155,16 +155,16 @@ func NewRequestFromAdvertise(advertise DHCPv6, modifiers ...Modifier) (DHCPv6, e } // build REQUEST from ADVERTISE req := DHCPv6Message{} - req.SetMessage(REQUEST) + req.SetMessage(MessageTypeRequest) req.SetTransactionID(adv.TransactionID()) // add Client ID - cid := adv.GetOneOption(OPTION_CLIENTID) + cid := adv.GetOneOption(OptionClientID) if cid == nil { return nil, fmt.Errorf("Client ID cannot be nil in ADVERTISE when building REQUEST") } req.AddOption(cid) // add Server ID - sid := adv.GetOneOption(OPTION_SERVERID) + sid := adv.GetOneOption(OptionServerID) if sid == nil { return nil, fmt.Errorf("Server ID cannot be nil in ADVERTISE when building REQUEST") } @@ -172,7 +172,7 @@ func NewRequestFromAdvertise(advertise DHCPv6, modifiers ...Modifier) (DHCPv6, e // add Elapsed Time req.AddOption(&OptElapsedTime{}) // add IA_NA - iaNa := adv.GetOneOption(OPTION_IA_NA) + iaNa := adv.GetOneOption(OptionIANA) if iaNa == nil { return nil, fmt.Errorf("IA_NA cannot be nil in ADVERTISE when building REQUEST") } @@ -180,13 +180,13 @@ func NewRequestFromAdvertise(advertise DHCPv6, modifiers ...Modifier) (DHCPv6, e // add OptRequestedOption oro := OptRequestedOption{} oro.SetRequestedOptions([]OptionCode{ - DNS_RECURSIVE_NAME_SERVER, - DOMAIN_SEARCH_LIST, + OptionDNSRecursiveNameServer, + OptionDomainSearchList, }) req.AddOption(&oro) // add OPTION_VENDOR_CLASS, only if present in the original request // TODO implement OptionVendorClass - vClass := adv.GetOneOption(OPTION_VENDOR_CLASS) + vClass := adv.GetOneOption(OptionVendorClass) if vClass != nil { req.AddOption(vClass) } @@ -207,9 +207,9 @@ func NewReplyFromDHCPv6Message(message DHCPv6, modifiers ...Modifier) (DHCPv6, e return nil, errors.New("DHCPv6Message cannot be nil") } switch message.Type() { - case REQUEST, CONFIRM, RENEW, REBIND, RELEASE: - default: - return nil, errors.New("Cannot create REPLY from the passed message type set") + case MessageTypeRequest, MessageTypeConfirm, MessageTypeRenew, MessageTypeRebind, MessageTypeRelease: + default: + return nil, errors.New("Cannot create REPLY from the passed message type set") } msg, ok := message.(*DHCPv6Message) if !ok { @@ -217,10 +217,10 @@ func NewReplyFromDHCPv6Message(message DHCPv6, modifiers ...Modifier) (DHCPv6, e } // build REPLY from MESSAGE rep := DHCPv6Message{} - rep.SetMessage(REPLY) + rep.SetMessage(MessageTypeReply) rep.SetTransactionID(msg.TransactionID()) // add Client ID - cid := message.GetOneOption(OPTION_CLIENTID) + cid := message.GetOneOption(OptionClientID) if cid == nil { return nil, errors.New("Client ID cannot be nil when building REPLY") } @@ -243,7 +243,7 @@ func (d *DHCPv6Message) SetMessage(messageType MessageType) { if msgString == "" { log.Printf("Warning: unknown DHCPv6 message type: %v", messageType) } - if messageType == RELAY_FORW || messageType == RELAY_REPL { + if messageType == MessageTypeRelayForward || messageType == MessageTypeRelayReply { log.Printf("Warning: using a RELAY message type with a non-relay message: %v (%v)", msgString, messageType) } diff --git a/dhcpv6/dhcpv6relay.go b/dhcpv6/dhcpv6relay.go index 1bde354..d9555cb 100644 --- a/dhcpv6/dhcpv6relay.go +++ b/dhcpv6/dhcpv6relay.go @@ -173,7 +173,7 @@ func NewRelayReplFromRelayForw(relayForw, msg DHCPv6) (DHCPv6, error) { if !ok { return nil, errors.New("Not a DHCPv6Relay") } - if relay.Type() != RELAY_FORW { + if relay.Type() != MessageTypeRelayForward { return nil, errors.New("The passed packet is not of type RELAY_FORW") } if msg == nil { @@ -185,7 +185,7 @@ func NewRelayReplFromRelayForw(relayForw, msg DHCPv6) (DHCPv6, error) { for { linkAddr = append(linkAddr, relay.LinkAddr()) peerAddr = append(peerAddr, relay.PeerAddr()) - optiids = append(optiids, relay.GetOneOption(OPTION_INTERFACE_ID)) + optiids = append(optiids, relay.GetOneOption(OptionInterfaceID)) decap, err := DecapsulateRelay(relay) if err != nil { return nil, err @@ -197,7 +197,7 @@ func NewRelayReplFromRelayForw(relayForw, msg DHCPv6) (DHCPv6, error) { } } for i := len(linkAddr) - 1; i >= 0; i-- { - msg, err = EncapsulateRelay(msg, RELAY_REPL, linkAddr[i], peerAddr[i]) + msg, err = EncapsulateRelay(msg, MessageTypeRelayReply, linkAddr[i], peerAddr[i]) if opt := optiids[i]; opt != nil { msg.AddOption(opt) } diff --git a/dhcpv6/dhcpv6relay_test.go b/dhcpv6/dhcpv6relay_test.go index e08e6a4..afb4086 100644 --- a/dhcpv6/dhcpv6relay_test.go +++ b/dhcpv6/dhcpv6relay_test.go @@ -12,15 +12,15 @@ func TestDHCPv6Relay(t *testing.T) { ll := net.IP{0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, 0xbb, 0xcc, 0xff, 0xfe, 0xdd, 0xee, 0xff} ma := net.IP{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01} r := DHCPv6Relay{ - messageType: RELAY_FORW, + messageType: MessageTypeRelayForward, hopCount: 10, linkAddr: ll, peerAddr: ma, // options is left empty here for testing purposes, even if it's // mandatory to have at least a relay message option } - if mt := r.MessageType(); mt != RELAY_FORW { - t.Fatalf("Invalid message type. Expected %v, got %v", RELAY_FORW, mt) + if mt := r.MessageType(); mt != MessageTypeRelayForward { + t.Fatalf("Invalid message type. Expected %v, got %v", MessageTypeRelayForward, mt) } if hc := r.HopCount(); hc != 10 { t.Fatalf("Invalid hop count. Expected 10, got %v", hc) @@ -39,9 +39,9 @@ func TestDHCPv6Relay(t *testing.T) { func TestDHCPv6RelaySettersAndGetters(t *testing.T) { r := DHCPv6Relay{} // set and get message type - r.SetMessageType(RELAY_REPL) - if mt := r.MessageType(); mt != RELAY_REPL { - t.Fatalf("Invalid message type. Expected %v, got %v", RELAY_REPL, mt) + r.SetMessageType(MessageTypeRelayReply) + if mt := r.MessageType(); mt != MessageTypeRelayReply { + t.Fatalf("Invalid message type. Expected %v, got %v", MessageTypeRelayReply, mt) } // set and get hop count r.SetHopCount(5) @@ -68,7 +68,7 @@ func TestDHCPv6RelaySettersAndGetters(t *testing.T) { func TestDHCPv6RelayToBytes(t *testing.T) { expected := []byte{ - 12, // RELAY_FORW + 12, // MessageTypeRelayForward 1, // hop count 0xff, 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01, // link addr 0xff, 0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x02, // peer addr @@ -76,7 +76,7 @@ func TestDHCPv6RelayToBytes(t *testing.T) { 0, 9, // relay msg 0, 10, // option length // inner dhcp solicit - 1, // SOLICIT + 1, // MessageTypeSolicit 0xaa, 0xbb, 0xcc, // transaction ID // inner option - elapsed time 0, 8, // elapsed time @@ -84,14 +84,14 @@ func TestDHCPv6RelayToBytes(t *testing.T) { 0, 0, } r := DHCPv6Relay{ - messageType: RELAY_FORW, + messageType: MessageTypeRelayForward, hopCount: 1, linkAddr: net.IPv6interfacelocalallnodes, peerAddr: net.IPv6linklocalallrouters, } opt := OptRelayMsg{ relayMessage: &DHCPv6Message{ - messageType: SOLICIT, + messageType: MessageTypeSolicit, transactionID: 0xaabbcc, options: []Option{ &OptElapsedTime{ @@ -109,12 +109,12 @@ func TestDHCPv6RelayToBytes(t *testing.T) { func TestNewRelayRepFromRelayForw(t *testing.T) { rf := DHCPv6Relay{} - rf.SetMessageType(RELAY_FORW) + rf.SetMessageType(MessageTypeRelayForward) rf.SetPeerAddr(net.IPv6linklocalallrouters) rf.SetLinkAddr(net.IPv6interfacelocalallnodes) oro := OptRelayMsg{} s := DHCPv6Message{} - s.SetMessage(SOLICIT) + s.SetMessage(MessageTypeSolicit) cid := OptClientId{} s.AddOption(&cid) oro.SetRelayMessage(&s) @@ -125,7 +125,7 @@ func TestNewRelayRepFromRelayForw(t *testing.T) { rr, err := NewRelayReplFromRelayForw(&rf, a) require.NoError(t, err) relay := rr.(*DHCPv6Relay) - require.Equal(t, rr.Type(), RELAY_REPL) + require.Equal(t, rr.Type(), MessageTypeRelayReply) require.Equal(t, relay.HopCount(), rf.HopCount()) require.Equal(t, relay.PeerAddr(), rf.PeerAddr()) require.Equal(t, relay.LinkAddr(), rf.LinkAddr()) diff --git a/dhcpv6/modifiers.go b/dhcpv6/modifiers.go index 54285cd..32d11ac 100644 --- a/dhcpv6/modifiers.go +++ b/dhcpv6/modifiers.go @@ -29,15 +29,15 @@ func WithNetboot(d DHCPv6) DHCPv6 { log.Printf("WithNetboot: not a DHCPv6Message") return d } - // add OPT_BOOTFILE_URL and OPT_BOOTFILE_PARAM - opt := msg.GetOneOption(OPTION_ORO) + // add OptionBootfileURL and OptionBootfileParam + opt := msg.GetOneOption(OptionORO) if opt == nil { opt = &OptRequestedOption{} } // TODO only add options if they are not there already oro := opt.(*OptRequestedOption) - oro.AddRequestedOption(OPT_BOOTFILE_URL) - oro.AddRequestedOption(OPT_BOOTFILE_PARAM) + oro.AddRequestedOption(OptionBootfileURL) + oro.AddRequestedOption(OptionBootfileParam) msg.UpdateOption(oro) return d } diff --git a/dhcpv6/modifiers_test.go b/dhcpv6/modifiers_test.go index da1ef56..ab21367 100644 --- a/dhcpv6/modifiers_test.go +++ b/dhcpv6/modifiers_test.go @@ -16,7 +16,7 @@ func TestWithClientID(t *testing.T) { } m, err := NewMessage(WithClientID(duid)) require.NoError(t, err) - opt := m.GetOneOption(OPTION_CLIENTID) + opt := m.GetOneOption(OptionClientID) require.NotNil(t, opt) cid := opt.(*OptClientId) require.Equal(t, cid.Cid, duid) @@ -30,7 +30,7 @@ func TestWithServerID(t *testing.T) { } m, err := NewMessage(WithServerID(duid)) require.NoError(t, err) - opt := m.GetOneOption(OPTION_SERVERID) + opt := m.GetOneOption(OptionServerID) require.NotNil(t, opt) sid := opt.(*OptServerId) require.Equal(t, sid.Sid, duid) diff --git a/dhcpv6/option_archtype.go b/dhcpv6/option_archtype.go index 802e334..a1b4a9b 100644 --- a/dhcpv6/option_archtype.go +++ b/dhcpv6/option_archtype.go @@ -45,12 +45,12 @@ type OptClientArchType struct { } func (op *OptClientArchType) Code() OptionCode { - return OPTION_CLIENT_ARCH_TYPE + return OptionClientArchType } func (op *OptClientArchType) ToBytes() []byte { buf := make([]byte, 6) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_CLIENT_ARCH_TYPE)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionClientArchType)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) binary.BigEndian.PutUint16(buf[4:6], uint16(op.ArchType)) return buf diff --git a/dhcpv6/option_archtype_test.go b/dhcpv6/option_archtype_test.go index b446661..748c8c5 100644 --- a/dhcpv6/option_archtype_test.go +++ b/dhcpv6/option_archtype_test.go @@ -26,7 +26,7 @@ func TestOptClientArchTypeParseAndToBytes(t *testing.T) { 0, 8, // EFI_XSCALE } expected := []byte{ - 0, 61, // OPTION_CLIENT_ARCH_TYPE + 0, 61, // OptionClientArchType 0, 2, // length 0, 8, // EFI_XSCALE } @@ -40,5 +40,5 @@ func TestOptClientArchType(t *testing.T) { ArchType: EFI_ITANIUM, } require.Equal(t, opt.Length(), 2) - require.Equal(t, opt.Code(), OPTION_CLIENT_ARCH_TYPE) + require.Equal(t, opt.Code(), OptionClientArchType) } diff --git a/dhcpv6/option_bootfileurl.go b/dhcpv6/option_bootfileurl.go index e4817cb..d2da0c3 100644 --- a/dhcpv6/option_bootfileurl.go +++ b/dhcpv6/option_bootfileurl.go @@ -8,20 +8,20 @@ import ( "fmt" ) -// OptBootFileURL implements the OPT_BOOTFILE_URL option +// OptBootFileURL implements the OptionBootfileURL option type OptBootFileURL struct { BootFileURL []byte } // Code returns the option code func (op *OptBootFileURL) Code() OptionCode { - return OPT_BOOTFILE_URL + return OptionBootfileURL } // ToBytes serializes the option and returns it as a sequence of bytes func (op *OptBootFileURL) ToBytes() []byte { buf := make([]byte, 4) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPT_BOOTFILE_URL)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionBootfileURL)) binary.BigEndian.PutUint16(buf[2:4], uint16(len(op.BootFileURL))) buf = append(buf, op.BootFileURL...) return buf diff --git a/dhcpv6/option_clientid.go b/dhcpv6/option_clientid.go index 3c01d8c..fc68ae7 100644 --- a/dhcpv6/option_clientid.go +++ b/dhcpv6/option_clientid.go @@ -14,12 +14,12 @@ type OptClientId struct { } func (op *OptClientId) Code() OptionCode { - return OPTION_CLIENTID + return OptionClientID } func (op *OptClientId) ToBytes() []byte { buf := make([]byte, 4) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_CLIENTID)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionClientID)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) buf = append(buf, op.Cid.ToBytes()...) return buf diff --git a/dhcpv6/option_clientid_test.go b/dhcpv6/option_clientid_test.go index dcaffca..77839f3 100644 --- a/dhcpv6/option_clientid_test.go +++ b/dhcpv6/option_clientid_test.go @@ -30,7 +30,7 @@ func TestOptClientIdToBytes(t *testing.T) { }, } expected := []byte{ - 0, 1, // OPTION_CLIENTID + 0, 1, // OptionClientID 0, 10, // length 0, 3, // DUID_LL 0, 1, // hwtype ethernet @@ -46,7 +46,7 @@ func TestOptClientIdDecodeEncode(t *testing.T) { 5, 4, 3, 2, 1, 0, // hw addr } expected := append([]byte{ - 0, 1, // OPTION_CLIENTID + 0, 1, // OptionClientID 0, 10, // length }, data...) opt, err := ParseOptClientId(data) @@ -63,5 +63,5 @@ func TestOptionClientId(t *testing.T) { }, } require.Equal(t, opt.Length(), 10) - require.Equal(t, opt.Code(), OPTION_CLIENTID) + require.Equal(t, opt.Code(), OptionClientID) } diff --git a/dhcpv6/option_dnsrecursivenameserver.go b/dhcpv6/option_dnsrecursivenameserver.go index 737a2d3..72b0767 100644 --- a/dhcpv6/option_dnsrecursivenameserver.go +++ b/dhcpv6/option_dnsrecursivenameserver.go @@ -9,21 +9,21 @@ import ( "net" ) -// OptDNSRecursiveNameServer represents a DNS_RECURSIVE_NAME_SERVER option +// OptDNSRecursiveNameServer represents a OptionDNSRecursiveNameServer option type OptDNSRecursiveNameServer struct { NameServers []net.IP } // Code returns the option code func (op *OptDNSRecursiveNameServer) Code() OptionCode { - return DNS_RECURSIVE_NAME_SERVER + return OptionDNSRecursiveNameServer } // ToBytes returns the option serialized to bytes, including option code and // length func (op *OptDNSRecursiveNameServer) ToBytes() []byte { buf := make([]byte, 4) - binary.BigEndian.PutUint16(buf[0:2], uint16(DNS_RECURSIVE_NAME_SERVER)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionDNSRecursiveNameServer)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) for _, ns := range op.NameServers { buf = append(buf, ns...) diff --git a/dhcpv6/option_dnsrecursivenameserver_test.go b/dhcpv6/option_dnsrecursivenameserver_test.go index 85bb982..71fe6d3 100644 --- a/dhcpv6/option_dnsrecursivenameserver_test.go +++ b/dhcpv6/option_dnsrecursivenameserver_test.go @@ -25,7 +25,7 @@ func TestOptDNSRecursiveNameServerToBytes(t *testing.T) { ns2 := net.ParseIP("2001:4860:4860::8888") nameservers := []net.IP{ns1, ns2} expected := []byte{ - 0, 23, // DNS_RECURSIVE_NAME_SERVER + 0, 23, // OptionDNSRecursiveNameServer 0, 32, // length } expected = append(expected, []byte(ns1)...) diff --git a/dhcpv6/option_domainsearchlist.go b/dhcpv6/option_domainsearchlist.go index 402c68e..a3c6f28 100644 --- a/dhcpv6/option_domainsearchlist.go +++ b/dhcpv6/option_domainsearchlist.go @@ -6,22 +6,24 @@ package dhcpv6 import ( "encoding/binary" "fmt" + + "github.com/insomniacslk/dhcp/rfc1035label" ) -// OptDomainSearchList list implements a DOMAIN_SEARCH_LIST option +// OptDomainSearchList list implements a OptionDomainSearchList option type OptDomainSearchList struct { DomainSearchList []string } func (op *OptDomainSearchList) Code() OptionCode { - return DOMAIN_SEARCH_LIST + return OptionDomainSearchList } func (op *OptDomainSearchList) ToBytes() []byte { buf := make([]byte, 4) - binary.BigEndian.PutUint16(buf[0:2], uint16(DOMAIN_SEARCH_LIST)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionDomainSearchList)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) - buf = append(buf, LabelsToBytes(op.DomainSearchList)...) + buf = append(buf, rfc1035label.LabelsToBytes(op.DomainSearchList)...) return buf } @@ -42,7 +44,7 @@ func (op *OptDomainSearchList) String() string { func ParseOptDomainSearchList(data []byte) (*OptDomainSearchList, error) { opt := OptDomainSearchList{} var err error - opt.DomainSearchList, err = LabelsFromBytes(data) + opt.DomainSearchList, err = rfc1035label.LabelsFromBytes(data) if err != nil { return nil, err } diff --git a/dhcpv6/option_domainsearchlist_test.go b/dhcpv6/option_domainsearchlist_test.go index d5b8bf7..68f93ba 100644 --- a/dhcpv6/option_domainsearchlist_test.go +++ b/dhcpv6/option_domainsearchlist_test.go @@ -20,7 +20,7 @@ func TestParseOptDomainSearchList(t *testing.T) { func TestOptDomainSearchListToBytes(t *testing.T) { expected := []byte{ - 0, 24, // DOMAIN_SEARCH_LIST + 0, 24, // OptionDomainSearchList 0, 33, // length 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0, 6, 's', 'u', 'b', 'n', 'e', 't', 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'o', 'r', 'g', 0, diff --git a/dhcpv6/option_elapsedtime.go b/dhcpv6/option_elapsedtime.go index e0a1094..6009bf8 100644 --- a/dhcpv6/option_elapsedtime.go +++ b/dhcpv6/option_elapsedtime.go @@ -13,12 +13,12 @@ type OptElapsedTime struct { } func (op *OptElapsedTime) Code() OptionCode { - return OPTION_ELAPSED_TIME + return OptionElapsedTime } func (op *OptElapsedTime) ToBytes() []byte { buf := make([]byte, 6) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_ELAPSED_TIME)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionElapsedTime)) binary.BigEndian.PutUint16(buf[2:4], 2) binary.BigEndian.PutUint16(buf[4:6], uint16(op.ElapsedTime)) return buf diff --git a/dhcpv6/option_iaaddress.go b/dhcpv6/option_iaaddress.go index 1a89a25..0500d83 100644 --- a/dhcpv6/option_iaaddress.go +++ b/dhcpv6/option_iaaddress.go @@ -9,7 +9,7 @@ import ( "net" ) -// OptIAAddress represents an OPTION_IAADDR +// OptIAAddress represents an OptionIAAddr type OptIAAddress struct { IPv6Addr net.IP PreferredLifetime uint32 @@ -19,13 +19,13 @@ type OptIAAddress struct { // Code returns the option's code func (op *OptIAAddress) Code() OptionCode { - return OPTION_IAADDR + return OptionIAAddr } // ToBytes serializes the option and returns it as a sequence of bytes func (op *OptIAAddress) ToBytes() []byte { buf := make([]byte, 28) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_IAADDR)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionIAAddr)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) copy(buf[4:20], op.IPv6Addr[:]) binary.BigEndian.PutUint32(buf[20:24], op.PreferredLifetime) diff --git a/dhcpv6/option_iaaddress_test.go b/dhcpv6/option_iaaddress_test.go index ad4f69c..0240949 100644 --- a/dhcpv6/option_iaaddress_test.go +++ b/dhcpv6/option_iaaddress_test.go @@ -45,7 +45,7 @@ func TestOptIAAddressParseInvalidBrokenOptions(t *testing.T) { func TestOptIAAddressToBytes(t *testing.T) { expected := []byte{ - 0, 5, // OPTION_IAADDR + 0, 5, // OptionIAAddr 0, 30, // length } ipBytes := []byte{0x24, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15} diff --git a/dhcpv6/option_iaprefix.go b/dhcpv6/option_iaprefix.go index 57810b1..3f6227b 100644 --- a/dhcpv6/option_iaprefix.go +++ b/dhcpv6/option_iaprefix.go @@ -18,12 +18,12 @@ type OptIAPrefix struct { } func (op *OptIAPrefix) Code() OptionCode { - return OPTION_IAPREFIX + return OptionIAPrefix } func (op *OptIAPrefix) ToBytes() []byte { buf := make([]byte, 12) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_IAPREFIX)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionIAPrefix)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) binary.BigEndian.PutUint32(buf[4:8], op.preferredLifetime) binary.BigEndian.PutUint32(buf[8:12], op.validLifetime) diff --git a/dhcpv6/option_interfaceid.go b/dhcpv6/option_interfaceid.go index 2634d9f..2bee744 100644 --- a/dhcpv6/option_interfaceid.go +++ b/dhcpv6/option_interfaceid.go @@ -13,12 +13,12 @@ type OptInterfaceId struct { } func (op *OptInterfaceId) Code() OptionCode { - return OPTION_INTERFACE_ID + return OptionInterfaceID } func (op *OptInterfaceId) ToBytes() []byte { buf := make([]byte, 4) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_INTERFACE_ID)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionInterfaceID)) binary.BigEndian.PutUint16(buf[2:4], uint16(len(op.interfaceId))) buf = append(buf, op.interfaceId...) return buf diff --git a/dhcpv6/option_nii.go b/dhcpv6/option_nii.go index 3a838ee..68e315e 100644 --- a/dhcpv6/option_nii.go +++ b/dhcpv6/option_nii.go @@ -33,12 +33,12 @@ type OptNetworkInterfaceId struct { } func (op *OptNetworkInterfaceId) Code() OptionCode { - return OPTION_NII + return OptionNII } func (op *OptNetworkInterfaceId) ToBytes() []byte { buf := make([]byte, 7) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_NII)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionNII)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) buf[4] = op.type_ buf[5] = op.major diff --git a/dhcpv6/option_nontemporaryaddress.go b/dhcpv6/option_nontemporaryaddress.go index 5debeec..62442c1 100644 --- a/dhcpv6/option_nontemporaryaddress.go +++ b/dhcpv6/option_nontemporaryaddress.go @@ -16,12 +16,12 @@ type OptIANA struct { } func (op *OptIANA) Code() OptionCode { - return OPTION_IA_NA + return OptionIANA } func (op *OptIANA) ToBytes() []byte { buf := make([]byte, 16) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_IA_NA)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionIANA)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) copy(buf[4:8], op.IaId[:]) binary.BigEndian.PutUint32(buf[8:12], op.T1) diff --git a/dhcpv6/option_nontemporaryaddress_test.go b/dhcpv6/option_nontemporaryaddress_test.go index 54df8f0..39c3c36 100644 --- a/dhcpv6/option_nontemporaryaddress_test.go +++ b/dhcpv6/option_nontemporaryaddress_test.go @@ -47,7 +47,7 @@ func TestOptIANAGetOneOption(t *testing.T) { opt := OptIANA{ Options: []Option{&OptElapsedTime{}, oaddr}, } - require.Equal(t, oaddr, opt.GetOneOption(OPTION_IAADDR)) + require.Equal(t, oaddr, opt.GetOneOption(OptionIAAddr)) } func TestOptIANAGetOneOptionMissingOpt(t *testing.T) { @@ -57,7 +57,7 @@ func TestOptIANAGetOneOptionMissingOpt(t *testing.T) { opt := OptIANA{ Options: []Option{&OptElapsedTime{}, oaddr}, } - require.Equal(t, nil, opt.GetOneOption(DNS_RECURSIVE_NAME_SERVER)) + require.Equal(t, nil, opt.GetOneOption(OptionDNSRecursiveNameServer)) } func TestOptIANADelOption(t *testing.T) { @@ -69,13 +69,13 @@ func TestOptIANADelOption(t *testing.T) { optiana1.Options = append(optiana1.Options, &optsc) optiana1.Options = append(optiana1.Options, &optiaaddr) optiana1.Options = append(optiana1.Options, &optiaaddr) - optiana1.DelOption(OPTION_IAADDR) + optiana1.DelOption(OptionIAAddr) require.Equal(t, optiana1.Options, []Option{&optsc}) optiana2.Options = append(optiana2.Options, &optiaaddr) optiana2.Options = append(optiana2.Options, &optsc) optiana2.Options = append(optiana2.Options, &optiaaddr) - optiana2.DelOption(OPTION_IAADDR) + optiana2.DelOption(OptionIAAddr) require.Equal(t, optiana2.Options, []Option{&optsc}) } @@ -91,7 +91,7 @@ func TestOptIANAToBytes(t *testing.T) { }, } expected := []byte{ - 0, 3, // OPTION_IA_NA + 0, 3, // OptionIANA 0, 18, // length 1, 2, 3, 4, // IA ID 0, 0, 0x30, 0x39, // T1 = 12345 diff --git a/dhcpv6/option_prefixdelegation.go b/dhcpv6/option_prefixdelegation.go index 2a211c0..ecc7990 100644 --- a/dhcpv6/option_prefixdelegation.go +++ b/dhcpv6/option_prefixdelegation.go @@ -16,12 +16,12 @@ type OptIAForPrefixDelegation struct { } func (op *OptIAForPrefixDelegation) Code() OptionCode { - return OPTION_IA_PD + return OptionIAPD } func (op *OptIAForPrefixDelegation) ToBytes() []byte { buf := make([]byte, 16) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_IA_PD)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionIAPD)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) copy(buf[4:8], op.iaId[:]) binary.BigEndian.PutUint32(buf[8:12], op.t1) diff --git a/dhcpv6/option_relaymsg.go b/dhcpv6/option_relaymsg.go index 98b9e84..89621ec 100644 --- a/dhcpv6/option_relaymsg.go +++ b/dhcpv6/option_relaymsg.go @@ -13,12 +13,12 @@ type OptRelayMsg struct { } func (op *OptRelayMsg) Code() OptionCode { - return OPTION_RELAY_MSG + return OptionRelayMsg } func (op *OptRelayMsg) ToBytes() []byte { buf := make([]byte, 4) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_RELAY_MSG)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionRelayMsg)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) buf = append(buf, op.relayMessage.ToBytes()...) return buf diff --git a/dhcpv6/option_relaymsg_test.go b/dhcpv6/option_relaymsg_test.go index 6d9d6a6..df2442c 100644 --- a/dhcpv6/option_relaymsg_test.go +++ b/dhcpv6/option_relaymsg_test.go @@ -7,7 +7,7 @@ import ( func TestRelayMsgParseOptRelayMsg(t *testing.T) { opt, err := ParseOptRelayMsg([]byte{ - 1, // SOLICIT + 1, // MessageTypeSolicit 0xaa, 0xbb, 0xcc, // transaction ID 0, 8, // option: elapsed time 0, 2, // option length @@ -16,9 +16,9 @@ func TestRelayMsgParseOptRelayMsg(t *testing.T) { if err != nil { t.Fatal(err) } - if code := opt.Code(); code != OPTION_RELAY_MSG { - t.Fatalf("Invalid option code. Expected OPTION_RELAY_MSG (%v), got %v", - OPTION_RELAY_MSG, code, + if code := opt.Code(); code != OptionRelayMsg { + t.Fatalf("Invalid option code. Expected OptionRelayMsg (%v), got %v", + OptionRelayMsg, code, ) } } @@ -27,7 +27,7 @@ func TestRelayMsgOptionsFromBytes(t *testing.T) { opts, err := OptionsFromBytes([]byte{ 0, 9, // option: relay message 0, 10, // relayed message length - 1, // SOLICIT + 1, // MessageTypeSolicit 0xaa, 0xbb, 0xcc, // transaction ID 0, 8, // option: elapsed time 0, 2, // option length @@ -40,9 +40,9 @@ func TestRelayMsgOptionsFromBytes(t *testing.T) { t.Fatalf("Invalid number of options. Expected 1, got %v", len(opts)) } opt := opts[0] - if code := opt.Code(); code != OPTION_RELAY_MSG { - t.Fatalf("Invalid option code. Expected OPTION_RELAY_MSG (%v), got %v", - OPTION_RELAY_MSG, code, + if code := opt.Code(); code != OptionRelayMsg { + t.Fatalf("Invalid option code. Expected OptionRelayMsg (%v), got %v", + OptionRelayMsg, code, ) } } @@ -55,7 +55,7 @@ func TestRelayMsgParseOptRelayMsgSingleEncapsulation(t *testing.T) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, // peerAddr 0, 9, // option: relay message 0, 10, // relayed message length - 1, // SOLICIT + 1, // MessageTypeSolicit 0xaa, 0xbb, 0xcc, // transaction ID 0, 8, // option: elapsed time 0, 2, // option length @@ -70,15 +70,15 @@ func TestRelayMsgParseOptRelayMsgSingleEncapsulation(t *testing.T) { reflect.TypeOf(d), ) } - if mType := r.Type(); mType != RELAY_FORW { - t.Fatalf("Invalid messge type for relay. Expected %v, got %v", RELAY_FORW, mType) + if mType := r.Type(); mType != MessageTypeRelayForward { + t.Fatalf("Invalid messge type for relay. Expected %v, got %v", MessageTypeRelayForward, mType) } if len(r.options) != 1 { t.Fatalf("Invalid number of options. Expected 1, got %v", len(r.options)) } - if code := r.options[0].Code(); code != OPTION_RELAY_MSG { - t.Fatalf("Invalid option code. Expected OPTION_RELAY_MSG (%v), got %v", - OPTION_RELAY_MSG, code, + if code := r.options[0].Code(); code != OptionRelayMsg { + t.Fatalf("Invalid option code. Expected OptionRelayMsg (%v), got %v", + OptionRelayMsg, code, ) } opt := r.options[0] @@ -94,9 +94,9 @@ func TestRelayMsgParseOptRelayMsgSingleEncapsulation(t *testing.T) { reflect.TypeOf(innerDHCP), ) } - if dType := innerDHCP.Type(); dType != SOLICIT { - t.Fatalf("Invalid inner DHCP type. Expected SOLICIT (%v), got %v", - SOLICIT, dType, + if dType := innerDHCP.Type(); dType != MessageTypeSolicit { + t.Fatalf("Invalid inner DHCP type. Expected MessageTypeSolicit (%v), got %v", + MessageTypeSolicit, dType, ) } if tID := innerDHCP.TransactionID(); tID != 0xaabbcc { diff --git a/dhcpv6/option_remoteid.go b/dhcpv6/option_remoteid.go index 210363d..9d249a7 100644 --- a/dhcpv6/option_remoteid.go +++ b/dhcpv6/option_remoteid.go @@ -14,12 +14,12 @@ type OptRemoteId struct { } func (op *OptRemoteId) Code() OptionCode { - return OPTION_REMOTE_ID + return OptionRemoteID } func (op *OptRemoteId) ToBytes() []byte { buf := make([]byte, 8) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_REMOTE_ID)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionRemoteID)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) binary.BigEndian.PutUint32(buf[4:8], uint32(op.enterpriseNumber)) buf = append(buf, op.remoteId...) diff --git a/dhcpv6/option_requestedoption.go b/dhcpv6/option_requestedoption.go index f6327f9..a55c533 100644 --- a/dhcpv6/option_requestedoption.go +++ b/dhcpv6/option_requestedoption.go @@ -13,13 +13,13 @@ type OptRequestedOption struct { } func (op *OptRequestedOption) Code() OptionCode { - return OPTION_ORO + return OptionORO } func (op *OptRequestedOption) ToBytes() []byte { buf := make([]byte, 4) roBytes := make([]byte, 2) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_ORO)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionORO)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) for _, ro := range op.requestedOptions { binary.BigEndian.PutUint16(roBytes, uint16(ro)) diff --git a/dhcpv6/option_serverid.go b/dhcpv6/option_serverid.go index ffc1b69..dbc17f5 100644 --- a/dhcpv6/option_serverid.go +++ b/dhcpv6/option_serverid.go @@ -14,12 +14,12 @@ type OptServerId struct { } func (op *OptServerId) Code() OptionCode { - return OPTION_SERVERID + return OptionServerID } func (op *OptServerId) ToBytes() []byte { buf := make([]byte, 4) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_SERVERID)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionServerID)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) buf = append(buf, op.Sid.ToBytes()...) return buf diff --git a/dhcpv6/option_serverid_test.go b/dhcpv6/option_serverid_test.go index f420b78..e330fa8 100644 --- a/dhcpv6/option_serverid_test.go +++ b/dhcpv6/option_serverid_test.go @@ -30,7 +30,7 @@ func TestOptServerIdToBytes(t *testing.T) { }, } expected := []byte{ - 0, 2, // OPTION_SERVERID + 0, 2, // OptionServerID 0, 10, // length 0, 3, // DUID_LL 0, 1, // hwtype ethernet @@ -46,7 +46,7 @@ func TestOptServerIdDecodeEncode(t *testing.T) { 5, 4, 3, 2, 1, 0, // hw addr } expected := append([]byte{ - 0, 2, // OPTION_SERVERID + 0, 2, // OptionServerID 0, 10, // length }, data...) opt, err := ParseOptServerId(data) @@ -63,5 +63,5 @@ func TestOptionServerId(t *testing.T) { }, } require.Equal(t, opt.Length(), 10) - require.Equal(t, opt.Code(), OPTION_SERVERID) + require.Equal(t, opt.Code(), OptionServerID) } diff --git a/dhcpv6/option_statuscode.go b/dhcpv6/option_statuscode.go index e6bd8ae..11f1cbf 100644 --- a/dhcpv6/option_statuscode.go +++ b/dhcpv6/option_statuscode.go @@ -18,13 +18,13 @@ type OptStatusCode struct { // Code returns the option code func (op *OptStatusCode) Code() OptionCode { - return OPTION_STATUS_CODE + return OptionStatusCode } // ToBytes serializes the option and returns it as a sequence of bytes func (op *OptStatusCode) ToBytes() []byte { buf := make([]byte, 6) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_STATUS_CODE)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionStatusCode)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) binary.BigEndian.PutUint16(buf[4:6], uint16(op.StatusCode)) buf = append(buf, op.StatusMessage...) diff --git a/dhcpv6/option_statuscode_test.go b/dhcpv6/option_statuscode_test.go index 95c785e..6d2ba94 100644 --- a/dhcpv6/option_statuscode_test.go +++ b/dhcpv6/option_statuscode_test.go @@ -20,7 +20,7 @@ func TestParseOptStatusCode(t *testing.T) { func TestOptStatusCodeToBytes(t *testing.T) { expected := []byte{ - 0, 13, // OPTION_STATUS_CODE + 0, 13, // OptionStatusCode 0, 9, // length 0, 0, // StatusSuccess 's', 'u', 'c', 'c', 'e', 's', 's', diff --git a/dhcpv6/option_types.go b/dhcpv6/option_types.go index 946dcd0..6a852ad 100644 --- a/dhcpv6/option_types.go +++ b/dhcpv6/option_types.go @@ -1,152 +1,153 @@ package dhcpv6 -// FIXME: rename all the options to have a consistent name, e.g. OPT_<NAME> +// All DHCPv6 options. const ( - OPTION_CLIENTID OptionCode = 1 - OPTION_SERVERID OptionCode = 2 - OPTION_IA_NA OptionCode = 3 - OPTION_IA_TA OptionCode = 4 - OPTION_IAADDR OptionCode = 5 - OPTION_ORO OptionCode = 6 - OPTION_PREFERENCE OptionCode = 7 - OPTION_ELAPSED_TIME OptionCode = 8 - OPTION_RELAY_MSG OptionCode = 9 + OptionClientID OptionCode = 1 + OptionServerID OptionCode = 2 + OptionIANA OptionCode = 3 + OptionIATA OptionCode = 4 + OptionIAAddr OptionCode = 5 + OptionORO OptionCode = 6 + OptionPreference OptionCode = 7 + OptionElapsedTime OptionCode = 8 + OptionRelayMsg OptionCode = 9 // skip 10 - OPTION_AUTH OptionCode = 11 - OPTION_UNICAST OptionCode = 12 - OPTION_STATUS_CODE OptionCode = 13 - OPTION_RAPID_COMMIT OptionCode = 14 - OPTION_USER_CLASS OptionCode = 15 - OPTION_VENDOR_CLASS OptionCode = 16 - OPTION_VENDOR_OPTS OptionCode = 17 - OPTION_INTERFACE_ID OptionCode = 18 - OPTION_RECONF_MSG OptionCode = 19 - OPTION_RECONF_ACCEPT OptionCode = 20 - SIP_SERVERS_DOMAIN_NAME_LIST OptionCode = 21 - SIP_SERVERS_IPV6_ADDRESS_LIST OptionCode = 22 - DNS_RECURSIVE_NAME_SERVER OptionCode = 23 - DOMAIN_SEARCH_LIST OptionCode = 24 - OPTION_IA_PD OptionCode = 25 - OPTION_IAPREFIX OptionCode = 26 - OPTION_NIS_SERVERS OptionCode = 27 - OPTION_NISP_SERVERS OptionCode = 28 - OPTION_NIS_DOMAIN_NAME OptionCode = 29 - OPTION_NISP_DOMAIN_NAME OptionCode = 30 - SNTP_SERVER_LIST OptionCode = 31 - INFORMATION_REFRESH_TIME OptionCode = 32 - BCMCS_CONTROLLER_DOMAIN_NAME_LIST OptionCode = 33 - BCMCS_CONTROLLER_IPV6_ADDRESS_LIST OptionCode = 34 + OptionAuth OptionCode = 11 + OptionUnicast OptionCode = 12 + OptionStatusCode OptionCode = 13 + OptionRapidCommit OptionCode = 14 + OptionUserClass OptionCode = 15 + OptionVendorClass OptionCode = 16 + OptionVendorOpts OptionCode = 17 + OptionInterfaceID OptionCode = 18 + OptionReconfMessage OptionCode = 19 + OptionReconfAccept OptionCode = 20 + OptionSIPServersDomainNameList OptionCode = 21 + OptionSIPServersIPv6AddressList OptionCode = 22 + OptionDNSRecursiveNameServer OptionCode = 23 + OptionDomainSearchList OptionCode = 24 + OptionIAPD OptionCode = 25 + OptionIAPrefix OptionCode = 26 + OptionNISServers OptionCode = 27 + OptionNISPServers OptionCode = 28 + OptionNISDomainName OptionCode = 29 + OptionNISPDomainName OptionCode = 30 + OptionSNTPServerList OptionCode = 31 + OptionInformationRefreshTime OptionCode = 32 + OptionBCMCSControllerDomainNameList OptionCode = 33 + OptionBCMCSControllerIPv6AddressList OptionCode = 34 // skip 35 - OPTION_GEOCONF_CIVIC OptionCode = 36 - OPTION_REMOTE_ID OptionCode = 37 - RELAY_AGENT_SUBSCRIBER_ID OptionCode = 38 - FQDN OptionCode = 39 - PANA_AUTHENTICATION_AGENT OptionCode = 40 - OPTION_NEW_POSIX_TIMEZONE OptionCode = 41 - OPTION_NEW_TZDB_TIMEZONE OptionCode = 42 - ECHO_REQUEST OptionCode = 43 - OPTION_LQ_QUERY OptionCode = 44 - OPTION_CLIENT_DATA OptionCode = 45 - OPTION_CLT_TIME OptionCode = 46 - OPTION_LQ_RELAY_DATA OptionCode = 47 - OPTION_LQ_CLIENT_LINK OptionCode = 48 - MIPV6_HOME_NETWORK_ID_FQDN OptionCode = 49 - MIPV6_VISITED_HOME_NETWORK_INFORMATION OptionCode = 50 - LOST_SERVER OptionCode = 51 - CAPWAP_ACCESS_CONTROLLER_ADDRESSES OptionCode = 52 - RELAY_ID OptionCode = 53 - OPTION_IPV6_ADDRESS_MOS OptionCode = 54 - OPTION_IPV6_FQDN_MOS OptionCode = 55 - OPTION_NTP_SERVER OptionCode = 56 - OPTION_V6_ACCESS_DOMAIN OptionCode = 57 - OPTION_SIP_UA_CS_LIST OptionCode = 58 - OPT_BOOTFILE_URL OptionCode = 59 - OPT_BOOTFILE_PARAM OptionCode = 60 - OPTION_CLIENT_ARCH_TYPE OptionCode = 61 - OPTION_NII OptionCode = 62 - OPTION_GEOLOCATION OptionCode = 63 - OPTION_AFTR_NAME OptionCode = 64 - OPTION_ERP_LOCAL_DOMAIN_NAME OptionCode = 65 - OPTION_RSOO OptionCode = 66 - OPTION_PD_EXCLUDE OptionCode = 67 - VIRTUAL_SUBNET_SELECTION OptionCode = 68 - MIPV6_IDENTIFIED_HOME_NETWORK_INFORMATION OptionCode = 69 - MIPV6_UNRESTRICTED_HOME_NETWORK_INFORMATION OptionCode = 70 - MIPV6_HOME_NETWORK_PREFIX OptionCode = 71 - MIPV6_HOME_AGENT_ADDRESS OptionCode = 72 - MIPV6_HOME_AGENT_FQDN OptionCode = 73 + OptionGeoConfCivic OptionCode = 36 + OptionRemoteID OptionCode = 37 + OptionRelayAgentSubscriberID OptionCode = 38 + OptionFQDN OptionCode = 39 + OptionPANAAuthenticationAgent OptionCode = 40 + OptionNewPOSIXTimezone OptionCode = 41 + OptionNewTZDBTimezone OptionCode = 42 + OptionEchoRequest OptionCode = 43 + OptionLQQuery OptionCode = 44 + OptionClientData OptionCode = 45 + OptionCLTTime OptionCode = 46 + OptionLQRelayData OptionCode = 47 + OptionLQClientLink OptionCode = 48 + OptionMIPv6HomeNetworkIDFQDN OptionCode = 49 + OptionMIPv6VisitedHomeNetworkInformation OptionCode = 50 + OptionLoSTServer OptionCode = 51 + OptionCAPWAPAccessControllerAddresses OptionCode = 52 + OptionRelayID OptionCode = 53 + OptionIPv6AddressMOS OptionCode = 54 + OptionIPv6FQDNMOS OptionCode = 55 + OptionNTPServer OptionCode = 56 + OptionV6AccessDomain OptionCode = 57 + OptionSIPUACSList OptionCode = 58 + OptionBootfileURL OptionCode = 59 + OptionBootfileParam OptionCode = 60 + OptionClientArchType OptionCode = 61 + OptionNII OptionCode = 62 + OptionGeolocation OptionCode = 63 + OptionAFTRName OptionCode = 64 + OptionERPLocalDomainName OptionCode = 65 + OptionRSOO OptionCode = 66 + OptionPDExclude OptionCode = 67 + OptionVirtualSubnetSelection OptionCode = 68 + OptionMIPv6IdentifiedHomeNetworkInformation OptionCode = 69 + OptionMIPv6UnrestrictedHomeNetworkInformation OptionCode = 70 + OptionMIPv6HomeNetworkPrefix OptionCode = 71 + OptionMIPv6HomeAgentAddress OptionCode = 72 + OptionMIPv6HomeAgentFQDN OptionCode = 73 ) +// OptionCodeToString maps DHCPv6 OptionCodes to human-readable strings. var OptionCodeToString = map[OptionCode]string{ - OPTION_CLIENTID: "OPTION_CLIENTID", - OPTION_SERVERID: "OPTION_SERVERID", - OPTION_IA_NA: "OPTION_IA_NA", - OPTION_IA_TA: "OPTION_IA_TA", - OPTION_IAADDR: "OPTION_IAADDR", - OPTION_ORO: "OPTION_ORO", - OPTION_PREFERENCE: "OPTION_PREFERENCE", - OPTION_ELAPSED_TIME: "OPTION_ELAPSED_TIME", - OPTION_RELAY_MSG: "OPTION_RELAY_MSG", - OPTION_AUTH: "OPTION_AUTH", - OPTION_UNICAST: "OPTION_UNICAST", - OPTION_STATUS_CODE: "OPTION_STATUS_CODE", - OPTION_RAPID_COMMIT: "OPTION_RAPID_COMMIT", - OPTION_USER_CLASS: "OPTION_USER_CLASS", - OPTION_VENDOR_CLASS: "OPTION_VENDOR_CLASS", - OPTION_VENDOR_OPTS: "OPTION_VENDOR_OPTS", - OPTION_INTERFACE_ID: "OPTION_INTERFACE_ID", - OPTION_RECONF_MSG: "OPTION_RECONF_MSG", - OPTION_RECONF_ACCEPT: "OPTION_RECONF_ACCEPT", - SIP_SERVERS_DOMAIN_NAME_LIST: "SIP Servers Domain Name List", - SIP_SERVERS_IPV6_ADDRESS_LIST: "SIP Servers IPv6 Address List", - DNS_RECURSIVE_NAME_SERVER: "DNS Recursive Name Server", - DOMAIN_SEARCH_LIST: "Domain Search List", - OPTION_IA_PD: "OPTION_IA_PD", - OPTION_IAPREFIX: "OPTION_IAPREFIX", - OPTION_NIS_SERVERS: "OPTION_NIS_SERVERS", - OPTION_NISP_SERVERS: "OPTION_NISP_SERVERS", - OPTION_NIS_DOMAIN_NAME: "OPTION_NIS_DOMAIN_NAME", - OPTION_NISP_DOMAIN_NAME: "OPTION_NISP_DOMAIN_NAME", - SNTP_SERVER_LIST: "SNTP Server List", - INFORMATION_REFRESH_TIME: "Information Refresh Time", - BCMCS_CONTROLLER_DOMAIN_NAME_LIST: "BCMCS Controller Domain Name List", - BCMCS_CONTROLLER_IPV6_ADDRESS_LIST: "BCMCS Controller IPv6 Address List", - OPTION_GEOCONF_CIVIC: "OPTION_GEOCONF", - OPTION_REMOTE_ID: "OPTION_REMOTE_ID", - RELAY_AGENT_SUBSCRIBER_ID: "Relay-Agent Subscriber ID", - FQDN: "FQDN", - PANA_AUTHENTICATION_AGENT: "PANA Authentication Agent", - OPTION_NEW_POSIX_TIMEZONE: "OPTION_NEW_POSIX_TIME_ZONE", - OPTION_NEW_TZDB_TIMEZONE: "OPTION_NEW_TZDB_TIMEZONE", - ECHO_REQUEST: "Echo Request", - OPTION_LQ_QUERY: "OPTION_LQ_QUERY", - OPTION_CLIENT_DATA: "OPTION_CLIENT_DATA", - OPTION_CLT_TIME: "OPTION_CLT_TIME", - OPTION_LQ_RELAY_DATA: "OPTION_LQ_RELAY_DATA", - OPTION_LQ_CLIENT_LINK: "OPTION_LQ_CLIENT_LINK", - MIPV6_HOME_NETWORK_ID_FQDN: "MIPv6 Home Network ID FQDN", - MIPV6_VISITED_HOME_NETWORK_INFORMATION: "MIPv6 Visited Home Network Information", - LOST_SERVER: "LoST Server", - CAPWAP_ACCESS_CONTROLLER_ADDRESSES: "CAPWAP Access Controller Addresses", - RELAY_ID: "RELAY_ID", - OPTION_IPV6_ADDRESS_MOS: "OPTION-IPv6_Address-MoS", - OPTION_IPV6_FQDN_MOS: "OPTION-IPv6-FQDN-MoS", - OPTION_NTP_SERVER: "OPTION_NTP_SERVER", - OPTION_V6_ACCESS_DOMAIN: "OPTION_V6_ACCESS_DOMAIN", - OPTION_SIP_UA_CS_LIST: "OPTION_SIP_UA_CS_LIST", - OPT_BOOTFILE_URL: "OPT_BOOTFILE_URL", - OPT_BOOTFILE_PARAM: "OPT_BOOTFILE_PARAM", - OPTION_CLIENT_ARCH_TYPE: "OPTION_CLIENT_ARCH_TYPE", - OPTION_NII: "OPTION_NII", - OPTION_GEOLOCATION: "OPTION_GEOLOCATION", - OPTION_AFTR_NAME: "OPTION_AFTR_NAME", - OPTION_ERP_LOCAL_DOMAIN_NAME: "OPTION_ERP_LOCAL_DOMAIN_NAME", - OPTION_RSOO: "OPTION_RSOO", - OPTION_PD_EXCLUDE: "OPTION_PD_EXCLUDE", - VIRTUAL_SUBNET_SELECTION: "Virtual Subnet Selection", - MIPV6_IDENTIFIED_HOME_NETWORK_INFORMATION: "MIPv6 Identified Home Network Information", - MIPV6_UNRESTRICTED_HOME_NETWORK_INFORMATION: "MIPv6 Unrestricted Home Network Information", - MIPV6_HOME_NETWORK_PREFIX: "MIPv6 Home Network Prefix", - MIPV6_HOME_AGENT_ADDRESS: "MIPv6 Home Agent Address", - MIPV6_HOME_AGENT_FQDN: "MIPv6 Home Agent FQDN", + OptionClientID: "OPTION_CLIENTID", + OptionServerID: "OPTION_SERVERID", + OptionIANA: "OPTION_IA_NA", + OptionIATA: "OPTION_IA_TA", + OptionIAAddr: "OPTION_IAADDR", + OptionORO: "OPTION_ORO", + OptionPreference: "OPTION_PREFERENCE", + OptionElapsedTime: "OPTION_ELAPSED_TIME", + OptionRelayMsg: "OPTION_RELAY_MSG", + OptionAuth: "OPTION_AUTH", + OptionUnicast: "OPTION_UNICAST", + OptionStatusCode: "OPTION_STATUS_CODE", + OptionRapidCommit: "OPTION_RAPID_COMMIT", + OptionUserClass: "OPTION_USER_CLASS", + OptionVendorClass: "OPTION_VENDOR_CLASS", + OptionVendorOpts: "OPTION_VENDOR_OPTS", + OptionInterfaceID: "OPTION_INTERFACE_ID", + OptionReconfMessage: "OPTION_RECONF_MSG", + OptionReconfAccept: "OPTION_RECONF_ACCEPT", + OptionSIPServersDomainNameList: "SIP Servers Domain Name List", + OptionSIPServersIPv6AddressList: "SIP Servers IPv6 Address List", + OptionDNSRecursiveNameServer: "DNS Recursive Name Server", + OptionDomainSearchList: "Domain Search List", + OptionIAPD: "OPTION_IA_PD", + OptionIAPrefix: "OPTION_IAPREFIX", + OptionNISServers: "OPTION_NIS_SERVERS", + OptionNISPServers: "OPTION_NISP_SERVERS", + OptionNISDomainName: "OPTION_NIS_DOMAIN_NAME", + OptionNISPDomainName: "OPTION_NISP_DOMAIN_NAME", + OptionSNTPServerList: "SNTP Server List", + OptionInformationRefreshTime: "Information Refresh Time", + OptionBCMCSControllerDomainNameList: "BCMCS Controller Domain Name List", + OptionBCMCSControllerIPv6AddressList: "BCMCS Controller IPv6 Address List", + OptionGeoConfCivic: "OPTION_GEOCONF", + OptionRemoteID: "OPTION_REMOTE_ID", + OptionRelayAgentSubscriberID: "Relay-Agent Subscriber ID", + OptionFQDN: "FQDN", + OptionPANAAuthenticationAgent: "PANA Authentication Agent", + OptionNewPOSIXTimezone: "OPTION_NEW_POSIX_TIME_ZONE", + OptionNewTZDBTimezone: "OPTION_NEW_TZDB_TIMEZONE", + OptionEchoRequest: "Echo Request", + OptionLQQuery: "OPTION_LQ_QUERY", + OptionClientData: "OPTION_CLIENT_DATA", + OptionCLTTime: "OPTION_CLT_TIME", + OptionLQRelayData: "OPTION_LQ_RELAY_DATA", + OptionLQClientLink: "OPTION_LQ_CLIENT_LINK", + OptionMIPv6HomeNetworkIDFQDN: "MIPv6 Home Network ID FQDN", + OptionMIPv6VisitedHomeNetworkInformation: "MIPv6 Visited Home Network Information", + OptionLoSTServer: "LoST Server", + OptionCAPWAPAccessControllerAddresses: "CAPWAP Access Controller Addresses", + OptionRelayID: "RELAY_ID", + OptionIPv6AddressMOS: "OPTION-IPv6_Address-MoS", + OptionIPv6FQDNMOS: "OPTION-IPv6-FQDN-MoS", + OptionNTPServer: "OPTION_NTP_SERVER", + OptionV6AccessDomain: "OPTION_V6_ACCESS_DOMAIN", + OptionSIPUACSList: "OPTION_SIP_UA_CS_LIST", + OptionBootfileURL: "OPT_BOOTFILE_URL", + OptionBootfileParam: "OPT_BOOTFILE_PARAM", + OptionClientArchType: "OPTION_CLIENT_ARCH_TYPE", + OptionNII: "OPTION_NII", + OptionGeolocation: "OPTION_GEOLOCATION", + OptionAFTRName: "OPTION_AFTR_NAME", + OptionERPLocalDomainName: "OPTION_ERP_LOCAL_DOMAIN_NAME", + OptionRSOO: "OPTION_RSOO", + OptionPDExclude: "OPTION_PD_EXCLUDE", + OptionVirtualSubnetSelection: "Virtual Subnet Selection", + OptionMIPv6IdentifiedHomeNetworkInformation: "MIPv6 Identified Home Network Information", + OptionMIPv6UnrestrictedHomeNetworkInformation: "MIPv6 Unrestricted Home Network Information", + OptionMIPv6HomeNetworkPrefix: "MIPv6 Home Network Prefix", + OptionMIPv6HomeAgentAddress: "MIPv6 Home Agent Address", + OptionMIPv6HomeAgentFQDN: "MIPv6 Home Agent FQDN", } diff --git a/dhcpv6/option_userclass.go b/dhcpv6/option_userclass.go index c5ac4ca..652c216 100644 --- a/dhcpv6/option_userclass.go +++ b/dhcpv6/option_userclass.go @@ -17,13 +17,13 @@ type OptUserClass struct { // Code returns the option code func (op *OptUserClass) Code() OptionCode { - return OPTION_USER_CLASS + return OptionUserClass } // ToBytes serializes the option and returns it as a sequence of bytes func (op *OptUserClass) ToBytes() []byte { buf := make([]byte, 4) - binary.BigEndian.PutUint16(buf[0:2], uint16(OPTION_USER_CLASS)) + binary.BigEndian.PutUint16(buf[0:2], uint16(OptionUserClass)) binary.BigEndian.PutUint16(buf[2:4], uint16(op.Length())) u16 := make([]byte, 2) for _, uc := range op.UserClasses { diff --git a/dhcpv6/option_userclass_test.go b/dhcpv6/option_userclass_test.go index 92c3848..3ba65cf 100644 --- a/dhcpv6/option_userclass_test.go +++ b/dhcpv6/option_userclass_test.go @@ -40,7 +40,7 @@ func TestOptUserClassToBytes(t *testing.T) { } data := opt.ToBytes() expected := []byte{ - 0, 15, // OPTION_USER_CLASS + 0, 15, // OptionUserClass 0, 11, // length 0, 9, 'l', 'i', 'n', 'u', 'x', 'b', 'o', 'o', 't', } @@ -56,7 +56,7 @@ func TestOptUserClassToBytesMultiple(t *testing.T) { } data := opt.ToBytes() expected := []byte{ - 0, 15, // OPTION_USER_CLASS + 0, 15, // OptionUserClass 0, 17, // length 0, 9, 'l', 'i', 'n', 'u', 'x', 'b', 'o', 'o', 't', 0, 4, 't', 'e', 's', 't', diff --git a/dhcpv6/options.go b/dhcpv6/options.go index d64d1d9..0a0bdc1 100644 --- a/dhcpv6/options.go +++ b/dhcpv6/options.go @@ -68,41 +68,41 @@ func ParseOption(dataStart []byte) (Option, error) { ) optData := dataStart[4 : 4+length] switch code { - case OPTION_CLIENTID: + case OptionClientID: opt, err = ParseOptClientId(optData) - case OPTION_SERVERID: + case OptionServerID: opt, err = ParseOptServerId(optData) - case OPTION_ELAPSED_TIME: + case OptionElapsedTime: opt, err = ParseOptElapsedTime(optData) - case OPTION_ORO: + case OptionORO: opt, err = ParseOptRequestedOption(optData) - case DNS_RECURSIVE_NAME_SERVER: + case OptionDNSRecursiveNameServer: opt, err = ParseOptDNSRecursiveNameServer(optData) - case DOMAIN_SEARCH_LIST: + case OptionDomainSearchList: opt, err = ParseOptDomainSearchList(optData) - case OPTION_IA_NA: + case OptionIANA: opt, err = ParseOptIANA(optData) - case OPTION_IA_PD: + case OptionIAPD: opt, err = ParseOptIAForPrefixDelegation(optData) - case OPTION_IAADDR: + case OptionIAAddr: opt, err = ParseOptIAAddress(optData) - case OPTION_IAPREFIX: + case OptionIAPrefix: opt, err = ParseOptIAPrefix(optData) - case OPTION_STATUS_CODE: + case OptionStatusCode: opt, err = ParseOptStatusCode(optData) - case OPTION_RELAY_MSG: + case OptionRelayMsg: opt, err = ParseOptRelayMsg(optData) - case OPTION_REMOTE_ID: + case OptionRemoteID: opt, err = ParseOptRemoteId(optData) - case OPTION_INTERFACE_ID: + case OptionInterfaceID: opt, err = ParseOptInterfaceId(optData) - case OPTION_CLIENT_ARCH_TYPE: + case OptionClientArchType: opt, err = ParseOptClientArchType(optData) - case OPTION_NII: + case OptionNII: opt, err = ParseOptNetworkInterfaceId(optData) - case OPT_BOOTFILE_URL: + case OptionBootfileURL: opt, err = ParseOptBootFileURL(optData) - case OPTION_USER_CLASS: + case OptionUserClass: opt, err = ParseOptUserClass(optData) default: opt = &OptionGeneric{OptionCode: code, OptionData: optData} diff --git a/dhcpv6/types.go b/dhcpv6/types.go index 795a284..1ef5938 100644 --- a/dhcpv6/types.go +++ b/dhcpv6/types.go @@ -2,53 +2,59 @@ package dhcpv6 // from http://www.networksorcery.com/enp/protocol/dhcpv6.htm +// MessageType represents the kind of DHCPv6 message. type MessageType uint8 +// The different kinds of DHCPv6 message types. const ( - // MSGTYPE_NONE is used internally and is not part of the RFC - MSGTYPE_NONE MessageType = 0 - SOLICIT MessageType = 1 - ADVERTISE MessageType = 2 - REQUEST MessageType = 3 - CONFIRM MessageType = 4 - RENEW MessageType = 5 - REBIND MessageType = 6 - REPLY MessageType = 7 - RELEASE MessageType = 8 - DECLINE MessageType = 9 - RECONFIGURE MessageType = 10 - INFORMATION_REQUEST MessageType = 11 - RELAY_FORW MessageType = 12 - RELAY_REPL MessageType = 13 - LEASEQUERY MessageType = 14 - LEASEQUERY_REPLY MessageType = 15 - LEASEQUERY_DONE MessageType = 16 - LEASEQUERY_DATA MessageType = 17 + // MessageTypeNone is used internally and is not part of the RFC + MessageTypeNone MessageType = 0 + MessageTypeSolicit MessageType = 1 + MessageTypeAdvertise MessageType = 2 + MessageTypeRequest MessageType = 3 + MessageTypeConfirm MessageType = 4 + MessageTypeRenew MessageType = 5 + MessageTypeRebind MessageType = 6 + MessageTypeReply MessageType = 7 + MessageTypeRelease MessageType = 8 + MessageTypeDecline MessageType = 9 + MessageTypeReconfigure MessageType = 10 + MessageTypeInformationRequest MessageType = 11 + MessageTypeRelayForward MessageType = 12 + MessageTypeRelayReply MessageType = 13 + MessageTypeLeaseQuery MessageType = 14 + MessageTypeLeaseQueryReply MessageType = 15 + MessageTypeLeaseQueryDone MessageType = 16 + MessageTypeLeaseQueryData MessageType = 17 ) +// MessageTypeToString converts a MessageType to a human-readable string +// representation. func MessageTypeToString(t MessageType) string { - if m := MessageTypeToStringMap[t]; m != "" { + if m, ok := MessageTypeToStringMap[t]; ok { return m } return "Unknown" } +// MessageTypeToStringMap contains the mapping of MessageTypes to human-readable +// strings. var MessageTypeToStringMap = map[MessageType]string{ - SOLICIT: "SOLICIT", - ADVERTISE: "ADVERTISE", - REQUEST: "REQUEST", - CONFIRM: "CONFIRM", - RENEW: "RENEW", - REBIND: "REBIND", - REPLY: "REPLY", - RELEASE: "RELEASE", - DECLINE: "DECLINE", - RECONFIGURE: "RECONFIGURE", - INFORMATION_REQUEST: "INFORMATION-REQUEST", - RELAY_FORW: "RELAY-FORW", - RELAY_REPL: "RELAY-REPL", - LEASEQUERY: "LEASEQUERY", - LEASEQUERY_REPLY: "LEASEQUERY-REPLY", - LEASEQUERY_DONE: "LEASEQUERY-DONE", - LEASEQUERY_DATA: "LEASEQUERY-DATA", + MessageTypeSolicit: "SOLICIT", + MessageTypeAdvertise: "ADVERTISE", + MessageTypeRequest: "REQUEST", + MessageTypeConfirm: "CONFIRM", + MessageTypeRenew: "RENEW", + MessageTypeRebind: "REBIND", + MessageTypeReply: "REPLY", + MessageTypeRelease: "RELEASE", + MessageTypeDecline: "DECLINE", + MessageTypeReconfigure: "RECONFIGURE", + MessageTypeInformationRequest: "INFORMATION-REQUEST", + MessageTypeRelayForward: "RELAY-FORW", + MessageTypeRelayReply: "RELAY-REPL", + MessageTypeLeaseQuery: "LEASEQUERY", + MessageTypeLeaseQueryReply: "LEASEQUERY-REPLY", + MessageTypeLeaseQueryDone: "LEASEQUERY-DONE", + MessageTypeLeaseQueryData: "LEASEQUERY-DATA", } diff --git a/dhcpv6/utils.go b/dhcpv6/utils.go index b1c0b93..1681661 100644 --- a/dhcpv6/utils.go +++ b/dhcpv6/utils.go @@ -11,14 +11,14 @@ import ( // if the "boot file" option is included in the packet, which is useful for // ADVERTISE/REPLY packet. func IsNetboot(msg DHCPv6) bool { - for _, optoro := range msg.GetOption(OPTION_ORO) { + for _, optoro := range msg.GetOption(OptionORO) { for _, o := range optoro.(*OptRequestedOption).RequestedOptions() { - if o == OPT_BOOTFILE_URL { + if o == OptionBootfileURL { return true } } } - if optbf := msg.GetOneOption(OPT_BOOTFILE_URL); optbf != nil { + if optbf := msg.GetOneOption(OptionBootfileURL); optbf != nil { return true } return false @@ -42,14 +42,14 @@ func IsUsingUEFI(msg DHCPv6) bool { // 7 EFI BC // 8 EFI Xscale // 9 EFI x86-64 - if opt := msg.GetOneOption(OPTION_CLIENT_ARCH_TYPE); opt != nil { + if opt := msg.GetOneOption(OptionClientArchType); opt != nil { optat := opt.(*OptClientArchType) // TODO investigate if other types are appropriate if optat.ArchType == EFI_BC || optat.ArchType == EFI_X86_64 { return true } } - if opt := msg.GetOneOption(OPTION_USER_CLASS); opt != nil { + if opt := msg.GetOneOption(OptionUserClass); opt != nil { optuc := opt.(*OptUserClass) for _, uc := range optuc.UserClasses { if strings.Contains(string(uc), "EFI") { diff --git a/dhcpv6/utils_test.go b/dhcpv6/utils_test.go index 77205b4..f3b53f0 100644 --- a/dhcpv6/utils_test.go +++ b/dhcpv6/utils_test.go @@ -12,7 +12,7 @@ func TestIsNetboot(t *testing.T) { msg2 := DHCPv6Message{} optro := OptRequestedOption{} - optro.AddRequestedOption(OPT_BOOTFILE_URL) + optro.AddRequestedOption(OptionBootfileURL) msg2.AddOption(&optro) require.True(t, IsNetboot(&msg2)) @@ -61,7 +61,7 @@ func TestGetTransactionIDMessage(t *testing.T) { func TestGetTransactionIDRelay(t *testing.T) { message, err := NewMessage() require.NoError(t, err) - relay, err := EncapsulateRelay(message, RELAY_FORW, nil, nil) + relay, err := EncapsulateRelay(message, MessageTypeRelayForward, nil, nil) require.NoError(t, err) transactionID, err := GetTransactionID(relay) require.NoError(t, err) diff --git a/netboot/netboot.go b/netboot/netboot.go index 97a3240..81ba144 100644 --- a/netboot/netboot.go +++ b/netboot/netboot.go @@ -50,7 +50,7 @@ func ConversationToNetconf(conversation []dhcpv6.DHCPv6) (*NetConf, string, erro var reply dhcpv6.DHCPv6 for _, m := range conversation { // look for a REPLY - if m.Type() == dhcpv6.REPLY { + if m.Type() == dhcpv6.MessageTypeReply { reply = m break } @@ -67,14 +67,14 @@ func ConversationToNetconf(conversation []dhcpv6.DHCPv6) (*NetConf, string, erro opt dhcpv6.Option bootfile string ) - opt = reply.GetOneOption(dhcpv6.OPT_BOOTFILE_URL) + opt = reply.GetOneOption(dhcpv6.OptionBootfileURL) if opt == nil { log.Printf("no bootfile URL option found in REPLY, looking for it in ADVERTISE") // as a fallback, look for bootfile URL in the advertise var advertise dhcpv6.DHCPv6 for _, m := range conversation { // look for an ADVERTISE - if m.Type() == dhcpv6.ADVERTISE { + if m.Type() == dhcpv6.MessageTypeAdvertise { advertise = m break } @@ -82,7 +82,7 @@ func ConversationToNetconf(conversation []dhcpv6.DHCPv6) (*NetConf, string, erro if advertise == nil { return nil, "", errors.New("no ADVERTISE found") } - opt = advertise.GetOneOption(dhcpv6.OPT_BOOTFILE_URL) + opt = advertise.GetOneOption(dhcpv6.OptionBootfileURL) if opt == nil { return nil, "", errors.New("no bootfile URL option found in ADVERTISE") } diff --git a/netboot/netconf.go b/netboot/netconf.go index f7a117c..84fb263 100644 --- a/netboot/netconf.go +++ b/netboot/netconf.go @@ -30,7 +30,7 @@ type NetConf struct { // GetNetConfFromPacketv6 extracts network configuration information from a DHCPv6 // Reply packet and returns a populated NetConf structure func GetNetConfFromPacketv6(d *dhcpv6.DHCPv6Message) (*NetConf, error) { - opt := d.GetOneOption(dhcpv6.OPTION_IA_NA) + opt := d.GetOneOption(dhcpv6.OptionIANA) if opt == nil { return nil, errors.New("No option IA NA found") } @@ -39,7 +39,7 @@ func GetNetConfFromPacketv6(d *dhcpv6.DHCPv6Message) (*NetConf, error) { oiana := opt.(*dhcpv6.OptIANA) iaaddrs := make([]*dhcpv6.OptIAAddress, 0) for _, o := range oiana.Options { - if o.Code() == dhcpv6.OPTION_IAADDR { + if o.Code() == dhcpv6.OptionIAAddr { iaaddrs = append(iaaddrs, o.(*dhcpv6.OptIAAddress)) } } @@ -55,7 +55,7 @@ func GetNetConfFromPacketv6(d *dhcpv6.DHCPv6Message) (*NetConf, error) { }) } // get DNS configuration - opt = d.GetOneOption(dhcpv6.DNS_RECURSIVE_NAME_SERVER) + opt = d.GetOneOption(dhcpv6.OptionDNSRecursiveNameServer) if opt == nil { return nil, errors.New("No option DNS Recursive Name Servers found ") } @@ -63,7 +63,7 @@ func GetNetConfFromPacketv6(d *dhcpv6.DHCPv6Message) (*NetConf, error) { // TODO should this be copied? netconf.DNSServers = odnsserv.NameServers - opt = d.GetOneOption(dhcpv6.DOMAIN_SEARCH_LIST) + opt = d.GetOneOption(dhcpv6.OptionDomainSearchList) if opt == nil { return nil, errors.New("No option DNS Domain Search List found") } diff --git a/dhcpv6/option_rfc1035label.go b/rfc1035label/label.go index 06870b5..c63b4af 100644 --- a/dhcpv6/option_rfc1035label.go +++ b/rfc1035label/label.go @@ -1,10 +1,14 @@ -package dhcpv6 +package rfc1035label import ( "fmt" "strings" ) +// This implements the compression from RFC 1035, section 4.1.4 +// https://tools.ietf.org/html/rfc1035 + +// LabelsFromBytes decodes a serialized stream and returns a list of labels func LabelsFromBytes(buf []byte) ([]string, error) { var ( pos = 0 @@ -30,9 +34,9 @@ func LabelsFromBytes(buf []byte) ([]string, error) { label += string(buf[pos : pos+length]) pos += length } - return domains, nil } +// LabelToBytes encodes a label and returns a serialized stream of bytes func LabelToBytes(label string) []byte { var encodedLabel []byte if len(label) == 0 { @@ -45,6 +49,8 @@ func LabelToBytes(label string) []byte { return append(encodedLabel, 0) } +// LabelsToBytes encodes a list of labels and returns a serialized stream of +// bytes func LabelsToBytes(labels []string) []byte { var encodedLabels []byte for _, label := range labels { diff --git a/dhcpv6/option_rfc1035label_test.go b/rfc1035label/label_test.go index f99c209..f91110b 100644 --- a/dhcpv6/option_rfc1035label_test.go +++ b/rfc1035label/label_test.go @@ -1,4 +1,4 @@ -package dhcpv6 +package rfc1035label import ( "bytes" |