home *** CD-ROM | disk | FTP | other *** search
/ Power Hacker 2003 / Power_Hacker_2003.iso / E-zine / Magazines / crh / freebsd / rootkit / sniffit.0.3.5 / libpcap-0.3 / gencode.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-05-27  |  35.8 KB  |  1,899 lines
  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.