xref: /openbsd-src/lib/libpcap/gencode.c (revision ce7e0fc6a9d74d25b78fb6ad846387717f5172b6)
1 /*	$OpenBSD: gencode.c,v 1.16 2002/03/23 01:33:16 frantzen Exp $	*/
2 
3 /*
4  * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that: (1) source code distributions
9  * retain the above copyright notice and this paragraph in its entirety, (2)
10  * distributions including binary code include the above copyright notice and
11  * this paragraph in its entirety in the documentation or other materials
12  * provided with the distribution, and (3) all advertising materials mentioning
13  * features or use of this software display the following acknowledgement:
14  * ``This product includes software developed by the University of California,
15  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
16  * the University nor the names of its contributors may be used to endorse
17  * or promote products derived from this software without specific prior
18  * written permission.
19  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
20  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
21  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22  */
23 #ifndef lint
24 static const char rcsid[] =
25     "@(#) $Header: /home/cvs/src/lib/libpcap/gencode.c,v 1.16 2002/03/23 01:33:16 frantzen Exp $ (LBL)";
26 #endif
27 
28 #include <sys/types.h>
29 #include <sys/socket.h>
30 #include <sys/time.h>
31 
32 struct mbuf;
33 struct rtentry;
34 
35 #include <net/if.h>
36 
37 #include <netinet/in.h>
38 #include <netinet/if_ether.h>
39 #include <netinet/if_arc.h>
40 
41 #include <net/if_pflog.h>
42 #include <net/pfvar.h>
43 
44 #include <stdlib.h>
45 #include <stddef.h>
46 #include <memory.h>
47 #include <setjmp.h>
48 #include <stdarg.h>
49 
50 #include "pcap-int.h"
51 
52 #include "ethertype.h"
53 #include "gencode.h"
54 #include "ppp.h"
55 #include <pcap-namedb.h>
56 #ifdef INET6
57 #include <netdb.h>
58 #include <sys/socket.h>
59 #endif /*INET6*/
60 
61 #ifdef HAVE_OS_PROTO_H
62 #include "os-proto.h"
63 #endif
64 
65 #define JMP(c) ((c)|BPF_JMP|BPF_K)
66 
67 /* Locals */
68 static jmp_buf top_ctx;
69 static pcap_t *bpf_pcap;
70 
71 /* XXX */
72 #ifdef PCAP_FDDIPAD
73 int	pcap_fddipad = PCAP_FDDIPAD;
74 #else
75 int	pcap_fddipad;
76 #endif
77 
78 /* VARARGS */
79 __dead void
80 bpf_error(const char *fmt, ...)
81 {
82 	va_list ap;
83 
84 	va_start(ap, fmt);
85 	if (bpf_pcap != NULL)
86 		(void)vsnprintf(pcap_geterr(bpf_pcap), PCAP_ERRBUF_SIZE,
87 		    fmt, ap);
88 	va_end(ap);
89 	longjmp(top_ctx, 1);
90 	/* NOTREACHED */
91 }
92 
93 static void init_linktype(int);
94 
95 static int alloc_reg(void);
96 static void free_reg(int);
97 
98 static struct block *root;
99 
100 /*
101  * We divy out chunks of memory rather than call malloc each time so
102  * we don't have to worry about leaking memory.  It's probably
103  * not a big deal if all this memory was wasted but it this ever
104  * goes into a library that would probably not be a good idea.
105  */
106 #define NCHUNKS 16
107 #define CHUNK0SIZE 1024
108 struct chunk {
109 	u_int n_left;
110 	void *m;
111 };
112 
113 static struct chunk chunks[NCHUNKS];
114 static int cur_chunk;
115 
116 static void *newchunk(u_int);
117 static void freechunks(void);
118 static __inline struct block *new_block(int);
119 static __inline struct slist *new_stmt(int);
120 static struct block *gen_retblk(int);
121 static __inline void syntax(void);
122 
123 static void backpatch(struct block *, struct block *);
124 static void merge(struct block *, struct block *);
125 static struct block *gen_cmp(u_int, u_int, bpf_int32);
126 static struct block *gen_mcmp(u_int, u_int, bpf_int32, bpf_u_int32);
127 static struct block *gen_bcmp(u_int, u_int, const u_char *);
128 static struct block *gen_uncond(int);
129 static __inline struct block *gen_true(void);
130 static __inline struct block *gen_false(void);
131 static struct block *gen_linktype(int);
132 static struct block *gen_hostop(bpf_u_int32, bpf_u_int32, int, int, u_int, u_int);
133 #ifdef INET6
134 static struct block *gen_hostop6(struct in6_addr *, struct in6_addr *, int, int, u_int, u_int);
135 #endif
136 static struct block *gen_ahostop(const u_char *, int);
137 static struct block *gen_ehostop(const u_char *, int);
138 static struct block *gen_fhostop(const u_char *, int);
139 static struct block *gen_dnhostop(bpf_u_int32, int, u_int);
140 static struct block *gen_host(bpf_u_int32, bpf_u_int32, int, int);
141 #ifdef INET6
142 static struct block *gen_host6(struct in6_addr *, struct in6_addr *, int, int);
143 #endif
144 #ifndef INET6
145 static struct block *gen_gateway(const u_char *, bpf_u_int32 **, int, int);
146 #endif
147 static struct block *gen_ipfrag(void);
148 static struct block *gen_portatom(int, bpf_int32);
149 #ifdef INET6
150 static struct block *gen_portatom6(int, bpf_int32);
151 #endif
152 struct block *gen_portop(int, int, int);
153 static struct block *gen_port(int, int, int);
154 #ifdef INET6
155 struct block *gen_portop6(int, int, int);
156 static struct block *gen_port6(int, int, int);
157 #endif
158 static int lookup_proto(const char *, int);
159 static struct block *gen_protochain(int, int, int);
160 static struct block *gen_proto(int, int, int);
161 static struct slist *xfer_to_x(struct arth *);
162 static struct slist *xfer_to_a(struct arth *);
163 static struct block *gen_len(int, int);
164 
165 static void *
166 newchunk(n)
167 	u_int n;
168 {
169 	struct chunk *cp;
170 	int k, size;
171 
172 	/* XXX Round to structure boundary. */
173 	n = ALIGN(n);
174 
175 	cp = &chunks[cur_chunk];
176 	if (n > cp->n_left) {
177 		++cp, k = ++cur_chunk;
178 		if (k >= NCHUNKS)
179 			bpf_error("out of memory");
180 		size = CHUNK0SIZE << k;
181 		cp->m = (void *)malloc(size);
182 		memset((char *)cp->m, 0, size);
183 		cp->n_left = size;
184 		if (n > size)
185 			bpf_error("out of memory");
186 	}
187 	cp->n_left -= n;
188 	return (void *)((char *)cp->m + cp->n_left);
189 }
190 
191 static void
192 freechunks()
193 {
194 	int i;
195 
196 	cur_chunk = 0;
197 	for (i = 0; i < NCHUNKS; ++i)
198 		if (chunks[i].m != NULL) {
199 			free(chunks[i].m);
200 			chunks[i].m = NULL;
201 		}
202 }
203 
204 /*
205  * A strdup whose allocations are freed after code generation is over.
206  */
207 char *
208 sdup(s)
209 	register const char *s;
210 {
211 	int n = strlen(s) + 1;
212 	char *cp = newchunk(n);
213 
214 	strlcpy(cp, s, n);
215 	return (cp);
216 }
217 
218 static __inline struct block *
219 new_block(code)
220 	int code;
221 {
222 	struct block *p;
223 
224 	p = (struct block *)newchunk(sizeof(*p));
225 	p->s.code = code;
226 	p->head = p;
227 
228 	return p;
229 }
230 
231 static __inline struct slist *
232 new_stmt(code)
233 	int code;
234 {
235 	struct slist *p;
236 
237 	p = (struct slist *)newchunk(sizeof(*p));
238 	p->s.code = code;
239 
240 	return p;
241 }
242 
243 static struct block *
244 gen_retblk(v)
245 	int v;
246 {
247 	struct block *b = new_block(BPF_RET|BPF_K);
248 
249 	b->s.k = v;
250 	return b;
251 }
252 
253 static __inline void
254 syntax()
255 {
256 	bpf_error("syntax error in filter expression");
257 }
258 
259 static bpf_u_int32 netmask;
260 static int snaplen;
261 int no_optimize;
262 
263 int
264 pcap_compile(pcap_t *p, struct bpf_program *program,
265 	     char *buf, int optimize, bpf_u_int32 mask)
266 {
267 	extern int n_errors;
268 	int len;
269 
270 	no_optimize = 0;
271 	n_errors = 0;
272 	root = NULL;
273 	bpf_pcap = p;
274 	if (setjmp(top_ctx)) {
275 		freechunks();
276 		return (-1);
277 	}
278 
279 	netmask = mask;
280 	snaplen = pcap_snapshot(p);
281 
282 	lex_init(buf ? buf : "");
283 	init_linktype(pcap_datalink(p));
284 	(void)pcap_parse();
285 
286 	if (n_errors)
287 		syntax();
288 
289 	if (root == NULL)
290 		root = gen_retblk(snaplen);
291 
292 	if (optimize && !no_optimize) {
293 		bpf_optimize(&root);
294 		if (root == NULL ||
295 		    (root->s.code == (BPF_RET|BPF_K) && root->s.k == 0))
296 			bpf_error("expression rejects all packets");
297 	}
298 	program->bf_insns = icode_to_fcode(root, &len);
299 	program->bf_len = len;
300 
301 	freechunks();
302 	return (0);
303 }
304 
305 /*
306  * entry point for using the compiler with no pcap open
307  * pass in all the stuff that is needed explicitly instead.
308  */
309 int
310 pcap_compile_nopcap(int snaplen_arg, int linktype_arg,
311 		    struct bpf_program *program,
312 	     char *buf, int optimize, bpf_u_int32 mask)
313 {
314 	extern int n_errors;
315 	int len;
316 
317 	n_errors = 0;
318 	root = NULL;
319 	bpf_pcap = NULL;
320 	if (setjmp(top_ctx)) {
321 		freechunks();
322 		return (-1);
323 	}
324 
325 	netmask = mask;
326 
327 	/* XXX needed? I don't grok the use of globals here. */
328 	snaplen = snaplen_arg;
329 
330 	lex_init(buf ? buf : "");
331 	init_linktype(linktype_arg);
332 	(void)pcap_parse();
333 
334 	if (n_errors)
335 		syntax();
336 
337 	if (root == NULL)
338 		root = gen_retblk(snaplen_arg);
339 
340 	if (optimize) {
341 		bpf_optimize(&root);
342 		if (root == NULL ||
343 		    (root->s.code == (BPF_RET|BPF_K) && root->s.k == 0))
344 			bpf_error("expression rejects all packets");
345 	}
346 	program->bf_insns = icode_to_fcode(root, &len);
347 	program->bf_len = len;
348 
349 	freechunks();
350 	return (0);
351 }
352 
353 /*
354  * Clean up a "struct bpf_program" by freeing all the memory allocated
355  * in it.
356  */
357 void
358 pcap_freecode(struct bpf_program *program)
359 {
360 	program->bf_len = 0;
361 	if (program->bf_insns != NULL) {
362 		free((char *)program->bf_insns);
363 		program->bf_insns = NULL;
364 	}
365 }
366 
367 /*
368  * Backpatch the blocks in 'list' to 'target'.  The 'sense' field indicates
369  * which of the jt and jf fields has been resolved and which is a pointer
370  * back to another unresolved block (or nil).  At least one of the fields
371  * in each block is already resolved.
372  */
373 static void
374 backpatch(list, target)
375 	struct block *list, *target;
376 {
377 	struct block *next;
378 
379 	while (list) {
380 		if (!list->sense) {
381 			next = JT(list);
382 			JT(list) = target;
383 		} else {
384 			next = JF(list);
385 			JF(list) = target;
386 		}
387 		list = next;
388 	}
389 }
390 
391 /*
392  * Merge the lists in b0 and b1, using the 'sense' field to indicate
393  * which of jt and jf is the link.
394  */
395 static void
396 merge(b0, b1)
397 	struct block *b0, *b1;
398 {
399 	register struct block **p = &b0;
400 
401 	/* Find end of list. */
402 	while (*p)
403 		p = !((*p)->sense) ? &JT(*p) : &JF(*p);
404 
405 	/* Concatenate the lists. */
406 	*p = b1;
407 }
408 
409 void
410 finish_parse(p)
411 	struct block *p;
412 {
413 	backpatch(p, gen_retblk(snaplen));
414 	p->sense = !p->sense;
415 	backpatch(p, gen_retblk(0));
416 	root = p->head;
417 }
418 
419 void
420 gen_and(b0, b1)
421 	struct block *b0, *b1;
422 {
423 	backpatch(b0, b1->head);
424 	b0->sense = !b0->sense;
425 	b1->sense = !b1->sense;
426 	merge(b1, b0);
427 	b1->sense = !b1->sense;
428 	b1->head = b0->head;
429 }
430 
431 void
432 gen_or(b0, b1)
433 	struct block *b0, *b1;
434 {
435 	b0->sense = !b0->sense;
436 	backpatch(b0, b1->head);
437 	b0->sense = !b0->sense;
438 	merge(b1, b0);
439 	b1->head = b0->head;
440 }
441 
442 void
443 gen_not(b)
444 	struct block *b;
445 {
446 	b->sense = !b->sense;
447 }
448 
449 static struct block *
450 gen_cmp(offset, size, v)
451 	u_int offset, size;
452 	bpf_int32 v;
453 {
454 	struct slist *s;
455 	struct block *b;
456 
457 	s = new_stmt(BPF_LD|BPF_ABS|size);
458 	s->s.k = offset;
459 
460 	b = new_block(JMP(BPF_JEQ));
461 	b->stmts = s;
462 	b->s.k = v;
463 
464 	return b;
465 }
466 
467 static struct block *
468 gen_mcmp(offset, size, v, mask)
469 	u_int offset, size;
470 	bpf_int32 v;
471 	bpf_u_int32 mask;
472 {
473 	struct block *b = gen_cmp(offset, size, v);
474 	struct slist *s;
475 
476 	if (mask != 0xffffffff) {
477 		s = new_stmt(BPF_ALU|BPF_AND|BPF_K);
478 		s->s.k = mask;
479 		b->stmts->next = s;
480 	}
481 	return b;
482 }
483 
484 static struct block *
485 gen_bcmp(offset, size, v)
486 	register u_int offset, size;
487 	register const u_char *v;
488 {
489 	register struct block *b, *tmp;
490 
491 	b = NULL;
492 	while (size >= 4) {
493 		register const u_char *p = &v[size - 4];
494 		bpf_int32 w = ((bpf_int32)p[0] << 24) |
495 		    ((bpf_int32)p[1] << 16) | ((bpf_int32)p[2] << 8) | p[3];
496 
497 		tmp = gen_cmp(offset + size - 4, BPF_W, w);
498 		if (b != NULL)
499 			gen_and(b, tmp);
500 		b = tmp;
501 		size -= 4;
502 	}
503 	while (size >= 2) {
504 		register const u_char *p = &v[size - 2];
505 		bpf_int32 w = ((bpf_int32)p[0] << 8) | p[1];
506 
507 		tmp = gen_cmp(offset + size - 2, BPF_H, w);
508 		if (b != NULL)
509 			gen_and(b, tmp);
510 		b = tmp;
511 		size -= 2;
512 	}
513 	if (size > 0) {
514 		tmp = gen_cmp(offset, BPF_B, (bpf_int32)v[0]);
515 		if (b != NULL)
516 			gen_and(b, tmp);
517 		b = tmp;
518 	}
519 	return b;
520 }
521 
522 /*
523  * Various code constructs need to know the layout of the data link
524  * layer.  These variables give the necessary offsets.  off_linktype
525  * is set to -1 for no encapsulation, in which case, IP is assumed.
526  */
527 static u_int off_linktype;
528 static u_int off_nl;
529 static int linktype;
530 
531 static void
532 init_linktype(type)
533 	int type;
534 {
535 	linktype = type;
536 
537 	switch (type) {
538 
539 	case DLT_ARCNET:
540 		off_linktype = 2;
541 		off_nl = 6;	/* XXX in reality, variable! */
542 		return;
543 
544 	case DLT_EN10MB:
545 		off_linktype = 12;
546 		off_nl = 14;
547 		return;
548 
549 	case DLT_SLIP:
550 		/*
551 		 * SLIP doesn't have a link level type.  The 16 byte
552 		 * header is hacked into our SLIP driver.
553 		 */
554 		off_linktype = -1;
555 		off_nl = 16;
556 		return;
557 
558 	case DLT_SLIP_BSDOS:
559 		/* XXX this may be the same as the DLT_PPP_BSDOS case */
560 		off_linktype = -1;
561 		/* XXX end */
562 		off_nl = 24;
563 		return;
564 
565 	case DLT_NULL:
566 		off_linktype = 0;
567 		off_nl = 4;
568 		return;
569 
570 	case DLT_PPP:
571 		off_linktype = 2;
572 		off_nl = 4;
573 		return;
574 
575 	case DLT_PPP_BSDOS:
576 		off_linktype = 5;
577 		off_nl = 24;
578 		return;
579 
580 	case DLT_FDDI:
581 		/*
582 		 * FDDI doesn't really have a link-level type field.
583 		 * We assume that SSAP = SNAP is being used and pick
584 		 * out the encapsulated Ethernet type.
585 		 */
586 		off_linktype = 19;
587 #ifdef PCAP_FDDIPAD
588 		off_linktype += pcap_fddipad;
589 #endif
590 		off_nl = 21;
591 #ifdef PCAP_FDDIPAD
592 		off_nl += pcap_fddipad;
593 #endif
594 		return;
595 
596 	case DLT_IEEE802:
597 		off_linktype = 20;
598 		off_nl = 22;
599 		return;
600 
601 	case DLT_ATM_RFC1483:
602 		/*
603 		 * assume routed, non-ISO PDUs
604 		 * (i.e., LLC = 0xAA-AA-03, OUT = 0x00-00-00)
605 		 */
606 		off_linktype = 6;
607 		off_nl = 8;
608 		return;
609 
610 	case DLT_LOOP:
611 		off_linktype = -1;
612 		off_nl = 4;
613 		return;
614 
615 	case DLT_ENC:
616 		off_linktype = -1;
617 		off_nl = 12;
618 		return;
619 
620 	case DLT_PFLOG:
621 		off_linktype = 0;
622 		off_nl = 28;
623 		return;
624 
625 	case DLT_RAW:
626 		off_linktype = -1;
627 		off_nl = 0;
628 		return;
629 	}
630 	bpf_error("unknown data link type 0x%x", linktype);
631 	/* NOTREACHED */
632 }
633 
634 static struct block *
635 gen_uncond(rsense)
636 	int rsense;
637 {
638 	struct block *b;
639 	struct slist *s;
640 
641 	s = new_stmt(BPF_LD|BPF_IMM);
642 	s->s.k = !rsense;
643 	b = new_block(JMP(BPF_JEQ));
644 	b->stmts = s;
645 
646 	return b;
647 }
648 
649 static __inline struct block *
650 gen_true()
651 {
652 	return gen_uncond(1);
653 }
654 
655 static __inline struct block *
656 gen_false()
657 {
658 	return gen_uncond(0);
659 }
660 
661 static struct block *
662 gen_linktype(proto)
663 	register int proto;
664 {
665 	struct block *b0, *b1;
666 
667 	/* If we're not using encapsulation and checking for IP, we're done */
668 	if (off_linktype == -1 && proto == ETHERTYPE_IP)
669 		return gen_true();
670 #ifdef INET6
671 	/* this isn't the right thing to do, but sometimes necessary */
672 	if (off_linktype == -1 && proto == ETHERTYPE_IPV6)
673 		return gen_true();
674 #endif
675 
676 	switch (linktype) {
677 
678 	case DLT_SLIP:
679 		return gen_false();
680 
681 	case DLT_PPP:
682 		if (proto == ETHERTYPE_IP)
683 			proto = PPP_IP;			/* XXX was 0x21 */
684 #ifdef INET6
685 		else if (proto == ETHERTYPE_IPV6)
686 			proto = PPP_IPV6;
687 #endif
688 		break;
689 
690 	case DLT_PPP_BSDOS:
691 		switch (proto) {
692 
693 		case ETHERTYPE_IP:
694 			b0 = gen_cmp(off_linktype, BPF_H, PPP_IP);
695 			b1 = gen_cmp(off_linktype, BPF_H, PPP_VJC);
696 			gen_or(b0, b1);
697 			b0 = gen_cmp(off_linktype, BPF_H, PPP_VJNC);
698 			gen_or(b1, b0);
699 			return b0;
700 
701 #ifdef INET6
702 		case ETHERTYPE_IPV6:
703 			proto = PPP_IPV6;
704 			/* more to go? */
705 			break;
706 #endif /* INET6 */
707 
708 		case ETHERTYPE_DN:
709 			proto = PPP_DECNET;
710 			break;
711 
712 		case ETHERTYPE_ATALK:
713 			proto = PPP_APPLE;
714 			break;
715 
716 		case ETHERTYPE_NS:
717 			proto = PPP_NS;
718 			break;
719 		}
720 		break;
721 
722 	case DLT_LOOP:
723 	case DLT_ENC:
724 	case DLT_NULL:
725 		/* XXX */
726 		if (proto == ETHERTYPE_IP)
727 			return (gen_cmp(0, BPF_W, (bpf_int32)htonl(AF_INET)));
728 #ifdef INET6
729 		else if (proto == ETHERTYPE_IPV6)
730 			return (gen_cmp(0, BPF_W, (bpf_int32)htonl(AF_INET6)));
731 #endif /* INET6 */
732 		else
733 			return gen_false();
734 		break;
735 	case DLT_PFLOG:
736 		if (proto == ETHERTYPE_IP)
737 			return (gen_cmp(0, BPF_W, (bpf_int32)AF_INET));
738 #ifdef INET6
739 		else if (proto == ETHERTYPE_IPV6)
740 			return (gen_cmp(0, BPF_W, (bpf_int32)AF_INET6));
741 #endif /* INET6 */
742 		else
743 			return gen_false();
744 		break;
745 	case DLT_ARCNET:
746 		/*
747 		 * XXX should we check for first fragment if the protocol
748 		 * uses PHDS?
749 		 */
750 		switch(proto) {
751 		default:
752 			return gen_false();
753 #ifdef INET6
754 		case ETHERTYPE_IPV6:
755 			return(gen_cmp(2, BPF_B,
756 					(bpf_int32)htonl(ARCTYPE_INET6)));
757 #endif /* INET6 */
758 		case ETHERTYPE_IP:
759 			b0 = gen_cmp(2, BPF_B, (bpf_int32)htonl(ARCTYPE_IP));
760 			b1 = gen_cmp(2, BPF_B,
761 					(bpf_int32)htonl(ARCTYPE_IP_OLD));
762 			gen_or(b0, b1);
763 			return(b1);
764 		case ETHERTYPE_ARP:
765 			b0 = gen_cmp(2, BPF_B, (bpf_int32)htonl(ARCTYPE_ARP));
766 			b1 = gen_cmp(2, BPF_B,
767 					(bpf_int32)htonl(ARCTYPE_ARP_OLD));
768 			gen_or(b0, b1);
769 			return(b1);
770 		case ETHERTYPE_REVARP:
771 			return(gen_cmp(2, BPF_B,
772 					(bpf_int32)htonl(ARCTYPE_REVARP)));
773 		case ETHERTYPE_ATALK:
774 			return(gen_cmp(2, BPF_B,
775 					(bpf_int32)htonl(ARCTYPE_ATALK)));
776 		}
777 	}
778 	return gen_cmp(off_linktype, BPF_H, (bpf_int32)proto);
779 }
780 
781 static struct block *
782 gen_hostop(addr, mask, dir, proto, src_off, dst_off)
783 	bpf_u_int32 addr;
784 	bpf_u_int32 mask;
785 	int dir, proto;
786 	u_int src_off, dst_off;
787 {
788 	struct block *b0, *b1;
789 	u_int offset;
790 
791 	switch (dir) {
792 
793 	case Q_SRC:
794 		offset = src_off;
795 		break;
796 
797 	case Q_DST:
798 		offset = dst_off;
799 		break;
800 
801 	case Q_AND:
802 		b0 = gen_hostop(addr, mask, Q_SRC, proto, src_off, dst_off);
803 		b1 = gen_hostop(addr, mask, Q_DST, proto, src_off, dst_off);
804 		gen_and(b0, b1);
805 		return b1;
806 
807 	case Q_OR:
808 	case Q_DEFAULT:
809 		b0 = gen_hostop(addr, mask, Q_SRC, proto, src_off, dst_off);
810 		b1 = gen_hostop(addr, mask, Q_DST, proto, src_off, dst_off);
811 		gen_or(b0, b1);
812 		return b1;
813 
814 	default:
815 		abort();
816 	}
817 	b0 = gen_linktype(proto);
818 	b1 = gen_mcmp(offset, BPF_W, (bpf_int32)addr, mask);
819 	gen_and(b0, b1);
820 	return b1;
821 }
822 
823 #ifdef INET6
824 static struct block *
825 gen_hostop6(addr, mask, dir, proto, src_off, dst_off)
826 	struct in6_addr *addr;
827 	struct in6_addr *mask;
828 	int dir, proto;
829 	u_int src_off, dst_off;
830 {
831 	struct block *b0, *b1;
832 	u_int offset;
833 	u_int32_t *a, *m;
834 
835 	switch (dir) {
836 
837 	case Q_SRC:
838 		offset = src_off;
839 		break;
840 
841 	case Q_DST:
842 		offset = dst_off;
843 		break;
844 
845 	case Q_AND:
846 		b0 = gen_hostop6(addr, mask, Q_SRC, proto, src_off, dst_off);
847 		b1 = gen_hostop6(addr, mask, Q_DST, proto, src_off, dst_off);
848 		gen_and(b0, b1);
849 		return b1;
850 
851 	case Q_OR:
852 	case Q_DEFAULT:
853 		b0 = gen_hostop6(addr, mask, Q_SRC, proto, src_off, dst_off);
854 		b1 = gen_hostop6(addr, mask, Q_DST, proto, src_off, dst_off);
855 		gen_or(b0, b1);
856 		return b1;
857 
858 	default:
859 		abort();
860 	}
861 	/* this order is important */
862 	a = (u_int32_t *)addr;
863 	m = (u_int32_t *)mask;
864 	b1 = gen_mcmp(offset + 12, BPF_W, ntohl(a[3]), ntohl(m[3]));
865 	b0 = gen_mcmp(offset + 8, BPF_W, ntohl(a[2]), ntohl(m[2]));
866 	gen_and(b0, b1);
867 	b0 = gen_mcmp(offset + 4, BPF_W, ntohl(a[1]), ntohl(m[1]));
868 	gen_and(b0, b1);
869 	b0 = gen_mcmp(offset + 0, BPF_W, ntohl(a[0]), ntohl(m[0]));
870 	gen_and(b0, b1);
871 	b0 = gen_linktype(proto);
872 	gen_and(b0, b1);
873 	return b1;
874 }
875 #endif /*INET6*/
876 
877 static struct block *
878 gen_ehostop(eaddr, dir)
879 	register const u_char *eaddr;
880 	register int dir;
881 {
882 	struct block *b0, *b1;
883 
884 	switch (dir) {
885 	case Q_SRC:
886 		return gen_bcmp(6, 6, eaddr);
887 
888 	case Q_DST:
889 		return gen_bcmp(0, 6, eaddr);
890 
891 	case Q_AND:
892 		b0 = gen_ehostop(eaddr, Q_SRC);
893 		b1 = gen_ehostop(eaddr, Q_DST);
894 		gen_and(b0, b1);
895 		return b1;
896 
897 	case Q_DEFAULT:
898 	case Q_OR:
899 		b0 = gen_ehostop(eaddr, Q_SRC);
900 		b1 = gen_ehostop(eaddr, Q_DST);
901 		gen_or(b0, b1);
902 		return b1;
903 	}
904 	abort();
905 	/* NOTREACHED */
906 }
907 
908 /*
909  * Like gen_ehostop, but for DLT_FDDI
910  */
911 static struct block *
912 gen_fhostop(eaddr, dir)
913 	register const u_char *eaddr;
914 	register int dir;
915 {
916 	struct block *b0, *b1;
917 
918 	switch (dir) {
919 	case Q_SRC:
920 #ifdef PCAP_FDDIPAD
921 		return gen_bcmp(6 + 1 + pcap_fddipad, 6, eaddr);
922 #else
923 		return gen_bcmp(6 + 1, 6, eaddr);
924 #endif
925 
926 	case Q_DST:
927 #ifdef PCAP_FDDIPAD
928 		return gen_bcmp(0 + 1 + pcap_fddipad, 6, eaddr);
929 #else
930 		return gen_bcmp(0 + 1, 6, eaddr);
931 #endif
932 
933 	case Q_AND:
934 		b0 = gen_fhostop(eaddr, Q_SRC);
935 		b1 = gen_fhostop(eaddr, Q_DST);
936 		gen_and(b0, b1);
937 		return b1;
938 
939 	case Q_DEFAULT:
940 	case Q_OR:
941 		b0 = gen_fhostop(eaddr, Q_SRC);
942 		b1 = gen_fhostop(eaddr, Q_DST);
943 		gen_or(b0, b1);
944 		return b1;
945 	}
946 	abort();
947 	/* NOTREACHED */
948 }
949 
950 /*
951  * This is quite tricky because there may be pad bytes in front of the
952  * DECNET header, and then there are two possible data packet formats that
953  * carry both src and dst addresses, plus 5 packet types in a format that
954  * carries only the src node, plus 2 types that use a different format and
955  * also carry just the src node.
956  *
957  * Yuck.
958  *
959  * Instead of doing those all right, we just look for data packets with
960  * 0 or 1 bytes of padding.  If you want to look at other packets, that
961  * will require a lot more hacking.
962  *
963  * To add support for filtering on DECNET "areas" (network numbers)
964  * one would want to add a "mask" argument to this routine.  That would
965  * make the filter even more inefficient, although one could be clever
966  * and not generate masking instructions if the mask is 0xFFFF.
967  */
968 static struct block *
969 gen_dnhostop(addr, dir, base_off)
970 	bpf_u_int32 addr;
971 	int dir;
972 	u_int base_off;
973 {
974 	struct block *b0, *b1, *b2, *tmp;
975 	u_int offset_lh;	/* offset if long header is received */
976 	u_int offset_sh;	/* offset if short header is received */
977 
978 	switch (dir) {
979 
980 	case Q_DST:
981 		offset_sh = 1;	/* follows flags */
982 		offset_lh = 7;	/* flgs,darea,dsubarea,HIORD */
983 		break;
984 
985 	case Q_SRC:
986 		offset_sh = 3;	/* follows flags, dstnode */
987 		offset_lh = 15;	/* flgs,darea,dsubarea,did,sarea,ssub,HIORD */
988 		break;
989 
990 	case Q_AND:
991 		/* Inefficient because we do our Calvinball dance twice */
992 		b0 = gen_dnhostop(addr, Q_SRC, base_off);
993 		b1 = gen_dnhostop(addr, Q_DST, base_off);
994 		gen_and(b0, b1);
995 		return b1;
996 
997 	case Q_OR:
998 	case Q_DEFAULT:
999 		/* Inefficient because we do our Calvinball dance twice */
1000 		b0 = gen_dnhostop(addr, Q_SRC, base_off);
1001 		b1 = gen_dnhostop(addr, Q_DST, base_off);
1002 		gen_or(b0, b1);
1003 		return b1;
1004 
1005 	default:
1006 		abort();
1007 	}
1008 	b0 = gen_linktype(ETHERTYPE_DN);
1009 	/* Check for pad = 1, long header case */
1010 	tmp = gen_mcmp(base_off + 2, BPF_H,
1011 	    (bpf_int32)ntohs(0x0681), (bpf_int32)ntohs(0x07FF));
1012 	b1 = gen_cmp(base_off + 2 + 1 + offset_lh,
1013 	    BPF_H, (bpf_int32)ntohs(addr));
1014 	gen_and(tmp, b1);
1015 	/* Check for pad = 0, long header case */
1016 	tmp = gen_mcmp(base_off + 2, BPF_B, (bpf_int32)0x06, (bpf_int32)0x7);
1017 	b2 = gen_cmp(base_off + 2 + offset_lh, BPF_H, (bpf_int32)ntohs(addr));
1018 	gen_and(tmp, b2);
1019 	gen_or(b2, b1);
1020 	/* Check for pad = 1, short header case */
1021 	tmp = gen_mcmp(base_off + 2, BPF_H,
1022 	    (bpf_int32)ntohs(0x0281), (bpf_int32)ntohs(0x07FF));
1023 	b2 = gen_cmp(base_off + 2 + 1 + offset_sh,
1024 	    BPF_H, (bpf_int32)ntohs(addr));
1025 	gen_and(tmp, b2);
1026 	gen_or(b2, b1);
1027 	/* Check for pad = 0, short header case */
1028 	tmp = gen_mcmp(base_off + 2, BPF_B, (bpf_int32)0x02, (bpf_int32)0x7);
1029 	b2 = gen_cmp(base_off + 2 + offset_sh, BPF_H, (bpf_int32)ntohs(addr));
1030 	gen_and(tmp, b2);
1031 	gen_or(b2, b1);
1032 
1033 	/* Combine with test for linktype */
1034 	gen_and(b0, b1);
1035 	return b1;
1036 }
1037 
1038 static struct block *
1039 gen_host(addr, mask, proto, dir)
1040 	bpf_u_int32 addr;
1041 	bpf_u_int32 mask;
1042 	int proto;
1043 	int dir;
1044 {
1045 	struct block *b0, *b1;
1046 
1047 	switch (proto) {
1048 
1049 	case Q_DEFAULT:
1050 		b0 = gen_host(addr, mask, Q_IP, dir);
1051 		b1 = gen_host(addr, mask, Q_ARP, dir);
1052 		gen_or(b0, b1);
1053 		b0 = gen_host(addr, mask, Q_RARP, dir);
1054 		gen_or(b1, b0);
1055 		return b0;
1056 
1057 	case Q_IP:
1058 		return gen_hostop(addr, mask, dir, ETHERTYPE_IP,
1059 				  off_nl + 12, off_nl + 16);
1060 
1061 	case Q_RARP:
1062 		return gen_hostop(addr, mask, dir, ETHERTYPE_REVARP,
1063 				  off_nl + 14, off_nl + 24);
1064 
1065 	case Q_ARP:
1066 		return gen_hostop(addr, mask, dir, ETHERTYPE_ARP,
1067 				  off_nl + 14, off_nl + 24);
1068 
1069 	case Q_TCP:
1070 		bpf_error("'tcp' modifier applied to host");
1071 
1072 	case Q_UDP:
1073 		bpf_error("'udp' modifier applied to host");
1074 
1075 	case Q_ICMP:
1076 		bpf_error("'icmp' modifier applied to host");
1077 
1078 	case Q_IGMP:
1079 		bpf_error("'igmp' modifier applied to host");
1080 
1081 	case Q_IGRP:
1082 		bpf_error("'igrp' modifier applied to host");
1083 
1084 	case Q_PIM:
1085 		bpf_error("'pim' modifier applied to host");
1086 
1087 	case Q_ATALK:
1088 		bpf_error("ATALK host filtering not implemented");
1089 
1090 	case Q_DECNET:
1091 		return gen_dnhostop(addr, dir, off_nl);
1092 
1093 	case Q_SCA:
1094 		bpf_error("SCA host filtering not implemented");
1095 
1096 	case Q_LAT:
1097 		bpf_error("LAT host filtering not implemented");
1098 
1099 	case Q_MOPDL:
1100 		bpf_error("MOPDL host filtering not implemented");
1101 
1102 	case Q_MOPRC:
1103 		bpf_error("MOPRC host filtering not implemented");
1104 
1105 #ifdef INET6
1106 	case Q_IPV6:
1107 		bpf_error("'ip6' modifier applied to ip host");
1108 
1109 	case Q_ICMPV6:
1110 		bpf_error("'icmp6' modifier applied to host");
1111 #endif /* INET6 */
1112 
1113 	case Q_AH:
1114 		bpf_error("'ah' modifier applied to host");
1115 
1116 	case Q_ESP:
1117 		bpf_error("'esp' modifier applied to host");
1118 
1119 	default:
1120 		abort();
1121 	}
1122 	/* NOTREACHED */
1123 }
1124 
1125 #ifdef INET6
1126 static struct block *
1127 gen_host6(addr, mask, proto, dir)
1128 	struct in6_addr *addr;
1129 	struct in6_addr *mask;
1130 	int proto;
1131 	int dir;
1132 {
1133 	switch (proto) {
1134 
1135 	case Q_DEFAULT:
1136 		return gen_host6(addr, mask, Q_IPV6, dir);
1137 
1138 	case Q_IP:
1139 		bpf_error("'ip' modifier applied to ip6 host");
1140 
1141 	case Q_RARP:
1142 		bpf_error("'rarp' modifier applied to ip6 host");
1143 
1144 	case Q_ARP:
1145 		bpf_error("'arp' modifier applied to ip6 host");
1146 
1147 	case Q_TCP:
1148 		bpf_error("'tcp' modifier applied to host");
1149 
1150 	case Q_UDP:
1151 		bpf_error("'udp' modifier applied to host");
1152 
1153 	case Q_ICMP:
1154 		bpf_error("'icmp' modifier applied to host");
1155 
1156 	case Q_IGMP:
1157 		bpf_error("'igmp' modifier applied to host");
1158 
1159 	case Q_IGRP:
1160 		bpf_error("'igrp' modifier applied to host");
1161 
1162 	case Q_PIM:
1163 		bpf_error("'pim' modifier applied to host");
1164 
1165 	case Q_ATALK:
1166 		bpf_error("ATALK host filtering not implemented");
1167 
1168 	case Q_DECNET:
1169 		bpf_error("'decnet' modifier applied to ip6 host");
1170 
1171 	case Q_SCA:
1172 		bpf_error("SCA host filtering not implemented");
1173 
1174 	case Q_LAT:
1175 		bpf_error("LAT host filtering not implemented");
1176 
1177 	case Q_MOPDL:
1178 		bpf_error("MOPDL host filtering not implemented");
1179 
1180 	case Q_MOPRC:
1181 		bpf_error("MOPRC host filtering not implemented");
1182 
1183 	case Q_IPV6:
1184 		return gen_hostop6(addr, mask, dir, ETHERTYPE_IPV6,
1185 				  off_nl + 8, off_nl + 24);
1186 
1187 	case Q_ICMPV6:
1188 		bpf_error("'icmp6' modifier applied to host");
1189 
1190 	case Q_AH:
1191 		bpf_error("'ah' modifier applied to host");
1192 
1193 	case Q_ESP:
1194 		bpf_error("'esp' modifier applied to host");
1195 
1196 	default:
1197 		abort();
1198 	}
1199 	/* NOTREACHED */
1200 }
1201 #endif /*INET6*/
1202 
1203 #ifndef INET6
1204 static struct block *
1205 gen_gateway(eaddr, alist, proto, dir)
1206 	const u_char *eaddr;
1207 	bpf_u_int32 **alist;
1208 	int proto;
1209 	int dir;
1210 {
1211 	struct block *b0, *b1, *tmp;
1212 
1213 	if (dir != 0)
1214 		bpf_error("direction applied to 'gateway'");
1215 
1216 	switch (proto) {
1217 	case Q_DEFAULT:
1218 	case Q_IP:
1219 	case Q_ARP:
1220 	case Q_RARP:
1221 		if (linktype == DLT_EN10MB)
1222 			b0 = gen_ehostop(eaddr, Q_OR);
1223 		else if (linktype == DLT_FDDI)
1224 			b0 = gen_fhostop(eaddr, Q_OR);
1225 		else
1226 			bpf_error(
1227 			    "'gateway' supported only on ethernet or FDDI");
1228 
1229 		b1 = gen_host(**alist++, 0xffffffff, proto, Q_OR);
1230 		while (*alist) {
1231 			tmp = gen_host(**alist++, 0xffffffff, proto, Q_OR);
1232 			gen_or(b1, tmp);
1233 			b1 = tmp;
1234 		}
1235 		gen_not(b1);
1236 		gen_and(b0, b1);
1237 		return b1;
1238 	}
1239 	bpf_error("illegal modifier of 'gateway'");
1240 	/* NOTREACHED */
1241 }
1242 #endif	/*INET6*/
1243 
1244 struct block *
1245 gen_proto_abbrev(proto)
1246 	int proto;
1247 {
1248 	struct block *b0 = NULL, *b1;
1249 
1250 	switch (proto) {
1251 
1252 	case Q_TCP:
1253 		b1 = gen_proto(IPPROTO_TCP, Q_IP, Q_DEFAULT);
1254 #ifdef INET6
1255 		b0 = gen_proto(IPPROTO_TCP, Q_IPV6, Q_DEFAULT);
1256 		gen_or(b0, b1);
1257 #endif
1258 		break;
1259 
1260 	case Q_UDP:
1261 		b1 = gen_proto(IPPROTO_UDP, Q_IP, Q_DEFAULT);
1262 #ifdef INET6
1263 		b0 = gen_proto(IPPROTO_UDP, Q_IPV6, Q_DEFAULT);
1264 		gen_or(b0, b1);
1265 #endif
1266 		break;
1267 
1268 	case Q_ICMP:
1269 		b1 = gen_proto(IPPROTO_ICMP, Q_IP, Q_DEFAULT);
1270 		break;
1271 
1272 #ifndef	IPPROTO_IGMP
1273 #define	IPPROTO_IGMP	2
1274 #endif
1275 
1276 	case Q_IGMP:
1277 		b1 = gen_proto(IPPROTO_IGMP, Q_IP, Q_DEFAULT);
1278 		break;
1279 
1280 #ifndef	IPPROTO_IGRP
1281 #define	IPPROTO_IGRP	9
1282 #endif
1283 	case Q_IGRP:
1284 		b1 = gen_proto(IPPROTO_IGRP, Q_IP, Q_DEFAULT);
1285 		break;
1286 
1287 #ifndef IPPROTO_PIM
1288 #define IPPROTO_PIM	103
1289 #endif
1290 
1291 	case Q_PIM:
1292 		b1 = gen_proto(IPPROTO_PIM, Q_IP, Q_DEFAULT);
1293 #ifdef INET6
1294 		b0 = gen_proto(IPPROTO_PIM, Q_IPV6, Q_DEFAULT);
1295 		gen_or(b0, b1);
1296 #endif
1297 		break;
1298 
1299 	case Q_IP:
1300 		b1 =  gen_linktype(ETHERTYPE_IP);
1301 		break;
1302 
1303 	case Q_ARP:
1304 		b1 =  gen_linktype(ETHERTYPE_ARP);
1305 		break;
1306 
1307 	case Q_RARP:
1308 		b1 =  gen_linktype(ETHERTYPE_REVARP);
1309 		break;
1310 
1311 	case Q_LINK:
1312 		bpf_error("link layer applied in wrong context");
1313 
1314 	case Q_ATALK:
1315 		b1 =  gen_linktype(ETHERTYPE_ATALK);
1316 		break;
1317 
1318 	case Q_DECNET:
1319 		b1 =  gen_linktype(ETHERTYPE_DN);
1320 		break;
1321 
1322 	case Q_SCA:
1323 		b1 =  gen_linktype(ETHERTYPE_SCA);
1324 		break;
1325 
1326 	case Q_LAT:
1327 		b1 =  gen_linktype(ETHERTYPE_LAT);
1328 		break;
1329 
1330 	case Q_MOPDL:
1331 		b1 =  gen_linktype(ETHERTYPE_MOPDL);
1332 		break;
1333 
1334 	case Q_MOPRC:
1335 		b1 =  gen_linktype(ETHERTYPE_MOPRC);
1336 		break;
1337 
1338 #ifdef INET6
1339 	case Q_IPV6:
1340 		b1 = gen_linktype(ETHERTYPE_IPV6);
1341 		break;
1342 
1343 #ifndef IPPROTO_ICMPV6
1344 #define IPPROTO_ICMPV6	58
1345 #endif
1346 	case Q_ICMPV6:
1347 		b1 = gen_proto(IPPROTO_ICMPV6, Q_IPV6, Q_DEFAULT);
1348 		break;
1349 #endif /* INET6 */
1350 
1351 #ifndef IPPROTO_AH
1352 #define IPPROTO_AH	51
1353 #endif
1354 	case Q_AH:
1355 		b1 = gen_proto(IPPROTO_AH, Q_IP, Q_DEFAULT);
1356 #ifdef INET6
1357 		b0 = gen_proto(IPPROTO_AH, Q_IPV6, Q_DEFAULT);
1358 		gen_or(b0, b1);
1359 #endif
1360 		break;
1361 
1362 #ifndef IPPROTO_ESP
1363 #define IPPROTO_ESP	50
1364 #endif
1365 	case Q_ESP:
1366 		b1 = gen_proto(IPPROTO_ESP, Q_IP, Q_DEFAULT);
1367 #ifdef INET6
1368 		b0 = gen_proto(IPPROTO_ESP, Q_IPV6, Q_DEFAULT);
1369 		gen_or(b0, b1);
1370 #endif
1371 		break;
1372 
1373 	default:
1374 		abort();
1375 	}
1376 	return b1;
1377 }
1378 
1379 static struct block *
1380 gen_ipfrag()
1381 {
1382 	struct slist *s;
1383 	struct block *b;
1384 
1385 	/* not ip frag */
1386 	s = new_stmt(BPF_LD|BPF_H|BPF_ABS);
1387 	s->s.k = off_nl + 6;
1388 	b = new_block(JMP(BPF_JSET));
1389 	b->s.k = 0x1fff;
1390 	b->stmts = s;
1391 	gen_not(b);
1392 
1393 	return b;
1394 }
1395 
1396 static struct block *
1397 gen_portatom(off, v)
1398 	int off;
1399 	bpf_int32 v;
1400 {
1401 	struct slist *s;
1402 	struct block *b;
1403 
1404 	s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
1405 	s->s.k = off_nl;
1406 
1407 	s->next = new_stmt(BPF_LD|BPF_IND|BPF_H);
1408 	s->next->s.k = off_nl + off;
1409 
1410 	b = new_block(JMP(BPF_JEQ));
1411 	b->stmts = s;
1412 	b->s.k = v;
1413 
1414 	return b;
1415 }
1416 
1417 #ifdef INET6
1418 static struct block *
1419 gen_portatom6(off, v)
1420 	int off;
1421 	bpf_int32 v;
1422 {
1423 	return gen_cmp(off_nl + 40 + off, BPF_H, v);
1424 }
1425 #endif/*INET6*/
1426 
1427 struct block *
1428 gen_portop(port, proto, dir)
1429 	int port, proto, dir;
1430 {
1431 	struct block *b0, *b1, *tmp;
1432 
1433 	/* ip proto 'proto' */
1434 	tmp = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)proto);
1435 	b0 = gen_ipfrag();
1436 	gen_and(tmp, b0);
1437 
1438 	switch (dir) {
1439 	case Q_SRC:
1440 		b1 = gen_portatom(0, (bpf_int32)port);
1441 		break;
1442 
1443 	case Q_DST:
1444 		b1 = gen_portatom(2, (bpf_int32)port);
1445 		break;
1446 
1447 	case Q_OR:
1448 	case Q_DEFAULT:
1449 		tmp = gen_portatom(0, (bpf_int32)port);
1450 		b1 = gen_portatom(2, (bpf_int32)port);
1451 		gen_or(tmp, b1);
1452 		break;
1453 
1454 	case Q_AND:
1455 		tmp = gen_portatom(0, (bpf_int32)port);
1456 		b1 = gen_portatom(2, (bpf_int32)port);
1457 		gen_and(tmp, b1);
1458 		break;
1459 
1460 	default:
1461 		abort();
1462 	}
1463 	gen_and(b0, b1);
1464 
1465 	return b1;
1466 }
1467 
1468 static struct block *
1469 gen_port(port, ip_proto, dir)
1470 	int port;
1471 	int ip_proto;
1472 	int dir;
1473 {
1474 	struct block *b0, *b1, *tmp;
1475 
1476 	/* ether proto ip */
1477 	b0 =  gen_linktype(ETHERTYPE_IP);
1478 
1479 	switch (ip_proto) {
1480 	case IPPROTO_UDP:
1481 	case IPPROTO_TCP:
1482 		b1 = gen_portop(port, ip_proto, dir);
1483 		break;
1484 
1485 	case PROTO_UNDEF:
1486 		tmp = gen_portop(port, IPPROTO_TCP, dir);
1487 		b1 = gen_portop(port, IPPROTO_UDP, dir);
1488 		gen_or(tmp, b1);
1489 		break;
1490 
1491 	default:
1492 		abort();
1493 	}
1494 	gen_and(b0, b1);
1495 	return b1;
1496 }
1497 
1498 #ifdef INET6
1499 struct block *
1500 gen_portop6(port, proto, dir)
1501 	int port, proto, dir;
1502 {
1503 	struct block *b0, *b1, *tmp;
1504 
1505 	/* ip proto 'proto' */
1506 	b0 = gen_cmp(off_nl + 6, BPF_B, (bpf_int32)proto);
1507 
1508 	switch (dir) {
1509 	case Q_SRC:
1510 		b1 = gen_portatom6(0, (bpf_int32)port);
1511 		break;
1512 
1513 	case Q_DST:
1514 		b1 = gen_portatom6(2, (bpf_int32)port);
1515 		break;
1516 
1517 	case Q_OR:
1518 	case Q_DEFAULT:
1519 		tmp = gen_portatom6(0, (bpf_int32)port);
1520 		b1 = gen_portatom6(2, (bpf_int32)port);
1521 		gen_or(tmp, b1);
1522 		break;
1523 
1524 	case Q_AND:
1525 		tmp = gen_portatom6(0, (bpf_int32)port);
1526 		b1 = gen_portatom6(2, (bpf_int32)port);
1527 		gen_and(tmp, b1);
1528 		break;
1529 
1530 	default:
1531 		abort();
1532 	}
1533 	gen_and(b0, b1);
1534 
1535 	return b1;
1536 }
1537 
1538 static struct block *
1539 gen_port6(port, ip_proto, dir)
1540 	int port;
1541 	int ip_proto;
1542 	int dir;
1543 {
1544 	struct block *b0, *b1, *tmp;
1545 
1546 	/* ether proto ip */
1547 	b0 =  gen_linktype(ETHERTYPE_IPV6);
1548 
1549 	switch (ip_proto) {
1550 	case IPPROTO_UDP:
1551 	case IPPROTO_TCP:
1552 		b1 = gen_portop6(port, ip_proto, dir);
1553 		break;
1554 
1555 	case PROTO_UNDEF:
1556 		tmp = gen_portop6(port, IPPROTO_TCP, dir);
1557 		b1 = gen_portop6(port, IPPROTO_UDP, dir);
1558 		gen_or(tmp, b1);
1559 		break;
1560 
1561 	default:
1562 		abort();
1563 	}
1564 	gen_and(b0, b1);
1565 	return b1;
1566 }
1567 #endif /* INET6 */
1568 
1569 static int
1570 lookup_proto(name, proto)
1571 	register const char *name;
1572 	register int proto;
1573 {
1574 	register int v;
1575 
1576 	switch (proto) {
1577 
1578 	case Q_DEFAULT:
1579 	case Q_IP:
1580 		v = pcap_nametoproto(name);
1581 		if (v == PROTO_UNDEF)
1582 			bpf_error("unknown ip proto '%s'", name);
1583 		break;
1584 
1585 	case Q_LINK:
1586 		/* XXX should look up h/w protocol type based on linktype */
1587 		v = pcap_nametoeproto(name);
1588 		if (v == PROTO_UNDEF)
1589 			bpf_error("unknown ether proto '%s'", name);
1590 		break;
1591 
1592 	default:
1593 		v = PROTO_UNDEF;
1594 		break;
1595 	}
1596 	return v;
1597 }
1598 
1599 static struct block *
1600 gen_protochain(v, proto, dir)
1601 	int v;
1602 	int proto;
1603 	int dir;
1604 {
1605 	struct block *b0, *b;
1606 	struct slist *s[100];
1607 	int fix2, fix3, fix4, fix5;
1608 	int ahcheck, again, end;
1609 	int i, max;
1610 	int reg1 = alloc_reg();
1611 	int reg2 = alloc_reg();
1612 
1613 	memset(s, 0, sizeof(s));
1614 	fix2 = fix3 = fix4 = fix5 = 0;
1615 
1616 	switch (proto) {
1617 	case Q_IP:
1618 	case Q_IPV6:
1619 		break;
1620 	case Q_DEFAULT:
1621 		b0 = gen_protochain(v, Q_IP, dir);
1622 		b = gen_protochain(v, Q_IPV6, dir);
1623 		gen_or(b0, b);
1624 		return b;
1625 	default:
1626 		bpf_error("bad protocol applied for 'protochain'");
1627 		/*NOTREACHED*/
1628 	}
1629 
1630 	no_optimize = 1; /*this code is not compatible with optimzer yet */
1631 
1632 	/*
1633 	 * s[0] is a dummy entry to protect other BPF insn from damaged
1634 	 * by s[fix] = foo with uninitialized variable "fix".  It is somewhat
1635 	 * hard to find interdependency made by jump table fixup.
1636 	 */
1637 	i = 0;
1638 	s[i] = new_stmt(0);	/*dummy*/
1639 	i++;
1640 
1641 	switch (proto) {
1642 	case Q_IP:
1643 		b0 = gen_linktype(ETHERTYPE_IP);
1644 
1645 		/* A = ip->ip_p */
1646 		s[i] = new_stmt(BPF_LD|BPF_ABS|BPF_B);
1647 		s[i]->s.k = off_nl + 9;
1648 		i++;
1649 		/* X = ip->ip_hl << 2 */
1650 		s[i] = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
1651 		s[i]->s.k = off_nl;
1652 		i++;
1653 		break;
1654 	case Q_IPV6:
1655 		b0 = gen_linktype(ETHERTYPE_IPV6);
1656 
1657 		/* A = ip6->ip_nxt */
1658 		s[i] = new_stmt(BPF_LD|BPF_ABS|BPF_B);
1659 		s[i]->s.k = off_nl + 6;
1660 		i++;
1661 		/* X = sizeof(struct ip6_hdr) */
1662 		s[i] = new_stmt(BPF_LDX|BPF_IMM);
1663 		s[i]->s.k = 40;
1664 		i++;
1665 		break;
1666 	default:
1667 		bpf_error("unsupported proto to gen_protochain");
1668 		/*NOTREACHED*/
1669 	}
1670 
1671 	/* again: if (A == v) goto end; else fall through; */
1672 	again = i;
1673 	s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
1674 	s[i]->s.k = v;
1675 	s[i]->s.jt = NULL;		/*later*/
1676 	s[i]->s.jf = NULL;		/*update in next stmt*/
1677 	fix5 = i;
1678 	i++;
1679 
1680 	/* if (A == IPPROTO_NONE) goto end */
1681 	s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
1682 	s[i]->s.jt = NULL;	/*later*/
1683 	s[i]->s.jf = NULL;	/*update in next stmt*/
1684 	s[i]->s.k = IPPROTO_NONE;
1685 	s[fix5]->s.jf = s[i];
1686 	fix2 = i;
1687 	i++;
1688 
1689 	if (proto == Q_IPV6) {
1690 		int v6start, v6end, v6advance, j;
1691 
1692 		v6start = i;
1693 		/* if (A == IPPROTO_HOPOPTS) goto v6advance */
1694 		s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
1695 		s[i]->s.jt = NULL;	/*later*/
1696 		s[i]->s.jf = NULL;	/*update in next stmt*/
1697 		s[i]->s.k = IPPROTO_HOPOPTS;
1698 		s[fix2]->s.jf = s[i];
1699 		i++;
1700 		/* if (A == IPPROTO_DSTOPTS) goto v6advance */
1701 		s[i - 1]->s.jf = s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
1702 		s[i]->s.jt = NULL;	/*later*/
1703 		s[i]->s.jf = NULL;	/*update in next stmt*/
1704 		s[i]->s.k = IPPROTO_DSTOPTS;
1705 		i++;
1706 		/* if (A == IPPROTO_ROUTING) goto v6advance */
1707 		s[i - 1]->s.jf = s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
1708 		s[i]->s.jt = NULL;	/*later*/
1709 		s[i]->s.jf = NULL;	/*update in next stmt*/
1710 		s[i]->s.k = IPPROTO_ROUTING;
1711 		i++;
1712 		/* if (A == IPPROTO_FRAGMENT) goto v6advance; else goto ahcheck; */
1713 		s[i - 1]->s.jf = s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
1714 		s[i]->s.jt = NULL;	/*later*/
1715 		s[i]->s.jf = NULL;	/*later*/
1716 		s[i]->s.k = IPPROTO_FRAGMENT;
1717 		fix3 = i;
1718 		v6end = i;
1719 		i++;
1720 
1721 		/* v6advance: */
1722 		v6advance = i;
1723 
1724 		/*
1725 		 * in short,
1726 		 * A = P[X + 1];
1727 		 * X = X + (P[X] + 1) * 8;
1728 		 */
1729 		/* A = X */
1730 		s[i] = new_stmt(BPF_MISC|BPF_TXA);
1731 		i++;
1732 		/* MEM[reg1] = A */
1733 		s[i] = new_stmt(BPF_ST);
1734 		s[i]->s.k = reg1;
1735 		i++;
1736 		/* A += 1 */
1737 		s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
1738 		s[i]->s.k = 1;
1739 		i++;
1740 		/* X = A */
1741 		s[i] = new_stmt(BPF_MISC|BPF_TAX);
1742 		i++;
1743 		/* A = P[X + packet head]; */
1744 		s[i] = new_stmt(BPF_LD|BPF_IND|BPF_B);
1745 		s[i]->s.k = off_nl;
1746 		i++;
1747 		/* MEM[reg2] = A */
1748 		s[i] = new_stmt(BPF_ST);
1749 		s[i]->s.k = reg2;
1750 		i++;
1751 		/* X = MEM[reg1] */
1752 		s[i] = new_stmt(BPF_LDX|BPF_MEM);
1753 		s[i]->s.k = reg1;
1754 		i++;
1755 		/* A = P[X + packet head] */
1756 		s[i] = new_stmt(BPF_LD|BPF_IND|BPF_B);
1757 		s[i]->s.k = off_nl;
1758 		i++;
1759 		/* A += 1 */
1760 		s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
1761 		s[i]->s.k = 1;
1762 		i++;
1763 		/* A *= 8 */
1764 		s[i] = new_stmt(BPF_ALU|BPF_MUL|BPF_K);
1765 		s[i]->s.k = 8;
1766 		i++;
1767 		/* X = A; */
1768 		s[i] = new_stmt(BPF_MISC|BPF_TAX);
1769 		i++;
1770 		/* A = MEM[reg2] */
1771 		s[i] = new_stmt(BPF_LD|BPF_MEM);
1772 		s[i]->s.k = reg2;
1773 		i++;
1774 
1775 		/* goto again; (must use BPF_JA for backward jump) */
1776 		s[i] = new_stmt(BPF_JMP|BPF_JA);
1777 		s[i]->s.k = again - i - 1;
1778 		s[i - 1]->s.jf = s[i];
1779 		i++;
1780 
1781 		/* fixup */
1782 		for (j = v6start; j <= v6end; j++)
1783 			s[j]->s.jt = s[v6advance];
1784 	} else {
1785 		/* nop */
1786 		s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
1787 		s[i]->s.k = 0;
1788 		s[fix2]->s.jf = s[i];
1789 		i++;
1790 	}
1791 
1792 	/* ahcheck: */
1793 	ahcheck = i;
1794 	/* if (A == IPPROTO_AH) then fall through; else goto end; */
1795 	s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
1796 	s[i]->s.jt = NULL;	/*later*/
1797 	s[i]->s.jf = NULL;	/*later*/
1798 	s[i]->s.k = IPPROTO_AH;
1799 	if (fix3)
1800 		s[fix3]->s.jf = s[ahcheck];
1801 	fix4 = i;
1802 	i++;
1803 
1804 	/*
1805 	 * in short,
1806 	 * A = P[X + 1];
1807 	 * X = X + (P[X] + 2) * 4;
1808 	 */
1809 	/* A = X */
1810 	s[i - 1]->s.jt = s[i] = new_stmt(BPF_MISC|BPF_TXA);
1811 	i++;
1812 	/* MEM[reg1] = A */
1813 	s[i] = new_stmt(BPF_ST);
1814 	s[i]->s.k = reg1;
1815 	i++;
1816 	/* A += 1 */
1817 	s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
1818 	s[i]->s.k = 1;
1819 	i++;
1820 	/* X = A */
1821 	s[i] = new_stmt(BPF_MISC|BPF_TAX);
1822 	i++;
1823 	/* A = P[X + packet head]; */
1824 	s[i] = new_stmt(BPF_LD|BPF_IND|BPF_B);
1825 	s[i]->s.k = off_nl;
1826 	i++;
1827 	/* MEM[reg2] = A */
1828 	s[i] = new_stmt(BPF_ST);
1829 	s[i]->s.k = reg2;
1830 	i++;
1831 	/* X = MEM[reg1] */
1832 	s[i] = new_stmt(BPF_LDX|BPF_MEM);
1833 	s[i]->s.k = reg1;
1834 	i++;
1835 	/* A = P[X + packet head] */
1836 	s[i] = new_stmt(BPF_LD|BPF_IND|BPF_B);
1837 	s[i]->s.k = off_nl;
1838 	i++;
1839 	/* A += 2 */
1840 	s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
1841 	s[i]->s.k = 2;
1842 	i++;
1843 	/* A *= 4 */
1844 	s[i] = new_stmt(BPF_ALU|BPF_MUL|BPF_K);
1845 	s[i]->s.k = 4;
1846 	i++;
1847 	/* X = A; */
1848 	s[i] = new_stmt(BPF_MISC|BPF_TAX);
1849 	i++;
1850 	/* A = MEM[reg2] */
1851 	s[i] = new_stmt(BPF_LD|BPF_MEM);
1852 	s[i]->s.k = reg2;
1853 	i++;
1854 
1855 	/* goto again; (must use BPF_JA for backward jump) */
1856 	s[i] = new_stmt(BPF_JMP|BPF_JA);
1857 	s[i]->s.k = again - i - 1;
1858 	i++;
1859 
1860 	/* end: nop */
1861 	end = i;
1862 	s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
1863 	s[i]->s.k = 0;
1864 	s[fix2]->s.jt = s[end];
1865 	s[fix4]->s.jf = s[end];
1866 	s[fix5]->s.jt = s[end];
1867 	i++;
1868 
1869 	/*
1870 	 * make slist chain
1871 	 */
1872 	max = i;
1873 	for (i = 0; i < max - 1; i++)
1874 		s[i]->next = s[i + 1];
1875 	s[max - 1]->next = NULL;
1876 
1877 	/*
1878 	 * emit final check
1879 	 */
1880 	b = new_block(JMP(BPF_JEQ));
1881 	b->stmts = s[1];	/*remember, s[0] is dummy*/
1882 	b->s.k = v;
1883 
1884 	free_reg(reg1);
1885 	free_reg(reg2);
1886 
1887 	gen_and(b0, b);
1888 	return b;
1889 }
1890 
1891 static struct block *
1892 gen_proto(v, proto, dir)
1893 	int v;
1894 	int proto;
1895 	int dir;
1896 {
1897 	struct block *b0, *b1;
1898 
1899 	if (dir != Q_DEFAULT)
1900 		bpf_error("direction applied to 'proto'");
1901 
1902 	switch (proto) {
1903 	case Q_DEFAULT:
1904 #ifdef INET6
1905 		b0 = gen_proto(v, Q_IP, dir);
1906 		b1 = gen_proto(v, Q_IPV6, dir);
1907 		gen_or(b0, b1);
1908 		return b1;
1909 #else
1910 		/*FALLTHROUGH*/
1911 #endif
1912 	case Q_IP:
1913 		b0 = gen_linktype(ETHERTYPE_IP);
1914 #ifndef CHASE_CHAIN
1915 		b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)v);
1916 #else
1917 		b1 = gen_protochain(v, Q_IP);
1918 #endif
1919 		gen_and(b0, b1);
1920 		return b1;
1921 
1922 	case Q_ARP:
1923 		bpf_error("arp does not encapsulate another protocol");
1924 		/* NOTREACHED */
1925 
1926 	case Q_RARP:
1927 		bpf_error("rarp does not encapsulate another protocol");
1928 		/* NOTREACHED */
1929 
1930 	case Q_ATALK:
1931 		bpf_error("atalk encapsulation is not specifiable");
1932 		/* NOTREACHED */
1933 
1934 	case Q_DECNET:
1935 		bpf_error("decnet encapsulation is not specifiable");
1936 		/* NOTREACHED */
1937 
1938 	case Q_SCA:
1939 		bpf_error("sca does not encapsulate another protocol");
1940 		/* NOTREACHED */
1941 
1942 	case Q_LAT:
1943 		bpf_error("lat does not encapsulate another protocol");
1944 		/* NOTREACHED */
1945 
1946 	case Q_MOPRC:
1947 		bpf_error("moprc does not encapsulate another protocol");
1948 		/* NOTREACHED */
1949 
1950 	case Q_MOPDL:
1951 		bpf_error("mopdl does not encapsulate another protocol");
1952 		/* NOTREACHED */
1953 
1954 	case Q_LINK:
1955 		return gen_linktype(v);
1956 
1957 	case Q_UDP:
1958 		bpf_error("'udp proto' is bogus");
1959 		/* NOTREACHED */
1960 
1961 	case Q_TCP:
1962 		bpf_error("'tcp proto' is bogus");
1963 		/* NOTREACHED */
1964 
1965 	case Q_ICMP:
1966 		bpf_error("'icmp proto' is bogus");
1967 		/* NOTREACHED */
1968 
1969 	case Q_IGMP:
1970 		bpf_error("'igmp proto' is bogus");
1971 		/* NOTREACHED */
1972 
1973 	case Q_IGRP:
1974 		bpf_error("'igrp proto' is bogus");
1975 		/* NOTREACHED */
1976 
1977 	case Q_PIM:
1978 		bpf_error("'pim proto' is bogus");
1979 		/* NOTREACHED */
1980 
1981 #ifdef INET6
1982 	case Q_IPV6:
1983 		b0 = gen_linktype(ETHERTYPE_IPV6);
1984 #ifndef CHASE_CHAIN
1985 		b1 = gen_cmp(off_nl + 6, BPF_B, (bpf_int32)v);
1986 #else
1987 		b1 = gen_protochain(v, Q_IPV6);
1988 #endif
1989 		gen_and(b0, b1);
1990 		return b1;
1991 
1992 	case Q_ICMPV6:
1993 		bpf_error("'icmp6 proto' is bogus");
1994 #endif /* INET6 */
1995 
1996 	case Q_AH:
1997 		bpf_error("'ah proto' is bogus");
1998 
1999 	case Q_ESP:
2000 		bpf_error("'ah proto' is bogus");
2001 
2002 	default:
2003 		abort();
2004 		/* NOTREACHED */
2005 	}
2006 	/* NOTREACHED */
2007 }
2008 
2009 struct block *
2010 gen_scode(name, q)
2011 	register const char *name;
2012 	struct qual q;
2013 {
2014 	int proto = q.proto;
2015 	int dir = q.dir;
2016 	int tproto;
2017 	u_char *eaddr;
2018 	bpf_u_int32 mask, addr;
2019 #ifndef INET6
2020 	bpf_u_int32 **alist;
2021 #else
2022 	int tproto6;
2023 	struct sockaddr_in *sin;
2024 	struct sockaddr_in6 *sin6;
2025 	struct addrinfo *res, *res0;
2026 	struct in6_addr mask128;
2027 #endif /*INET6*/
2028 	struct block *b, *tmp;
2029 	int port, real_proto;
2030 
2031 	switch (q.addr) {
2032 
2033 	case Q_NET:
2034 		addr = pcap_nametonetaddr(name);
2035 		if (addr == 0)
2036 			bpf_error("unknown network '%s'", name);
2037 		/* Left justify network addr and calculate its network mask */
2038 		mask = 0xffffffff;
2039 		while (addr && (addr & 0xff000000) == 0) {
2040 			addr <<= 8;
2041 			mask <<= 8;
2042 		}
2043 		return gen_host(addr, mask, proto, dir);
2044 
2045 	case Q_DEFAULT:
2046 	case Q_HOST:
2047 		if (proto == Q_LINK) {
2048 			switch (linktype) {
2049 
2050 			case DLT_EN10MB:
2051 				eaddr = pcap_ether_hostton(name);
2052 				if (eaddr == NULL)
2053 					bpf_error(
2054 					    "unknown ether host '%s'", name);
2055 				return gen_ehostop(eaddr, dir);
2056 
2057 			case DLT_FDDI:
2058 				eaddr = pcap_ether_hostton(name);
2059 				if (eaddr == NULL)
2060 					bpf_error(
2061 					    "unknown FDDI host '%s'", name);
2062 				return gen_fhostop(eaddr, dir);
2063 
2064 			default:
2065 				bpf_error(
2066 			"only ethernet/FDDI supports link-level host name");
2067 				break;
2068 			}
2069 		} else if (proto == Q_DECNET) {
2070 			unsigned short dn_addr = __pcap_nametodnaddr(name);
2071 			/*
2072 			 * I don't think DECNET hosts can be multihomed, so
2073 			 * there is no need to build up a list of addresses
2074 			 */
2075 			return (gen_host(dn_addr, 0, proto, dir));
2076 		} else {
2077 #ifndef INET6
2078 			alist = pcap_nametoaddr(name);
2079 			if (alist == NULL || *alist == NULL)
2080 				bpf_error("unknown host '%s'", name);
2081 			tproto = proto;
2082 			if (off_linktype == -1 && tproto == Q_DEFAULT)
2083 				tproto = Q_IP;
2084 			b = gen_host(**alist++, 0xffffffff, tproto, dir);
2085 			while (*alist) {
2086 				tmp = gen_host(**alist++, 0xffffffff,
2087 					       tproto, dir);
2088 				gen_or(b, tmp);
2089 				b = tmp;
2090 			}
2091 			return b;
2092 #else
2093 			memset(&mask128, 0xff, sizeof(mask128));
2094 			res0 = res = pcap_nametoaddrinfo(name);
2095 			if (res == NULL)
2096 				bpf_error("unknown host '%s'", name);
2097 			b = tmp = NULL;
2098 			tproto = tproto6 = proto;
2099 			if (off_linktype == -1 && tproto == Q_DEFAULT) {
2100 				tproto = Q_IP;
2101 				tproto6 = Q_IPV6;
2102 			}
2103 			for (res = res0; res; res = res->ai_next) {
2104 				switch (res->ai_family) {
2105 				case AF_INET:
2106 					if (tproto == Q_IPV6)
2107 						continue;
2108 
2109 					sin = (struct sockaddr_in *)
2110 						res->ai_addr;
2111 					tmp = gen_host(ntohl(sin->sin_addr.s_addr),
2112 						0xffffffff, tproto, dir);
2113 					break;
2114 				case AF_INET6:
2115 					if (tproto6 == Q_IP)
2116 						continue;
2117 
2118 					sin6 = (struct sockaddr_in6 *)
2119 						res->ai_addr;
2120 					tmp = gen_host6(&sin6->sin6_addr,
2121 						&mask128, tproto6, dir);
2122 					break;
2123 				}
2124 				if (b)
2125 					gen_or(b, tmp);
2126 				b = tmp;
2127 			}
2128 			freeaddrinfo(res0);
2129 			if (b == NULL) {
2130 				bpf_error("unknown host '%s'%s", name,
2131 				    (proto == Q_DEFAULT)
2132 					? ""
2133 					: " for specified address family");
2134 			}
2135 			return b;
2136 #endif /*INET6*/
2137 		}
2138 
2139 	case Q_PORT:
2140 		if (proto != Q_DEFAULT && proto != Q_UDP && proto != Q_TCP)
2141 			bpf_error("illegal qualifier of 'port'");
2142 		if (pcap_nametoport(name, &port, &real_proto) == 0)
2143 			bpf_error("unknown port '%s'", name);
2144 		if (proto == Q_UDP) {
2145 			if (real_proto == IPPROTO_TCP)
2146 				bpf_error("port '%s' is tcp", name);
2147 			else
2148 				/* override PROTO_UNDEF */
2149 				real_proto = IPPROTO_UDP;
2150 		}
2151 		if (proto == Q_TCP) {
2152 			if (real_proto == IPPROTO_UDP)
2153 				bpf_error("port '%s' is udp", name);
2154 			else
2155 				/* override PROTO_UNDEF */
2156 				real_proto = IPPROTO_TCP;
2157 		}
2158 #ifndef INET6
2159 		return gen_port(port, real_proto, dir);
2160 #else
2161 	    {
2162 		struct block *b;
2163 		b = gen_port(port, real_proto, dir);
2164 		gen_or(gen_port6(port, real_proto, dir), b);
2165 		return b;
2166 	    }
2167 #endif /* INET6 */
2168 
2169 	case Q_GATEWAY:
2170 #ifndef INET6
2171 		eaddr = pcap_ether_hostton(name);
2172 		if (eaddr == NULL)
2173 			bpf_error("unknown ether host: %s", name);
2174 
2175 		alist = pcap_nametoaddr(name);
2176 		if (alist == NULL || *alist == NULL)
2177 			bpf_error("unknown host '%s'", name);
2178 		return gen_gateway(eaddr, alist, proto, dir);
2179 #else
2180 		bpf_error("'gateway' not supported in this configuration");
2181 #endif /*INET6*/
2182 
2183 	case Q_PROTO:
2184 		real_proto = lookup_proto(name, proto);
2185 		if (real_proto >= 0)
2186 			return gen_proto(real_proto, proto, dir);
2187 		else
2188 			bpf_error("unknown protocol: %s", name);
2189 
2190 	case Q_PROTOCHAIN:
2191 		real_proto = lookup_proto(name, proto);
2192 		if (real_proto >= 0)
2193 			return gen_protochain(real_proto, proto, dir);
2194 		else
2195 			bpf_error("unknown protocol: %s", name);
2196 
2197 
2198 	case Q_UNDEF:
2199 		syntax();
2200 		/* NOTREACHED */
2201 	}
2202 	abort();
2203 	/* NOTREACHED */
2204 }
2205 
2206 struct block *
2207 gen_mcode(s1, s2, masklen, q)
2208 	register const char *s1, *s2;
2209 	register int masklen;
2210 	struct qual q;
2211 {
2212 	register int nlen, mlen;
2213 	bpf_u_int32 n, m;
2214 
2215 	nlen = __pcap_atoin(s1, &n);
2216 	/* Promote short ipaddr */
2217 	n <<= 32 - nlen;
2218 
2219 	if (s2 != NULL) {
2220 		mlen = __pcap_atoin(s2, &m);
2221 		/* Promote short ipaddr */
2222 		m <<= 32 - mlen;
2223 		if ((n & ~m) != 0)
2224 			bpf_error("non-network bits set in \"%s mask %s\"",
2225 			    s1, s2);
2226 	} else {
2227 		/* Convert mask len to mask */
2228 		if (masklen > 32)
2229 			bpf_error("mask length must be <= 32");
2230 		m = 0xffffffff << (32 - masklen);
2231 		if ((n & ~m) != 0)
2232 			bpf_error("non-network bits set in \"%s/%d\"",
2233 			    s1, masklen);
2234 	}
2235 
2236 	switch (q.addr) {
2237 
2238 	case Q_NET:
2239 		return gen_host(n, m, q.proto, q.dir);
2240 
2241 	default:
2242 		bpf_error("Mask syntax for networks only");
2243 		/* NOTREACHED */
2244 	}
2245 }
2246 
2247 struct block *
2248 gen_ncode(s, v, q)
2249 	register const char *s;
2250 	bpf_u_int32 v;
2251 	struct qual q;
2252 {
2253 	bpf_u_int32 mask;
2254 	int proto = q.proto;
2255 	int dir = q.dir;
2256 	register int vlen;
2257 
2258 	if (s == NULL)
2259 		vlen = 32;
2260 	else if (q.proto == Q_DECNET)
2261 		vlen = __pcap_atodn(s, &v);
2262 	else
2263 		vlen = __pcap_atoin(s, &v);
2264 
2265 	switch (q.addr) {
2266 
2267 	case Q_DEFAULT:
2268 	case Q_HOST:
2269 	case Q_NET:
2270 		if (proto == Q_DECNET)
2271 			return gen_host(v, 0, proto, dir);
2272 		else if (proto == Q_LINK) {
2273 			bpf_error("illegal link layer address");
2274 		} else {
2275 			mask = 0xffffffff;
2276 			if (s == NULL && q.addr == Q_NET) {
2277 				/* Promote short net number */
2278 				while (v && (v & 0xff000000) == 0) {
2279 					v <<= 8;
2280 					mask <<= 8;
2281 				}
2282 			} else {
2283 				/* Promote short ipaddr */
2284 				v <<= 32 - vlen;
2285 				mask <<= 32 - vlen;
2286 			}
2287 			return gen_host(v, mask, proto, dir);
2288 		}
2289 
2290 	case Q_PORT:
2291 		if (proto == Q_UDP)
2292 			proto = IPPROTO_UDP;
2293 		else if (proto == Q_TCP)
2294 			proto = IPPROTO_TCP;
2295 		else if (proto == Q_DEFAULT)
2296 			proto = PROTO_UNDEF;
2297 		else
2298 			bpf_error("illegal qualifier of 'port'");
2299 
2300 #ifndef INET6
2301 		return gen_port((int)v, proto, dir);
2302 #else
2303 	    {
2304 		struct block *b;
2305 		b = gen_port((int)v, proto, dir);
2306 		gen_or(gen_port6((int)v, proto, dir), b);
2307 		return b;
2308 	    }
2309 #endif /* INET6 */
2310 
2311 	case Q_GATEWAY:
2312 		bpf_error("'gateway' requires a name");
2313 		/* NOTREACHED */
2314 
2315 	case Q_PROTO:
2316 		return gen_proto((int)v, proto, dir);
2317 
2318 	case Q_PROTOCHAIN:
2319 		return gen_protochain((int)v, proto, dir);
2320 
2321 	case Q_UNDEF:
2322 		syntax();
2323 		/* NOTREACHED */
2324 
2325 	default:
2326 		abort();
2327 		/* NOTREACHED */
2328 	}
2329 	/* NOTREACHED */
2330 }
2331 
2332 #ifdef INET6
2333 struct block *
2334 gen_mcode6(s1, s2, masklen, q)
2335 	register const char *s1, *s2;
2336 	register int masklen;
2337 	struct qual q;
2338 {
2339 	struct addrinfo *res;
2340 	struct in6_addr *addr;
2341 	struct in6_addr mask;
2342 	struct block *b;
2343 	u_int32_t *a, *m;
2344 
2345 	if (s2)
2346 		bpf_error("no mask %s supported", s2);
2347 
2348 	res = pcap_nametoaddrinfo(s1);
2349 	if (!res)
2350 		bpf_error("invalid ip6 address %s", s1);
2351 	if (res->ai_next)
2352 		bpf_error("%s resolved to multiple address", s1);
2353 	addr = &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr;
2354 
2355 	if (sizeof(mask) * 8 < masklen)
2356 		bpf_error("mask length must be <= %u", (unsigned int)(sizeof(mask) * 8));
2357 	memset(&mask, 0xff, masklen / 8);
2358 	if (masklen % 8) {
2359 		mask.s6_addr[masklen / 8] =
2360 			(0xff << (8 - masklen % 8)) & 0xff;
2361 	}
2362 
2363 	a = (u_int32_t *)addr;
2364 	m = (u_int32_t *)&mask;
2365 	if ((a[0] & ~m[0]) || (a[1] & ~m[1])
2366 	 || (a[2] & ~m[2]) || (a[3] & ~m[3])) {
2367 		bpf_error("non-network bits set in \"%s/%d\"", s1, masklen);
2368 	}
2369 
2370 	switch (q.addr) {
2371 
2372 	case Q_DEFAULT:
2373 	case Q_HOST:
2374 		if (masklen != 128)
2375 			bpf_error("Mask syntax for networks only");
2376 		/* FALLTHROUGH */
2377 
2378 	case Q_NET:
2379 		b = gen_host6(addr, &mask, q.proto, q.dir);
2380 		freeaddrinfo(res);
2381 		return b;
2382 
2383 	default:
2384 		bpf_error("invalid qualifier against IPv6 address");
2385 		/* NOTREACHED */
2386 	}
2387 }
2388 #endif /*INET6*/
2389 
2390 struct block *
2391 gen_ecode(eaddr, q)
2392 	register const u_char *eaddr;
2393 	struct qual q;
2394 {
2395 	if ((q.addr == Q_HOST || q.addr == Q_DEFAULT) && q.proto == Q_LINK) {
2396 		if (linktype == DLT_EN10MB)
2397 			return gen_ehostop(eaddr, (int)q.dir);
2398 		if (linktype == DLT_FDDI)
2399 			return gen_fhostop(eaddr, (int)q.dir);
2400 	}
2401 	bpf_error("ethernet address used in non-ether expression");
2402 	/* NOTREACHED */
2403 }
2404 
2405 void
2406 sappend(s0, s1)
2407 	struct slist *s0, *s1;
2408 {
2409 	/*
2410 	 * This is definitely not the best way to do this, but the
2411 	 * lists will rarely get long.
2412 	 */
2413 	while (s0->next)
2414 		s0 = s0->next;
2415 	s0->next = s1;
2416 }
2417 
2418 static struct slist *
2419 xfer_to_x(a)
2420 	struct arth *a;
2421 {
2422 	struct slist *s;
2423 
2424 	s = new_stmt(BPF_LDX|BPF_MEM);
2425 	s->s.k = a->regno;
2426 	return s;
2427 }
2428 
2429 static struct slist *
2430 xfer_to_a(a)
2431 	struct arth *a;
2432 {
2433 	struct slist *s;
2434 
2435 	s = new_stmt(BPF_LD|BPF_MEM);
2436 	s->s.k = a->regno;
2437 	return s;
2438 }
2439 
2440 struct arth *
2441 gen_load(proto, index, size)
2442 	int proto;
2443 	struct arth *index;
2444 	int size;
2445 {
2446 	struct slist *s, *tmp;
2447 	struct block *b;
2448 	int regno = alloc_reg();
2449 
2450 	free_reg(index->regno);
2451 	switch (size) {
2452 
2453 	default:
2454 		bpf_error("data size must be 1, 2, or 4");
2455 
2456 	case 1:
2457 		size = BPF_B;
2458 		break;
2459 
2460 	case 2:
2461 		size = BPF_H;
2462 		break;
2463 
2464 	case 4:
2465 		size = BPF_W;
2466 		break;
2467 	}
2468 	switch (proto) {
2469 	default:
2470 		bpf_error("unsupported index operation");
2471 
2472 	case Q_LINK:
2473 		s = xfer_to_x(index);
2474 		tmp = new_stmt(BPF_LD|BPF_IND|size);
2475 		sappend(s, tmp);
2476 		sappend(index->s, s);
2477 		break;
2478 
2479 	case Q_IP:
2480 	case Q_ARP:
2481 	case Q_RARP:
2482 	case Q_ATALK:
2483 	case Q_DECNET:
2484 	case Q_SCA:
2485 	case Q_LAT:
2486 	case Q_MOPRC:
2487 	case Q_MOPDL:
2488 #ifdef INET6
2489 	case Q_IPV6:
2490 #endif
2491 		/* XXX Note that we assume a fixed link header here. */
2492 		s = xfer_to_x(index);
2493 		tmp = new_stmt(BPF_LD|BPF_IND|size);
2494 		tmp->s.k = off_nl;
2495 		sappend(s, tmp);
2496 		sappend(index->s, s);
2497 
2498 		b = gen_proto_abbrev(proto);
2499 		if (index->b)
2500 			gen_and(index->b, b);
2501 		index->b = b;
2502 		break;
2503 
2504 	case Q_TCP:
2505 	case Q_UDP:
2506 	case Q_ICMP:
2507 	case Q_IGMP:
2508 	case Q_IGRP:
2509 	case Q_PIM:
2510 		s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
2511 		s->s.k = off_nl;
2512 		sappend(s, xfer_to_a(index));
2513 		sappend(s, new_stmt(BPF_ALU|BPF_ADD|BPF_X));
2514 		sappend(s, new_stmt(BPF_MISC|BPF_TAX));
2515 		sappend(s, tmp = new_stmt(BPF_LD|BPF_IND|size));
2516 		tmp->s.k = off_nl;
2517 		sappend(index->s, s);
2518 
2519 		gen_and(gen_proto_abbrev(proto), b = gen_ipfrag());
2520 		if (index->b)
2521 			gen_and(index->b, b);
2522 #ifdef INET6
2523 		gen_and(gen_proto_abbrev(Q_IP), b);
2524 #endif
2525 		index->b = b;
2526 		break;
2527 #ifdef INET6
2528 	case Q_ICMPV6:
2529 		bpf_error("IPv6 upper-layer protocol is not supported by proto[x]");
2530 		/*NOTREACHED*/
2531 #endif
2532 	}
2533 	index->regno = regno;
2534 	s = new_stmt(BPF_ST);
2535 	s->s.k = regno;
2536 	sappend(index->s, s);
2537 
2538 	return index;
2539 }
2540 
2541 struct block *
2542 gen_relation(code, a0, a1, reversed)
2543 	int code;
2544 	struct arth *a0, *a1;
2545 	int reversed;
2546 {
2547 	struct slist *s0, *s1, *s2;
2548 	struct block *b, *tmp;
2549 
2550 	s0 = xfer_to_x(a1);
2551 	s1 = xfer_to_a(a0);
2552 	s2 = new_stmt(BPF_ALU|BPF_SUB|BPF_X);
2553 	b = new_block(JMP(code));
2554 	if (code == BPF_JGT || code == BPF_JGE) {
2555 		reversed = !reversed;
2556 		b->s.k = 0x80000000;
2557 	}
2558 	if (reversed)
2559 		gen_not(b);
2560 
2561 	sappend(s1, s2);
2562 	sappend(s0, s1);
2563 	sappend(a1->s, s0);
2564 	sappend(a0->s, a1->s);
2565 
2566 	b->stmts = a0->s;
2567 
2568 	free_reg(a0->regno);
2569 	free_reg(a1->regno);
2570 
2571 	/* 'and' together protocol checks */
2572 	if (a0->b) {
2573 		if (a1->b) {
2574 			gen_and(a0->b, tmp = a1->b);
2575 		}
2576 		else
2577 			tmp = a0->b;
2578 	} else
2579 		tmp = a1->b;
2580 
2581 	if (tmp)
2582 		gen_and(tmp, b);
2583 
2584 	return b;
2585 }
2586 
2587 struct arth *
2588 gen_loadlen()
2589 {
2590 	int regno = alloc_reg();
2591 	struct arth *a = (struct arth *)newchunk(sizeof(*a));
2592 	struct slist *s;
2593 
2594 	s = new_stmt(BPF_LD|BPF_LEN);
2595 	s->next = new_stmt(BPF_ST);
2596 	s->next->s.k = regno;
2597 	a->s = s;
2598 	a->regno = regno;
2599 
2600 	return a;
2601 }
2602 
2603 struct arth *
2604 gen_loadi(val)
2605 	int val;
2606 {
2607 	struct arth *a;
2608 	struct slist *s;
2609 	int reg;
2610 
2611 	a = (struct arth *)newchunk(sizeof(*a));
2612 
2613 	reg = alloc_reg();
2614 
2615 	s = new_stmt(BPF_LD|BPF_IMM);
2616 	s->s.k = val;
2617 	s->next = new_stmt(BPF_ST);
2618 	s->next->s.k = reg;
2619 	a->s = s;
2620 	a->regno = reg;
2621 
2622 	return a;
2623 }
2624 
2625 struct arth *
2626 gen_neg(a)
2627 	struct arth *a;
2628 {
2629 	struct slist *s;
2630 
2631 	s = xfer_to_a(a);
2632 	sappend(a->s, s);
2633 	s = new_stmt(BPF_ALU|BPF_NEG);
2634 	s->s.k = 0;
2635 	sappend(a->s, s);
2636 	s = new_stmt(BPF_ST);
2637 	s->s.k = a->regno;
2638 	sappend(a->s, s);
2639 
2640 	return a;
2641 }
2642 
2643 struct arth *
2644 gen_arth(code, a0, a1)
2645 	int code;
2646 	struct arth *a0, *a1;
2647 {
2648 	struct slist *s0, *s1, *s2;
2649 
2650 	s0 = xfer_to_x(a1);
2651 	s1 = xfer_to_a(a0);
2652 	s2 = new_stmt(BPF_ALU|BPF_X|code);
2653 
2654 	sappend(s1, s2);
2655 	sappend(s0, s1);
2656 	sappend(a1->s, s0);
2657 	sappend(a0->s, a1->s);
2658 
2659 	free_reg(a1->regno);
2660 
2661 	s0 = new_stmt(BPF_ST);
2662 	a0->regno = s0->s.k = alloc_reg();
2663 	sappend(a0->s, s0);
2664 
2665 	return a0;
2666 }
2667 
2668 /*
2669  * Here we handle simple allocation of the scratch registers.
2670  * If too many registers are alloc'd, the allocator punts.
2671  */
2672 static int regused[BPF_MEMWORDS];
2673 static int curreg;
2674 
2675 /*
2676  * Return the next free register.
2677  */
2678 static int
2679 alloc_reg()
2680 {
2681 	int n = BPF_MEMWORDS;
2682 
2683 	while (--n >= 0) {
2684 		if (regused[curreg])
2685 			curreg = (curreg + 1) % BPF_MEMWORDS;
2686 		else {
2687 			regused[curreg] = 1;
2688 			return curreg;
2689 		}
2690 	}
2691 	bpf_error("too many registers needed to evaluate expression");
2692 	/* NOTREACHED */
2693 }
2694 
2695 /*
2696  * Return a register to the table so it can
2697  * be used later.
2698  */
2699 static void
2700 free_reg(n)
2701 	int n;
2702 {
2703 	regused[n] = 0;
2704 }
2705 
2706 static struct block *
2707 gen_len(jmp, n)
2708 	int jmp, n;
2709 {
2710 	struct slist *s;
2711 	struct block *b;
2712 
2713 	s = new_stmt(BPF_LD|BPF_LEN);
2714 	b = new_block(JMP(jmp));
2715 	b->stmts = s;
2716 	b->s.k = n;
2717 
2718 	return b;
2719 }
2720 
2721 struct block *
2722 gen_greater(n)
2723 	int n;
2724 {
2725 	return gen_len(BPF_JGE, n);
2726 }
2727 
2728 struct block *
2729 gen_less(n)
2730 	int n;
2731 {
2732 	struct block *b;
2733 
2734 	b = gen_len(BPF_JGT, n);
2735 	gen_not(b);
2736 
2737 	return b;
2738 }
2739 
2740 struct block *
2741 gen_byteop(op, idx, val)
2742 	int op, idx, val;
2743 {
2744 	struct block *b;
2745 	struct slist *s;
2746 
2747 	switch (op) {
2748 	default:
2749 		abort();
2750 
2751 	case '=':
2752 		return gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
2753 
2754 	case '<':
2755 		b = gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
2756 		b->s.code = JMP(BPF_JGE);
2757 		gen_not(b);
2758 		return b;
2759 
2760 	case '>':
2761 		b = gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
2762 		b->s.code = JMP(BPF_JGT);
2763 		return b;
2764 
2765 	case '|':
2766 		s = new_stmt(BPF_ALU|BPF_OR|BPF_K);
2767 		break;
2768 
2769 	case '&':
2770 		s = new_stmt(BPF_ALU|BPF_AND|BPF_K);
2771 		break;
2772 	}
2773 	s->s.k = val;
2774 	b = new_block(JMP(BPF_JEQ));
2775 	b->stmts = s;
2776 	gen_not(b);
2777 
2778 	return b;
2779 }
2780 
2781 static u_char abroadcast[] = { 0x0 };
2782 
2783 struct block *
2784 gen_broadcast(proto)
2785 	int proto;
2786 {
2787 	bpf_u_int32 hostmask;
2788 	struct block *b0, *b1, *b2;
2789 	static u_char ebroadcast[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
2790 
2791 	switch (proto) {
2792 
2793 	case Q_DEFAULT:
2794 	case Q_LINK:
2795 		if (linktype == DLT_ARCNET)
2796 			return gen_ahostop(abroadcast, Q_DST);
2797 		if (linktype == DLT_EN10MB)
2798 			return gen_ehostop(ebroadcast, Q_DST);
2799 		if (linktype == DLT_FDDI)
2800 			return gen_fhostop(ebroadcast, Q_DST);
2801 		bpf_error("not a broadcast link");
2802 		break;
2803 
2804 	case Q_IP:
2805 		b0 = gen_linktype(ETHERTYPE_IP);
2806 		hostmask = ~netmask;
2807 		b1 = gen_mcmp(off_nl + 16, BPF_W, (bpf_int32)0, hostmask);
2808 		b2 = gen_mcmp(off_nl + 16, BPF_W,
2809 			      (bpf_int32)(~0 & hostmask), hostmask);
2810 		gen_or(b1, b2);
2811 		gen_and(b0, b2);
2812 		return b2;
2813 	}
2814 	bpf_error("only ether/ip broadcast filters supported");
2815 }
2816 
2817 struct block *
2818 gen_multicast(proto)
2819 	int proto;
2820 {
2821 	register struct block *b0, *b1;
2822 	register struct slist *s;
2823 
2824 	switch (proto) {
2825 
2826 	case Q_DEFAULT:
2827 	case Q_LINK:
2828 		if (linktype == DLT_ARCNET)
2829 			/* all ARCnet multicasts use the same address */
2830 			return gen_ahostop(abroadcast, Q_DST);
2831 
2832 		if (linktype == DLT_EN10MB) {
2833 			/* ether[0] & 1 != 0 */
2834 			s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
2835 			s->s.k = 0;
2836 			b0 = new_block(JMP(BPF_JSET));
2837 			b0->s.k = 1;
2838 			b0->stmts = s;
2839 			return b0;
2840 		}
2841 
2842 		if (linktype == DLT_FDDI) {
2843 			/* XXX TEST THIS: MIGHT NOT PORT PROPERLY XXX */
2844 			/* fddi[1] & 1 != 0 */
2845 			s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
2846 			s->s.k = 1;
2847 			b0 = new_block(JMP(BPF_JSET));
2848 			b0->s.k = 1;
2849 			b0->stmts = s;
2850 			return b0;
2851 		}
2852 		/* Link not known to support multicasts */
2853 		break;
2854 
2855 	case Q_IP:
2856 		b0 = gen_linktype(ETHERTYPE_IP);
2857 		b1 = gen_cmp(off_nl + 16, BPF_B, (bpf_int32)224);
2858 		b1->s.code = JMP(BPF_JGE);
2859 		gen_and(b0, b1);
2860 		return b1;
2861 
2862 #ifdef INET6
2863 	case Q_IPV6:
2864 		b0 = gen_linktype(ETHERTYPE_IPV6);
2865 		b1 = gen_cmp(off_nl + 24, BPF_B, (bpf_int32)255);
2866 		gen_and(b0, b1);
2867 		return b1;
2868 #endif /* INET6 */
2869 	}
2870 	bpf_error("only IP multicast filters supported on ethernet/FDDI");
2871 }
2872 
2873 /*
2874  * generate command for inbound/outbound.  It's here so we can
2875  * make it link-type specific.  'dir' = 0 implies "inbound",
2876  * = 1 implies "outbound".
2877  */
2878 struct block *
2879 gen_inbound(dir)
2880 	int dir;
2881 {
2882 	register struct block *b0;
2883 
2884 	/*
2885 	 * Only SLIP and old-style PPP data link types support
2886 	 * inbound/outbound qualifiers.
2887 	 */
2888 	switch (linktype) {
2889 	case DLT_SLIP:
2890 	case DLT_PPP:
2891 		b0 = gen_relation(BPF_JEQ,
2892 				  gen_load(Q_LINK, gen_loadi(0), 1),
2893 				  gen_loadi(0),
2894 				  dir);
2895 		break;
2896 
2897 	case DLT_PFLOG:
2898 		b0 = gen_cmp(offsetof(struct pfloghdr, dir), BPF_H,
2899 		    (bpf_int32)((dir == 0) ? PF_IN : PF_OUT));
2900 		break;
2901 
2902 	default:
2903 		bpf_error("inbound/outbound not supported on linktype 0x%x\n",
2904 		    linktype);
2905 		/* NOTREACHED */
2906 	}
2907 
2908 	return (b0);
2909 }
2910 
2911 
2912 /* PF firewall log matched interface */
2913 struct block *
2914 gen_pf_ifname(char *ifname)
2915 {
2916 	struct block *b0;
2917 
2918 	if (linktype != DLT_PFLOG) {
2919 		bpf_error("ifname not supported on linktype 0x%x\n", linktype);
2920 		/* NOTREACHED */
2921 	}
2922 	if (strlen(ifname) >= sizeof(((struct pfloghdr *)0)->ifname)) {
2923 		bpf_error("ifname interface names can only be %d characters\n",
2924 		    sizeof(((struct pfloghdr *)0)->ifname) - 1);
2925 
2926 		/* NOTREACHED */
2927 	}
2928 	b0 = gen_bcmp(offsetof(struct pfloghdr, ifname), strlen(ifname),
2929 	    ifname);
2930 	return (b0);
2931 }
2932 
2933 
2934 /* PF firewall log rule number */
2935 struct block *
2936 gen_pf_rnr(int rnr)
2937 {
2938 	struct block *b0;
2939 
2940 	if (linktype != DLT_PFLOG) {
2941 		bpf_error("rnr not supported on linktype 0x%x\n", linktype);
2942 		/* NOTREACHED */
2943 	}
2944 
2945 	b0 = gen_cmp(offsetof(struct pfloghdr, rnr), BPF_H, (bpf_int32)rnr);
2946 	return (b0);
2947 }
2948 
2949 /* PF firewall log reason code */
2950 struct block *
2951 gen_pf_reason(int reason)
2952 {
2953 	struct block *b0;
2954 
2955 	if (linktype != DLT_PFLOG) {
2956 		bpf_error("reason not supported on linktype 0x%x\n", linktype);
2957 		/* NOTREACHED */
2958 	}
2959 
2960 	b0 = gen_cmp(offsetof(struct pfloghdr, reason), BPF_H,
2961 	    (bpf_int32)reason);
2962 	return (b0);
2963 }
2964 
2965 /* PF firewall log action */
2966 struct block *
2967 gen_pf_action(int action)
2968 {
2969 	struct block *b0;
2970 
2971 	if (linktype != DLT_PFLOG) {
2972 		bpf_error("action not supported on linktype 0x%x\n", linktype);
2973 		/* NOTREACHED */
2974 	}
2975 
2976 	b0 = gen_cmp(offsetof(struct pfloghdr, action), BPF_H,
2977 	    (bpf_int32)action);
2978 	return (b0);
2979 }
2980 
2981 struct block *
2982 gen_acode(eaddr, q)
2983 	register const u_char *eaddr;
2984 	struct qual q;
2985 {
2986 	if ((q.addr == Q_HOST || q.addr == Q_DEFAULT) && q.proto == Q_LINK) {
2987 		if (linktype == DLT_ARCNET)
2988 			return gen_ahostop(eaddr, (int)q.dir);
2989 	}
2990 	bpf_error("ARCnet address used in non-arc expression");
2991 	/* NOTREACHED */
2992 }
2993 
2994 static struct block *
2995 gen_ahostop(eaddr, dir)
2996 	register const u_char *eaddr;
2997 	register int dir;
2998 {
2999 	register struct block *b0, *b1;
3000 
3001 	switch (dir) {
3002 	/* src comes first, different from Ethernet */
3003 	case Q_SRC:
3004 		return gen_bcmp(0, 1, eaddr);
3005 
3006 	case Q_DST:
3007 		return gen_bcmp(1, 1, eaddr);
3008 
3009 	case Q_AND:
3010 		b0 = gen_ahostop(eaddr, Q_SRC);
3011 		b1 = gen_ahostop(eaddr, Q_DST);
3012 		gen_and(b0, b1);
3013 		return b1;
3014 
3015 	case Q_DEFAULT:
3016 	case Q_OR:
3017 		b0 = gen_ahostop(eaddr, Q_SRC);
3018 		b1 = gen_ahostop(eaddr, Q_DST);
3019 		gen_or(b0, b1);
3020 		return b1;
3021 	}
3022 	abort();
3023 	/* NOTREACHED */
3024 }
3025