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. Neither the name of the University nor the names of its contributors
22 *    may be used to endorse or promote products derived from this software
23 *    without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * SUCH DAMAGE.
36 *
37 *	from: @(#)bpf.c	8.1 (Berkeley) 6/4/93
38 *
39 * From: Utah Hdr: bpf.c 3.1 92/07/06
40 * Author: Jeff Forys, University of Utah CSS
41 */
42
43#ifndef lint
44#if 0
45static const char sccsid[] = "@(#)bpf.c	8.1 (Berkeley) 6/4/93";
46#endif
47static const char rcsid[] =
48  "$FreeBSD: releng/11.0/libexec/rbootd/bpf.c 298213 2016-04-18 15:05:48Z pfg $";
49#endif /* not lint */
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
70static int BpfFd = -1;
71static unsigned BpfLen = 0;
72static 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*/
86int
87BpfOpen(void)
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*/
215char *
216BpfGetIntfName(char **errmsg)
217{
218	struct ifreq ibuf[8], *ifrp, *ifend, *mp;
219	struct ifconf ifc;
220	int fd;
221	int minunit, n;
222	char *cp;
223	static char device[sizeof(ifrp->ifr_name)];
224	static char errbuf[128] = "No Error!";
225
226	if (errmsg != NULL)
227		*errmsg = errbuf;
228
229	if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
230		(void) strcpy(errbuf, "bpf: socket: %m");
231		return(NULL);
232	}
233	ifc.ifc_len = sizeof ibuf;
234	ifc.ifc_buf = (caddr_t)ibuf;
235
236	if (ioctl(fd, SIOCGIFCONF, (char *)&ifc) < 0 ||
237	    ifc.ifc_len < sizeof(struct ifreq)) {
238		(void) strcpy(errbuf, "bpf: ioctl(SIOCGIFCONF): %m");
239		return(NULL);
240	}
241	ifrp = ibuf;
242	ifend = (struct ifreq *)((char *)ibuf + ifc.ifc_len);
243
244	mp = NULL;
245	minunit = 666;
246	for (; ifrp < ifend; ++ifrp) {
247		if (ioctl(fd, SIOCGIFFLAGS, (char *)ifrp) < 0) {
248			(void) strcpy(errbuf, "bpf: ioctl(SIOCGIFFLAGS): %m");
249			return(NULL);
250		}
251
252		/*
253		 *  If interface is down or this is the loopback interface,
254		 *  ignore it.
255		 */
256		if ((ifrp->ifr_flags & IFF_UP) == 0 ||
257#ifdef IFF_LOOPBACK
258		    (ifrp->ifr_flags & IFF_LOOPBACK))
259#else
260		    (strcmp(ifrp->ifr_name, "lo0") == 0))
261#endif
262			continue;
263
264		for (cp = ifrp->ifr_name; !isdigit(*cp); ++cp)
265			;
266		n = atoi(cp);
267		if (n < minunit) {
268			minunit = n;
269			mp = ifrp;
270		}
271	}
272
273	(void) close(fd);
274	if (mp == NULL) {
275		(void) strcpy(errbuf, "bpf: no interfaces found");
276		return(NULL);
277	}
278
279	(void) strcpy(device, mp->ifr_name);
280	return(device);
281}
282
283/*
284**  BpfRead -- Read packets from a BPF device and fill in `rconn'.
285**
286**	Parameters:
287**		rconn - filled in with next packet.
288**		doread - is True if we can issue a read() syscall.
289**
290**	Returns:
291**		True if `rconn' contains a new packet, False otherwise.
292**
293**	Side Effects:
294**		None.
295*/
296int
297BpfRead(RMPCONN *rconn, int doread)
298{
299	int datlen, caplen, hdrlen;
300	static u_int8_t *bp = NULL, *ep = NULL;
301	int cc;
302
303	/*
304	 *  The read() may block, or it may return one or more packets.
305	 *  We let the caller decide whether or not we can issue a read().
306	 */
307	if (doread) {
308		if ((cc = read(BpfFd, (char *)BpfPkt, (int)BpfLen)) < 0) {
309			syslog(LOG_ERR, "bpf: read: %m");
310			return(0);
311		} else {
312			bp = BpfPkt;
313			ep = BpfPkt + cc;
314		}
315	}
316
317#define bhp ((struct bpf_hdr *)bp)
318	/*
319	 *  If there is a new packet in the buffer, stuff it into `rconn'
320	 *  and return a success indication.
321	 */
322	if (bp < ep) {
323		datlen = bhp->bh_datalen;
324		caplen = bhp->bh_caplen;
325		hdrlen = bhp->bh_hdrlen;
326
327		if (caplen != datlen)
328			syslog(LOG_ERR,
329			       "bpf: short packet dropped (%d of %d bytes)",
330			       caplen, datlen);
331		else if (caplen > sizeof(struct rmp_packet))
332			syslog(LOG_ERR, "bpf: large packet dropped (%d bytes)",
333			       caplen);
334		else {
335			rconn->rmplen = caplen;
336			memmove((char *)&rconn->tstamp, (char *)&bhp->bh_tstamp,
337			      sizeof(struct timeval));
338			memmove((char *)&rconn->rmp, (char *)bp + hdrlen, caplen);
339		}
340		bp += BPF_WORDALIGN(caplen + hdrlen);
341		return(1);
342	}
343#undef bhp
344
345	return(0);
346}
347
348/*
349**  BpfWrite -- Write packet to BPF device.
350**
351**	Parameters:
352**		rconn - packet to send.
353**
354**	Returns:
355**		True if write succeeded, False otherwise.
356**
357**	Side Effects:
358**		None.
359*/
360int
361BpfWrite(RMPCONN *rconn)
362{
363	if (write(BpfFd, (char *)&rconn->rmp, rconn->rmplen) < 0) {
364		syslog(LOG_ERR, "write: %s: %m", EnetStr(rconn));
365		return(0);
366	}
367
368	return(1);
369}
370
371/*
372**  BpfClose -- Close a BPF device.
373**
374**	Parameters:
375**		None.
376**
377**	Returns:
378**		Nothing.
379**
380**	Side Effects:
381**		None.
382*/
383void
384BpfClose(void)
385{
386	struct ifreq ifr;
387
388	if (BpfPkt != NULL) {
389		free((char *)BpfPkt);
390		BpfPkt = NULL;
391	}
392
393	if (BpfFd == -1)
394		return;
395
396#ifdef MSG_EOR
397	ifr.ifr_addr.sa_len = RMP_ADDRLEN + 2;
398#endif
399	ifr.ifr_addr.sa_family = AF_UNSPEC;
400	memmove((char *)&ifr.ifr_addr.sa_data[0], &RmpMcastAddr[0], RMP_ADDRLEN);
401	if (ioctl(BpfFd, SIOCDELMULTI, (caddr_t)&ifr) < 0)
402		(void) ioctl(BpfFd, BIOCPROMISC, (caddr_t)0);
403
404	(void) close(BpfFd);
405	BpfFd = -1;
406}
407