userland - dhclient - Fix possible infinite loop
[dragonfly.git] / sbin / dhclient / bpf.c
1 /*      $OpenBSD: bpf.c,v 1.20 2007/01/08 02:51:13 krw Exp $    */
2 /*      $DragonFly: src/sbin/dhclient/bpf.c,v 1.2 2008/11/05 14:08:41 sephe Exp $       */
3
4 /* BPF socket interface code, originally contributed by Archie Cobbs. */
5
6 /*
7  * Copyright (c) 1995, 1996, 1998, 1999
8  * The Internet Software Consortium.    All rights reserved.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  *
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. Neither the name of The Internet Software Consortium nor the names
20  *    of its contributors may be used to endorse or promote products derived
21  *    from this software without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND
24  * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
25  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
26  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27  * DISCLAIMED.  IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR
28  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
31  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
32  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
33  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
34  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  *
37  * This software has been written for the Internet Software Consortium
38  * by Ted Lemon <mellon@fugue.com> in cooperation with Vixie
39  * Enterprises.  To learn more about the Internet Software Consortium,
40  * see ``http://www.vix.com/isc''.  To learn more about Vixie
41  * Enterprises, see ``http://www.vix.com''.
42  */
43
44 #include <sys/ioctl.h>
45 #include <sys/uio.h>
46
47 #include <net/bpf.h>
48 #include <netinet/if_ether.h>
49 #include <netinet/in_systm.h>
50 #include <netinet/ip.h>
51 #include <netinet/udp.h>
52
53 #include "dhcpd.h"
54
55 /*
56  * Called by get_interface_list for each interface that's discovered.
57  * Opens a packet filter for each interface and adds it to the select
58  * mask.
59  */
60 int
61 if_register_bpf(void)
62 {
63         char filename[50];
64         int sock, b;
65
66         /*
67          * Open a BPF device.  Try auto-clone first (newer kernels),
68          * otherwise iterate (older kernels).
69          */
70         sock = open("/dev/bpf", O_RDWR, 0);
71         if (sock < 0) {
72                 for (b = 0; 1; b++) {
73                         snprintf(filename, sizeof(filename), "/dev/bpf%d", b);
74                         sock = open(filename, O_RDWR, 0);
75                         if (sock < 0) {
76                                 if (errno == EBUSY)
77                                         continue;
78                                 else
79                                         error("Can't find free bpf: %m");
80                         } else {
81                                 break;
82                         }
83                 }
84         }
85
86         /* Set the BPF device to point at this interface. */
87         if (ioctl(sock, BIOCSETIF, ifi->ifp) < 0)
88                 error("Can't attach interface %s to bpf device %s: %m",
89                     ifi->name, filename);
90
91         return (sock);
92 }
93
94 void
95 if_register_send(void)
96 {
97         int sock, on = 1;
98
99         /*
100          * If we're using the bpf API for sending and receiving, we
101          * don't need to register this interface twice.
102          */
103         ifi->wfdesc = ifi->rfdesc;
104
105         /*
106          * Use raw socket for unicast send.
107          */
108         if ((sock = socket(AF_INET, SOCK_RAW, IPPROTO_UDP)) == -1)
109                 error("socket(SOCK_RAW): %m");
110         if (setsockopt(sock, IPPROTO_IP, IP_HDRINCL, &on,
111             sizeof(on)) == -1)
112                 error("setsockopt(IP_HDRINCL): %m");
113         ifi->ufdesc = sock;
114 }
115
116 /*
117  * Packet filter program...
118  *
119  * XXX: Changes to the filter program may require changes to the
120  * constant offsets used in if_register_send to patch the BPF program!
121  */
122 struct bpf_insn dhcp_bpf_filter[] = {
123         /* Make sure this is an IP packet... */
124         BPF_STMT(BPF_LD + BPF_H + BPF_ABS, 12),
125         BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ETHERTYPE_IP, 0, 8),
126
127         /* Make sure it's a UDP packet... */
128         BPF_STMT(BPF_LD + BPF_B + BPF_ABS, 23),
129         BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_UDP, 0, 6),
130
131         /* Make sure this isn't a fragment... */
132         BPF_STMT(BPF_LD + BPF_H + BPF_ABS, 20),
133         BPF_JUMP(BPF_JMP + BPF_JSET + BPF_K, 0x1fff, 4, 0),
134
135         /* Get the IP header length... */
136         BPF_STMT(BPF_LDX + BPF_B + BPF_MSH, 14),
137
138         /* Make sure it's to the right port... */
139         BPF_STMT(BPF_LD + BPF_H + BPF_IND, 16),
140         BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 67, 0, 1),          /* patch */
141
142         /* If we passed all the tests, ask for the whole packet. */
143         BPF_STMT(BPF_RET+BPF_K, (u_int)-1),
144
145         /* Otherwise, drop it. */
146         BPF_STMT(BPF_RET+BPF_K, 0),
147 };
148
149 int dhcp_bpf_filter_len = sizeof(dhcp_bpf_filter) / sizeof(struct bpf_insn);
150
151 /*
152  * Packet write filter program:
153  * 'ip and udp and src port bootps and dst port (bootps or bootpc)'
154  */
155 struct bpf_insn dhcp_bpf_wfilter[] = {
156         BPF_STMT(BPF_LD + BPF_B + BPF_IND, 14),
157         BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, (IPVERSION << 4) + 5, 0, 12),
158
159         /* Make sure this is an IP packet... */
160         BPF_STMT(BPF_LD + BPF_H + BPF_ABS, 12),
161         BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ETHERTYPE_IP, 0, 10),
162
163         /* Make sure it's a UDP packet... */
164         BPF_STMT(BPF_LD + BPF_B + BPF_ABS, 23),
165         BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, IPPROTO_UDP, 0, 8),
166
167         /* Make sure this isn't a fragment... */
168         BPF_STMT(BPF_LD + BPF_H + BPF_ABS, 20),
169         BPF_JUMP(BPF_JMP + BPF_JSET + BPF_K, 0x1fff, 6, 0),     /* patched */
170
171         /* Get the IP header length... */
172         BPF_STMT(BPF_LDX + BPF_B + BPF_MSH, 14),
173
174         /* Make sure it's from the right port... */
175         BPF_STMT(BPF_LD + BPF_H + BPF_IND, 14),
176         BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 68, 0, 3),
177
178         /* Make sure it is to the right ports ... */
179         BPF_STMT(BPF_LD + BPF_H + BPF_IND, 16),
180         BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 67, 0, 1),
181
182         /* If we passed all the tests, ask for the whole packet. */
183         BPF_STMT(BPF_RET+BPF_K, (u_int)-1),
184
185         /* Otherwise, drop it. */
186         BPF_STMT(BPF_RET+BPF_K, 0),
187 };
188
189 int dhcp_bpf_wfilter_len = sizeof(dhcp_bpf_wfilter) / sizeof(struct bpf_insn);
190
191 void
192 if_register_receive(void)
193 {
194         struct bpf_version v;
195         struct bpf_program p;
196         int flag = 1, sz;
197
198         /* Open a BPF device and hang it on this interface... */
199         ifi->rfdesc = if_register_bpf();
200
201         /* Make sure the BPF version is in range... */
202         if (ioctl(ifi->rfdesc, BIOCVERSION, &v) < 0)
203                 error("Can't get BPF version: %m");
204
205         if (v.bv_major != BPF_MAJOR_VERSION ||
206             v.bv_minor < BPF_MINOR_VERSION)
207                 error("Kernel BPF version out of range - recompile dhcpd!");
208
209         /*
210          * Set immediate mode so that reads return as soon as a packet
211          * comes in, rather than waiting for the input buffer to fill
212          * with packets.
213          */
214         if (ioctl(ifi->rfdesc, BIOCIMMEDIATE, &flag) < 0)
215                 error("Can't set immediate mode on bpf device: %m");
216
217         /*if (ioctl(ifi->rfdesc, BIOCSFILDROP, &flag) < 0)
218                 error("Can't set filter-drop mode on bpf device: %m");*/
219
220         /* Get the required BPF buffer length from the kernel. */
221         if (ioctl(ifi->rfdesc, BIOCGBLEN, &sz) < 0)
222                 error("Can't get bpf buffer length: %m");
223         ifi->rbuf_max = sz;
224         ifi->rbuf = malloc(ifi->rbuf_max);
225         if (!ifi->rbuf)
226                 error("Can't allocate %lu bytes for bpf input buffer.",
227                     (unsigned long)ifi->rbuf_max);
228         ifi->rbuf_offset = 0;
229         ifi->rbuf_len = 0;
230
231         /* Set up the bpf filter program structure. */
232         p.bf_len = dhcp_bpf_filter_len;
233         p.bf_insns = dhcp_bpf_filter;
234
235         /* Patch the server port into the BPF program...
236          *
237          * XXX: changes to filter program may require changes to the
238          * insn number(s) used below!
239          */
240         dhcp_bpf_filter[8].k = LOCAL_PORT;
241
242         if (ioctl(ifi->rfdesc, BIOCSETF, &p) < 0)
243                 error("Can't install packet filter program: %m");
244
245         /* Set up the bpf write filter program structure. */
246         p.bf_len = dhcp_bpf_wfilter_len;
247         p.bf_insns = dhcp_bpf_wfilter;
248
249         if (dhcp_bpf_wfilter[7].k == 0x1fff)
250                 dhcp_bpf_wfilter[7].k = htons(IP_MF|IP_OFFMASK);
251
252         if (ioctl(ifi->rfdesc, BIOCSETWF, &p) < 0)
253                 error("Can't install write filter program: %m");
254
255         if (ioctl(ifi->rfdesc, BIOCLOCK, NULL) < 0)
256                 error("Cannot lock bpf");
257 }
258
259 ssize_t
260 send_packet(struct in_addr from, struct sockaddr_in *to,
261     struct hardware *hto)
262 {
263 #define IOVCNT          2
264         unsigned char buf[256];
265         struct iovec iov[IOVCNT];
266         struct msghdr msg;
267         int result, bufp = 0;
268
269         if (to->sin_addr.s_addr == INADDR_BROADCAST) {
270                 assemble_hw_header(buf, &bufp, hto);
271         }
272
273         assemble_udp_ip_header(buf, &bufp, from.s_addr,
274             to->sin_addr.s_addr, to->sin_port,
275             (unsigned char *)&client->packet,
276             client->packet_length);
277
278         iov[0].iov_base = (char *)buf;
279         iov[0].iov_len = bufp;
280         iov[1].iov_base = (char *)&client->packet;
281         iov[1].iov_len = client->packet_length;
282
283         if (to->sin_addr.s_addr == INADDR_BROADCAST) {
284                 result = writev(ifi->wfdesc, iov, IOVCNT);
285         } else {
286                 struct ip *ip = (struct ip *)buf;
287
288                 /*
289                  * DragonFly's raw socket expects ip_len/ip_off
290                  * in host byte order.
291                  */
292                 ip->ip_len = ntohs(ip->ip_len);
293                 ip->ip_off = ntohs(ip->ip_off);
294
295                 memset(&msg, 0, sizeof(msg));
296                 msg.msg_name = (struct sockaddr *)to;
297                 msg.msg_namelen = sizeof(*to);
298                 msg.msg_iov = iov;
299                 msg.msg_iovlen = IOVCNT;
300                 result = sendmsg(ifi->ufdesc, &msg, 0);
301         }
302
303         if (result == -1)
304                 warning("send_packet: %m");
305         return (result);
306 }
307
308 ssize_t
309 receive_packet(struct sockaddr_in *from, struct hardware *hfrom)
310 {
311         int length = 0, offset = 0;
312         struct bpf_hdr hdr;
313
314         /*
315          * All this complexity is because BPF doesn't guarantee that
316          * only one packet will be returned at a time.  We're getting
317          * what we deserve, though - this is a terrible abuse of the BPF
318          * interface.  Sigh.
319          */
320
321         /* Process packets until we get one we can return or until we've
322          * done a read and gotten nothing we can return...
323          */
324         do {
325                 /* If the buffer is empty, fill it. */
326                 if (ifi->rbuf_offset >= ifi->rbuf_len) {
327                         length = read(ifi->rfdesc, ifi->rbuf, ifi->rbuf_max);
328                         if (length <= 0)
329                                 return (length);
330                         ifi->rbuf_offset = 0;
331                         ifi->rbuf_len = BPF_WORDALIGN(length);
332                 }
333
334                 /*
335                  * If there isn't room for a whole bpf header, something
336                  * went wrong, but we'll ignore it and hope it goes
337                  * away... XXX
338                  */
339                 if (ifi->rbuf_len - ifi->rbuf_offset < sizeof(hdr)) {
340                         ifi->rbuf_offset = ifi->rbuf_len;
341                         continue;
342                 }
343
344                 /* Copy out a bpf header... */
345                 memcpy(&hdr, &ifi->rbuf[ifi->rbuf_offset], sizeof(hdr));
346
347                 /*
348                  * If the bpf header plus data doesn't fit in what's
349                  * left of the buffer, stick head in sand yet again...
350                  */
351                 if (ifi->rbuf_offset + hdr.bh_hdrlen + hdr.bh_caplen >
352                     ifi->rbuf_len) {
353                         ifi->rbuf_offset = ifi->rbuf_len;
354                         continue;
355                 }
356
357                 /*
358                  * If the captured data wasn't the whole packet, or if
359                  * the packet won't fit in the input buffer, all we can
360                  * do is drop it.
361                  */
362                 if (hdr.bh_caplen != hdr.bh_datalen) {
363                         ifi->rbuf_offset = BPF_WORDALIGN(
364                             ifi->rbuf_offset + hdr.bh_hdrlen +
365                             hdr.bh_caplen);
366                         continue;
367                 }
368
369                 /* Skip over the BPF header... */
370                 ifi->rbuf_offset += hdr.bh_hdrlen;
371
372                 /* Decode the physical header... */
373                 offset = decode_hw_header(ifi->rbuf, ifi->rbuf_offset, hfrom);
374
375                 /*
376                  * If a physical layer checksum failed (dunno of any
377                  * physical layer that supports this, but WTH), skip
378                  * this packet.
379                  */
380                 if (offset < 0) {
381                         ifi->rbuf_offset = BPF_WORDALIGN(
382                             ifi->rbuf_offset + hdr.bh_caplen);
383                         continue;
384                 }
385                 ifi->rbuf_offset += offset;
386                 hdr.bh_caplen -= offset;
387
388                 /* Decode the IP and UDP headers... */
389                 offset = decode_udp_ip_header(ifi->rbuf,
390                     ifi->rbuf_offset, from, NULL, hdr.bh_caplen);
391
392                 /* If the IP or UDP checksum was bad, skip the packet... */
393                 if (offset < 0) {
394                         ifi->rbuf_offset = BPF_WORDALIGN(
395                             ifi->rbuf_offset + hdr.bh_caplen);
396                         continue;
397                 }
398                 ifi->rbuf_offset += offset;
399                 hdr.bh_caplen -= offset;
400
401                 /*
402                  * If there's not enough room to stash the packet data,
403                  * we have to skip it (this shouldn't happen in real
404                  * life, though).
405                  */
406                 if (hdr.bh_caplen > sizeof(client->packet)) {
407                         ifi->rbuf_offset = BPF_WORDALIGN(
408                             ifi->rbuf_offset + hdr.bh_caplen);
409                         continue;
410                 }
411
412                 /* Copy out the data in the packet... */
413                 memset(&client->packet, DHO_END, sizeof(client->packet));
414                 memcpy(&client->packet, ifi->rbuf + ifi->rbuf_offset,
415                     hdr.bh_caplen);
416                 ifi->rbuf_offset = BPF_WORDALIGN(ifi->rbuf_offset +
417                     hdr.bh_caplen);
418                 return (hdr.bh_caplen);
419         } while (!length);
420         return (0);
421 }