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
|
package dhcpv4
import (
"encoding/binary"
"errors"
"net"
"syscall"
"time"
"golang.org/x/net/ipv4"
)
// MaxUDPReceivedPacketSize is the (arbitrary) maximum UDP packet size supported
// by this library. Theoretically could be up to 65kb.
const (
MaxUDPReceivedPacketSize = 8192
)
var (
// BroadcastAddressBytes are the bytes representing net.IPv4bcast.
BroadcastAddressBytes = [4]byte{
net.IPv4bcast[0],
net.IPv4bcast[1],
net.IPv4bcast[2],
net.IPv4bcast[3],
}
// DefaultReadTimeout is the time to wait after listening in which the
// exchange is considered failed.
DefaultReadTimeout = 3 * time.Second
// DefaultWriteTimeout is the time to wait after sending in which the
// exchange is considered failed.
DefaultWriteTimeout = 3 * time.Second
)
// Client is the object that actually performs the DHCP exchange. It currently
// only has read and write timeout values.
type Client struct {
ReadTimeout, WriteTimeout time.Duration
}
// NewClient generates a new client to perform a DHCP exchange with, setting the
// read and write timeout fields to defaults.
func NewClient() *Client {
return &Client{
ReadTimeout: DefaultReadTimeout,
WriteTimeout: DefaultWriteTimeout,
}
}
// MakeRawBroadcastPacket converts payload (a serialized DHCPv4 packet) into a
// raw packet suitable for UDP broadcast.
func MakeRawBroadcastPacket(payload []byte) ([]byte, error) {
udp := make([]byte, 8)
binary.BigEndian.PutUint16(udp[:2], ClientPort)
binary.BigEndian.PutUint16(udp[2:4], ServerPort)
binary.BigEndian.PutUint16(udp[4:6], uint16(8+len(payload)))
binary.BigEndian.PutUint16(udp[6:8], 0) // try to offload the checksum
h := ipv4.Header{
Version: 4,
Len: 20,
TotalLen: 20 + len(udp) + len(payload),
TTL: 64,
Protocol: 17, // UDP
Dst: net.IPv4bcast,
Src: net.IPv4zero,
}
ret, err := h.Marshal()
if err != nil {
return nil, err
}
ret = append(ret, udp...)
ret = append(ret, payload...)
return ret, nil
}
// MakeBroadcastSocket creates a socket that can be passed to syscall.Sendto
// that will send packets out to the broadcast address.
func MakeBroadcastSocket(ifname string) (int, error) {
fd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_RAW, syscall.IPPROTO_RAW)
if err != nil {
return -1, err
}
err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_REUSEADDR, 1)
if err != nil {
return -1, err
}
err = syscall.SetsockoptInt(fd, syscall.IPPROTO_IP, syscall.IP_HDRINCL, 1)
if err != nil {
return -1, err
}
err = syscall.SetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_BROADCAST, 1)
if err != nil {
return -1, err
}
err = BindToInterface(fd, ifname)
if err != nil {
return -1, err
}
return fd, nil
}
// Exchange runs a full DORA transaction: Discover, Offer, Request, Acknowledge,
// over UDP. Does not retry in case of failures. Returns a list of DHCPv4
// structures representing the exchange. It can contain up to four elements,
// 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 Exchange(client *Client, ifname string, discover *DHCPv4) ([]DHCPv4, error) {
conversation := make([]DHCPv4, 1)
var err error
if discover == nil {
discover, err = NewDiscoveryForInterface(ifname)
if err != nil {
return conversation, err
}
}
// Get our file descriptor for the broadcast socket.
fd, err := MakeBroadcastSocket(ifname)
if err != nil {
return conversation, err
}
// Discover
conversation[0] = *discover
// Offer
offer, err := SendReceive(client, fd, discover)
if err != nil {
return conversation, err
}
conversation = append(conversation, *offer)
// Request
request, err := RequestFromOffer(*offer)
if err != nil {
return conversation, err
}
conversation = append(conversation, *request)
// Ack
ack, err := SendReceive(client, fd, discover)
if err != nil {
return conversation, err
}
conversation = append(conversation, *ack)
return conversation, nil
}
// SendReceive broadcasts packet (with some write timeout) and waits for a
// response up to some read timeout value.
func SendReceive(client *Client, fd int, packet *DHCPv4) (*DHCPv4, error) {
// Build up our packet bytes.
packetBytes, err := MakeRawBroadcastPacket(packet.ToBytes())
if err != nil {
return nil, err
}
// Create a goroutine to perform the blocking send, and time it out after
// a certain amount of time.
remoteAddr := syscall.SockaddrInet4{Port: ClientPort, Addr: BroadcastAddressBytes}
sendErrChan := make(chan error, 1)
go func() { sendErrChan <- syscall.Sendto(fd, packetBytes, 0, &remoteAddr) }()
select {
case err = <-sendErrChan:
if err != nil {
return nil, err
}
case <-time.After(client.WriteTimeout):
return nil, errors.New("timed out while communicating with server")
}
// Open up a connection to listen.
conn, err := net.ListenUDP("udp4", &net.UDPAddr{IP: net.IPv4zero, Port: ClientPort})
defer conn.Close()
conn.SetReadDeadline(time.Now().Add(client.ReadTimeout))
// Wait for a response from the server.
buf := make([]byte, MaxUDPReceivedPacketSize)
n, _, _, _, err := conn.ReadMsgUDP(buf, []byte{})
if err != nil {
return nil, err
}
// Serialize to a DHCPv4 packet.
response, err := FromBytes(buf[:n])
if err != nil {
return nil, err
}
return response, nil
}
|
