1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
package dhcpv6
import (
"encoding/binary"
"fmt"
)
type OptionCode uint16
type Option interface {
Code() OptionCode
ToBytes() []byte
Length() int
String() string
}
type OptionGeneric struct {
OptionCode OptionCode
OptionData []byte
}
func (og *OptionGeneric) Code() OptionCode {
return og.OptionCode
}
func (og *OptionGeneric) ToBytes() []byte {
var ret []byte
codeBytes := make([]byte, 2)
binary.BigEndian.PutUint16(codeBytes, uint16(og.OptionCode))
ret = append(ret, codeBytes...)
lengthBytes := make([]byte, 2)
binary.BigEndian.PutUint16(lengthBytes, uint16(len(og.OptionData)))
ret = append(ret, lengthBytes...)
ret = append(ret, og.OptionData...)
return ret
}
func (og *OptionGeneric) String() string {
code, ok := OptionCodeToString[og.OptionCode]
if !ok {
code = "UnknownOption"
}
return fmt.Sprintf("%v -> %v", code, og.OptionData)
}
func (og *OptionGeneric) Length() int {
return len(og.OptionData)
}
func ParseOption(dataStart []byte) (Option, error) {
// Parse a sequence of bytes as a single DHCPv6 option.
// Returns the option structure, or an error if any.
if len(dataStart) < 4 {
return nil, fmt.Errorf("Invalid DHCPv6 option: less than 4 bytes")
}
code := OptionCode(binary.BigEndian.Uint16(dataStart[:2]))
length := int(binary.BigEndian.Uint16(dataStart[2:4]))
if len(dataStart) < length+4 {
return nil, fmt.Errorf("Invalid option length for option %v. Declared %v, actual %v",
code, length, len(dataStart)-4,
)
}
var (
err error
opt Option
)
optData := dataStart[4 : 4+length]
switch code {
case OPTION_CLIENTID:
opt, err = ParseOptClientId(optData)
case OPTION_SERVERID:
opt, err = ParseOptServerId(optData)
case OPTION_ELAPSED_TIME:
opt, err = ParseOptElapsedTime(optData)
case OPTION_ORO:
opt, err = ParseOptRequestedOption(optData)
case DNS_RECURSIVE_NAME_SERVER:
opt, err = ParseOptDNSRecursiveNameServer(optData)
case DOMAIN_SEARCH_LIST:
opt, err = ParseOptDomainSearchList(optData)
case OPTION_IA_NA:
opt, err = ParseOptIANA(optData)
case OPTION_IA_PD:
opt, err = ParseOptIAForPrefixDelegation(optData)
case OPTION_IAADDR:
opt, err = ParseOptIAAddress(optData)
case OPTION_IAPREFIX:
opt, err = ParseOptIAPrefix(optData)
case OPTION_STATUS_CODE:
opt, err = ParseOptStatusCode(optData)
case OPTION_RELAY_MSG:
opt, err = ParseOptRelayMsg(optData)
default:
opt = &OptionGeneric{OptionCode: code, OptionData: optData}
}
if err != nil {
return nil, err
}
if length != opt.Length() {
return nil, fmt.Errorf("different lengths for opt %v: %v != %v", code, length, opt.Length())
}
return opt, nil
}
func OptionsFromBytes(data []byte) ([]Option, error) {
// Parse a sequence of bytes until the end and build a list of options from
// it. Returns an error if any invalid option or length is found.
if len(data) < 4 {
// cannot be shorter than option code (2 bytes) + length (2 bytes)
return nil, fmt.Errorf("Invalid options: shorter than 4 bytes")
}
options := make([]Option, 0, 10)
idx := 0
for {
if idx == len(data) {
break
}
if idx > len(data) {
// this should never happen
return nil, fmt.Errorf("Error: reading past the end of options")
}
opt, err := ParseOption(data[idx:])
if err != nil {
return nil, err
}
options = append(options, opt)
idx += opt.Length() + 4 // 4 bytes for type + length
}
return options, nil
}
|
