summaryrefslogtreecommitdiffhomepage
path: root/dhcpv4/bsdp.go
blob: 4096ce6c0979148451dbf9c38662ae0eb0f962b1 (plain)
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
// +build darwin

package dhcpv4

// Implements Apple's netboot protocol BSDP (Boot Service Discovery Protocol).
// Canonical implementation is defined here:
// http://opensource.apple.com/source/bootp/bootp-198.1/Documentation/BSDP.doc

import (
	"encoding/binary"
	"fmt"
	"syscall"
)

// Options (occur as sub-options of DHCP option 43).
const (
	BSDPOptionMessageType OptionCode = iota + 1
	BSDPOptionVersion
	BSDPOptionServerIdentifier
	BSDPOptionServerPriority
	BSDPOptionReplyPort
	BSDPOptionBootImageListPath // Not used
	BSDPOptionDefaultBootImageID
	BSDPOptionSelectedBootImageID
	BSDPOptionBootImageList
	BSDPOptionNetboot1_0Firmware
	BSDPOptionBootImageAttributesFilterList
	BSDPOptionShadowMountPath OptionCode = 128
	BSDPOptionShadowFilePath  OptionCode = 129
	BSDPOptionMachineName     OptionCode = 130
)

// Versions
var (
	BSDPVersion1_0 = []byte{1, 0}
	BSDPVersion1_1 = []byte{1, 1}
)

// BSDP message types
const (
	BSDPMessageTypeList byte = iota + 1
	BSDPMessageTypeSelect
	BSDPMessageTypeFailed
)

// Boot image kinds
const (
	BSDPBootImageMacOS9 byte = iota
	BSDPBootImageMacOSX
	BSDPBootImageMacOSXServer
	BSDPBootImageHardwareDiagnostics
	// 0x4 - 0x7f are reserved for future use.
)

// BootImageID describes a boot image ID - whether it's an install image and
// what kind of boot image (e.g. OS 9, macOS, hardware diagnostics)
type BootImageID struct {
	isInstall bool
	imageKind byte
	index     uint16
}

// toBytes serializes a BootImageID to network-order bytes.
func (b BootImageID) toBytes() (bytes []byte) {
	bytes = make([]byte, 4)
	// Attributes.
	if b.isInstall {
		bytes[0] |= 0x80
	}
	bytes[0] |= b.imageKind

	// Index
	binary.BigEndian.PutUint16(bytes[2:], b.index)
	return
}

// BootImageIDFromBytes deserializes a collection of 4 bytes to a BootImageID.
func bootImageIDFromBytes(bytes []byte) BootImageID {
	return BootImageID{
		isInstall: bytes[0]&0x80 != 0,
		imageKind: bytes[0] & 0x7f,
		index:     binary.BigEndian.Uint16(bytes[2:]),
	}
}

// BootImage describes a boot image - contains the boot image ID and the name.
type BootImage struct {
	ID BootImageID
	// This is a utf-8 string.
	Name string
}

// toBytes converts a BootImage to a slice of bytes.
func (b *BootImage) toBytes() (bytes []byte) {
	idBytes := b.ID.toBytes()
	bytes = append(bytes, idBytes[:]...)
	bytes = append(bytes, byte(len(b.Name)))
	bytes = append(bytes, []byte(b.Name)...)
	return
}

// BootImageFromBytes returns a deserialized BootImage struct from bytes as well
// as the number of bytes read from the slice.
func bootImageFromBytes(bytes []byte) (*BootImage, int, error) {
	// If less than length of boot image ID and count, it's probably invalid.
	if len(bytes) < 5 {
		return nil, 0, fmt.Errorf("not enough bytes for BootImage")
	}
	imageID := bootImageIDFromBytes(bytes[:4])
	nameLength := int(bytes[4])
	if 5+nameLength > len(bytes) {
		return nil, 0, fmt.Errorf("not enough bytes for BootImage")
	}
	name := string(bytes[5 : 5+nameLength])
	return &BootImage{ID: imageID, Name: name}, 5 + nameLength, nil
}

// makeVendorClassIdentifier calls the sysctl syscall on macOS to get the
// platform model.
func makeVendorClassIdentifier() (string, error) {
	// Fetch hardware model for class ID.
	hwModel, err := syscall.Sysctl("hw.model")
	if err != nil {
		return "", err
	}
	vendorClassID := fmt.Sprintf("AAPLBSDPC/i386/%s", hwModel)
	return vendorClassID, nil
}

// parseBootImagesFromBSDPOption parses data from the BSDPOptionBootImageList
// option and returns a list of BootImages.
func parseBootImagesFromBSDPOption(data []byte) ([]BootImage, error) {
	// Should at least have the # bytes of boot images.
	if len(data) < 4 {
		return nil, fmt.Errorf("invalid length boot image list")
	}

	readByteCount := 0
	start := data
	var bootImages []BootImage
	for {
		bootImage, readBytes, err := bootImageFromBytes(start)
		if err != nil {
			return nil, err
		}
		bootImages = append(bootImages, *bootImage)
		readByteCount += readBytes
		if readByteCount+1 >= len(data) {
			break
		}
		start = start[readByteCount:]
	}

	return bootImages, nil
}

// parseVendorOptionsFromOptions extracts the sub-options list of the vendor-
// specific options from the larger DHCP options list.
func parseVendorOptionsFromOptions(options []Option) []Option {
	var vendorOpts []Option
	var err error
	for _, opt := range options {
		if opt.Code == OptionVendorSpecificInformation {
			vendorOpts, err = OptionsFromBytes(opt.Data)
			if err != nil {
				return []Option{}
			}
			break
		}
	}
	return vendorOpts
}

