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