projects / openwrt.git / blob
? search:


f3fc5a60fe8282e4e21af2162f7e561d018023e3
[openwrt.git] / target / linux / etrax-2.6 / image / e100boot / src / libpcap-0.4 / gencode.c
1 /*
2 * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
3 * The Regents of the University of California. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that: (1) source code distributions
7 * retain the above copyright notice and this paragraph in its entirety, (2)
8 * distributions including binary code include the above copyright notice and
9 * this paragraph in its entirety in the documentation or other materials
10 * provided with the distribution, and (3) all advertising materials mentioning
11 * features or use of this software display the following acknowledgement:
12 * ``This product includes software developed by the University of California,
13 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
14 * the University nor the names of its contributors may be used to endorse
15 * or promote products derived from this software without specific prior
16 * written permission.
17 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
18 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
20 */
21 #ifndef lint
22 static const char rcsid[] =
23 "@(#) $Header: /usr/local/cvs/linux/tools/build/e100boot/libpcap-0.4/gencode.c,v 1.1 1999/08/26 10:05:22 johana Exp $ (LBL)";
24 #endif
25
26 #include <sys/types.h>
27 #include <sys/socket.h>
28 #include <sys/time.h>
29
30 #if __STDC__
31 struct mbuf;
32 struct rtentry;
33 #endif
34
35 #include <net/if.h>
36
37 #include <netinet/in.h>
38 #include <netinet/if_ether.h>
39
40 #include <stdlib.h>
41 #include <memory.h>
42 #include <setjmp.h>
43 #if __STDC__
44 #include <stdarg.h>
45 #else
46 #include <varargs.h>
47 #endif
48
49 #include "pcap-int.h"
50
51 #include "ethertype.h"
52 #include "gencode.h"
53 #include "ppp.h"
54 #include <pcap-namedb.h>
55
56 #include "gnuc.h"
57 #ifdef HAVE_OS_PROTO_H
58 #include "os-proto.h"
59 #endif
60
61 #define JMP(c) ((c)|BPF_JMP|BPF_K)
62
63 /* Locals */
64 static jmp_buf top_ctx;
65 static pcap_t *bpf_pcap;
66
67 /* XXX */
68 #ifdef PCAP_FDDIPAD
69 int pcap_fddipad = PCAP_FDDIPAD;
70 #else
71 int pcap_fddipad;
72 #endif
73
74 /* VARARGS */
75 __dead void
76 #if __STDC__
77 bpf_error(const char *fmt, ...)
78 #else
79 bpf_error(fmt, va_alist)
80 const char *fmt;
81 va_dcl
82 #endif
83 {
84 va_list ap;
85
86 #if __STDC__
87 va_start(ap, fmt);
88 #else
89 va_start(ap);
90 #endif
91 if (bpf_pcap != NULL)
92 (void)vsprintf(pcap_geterr(bpf_pcap), fmt, ap);
93 va_end(ap);
94 longjmp(top_ctx, 1);
95 /* NOTREACHED */
96 }
97
98 static void init_linktype(int);
99
100 static int alloc_reg(void);
101 static void free_reg(int);
102
103 static struct block *root;
104
105 /*
106 * We divy out chunks of memory rather than call malloc each time so
107 * we don't have to worry about leaking memory. It's probably
108 * not a big deal if all this memory was wasted but it this ever
109 * goes into a library that would probably not be a good idea.
110 */
111 #define NCHUNKS 16
112 #define CHUNK0SIZE 1024
113 struct chunk {
114 u_int n_left;
115 void *m;
116 };
117
118 static struct chunk chunks[NCHUNKS];
119 static int cur_chunk;
120
121 static void *newchunk(u_int);
122 static void freechunks(void);
123 static inline struct block *new_block(int);
124 static inline struct slist *new_stmt(int);
125 static struct block *gen_retblk(int);
126 static inline void syntax(void);
127
128 static void backpatch(struct block *, struct block *);
129 static void merge(struct block *, struct block *);
130 static struct block *gen_cmp(u_int, u_int, bpf_int32);
131 static struct block *gen_mcmp(u_int, u_int, bpf_int32, bpf_u_int32);
132 static struct block *gen_bcmp(u_int, u_int, const u_char *);
133 static struct block *gen_uncond(int);
134 static inline struct block *gen_true(void);
135 static inline struct block *gen_false(void);
136 static struct block *gen_linktype(int);
137 static struct block *gen_hostop(bpf_u_int32, bpf_u_int32, int, int, u_int, u_int);
138 static struct block *gen_ehostop(const u_char *, int);
139 static struct block *gen_fhostop(const u_char *, int);
140 static struct block *gen_dnhostop(bpf_u_int32, int, u_int);
141 static struct block *gen_host(bpf_u_int32, bpf_u_int32, int, int);
142 static struct block *gen_gateway(const u_char *, bpf_u_int32 **, int, int);
143 static struct block *gen_ipfrag(void);
144 static struct block *gen_portatom(int, bpf_int32);
145 struct block *gen_portop(int, int, int);
146 static struct block *gen_port(int, int, int);
147 static int lookup_proto(const char *, int);
148 static struct block *gen_proto(int, int, int);
149 static struct slist *xfer_to_x(struct arth *);
150 static struct slist *xfer_to_a(struct arth *);
151 static struct block *gen_len(int, int);
152
153 static void *
154 newchunk(n)
155 u_int n;
156 {
157 struct chunk *cp;
158 int k, size;
159
160 /* XXX Round up to nearest long. */
161 n = (n + sizeof(long) - 1) & ~(sizeof(long) - 1);
162
163 cp = &chunks[cur_chunk];
164 if (n > cp->n_left) {
165 ++cp, k = ++cur_chunk;
166 if (k >= NCHUNKS)
167 bpf_error("out of memory");
168 size = CHUNK0SIZE << k;
169 cp->m = (void *)malloc(size);
170 memset((char *)cp->m, 0, size);
171 cp->n_left = size;
172 if (n > size)
173 bpf_error("out of memory");
174 }
175 cp->n_left -= n;
176 return (void *)((char *)cp->m + cp->n_left);
177 }
178
179 static void
180 freechunks()
181 {
182 int i;
183
184 cur_chunk = 0;
185 for (i = 0; i < NCHUNKS; ++i)
186 if (chunks[i].m != NULL) {
187 free(chunks[i].m);
188 chunks[i].m = NULL;
189 }
190 }
191
192 /*
193 * A strdup whose allocations are freed after code generation is over.
194 */
195 char *
196 sdup(s)
197 register const char *s;
198 {
199 int n = strlen(s) + 1;
200 char *cp = newchunk(n);
201
202 strcpy(cp, s);
203 return (cp);
204 }
205
206 static inline struct block *
207 new_block(code)
208 int code;
209 {
210 struct block *p;
211
212 p = (struct block *)newchunk(sizeof(*p));
213 p->s.code = code;
214 p->head = p;
215
216 return p;
217 }
218
219 static inline struct slist *
220 new_stmt(code)
221 int code;
222 {
223 struct slist *p;
224
225 p = (struct slist *)newchunk(sizeof(*p));
226 p->s.code = code;
227
228 return p;
229 }
230
231 static struct block *
232 gen_retblk(v)
233 int v;
234 {
235 struct block *b = new_block(BPF_RET|BPF_K);
236
237 b->s.k = v;
238 return b;
239 }
240
241 static inline void
242 syntax()
243 {
244 bpf_error("syntax error in filter expression");
245 }
246
247 static bpf_u_int32 netmask;
248 static int snaplen;
249
250 int
251 pcap_compile(pcap_t *p, struct bpf_program *program,
252 char *buf, int optimize, bpf_u_int32 mask)
253 {
254 extern int n_errors;
255 int len;
256
257 n_errors = 0;
258 root = NULL;
259 bpf_pcap = p;
260 if (setjmp(top_ctx)) {
261 freechunks();
262 return (-1);
263 }
264
265 netmask = mask;
266 snaplen = pcap_snapshot(p);
267
268 lex_init(buf ? buf : "");
269 init_linktype(pcap_datalink(p));
270 (void)pcap_parse();
271
272 if (n_errors)
273 syntax();
274
275 if (root == NULL)
276 root = gen_retblk(snaplen);
277
278 if (optimize) {
279 bpf_optimize(&root);
280 if (root == NULL ||
281 (root->s.code == (BPF_RET|BPF_K) && root->s.k == 0))
282 bpf_error("expression rejects all packets");
283 }
284 program->bf_insns = icode_to_fcode(root, &len);
285 program->bf_len = len;
286
287 freechunks();
288 return (0);
289 }
290
291 /*
292 * Backpatch the blocks in 'list' to 'target'. The 'sense' field indicates
293 * which of the jt and jf fields has been resolved and which is a pointer
294 * back to another unresolved block (or nil). At least one of the fields
295 * in each block is already resolved.
296 */
297 static void
298 backpatch(list, target)
299 struct block *list, *target;
300 {
301 struct block *next;
302
303 while (list) {
304 if (!list->sense) {
305 next = JT(list);
306 JT(list) = target;
307 } else {
308 next = JF(list);
309 JF(list) = target;
310 }
311 list = next;
312 }
313 }
314
315 /*
316 * Merge the lists in b0 and b1, using the 'sense' field to indicate
317 * which of jt and jf is the link.
318 */
319 static void
320 merge(b0, b1)
321 struct block *b0, *b1;
322 {
323 register struct block **p = &b0;
324
325 /* Find end of list. */
326 while (*p)
327 p = !((*p)->sense) ? &JT(*p) : &JF(*p);
328
329 /* Concatenate the lists. */
330 *p = b1;
331 }
332
333 void
334 finish_parse(p)
335 struct block *p;
336 {
337 backpatch(p, gen_retblk(snaplen));
338 p->sense = !p->sense;
339 backpatch(p, gen_retblk(0));
340 root = p->head;
341 }
342
343 void
344 gen_and(b0, b1)
345 struct block *b0, *b1;
346 {
347 backpatch(b0, b1->head);
348 b0->sense = !b0->sense;
349 b1->sense = !b1->sense;
350 merge(b1, b0);
351 b1->sense = !b1->sense;
352 b1->head = b0->head;
353 }
354
355 void
356 gen_or(b0, b1)
357 struct block *b0, *b1;
358 {
359 b0->sense = !b0->sense;
360 backpatch(b0, b1->head);
361 b0->sense = !b0->sense;
362 merge(b1, b0);
363 b1->head = b0->head;
364 }
365
366 void
367 gen_not(b)
368 struct block *b;
369 {
370 b->sense = !b->sense;
371 }
372
373 static struct block *
374 gen_cmp(offset, size, v)
375 u_int offset, size;
376 bpf_int32 v;
377 {
378 struct slist *s;
379 struct block *b;
380
381 s = new_stmt(BPF_LD|BPF_ABS|size);
382 s->s.k = offset;
383
384 b = new_block(JMP(BPF_JEQ));
385 b->stmts = s;
386 b->s.k = v;
387
388 return b;
389 }
390
391 static struct block *
392 gen_mcmp(offset, size, v, mask)
393 u_int offset, size;
394 bpf_int32 v;
395 bpf_u_int32 mask;
396 {
397 struct block *b = gen_cmp(offset, size, v);
398 struct slist *s;
399
400 if (mask != 0xffffffff) {
401 s = new_stmt(BPF_ALU|BPF_AND|BPF_K);
402 s->s.k = mask;
403 b->stmts->next = s;
404 }
405 return b;
406 }
407
408 static struct block *
409 gen_bcmp(offset, size, v)
410 register u_int offset, size;
411 register const u_char *v;
412 {
413 register struct block *b, *tmp;
414
415 b = NULL;
416 while (size >= 4) {
417 register const u_char *p = &v[size - 4];
418 bpf_int32 w = ((bpf_int32)p[0] << 24) |
419 ((bpf_int32)p[1] << 16) | ((bpf_int32)p[2] << 8) | p[3];
420
421 tmp = gen_cmp(offset + size - 4, BPF_W, w);
422 if (b != NULL)
423 gen_and(b, tmp);
424 b = tmp;
425 size -= 4;
426 }
427 while (size >= 2) {
428 register const u_char *p = &v[size - 2];
429 bpf_int32 w = ((bpf_int32)p[0] << 8) | p[1];
430
431 tmp = gen_cmp(offset + size - 2, BPF_H, w);
432 if (b != NULL)
433 gen_and(b, tmp);
434 b = tmp;
435 size -= 2;
436 }
437 if (size > 0) {
438 tmp = gen_cmp(offset, BPF_B, (bpf_int32)v[0]);
439 if (b != NULL)
440 gen_and(b, tmp);
441 b = tmp;
442 }
443 return b;
444 }
445
446 /*
447 * Various code constructs need to know the layout of the data link
448 * layer. These variables give the necessary offsets. off_linktype
449 * is set to -1 for no encapsulation, in which case, IP is assumed.
450 */
451 static u_int off_linktype;
452 static u_int off_nl;
453 static int linktype;
454
455 static void
456 init_linktype(type)
457 int type;
458 {
459 linktype = type;
460
461 switch (type) {
462
463 case DLT_EN10MB:
464 off_linktype = 12;
465 off_nl = 14;
466 return;
467
468 case DLT_SLIP:
469 /*
470 * SLIP doesn't have a link level type. The 16 byte
471 * header is hacked into our SLIP driver.
472 */
473 off_linktype = -1;
474 off_nl = 16;
475 return;
476
477 case DLT_SLIP_BSDOS:
478 /* XXX this may be the same as the DLT_PPP_BSDOS case */
479 off_linktype = -1;
480 /* XXX end */
481 off_nl = 24;
482 return;
483
484 case DLT_NULL:
485 off_linktype = 0;
486 off_nl = 4;
487 return;
488
489 case DLT_PPP:
490 off_linktype = 2;
491 off_nl = 4;
492 return;
493
494 case DLT_PPP_BSDOS:
495 off_linktype = 5;
496 off_nl = 24;
497 return;
498
499 case DLT_FDDI:
500 /*
501 * FDDI doesn't really have a link-level type field.
502 * We assume that SSAP = SNAP is being used and pick
503 * out the encapsulated Ethernet type.
504 */
505 off_linktype = 19;
506 #ifdef PCAP_FDDIPAD
507 off_linktype += pcap_fddipad;
508 #endif
509 off_nl = 21;
510 #ifdef PCAP_FDDIPAD
511 off_nl += pcap_fddipad;
512 #endif
513 return;
514
515 case DLT_IEEE802:
516 off_linktype = 20;
517 off_nl = 22;
518 return;
519
520 case DLT_ATM_RFC1483:
521 /*
522 * assume routed, non-ISO PDUs
523 * (i.e., LLC = 0xAA-AA-03, OUT = 0x00-00-00)
524 */
525 off_linktype = 6;
526 off_nl = 8;
527 return;
528
529 case DLT_RAW:
530 off_linktype = -1;
531 off_nl = 0;
532 return;
533 }
534 bpf_error("unknown data link type 0x%x", linktype);
535 /* NOTREACHED */
536 }
537
538 static struct block *
539 gen_uncond(rsense)
540 int rsense;
541 {
542 struct block *b;
543 struct slist *s;
544
545 s = new_stmt(BPF_LD|BPF_IMM);
546 s->s.k = !rsense;
547 b = new_block(JMP(BPF_JEQ));
548 b->stmts = s;
549
550 return b;
551 }
552
553 static inline struct block *
554 gen_true()
555 {
556 return gen_uncond(1);
557 }
558
559 static inline struct block *
560 gen_false()
561 {
562 return gen_uncond(0);
563 }
564
565 static struct block *
566 gen_linktype(proto)
567 register int proto;
568 {
569 struct block *b0, *b1;
570
571 /* If we're not using encapsulation and checking for IP, we're done */
572 if (off_linktype == -1 && proto == ETHERTYPE_IP)
573 return gen_true();
574
575 switch (linktype) {
576
577 case DLT_SLIP:
578 return gen_false();
579
580 case DLT_PPP:
581 if (proto == ETHERTYPE_IP)
582 proto = PPP_IP; /* XXX was 0x21 */
583 break;
584
585 case DLT_PPP_BSDOS:
586 switch (proto) {
587
588 case ETHERTYPE_IP:
589 b0 = gen_cmp(off_linktype, BPF_H, PPP_IP);
590 b1 = gen_cmp(off_linktype, BPF_H, PPP_VJC);
591 gen_or(b0, b1);
592 b0 = gen_cmp(off_linktype, BPF_H, PPP_VJNC);
593 gen_or(b1, b0);
594 return b0;
595
596 case ETHERTYPE_DN:
597 proto = PPP_DECNET;
598 break;
599
600 case ETHERTYPE_ATALK:
601 proto = PPP_APPLE;
602 break;
603
604 case ETHERTYPE_NS:
605 proto = PPP_NS;
606 break;
607 }
608 break;
609
610 case DLT_NULL:
611 /* XXX */
612 if (proto == ETHERTYPE_IP)
613 return (gen_cmp(0, BPF_W, (bpf_int32)htonl(AF_INET)));
614 else
615 return gen_false();
616 }
617 return gen_cmp(off_linktype, BPF_H, (bpf_int32)proto);
618 }
619
620 static struct block *
621 gen_hostop(addr, mask, dir, proto, src_off, dst_off)
622 bpf_u_int32 addr;
623 bpf_u_int32 mask;
624 int dir, proto;
625 u_int src_off, dst_off;
626 {
627 struct block *b0, *b1;
628 u_int offset;
629
630 switch (dir) {
631
632 case Q_SRC:
633 offset = src_off;
634 break;
635
636 case Q_DST:
637 offset = dst_off;
638 break;
639
640 case Q_AND:
641 b0 = gen_hostop(addr, mask, Q_SRC, proto, src_off, dst_off);
642 b1 = gen_hostop(addr, mask, Q_DST, proto, src_off, dst_off);
643 gen_and(b0, b1);
644 return b1;
645
646 case Q_OR:
647 case Q_DEFAULT:
648 b0 = gen_hostop(addr, mask, Q_SRC, proto, src_off, dst_off);
649 b1 = gen_hostop(addr, mask, Q_DST, proto, src_off, dst_off);
650 gen_or(b0, b1);
651 return b1;
652
653 default:
654 abort();
655 }
656 b0 = gen_linktype(proto);
657 b1 = gen_mcmp(offset, BPF_W, (bpf_int32)addr, mask);
658 gen_and(b0, b1);
659 return b1;
660 }
661
662 static struct block *
663 gen_ehostop(eaddr, dir)
664 register const u_char *eaddr;
665 register int dir;
666 {
667 register struct block *b0, *b1;
668
669 switch (dir) {
670 case Q_SRC:
671 return gen_bcmp(6, 6, eaddr);
672
673 case Q_DST:
674 return gen_bcmp(0, 6, eaddr);
675
676 case Q_AND:
677 b0 = gen_ehostop(eaddr, Q_SRC);
678 b1 = gen_ehostop(eaddr, Q_DST);
679 gen_and(b0, b1);
680 return b1;
681
682 case Q_DEFAULT:
683 case Q_OR:
684 b0 = gen_ehostop(eaddr, Q_SRC);
685 b1 = gen_ehostop(eaddr, Q_DST);
686 gen_or(b0, b1);
687 return b1;
688 }
689 abort();
690 /* NOTREACHED */
691 }
692
693 /*
694 * Like gen_ehostop, but for DLT_FDDI
695 */
696 static struct block *
697 gen_fhostop(eaddr, dir)
698 register const u_char *eaddr;
699 register int dir;
700 {
701 struct block *b0, *b1;
702
703 switch (dir) {
704 case Q_SRC:
705 #ifdef PCAP_FDDIPAD
706 return gen_bcmp(6 + 1 + pcap_fddipad, 6, eaddr);
707 #else
708 return gen_bcmp(6 + 1, 6, eaddr);
709 #endif
710
711 case Q_DST:
712 #ifdef PCAP_FDDIPAD
713 return gen_bcmp(0 + 1 + pcap_fddipad, 6, eaddr);
714 #else
715 return gen_bcmp(0 + 1, 6, eaddr);
716 #endif
717
718 case Q_AND:
719 b0 = gen_fhostop(eaddr, Q_SRC);
720 b1 = gen_fhostop(eaddr, Q_DST);
721 gen_and(b0, b1);
722 return b1;
723
724 case Q_DEFAULT:
725 case Q_OR:
726 b0 = gen_fhostop(eaddr, Q_SRC);
727 b1 = gen_fhostop(eaddr, Q_DST);
728 gen_or(b0, b1);
729 return b1;
730 }
731 abort();
732 /* NOTREACHED */
733 }
734
735 /*
736 * This is quite tricky because there may be pad bytes in front of the
737 * DECNET header, and then there are two possible data packet formats that
738 * carry both src and dst addresses, plus 5 packet types in a format that
739 * carries only the src node, plus 2 types that use a different format and
740 * also carry just the src node.
741 *
742 * Yuck.
743 *
744 * Instead of doing those all right, we just look for data packets with
745 * 0 or 1 bytes of padding. If you want to look at other packets, that
746 * will require a lot more hacking.
747 *
748 * To add support for filtering on DECNET "areas" (network numbers)
749 * one would want to add a "mask" argument to this routine. That would
750 * make the filter even more inefficient, although one could be clever
751 * and not generate masking instructions if the mask is 0xFFFF.
752 */
753 static struct block *
754 gen_dnhostop(addr, dir, base_off)
755 bpf_u_int32 addr;
756 int dir;
757 u_int base_off;
758 {
759 struct block *b0, *b1, *b2, *tmp;
760 u_int offset_lh; /* offset if long header is received */
761 u_int offset_sh; /* offset if short header is received */
762
763 switch (dir) {
764
765 case Q_DST:
766 offset_sh = 1; /* follows flags */
767 offset_lh = 7; /* flgs,darea,dsubarea,HIORD */
768 break;
769
770 case Q_SRC:
771 offset_sh = 3; /* follows flags, dstnode */
772 offset_lh = 15; /* flgs,darea,dsubarea,did,sarea,ssub,HIORD */
773 break;
774
775 case Q_AND:
776 /* Inefficient because we do our Calvinball dance twice */
777 b0 = gen_dnhostop(addr, Q_SRC, base_off);
778 b1 = gen_dnhostop(addr, Q_DST, base_off);
779 gen_and(b0, b1);
780 return b1;
781
782 case Q_OR:
783 case Q_DEFAULT:
784 /* Inefficient because we do our Calvinball dance twice */
785 b0 = gen_dnhostop(addr, Q_SRC, base_off);
786 b1 = gen_dnhostop(addr, Q_DST, base_off);
787 gen_or(b0, b1);
788 return b1;
789
790 default:
791 abort();
792 }
793 b0 = gen_linktype(ETHERTYPE_DN);
794 /* Check for pad = 1, long header case */
795 tmp = gen_mcmp(base_off + 2, BPF_H,
796 (bpf_int32)ntohs(0x0681), (bpf_int32)ntohs(0x07FF));
797 b1 = gen_cmp(base_off + 2 + 1 + offset_lh,
798 BPF_H, (bpf_int32)ntohs(addr));
799 gen_and(tmp, b1);
800 /* Check for pad = 0, long header case */
801 tmp = gen_mcmp(base_off + 2, BPF_B, (bpf_int32)0x06, (bpf_int32)0x7);
802 b2 = gen_cmp(base_off + 2 + offset_lh, BPF_H, (bpf_int32)ntohs(addr));
803 gen_and(tmp, b2);
804 gen_or(b2, b1);
805 /* Check for pad = 1, short header case */
806 tmp = gen_mcmp(base_off + 2, BPF_H,
807 (bpf_int32)ntohs(0x0281), (bpf_int32)ntohs(0x07FF));
808 b2 = gen_cmp(base_off + 2 + 1 + offset_sh,
809 BPF_H, (bpf_int32)ntohs(addr));
810 gen_and(tmp, b2);
811 gen_or(b2, b1);
812 /* Check for pad = 0, short header case */
813 tmp = gen_mcmp(base_off + 2, BPF_B, (bpf_int32)0x02, (bpf_int32)0x7);
814 b2 = gen_cmp(base_off + 2 + offset_sh, BPF_H, (bpf_int32)ntohs(addr));
815 gen_and(tmp, b2);
816 gen_or(b2, b1);
817
818 /* Combine with test for linktype */
819 gen_and(b0, b1);
820 return b1;
821 }
822
823 static struct block *
824 gen_host(addr, mask, proto, dir)
825 bpf_u_int32 addr;
826 bpf_u_int32 mask;
827 int proto;
828 int dir;
829 {
830 struct block *b0, *b1;
831
832 switch (proto) {
833
834 case Q_DEFAULT:
835 b0 = gen_host(addr, mask, Q_IP, dir);
836 b1 = gen_host(addr, mask, Q_ARP, dir);
837 gen_or(b0, b1);
838 b0 = gen_host(addr, mask, Q_RARP, dir);
839 gen_or(b1, b0);
840 return b0;
841
842 case Q_IP:
843 return gen_hostop(addr, mask, dir, ETHERTYPE_IP,
844 off_nl + 12, off_nl + 16);
845
846 case Q_RARP:
847 return gen_hostop(addr, mask, dir, ETHERTYPE_REVARP,
848 off_nl + 14, off_nl + 24);
849
850 case Q_ARP:
851 return gen_hostop(addr, mask, dir, ETHERTYPE_ARP,
852 off_nl + 14, off_nl + 24);
853
854 case Q_TCP:
855 bpf_error("'tcp' modifier applied to host");
856
857 case Q_UDP:
858 bpf_error("'udp' modifier applied to host");
859
860 case Q_ICMP:
861 bpf_error("'icmp' modifier applied to host");
862
863 case Q_IGMP:
864 bpf_error("'igmp' modifier applied to host");
865
866 case Q_IGRP:
867 bpf_error("'igrp' modifier applied to host");
868
869 case Q_ATALK:
870 bpf_error("ATALK host filtering not implemented");
871
872 case Q_DECNET:
873 return gen_dnhostop(addr, dir, off_nl);
874
875 case Q_SCA:
876 bpf_error("SCA host filtering not implemented");
877
878 case Q_LAT:
879 bpf_error("LAT host filtering not implemented");
880
881 case Q_MOPDL:
882 bpf_error("MOPDL host filtering not implemented");
883
884 case Q_MOPRC:
885 bpf_error("MOPRC host filtering not implemented");
886
887 default:
888 abort();
889 }
890 /* NOTREACHED */
891 }
892
893 static struct block *
894 gen_gateway(eaddr, alist, proto, dir)
895 const u_char *eaddr;
896 bpf_u_int32 **alist;
897 int proto;
898 int dir;
899 {
900 struct block *b0, *b1, *tmp;
901
902 if (dir != 0)
903 bpf_error("direction applied to 'gateway'");
904
905 switch (proto) {
906 case Q_DEFAULT:
907 case Q_IP:
908 case Q_ARP:
909 case Q_RARP:
910 if (linktype == DLT_EN10MB)
911 b0 = gen_ehostop(eaddr, Q_OR);
912 else if (linktype == DLT_FDDI)
913 b0 = gen_fhostop(eaddr, Q_OR);
914 else
915 bpf_error(
916 "'gateway' supported only on ethernet or FDDI");
917
918 b1 = gen_host(**alist++, 0xffffffff, proto, Q_OR);
919 while (*alist) {
920 tmp = gen_host(**alist++, 0xffffffff, proto, Q_OR);
921 gen_or(b1, tmp);
922 b1 = tmp;
923 }
924 gen_not(b1);
925 gen_and(b0, b1);
926 return b1;
927 }
928 bpf_error("illegal modifier of 'gateway'");
929 /* NOTREACHED */
930 }
931
932 struct block *
933 gen_proto_abbrev(proto)
934 int proto;
935 {
936 struct block *b0, *b1;
937
938 switch (proto) {
939
940 case Q_TCP:
941 b0 = gen_linktype(ETHERTYPE_IP);
942 b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)IPPROTO_TCP);
943 gen_and(b0, b1);
944 break;
945
946 case Q_UDP:
947 b0 = gen_linktype(ETHERTYPE_IP);
948 b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)IPPROTO_UDP);
949 gen_and(b0, b1);
950 break;
951
952 case Q_ICMP:
953 b0 = gen_linktype(ETHERTYPE_IP);
954 b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)IPPROTO_ICMP);
955 gen_and(b0, b1);
956 break;
957
958 case Q_IGMP:
959 b0 = gen_linktype(ETHERTYPE_IP);
960 b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)2);
961 gen_and(b0, b1);
962 break;
963
964 #ifndef IPPROTO_IGRP
965 #define IPPROTO_IGRP 9
966 #endif
967 case Q_IGRP:
968 b0 = gen_linktype(ETHERTYPE_IP);
969 b1 = gen_cmp(off_nl + 9, BPF_B, (long)IPPROTO_IGRP);
970 gen_and(b0, b1);
971 break;
972
973 case Q_IP:
974 b1 = gen_linktype(ETHERTYPE_IP);
975 break;
976
977 case Q_ARP:
978 b1 = gen_linktype(ETHERTYPE_ARP);
979 break;
980
981 case Q_RARP:
982 b1 = gen_linktype(ETHERTYPE_REVARP);
983 break;
984
985 case Q_LINK:
986 bpf_error("link layer applied in wrong context");
987
988 case Q_ATALK:
989 b1 = gen_linktype(ETHERTYPE_ATALK);
990 break;
991
992 case Q_DECNET:
993 b1 = gen_linktype(ETHERTYPE_DN);
994 break;
995
996 case Q_SCA:
997 b1 = gen_linktype(ETHERTYPE_SCA);
998 break;
999
1000 case Q_LAT:
1001 b1 = gen_linktype(ETHERTYPE_LAT);
1002 break;
1003
1004 case Q_MOPDL:
1005 b1 = gen_linktype(ETHERTYPE_MOPDL);
1006 break;
1007
1008 case Q_MOPRC:
1009 b1 = gen_linktype(ETHERTYPE_MOPRC);
1010 break;
1011
1012 default:
1013 abort();
1014 }
1015 return b1;
1016 }
1017
1018 static struct block *
1019 gen_ipfrag()
1020 {
1021 struct slist *s;
1022 struct block *b;
1023
1024 /* not ip frag */
1025 s = new_stmt(BPF_LD|BPF_H|BPF_ABS);
1026 s->s.k = off_nl + 6;
1027 b = new_block(JMP(BPF_JSET));
1028 b->s.k = 0x1fff;
1029 b->stmts = s;
1030 gen_not(b);
1031
1032 return b;
1033 }
1034
1035 static struct block *
1036 gen_portatom(off, v)
1037 int off;
1038 bpf_int32 v;
1039 {
1040 struct slist *s;
1041 struct block *b;
1042
1043 s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
1044 s->s.k = off_nl;
1045
1046 s->next = new_stmt(BPF_LD|BPF_IND|BPF_H);
1047 s->next->s.k = off_nl + off;
1048
1049 b = new_block(JMP(BPF_JEQ));
1050 b->stmts = s;
1051 b->s.k = v;
1052
1053 return b;
1054 }
1055
1056 struct block *
1057 gen_portop(port, proto, dir)
1058 int port, proto, dir;
1059 {
1060 struct block *b0, *b1, *tmp;
1061
1062 /* ip proto 'proto' */
1063 tmp = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)proto);
1064 b0 = gen_ipfrag();
1065 gen_and(tmp, b0);
1066
1067 switch (dir) {
1068 case Q_SRC:
1069 b1 = gen_portatom(0, (bpf_int32)port);
1070 break;
1071
1072 case Q_DST:
1073 b1 = gen_portatom(2, (bpf_int32)port);
1074 break;
1075
1076 case Q_OR:
1077 case Q_DEFAULT:
1078 tmp = gen_portatom(0, (bpf_int32)port);
1079 b1 = gen_portatom(2, (bpf_int32)port);
1080 gen_or(tmp, b1);
1081 break;
1082
1083 case Q_AND:
1084 tmp = gen_portatom(0, (bpf_int32)port);
1085 b1 = gen_portatom(2, (bpf_int32)port);
1086 gen_and(tmp, b1);
1087 break;
1088
1089 default:
1090 abort();
1091 }
1092 gen_and(b0, b1);
1093
1094 return b1;
1095 }
1096
1097 static struct block *
1098 gen_port(port, ip_proto, dir)
1099 int port;
1100 int ip_proto;
1101 int dir;
1102 {
1103 struct block *b0, *b1, *tmp;
1104
1105 /* ether proto ip */
1106 b0 = gen_linktype(ETHERTYPE_IP);
1107
1108 switch (ip_proto) {
1109 case IPPROTO_UDP:
1110 case IPPROTO_TCP:
1111 b1 = gen_portop(port, ip_proto, dir);
1112 break;
1113
1114 case PROTO_UNDEF:
1115 tmp = gen_portop(port, IPPROTO_TCP, dir);
1116 b1 = gen_portop(port, IPPROTO_UDP, dir);
1117 gen_or(tmp, b1);
1118 break;
1119
1120 default:
1121 abort();
1122 }
1123 gen_and(b0, b1);
1124 return b1;
1125 }
1126
1127 static int
1128 lookup_proto(name, proto)
1129 register const char *name;
1130 register int proto;
1131 {
1132 register int v;
1133
1134 switch (proto) {
1135
1136 case Q_DEFAULT:
1137 case Q_IP:
1138 v = pcap_nametoproto(name);
1139 if (v == PROTO_UNDEF)
1140 bpf_error("unknown ip proto '%s'", name);
1141 break;
1142
1143 case Q_LINK:
1144 /* XXX should look up h/w protocol type based on linktype */
1145 v = pcap_nametoeproto(name);
1146 if (v == PROTO_UNDEF)
1147 bpf_error("unknown ether proto '%s'", name);
1148 break;
1149
1150 default:
1151 v = PROTO_UNDEF;
1152 break;
1153 }
1154 return v;
1155 }
1156
1157 static struct block *
1158 gen_proto(v, proto, dir)
1159 int v;
1160 int proto;
1161 int dir;
1162 {
1163 struct block *b0, *b1;
1164
1165 if (dir != Q_DEFAULT)
1166 bpf_error("direction applied to 'proto'");
1167
1168 switch (proto) {
1169 case Q_DEFAULT:
1170 case Q_IP:
1171 b0 = gen_linktype(ETHERTYPE_IP);
1172 b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)v);
1173 gen_and(b0, b1);
1174 return b1;
1175
1176 case Q_ARP:
1177 bpf_error("arp does not encapsulate another protocol");
1178 /* NOTREACHED */
1179
1180 case Q_RARP:
1181 bpf_error("rarp does not encapsulate another protocol");
1182 /* NOTREACHED */
1183
1184 case Q_ATALK:
1185 bpf_error("atalk encapsulation is not specifiable");
1186 /* NOTREACHED */
1187
1188 case Q_DECNET:
1189 bpf_error("decnet encapsulation is not specifiable");
1190 /* NOTREACHED */
1191
1192 case Q_SCA:
1193 bpf_error("sca does not encapsulate another protocol");
1194 /* NOTREACHED */
1195
1196 case Q_LAT:
1197 bpf_error("lat does not encapsulate another protocol");
1198 /* NOTREACHED */
1199
1200 case Q_MOPRC:
1201 bpf_error("moprc does not encapsulate another protocol");
1202 /* NOTREACHED */
1203
1204 case Q_MOPDL:
1205 bpf_error("mopdl does not encapsulate another protocol");
1206 /* NOTREACHED */
1207
1208 case Q_LINK:
1209 return gen_linktype(v);
1210
1211 case Q_UDP:
1212 bpf_error("'udp proto' is bogus");
1213 /* NOTREACHED */
1214
1215 case Q_TCP:
1216 bpf_error("'tcp proto' is bogus");
1217 /* NOTREACHED */
1218
1219 case Q_ICMP:
1220 bpf_error("'icmp proto' is bogus");
1221 /* NOTREACHED */
1222
1223 case Q_IGMP:
1224 bpf_error("'igmp proto' is bogus");
1225 /* NOTREACHED */
1226
1227 case Q_IGRP:
1228 bpf_error("'igrp proto' is bogus");
1229 /* NOTREACHED */
1230
1231 default:
1232 abort();
1233 /* NOTREACHED */
1234 }
1235 /* NOTREACHED */
1236 }
1237
1238 struct block *
1239 gen_scode(name, q)
1240 register const char *name;
1241 struct qual q;
1242 {
1243 int proto = q.proto;
1244 int dir = q.dir;
1245 int tproto;
1246 u_char *eaddr;
1247 bpf_u_int32 mask, addr, **alist;
1248 struct block *b, *tmp;
1249 int port, real_proto;
1250
1251 switch (q.addr) {
1252
1253 case Q_NET:
1254 addr = pcap_nametonetaddr(name);
1255 if (addr == 0)
1256 bpf_error("unknown network '%s'", name);
1257 /* Left justify network addr and calculate its network mask */
1258 mask = 0xffffffff;
1259 while (addr && (addr & 0xff000000) == 0) {
1260 addr <<= 8;
1261 mask <<= 8;
1262 }
1263 return gen_host(addr, mask, proto, dir);
1264
1265 case Q_DEFAULT:
1266 case Q_HOST:
1267 if (proto == Q_LINK) {
1268 switch (linktype) {
1269
1270 case DLT_EN10MB:
1271 eaddr = pcap_ether_hostton(name);
1272 if (eaddr == NULL)
1273 bpf_error(
1274 "unknown ether host '%s'", name);
1275 return gen_ehostop(eaddr, dir);
1276
1277 case DLT_FDDI:
1278 eaddr = pcap_ether_hostton(name);
1279 if (eaddr == NULL)
1280 bpf_error(
1281 "unknown FDDI host '%s'", name);
1282 return gen_fhostop(eaddr, dir);
1283
1284 default:
1285 bpf_error(
1286 "only ethernet/FDDI supports link-level host name");
1287 break;
1288 }
1289 } else if (proto == Q_DECNET) {
1290 unsigned short dn_addr = __pcap_nametodnaddr(name);
1291 /*
1292 * I don't think DECNET hosts can be multihomed, so
1293 * there is no need to build up a list of addresses
1294 */
1295 return (gen_host(dn_addr, 0, proto, dir));
1296 } else {
1297 alist = pcap_nametoaddr(name);
1298 if (alist == NULL || *alist == NULL)
1299 bpf_error("unknown host '%s'", name);
1300 tproto = proto;
1301 if (off_linktype == -1 && tproto == Q_DEFAULT)
1302 tproto = Q_IP;
1303 b = gen_host(**alist++, 0xffffffff, tproto, dir);
1304 while (*alist) {
1305 tmp = gen_host(**alist++, 0xffffffff,
1306 tproto, dir);
1307 gen_or(b, tmp);
1308 b = tmp;
1309 }
1310 return b;
1311 }
1312
1313 case Q_PORT:
1314 if (proto != Q_DEFAULT && proto != Q_UDP && proto != Q_TCP)
1315 bpf_error("illegal qualifier of 'port'");
1316 if (pcap_nametoport(name, &port, &real_proto) == 0)
1317 bpf_error("unknown port '%s'", name);
1318 if (proto == Q_UDP) {
1319 if (real_proto == IPPROTO_TCP)
1320 bpf_error("port '%s' is tcp", name);
1321 else
1322 /* override PROTO_UNDEF */
1323 real_proto = IPPROTO_UDP;
1324 }
1325 if (proto == Q_TCP) {
1326 if (real_proto == IPPROTO_UDP)
1327 bpf_error("port '%s' is udp", name);
1328 else
1329 /* override PROTO_UNDEF */
1330 real_proto = IPPROTO_TCP;
1331 }
1332 return gen_port(port, real_proto, dir);
1333
1334 case Q_GATEWAY:
1335 eaddr = pcap_ether_hostton(name);
1336 if (eaddr == NULL)
1337 bpf_error("unknown ether host: %s", name);
1338
1339 alist = pcap_nametoaddr(name);
1340 if (alist == NULL || *alist == NULL)
1341 bpf_error("unknown host '%s'", name);
1342 return gen_gateway(eaddr, alist, proto, dir);
1343
1344 case Q_PROTO:
1345 real_proto = lookup_proto(name, proto);
1346 if (real_proto >= 0)
1347 return gen_proto(real_proto, proto, dir);
1348 else
1349 bpf_error("unknown protocol: %s", name);
1350
1351 case Q_UNDEF:
1352 syntax();
1353 /* NOTREACHED */
1354 }
1355 abort();
1356 /* NOTREACHED */
1357 }
1358
1359 struct block *
1360 gen_mcode(s1, s2, masklen, q)
1361 register const char *s1, *s2;
1362 register int masklen;
1363 struct qual q;
1364 {
1365 register int nlen, mlen;
1366 bpf_u_int32 n, m;
1367
1368 nlen = __pcap_atoin(s1, &n);
1369 /* Promote short ipaddr */
1370 n <<= 32 - nlen;
1371
1372 if (s2 != NULL) {
1373 mlen = __pcap_atoin(s2, &m);
1374 /* Promote short ipaddr */
1375 m <<= 32 - mlen;
1376 if ((n & ~m) != 0)
1377 bpf_error("non-network bits set in \"%s mask %s\"",
1378 s1, s2);
1379 } else {
1380 /* Convert mask len to mask */
1381 if (masklen > 32)
1382 bpf_error("mask length must be <= 32");
1383 m = 0xffffffff << (32 - masklen);
1384 if ((n & ~m) != 0)
1385 bpf_error("non-network bits set in \"%s/%d\"",
1386 s1, masklen);
1387 }
1388
1389 switch (q.addr) {
1390
1391 case Q_NET:
1392 return gen_host(n, m, q.proto, q.dir);
1393
1394 default:
1395 bpf_error("Mask syntax for networks only");
1396 /* NOTREACHED */
1397 }
1398 }
1399
1400 struct block *
1401 gen_ncode(s, v, q)
1402 register const char *s;
1403 bpf_u_int32 v;
1404 struct qual q;
1405 {
1406 bpf_u_int32 mask;
1407 int proto = q.proto;
1408 int dir = q.dir;
1409 register int vlen;
1410
1411 if (s == NULL)
1412 vlen = 32;
1413 else if (q.proto == Q_DECNET)
1414 vlen = __pcap_atodn(s, &v);
1415 else
1416 vlen = __pcap_atoin(s, &v);
1417
1418 switch (q.addr) {
1419
1420 case Q_DEFAULT:
1421 case Q_HOST:
1422 case Q_NET:
1423 if (proto == Q_DECNET)
1424 return gen_host(v, 0, proto, dir);
1425 else if (proto == Q_LINK) {
1426 bpf_error("illegal link layer address");
1427 } else {
1428 mask = 0xffffffff;
1429 if (s == NULL && q.addr == Q_NET) {
1430 /* Promote short net number */
1431 while (v && (v & 0xff000000) == 0) {
1432 v <<= 8;
1433 mask <<= 8;
1434 }
1435 } else {
1436 /* Promote short ipaddr */
1437 v <<= 32 - vlen;
1438 mask <<= 32 - vlen;
1439 }
1440 return gen_host(v, mask, proto, dir);
1441 }
1442
1443 case Q_PORT:
1444 if (proto == Q_UDP)
1445 proto = IPPROTO_UDP;
1446 else if (proto == Q_TCP)
1447 proto = IPPROTO_TCP;
1448 else if (proto == Q_DEFAULT)
1449 proto = PROTO_UNDEF;
1450 else
1451 bpf_error("illegal qualifier of 'port'");
1452
1453 return gen_port((int)v, proto, dir);
1454
1455 case Q_GATEWAY:
1456 bpf_error("'gateway' requires a name");
1457 /* NOTREACHED */
1458
1459 case Q_PROTO:
1460 return gen_proto((int)v, proto, dir);
1461
1462 case Q_UNDEF:
1463 syntax();
1464 /* NOTREACHED */
1465
1466 default:
1467 abort();
1468 /* NOTREACHED */
1469 }
1470 /* NOTREACHED */
1471 }
1472
1473 struct block *
1474 gen_ecode(eaddr, q)
1475 register const u_char *eaddr;
1476 struct qual q;
1477 {
1478 if ((q.addr == Q_HOST || q.addr == Q_DEFAULT) && q.proto == Q_LINK) {
1479 if (linktype == DLT_EN10MB)
1480 return gen_ehostop(eaddr, (int)q.dir);
1481 if (linktype == DLT_FDDI)
1482 return gen_fhostop(eaddr, (int)q.dir);
1483 }
1484 bpf_error("ethernet address used in non-ether expression");
1485 /* NOTREACHED */
1486 }
1487
1488 void
1489 sappend(s0, s1)
1490 struct slist *s0, *s1;
1491 {
1492 /*
1493 * This is definitely not the best way to do this, but the
1494 * lists will rarely get long.
1495 */
1496 while (s0->next)
1497 s0 = s0->next;
1498 s0->next = s1;
1499 }
1500
1501 static struct slist *
1502 xfer_to_x(a)
1503 struct arth *a;
1504 {
1505 struct slist *s;
1506
1507 s = new_stmt(BPF_LDX|BPF_MEM);
1508 s->s.k = a->regno;
1509 return s;
1510 }
1511
1512 static struct slist *
1513 xfer_to_a(a)
1514 struct arth *a;
1515 {
1516 struct slist *s;
1517
1518 s = new_stmt(BPF_LD|BPF_MEM);
1519 s->s.k = a->regno;
1520 return s;
1521 }
1522
1523 struct arth *
1524 gen_load(proto, index, size)
1525 int proto;
1526 struct arth *index;
1527 int size;
1528 {
1529 struct slist *s, *tmp;
1530 struct block *b;
1531 int regno = alloc_reg();
1532
1533 free_reg(index->regno);
1534 switch (size) {
1535
1536 default:
1537 bpf_error("data size must be 1, 2, or 4");
1538
1539 case 1:
1540 size = BPF_B;
1541 break;
1542
1543 case 2:
1544 size = BPF_H;
1545 break;
1546
1547 case 4:
1548 size = BPF_W;
1549 break;
1550 }
1551 switch (proto) {
1552 default:
1553 bpf_error("unsupported index operation");
1554
1555 case Q_LINK:
1556 s = xfer_to_x(index);
1557 tmp = new_stmt(BPF_LD|BPF_IND|size);
1558 sappend(s, tmp);
1559 sappend(index->s, s);
1560 break;
1561
1562 case Q_IP:
1563 case Q_ARP:
1564 case Q_RARP:
1565 case Q_ATALK:
1566 case Q_DECNET:
1567 case Q_SCA:
1568 case Q_LAT:
1569 case Q_MOPRC:
1570 case Q_MOPDL:
1571 /* XXX Note that we assume a fixed link link header here. */
1572 s = xfer_to_x(index);
1573 tmp = new_stmt(BPF_LD|BPF_IND|size);
1574 tmp->s.k = off_nl;
1575 sappend(s, tmp);
1576 sappend(index->s, s);
1577
1578 b = gen_proto_abbrev(proto);
1579 if (index->b)
1580 gen_and(index->b, b);
1581 index->b = b;
1582 break;
1583
1584 case Q_TCP:
1585 case Q_UDP:
1586 case Q_ICMP:
1587 case Q_IGMP:
1588 case Q_IGRP:
1589 s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
1590 s->s.k = off_nl;
1591 sappend(s, xfer_to_a(index));
1592 sappend(s, new_stmt(BPF_ALU|BPF_ADD|BPF_X));
1593 sappend(s, new_stmt(BPF_MISC|BPF_TAX));
1594 sappend(s, tmp = new_stmt(BPF_LD|BPF_IND|size));
1595 tmp->s.k = off_nl;
1596 sappend(index->s, s);
1597
1598 gen_and(gen_proto_abbrev(proto), b = gen_ipfrag());
1599 if (index->b)
1600 gen_and(index->b, b);
1601 index->b = b;
1602 break;
1603 }
1604 index->regno = regno;
1605 s = new_stmt(BPF_ST);
1606 s->s.k = regno;
1607 sappend(index->s, s);
1608
1609 return index;
1610 }
1611
1612 struct block *
1613 gen_relation(code, a0, a1, reversed)
1614 int code;
1615 struct arth *a0, *a1;
1616 int reversed;
1617 {
1618 struct slist *s0, *s1, *s2;
1619 struct block *b, *tmp;
1620
1621 s0 = xfer_to_x(a1);
1622 s1 = xfer_to_a(a0);
1623 s2 = new_stmt(BPF_ALU|BPF_SUB|BPF_X);
1624 b = new_block(JMP(code));
1625 if (code == BPF_JGT || code == BPF_JGE) {
1626 reversed = !reversed;
1627 b->s.k = 0x80000000;
1628 }
1629 if (reversed)
1630 gen_not(b);
1631
1632 sappend(s1, s2);
1633 sappend(s0, s1);
1634 sappend(a1->s, s0);
1635 sappend(a0->s, a1->s);
1636
1637 b->stmts = a0->s;
1638
1639 free_reg(a0->regno);
1640 free_reg(a1->regno);
1641
1642 /* 'and' together protocol checks */
1643 if (a0->b) {
1644 if (a1->b) {
1645 gen_and(a0->b, tmp = a1->b);
1646 }
1647 else
1648 tmp = a0->b;
1649 } else
1650 tmp = a1->b;
1651
1652 if (tmp)
1653 gen_and(tmp, b);
1654
1655 return b;
1656 }
1657
1658 struct arth *
1659 gen_loadlen()
1660 {
1661 int regno = alloc_reg();
1662 struct arth *a = (struct arth *)newchunk(sizeof(*a));
1663 struct slist *s;
1664
1665 s = new_stmt(BPF_LD|BPF_LEN);
1666 s->next = new_stmt(BPF_ST);
1667 s->next->s.k = regno;
1668 a->s = s;
1669 a->regno = regno;
1670
1671 return a;
1672 }
1673
1674 struct arth *
1675 gen_loadi(val)
1676 int val;
1677 {
1678 struct arth *a;
1679 struct slist *s;
1680 int reg;
1681
1682 a = (struct arth *)newchunk(sizeof(*a));
1683
1684 reg = alloc_reg();
1685
1686 s = new_stmt(BPF_LD|BPF_IMM);
1687 s->s.k = val;
1688 s->next = new_stmt(BPF_ST);
1689 s->next->s.k = reg;
1690 a->s = s;
1691 a->regno = reg;
1692
1693 return a;
1694 }
1695
1696 struct arth *
1697 gen_neg(a)
1698 struct arth *a;
1699 {
1700 struct slist *s;
1701
1702 s = xfer_to_a(a);
1703 sappend(a->s, s);
1704 s = new_stmt(BPF_ALU|BPF_NEG);
1705 s->s.k = 0;
1706 sappend(a->s, s);
1707 s = new_stmt(BPF_ST);
1708 s->s.k = a->regno;
1709 sappend(a->s, s);
1710
1711 return a;
1712 }
1713
1714 struct arth *
1715 gen_arth(code, a0, a1)
1716 int code;
1717 struct arth *a0, *a1;
1718 {
1719 struct slist *s0, *s1, *s2;
1720
1721 s0 = xfer_to_x(a1);
1722 s1 = xfer_to_a(a0);
1723 s2 = new_stmt(BPF_ALU|BPF_X|code);
1724
1725 sappend(s1, s2);
1726 sappend(s0, s1);
1727 sappend(a1->s, s0);
1728 sappend(a0->s, a1->s);
1729
1730 free_reg(a1->regno);
1731
1732 s0 = new_stmt(BPF_ST);
1733 a0->regno = s0->s.k = alloc_reg();
1734 sappend(a0->s, s0);
1735
1736 return a0;
1737 }
1738
1739 /*
1740 * Here we handle simple allocation of the scratch registers.
1741 * If too many registers are alloc'd, the allocator punts.
1742 */
1743 static int regused[BPF_MEMWORDS];
1744 static int curreg;
1745
1746 /*
1747 * Return the next free register.
1748 */
1749 static int
1750 alloc_reg()
1751 {
1752 int n = BPF_MEMWORDS;
1753
1754 while (--n >= 0) {
1755 if (regused[curreg])
1756 curreg = (curreg + 1) % BPF_MEMWORDS;
1757 else {
1758 regused[curreg] = 1;
1759 return curreg;
1760 }
1761 }
1762 bpf_error("too many registers needed to evaluate expression");
1763 /* NOTREACHED */
1764 }
1765
1766 /*
1767 * Return a register to the table so it can
1768 * be used later.
1769 */
1770 static void
1771 free_reg(n)
1772 int n;
1773 {
1774 regused[n] = 0;
1775 }
1776
1777 static struct block *
1778 gen_len(jmp, n)
1779 int jmp, n;
1780 {
1781 struct slist *s;
1782 struct block *b;
1783
1784 s = new_stmt(BPF_LD|BPF_LEN);
1785 b = new_block(JMP(jmp));
1786 b->stmts = s;
1787 b->s.k = n;
1788
1789 return b;
1790 }
1791
1792 struct block *
1793 gen_greater(n)
1794 int n;
1795 {
1796 return gen_len(BPF_JGE, n);
1797 }
1798
1799 struct block *
1800 gen_less(n)
1801 int n;
1802 {
1803 struct block *b;
1804
1805 b = gen_len(BPF_JGT, n);
1806 gen_not(b);
1807
1808 return b;
1809 }
1810
1811 struct block *
1812 gen_byteop(op, idx, val)
1813 int op, idx, val;
1814 {
1815 struct block *b;
1816 struct slist *s;
1817
1818 switch (op) {
1819 default:
1820 abort();
1821
1822 case '=':
1823 return gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
1824
1825 case '<':
1826 b = gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
1827 b->s.code = JMP(BPF_JGE);
1828 gen_not(b);
1829 return b;
1830
1831 case '>':
1832 b = gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
1833 b->s.code = JMP(BPF_JGT);
1834 return b;
1835
1836 case '|':
1837 s = new_stmt(BPF_ALU|BPF_OR|BPF_K);
1838 break;
1839
1840 case '&':
1841 s = new_stmt(BPF_ALU|BPF_AND|BPF_K);
1842 break;
1843 }
1844 s->s.k = val;
1845 b = new_block(JMP(BPF_JEQ));
1846 b->stmts = s;
1847 gen_not(b);
1848
1849 return b;
1850 }
1851
1852 struct block *
1853 gen_broadcast(proto)
1854 int proto;
1855 {
1856 bpf_u_int32 hostmask;
1857 struct block *b0, *b1, *b2;
1858 static u_char ebroadcast[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1859
1860 switch (proto) {
1861
1862 case Q_DEFAULT:
1863 case Q_LINK:
1864 if (linktype == DLT_EN10MB)
1865 return gen_ehostop(ebroadcast, Q_DST);
1866 if (linktype == DLT_FDDI)
1867 return gen_fhostop(ebroadcast, Q_DST);
1868 bpf_error("not a broadcast link");
1869 break;
1870
1871 case Q_IP:
1872 b0 = gen_linktype(ETHERTYPE_IP);
1873 hostmask = ~netmask;
1874 b1 = gen_mcmp(off_nl + 16, BPF_W, (bpf_int32)0, hostmask);
1875 b2 = gen_mcmp(off_nl + 16, BPF_W,
1876 (bpf_int32)(~0 & hostmask), hostmask);
1877 gen_or(b1, b2);
1878 gen_and(b0, b2);
1879 return b2;
1880 }
1881 bpf_error("only ether/ip broadcast filters supported");
1882 }
1883
1884 struct block *
1885 gen_multicast(proto)
1886 int proto;
1887 {
1888 register struct block *b0, *b1;
1889 register struct slist *s;
1890
1891 switch (proto) {
1892
1893 case Q_DEFAULT:
1894 case Q_LINK:
1895 if (linktype == DLT_EN10MB) {
1896 /* ether[0] & 1 != 0 */
1897 s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
1898 s->s.k = 0;
1899 b0 = new_block(JMP(BPF_JSET));
1900 b0->s.k = 1;
1901 b0->stmts = s;
1902 return b0;
1903 }
1904
1905 if (linktype == DLT_FDDI) {
1906 /* XXX TEST THIS: MIGHT NOT PORT PROPERLY XXX */
1907 /* fddi[1] & 1 != 0 */
1908 s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
1909 s->s.k = 1;
1910 b0 = new_block(JMP(BPF_JSET));
1911 b0->s.k = 1;
1912 b0->stmts = s;
1913 return b0;
1914 }
1915 /* Link not known to support multicasts */
1916 break;
1917
1918 case Q_IP:
1919 b0 = gen_linktype(ETHERTYPE_IP);
1920 b1 = gen_cmp(off_nl + 16, BPF_B, (bpf_int32)224);
1921 b1->s.code = JMP(BPF_JGE);
1922 gen_and(b0, b1);
1923 return b1;
1924 }
1925 bpf_error("only IP multicast filters supported on ethernet/FDDI");
1926 }
1927
1928 /*
1929 * generate command for inbound/outbound. It's here so we can
1930 * make it link-type specific. 'dir' = 0 implies "inbound",
1931 * = 1 implies "outbound".
1932 */
1933 struct block *
1934 gen_inbound(dir)
1935 int dir;
1936 {
1937 register struct block *b0;
1938
1939 b0 = gen_relation(BPF_JEQ,
1940 gen_load(Q_LINK, gen_loadi(0), 1),
1941 gen_loadi(0),
1942 dir);
1943 return (b0);
1944 }
Personal OpenWRT clone
This page took 0.12266 seconds and 3 git commands to generate.