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