Also make clean for internal pic archives.
[dragonfly.git] / libexec / rbootd / bpf.c
1 /*
2  * Copyright (c) 1988, 1992 The University of Utah and the Center
3  *      for Software Science (CSS).
4  * Copyright (c) 1992, 1993
5  *      The Regents of the University of California.  All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * the Center for Software Science of the University of Utah Computer
9  * Science Department.  CSS requests users of this software to return
10  * to css-dist@cs.utah.edu any improvements that they make and grant
11  * CSS redistribution rights.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  * 3. All advertising materials mentioning features or use of this software
22  *    must display the following acknowledgement:
23  *      This product includes software developed by the University of
24  *      California, Berkeley and its contributors.
25  * 4. Neither the name of the University nor the names of its contributors
26  *    may be used to endorse or promote products derived from this software
27  *    without specific prior written permission.
28  *
29  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
30  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
31  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
32  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
33  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
34  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
35  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
37  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
38  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
39  * SUCH DAMAGE.
40  *
41  *      from: @(#)bpf.c 8.1 (Berkeley) 6/4/93
42  *
43  * From: Utah Hdr: bpf.c 3.1 92/07/06
44  * Author: Jeff Forys, University of Utah CSS
45  *
46  * @(#)bpf.c    8.1 (Berkeley) 6/4/93
47  * $FreeBSD: src/libexec/rbootd/bpf.c,v 1.10 1999/08/28 00:09:44 peter Exp $
48  * $DragonFly: src/libexec/rbootd/bpf.c,v 1.2 2003/06/17 04:27:07 dillon Exp $
49  */
50
51 #include <sys/param.h>
52 #include <sys/ioctl.h>
53 #include <sys/socket.h>
54 #include <sys/time.h>
55
56 #include <net/if.h>
57 #include <net/bpf.h>
58
59 #include <ctype.h>
60 #include <errno.h>
61 #include <fcntl.h>
62 #include <stdio.h>
63 #include <stdlib.h>
64 #include <string.h>
65 #include <syslog.h>
66 #include <unistd.h>
67 #include "defs.h"
68 #include "pathnames.h"
69
70 static int BpfFd = -1;
71 static unsigned BpfLen = 0;
72 static u_int8_t *BpfPkt = NULL;
73
74 /*
75 **  BpfOpen -- Open and initialize a BPF device.
76 **
77 **      Parameters:
78 **              None.
79 **
80 **      Returns:
81 **              File descriptor of opened BPF device (for select() etc).
82 **
83 **      Side Effects:
84 **              If an error is encountered, the program terminates here.
85 */
86 int
87 BpfOpen()
88 {
89         struct ifreq ifr;
90         char bpfdev[32];
91         int n = 0;
92
93         /*
94          *  Open the first available BPF device.
95          */
96         do {
97                 (void) sprintf(bpfdev, _PATH_BPF, n++);
98                 BpfFd = open(bpfdev, O_RDWR);
99         } while (BpfFd < 0 && (errno == EBUSY || errno == EPERM));
100
101         if (BpfFd < 0) {
102                 syslog(LOG_ERR, "bpf: no available devices: %m");
103                 Exit(0);
104         }
105
106         /*
107          *  Set interface name for bpf device, get data link layer
108          *  type and make sure it's type Ethernet.
109          */
110         (void) strncpy(ifr.ifr_name, IntfName, sizeof(ifr.ifr_name));
111         if (ioctl(BpfFd, BIOCSETIF, (caddr_t)&ifr) < 0) {
112                 syslog(LOG_ERR, "bpf: ioctl(BIOCSETIF,%s): %m", IntfName);
113                 Exit(0);
114         }
115
116         /*
117          *  Make sure we are dealing with an Ethernet device.
118          */
119         if (ioctl(BpfFd, BIOCGDLT, (caddr_t)&n) < 0) {
120                 syslog(LOG_ERR, "bpf: ioctl(BIOCGDLT): %m");
121                 Exit(0);
122         }
123         if (n != DLT_EN10MB) {
124                 syslog(LOG_ERR,"bpf: %s: data-link type %d unsupported",
125                        IntfName, n);
126                 Exit(0);
127         }
128
129         /*
130          *  On read(), return packets immediately (do not buffer them).
131          */
132         n = 1;
133         if (ioctl(BpfFd, BIOCIMMEDIATE, (caddr_t)&n) < 0) {
134                 syslog(LOG_ERR, "bpf: ioctl(BIOCIMMEDIATE): %m");
135                 Exit(0);
136         }
137
138         /*
139          *  Try to enable the chip/driver's multicast address filter to
140          *  grab our RMP address.  If this fails, try promiscuous mode.
141          *  If this fails, there's no way we are going to get any RMP
142          *  packets so just exit here.
143          */
144 #ifdef MSG_EOR
145         ifr.ifr_addr.sa_len = RMP_ADDRLEN + 2;
146 #endif
147         ifr.ifr_addr.sa_family = AF_UNSPEC;
148         memmove((char *)&ifr.ifr_addr.sa_data[0], &RmpMcastAddr[0], RMP_ADDRLEN);
149         if (ioctl(BpfFd, BIOCPROMISC, (caddr_t)0) < 0) {
150                 syslog(LOG_ERR, "bpf: can't set promiscuous mode: %m");
151                 Exit(0);
152         }
153
154         /*
155          *  Ask BPF how much buffer space it requires and allocate one.
156          */
157         if (ioctl(BpfFd, BIOCGBLEN, (caddr_t)&BpfLen) < 0) {
158                 syslog(LOG_ERR, "bpf: ioctl(BIOCGBLEN): %m");
159                 Exit(0);
160         }
161         if (BpfPkt == NULL)
162                 BpfPkt = (u_int8_t *)malloc(BpfLen);
163
164         if (BpfPkt == NULL) {
165                 syslog(LOG_ERR, "bpf: out of memory (%u bytes for bpfpkt)",
166                        BpfLen);
167                 Exit(0);
168         }
169
170         /*
171          *  Write a little program to snarf RMP Boot packets and stuff
172          *  it down BPF's throat (i.e. set up the packet filter).
173          */
174         {
175 #define RMP     ((struct rmp_packet *)0)
176                 static struct bpf_insn bpf_insn[] = {
177                     { BPF_LD|BPF_B|BPF_ABS,  0, 0, (long)&RMP->hp_llc.dsap },
178                     { BPF_JMP|BPF_JEQ|BPF_K, 0, 5, IEEE_DSAP_HP },
179                     { BPF_LD|BPF_H|BPF_ABS,  0, 0, (long)&RMP->hp_llc.cntrl },
180                     { BPF_JMP|BPF_JEQ|BPF_K, 0, 3, IEEE_CNTL_HP },
181                     { BPF_LD|BPF_H|BPF_ABS,  0, 0, (long)&RMP->hp_llc.dxsap },
182                     { BPF_JMP|BPF_JEQ|BPF_K, 0, 1, HPEXT_DXSAP },
183                     { BPF_RET|BPF_K,         0, 0, RMP_MAX_PACKET },
184                     { BPF_RET|BPF_K,         0, 0, 0x0 }
185                 };
186 #undef  RMP
187                 static struct bpf_program bpf_pgm = {
188                     sizeof(bpf_insn)/sizeof(bpf_insn[0]), bpf_insn
189                 };
190
191                 if (ioctl(BpfFd, BIOCSETF, (caddr_t)&bpf_pgm) < 0) {
192                         syslog(LOG_ERR, "bpf: ioctl(BIOCSETF): %m");
193                         Exit(0);
194                 }
195         }
196
197         return(BpfFd);
198 }
199
200 /*
201 **  BPF GetIntfName -- Return the name of a network interface attached to
202 **              the system, or 0 if none can be found.  The interface
203 **              must be configured up; the lowest unit number is
204 **              preferred; loopback is ignored.
205 **
206 **      Parameters:
207 **              errmsg - if no network interface found, *errmsg explains why.
208 **
209 **      Returns:
210 **              A (static) pointer to interface name, or NULL on error.
211 **
212 **      Side Effects:
213 **              None.
214 */
215 char *
216 BpfGetIntfName(errmsg)
217         char **errmsg;
218 {
219         struct ifreq ibuf[8], *ifrp, *ifend, *mp;
220         struct ifconf ifc;
221         int fd;
222         int minunit, n;
223         char *cp;
224         static char device[sizeof(ifrp->ifr_name)];
225         static char errbuf[128] = "No Error!";
226
227         if (errmsg != NULL)
228                 *errmsg = errbuf;
229
230         if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
231                 (void) strcpy(errbuf, "bpf: socket: %m");
232                 return(NULL);
233         }
234         ifc.ifc_len = sizeof ibuf;
235         ifc.ifc_buf = (caddr_t)ibuf;
236
237 #ifdef OSIOCGIFCONF
238         if (ioctl(fd, OSIOCGIFCONF, (char *)&ifc) < 0 ||
239             ifc.ifc_len < sizeof(struct ifreq)) {
240                 (void) strcpy(errbuf, "bpf: ioctl(OSIOCGIFCONF): %m");
241                 return(NULL);
242         }
243 #else
244         if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0 ||
245             ifc.ifc_len < sizeof(struct ifreq)) {
246                 (void) strcpy(errbuf, "bpf: ioctl(SIOCGIFCONF): %m");
247                 return(NULL);
248         }
249 #endif
250         ifrp = ibuf;
251         ifend = (struct ifreq *)((char *)ibuf + ifc.ifc_len);
252
253         mp = 0;
254         minunit = 666;
255         for (; ifrp < ifend; ++ifrp) {
256                 if (ioctl(fd, SIOCGIFFLAGS, (char *)ifrp) < 0) {
257                         (void) strcpy(errbuf, "bpf: ioctl(SIOCGIFFLAGS): %m");
258                         return(NULL);
259                 }
260
261                 /*
262                  *  If interface is down or this is the loopback interface,
263                  *  ignore it.
264                  */
265                 if ((ifrp->ifr_flags & IFF_UP) == 0 ||
266 #ifdef IFF_LOOPBACK
267                     (ifrp->ifr_flags & IFF_LOOPBACK))
268 #else
269                     (strcmp(ifrp->ifr_name, "lo0") == 0))
270 #endif
271                         continue;
272
273                 for (cp = ifrp->ifr_name; !isdigit(*cp); ++cp)
274                         ;
275                 n = atoi(cp);
276                 if (n < minunit) {
277                         minunit = n;
278                         mp = ifrp;
279                 }
280         }
281
282         (void) close(fd);
283         if (mp == 0) {
284                 (void) strcpy(errbuf, "bpf: no interfaces found");
285                 return(NULL);
286         }
287
288         (void) strcpy(device, mp->ifr_name);
289         return(device);
290 }
291
292 /*
293 **  BpfRead -- Read packets from a BPF device and fill in `rconn'.
294 **
295 **      Parameters:
296 **              rconn - filled in with next packet.
297 **              doread - is True if we can issue a read() syscall.
298 **
299 **      Returns:
300 **              True if `rconn' contains a new packet, False otherwise.
301 **
302 **      Side Effects:
303 **              None.
304 */
305 int
306 BpfRead(rconn, doread)
307         RMPCONN *rconn;
308         int doread;
309 {
310         int datlen, caplen, hdrlen;
311         static u_int8_t *bp = NULL, *ep = NULL;
312         int cc;
313
314         /*
315          *  The read() may block, or it may return one or more packets.
316          *  We let the caller decide whether or not we can issue a read().
317          */
318         if (doread) {
319                 if ((cc = read(BpfFd, (char *)BpfPkt, (int)BpfLen)) < 0) {
320                         syslog(LOG_ERR, "bpf: read: %m");
321                         return(0);
322                 } else {
323                         bp = BpfPkt;
324                         ep = BpfPkt + cc;
325                 }
326         }
327
328 #define bhp ((struct bpf_hdr *)bp)
329         /*
330          *  If there is a new packet in the buffer, stuff it into `rconn'
331          *  and return a success indication.
332          */
333         if (bp < ep) {
334                 datlen = bhp->bh_datalen;
335                 caplen = bhp->bh_caplen;
336                 hdrlen = bhp->bh_hdrlen;
337
338                 if (caplen != datlen)
339                         syslog(LOG_ERR,
340                                "bpf: short packet dropped (%d of %d bytes)",
341                                caplen, datlen);
342                 else if (caplen > sizeof(struct rmp_packet))
343                         syslog(LOG_ERR, "bpf: large packet dropped (%d bytes)",
344                                caplen);
345                 else {
346                         rconn->rmplen = caplen;
347                         memmove((char *)&rconn->tstamp, (char *)&bhp->bh_tstamp,
348                               sizeof(struct timeval));
349                         memmove((char *)&rconn->rmp, (char *)bp + hdrlen, caplen);
350                 }
351                 bp += BPF_WORDALIGN(caplen + hdrlen);
352                 return(1);
353         }
354 #undef bhp
355
356         return(0);
357 }
358
359 /*
360 **  BpfWrite -- Write packet to BPF device.
361 **
362 **      Parameters:
363 **              rconn - packet to send.
364 **
365 **      Returns:
366 **              True if write succeeded, False otherwise.
367 **
368 **      Side Effects:
369 **              None.
370 */
371 int
372 BpfWrite(rconn)
373         RMPCONN *rconn;
374 {
375         if (write(BpfFd, (char *)&rconn->rmp, rconn->rmplen) < 0) {
376                 syslog(LOG_ERR, "write: %s: %m", EnetStr(rconn));
377                 return(0);
378         }
379
380         return(1);
381 }
382
383 /*
384 **  BpfClose -- Close a BPF device.
385 **
386 **      Parameters:
387 **              None.
388 **
389 **      Returns:
390 **              Nothing.
391 **
392 **      Side Effects:
393 **              None.
394 */
395 void
396 BpfClose()
397 {
398         struct ifreq ifr;
399
400         if (BpfPkt != NULL) {
401                 free((char *)BpfPkt);
402                 BpfPkt = NULL;
403         }
404
405         if (BpfFd == -1)
406                 return;
407
408 #ifdef MSG_EOR
409         ifr.ifr_addr.sa_len = RMP_ADDRLEN + 2;
410 #endif
411         ifr.ifr_addr.sa_family = AF_UNSPEC;
412         memmove((char *)&ifr.ifr_addr.sa_data[0], &RmpMcastAddr[0], RMP_ADDRLEN);
413         if (ioctl(BpfFd, SIOCDELMULTI, (caddr_t)&ifr) < 0)
414                 (void) ioctl(BpfFd, BIOCPROMISC, (caddr_t)0);
415
416         (void) close(BpfFd);
417         BpfFd = -1;
418 }