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