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