// ParseBootImageListFromAck parses the list of boot images presented in the
// ACK[LIST] packet and returns them as a list of BootImages.
func ParseBootImageListFromAck(ack DHCPv4) ([]BootImage, error) {
	var bootImages []BootImage
	vendorOpts := parseVendorOptionsFromOptions(ack.options)
	for _, opt := range vendorOpts {
		if opt.Code == BSDPOptionBootImageList {
			images, err := parseBootImagesFromBSDPOption(opt.Data)
			if err != nil {
				return nil, err
			}
			bootImages = append(bootImages, images...)
		}
	}

	return bootImages, nil
}

// NewInformListForInterface creates a new INFORM packet for interface ifname
// with configuration options specified by config.
func NewInformListForInterface(iface string, replyPort uint16) (*DHCPv4, error) {
	d, err := NewInformForInterface(iface /* needsBroadcast */, false)
	if err != nil {
		return nil, err
	}

	// These are vendor-specific options used to pass along BSDP information.
	vendorOpts := []Option{
		Option{
			Code: BSDPOptionMessageType,
			Data: []byte{BSDPMessageTypeList},
		},
		Option{
			Code: BSDPOptionVersion,
			Data: BSDPVersion1_1,
		},
	}

	// If specified, replyPort MUST be a priviledged port.
	if replyPort != 0 && replyPort != ClientPort {
		if replyPort >= 1024 {
			return nil, fmt.Errorf("replyPort must be a priviledged port (< 1024)")
		}
		bytes := make([]byte, 3)
		bytes[0] = 2
		binary.BigEndian.PutUint16(bytes[1:], replyPort)
		d.AddOption(Option{
			Code: BSDPOptionReplyPort,
			Data: bytes,
		})
	}
	d.AddOption(Option{
		Code: OptionVendorSpecificInformation,
		Data: OptionsToBytes(vendorOpts),
	})

	d.AddOption(Option{
		Code: OptionParameterRequestList,
		Data: []byte{OptionVendorSpecificInformation, OptionClassIdentifier},
	})

	u16 := make([]byte, 2)
	binary.BigEndian.PutUint16(u16, 1500)
	d.AddOption(Option{
		Code: OptionMaximumDHCPMessageSize,
		Data: u16,
	})

	vendorClassID, err := makeVendorClassIdentifier()
	if err != nil {
		return nil, err
	}
	d.AddOption(Option{
		Code: OptionClassIdentifier,
		Data: []byte(vendorClassID),
	})

	d.AddOption(Option{Code: OptionEnd})
	return d, nil
}

// InformSelectForAck constructs an INFORM[SELECT] packet given an ACK to the
// previously-sent INFORM[LIST] with BSDPConfig config.
func InformSelectForAck(ack DHCPv4, replyPort uint16, selectedImage BootImage) (*DHCPv4, error) {
	d, err := New()
	if err != nil {
		return nil, err
	}
	d.SetOpcode(OpcodeBootRequest)
	d.SetHwType(ack.HwType())
	d.SetHwAddrLen(ack.HwAddrLen())
	clientHwAddr := ack.ClientHwAddr()
	d.SetClientHwAddr(clientHwAddr[:])
	d.SetTransactionID(ack.TransactionID())
	if ack.IsBroadcast() {
		d.SetBroadcast()
	} else {
		d.SetUnicast()
	}

	// Data for BSDPOptionSelectedBootImageID
	vendorOpts := []Option{
		Option{
			Code: BSDPOptionMessageType,
			Data: []byte{BSDPMessageTypeSelect},
		},
		Option{
			Code: BSDPOptionVersion,
			Data: BSDPVersion1_1,
		},
		Option{
			Code: BSDPOptionSelectedBootImageID,
			Data: selectedImage.ID.toBytes(),
		},
	}

	// Find server IP address
	var serverIP []byte
	for _, opt := range ack.options {
		if opt.Code == OptionServerIdentifier {
			serverIP = make([]byte, 4)
			copy(serverIP, opt.Data)
		}
	}
	if len(serverIP) == 0 {
		return nil, fmt.Errorf("could not parse server identifier from ACK")
	}
	vendorOpts = append(vendorOpts, Option{
		Code: BSDPOptionServerIdentifier,
		Data: serverIP,
	})

	// Validate replyPort if requested.
	if replyPort != 0 && replyPort != ClientPort {
		// replyPort MUST be a priviledged port.
		if replyPort >= 1024 {
			return nil, fmt.Errorf("replyPort must be a priviledged port")
		}
		bytes := make([]byte, 3)
		bytes[0] = 2
		binary.BigEndian.PutUint16(bytes[1:], replyPort)
		vendorOpts = append(vendorOpts, Option{
			Code: BSDPOptionReplyPort,
			Data: bytes,
		})
	}

	vendorClassID, err := makeVendorClassIdentifier()
	if err != nil {
		return nil, err
	}
	d.AddOption(Option{
		Code: OptionClassIdentifier,
		Data: []byte(vendorClassID),
	})
	d.AddOption(Option{
		Code: OptionParameterRequestList,
		Data: []byte{
			OptionSubnetMask,
			OptionRouter,
			OptionBootfileName,
			OptionVendorSpecificInformation,
			OptionClassIdentifier,
		},
	})
	d.AddOption(Option{
		Code: OptionDHCPMessageType,
		Data: []byte{MessageTypeInform},
	})
	d.AddOption(Option{
		Code: OptionVendorSpecificInformation,
		Data: OptionsToBytes(vendorOpts),
	})
	d.AddOption(Option{Code: OptionEnd})
	return d, nil
}