Propagate from the main branch:

[libpcap] / gencode.c

diff --git a/gencode.c b/gencode.c
index 90149f72805702571b3c4cd8df44d8e0b553cc55..81da02ef76d26ac90b0ba96c1c30fe6b0ed8e389 100644 (file)
--- a/gencode.c
+++ b/gencode.c
@@ -21,7 +21,7 @@
  */
 #ifndef lint
 static const char rcsid[] _U_ =
  */
 #ifndef lint
 static const char rcsid[] _U_ =

-    "@(#) $Header: /tcpdump/master/libpcap/gencode.c,v 1.221.2.2 2005-04-10 18:04:50 hannes Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/libpcap/gencode.c,v 1.221.2.41 2006-09-13 07:02:15 guy Exp $ (LBL)";

 #endif
 
 #ifdef HAVE_CONFIG_H
 #endif
 
 #ifdef HAVE_CONFIG_H


@@ -100,8 +100,8 @@ static const char rcsid[] _U_ =
 static jmp_buf top_ctx;
 static pcap_t *bpf_pcap;
 
 static jmp_buf top_ctx;
 static pcap_t *bpf_pcap;
 

-/* Hack for updating VLAN, MPLS offsets. */
-static u_int   orig_linktype = -1U, orig_nl = -1U, orig_nl_nosnap = -1U;
+/* Hack for updating VLAN, MPLS, and PPPoE offsets. */
+static u_int   orig_linktype = -1U, orig_nl = -1U, label_stack_depth = -1U;

 
 /* XXX */
 #ifdef PCAP_FDDIPAD
 
 /* XXX */
 #ifdef PCAP_FDDIPAD


@@ -111,7 +111,6 @@ static int  pcap_fddipad;
 /* VARARGS */
 void
 bpf_error(const char *fmt, ...)
 /* VARARGS */
 void
 bpf_error(const char *fmt, ...)

-

 {
        va_list ap;
 
 {
        va_list ap;
 


@@ -131,6 +130,19 @@ static void free_reg(int);
 
 static struct block *root;
 
 
 static struct block *root;
 

+/*
+ * Value passed to gen_load_a() to indicate what the offset argument
+ * is relative to.
+ */
+enum e_offrel {
+       OR_PACKET,      /* relative to the beginning of the packet */
+       OR_LINK,        /* relative to the link-layer header */
+       OR_NET,         /* relative to the network-layer header */
+       OR_NET_NOSNAP,  /* relative to the network-layer header, with no SNAP header at the link layer */
+       OR_TRAN_IPV4,   /* relative to the transport-layer header, with IPv4 network layer */
+       OR_TRAN_IPV6    /* relative to the transport-layer header, with IPv6 network layer */
+};
+

 /*
  * We divy out chunks of memory rather than call malloc each time so
  * we don't have to worry about leaking memory.  It's probably
 /*
  * We divy out chunks of memory rather than call malloc each time so
  * we don't have to worry about leaking memory.  It's probably


@@ -158,17 +170,27 @@ static inline void syntax(void);
 
 static void backpatch(struct block *, struct block *);
 static void merge(struct block *, struct block *);
 
 static void backpatch(struct block *, struct block *);
 static void merge(struct block *, struct block *);

-static struct block *gen_cmp(u_int, u_int, bpf_int32);
-static struct block *gen_cmp_gt(u_int, u_int, bpf_int32);
-static struct block *gen_mcmp(u_int, u_int, bpf_int32, bpf_u_int32);
-static struct block *gen_bcmp(u_int, u_int, const u_char *);
-static struct block *gen_ncmp(bpf_u_int32, bpf_u_int32, bpf_u_int32,
-    bpf_u_int32, bpf_u_int32, int);
+static struct block *gen_cmp(enum e_offrel, u_int, u_int, bpf_int32);
+static struct block *gen_cmp_gt(enum e_offrel, u_int, u_int, bpf_int32);
+static struct block *gen_cmp_ge(enum e_offrel, u_int, u_int, bpf_int32);
+static struct block *gen_cmp_lt(enum e_offrel, u_int, u_int, bpf_int32);
+static struct block *gen_cmp_le(enum e_offrel, u_int, u_int, bpf_int32);
+static struct block *gen_mcmp(enum e_offrel, u_int, u_int, bpf_int32,
+    bpf_u_int32);
+static struct block *gen_bcmp(enum e_offrel, u_int, u_int, const u_char *);
+static struct block *gen_ncmp(enum e_offrel, bpf_u_int32, bpf_u_int32,
+    bpf_u_int32, bpf_u_int32, int, bpf_int32);
+static struct slist *gen_load_llrel(u_int, u_int);
+static struct slist *gen_load_a(enum e_offrel, u_int, u_int);
+static struct slist *gen_loadx_iphdrlen(void);

 static struct block *gen_uncond(int);
 static inline struct block *gen_true(void);
 static inline struct block *gen_false(void);
 static struct block *gen_ether_linktype(int);
 static struct block *gen_linux_sll_linktype(int);
 static struct block *gen_uncond(int);
 static inline struct block *gen_true(void);
 static inline struct block *gen_false(void);
 static struct block *gen_ether_linktype(int);
 static struct block *gen_linux_sll_linktype(int);

+static void insert_radiotap_load_llprefixlen(struct block *);
+static void insert_load_llprefixlen(struct block *);
+static struct slist *gen_llprefixlen(void);

 static struct block *gen_linktype(int);
 static struct block *gen_snap(bpf_u_int32, bpf_u_int32, u_int);
 static struct block *gen_llc_linktype(int);
 static struct block *gen_linktype(int);
 static struct block *gen_snap(bpf_u_int32, bpf_u_int32, u_int);
 static struct block *gen_llc_linktype(int);


@@ -182,24 +204,31 @@ static struct block *gen_fhostop(const u_char *, int);
 static struct block *gen_thostop(const u_char *, int);
 static struct block *gen_wlanhostop(const u_char *, int);
 static struct block *gen_ipfchostop(const u_char *, int);
 static struct block *gen_thostop(const u_char *, int);
 static struct block *gen_wlanhostop(const u_char *, int);
 static struct block *gen_ipfchostop(const u_char *, int);

-static struct block *gen_dnhostop(bpf_u_int32, int, u_int);
-static struct block *gen_host(bpf_u_int32, bpf_u_int32, int, int);
+static struct block *gen_dnhostop(bpf_u_int32, int);
+static struct block *gen_mpls_linktype(int);
+static struct block *gen_host(bpf_u_int32, bpf_u_int32, int, int, int);

 #ifdef INET6
 #ifdef INET6

-static struct block *gen_host6(struct in6_addr *, struct in6_addr *, int, int);
+static struct block *gen_host6(struct in6_addr *, struct in6_addr *, int, int, int);

 #endif
 #ifndef INET6
 static struct block *gen_gateway(const u_char *, bpf_u_int32 **, int, int);
 #endif
 static struct block *gen_ipfrag(void);
 static struct block *gen_portatom(int, bpf_int32);
 #endif
 #ifndef INET6
 static struct block *gen_gateway(const u_char *, bpf_u_int32 **, int, int);
 #endif
 static struct block *gen_ipfrag(void);
 static struct block *gen_portatom(int, bpf_int32);

+static struct block *gen_portrangeatom(int, bpf_int32, bpf_int32);

 #ifdef INET6
 static struct block *gen_portatom6(int, bpf_int32);
 #ifdef INET6
 static struct block *gen_portatom6(int, bpf_int32);

+static struct block *gen_portrangeatom6(int, bpf_int32, bpf_int32);

 #endif
 struct block *gen_portop(int, int, int);
 static struct block *gen_port(int, int, int);
 #endif
 struct block *gen_portop(int, int, int);
 static struct block *gen_port(int, int, int);

+struct block *gen_portrangeop(int, int, int, int);
+static struct block *gen_portrange(int, int, int, int);

 #ifdef INET6
 struct block *gen_portop6(int, int, int);
 static struct block *gen_port6(int, int, int);
 #ifdef INET6
 struct block *gen_portop6(int, int, int);
 static struct block *gen_port6(int, int, int);

+struct block *gen_portrangeop6(int, int, int, int);
+static struct block *gen_portrange6(int, int, int, int);

 #endif
 static int lookup_proto(const char *, int);
 static struct block *gen_protochain(int, int, int);
 #endif
 static int lookup_proto(const char *, int);
 static struct block *gen_protochain(int, int, int);


@@ -451,6 +480,23 @@ finish_parse(p)
        p->sense = !p->sense;
        backpatch(p, gen_retblk(0));
        root = p->head;
        p->sense = !p->sense;
        backpatch(p, gen_retblk(0));
        root = p->head;

+
+       /*
+        * Insert before the statements of the first (root) block any
+        * statements needed to load the lengths of any variable-length
+        * headers into registers.
+        *
+        * XXX - a fancier strategy would be to insert those before the
+        * statements of all blocks that use those lengths and that
+        * have no predecessors that use them, so that we only compute
+        * the lengths if we need them.  There might be even better
+        * approaches than that.  However, as we're currently only
+        * handling variable-length radiotap headers, and as all
+        * filtering expressions other than raw link[M:N] tests
+        * require the length of that header, doing more for that
+        * header length isn't really worth the effort.
+        */
+       insert_load_llprefixlen(root);

 }
 
 void
 }
 
 void


@@ -484,60 +530,63 @@ gen_not(b)
 }
 
 static struct block *
 }
 
 static struct block *

-gen_cmp(offset, size, v)
+gen_cmp(offrel, offset, size, v)
+       enum e_offrel offrel;

        u_int offset, size;
        bpf_int32 v;
 {
        u_int offset, size;
        bpf_int32 v;
 {

-       struct slist *s;
-       struct block *b;
-
-       s = new_stmt(BPF_LD|BPF_ABS|size);
-       s->s.k = offset;
-
-       b = new_block(JMP(BPF_JEQ));
-       b->stmts = s;
-       b->s.k = v;
-
-       return b;
+       return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JEQ, 0, v);

 }
 
 static struct block *
 }
 
 static struct block *

-gen_cmp_gt(offset, size, v)
+gen_cmp_gt(offrel, offset, size, v)
+       enum e_offrel offrel;

        u_int offset, size;
        bpf_int32 v;
 {
        u_int offset, size;
        bpf_int32 v;
 {

-       struct slist *s;
-       struct block *b;
+       return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGT, 0, v);
+}

 
 

-       s = new_stmt(BPF_LD|BPF_ABS|size);
-       s->s.k = offset;
+static struct block *
+gen_cmp_ge(offrel, offset, size, v)
+       enum e_offrel offrel;
+       u_int offset, size;
+       bpf_int32 v;
+{
+       return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGE, 0, v);
+}

 
 

-       b = new_block(JMP(BPF_JGT));
-       b->stmts = s;
-       b->s.k = v;
+static struct block *
+gen_cmp_lt(offrel, offset, size, v)
+       enum e_offrel offrel;
+       u_int offset, size;
+       bpf_int32 v;
+{
+       return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGE, 1, v);
+}

 
 

-       return b;
+static struct block *
+gen_cmp_le(offrel, offset, size, v)
+       enum e_offrel offrel;
+       u_int offset, size;
+       bpf_int32 v;
+{
+       return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGT, 1, v);

 }
 
 static struct block *
 }
 
 static struct block *

-gen_mcmp(offset, size, v, mask)
+gen_mcmp(offrel, offset, size, v, mask)
+       enum e_offrel offrel;

        u_int offset, size;
        bpf_int32 v;
        bpf_u_int32 mask;
 {
        u_int offset, size;
        bpf_int32 v;
        bpf_u_int32 mask;
 {

-       struct block *b = gen_cmp(offset, size, v);
-       struct slist *s;
-
-       if (mask != 0xffffffff) {
-               s = new_stmt(BPF_ALU|BPF_AND|BPF_K);
-               s->s.k = mask;
-               b->stmts->next = s;
-       }
-       return b;
+       return gen_ncmp(offrel, offset, size, mask, BPF_JEQ, 0, v);

 }
 
 static struct block *
 }
 
 static struct block *

-gen_bcmp(offset, size, v)
+gen_bcmp(offrel, offset, size, v)
+       enum e_offrel offrel;

        register u_int offset, size;
        register const u_char *v;
 {
        register u_int offset, size;
        register const u_char *v;
 {


@@ -549,7 +598,7 @@ gen_bcmp(offset, size, v)
                bpf_int32 w = ((bpf_int32)p[0] << 24) |
                    ((bpf_int32)p[1] << 16) | ((bpf_int32)p[2] << 8) | p[3];
 
                bpf_int32 w = ((bpf_int32)p[0] << 24) |
                    ((bpf_int32)p[1] << 16) | ((bpf_int32)p[2] << 8) | p[3];
 

-               tmp = gen_cmp(offset + size - 4, BPF_W, w);
+               tmp = gen_cmp(offrel, offset + size - 4, BPF_W, w);

                if (b != NULL)
                        gen_and(b, tmp);
                b = tmp;
                if (b != NULL)
                        gen_and(b, tmp);
                b = tmp;


@@ -559,14 +608,14 @@ gen_bcmp(offset, size, v)
                register const u_char *p = &v[size - 2];
                bpf_int32 w = ((bpf_int32)p[0] << 8) | p[1];
 
                register const u_char *p = &v[size - 2];
                bpf_int32 w = ((bpf_int32)p[0] << 8) | p[1];
 

-               tmp = gen_cmp(offset + size - 2, BPF_H, w);
+               tmp = gen_cmp(offrel, offset + size - 2, BPF_H, w);

                if (b != NULL)
                        gen_and(b, tmp);
                b = tmp;
                size -= 2;
        }
        if (size > 0) {
                if (b != NULL)
                        gen_and(b, tmp);
                b = tmp;
                size -= 2;
        }
        if (size > 0) {

-               tmp = gen_cmp(offset, BPF_B, (bpf_int32)v[0]);
+               tmp = gen_cmp(offrel, offset, BPF_B, (bpf_int32)v[0]);

                if (b != NULL)
                        gen_and(b, tmp);
                b = tmp;
                if (b != NULL)
                        gen_and(b, tmp);
                b = tmp;


@@ -574,25 +623,33 @@ gen_bcmp(offset, size, v)
        return b;
 }
 
        return b;
 }
 

+/*
+ * AND the field of size "size" at offset "offset" relative to the header
+ * specified by "offrel" with "mask", and compare it with the value "v"
+ * with the test specified by "jtype"; if "reverse" is true, the test
+ * should test the opposite of "jtype".
+ */

 static struct block *
 static struct block *

-gen_ncmp(datasize, offset, mask, jtype, jvalue, reverse)
-       bpf_u_int32 datasize, offset, mask, jtype, jvalue;
+gen_ncmp(offrel, offset, size, mask, jtype, reverse, v)
+       enum e_offrel offrel;
+       bpf_int32 v;
+       bpf_u_int32 offset, size, mask, jtype;

        int reverse;
 {
        int reverse;
 {

-       struct slist *s;
+       struct slist *s, *s2;

        struct block *b;
 
        struct block *b;
 

-       s = new_stmt(BPF_LD|datasize|BPF_ABS);
-       s->s.k = offset;
+       s = gen_load_a(offrel, offset, size);

 
        if (mask != 0xffffffff) {
 
        if (mask != 0xffffffff) {

-               s->next = new_stmt(BPF_ALU|BPF_AND|BPF_K);
-               s->next->s.k = mask;
+               s2 = new_stmt(BPF_ALU|BPF_AND|BPF_K);
+               s2->s.k = mask;
+               sappend(s, s2);

        }
 
        b = new_block(JMP(jtype));
        b->stmts = s;
        }
 
        b = new_block(JMP(jtype));
        b->stmts = s;

-       b->s.k = jvalue;
+       b->s.k = v;

        if (reverse && (jtype == BPF_JGT || jtype == BPF_JGE))
                gen_not(b);
        return b;
        if (reverse && (jtype == BPF_JGT || jtype == BPF_JGE))
                gen_not(b);
        return b;


@@ -600,18 +657,37 @@ gen_ncmp(datasize, offset, mask, jtype, jvalue, reverse)
 
 /*
  * Various code constructs need to know the layout of the data link
 
 /*
  * Various code constructs need to know the layout of the data link

- * layer.  These variables give the necessary offsets.
+ * layer.  These variables give the necessary offsets from the beginning
+ * of the packet data.
+ *
+ * If the link layer has variable_length headers, the offsets are offsets
+ * from the end of the link-link-layer header, and "reg_ll_size" is
+ * the register number for a register containing the length of the
+ * link-layer header.  Otherwise, "reg_ll_size" is -1.
+ */
+static int reg_ll_size;
+
+/*
+ * This is the offset of the beginning of the link-layer header from
+ * the beginning of the raw packet data.
+ *
+ * It's usually 0, except for 802.11 with a fixed-length radio header.
+ * (For 802.11 with a variable-length radio header, we have to generate
+ * code to compute that offset; off_ll is 0 in that case.)

  */
  */

+static u_int off_ll;

 
 /*
  * This is the offset of the beginning of the MAC-layer header.
 
 /*
  * This is the offset of the beginning of the MAC-layer header.

- * It's usually 0, except for ATM LANE.
+ * It's usually 0, except for ATM LANE, where it's the offset, relative
+ * to the beginning of the raw packet data, of the Ethernet header.

  */
 static u_int off_mac;
 
 /*
  * "off_linktype" is the offset to information in the link-layer header
  */
 static u_int off_mac;
 
 /*
  * "off_linktype" is the offset to information in the link-layer header

- * giving the packet type.
+ * giving the packet type.  This offset is relative to the beginning
+ * of the link-layer header (i.e., it doesn't include off_ll).

  *
  * For Ethernet, it's the offset of the Ethernet type field.
  *
  *
  * For Ethernet, it's the offset of the Ethernet type field.
  *


@@ -648,6 +724,14 @@ static u_int off_vpi;
 static u_int off_vci;
 static u_int off_proto;
 
 static u_int off_vci;
 static u_int off_proto;
 

+/*
+ * These are offsets for the MTP3 fields.
+ */
+static u_int off_sio;
+static u_int off_opc;
+static u_int off_dpc;
+static u_int off_sls;
+

 /*
  * This is the offset of the first byte after the ATM pseudo_header,
  * or -1 if there is no ATM pseudo-header.
 /*
  * This is the offset of the first byte after the ATM pseudo_header,
  * or -1 if there is no ATM pseudo-header.


@@ -656,6 +740,8 @@ static u_int off_payload;
 
 /*
  * These are offsets to the beginning of the network-layer header.
 
 /*
  * These are offsets to the beginning of the network-layer header.

+ * They are relative to the beginning of the link-layer header (i.e.,
+ * they don't include off_ll).

  *
  * If the link layer never uses 802.2 LLC:
  *
  *
  * If the link layer never uses 802.2 LLC:
  *


@@ -701,9 +787,24 @@ init_linktype(p)
        off_proto = -1;
        off_payload = -1;
 
        off_proto = -1;
        off_payload = -1;
 

+       /*
+        * And assume we're not doing SS7.
+        */
+       off_sio = -1;
+       off_opc = -1;
+       off_dpc = -1;
+       off_sls = -1;
+
+       /*
+        * Also assume it's not 802.11 with a fixed-length radio header.
+        */
+       off_ll = 0;
+

        orig_linktype = -1;
        orig_nl = -1;
        orig_linktype = -1;
        orig_nl = -1;

-       orig_nl_nosnap = -1;
+        label_stack_depth = 0;
+
+       reg_ll_size = -1;

 
        switch (linktype) {
 
 
        switch (linktype) {
 


@@ -862,9 +963,10 @@ init_linktype(p)
                 * XXX - same variable-length header problem; at least
                 * the Prism header is fixed-length.
                 */
                 * XXX - same variable-length header problem; at least
                 * the Prism header is fixed-length.
                 */

-               off_linktype = 144+24;
-               off_nl = 144+32;        /* Prism+802.11+802.2+SNAP */
-               off_nl_nosnap = 144+27; /* Prism+802.11+802.2 */
+               off_ll = 144;
+               off_linktype = 24;
+               off_nl = 32;    /* Prism+802.11+802.2+SNAP */
+               off_nl_nosnap = 27;     /* Prism+802.11+802.2 */

                return;
 
        case DLT_IEEE802_11_RADIO_AVS:
                return;
 
        case DLT_IEEE802_11_RADIO_AVS:


@@ -880,11 +982,23 @@ init_linktype(p)
                 * more so; this header is also variable-length,
                 * with the length being the 32-bit big-endian
                 * number at an offset of 4 from the beginning
                 * more so; this header is also variable-length,
                 * with the length being the 32-bit big-endian
                 * number at an offset of 4 from the beginning

-                * of the radio header.
+                * of the radio header.  We should handle that the
+                * same way we handle the length at the beginning
+                * of the radiotap header.
+                *
+                * XXX - in Linux, do any drivers that supply an AVS
+                * header supply a link-layer type other than
+                * ARPHRD_IEEE80211_PRISM?  If so, we should map that
+                * to DLT_IEEE802_11_RADIO_AVS; if not, or if there are
+                * any drivers that supply an AVS header but supply
+                * an ARPHRD value of ARPHRD_IEEE80211_PRISM, we'll
+                * have to check the header in the generated code to
+                * determine whether it's Prism or AVS.

                 */
                 */

-               off_linktype = 64+24;
-               off_nl = 64+32;         /* Radio+802.11+802.2+SNAP */
-               off_nl_nosnap = 64+27;  /* Radio+802.11+802.2 */
+               off_ll = 64;
+               off_linktype = 24;
+               off_nl = 32;            /* Radio+802.11+802.2+SNAP */
+               off_nl_nosnap = 27;     /* Radio+802.11+802.2 */

                return;
 
        case DLT_IEEE802_11_RADIO:
                return;
 
        case DLT_IEEE802_11_RADIO:


@@ -893,21 +1007,14 @@ init_linktype(p)
                 * the 802.11 header, containing a bunch of additional
                 * information including radio-level information.
                 *
                 * the 802.11 header, containing a bunch of additional
                 * information including radio-level information.
                 *

-                * XXX - same variable-length header problem, only
-                * even *more* so; this header is also variable-length,
-                * with the length being the 16-bit number at an offset
-                * of 2 from the beginning of the radio header, and it's
-                * device-dependent (different devices might supply
-                * different amounts of information), so we can't even
-                * assume a fixed length for the current version of the
-                * header.
-                *
-                * Therefore, currently, only raw "link[N:M]" filtering is
-                * supported.
+                * The radiotap header is variable length, and we
+                * generate code to compute its length and store it
+                * in a register.  These offsets are relative to the
+                * beginning of the 802.11 header.

                 */
                 */

-               off_linktype = -1;
-               off_nl = -1;
-               off_nl_nosnap = -1;
+               off_linktype = 24;
+               off_nl = 32;            /* 802.11+802.2+SNAP */
+               off_nl_nosnap = 27;     /* 802.11+802.2 */

                return;
 
        case DLT_ATM_RFC1483:
                return;
 
        case DLT_ATM_RFC1483:


@@ -915,6 +1022,13 @@ init_linktype(p)
                /*
                 * assume routed, non-ISO PDUs
                 * (i.e., LLC = 0xAA-AA-03, OUT = 0x00-00-00)
                /*
                 * assume routed, non-ISO PDUs
                 * (i.e., LLC = 0xAA-AA-03, OUT = 0x00-00-00)

+                *
+                * XXX - what about ISO PDUs, e.g. CLNP, ISIS, ESIS,
+                * or PPP with the PPP NLPID (e.g., PPPoA)?  The
+                * latter would presumably be treated the way PPPoE
+                * should be, so you can do "pppoe and udp port 2049"
+                * or "pppoa and tcp port 80" and have it check for
+                * PPPo{A,E} and a PPP protocol of IP and....

                 */
                off_linktype = 0;
                off_nl = 8;             /* 802.2+SNAP */
                 */
                off_linktype = 0;
                off_nl = 8;             /* 802.2+SNAP */


@@ -986,6 +1100,17 @@ init_linktype(p)
                off_nl_nosnap = 0;      /* no 802.2 LLC */
                return;
 
                off_nl_nosnap = 0;      /* no 802.2 LLC */
                return;
 

+                /*
+                 * the only BPF-interesting FRF.16 frames are non-control frames;
+                 * Frame Relay has a variable length link-layer
+                 * so lets start with offset 4 for now and increments later on (FIXME);
+                 */
+       case DLT_MFR:
+               off_linktype = -1;
+               off_nl = 4;
+               off_nl_nosnap = 0;      /* XXX - for now -> no 802.2 LLC */
+               return;
+

        case DLT_APPLE_IP_OVER_IEEE1394:
                off_linktype = 16;
                off_nl = 18;
        case DLT_APPLE_IP_OVER_IEEE1394:
                off_linktype = 16;
                off_nl = 18;


@@ -1023,8 +1148,12 @@ init_linktype(p)
                off_nl_nosnap = PFLOG_HDRLEN;   /* no 802.2 LLC */
                return;
 
                off_nl_nosnap = PFLOG_HDRLEN;   /* no 802.2 LLC */
                return;
 

+        case DLT_JUNIPER_MFR:

         case DLT_JUNIPER_MLFR:
         case DLT_JUNIPER_MLPPP:
         case DLT_JUNIPER_MLFR:
         case DLT_JUNIPER_MLPPP:

+        case DLT_JUNIPER_PPP:
+        case DLT_JUNIPER_CHDLC:
+        case DLT_JUNIPER_FRELAY:

                 off_linktype = 4;
                off_nl = 4;
                off_nl_nosnap = -1;     /* no 802.2 LLC */
                 off_linktype = 4;
                off_nl = 4;
                off_nl_nosnap = -1;     /* no 802.2 LLC */


@@ -1042,6 +1171,55 @@ init_linktype(p)
                off_nl_nosnap = 18;
                return;
 
                off_nl_nosnap = 18;
                return;
 

+               /* frames captured on a Juniper PPPoE service PIC
+                * contain raw ethernet frames */
+       case DLT_JUNIPER_PPPOE:
+        case DLT_JUNIPER_ETHER:
+               off_linktype = 16;
+               off_nl = 18;            /* Ethernet II */
+               off_nl_nosnap = 21;     /* 802.3+802.2 */
+               return;
+
+       case DLT_JUNIPER_PPPOE_ATM:
+               off_linktype = 4;
+               off_nl = 6;
+               off_nl_nosnap = -1;      /* no 802.2 LLC */
+               return;
+
+       case DLT_JUNIPER_GGSN:
+               off_linktype = 6;
+               off_nl = 12;
+               off_nl_nosnap = -1;      /* no 802.2 LLC */
+               return;
+
+       case DLT_JUNIPER_ES:
+               off_linktype = 6;
+               off_nl = -1;            /* not really a network layer but raw IP adresses */
+               off_nl_nosnap = -1;     /* no 802.2 LLC */
+               return;
+
+       case DLT_JUNIPER_MONITOR:
+               off_linktype = 12;
+               off_nl = 12;            /* raw IP/IP6 header */
+               off_nl_nosnap = -1;     /* no 802.2 LLC */
+               return;
+
+       case DLT_JUNIPER_SERVICES:
+               off_linktype = 12;
+               off_nl = -1;            /* L3 proto location dep. on cookie type */
+               off_nl_nosnap = -1;     /* no 802.2 LLC */
+               return;
+
+       case DLT_MTP2:
+               off_sio = 3;
+               off_opc = 4;
+               off_dpc = 4;
+               off_sls = 7;
+               off_linktype = -1;
+               off_nl = -1;
+               off_nl_nosnap = -1;
+               return;
+

 #ifdef DLT_PFSYNC
        case DLT_PFSYNC:
                off_linktype = -1;
 #ifdef DLT_PFSYNC
        case DLT_PFSYNC:
                off_linktype = -1;


@@ -1063,6 +1241,148 @@ init_linktype(p)
        /* NOTREACHED */
 }
 
        /* NOTREACHED */
 }
 

+/*
+ * Load a value relative to the beginning of the link-layer header.
+ * The link-layer header doesn't necessarily begin at the beginning
+ * of the packet data; there might be a variable-length prefix containing
+ * radio information.
+ */
+static struct slist *
+gen_load_llrel(offset, size)
+       u_int offset, size;
+{
+       struct slist *s, *s2;
+
+       s = gen_llprefixlen();
+
+       /*
+        * If "s" is non-null, it has code to arrange that the X register
+        * contains the length of the prefix preceding the link-layer
+        * header.
+        *
+        * Otherwise, the length of the prefix preceding the link-layer
+        * header is "off_ll".
+        */
+       if (s != NULL) {
+               s2 = new_stmt(BPF_LD|BPF_IND|size);
+               s2->s.k = offset;
+               sappend(s, s2);
+       } else {
+               s = new_stmt(BPF_LD|BPF_ABS|size);
+               s->s.k = offset + off_ll;
+       }
+       return s;
+}
+
+/*
+ * Load a value relative to the beginning of the specified header.
+ */
+static struct slist *
+gen_load_a(offrel, offset, size)
+       enum e_offrel offrel;
+       u_int offset, size;
+{
+       struct slist *s, *s2;
+
+       switch (offrel) {
+
+       case OR_PACKET:
+                s = new_stmt(BPF_LD|BPF_ABS|size);
+                s->s.k = offset;
+               break;
+
+       case OR_LINK:
+               s = gen_load_llrel(offset, size);
+               break;
+
+       case OR_NET:
+               s = gen_load_llrel(off_nl + offset, size);
+               break;
+
+       case OR_NET_NOSNAP:
+               s = gen_load_llrel(off_nl_nosnap + offset, size);
+               break;
+
+       case OR_TRAN_IPV4:
+               /*
+                * Load the X register with the length of the IPv4 header,
+                * in bytes.
+                */
+               s = gen_loadx_iphdrlen();
+
+               /*
+                * Load the item at {length of the link-layer header} +
+                * {length of the IPv4 header} + {specified offset}.
+                */
+               s2 = new_stmt(BPF_LD|BPF_IND|size);
+               s2->s.k = off_nl + offset;
+               sappend(s, s2);
+               break;
+
+       case OR_TRAN_IPV6:
+               s = gen_load_llrel(off_nl + 40 + offset, size);
+               break;
+
+       default:
+               abort();
+               return NULL;
+       }
+       return s;
+}
+
+/*
+ * Generate code to load into the X register the sum of the length of
+ * the IPv4 header and any variable-length header preceding the link-layer
+ * header.
+ */
+static struct slist *
+gen_loadx_iphdrlen()
+{
+       struct slist *s, *s2;
+
+       s = gen_llprefixlen();
+       if (s != NULL) {
+               /*
+                * There's a variable-length prefix preceding the
+                * link-layer header.  "s" points to a list of statements
+                * that put the length of that prefix into the X register.
+                * The 4*([k]&0xf) addressing mode can't be used, as we
+                * don't have a constant offset, so we have to load the
+                * value in question into the A register and add to it
+                * the value from the X register.
+                */
+               s2 = new_stmt(BPF_LD|BPF_IND|BPF_B);
+               s2->s.k = off_nl;
+               sappend(s, s2);
+               s2 = new_stmt(BPF_ALU|BPF_AND|BPF_K);
+               s2->s.k = 0xf;
+               sappend(s, s2);
+               s2 = new_stmt(BPF_ALU|BPF_LSH|BPF_K);
+               s2->s.k = 2;
+               sappend(s, s2);
+
+               /*
+                * The A register now contains the length of the
+                * IP header.  We need to add to it the length
+                * of the prefix preceding the link-layer
+                * header, which is still in the X register, and
+                * move the result into the X register.
+                */
+               sappend(s, new_stmt(BPF_ALU|BPF_ADD|BPF_X));
+               sappend(s, new_stmt(BPF_MISC|BPF_TAX));
+       } else {
+               /*
+                * There is no variable-length header preceding the
+                * link-layer header; if there's a fixed-length
+                * header preceding it, its length is included in
+                * the off_ variables, so it doesn't need to be added.
+                */
+               s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
+               s->s.k = off_nl;
+       }
+       return s;
+}
+

 static struct block *
 gen_uncond(rsense)
        int rsense;
 static struct block *
 gen_uncond(rsense)
        int rsense;


@@ -1130,9 +1450,9 @@ gen_ether_linktype(proto)
                 * DSAP, as we do for other types <= ETHERMTU
                 * (i.e., other SAP values)?
                 */
                 * DSAP, as we do for other types <= ETHERMTU
                 * (i.e., other SAP values)?
                 */

-               b0 = gen_cmp_gt(off_linktype, BPF_H, ETHERMTU);
+               b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);

                gen_not(b0);
                gen_not(b0);

-               b1 = gen_cmp(off_linktype + 2, BPF_H, (bpf_int32)
+               b1 = gen_cmp(OR_LINK, off_linktype + 2, BPF_H, (bpf_int32)

                             ((proto << 8) | proto));
                gen_and(b0, b1);
                return b1;
                             ((proto << 8) | proto));
                gen_and(b0, b1);
                return b1;


@@ -1170,8 +1490,10 @@ gen_ether_linktype(proto)
                 * This generates code to check both for the
                 * IPX LSAP (Ethernet_802.2) and for Ethernet_802.3.
                 */
                 * This generates code to check both for the
                 * IPX LSAP (Ethernet_802.2) and for Ethernet_802.3.
                 */

-               b0 = gen_cmp(off_linktype + 2, BPF_B, (bpf_int32)LLCSAP_IPX);
-               b1 = gen_cmp(off_linktype + 2, BPF_H, (bpf_int32)0xFFFF);
+               b0 = gen_cmp(OR_LINK, off_linktype + 2, BPF_B,
+                   (bpf_int32)LLCSAP_IPX);
+               b1 = gen_cmp(OR_LINK, off_linktype + 2, BPF_H,
+                   (bpf_int32)0xFFFF);

                gen_or(b0, b1);
 
                /*
                gen_or(b0, b1);
 
                /*


@@ -1185,7 +1507,7 @@ gen_ether_linktype(proto)
                 * Now we generate code to check for 802.3
                 * frames in general.
                 */
                 * Now we generate code to check for 802.3
                 * frames in general.
                 */

-               b0 = gen_cmp_gt(off_linktype, BPF_H, ETHERMTU);
+               b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);

                gen_not(b0);
 
                /*
                gen_not(b0);
 
                /*


@@ -1201,7 +1523,8 @@ gen_ether_linktype(proto)
                 * do that before checking for the other frame
                 * types.
                 */
                 * do that before checking for the other frame
                 * types.
                 */

-               b0 = gen_cmp(off_linktype, BPF_H, (bpf_int32)ETHERTYPE_IPX);
+               b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
+                   (bpf_int32)ETHERTYPE_IPX);

                gen_or(b0, b1);
                return b1;
 
                gen_or(b0, b1);
                return b1;
 


@@ -1217,7 +1540,7 @@ gen_ether_linktype(proto)
                 * we check for an Ethernet type field less than
                 * 1500, which means it's an 802.3 length field.
                 */
                 * we check for an Ethernet type field less than
                 * 1500, which means it's an 802.3 length field.
                 */

-               b0 = gen_cmp_gt(off_linktype, BPF_H, ETHERMTU);
+               b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);

                gen_not(b0);
 
                /*
                gen_not(b0);
 
                /*


@@ -1242,7 +1565,7 @@ gen_ether_linktype(proto)
                 * phase 1?); we just check for the Ethernet
                 * protocol type.
                 */
                 * phase 1?); we just check for the Ethernet
                 * protocol type.
                 */

-               b0 = gen_cmp(off_linktype, BPF_H, (bpf_int32)proto);
+               b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);

 
                gen_or(b0, b1);
                return b1;
 
                gen_or(b0, b1);
                return b1;


@@ -1257,9 +1580,10 @@ gen_ether_linktype(proto)
                         * a length field, <= ETHERMTU) and
                         * then check the DSAP.
                         */
                         * a length field, <= ETHERMTU) and
                         * then check the DSAP.
                         */

-                       b0 = gen_cmp_gt(off_linktype, BPF_H, ETHERMTU);
+                       b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);

                        gen_not(b0);
                        gen_not(b0);

-                       b1 = gen_cmp(off_linktype + 2, BPF_B, (bpf_int32)proto);
+                       b1 = gen_cmp(OR_LINK, off_linktype + 2, BPF_B,
+                           (bpf_int32)proto);

                        gen_and(b0, b1);
                        return b1;
                } else {
                        gen_and(b0, b1);
                        return b1;
                } else {


@@ -1272,7 +1596,8 @@ gen_ether_linktype(proto)
                         * will fail and the frame won't match,
                         * which is what we want).
                         */
                         * will fail and the frame won't match,
                         * which is what we want).
                         */

-                       return gen_cmp(off_linktype, BPF_H, (bpf_int32)proto);
+                       return gen_cmp(OR_LINK, off_linktype, BPF_H,
+                           (bpf_int32)proto);

                }
        }
 }
                }
        }
 }


@@ -1308,8 +1633,8 @@ gen_linux_sll_linktype(proto)
                 * DSAP, as we do for other types <= ETHERMTU
                 * (i.e., other SAP values)?
                 */
                 * DSAP, as we do for other types <= ETHERMTU
                 * (i.e., other SAP values)?
                 */

-               b0 = gen_cmp(off_linktype, BPF_H, LINUX_SLL_P_802_2);
-               b1 = gen_cmp(off_linktype + 2, BPF_H, (bpf_int32)
+               b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
+               b1 = gen_cmp(OR_LINK, off_linktype + 2, BPF_H, (bpf_int32)

                             ((proto << 8) | proto));
                gen_and(b0, b1);
                return b1;
                             ((proto << 8) | proto));
                gen_and(b0, b1);
                return b1;


@@ -1340,19 +1665,19 @@ gen_linux_sll_linktype(proto)
                 * then put a check for LINUX_SLL_P_802_2 frames
                 * before it.
                 */
                 * then put a check for LINUX_SLL_P_802_2 frames
                 * before it.
                 */

-               b0 = gen_cmp(off_linktype + 2, BPF_B,
+               b0 = gen_cmp(OR_LINK, off_linktype + 2, BPF_B,

                    (bpf_int32)LLCSAP_IPX);
                b1 = gen_snap(0x000000, ETHERTYPE_IPX,
                    off_linktype + 2);
                gen_or(b0, b1);
                    (bpf_int32)LLCSAP_IPX);
                b1 = gen_snap(0x000000, ETHERTYPE_IPX,
                    off_linktype + 2);
                gen_or(b0, b1);

-               b0 = gen_cmp(off_linktype, BPF_H, LINUX_SLL_P_802_2);
+               b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);

                gen_and(b0, b1);
 
                /*
                 * Now check for 802.3 frames and OR that with
                 * the previous test.
                 */
                gen_and(b0, b1);
 
                /*
                 * Now check for 802.3 frames and OR that with
                 * the previous test.
                 */

-               b0 = gen_cmp(off_linktype, BPF_H, LINUX_SLL_P_802_3);
+               b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_3);

                gen_or(b0, b1);
 
                /*
                gen_or(b0, b1);
 
                /*


@@ -1360,7 +1685,7 @@ gen_linux_sll_linktype(proto)
                 * do that before checking for the other frame
                 * types.
                 */
                 * do that before checking for the other frame
                 * types.
                 */

-               b0 = gen_cmp(off_linktype, BPF_H,
+               b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,

                    (bpf_int32)ETHERTYPE_IPX);
                gen_or(b0, b1);
                return b1;
                    (bpf_int32)ETHERTYPE_IPX);
                gen_or(b0, b1);
                return b1;


@@ -1377,7 +1702,7 @@ gen_linux_sll_linktype(proto)
                 * we check for the 802.2 protocol type in the
                 * "Ethernet type" field.
                 */
                 * we check for the 802.2 protocol type in the
                 * "Ethernet type" field.
                 */

-               b0 = gen_cmp(off_linktype, BPF_H, LINUX_SLL_P_802_2);
+               b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);

 
                /*
                 * 802.2-encapsulated ETHERTYPE_ATALK packets are
 
                /*
                 * 802.2-encapsulated ETHERTYPE_ATALK packets are


@@ -1403,7 +1728,7 @@ gen_linux_sll_linktype(proto)
                 * phase 1?); we just check for the Ethernet
                 * protocol type.
                 */
                 * phase 1?); we just check for the Ethernet
                 * protocol type.
                 */

-               b0 = gen_cmp(off_linktype, BPF_H, (bpf_int32)proto);
+               b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);

 
                gen_or(b0, b1);
                return b1;
 
                gen_or(b0, b1);
                return b1;


@@ -1417,9 +1742,9 @@ gen_linux_sll_linktype(proto)
                         * in the "Ethernet type" field, and
                         * then check the DSAP.
                         */
                         * in the "Ethernet type" field, and
                         * then check the DSAP.
                         */

-                       b0 = gen_cmp(off_linktype, BPF_H,
+                       b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,

                            LINUX_SLL_P_802_2);
                            LINUX_SLL_P_802_2);

-                       b1 = gen_cmp(off_linktype + 2, BPF_B,
+                       b1 = gen_cmp(OR_LINK, off_linktype + 2, BPF_B,

                             (bpf_int32)proto);
                        gen_and(b0, b1);
                        return b1;
                             (bpf_int32)proto);
                        gen_and(b0, b1);
                        return b1;


@@ -1433,12 +1758,130 @@ gen_linux_sll_linktype(proto)
                         * will fail and the frame won't match,
                         * which is what we want).
                         */
                         * will fail and the frame won't match,
                         * which is what we want).
                         */

-                       return gen_cmp(off_linktype, BPF_H,
+                       return gen_cmp(OR_LINK, off_linktype, BPF_H,

                            (bpf_int32)proto);
                }
        }
 }
 
                            (bpf_int32)proto);
                }
        }
 }
 

+static void
+insert_radiotap_load_llprefixlen(b)
+       struct block *b;
+{
+       struct slist *s1, *s2;
+
+       /*
+        * Prepend to the statements in this block code to load the
+        * length of the radiotap header into the register assigned
+        * to hold that length, if one has been assigned.
+        */
+       if (reg_ll_size != -1) {
+               /*
+                * The 2 bytes at offsets of 2 and 3 from the beginning
+                * of the radiotap header are the length of the radiotap
+                * header; unfortunately, it's little-endian, so we have
+                * to load it a byte at a time and construct the value.
+                */
+
+               /*
+                * Load the high-order byte, at an offset of 3, shift it
+                * left a byte, and put the result in the X register.
+                */
+               s1 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
+               s1->s.k = 3;
+               s2 = new_stmt(BPF_ALU|BPF_LSH|BPF_K);
+               sappend(s1, s2);
+               s2->s.k = 8;
+               s2 = new_stmt(BPF_MISC|BPF_TAX);
+               sappend(s1, s2);
+
+               /*
+                * Load the next byte, at an offset of 2, and OR the
+                * value from the X register into it.
+                */
+               s2 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
+               sappend(s1, s2);
+               s2->s.k = 2;
+               s2 = new_stmt(BPF_ALU|BPF_OR|BPF_X);
+               sappend(s1, s2);
+
+               /*
+                * Now allocate a register to hold that value and store
+                * it.
+                */
+               s2 = new_stmt(BPF_ST);
+               s2->s.k = reg_ll_size;
+               sappend(s1, s2);
+
+               /*
+                * Now move it into the X register.
+                */
+               s2 = new_stmt(BPF_MISC|BPF_TAX);
+               sappend(s1, s2);
+
+               /*
+                * Now append all the existing statements in this
+                * block to these statements.
+                */
+               sappend(s1, b->stmts);
+               b->stmts = s1;
+       }
+}
+
+
+static void
+insert_load_llprefixlen(b)
+       struct block *b;
+{
+       switch (linktype) {
+
+       case DLT_IEEE802_11_RADIO:
+               insert_radiotap_load_llprefixlen(b);
+       }
+}
+
+
+static struct slist *
+gen_radiotap_llprefixlen(void)
+{
+       struct slist *s;
+
+       if (reg_ll_size == -1) {
+               /*
+                * We haven't yet assigned a register for the length
+                * of the radiotap header; allocate one.
+                */
+               reg_ll_size = alloc_reg();
+       }
+
+       /*
+        * Load the register containing the radiotap length
+        * into the X register.
+        */
+       s = new_stmt(BPF_LDX|BPF_MEM);
+       s->s.k = reg_ll_size;
+       return s;
+}
+
+/*
+ * Generate code to compute the link-layer header length, if necessary,
+ * putting it into the X register, and to return either a pointer to a
+ * "struct slist" for the list of statements in that code, or NULL if
+ * no code is necessary.
+ */
+static struct slist *
+gen_llprefixlen(void)
+{
+       switch (linktype) {
+
+       case DLT_IEEE802_11_RADIO:
+               return gen_radiotap_llprefixlen();
+
+       default:
+               return NULL;
+       }
+}
+

 /*
  * Generate code to match a particular packet type by matching the
  * link-layer type field or fields in the 802.2 LLC header.
 /*
  * Generate code to match a particular packet type by matching the
  * link-layer type field or fields in the 802.2 LLC header.


@@ -1452,12 +1895,31 @@ gen_linktype(proto)
 {
        struct block *b0, *b1, *b2;
 
 {
        struct block *b0, *b1, *b2;
 

+       /* are we checking MPLS-encapsulated packets? */
+       if (label_stack_depth > 0) {
+               switch (proto) {
+               case ETHERTYPE_IP:
+               case PPP_IP:
+               /* FIXME add other L3 proto IDs */
+                       return gen_mpls_linktype(Q_IP); 
+
+               case ETHERTYPE_IPV6:
+               case PPP_IPV6:
+               /* FIXME add other L3 proto IDs */
+                       return gen_mpls_linktype(Q_IPV6); 
+
+               default:
+                       bpf_error("unsupported protocol over mpls");
+                       /* NOTREACHED */
+               }
+       }
+

        switch (linktype) {
 
        case DLT_EN10MB:
        switch (linktype) {
 
        case DLT_EN10MB:

-                return gen_ether_linktype(proto);
-                /*NOTREACHED*/
-                break;
+               return gen_ether_linktype(proto);
+               /*NOTREACHED*/
+               break;

 
        case DLT_C_HDLC:
                switch (proto) {
 
        case DLT_C_HDLC:
                switch (proto) {


@@ -1467,17 +1929,19 @@ gen_linktype(proto)
                        /* fall through */
 
                default:
                        /* fall through */
 
                default:

-                       return gen_cmp(off_linktype, BPF_H, (bpf_int32)proto);
+                       return gen_cmp(OR_LINK, off_linktype, BPF_H,
+                           (bpf_int32)proto);

                        /*NOTREACHED*/
                        break;
                }
                break;
 
                        /*NOTREACHED*/
                        break;
                }
                break;
 

-       case DLT_IEEE802_11:
-       case DLT_PRISM_HEADER:
-       case DLT_IEEE802_11_RADIO:

        case DLT_FDDI:
        case DLT_IEEE802:
        case DLT_FDDI:
        case DLT_IEEE802:

+       case DLT_IEEE802_11:
+       case DLT_IEEE802_11_RADIO_AVS:
+       case DLT_IEEE802_11_RADIO:
+       case DLT_PRISM_HEADER:

        case DLT_ATM_RFC1483:
        case DLT_ATM_CLIP:
        case DLT_IP_OVER_FC:
        case DLT_ATM_RFC1483:
        case DLT_ATM_CLIP:
        case DLT_IP_OVER_FC:


@@ -1499,7 +1963,8 @@ gen_linktype(proto)
                         * LE Control marker.  (We've already generated
                         * a test for LANE.)
                         */
                         * LE Control marker.  (We've already generated
                         * a test for LANE.)
                         */

-                       b0 = gen_cmp(SUNATM_PKT_BEGIN_POS, BPF_H, 0xFF00);
+                       b0 = gen_cmp(OR_LINK, SUNATM_PKT_BEGIN_POS, BPF_H,
+                           0xFF00);

                        gen_not(b0);
 
                        /*
                        gen_not(b0);
 
                        /*


@@ -1609,10 +2074,10 @@ gen_linktype(proto)
                switch (proto) {
 
                case ETHERTYPE_IP:
                switch (proto) {
 
                case ETHERTYPE_IP:

-                       b0 = gen_cmp(off_linktype, BPF_H, PPP_IP);
-                       b1 = gen_cmp(off_linktype, BPF_H, PPP_VJC);
+                       b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_IP);
+                       b1 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_VJC);

                        gen_or(b0, b1);
                        gen_or(b0, b1);

-                       b0 = gen_cmp(off_linktype, BPF_H, PPP_VJNC);
+                       b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_VJNC);

                        gen_or(b1, b0);
                        return b0;
 
                        gen_or(b1, b0);
                        return b0;
 


@@ -1718,7 +2183,7 @@ gen_linktype(proto)
                                proto = SWAPLONG(proto);
                        proto = htonl(proto);
                }
                                proto = SWAPLONG(proto);
                        proto = htonl(proto);
                }

-               return (gen_cmp(0, BPF_W, (bpf_int32)proto));
+               return (gen_cmp(OR_LINK, 0, BPF_W, (bpf_int32)proto));

 
        case DLT_PFLOG:
                /*
 
        case DLT_PFLOG:
                /*


@@ -1726,12 +2191,12 @@ gen_linktype(proto)
                 * the packet.
                 */
                if (proto == ETHERTYPE_IP)
                 * the packet.
                 */
                if (proto == ETHERTYPE_IP)

-                       return (gen_cmp(offsetof(struct pfloghdr, af), BPF_B,
-                           (bpf_int32)AF_INET));
+                       return (gen_cmp(OR_LINK, offsetof(struct pfloghdr, af),
+                           BPF_B, (bpf_int32)AF_INET));

 #ifdef INET6
                else if (proto == ETHERTYPE_IPV6)
 #ifdef INET6
                else if (proto == ETHERTYPE_IPV6)

-                       return (gen_cmp(offsetof(struct pfloghdr, af), BPF_B,
-                           (bpf_int32)AF_INET6));
+                       return (gen_cmp(OR_LINK, offsetof(struct pfloghdr, af),
+                           BPF_B, (bpf_int32)AF_INET6));

 #endif /* INET6 */
                else
                        return gen_false();
 #endif /* INET6 */
                else
                        return gen_false();


@@ -1751,32 +2216,32 @@ gen_linktype(proto)
 
 #ifdef INET6
                case ETHERTYPE_IPV6:
 
 #ifdef INET6
                case ETHERTYPE_IPV6:

-                       return (gen_cmp(off_linktype, BPF_B,
+                       return (gen_cmp(OR_LINK, off_linktype, BPF_B,

                                (bpf_int32)ARCTYPE_INET6));
 #endif /* INET6 */
 
                case ETHERTYPE_IP:
                                (bpf_int32)ARCTYPE_INET6));
 #endif /* INET6 */
 
                case ETHERTYPE_IP:

-                       b0 = gen_cmp(off_linktype, BPF_B,
+                       b0 = gen_cmp(OR_LINK, off_linktype, BPF_B,

                                     (bpf_int32)ARCTYPE_IP);
                                     (bpf_int32)ARCTYPE_IP);

-                       b1 = gen_cmp(off_linktype, BPF_B,
+                       b1 = gen_cmp(OR_LINK, off_linktype, BPF_B,

                                     (bpf_int32)ARCTYPE_IP_OLD);
                        gen_or(b0, b1);
                        return (b1);
 
                case ETHERTYPE_ARP:
                                     (bpf_int32)ARCTYPE_IP_OLD);
                        gen_or(b0, b1);
                        return (b1);
 
                case ETHERTYPE_ARP:

-                       b0 = gen_cmp(off_linktype, BPF_B,
+                       b0 = gen_cmp(OR_LINK, off_linktype, BPF_B,

                                     (bpf_int32)ARCTYPE_ARP);
                                     (bpf_int32)ARCTYPE_ARP);

-                       b1 = gen_cmp(off_linktype, BPF_B,
+                       b1 = gen_cmp(OR_LINK, off_linktype, BPF_B,

                                     (bpf_int32)ARCTYPE_ARP_OLD);
                        gen_or(b0, b1);
                        return (b1);
 
                case ETHERTYPE_REVARP:
                                     (bpf_int32)ARCTYPE_ARP_OLD);
                        gen_or(b0, b1);
                        return (b1);
 
                case ETHERTYPE_REVARP:

-                       return (gen_cmp(off_linktype, BPF_B,
+                       return (gen_cmp(OR_LINK, off_linktype, BPF_B,

                                        (bpf_int32)ARCTYPE_REVARP));
 
                case ETHERTYPE_ATALK:
                                        (bpf_int32)ARCTYPE_REVARP));
 
                case ETHERTYPE_ATALK:

-                       return (gen_cmp(off_linktype, BPF_B,
+                       return (gen_cmp(OR_LINK, off_linktype, BPF_B,

                                        (bpf_int32)ARCTYPE_ATALK));
                }
                /*NOTREACHED*/
                                        (bpf_int32)ARCTYPE_ATALK));
                }
                /*NOTREACHED*/


@@ -1803,14 +2268,14 @@ gen_linktype(proto)
                        /*
                         * Check for the special NLPID for IP.
                         */
                        /*
                         * Check for the special NLPID for IP.
                         */

-                       return gen_cmp(2, BPF_H, (0x03<<8) | 0xcc);
+                       return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | 0xcc);

 
 #ifdef INET6
                case ETHERTYPE_IPV6:
                        /*
                         * Check for the special NLPID for IPv6.
                         */
 
 #ifdef INET6
                case ETHERTYPE_IPV6:
                        /*
                         * Check for the special NLPID for IPv6.
                         */

-                       return gen_cmp(2, BPF_H, (0x03<<8) | 0x8e);
+                       return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | 0x8e);

 #endif
 
                case LLCSAP_ISONS:
 #endif
 
                case LLCSAP_ISONS:


@@ -1825,9 +2290,9 @@ gen_linktype(proto)
                         * control field of UI, i.e. 0x03 followed
                         * by the NLPID.
                         */
                         * control field of UI, i.e. 0x03 followed
                         * by the NLPID.
                         */

-                       b0 = gen_cmp(2, BPF_H, (0x03<<8) | ISO8473_CLNP);
-                       b1 = gen_cmp(2, BPF_H, (0x03<<8) | ISO9542_ESIS);
-                       b2 = gen_cmp(2, BPF_H, (0x03<<8) | ISO10589_ISIS);
+                       b0 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO8473_CLNP);
+                       b1 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO9542_ESIS);
+                       b2 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO10589_ISIS);

                        gen_or(b1, b2);
                        gen_or(b0, b2);
                        return b2;
                        gen_or(b1, b2);
                        gen_or(b0, b2);
                        return b2;


@@ -1838,10 +2303,21 @@ gen_linktype(proto)
                /*NOTREACHED*/
                break;
 
                /*NOTREACHED*/
                break;
 

+        case DLT_JUNIPER_MFR:

         case DLT_JUNIPER_MLFR:
         case DLT_JUNIPER_MLPPP:
        case DLT_JUNIPER_ATM1:
        case DLT_JUNIPER_ATM2:
         case DLT_JUNIPER_MLFR:
         case DLT_JUNIPER_MLPPP:
        case DLT_JUNIPER_ATM1:
        case DLT_JUNIPER_ATM2:

+       case DLT_JUNIPER_PPPOE:
+       case DLT_JUNIPER_PPPOE_ATM:
+        case DLT_JUNIPER_GGSN:
+        case DLT_JUNIPER_ES:
+        case DLT_JUNIPER_MONITOR:
+        case DLT_JUNIPER_SERVICES:
+        case DLT_JUNIPER_ETHER:
+        case DLT_JUNIPER_PPP:
+        case DLT_JUNIPER_FRELAY:
+        case DLT_JUNIPER_CHDLC:

                /* just lets verify the magic number for now -
                 * on ATM we may have up to 6 different encapsulations on the wire
                 * and need a lot of heuristics to figure out that the payload
                /* just lets verify the magic number for now -
                 * on ATM we may have up to 6 different encapsulations on the wire
                 * and need a lot of heuristics to figure out that the payload


@@ -1849,7 +2325,7 @@ gen_linktype(proto)
                 *
                 * FIXME encapsulation specific BPF_ filters
                 */
                 *
                 * FIXME encapsulation specific BPF_ filters
                 */

-               return gen_mcmp(0, BPF_W, 0x4d474300, 0xffffff00); /* compare the magic number */
+               return gen_mcmp(OR_LINK, 0, BPF_W, 0x4d474300, 0xffffff00); /* compare the magic number */

 
        case DLT_LINUX_IRDA:
                bpf_error("IrDA link-layer type filtering not implemented");
 
        case DLT_LINUX_IRDA:
                bpf_error("IrDA link-layer type filtering not implemented");


@@ -1883,7 +2359,7 @@ gen_linktype(proto)
         * at "off_linktype", so we don't have to do the code generation
         * above.)
         */
         * at "off_linktype", so we don't have to do the code generation
         * above.)
         */

-       return gen_cmp(off_linktype, BPF_H, (bpf_int32)proto);
+       return gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);

 }
 
 /*
 }
 
 /*


@@ -1909,7 +2385,7 @@ gen_snap(orgcode, ptype, offset)
        snapblock[5] = (orgcode >> 0);  /* lower 8 bits of organization code */
        snapblock[6] = (ptype >> 8);    /* upper 8 bits of protocol type */
        snapblock[7] = (ptype >> 0);    /* lower 8 bits of protocol type */
        snapblock[5] = (orgcode >> 0);  /* lower 8 bits of organization code */
        snapblock[6] = (ptype >> 8);    /* upper 8 bits of protocol type */
        snapblock[7] = (ptype >> 0);    /* lower 8 bits of protocol type */

-       return gen_bcmp(offset, 8, snapblock);
+       return gen_bcmp(OR_LINK, offset, 8, snapblock);

 }
 
 /*
 }
 
 /*


@@ -1942,7 +2418,7 @@ gen_llc_linktype(proto)
                 * DSAP, as we do for other types <= ETHERMTU
                 * (i.e., other SAP values)?
                 */
                 * DSAP, as we do for other types <= ETHERMTU
                 * (i.e., other SAP values)?
                 */

-               return gen_cmp(off_linktype, BPF_H, (long)
+               return gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_u_int32)

                             ((proto << 8) | proto));
 
        case LLCSAP_IPX:
                             ((proto << 8) | proto));
 
        case LLCSAP_IPX:


@@ -1950,7 +2426,8 @@ gen_llc_linktype(proto)
                 * XXX - are there ever SNAP frames for IPX on
                 * non-Ethernet 802.x networks?
                 */
                 * XXX - are there ever SNAP frames for IPX on
                 * non-Ethernet 802.x networks?
                 */

-               return gen_cmp(off_linktype, BPF_B, (bpf_int32)LLCSAP_IPX);
+               return gen_cmp(OR_LINK, off_linktype, BPF_B,
+                   (bpf_int32)LLCSAP_IPX);

 
        case ETHERTYPE_ATALK:
                /*
 
        case ETHERTYPE_ATALK:
                /*


@@ -1974,7 +2451,8 @@ gen_llc_linktype(proto)
                         * This is an LLC SAP value, so check
                         * the DSAP.
                         */
                         * This is an LLC SAP value, so check
                         * the DSAP.
                         */

-                       return gen_cmp(off_linktype, BPF_B, (bpf_int32)proto);
+                       return gen_cmp(OR_LINK, off_linktype, BPF_B,
+                           (bpf_int32)proto);

                } else {
                        /*
                         * This is an Ethernet type; we assume that it's
                } else {
                        /*
                         * This is an Ethernet type; we assume that it's


@@ -1996,7 +2474,8 @@ gen_llc_linktype(proto)
                         * I don't know whether it's worth the extra CPU
                         * time to do the right check or not.
                         */
                         * I don't know whether it's worth the extra CPU
                         * time to do the right check or not.
                         */

-                       return gen_cmp(off_linktype+6, BPF_H, (bpf_int32)proto);
+                       return gen_cmp(OR_LINK, off_linktype+6, BPF_H,
+                           (bpf_int32)proto);

                }
        }
 }
                }
        }
 }


@@ -2038,7 +2517,7 @@ gen_hostop(addr, mask, dir, proto, src_off, dst_off)
                abort();
        }
        b0 = gen_linktype(proto);
                abort();
        }
        b0 = gen_linktype(proto);

-       b1 = gen_mcmp(offset, BPF_W, (bpf_int32)addr, mask);
+       b1 = gen_mcmp(OR_NET, offset, BPF_W, (bpf_int32)addr, mask);

        gen_and(b0, b1);
        return b1;
 }
        gen_and(b0, b1);
        return b1;
 }


@@ -2084,12 +2563,12 @@ gen_hostop6(addr, mask, dir, proto, src_off, dst_off)
        /* this order is important */
        a = (u_int32_t *)addr;
        m = (u_int32_t *)mask;
        /* this order is important */
        a = (u_int32_t *)addr;
        m = (u_int32_t *)mask;

-       b1 = gen_mcmp(offset + 12, BPF_W, ntohl(a[3]), ntohl(m[3]));
-       b0 = gen_mcmp(offset + 8, BPF_W, ntohl(a[2]), ntohl(m[2]));
+       b1 = gen_mcmp(OR_NET, offset + 12, BPF_W, ntohl(a[3]), ntohl(m[3]));
+       b0 = gen_mcmp(OR_NET, offset + 8, BPF_W, ntohl(a[2]), ntohl(m[2]));

        gen_and(b0, b1);
        gen_and(b0, b1);

-       b0 = gen_mcmp(offset + 4, BPF_W, ntohl(a[1]), ntohl(m[1]));
+       b0 = gen_mcmp(OR_NET, offset + 4, BPF_W, ntohl(a[1]), ntohl(m[1]));

        gen_and(b0, b1);
        gen_and(b0, b1);

-       b0 = gen_mcmp(offset + 0, BPF_W, ntohl(a[0]), ntohl(m[0]));
+       b0 = gen_mcmp(OR_NET, offset + 0, BPF_W, ntohl(a[0]), ntohl(m[0]));

        gen_and(b0, b1);
        b0 = gen_linktype(proto);
        gen_and(b0, b1);
        gen_and(b0, b1);
        b0 = gen_linktype(proto);
        gen_and(b0, b1);


@@ -2106,10 +2585,10 @@ gen_ehostop(eaddr, dir)
 
        switch (dir) {
        case Q_SRC:
 
        switch (dir) {
        case Q_SRC:

-               return gen_bcmp(off_mac + 6, 6, eaddr);
+               return gen_bcmp(OR_LINK, off_mac + 6, 6, eaddr);

 
        case Q_DST:
 
        case Q_DST:

-               return gen_bcmp(off_mac + 0, 6, eaddr);
+               return gen_bcmp(OR_LINK, off_mac + 0, 6, eaddr);

 
        case Q_AND:
                b0 = gen_ehostop(eaddr, Q_SRC);
 
        case Q_AND:
                b0 = gen_ehostop(eaddr, Q_SRC);


@@ -2141,16 +2620,16 @@ gen_fhostop(eaddr, dir)
        switch (dir) {
        case Q_SRC:
 #ifdef PCAP_FDDIPAD
        switch (dir) {
        case Q_SRC:
 #ifdef PCAP_FDDIPAD

-               return gen_bcmp(6 + 1 + pcap_fddipad, 6, eaddr);
+               return gen_bcmp(OR_LINK, 6 + 1 + pcap_fddipad, 6, eaddr);

 #else
 #else

-               return gen_bcmp(6 + 1, 6, eaddr);
+               return gen_bcmp(OR_LINK, 6 + 1, 6, eaddr);

 #endif
 
        case Q_DST:
 #ifdef PCAP_FDDIPAD
 #endif
 
        case Q_DST:
 #ifdef PCAP_FDDIPAD

-               return gen_bcmp(0 + 1 + pcap_fddipad, 6, eaddr);
+               return gen_bcmp(OR_LINK, 0 + 1 + pcap_fddipad, 6, eaddr);

 #else
 #else

-               return gen_bcmp(0 + 1, 6, eaddr);
+               return gen_bcmp(OR_LINK, 0 + 1, 6, eaddr);

 #endif
 
        case Q_AND:
 #endif
 
        case Q_AND:


@@ -2182,10 +2661,10 @@ gen_thostop(eaddr, dir)
 
        switch (dir) {
        case Q_SRC:
 
        switch (dir) {
        case Q_SRC:

-               return gen_bcmp(8, 6, eaddr);
+               return gen_bcmp(OR_LINK, 8, 6, eaddr);

 
        case Q_DST:
 
        case Q_DST:

-               return gen_bcmp(2, 6, eaddr);
+               return gen_bcmp(OR_LINK, 2, 6, eaddr);

 
        case Q_AND:
                b0 = gen_thostop(eaddr, Q_SRC);
 
        case Q_AND:
                b0 = gen_thostop(eaddr, Q_SRC);


@@ -2242,8 +2721,7 @@ gen_wlanhostop(eaddr, dir)
                 *
                 * First, check for To DS set, i.e. check "link[1] & 0x01".
                 */
                 *
                 * First, check for To DS set, i.e. check "link[1] & 0x01".
                 */

-               s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-               s->s.k = 1;
+               s = gen_load_a(OR_LINK, 1, BPF_B);

                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x01; /* To DS */
                b1->stmts = s;
                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x01; /* To DS */
                b1->stmts = s;


@@ -2251,15 +2729,14 @@ gen_wlanhostop(eaddr, dir)
                /*
                 * If To DS is set, the SA is at 24.
                 */
                /*
                 * If To DS is set, the SA is at 24.
                 */

-               b0 = gen_bcmp(24, 6, eaddr);
+               b0 = gen_bcmp(OR_LINK, 24, 6, eaddr);

                gen_and(b1, b0);
 
                /*
                 * Now, check for To DS not set, i.e. check
                 * "!(link[1] & 0x01)".
                 */
                gen_and(b1, b0);
 
                /*
                 * Now, check for To DS not set, i.e. check
                 * "!(link[1] & 0x01)".
                 */

-               s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-               s->s.k = 1;
+               s = gen_load_a(OR_LINK, 1, BPF_B);

                b2 = new_block(JMP(BPF_JSET));
                b2->s.k = 0x01; /* To DS */
                b2->stmts = s;
                b2 = new_block(JMP(BPF_JSET));
                b2->s.k = 0x01; /* To DS */
                b2->stmts = s;


@@ -2268,7 +2745,7 @@ gen_wlanhostop(eaddr, dir)
                /*
                 * If To DS is not set, the SA is at 16.
                 */
                /*
                 * If To DS is not set, the SA is at 16.
                 */

-               b1 = gen_bcmp(16, 6, eaddr);
+               b1 = gen_bcmp(OR_LINK, 16, 6, eaddr);

                gen_and(b2, b1);
 
                /*
                gen_and(b2, b1);
 
                /*


@@ -2282,8 +2759,7 @@ gen_wlanhostop(eaddr, dir)
                 * Now check for From DS being set, and AND that with
                 * the ORed-together checks.
                 */
                 * Now check for From DS being set, and AND that with
                 * the ORed-together checks.
                 */

-               s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-               s->s.k = 1;
+               s = gen_load_a(OR_LINK, 1, BPF_B);

                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x02; /* From DS */
                b1->stmts = s;
                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x02; /* From DS */
                b1->stmts = s;


@@ -2292,8 +2768,7 @@ gen_wlanhostop(eaddr, dir)
                /*
                 * Now check for data frames with From DS not set.
                 */
                /*
                 * Now check for data frames with From DS not set.
                 */

-               s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-               s->s.k = 1;
+               s = gen_load_a(OR_LINK, 1, BPF_B);

                b2 = new_block(JMP(BPF_JSET));
                b2->s.k = 0x02; /* From DS */
                b2->stmts = s;
                b2 = new_block(JMP(BPF_JSET));
                b2->s.k = 0x02; /* From DS */
                b2->stmts = s;


@@ -2302,7 +2777,7 @@ gen_wlanhostop(eaddr, dir)
                /*
                 * If From DS isn't set, the SA is at 10.
                 */
                /*
                 * If From DS isn't set, the SA is at 10.
                 */

-               b1 = gen_bcmp(10, 6, eaddr);
+               b1 = gen_bcmp(OR_LINK, 10, 6, eaddr);

                gen_and(b2, b1);
 
                /*
                gen_and(b2, b1);
 
                /*


@@ -2316,8 +2791,7 @@ gen_wlanhostop(eaddr, dir)
                 * Now check for a data frame.
                 * I.e, check "link[0] & 0x08".
                 */
                 * Now check for a data frame.
                 * I.e, check "link[0] & 0x08".
                 */

-               s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-               s->s.k = 0;
+               gen_load_a(OR_LINK, 0, BPF_B);

                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x08;
                b1->stmts = s;
                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x08;
                b1->stmts = s;


@@ -2332,8 +2806,7 @@ gen_wlanhostop(eaddr, dir)
                 * is a management frame.
                 * I.e, check "!(link[0] & 0x08)".
                 */
                 * is a management frame.
                 * I.e, check "!(link[0] & 0x08)".
                 */

-               s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-               s->s.k = 0;
+               s = gen_load_a(OR_LINK, 0, BPF_B);

                b2 = new_block(JMP(BPF_JSET));
                b2->s.k = 0x08;
                b2->stmts = s;
                b2 = new_block(JMP(BPF_JSET));
                b2->s.k = 0x08;
                b2->stmts = s;


@@ -2342,7 +2815,7 @@ gen_wlanhostop(eaddr, dir)
                /*
                 * For management frames, the SA is at 10.
                 */
                /*
                 * For management frames, the SA is at 10.
                 */

-               b1 = gen_bcmp(10, 6, eaddr);
+               b1 = gen_bcmp(OR_LINK, 10, 6, eaddr);

                gen_and(b2, b1);
 
                /*
                gen_and(b2, b1);
 
                /*


@@ -2360,8 +2833,7 @@ gen_wlanhostop(eaddr, dir)
                 *
                 * I.e., check "!(link[0] & 0x04)".
                 */
                 *
                 * I.e., check "!(link[0] & 0x04)".
                 */

-               s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-               s->s.k = 0;
+               s = gen_load_a(OR_LINK, 0, BPF_B);

                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x04;
                b1->stmts = s;
                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x04;
                b1->stmts = s;


@@ -2396,8 +2868,7 @@ gen_wlanhostop(eaddr, dir)
                 *
                 * First, check for To DS set, i.e. "link[1] & 0x01".
                 */
                 *
                 * First, check for To DS set, i.e. "link[1] & 0x01".
                 */

-               s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-               s->s.k = 1;
+               s = gen_load_a(OR_LINK, 1, BPF_B);

                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x01; /* To DS */
                b1->stmts = s;
                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x01; /* To DS */
                b1->stmts = s;


@@ -2405,15 +2876,14 @@ gen_wlanhostop(eaddr, dir)
                /*
                 * If To DS is set, the DA is at 16.
                 */
                /*
                 * If To DS is set, the DA is at 16.
                 */

-               b0 = gen_bcmp(16, 6, eaddr);
+               b0 = gen_bcmp(OR_LINK, 16, 6, eaddr);

                gen_and(b1, b0);
 
                /*
                 * Now, check for To DS not set, i.e. check
                 * "!(link[1] & 0x01)".
                 */
                gen_and(b1, b0);
 
                /*
                 * Now, check for To DS not set, i.e. check
                 * "!(link[1] & 0x01)".
                 */

-               s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-               s->s.k = 1;
+               s = gen_load_a(OR_LINK, 1, BPF_B);

                b2 = new_block(JMP(BPF_JSET));
                b2->s.k = 0x01; /* To DS */
                b2->stmts = s;
                b2 = new_block(JMP(BPF_JSET));
                b2->s.k = 0x01; /* To DS */
                b2->stmts = s;


@@ -2422,7 +2892,7 @@ gen_wlanhostop(eaddr, dir)
                /*
                 * If To DS is not set, the DA is at 4.
                 */
                /*
                 * If To DS is not set, the DA is at 4.
                 */

-               b1 = gen_bcmp(4, 6, eaddr);
+               b1 = gen_bcmp(OR_LINK, 4, 6, eaddr);

                gen_and(b2, b1);
 
                /*
                gen_and(b2, b1);
 
                /*


@@ -2435,8 +2905,7 @@ gen_wlanhostop(eaddr, dir)
                 * Now check for a data frame.
                 * I.e, check "link[0] & 0x08".
                 */
                 * Now check for a data frame.
                 * I.e, check "link[0] & 0x08".
                 */

-               s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-               s->s.k = 0;
+               s = gen_load_a(OR_LINK, 0, BPF_B);

                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x08;
                b1->stmts = s;
                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x08;
                b1->stmts = s;


@@ -2451,8 +2920,7 @@ gen_wlanhostop(eaddr, dir)
                 * is a management frame.
                 * I.e, check "!(link[0] & 0x08)".
                 */
                 * is a management frame.
                 * I.e, check "!(link[0] & 0x08)".
                 */

-               s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-               s->s.k = 0;
+               s = gen_load_a(OR_LINK, 0, BPF_B);

                b2 = new_block(JMP(BPF_JSET));
                b2->s.k = 0x08;
                b2->stmts = s;
                b2 = new_block(JMP(BPF_JSET));
                b2->s.k = 0x08;
                b2->stmts = s;


@@ -2461,7 +2929,7 @@ gen_wlanhostop(eaddr, dir)
                /*
                 * For management frames, the DA is at 4.
                 */
                /*
                 * For management frames, the DA is at 4.
                 */

-               b1 = gen_bcmp(4, 6, eaddr);
+               b1 = gen_bcmp(OR_LINK, 4, 6, eaddr);

                gen_and(b2, b1);
 
                /*
                gen_and(b2, b1);
 
                /*


@@ -2479,8 +2947,7 @@ gen_wlanhostop(eaddr, dir)
                 *
                 * I.e., check "!(link[0] & 0x04)".
                 */
                 *
                 * I.e., check "!(link[0] & 0x04)".
                 */

-               s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-               s->s.k = 0;
+               s = gen_load_a(OR_LINK, 0, BPF_B);

                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x04;
                b1->stmts = s;
                b1 = new_block(JMP(BPF_JSET));
                b1->s.k = 0x04;
                b1->stmts = s;


@@ -2524,10 +2991,10 @@ gen_ipfchostop(eaddr, dir)
 
        switch (dir) {
        case Q_SRC:
 
        switch (dir) {
        case Q_SRC:

-               return gen_bcmp(10, 6, eaddr);
+               return gen_bcmp(OR_LINK, 10, 6, eaddr);

 
        case Q_DST:
 
        case Q_DST:

-               return gen_bcmp(2, 6, eaddr);
+               return gen_bcmp(OR_LINK, 2, 6, eaddr);

 
        case Q_AND:
                b0 = gen_ipfchostop(eaddr, Q_SRC);
 
        case Q_AND:
                b0 = gen_ipfchostop(eaddr, Q_SRC);


@@ -2565,10 +3032,9 @@ gen_ipfchostop(eaddr, dir)
  * and not generate masking instructions if the mask is 0xFFFF.
  */
 static struct block *
  * and not generate masking instructions if the mask is 0xFFFF.
  */
 static struct block *

-gen_dnhostop(addr, dir, base_off)
+gen_dnhostop(addr, dir)

        bpf_u_int32 addr;
        int dir;
        bpf_u_int32 addr;
        int dir;

-       u_int base_off;

 {
        struct block *b0, *b1, *b2, *tmp;
        u_int offset_lh;        /* offset if long header is received */
 {
        struct block *b0, *b1, *b2, *tmp;
        u_int offset_lh;        /* offset if long header is received */


@@ -2588,16 +3054,16 @@ gen_dnhostop(addr, dir, base_off)
 
        case Q_AND:
                /* Inefficient because we do our Calvinball dance twice */
 
        case Q_AND:
                /* Inefficient because we do our Calvinball dance twice */

-               b0 = gen_dnhostop(addr, Q_SRC, base_off);
-               b1 = gen_dnhostop(addr, Q_DST, base_off);
+               b0 = gen_dnhostop(addr, Q_SRC);
+               b1 = gen_dnhostop(addr, Q_DST);

                gen_and(b0, b1);
                return b1;
 
        case Q_OR:
        case Q_DEFAULT:
                /* Inefficient because we do our Calvinball dance twice */
                gen_and(b0, b1);
                return b1;
 
        case Q_OR:
        case Q_DEFAULT:
                /* Inefficient because we do our Calvinball dance twice */

-               b0 = gen_dnhostop(addr, Q_SRC, base_off);
-               b1 = gen_dnhostop(addr, Q_DST, base_off);
+               b0 = gen_dnhostop(addr, Q_SRC);
+               b1 = gen_dnhostop(addr, Q_DST);

                gen_or(b0, b1);
                return b1;
 
                gen_or(b0, b1);
                return b1;
 


@@ -2609,26 +3075,25 @@ gen_dnhostop(addr, dir, base_off)
        }
        b0 = gen_linktype(ETHERTYPE_DN);
        /* Check for pad = 1, long header case */
        }
        b0 = gen_linktype(ETHERTYPE_DN);
        /* Check for pad = 1, long header case */

-       tmp = gen_mcmp(base_off + 2, BPF_H,
+       tmp = gen_mcmp(OR_NET, 2, BPF_H,

            (bpf_int32)ntohs(0x0681), (bpf_int32)ntohs(0x07FF));
            (bpf_int32)ntohs(0x0681), (bpf_int32)ntohs(0x07FF));

-       b1 = gen_cmp(base_off + 2 + 1 + offset_lh,
+       b1 = gen_cmp(OR_NET, 2 + 1 + offset_lh,

            BPF_H, (bpf_int32)ntohs(addr));
        gen_and(tmp, b1);
        /* Check for pad = 0, long header case */
            BPF_H, (bpf_int32)ntohs(addr));
        gen_and(tmp, b1);
        /* Check for pad = 0, long header case */

-       tmp = gen_mcmp(base_off + 2, BPF_B, (bpf_int32)0x06, (bpf_int32)0x7);
-       b2 = gen_cmp(base_off + 2 + offset_lh, BPF_H, (bpf_int32)ntohs(addr));
+       tmp = gen_mcmp(OR_NET, 2, BPF_B, (bpf_int32)0x06, (bpf_int32)0x7);
+       b2 = gen_cmp(OR_NET, 2 + offset_lh, BPF_H, (bpf_int32)ntohs(addr));

        gen_and(tmp, b2);
        gen_or(b2, b1);
        /* Check for pad = 1, short header case */
        gen_and(tmp, b2);
        gen_or(b2, b1);
        /* Check for pad = 1, short header case */

-       tmp = gen_mcmp(base_off + 2, BPF_H,
+       tmp = gen_mcmp(OR_NET, 2, BPF_H,

            (bpf_int32)ntohs(0x0281), (bpf_int32)ntohs(0x07FF));
            (bpf_int32)ntohs(0x0281), (bpf_int32)ntohs(0x07FF));

-       b2 = gen_cmp(base_off + 2 + 1 + offset_sh,
-           BPF_H, (bpf_int32)ntohs(addr));
+       b2 = gen_cmp(OR_NET, 2 + 1 + offset_sh, BPF_H, (bpf_int32)ntohs(addr));

        gen_and(tmp, b2);
        gen_or(b2, b1);
        /* Check for pad = 0, short header case */
        gen_and(tmp, b2);
        gen_or(b2, b1);
        /* Check for pad = 0, short header case */

-       tmp = gen_mcmp(base_off + 2, BPF_B, (bpf_int32)0x02, (bpf_int32)0x7);
-       b2 = gen_cmp(base_off + 2 + offset_sh, BPF_H, (bpf_int32)ntohs(addr));
+       tmp = gen_mcmp(OR_NET, 2, BPF_B, (bpf_int32)0x02, (bpf_int32)0x7);
+       b2 = gen_cmp(OR_NET, 2 + offset_sh, BPF_H, (bpf_int32)ntohs(addr));

        gen_and(tmp, b2);
        gen_or(b2, b1);
 
        gen_and(tmp, b2);
        gen_or(b2, b1);
 


@@ -2637,62 +3102,104 @@ gen_dnhostop(addr, dir, base_off)
        return b1;
 }
 
        return b1;
 }
 

+/*
+ * Generate a check for IPv4 or IPv6 for MPLS-encapsulated packets;
+ * test the bottom-of-stack bit, and then check the version number
+ * field in the IP header.
+ */

 static struct block *
 static struct block *

-gen_host(addr, mask, proto, dir)
+gen_mpls_linktype(proto)
+       int proto;
+{
+       struct block *b0, *b1;
+
+        switch (proto) {
+
+        case Q_IP:
+                /* match the bottom-of-stack bit */
+                b0 = gen_mcmp(OR_NET, -2, BPF_B, 0x01, 0x01);
+                /* match the IPv4 version number */
+                b1 = gen_mcmp(OR_NET, 0, BPF_B, 0x40, 0xf0);
+                gen_and(b0, b1);
+                return b1;
+ 
+       case Q_IPV6:
+                /* match the bottom-of-stack bit */
+                b0 = gen_mcmp(OR_NET, -2, BPF_B, 0x01, 0x01);
+                /* match the IPv4 version number */
+                b1 = gen_mcmp(OR_NET, 0, BPF_B, 0x60, 0xf0);
+                gen_and(b0, b1);
+                return b1;
+ 
+       default:
+                abort();
+        }
+}
+
+static struct block *
+gen_host(addr, mask, proto, dir, type)

        bpf_u_int32 addr;
        bpf_u_int32 mask;
        int proto;
        int dir;
        bpf_u_int32 addr;
        bpf_u_int32 mask;
        int proto;
        int dir;

+       int type;

 {
        struct block *b0, *b1;
 {
        struct block *b0, *b1;

+       const char *typestr;
+
+       if (type == Q_NET)
+               typestr = "net";
+       else
+               typestr = "host";

 
        switch (proto) {
 
        case Q_DEFAULT:
 
        switch (proto) {
 
        case Q_DEFAULT:

-               b0 = gen_host(addr, mask, Q_IP, dir);
-               if (off_linktype != (u_int)-1) {
-                   b1 = gen_host(addr, mask, Q_ARP, dir);
-                   gen_or(b0, b1);
-                   b0 = gen_host(addr, mask, Q_RARP, dir);
-                   gen_or(b1, b0);
+               b0 = gen_host(addr, mask, Q_IP, dir, type);
+               /*
+                * Only check for non-IPv4 addresses if we're not
+                * checking MPLS-encapsulated packets.
+                */
+               if (label_stack_depth == 0) {
+                       b1 = gen_host(addr, mask, Q_ARP, dir, type);
+                       gen_or(b0, b1);
+                       b0 = gen_host(addr, mask, Q_RARP, dir, type);
+                       gen_or(b1, b0);

                }
                return b0;
 
        case Q_IP:
                }
                return b0;
 
        case Q_IP:

-               return gen_hostop(addr, mask, dir, ETHERTYPE_IP,
-                                 off_nl + 12, off_nl + 16);
+               return gen_hostop(addr, mask, dir, ETHERTYPE_IP, 12, 16);

 
        case Q_RARP:
 
        case Q_RARP:

-               return gen_hostop(addr, mask, dir, ETHERTYPE_REVARP,
-                                 off_nl + 14, off_nl + 24);
+               return gen_hostop(addr, mask, dir, ETHERTYPE_REVARP, 14, 24);

 
        case Q_ARP:
 
        case Q_ARP:

-               return gen_hostop(addr, mask, dir, ETHERTYPE_ARP,
-                                 off_nl + 14, off_nl + 24);
+               return gen_hostop(addr, mask, dir, ETHERTYPE_ARP, 14, 24);

 
        case Q_TCP:
 
        case Q_TCP:

-               bpf_error("'tcp' modifier applied to host");
+               bpf_error("'tcp' modifier applied to %s", typestr);

 
        case Q_SCTP:
 
        case Q_SCTP:

-               bpf_error("'sctp' modifier applied to host");
+               bpf_error("'sctp' modifier applied to %s", typestr);

 
        case Q_UDP:
 
        case Q_UDP:

-               bpf_error("'udp' modifier applied to host");
+               bpf_error("'udp' modifier applied to %s", typestr);

 
        case Q_ICMP:
 
        case Q_ICMP:

-               bpf_error("'icmp' modifier applied to host");
+               bpf_error("'icmp' modifier applied to %s", typestr);

 
        case Q_IGMP:
 
        case Q_IGMP:

-               bpf_error("'igmp' modifier applied to host");
+               bpf_error("'igmp' modifier applied to %s", typestr);

 
        case Q_IGRP:
 
        case Q_IGRP:

-               bpf_error("'igrp' modifier applied to host");
+               bpf_error("'igrp' modifier applied to %s", typestr);

 
        case Q_PIM:
 
        case Q_PIM:

-               bpf_error("'pim' modifier applied to host");
+               bpf_error("'pim' modifier applied to %s", typestr);

 
        case Q_VRRP:
 
        case Q_VRRP:

-               bpf_error("'vrrp' modifier applied to host");
+               bpf_error("'vrrp' modifier applied to %s", typestr);

 
        case Q_ATALK:
                bpf_error("ATALK host filtering not implemented");
 
        case Q_ATALK:
                bpf_error("ATALK host filtering not implemented");


@@ -2701,7 +3208,7 @@ gen_host(addr, mask, proto, dir)
                bpf_error("AARP host filtering not implemented");
 
        case Q_DECNET:
                bpf_error("AARP host filtering not implemented");
 
        case Q_DECNET:

-               return gen_dnhostop(addr, dir, off_nl);
+               return gen_dnhostop(addr, dir);

 
        case Q_SCA:
                bpf_error("SCA host filtering not implemented");
 
        case Q_SCA:
                bpf_error("SCA host filtering not implemented");


@@ -2720,35 +3227,38 @@ gen_host(addr, mask, proto, dir)
                bpf_error("'ip6' modifier applied to ip host");
 
        case Q_ICMPV6:
                bpf_error("'ip6' modifier applied to ip host");
 
        case Q_ICMPV6:

-               bpf_error("'icmp6' modifier applied to host");
+               bpf_error("'icmp6' modifier applied to %s", typestr);

 #endif /* INET6 */
 
        case Q_AH:
 #endif /* INET6 */
 
        case Q_AH:

-               bpf_error("'ah' modifier applied to host");
+               bpf_error("'ah' modifier applied to %s", typestr);

 
        case Q_ESP:
 
        case Q_ESP:

-               bpf_error("'esp' modifier applied to host");
+               bpf_error("'esp' modifier applied to %s", typestr);

 
        case Q_ISO:
                bpf_error("ISO host filtering not implemented");
 
        case Q_ESIS:
 
        case Q_ISO:
                bpf_error("ISO host filtering not implemented");
 
        case Q_ESIS:

-               bpf_error("'esis' modifier applied to host");
+               bpf_error("'esis' modifier applied to %s", typestr);

 
        case Q_ISIS:
 
        case Q_ISIS:

-               bpf_error("'isis' modifier applied to host");
+               bpf_error("'isis' modifier applied to %s", typestr);

 
        case Q_CLNP:
 
        case Q_CLNP:

-               bpf_error("'clnp' modifier applied to host");
+               bpf_error("'clnp' modifier applied to %s", typestr);

 
        case Q_STP:
 
        case Q_STP:

-               bpf_error("'stp' modifier applied to host");
+               bpf_error("'stp' modifier applied to %s", typestr);

 
        case Q_IPX:
                bpf_error("IPX host filtering not implemented");
 
        case Q_NETBEUI:
 
        case Q_IPX:
                bpf_error("IPX host filtering not implemented");
 
        case Q_NETBEUI:

-               bpf_error("'netbeui' modifier applied to host");
+               bpf_error("'netbeui' modifier applied to %s", typestr);
+
+       case Q_RADIO:
+               bpf_error("'radio' modifier applied to %s", typestr);

 
        default:
                abort();
 
        default:
                abort();


@@ -2758,49 +3268,57 @@ gen_host(addr, mask, proto, dir)
 
 #ifdef INET6
 static struct block *
 
 #ifdef INET6
 static struct block *

-gen_host6(addr, mask, proto, dir)
+gen_host6(addr, mask, proto, dir, type)

        struct in6_addr *addr;
        struct in6_addr *mask;
        int proto;
        int dir;
        struct in6_addr *addr;
        struct in6_addr *mask;
        int proto;
        int dir;

+       int type;

 {
 {

+       const char *typestr;
+
+       if (type == Q_NET)
+               typestr = "net";
+       else
+               typestr = "host";
+

        switch (proto) {
 
        case Q_DEFAULT:
        switch (proto) {
 
        case Q_DEFAULT:

-               return gen_host6(addr, mask, Q_IPV6, dir);
+               return gen_host6(addr, mask, Q_IPV6, dir, type);

 
        case Q_IP:
 
        case Q_IP:

-               bpf_error("'ip' modifier applied to ip6 host");
+               bpf_error("'ip' modifier applied to ip6 %s", typestr);

 
        case Q_RARP:
 
        case Q_RARP:

-               bpf_error("'rarp' modifier applied to ip6 host");
+               bpf_error("'rarp' modifier applied to ip6 %s", typestr);

 
        case Q_ARP:
 
        case Q_ARP:

-               bpf_error("'arp' modifier applied to ip6 host");
+               bpf_error("'arp' modifier applied to ip6 %s", typestr);

 
        case Q_SCTP:
 
        case Q_SCTP:

-               bpf_error("'sctp' modifier applied to host");
+               bpf_error("'sctp' modifier applied to %s", typestr);

 
        case Q_TCP:
 
        case Q_TCP:

-               bpf_error("'tcp' modifier applied to host");
+               bpf_error("'tcp' modifier applied to %s", typestr);

 
        case Q_UDP:
 
        case Q_UDP:

-               bpf_error("'udp' modifier applied to host");
+               bpf_error("'udp' modifier applied to %s", typestr);

 
        case Q_ICMP:
 
        case Q_ICMP:

-               bpf_error("'icmp' modifier applied to host");
+               bpf_error("'icmp' modifier applied to %s", typestr);

 
        case Q_IGMP:
 
        case Q_IGMP:

-               bpf_error("'igmp' modifier applied to host");
+               bpf_error("'igmp' modifier applied to %s", typestr);

 
        case Q_IGRP:
 
        case Q_IGRP:

-               bpf_error("'igrp' modifier applied to host");
+               bpf_error("'igrp' modifier applied to %s", typestr);

 
        case Q_PIM:
 
        case Q_PIM:

-               bpf_error("'pim' modifier applied to host");
+               bpf_error("'pim' modifier applied to %s", typestr);

 
        case Q_VRRP:
 
        case Q_VRRP:

-               bpf_error("'vrrp' modifier applied to host");
+               bpf_error("'vrrp' modifier applied to %s", typestr);

 
        case Q_ATALK:
                bpf_error("ATALK host filtering not implemented");
 
        case Q_ATALK:
                bpf_error("ATALK host filtering not implemented");


@@ -2809,7 +3327,7 @@ gen_host6(addr, mask, proto, dir)
                bpf_error("AARP host filtering not implemented");
 
        case Q_DECNET:
                bpf_error("AARP host filtering not implemented");
 
        case Q_DECNET:

-               bpf_error("'decnet' modifier applied to ip6 host");
+               bpf_error("'decnet' modifier applied to ip6 %s", typestr);

 
        case Q_SCA:
                bpf_error("SCA host filtering not implemented");
 
        case Q_SCA:
                bpf_error("SCA host filtering not implemented");


@@ -2824,38 +3342,40 @@ gen_host6(addr, mask, proto, dir)
                bpf_error("MOPRC host filtering not implemented");
 
        case Q_IPV6:
                bpf_error("MOPRC host filtering not implemented");
 
        case Q_IPV6:

-               return gen_hostop6(addr, mask, dir, ETHERTYPE_IPV6,
-                                 off_nl + 8, off_nl + 24);
+               return gen_hostop6(addr, mask, dir, ETHERTYPE_IPV6, 8, 24);

 
        case Q_ICMPV6:
 
        case Q_ICMPV6:

-               bpf_error("'icmp6' modifier applied to host");
+               bpf_error("'icmp6' modifier applied to %s", typestr);

 
        case Q_AH:
 
        case Q_AH:

-               bpf_error("'ah' modifier applied to host");
+               bpf_error("'ah' modifier applied to %s", typestr);

 
        case Q_ESP:
 
        case Q_ESP:

-               bpf_error("'esp' modifier applied to host");
+               bpf_error("'esp' modifier applied to %s", typestr);

 
        case Q_ISO:
                bpf_error("ISO host filtering not implemented");
 
        case Q_ESIS:
 
        case Q_ISO:
                bpf_error("ISO host filtering not implemented");
 
        case Q_ESIS:

-               bpf_error("'esis' modifier applied to host");
+               bpf_error("'esis' modifier applied to %s", typestr);

 
        case Q_ISIS:
 
        case Q_ISIS:

-               bpf_error("'isis' modifier applied to host");
+               bpf_error("'isis' modifier applied to %s", typestr);

 
        case Q_CLNP:
 
        case Q_CLNP:

-               bpf_error("'clnp' modifier applied to host");
+               bpf_error("'clnp' modifier applied to %s", typestr);

 
        case Q_STP:
 
        case Q_STP:

-               bpf_error("'stp' modifier applied to host");
+               bpf_error("'stp' modifier applied to %s", typestr);

 
        case Q_IPX:
                bpf_error("IPX host filtering not implemented");
 
        case Q_NETBEUI:
 
        case Q_IPX:
                bpf_error("IPX host filtering not implemented");
 
        case Q_NETBEUI:

-               bpf_error("'netbeui' modifier applied to host");
+               bpf_error("'netbeui' modifier applied to %s", typestr);
+
+       case Q_RADIO:
+               bpf_error("'radio' modifier applied to %s", typestr);

 
        default:
                abort();
 
        default:
                abort();


@@ -2882,21 +3402,31 @@ gen_gateway(eaddr, alist, proto, dir)
        case Q_IP:
        case Q_ARP:
        case Q_RARP:
        case Q_IP:
        case Q_ARP:
        case Q_RARP:

-               if (linktype == DLT_EN10MB)
-                       b0 = gen_ehostop(eaddr, Q_OR);
-               else if (linktype == DLT_FDDI)
-                       b0 = gen_fhostop(eaddr, Q_OR);
-               else if (linktype == DLT_IEEE802)
-                       b0 = gen_thostop(eaddr, Q_OR);
-               else if (linktype == DLT_IEEE802_11)
-                       b0 = gen_wlanhostop(eaddr, Q_OR);
-               else if (linktype == DLT_SUNATM && is_lane) {
+                switch (linktype) {
+                case DLT_EN10MB:
+                    b0 = gen_ehostop(eaddr, Q_OR);
+                    break;
+                case DLT_FDDI:
+                    b0 = gen_fhostop(eaddr, Q_OR);
+                    break;
+               case DLT_IEEE802:
+                    b0 = gen_thostop(eaddr, Q_OR);
+                    break;
+               case DLT_IEEE802_11:
+               case DLT_IEEE802_11_RADIO_AVS:
+               case DLT_IEEE802_11_RADIO:
+               case DLT_PRISM_HEADER:
+                    b0 = gen_wlanhostop(eaddr, Q_OR);
+                    break;
+                case DLT_SUNATM:
+                    if (is_lane) {

                        /*
                         * Check that the packet doesn't begin with an
                         * LE Control marker.  (We've already generated
                         * a test for LANE.)
                         */
                        /*
                         * Check that the packet doesn't begin with an
                         * LE Control marker.  (We've already generated
                         * a test for LANE.)
                         */

-                       b1 = gen_cmp(SUNATM_PKT_BEGIN_POS, BPF_H, 0xFF00);
+                       b1 = gen_cmp(OR_LINK, SUNATM_PKT_BEGIN_POS, BPF_H,
+                           0xFF00);

                        gen_not(b1);
 
                        /*
                        gen_not(b1);
 
                        /*


@@ -2904,15 +3434,19 @@ gen_gateway(eaddr, alist, proto, dir)
                         */
                        b0 = gen_ehostop(eaddr, Q_OR);
                        gen_and(b1, b0);
                         */
                        b0 = gen_ehostop(eaddr, Q_OR);
                        gen_and(b1, b0);

-               } else if (linktype == DLT_IP_OVER_FC)
-                       b0 = gen_ipfchostop(eaddr, Q_OR);
-               else
-                       bpf_error(
+                    }
+                    break;
+               case DLT_IP_OVER_FC:
+                    b0 = gen_ipfchostop(eaddr, Q_OR);
+                    break;
+                default:
+                    bpf_error(

                            "'gateway' supported only on ethernet/FDDI/token ring/802.11/Fibre Channel");
                            "'gateway' supported only on ethernet/FDDI/token ring/802.11/Fibre Channel");

-
-               b1 = gen_host(**alist++, 0xffffffff, proto, Q_OR);
+                }
+               b1 = gen_host(**alist++, 0xffffffff, proto, Q_OR, Q_HOST);

                while (*alist) {
                while (*alist) {

-                       tmp = gen_host(**alist++, 0xffffffff, proto, Q_OR);
+                       tmp = gen_host(**alist++, 0xffffffff, proto, Q_OR,
+                           Q_HOST);

                        gen_or(b1, tmp);
                        b1 = tmp;
                }
                        gen_or(b1, tmp);
                        b1 = tmp;
                }


@@ -3084,9 +3618,7 @@ gen_proto_abbrev(proto)
                break;
 
        case Q_ISIS:
                break;
 
        case Q_ISIS:

-                b0 = gen_linktype(LLCSAP_ISONS);

                b1 = gen_proto(ISO10589_ISIS, Q_ISO, Q_DEFAULT);
                b1 = gen_proto(ISO10589_ISIS, Q_ISO, Q_DEFAULT);

-                gen_and(b0, b1);

                break;
 
        case Q_ISIS_L1: /* all IS-IS Level1 PDU-Types */
                break;
 
        case Q_ISIS_L1: /* all IS-IS Level1 PDU-Types */


@@ -3165,6 +3697,9 @@ gen_proto_abbrev(proto)
                b1 = gen_linktype(LLCSAP_NETBEUI);
                break;
 
                b1 = gen_linktype(LLCSAP_NETBEUI);
                break;
 

+       case Q_RADIO:
+               bpf_error("'radio' is not a valid protocol type");
+

        default:
                abort();
        }
        default:
                abort();
        }


@@ -3178,8 +3713,7 @@ gen_ipfrag()
        struct block *b;
 
        /* not ip frag */
        struct block *b;
 
        /* not ip frag */

-       s = new_stmt(BPF_LD|BPF_H|BPF_ABS);
-       s->s.k = off_nl + 6;
+       s = gen_load_a(OR_NET, 6, BPF_H);

        b = new_block(JMP(BPF_JSET));
        b->s.k = 0x1fff;
        b->stmts = s;
        b = new_block(JMP(BPF_JSET));
        b->s.k = 0x1fff;
        b->stmts = s;


@@ -3188,25 +3722,21 @@ gen_ipfrag()
        return b;
 }
 
        return b;
 }
 

+/*
+ * Generate a comparison to a port value in the transport-layer header
+ * at the specified offset from the beginning of that header.
+ *
+ * XXX - this handles a variable-length prefix preceding the link-layer
+ * header, such as the radiotap or AVS radio prefix, but doesn't handle
+ * variable-length link-layer headers (such as Token Ring or 802.11
+ * headers).
+ */

 static struct block *
 gen_portatom(off, v)
        int off;
        bpf_int32 v;
 {
 static struct block *
 gen_portatom(off, v)
        int off;
        bpf_int32 v;
 {

-       struct slist *s;
-       struct block *b;
-
-       s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
-       s->s.k = off_nl;
-
-       s->next = new_stmt(BPF_LD|BPF_IND|BPF_H);
-       s->next->s.k = off_nl + off;
-
-       b = new_block(JMP(BPF_JEQ));
-       b->stmts = s;
-       b->s.k = v;
-
-       return b;
+       return gen_cmp(OR_TRAN_IPV4, off, BPF_H, v);

 }
 
 #ifdef INET6
 }
 
 #ifdef INET6


@@ -3215,7 +3745,7 @@ gen_portatom6(off, v)
        int off;
        bpf_int32 v;
 {
        int off;
        bpf_int32 v;
 {

-       return gen_cmp(off_nl + 40 + off, BPF_H, v);
+       return gen_cmp(OR_TRAN_IPV6, off, BPF_H, v);

 }
 #endif/*INET6*/
 
 }
 #endif/*INET6*/
 


@@ -3226,7 +3756,7 @@ gen_portop(port, proto, dir)
        struct block *b0, *b1, *tmp;
 
        /* ip proto 'proto' */
        struct block *b0, *b1, *tmp;
 
        /* ip proto 'proto' */

-       tmp = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)proto);
+       tmp = gen_cmp(OR_NET, 9, BPF_B, (bpf_int32)proto);

        b0 = gen_ipfrag();
        gen_and(tmp, b0);
 
        b0 = gen_ipfrag();
        gen_and(tmp, b0);
 


@@ -3316,8 +3846,8 @@ gen_portop6(port, proto, dir)
 {
        struct block *b0, *b1, *tmp;
 
 {
        struct block *b0, *b1, *tmp;
 

-       /* ip proto 'proto' */
-       b0 = gen_cmp(off_nl + 6, BPF_B, (bpf_int32)proto);
+       /* ip6 proto 'proto' */
+       b0 = gen_cmp(OR_NET, 6, BPF_B, (bpf_int32)proto);

 
        switch (dir) {
        case Q_SRC:
 
        switch (dir) {
        case Q_SRC:


@@ -3357,7 +3887,7 @@ gen_port6(port, ip_proto, dir)
 {
        struct block *b0, *b1, *tmp;
 
 {
        struct block *b0, *b1, *tmp;
 

-       /* ether proto ip */
+       /* link proto ip6 */

        b0 =  gen_linktype(ETHERTYPE_IPV6);
 
        switch (ip_proto) {
        b0 =  gen_linktype(ETHERTYPE_IPV6);
 
        switch (ip_proto) {


@@ -3383,6 +3913,211 @@ gen_port6(port, ip_proto, dir)
 }
 #endif /* INET6 */
 
 }
 #endif /* INET6 */
 

+/* gen_portrange code */
+static struct block *
+gen_portrangeatom(off, v1, v2)
+       int off;
+       bpf_int32 v1, v2;
+{
+       struct block *b1, *b2;
+
+       if (v1 > v2) {
+               /*
+                * Reverse the order of the ports, so v1 is the lower one.
+                */
+               bpf_int32 vtemp;
+
+               vtemp = v1;
+               v1 = v2;
+               v2 = vtemp;
+       }
+
+       b1 = gen_cmp_ge(OR_TRAN_IPV4, off, BPF_H, v1);
+       b2 = gen_cmp_le(OR_TRAN_IPV4, off, BPF_H, v2);
+
+       gen_and(b1, b2); 
+
+       return b2;
+}
+
+struct block *
+gen_portrangeop(port1, port2, proto, dir)
+       int port1, port2;
+       int proto;
+       int dir;
+{
+       struct block *b0, *b1, *tmp;
+
+       /* ip proto 'proto' */
+       tmp = gen_cmp(OR_NET, 9, BPF_B, (bpf_int32)proto);
+       b0 = gen_ipfrag();
+       gen_and(tmp, b0);
+
+       switch (dir) {
+       case Q_SRC:
+               b1 = gen_portrangeatom(0, (bpf_int32)port1, (bpf_int32)port2);
+               break;
+
+       case Q_DST:
+               b1 = gen_portrangeatom(2, (bpf_int32)port1, (bpf_int32)port2);
+               break;
+
+       case Q_OR:
+       case Q_DEFAULT:
+               tmp = gen_portrangeatom(0, (bpf_int32)port1, (bpf_int32)port2);
+               b1 = gen_portrangeatom(2, (bpf_int32)port1, (bpf_int32)port2);
+               gen_or(tmp, b1);
+               break;
+
+       case Q_AND:
+               tmp = gen_portrangeatom(0, (bpf_int32)port1, (bpf_int32)port2);
+               b1 = gen_portrangeatom(2, (bpf_int32)port1, (bpf_int32)port2);
+               gen_and(tmp, b1);
+               break;
+
+       default:
+               abort();
+       }
+       gen_and(b0, b1);
+
+       return b1;
+}
+
+static struct block *
+gen_portrange(port1, port2, ip_proto, dir)
+       int port1, port2;
+       int ip_proto;
+       int dir;
+{
+       struct block *b0, *b1, *tmp;
+
+       /* link proto ip */
+       b0 =  gen_linktype(ETHERTYPE_IP);
+
+       switch (ip_proto) {
+       case IPPROTO_UDP:
+       case IPPROTO_TCP:
+       case IPPROTO_SCTP:
+               b1 = gen_portrangeop(port1, port2, ip_proto, dir);
+               break;
+
+       case PROTO_UNDEF:
+               tmp = gen_portrangeop(port1, port2, IPPROTO_TCP, dir);
+               b1 = gen_portrangeop(port1, port2, IPPROTO_UDP, dir);
+               gen_or(tmp, b1);
+               tmp = gen_portrangeop(port1, port2, IPPROTO_SCTP, dir);
+               gen_or(tmp, b1);
+               break;
+
+       default:
+               abort();
+       }
+       gen_and(b0, b1);
+       return b1;
+}
+
+#ifdef INET6
+static struct block *
+gen_portrangeatom6(off, v1, v2)
+       int off;
+       bpf_int32 v1, v2;
+{
+       struct block *b1, *b2;
+
+       if (v1 > v2) {
+               /*
+                * Reverse the order of the ports, so v1 is the lower one.
+                */
+               bpf_int32 vtemp;
+
+               vtemp = v1;
+               v1 = v2;
+               v2 = vtemp;
+       }
+
+       b1 = gen_cmp_ge(OR_TRAN_IPV6, off, BPF_H, v1);
+       b2 = gen_cmp_le(OR_TRAN_IPV6, off, BPF_H, v2);
+
+       gen_and(b1, b2); 
+
+       return b2;
+}
+
+struct block *
+gen_portrangeop6(port1, port2, proto, dir)
+       int port1, port2;
+       int proto;
+       int dir;
+{
+       struct block *b0, *b1, *tmp;
+
+       /* ip6 proto 'proto' */
+       b0 = gen_cmp(OR_NET, 6, BPF_B, (bpf_int32)proto);
+
+       switch (dir) {
+       case Q_SRC:
+               b1 = gen_portrangeatom6(0, (bpf_int32)port1, (bpf_int32)port2);
+               break;
+
+       case Q_DST:
+               b1 = gen_portrangeatom6(2, (bpf_int32)port1, (bpf_int32)port2);
+               break;
+
+       case Q_OR:
+       case Q_DEFAULT:
+               tmp = gen_portrangeatom6(0, (bpf_int32)port1, (bpf_int32)port2);
+               b1 = gen_portrangeatom6(2, (bpf_int32)port1, (bpf_int32)port2);
+               gen_or(tmp, b1);
+               break;
+
+       case Q_AND:
+               tmp = gen_portrangeatom6(0, (bpf_int32)port1, (bpf_int32)port2);
+               b1 = gen_portrangeatom6(2, (bpf_int32)port1, (bpf_int32)port2);
+               gen_and(tmp, b1);
+               break;
+
+       default:
+               abort();
+       }
+       gen_and(b0, b1);
+
+       return b1;
+}
+
+static struct block *
+gen_portrange6(port1, port2, ip_proto, dir)
+       int port1, port2;
+       int ip_proto;
+       int dir;
+{
+       struct block *b0, *b1, *tmp;
+
+       /* link proto ip6 */
+       b0 =  gen_linktype(ETHERTYPE_IPV6);
+
+       switch (ip_proto) {
+       case IPPROTO_UDP:
+       case IPPROTO_TCP:
+       case IPPROTO_SCTP:
+               b1 = gen_portrangeop6(port1, port2, ip_proto, dir);
+               break;
+
+       case PROTO_UNDEF:
+               tmp = gen_portrangeop6(port1, port2, IPPROTO_TCP, dir);
+               b1 = gen_portrangeop6(port1, port2, IPPROTO_UDP, dir);
+               gen_or(tmp, b1);
+               tmp = gen_portrangeop6(port1, port2, IPPROTO_SCTP, dir);
+               gen_or(tmp, b1);
+               break;
+
+       default:
+               abort();
+       }
+       gen_and(b0, b1);
+       return b1;
+}
+#endif /* INET6 */
+

 static int
 lookup_proto(name, proto)
        register const char *name;
 static int
 lookup_proto(name, proto)
        register const char *name;


@@ -3471,10 +4206,23 @@ gen_protochain(v, proto, dir)
                /*NOTREACHED*/
        }
 
                /*NOTREACHED*/
        }
 

+       /*
+        * We don't handle variable-length radiotap here headers yet.
+        * We might want to add BPF instructions to do the protochain
+        * work, to simplify that and, on platforms that have a BPF
+        * interpreter with the new instructions, let the filtering
+        * be done in the kernel.  (We already require a modified BPF
+        * engine to do the protochain stuff, to support backward
+        * branches, and backward branch support is unlikely to appear
+        * in kernel BPF engines.)
+        */
+       if (linktype == DLT_IEEE802_11_RADIO)
+               bpf_error("'protochain' not supported with radiotap headers");
+

        no_optimize = 1; /*this code is not compatible with optimzer yet */
 
        /*
        no_optimize = 1; /*this code is not compatible with optimzer yet */
 
        /*

-        * s[0] is a dummy entry to protect other BPF insn from damaged
+        * s[0] is a dummy entry to protect other BPF insn from damage

         * by s[fix] = foo with uninitialized variable "fix".  It is somewhat
         * hard to find interdependency made by jump table fixup.
         */
         * by s[fix] = foo with uninitialized variable "fix".  It is somewhat
         * hard to find interdependency made by jump table fixup.
         */


@@ -3730,6 +4478,15 @@ gen_protochain(v, proto, dir)
 #endif
 }
 
 #endif
 }
 

+/*
+ * Generate code that checks whether the packet is a packet for protocol
+ * <proto> and whether the type field in that protocol's header has
+ * the value <v>, e.g. if <proto> is Q_IP, it checks whether it's an
+ * IP packet and checks the protocol number in the IP header against <v>.
+ *
+ * If <proto> is Q_DEFAULT, i.e. just "proto" was specified, it checks
+ * against Q_IP and Q_IPV6.
+ */

 static struct block *
 gen_proto(v, proto, dir)
        int v;
 static struct block *
 gen_proto(v, proto, dir)
        int v;


@@ -3767,9 +4524,10 @@ gen_proto(v, proto, dir)
                 *
                 * So we always check for ETHERTYPE_IP.
                 */
                 *
                 * So we always check for ETHERTYPE_IP.
                 */

+

                b0 = gen_linktype(ETHERTYPE_IP);
 #ifndef CHASE_CHAIN
                b0 = gen_linktype(ETHERTYPE_IP);
 #ifndef CHASE_CHAIN

-               b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)v);
+               b1 = gen_cmp(OR_NET, 9, BPF_B, (bpf_int32)v);

 #else
                b1 = gen_protochain(v, Q_IP);
 #endif
 #else
                b1 = gen_protochain(v, Q_IP);
 #endif


@@ -3798,7 +4556,7 @@ gen_proto(v, proto, dir)
                         *
                         * XXX - what about SNAP-encapsulated frames?
                         */
                         *
                         * XXX - what about SNAP-encapsulated frames?
                         */

-                       return gen_cmp(2, BPF_H, (0x03<<8) | v);
+                       return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | v);

                        /*NOTREACHED*/
                        break;
 
                        /*NOTREACHED*/
                        break;
 


@@ -3809,13 +4567,13 @@ gen_proto(v, proto, dir)
                         */
                        b0 = gen_linktype(LLCSAP_ISONS<<8 | LLCSAP_ISONS);
                        /* OSI in C-HDLC is stuffed with a fudge byte */
                         */
                        b0 = gen_linktype(LLCSAP_ISONS<<8 | LLCSAP_ISONS);
                        /* OSI in C-HDLC is stuffed with a fudge byte */

-                       b1 = gen_cmp(off_nl_nosnap+1, BPF_B, (long)v);
+                       b1 = gen_cmp(OR_NET_NOSNAP, 1, BPF_B, (long)v);

                        gen_and(b0, b1);
                        return b1;
 
                default:
                        b0 = gen_linktype(LLCSAP_ISONS);
                        gen_and(b0, b1);
                        return b1;
 
                default:
                        b0 = gen_linktype(LLCSAP_ISONS);

-                       b1 = gen_cmp(off_nl_nosnap, BPF_B, (long)v);
+                       b1 = gen_cmp(OR_NET_NOSNAP, 0, BPF_B, (long)v);

                        gen_and(b0, b1);
                        return b1;
                }
                        gen_and(b0, b1);
                        return b1;
                }


@@ -3826,7 +4584,7 @@ gen_proto(v, proto, dir)
                 * 4 is the offset of the PDU type relative to the IS-IS
                 * header.
                 */
                 * 4 is the offset of the PDU type relative to the IS-IS
                 * header.
                 */

-               b1 = gen_cmp(off_nl_nosnap+4, BPF_B, (long)v);
+               b1 = gen_cmp(OR_NET_NOSNAP, 4, BPF_B, (long)v);

                gen_and(b0, b1);
                return b1;
 
                gen_and(b0, b1);
                return b1;
 


@@ -3901,7 +4659,7 @@ gen_proto(v, proto, dir)
        case Q_IPV6:
                b0 = gen_linktype(ETHERTYPE_IPV6);
 #ifndef CHASE_CHAIN
        case Q_IPV6:
                b0 = gen_linktype(ETHERTYPE_IPV6);
 #ifndef CHASE_CHAIN

-               b1 = gen_cmp(off_nl + 6, BPF_B, (bpf_int32)v);
+               b1 = gen_cmp(OR_NET, 6, BPF_B, (bpf_int32)v);

 #else
                b1 = gen_protochain(v, Q_IPV6);
 #endif
 #else
                b1 = gen_protochain(v, Q_IPV6);
 #endif


@@ -3927,6 +4685,9 @@ gen_proto(v, proto, dir)
        case Q_NETBEUI:
                bpf_error("'netbeui proto' is bogus");
 
        case Q_NETBEUI:
                bpf_error("'netbeui proto' is bogus");
 

+       case Q_RADIO:
+               bpf_error("'radio proto' is bogus");
+

        default:
                abort();
                /* NOTREACHED */
        default:
                abort();
                /* NOTREACHED */


@@ -3955,6 +4716,7 @@ gen_scode(name, q)
 #endif /*INET6*/
        struct block *b, *tmp;
        int port, real_proto;
 #endif /*INET6*/
        struct block *b, *tmp;
        int port, real_proto;

+       int port1, port2;

 
        switch (q.addr) {
 
 
        switch (q.addr) {
 


@@ -3968,7 +4730,7 @@ gen_scode(name, q)
                        addr <<= 8;
                        mask <<= 8;
                }
                        addr <<= 8;
                        mask <<= 8;
                }

-               return gen_host(addr, mask, proto, dir);
+               return gen_host(addr, mask, proto, dir, q.addr);

 
        case Q_DEFAULT:
        case Q_HOST:
 
        case Q_DEFAULT:
        case Q_HOST:


@@ -4003,6 +4765,9 @@ gen_scode(name, q)
                                return b;
 
                        case DLT_IEEE802_11:
                                return b;
 
                        case DLT_IEEE802_11:

+                       case DLT_IEEE802_11_RADIO_AVS:
+                       case DLT_IEEE802_11_RADIO:
+                       case DLT_PRISM_HEADER:

                                eaddr = pcap_ether_hostton(name);
                                if (eaddr == NULL)
                                        bpf_error(
                                eaddr = pcap_ether_hostton(name);
                                if (eaddr == NULL)
                                        bpf_error(


@@ -4029,8 +4794,8 @@ gen_scode(name, q)
                                 * with an LE Control marker.  (We've
                                 * already generated a test for LANE.)
                                 */
                                 * with an LE Control marker.  (We've
                                 * already generated a test for LANE.)
                                 */

-                               tmp = gen_cmp(SUNATM_PKT_BEGIN_POS, BPF_H,
-                                   0xFF00);
+                               tmp = gen_cmp(OR_LINK, SUNATM_PKT_BEGIN_POS,
+                                   BPF_H, 0xFF00);

                                gen_not(tmp);
 
                                eaddr = pcap_ether_hostton(name);
                                gen_not(tmp);
 
                                eaddr = pcap_ether_hostton(name);


@@ -4050,7 +4815,7 @@ gen_scode(name, q)
                         * I don't think DECNET hosts can be multihomed, so
                         * there is no need to build up a list of addresses
                         */
                         * I don't think DECNET hosts can be multihomed, so
                         * there is no need to build up a list of addresses
                         */

-                       return (gen_host(dn_addr, 0, proto, dir));
+                       return (gen_host(dn_addr, 0, proto, dir, q.addr));

                } else {
 #ifndef INET6
                        alist = pcap_nametoaddr(name);
                } else {
 #ifndef INET6
                        alist = pcap_nametoaddr(name);


@@ -4059,10 +4824,10 @@ gen_scode(name, q)
                        tproto = proto;
                        if (off_linktype == (u_int)-1 && tproto == Q_DEFAULT)
                                tproto = Q_IP;
                        tproto = proto;
                        if (off_linktype == (u_int)-1 && tproto == Q_DEFAULT)
                                tproto = Q_IP;

-                       b = gen_host(**alist++, 0xffffffff, tproto, dir);
+                       b = gen_host(**alist++, 0xffffffff, tproto, dir, q.addr);

                        while (*alist) {
                                tmp = gen_host(**alist++, 0xffffffff,
                        while (*alist) {
                                tmp = gen_host(**alist++, 0xffffffff,

-                                              tproto, dir);
+                                              tproto, dir, q.addr);

                                gen_or(b, tmp);
                                b = tmp;
                        }
                                gen_or(b, tmp);
                                b = tmp;
                        }


@@ -4087,7 +4852,7 @@ gen_scode(name, q)
                                        sin = (struct sockaddr_in *)
                                                res->ai_addr;
                                        tmp = gen_host(ntohl(sin->sin_addr.s_addr),
                                        sin = (struct sockaddr_in *)
                                                res->ai_addr;
                                        tmp = gen_host(ntohl(sin->sin_addr.s_addr),

-                                               0xffffffff, tproto, dir);
+                                               0xffffffff, tproto, dir, q.addr);

                                        break;
                                case AF_INET6:
                                        if (tproto6 == Q_IP)
                                        break;
                                case AF_INET6:
                                        if (tproto6 == Q_IP)


@@ -4096,7 +4861,7 @@ gen_scode(name, q)
                                        sin6 = (struct sockaddr_in6 *)
                                                res->ai_addr;
                                        tmp = gen_host6(&sin6->sin6_addr,
                                        sin6 = (struct sockaddr_in6 *)
                                                res->ai_addr;
                                        tmp = gen_host6(&sin6->sin6_addr,

-                                               &mask128, tproto6, dir);
+                                               &mask128, tproto6, dir, q.addr);

                                        break;
                                default:
                                        continue;
                                        break;
                                default:
                                        continue;


@@ -4162,6 +4927,50 @@ gen_scode(name, q)
            }
 #endif /* INET6 */
 
            }
 #endif /* INET6 */
 

+       case Q_PORTRANGE:
+               if (proto != Q_DEFAULT &&
+                   proto != Q_UDP && proto != Q_TCP && proto != Q_SCTP)
+                       bpf_error("illegal qualifier of 'portrange'");
+               if (pcap_nametoportrange(name, &port1, &port2, &real_proto) == 0) 
+                       bpf_error("unknown port in range '%s'", name);
+               if (proto == Q_UDP) {
+                       if (real_proto == IPPROTO_TCP)
+                               bpf_error("port in range '%s' is tcp", name);
+                       else if (real_proto == IPPROTO_SCTP)
+                               bpf_error("port in range '%s' is sctp", name);
+                       else
+                               /* override PROTO_UNDEF */
+                               real_proto = IPPROTO_UDP;
+               }
+               if (proto == Q_TCP) {
+                       if (real_proto == IPPROTO_UDP)
+                               bpf_error("port in range '%s' is udp", name);
+                       else if (real_proto == IPPROTO_SCTP)
+                               bpf_error("port in range '%s' is sctp", name);
+                       else
+                               /* override PROTO_UNDEF */
+                               real_proto = IPPROTO_TCP;
+               }
+               if (proto == Q_SCTP) {
+                       if (real_proto == IPPROTO_UDP)
+                               bpf_error("port in range '%s' is udp", name);
+                       else if (real_proto == IPPROTO_TCP)
+                               bpf_error("port in range '%s' is tcp", name);
+                       else
+                               /* override PROTO_UNDEF */
+                               real_proto = IPPROTO_SCTP;      
+               }
+#ifndef INET6
+               return gen_portrange(port1, port2, real_proto, dir);
+#else
+           {
+               struct block *b;
+               b = gen_portrange(port1, port2, real_proto, dir);
+               gen_or(gen_portrange6(port1, port2, real_proto, dir), b);
+               return b;
+           }
+#endif /* INET6 */
+

        case Q_GATEWAY:
 #ifndef INET6
                eaddr = pcap_ether_hostton(name);
        case Q_GATEWAY:
 #ifndef INET6
                eaddr = pcap_ether_hostton(name);


@@ -4225,7 +5034,14 @@ gen_mcode(s1, s2, masklen, q)
                /* Convert mask len to mask */
                if (masklen > 32)
                        bpf_error("mask length must be <= 32");
                /* Convert mask len to mask */
                if (masklen > 32)
                        bpf_error("mask length must be <= 32");

-               m = 0xffffffff << (32 - masklen);
+               if (masklen == 0) {
+                       /*
+                        * X << 32 is not guaranteed by C to be 0; it's
+                        * undefined.
+                        */
+                       m = 0;
+               } else
+                       m = 0xffffffff << (32 - masklen);

                if ((n & ~m) != 0)
                        bpf_error("non-network bits set in \"%s/%d\"",
                            s1, masklen);
                if ((n & ~m) != 0)
                        bpf_error("non-network bits set in \"%s/%d\"",
                            s1, masklen);


@@ -4234,7 +5050,7 @@ gen_mcode(s1, s2, masklen, q)
        switch (q.addr) {
 
        case Q_NET:
        switch (q.addr) {
 
        case Q_NET:

-               return gen_host(n, m, q.proto, q.dir);
+               return gen_host(n, m, q.proto, q.dir, q.addr);

 
        default:
                bpf_error("Mask syntax for networks only");
 
        default:
                bpf_error("Mask syntax for networks only");


@@ -4267,7 +5083,7 @@ gen_ncode(s, v, q)
        case Q_HOST:
        case Q_NET:
                if (proto == Q_DECNET)
        case Q_HOST:
        case Q_NET:
                if (proto == Q_DECNET)

-                       return gen_host(v, 0, proto, dir);
+                       return gen_host(v, 0, proto, dir, q.addr);

                else if (proto == Q_LINK) {
                        bpf_error("illegal link layer address");
                } else {
                else if (proto == Q_LINK) {
                        bpf_error("illegal link layer address");
                } else {


@@ -4283,7 +5099,7 @@ gen_ncode(s, v, q)
                                v <<= 32 - vlen;
                                mask <<= 32 - vlen;
                        }
                                v <<= 32 - vlen;
                                mask <<= 32 - vlen;
                        }

-                       return gen_host(v, mask, proto, dir);
+                       return gen_host(v, mask, proto, dir, q.addr);

                }
 
        case Q_PORT:
                }
 
        case Q_PORT:


@@ -4309,6 +5125,29 @@ gen_ncode(s, v, q)
            }
 #endif /* INET6 */
 
            }
 #endif /* INET6 */
 

+       case Q_PORTRANGE:
+               if (proto == Q_UDP)
+                       proto = IPPROTO_UDP;
+               else if (proto == Q_TCP)
+                       proto = IPPROTO_TCP;
+               else if (proto == Q_SCTP)
+                       proto = IPPROTO_SCTP;
+               else if (proto == Q_DEFAULT)
+                       proto = PROTO_UNDEF;
+               else
+                       bpf_error("illegal qualifier of 'portrange'");
+
+#ifndef INET6
+               return gen_portrange((int)v, (int)v, proto, dir);
+#else
+           {
+               struct block *b;
+               b = gen_portrange((int)v, (int)v, proto, dir);
+               gen_or(gen_portrange6((int)v, (int)v, proto, dir), b);
+               return b;
+           }
+#endif /* INET6 */
+

        case Q_GATEWAY:
                bpf_error("'gateway' requires a name");
                /* NOTREACHED */
        case Q_GATEWAY:
                bpf_error("'gateway' requires a name");
                /* NOTREACHED */


@@ -4378,7 +5217,7 @@ gen_mcode6(s1, s2, masklen, q)
                /* FALLTHROUGH */
 
        case Q_NET:
                /* FALLTHROUGH */
 
        case Q_NET:

-               b = gen_host6(addr, &mask, q.proto, q.dir);
+               b = gen_host6(addr, &mask, q.proto, q.dir, q.addr);

                freeaddrinfo(res);
                return b;
 
                freeaddrinfo(res);
                return b;
 


@@ -4397,21 +5236,27 @@ gen_ecode(eaddr, q)
        struct block *b, *tmp;
 
        if ((q.addr == Q_HOST || q.addr == Q_DEFAULT) && q.proto == Q_LINK) {
        struct block *b, *tmp;
 
        if ((q.addr == Q_HOST || q.addr == Q_DEFAULT) && q.proto == Q_LINK) {

-               if (linktype == DLT_EN10MB)
-                       return gen_ehostop(eaddr, (int)q.dir);
-               if (linktype == DLT_FDDI)
-                       return gen_fhostop(eaddr, (int)q.dir);
-               if (linktype == DLT_IEEE802)
-                       return gen_thostop(eaddr, (int)q.dir);
-               if (linktype == DLT_IEEE802_11)
-                       return gen_wlanhostop(eaddr, (int)q.dir);
-               if (linktype == DLT_SUNATM && is_lane) {
+            switch (linktype) {
+            case DLT_EN10MB:
+                return gen_ehostop(eaddr, (int)q.dir);
+            case DLT_FDDI:
+                return gen_fhostop(eaddr, (int)q.dir);
+            case DLT_IEEE802:
+                return gen_thostop(eaddr, (int)q.dir);
+           case DLT_IEEE802_11:
+           case DLT_IEEE802_11_RADIO_AVS:
+           case DLT_IEEE802_11_RADIO:
+           case DLT_PRISM_HEADER:
+                return gen_wlanhostop(eaddr, (int)q.dir);
+            case DLT_SUNATM:
+               if (is_lane) {

                        /*
                         * Check that the packet doesn't begin with an
                         * LE Control marker.  (We've already generated
                         * a test for LANE.)
                         */
                        /*
                         * Check that the packet doesn't begin with an
                         * LE Control marker.  (We've already generated
                         * a test for LANE.)
                         */

-                       tmp = gen_cmp(SUNATM_PKT_BEGIN_POS, BPF_H, 0xFF00);
+                       tmp = gen_cmp(OR_LINK, SUNATM_PKT_BEGIN_POS, BPF_H,
+                           0xFF00);

                        gen_not(tmp);
 
                        /*
                        gen_not(tmp);
 
                        /*


@@ -4421,9 +5266,13 @@ gen_ecode(eaddr, q)
                        gen_and(tmp, b);
                        return b;
                }
                        gen_and(tmp, b);
                        return b;
                }

-               if (linktype == DLT_IP_OVER_FC)
-                       return gen_ipfchostop(eaddr, (int)q.dir);
+                break;
+           case DLT_IP_OVER_FC:
+                return gen_ipfchostop(eaddr, (int)q.dir);
+            default:

                bpf_error("ethernet addresses supported only on ethernet/FDDI/token ring/802.11/ATM LANE/Fibre Channel");
                bpf_error("ethernet addresses supported only on ethernet/FDDI/token ring/802.11/ATM LANE/Fibre Channel");

+                break;
+            }

        }
        bpf_error("ethernet address used in non-ether expression");
        /* NOTREACHED */
        }
        bpf_error("ethernet address used in non-ether expression");
        /* NOTREACHED */


@@ -4464,6 +5313,13 @@ xfer_to_a(a)
        return s;
 }
 
        return s;
 }
 

+/*
+ * Modify "index" to use the value stored into its register as an
+ * offset relative to the beginning of the header for the protocol
+ * "proto", and allocate a register and put an item "size" bytes long
+ * (1, 2, or 4) at that offset into that register, making it the register
+ * for "index".
+ */

 struct arth *
 gen_load(proto, index, size)
        int proto;
 struct arth *
 gen_load(proto, index, size)
        int proto;


@@ -4496,8 +5352,36 @@ gen_load(proto, index, size)
        default:
                bpf_error("unsupported index operation");
 
        default:
                bpf_error("unsupported index operation");
 

+       case Q_RADIO:
+               /*
+                * The offset is relative to the beginning of the packet
+                * data, if we have a radio header.  (If we don't, this
+                * is an error.)
+                */
+               if (linktype != DLT_IEEE802_11_RADIO_AVS &&
+                   linktype != DLT_IEEE802_11_RADIO &&
+                   linktype != DLT_PRISM_HEADER)
+                       bpf_error("radio information not present in capture");
+
+               /*
+                * Load into the X register the offset computed into the
+                * register specifed by "index".
+                */
+               s = xfer_to_x(index);
+
+               /*
+                * Load the item at that offset.
+                */
+               tmp = new_stmt(BPF_LD|BPF_IND|size);
+               sappend(s, tmp);
+               sappend(index->s, s);
+               break;
+

        case Q_LINK:
                /*
        case Q_LINK:
                /*

+                * The offset is relative to the beginning of
+                * the link-layer header.
+                *

                 * XXX - what about ATM LANE?  Should the index be
                 * relative to the beginning of the AAL5 frame, so
                 * that 0 refers to the beginning of the LE Control
                 * XXX - what about ATM LANE?  Should the index be
                 * relative to the beginning of the AAL5 frame, so
                 * that 0 refers to the beginning of the LE Control


@@ -4505,8 +5389,33 @@ gen_load(proto, index, size)
                 * frame, so that 0 refers, for Ethernet LANE, to
                 * the beginning of the destination address?
                 */
                 * frame, so that 0 refers, for Ethernet LANE, to
                 * the beginning of the destination address?
                 */

-               s = xfer_to_x(index);
+               s = gen_llprefixlen();
+
+               /*
+                * If "s" is non-null, it has code to arrange that the
+                * X register contains the length of the prefix preceding
+                * the link-layer header.  Add to it the offset computed
+                * into the register specified by "index", and move that
+                * into the X register.  Otherwise, just load into the X
+                * register the offset computed into the register specifed
+                * by "index".
+                */
+               if (s != NULL) {
+                       sappend(s, xfer_to_a(index));
+                       sappend(s, new_stmt(BPF_ALU|BPF_ADD|BPF_X));
+                       sappend(s, new_stmt(BPF_MISC|BPF_TAX));
+               } else
+                       s = xfer_to_x(index);
+
+               /*
+                * Load the item at the sum of the offset we've put in the
+                * X register and the offset of the start of the link
+                * layer header (which is 0 if the radio header is
+                * variable-length; that header length is what we put
+                * into the X register and then added to the index).
+                */

                tmp = new_stmt(BPF_LD|BPF_IND|size);
                tmp = new_stmt(BPF_LD|BPF_IND|size);

+               tmp->s.k = off_ll;

                sappend(s, tmp);
                sappend(index->s, s);
                break;
                sappend(s, tmp);
                sappend(index->s, s);
                break;


@@ -4523,13 +5432,44 @@ gen_load(proto, index, size)
 #ifdef INET6
        case Q_IPV6:
 #endif
 #ifdef INET6
        case Q_IPV6:
 #endif

-               /* XXX Note that we assume a fixed link header here. */
-               s = xfer_to_x(index);
+               /*
+                * The offset is relative to the beginning of
+                * the network-layer header.
+                * XXX - are there any cases where we want
+                * off_nl_nosnap?
+                */
+               s = gen_llprefixlen();
+
+               /*
+                * If "s" is non-null, it has code to arrange that the
+                * X register contains the length of the prefix preceding
+                * the link-layer header.  Add to it the offset computed
+                * into the register specified by "index", and move that
+                * into the X register.  Otherwise, just load into the X
+                * register the offset computed into the register specifed
+                * by "index".
+                */
+               if (s != NULL) {
+                       sappend(s, xfer_to_a(index));
+                       sappend(s, new_stmt(BPF_ALU|BPF_ADD|BPF_X));
+                       sappend(s, new_stmt(BPF_MISC|BPF_TAX));
+               } else
+                       s = xfer_to_x(index);
+
+               /*
+                * Load the item at the sum of the offset we've put in the
+                * X register and the offset of the start of the network
+                * layer header.
+                */

                tmp = new_stmt(BPF_LD|BPF_IND|size);
                tmp->s.k = off_nl;
                sappend(s, tmp);
                sappend(index->s, s);
 
                tmp = new_stmt(BPF_LD|BPF_IND|size);
                tmp->s.k = off_nl;
                sappend(s, tmp);
                sappend(index->s, s);
 

+               /*
+                * Do the computation only if the packet contains
+                * the protocol in question.
+                */

                b = gen_proto_abbrev(proto);
                if (index->b)
                        gen_and(index->b, b);
                b = gen_proto_abbrev(proto);
                if (index->b)
                        gen_and(index->b, b);


@@ -4544,8 +5484,29 @@ gen_load(proto, index, size)
        case Q_IGRP:
        case Q_PIM:
        case Q_VRRP:
        case Q_IGRP:
        case Q_PIM:
        case Q_VRRP:

-               s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
-               s->s.k = off_nl;
+               /*
+                * The offset is relative to the beginning of
+                * the transport-layer header.
+                * XXX - are there any cases where we want
+                * off_nl_nosnap?
+                * XXX - we should, if we're built with
+                * IPv6 support, generate code to load either
+                * IPv4, IPv6, or both, as appropriate.
+                */
+               s = gen_loadx_iphdrlen();
+
+               /*
+                * The X register now contains the sum of the offset
+                * of the beginning of the link-layer header and
+                * the length of the network-layer header.  Load
+                * into the A register the offset relative to
+                * the beginning of the transport layer header,
+                * add the X register to that, move that to the
+                * X register, and load with an offset from the
+                * X register equal to the offset of the network
+                * layer header relative to the beginning of
+                * the link-layer header.
+                */

                sappend(s, xfer_to_a(index));
                sappend(s, new_stmt(BPF_ALU|BPF_ADD|BPF_X));
                sappend(s, new_stmt(BPF_MISC|BPF_TAX));
                sappend(s, xfer_to_a(index));
                sappend(s, new_stmt(BPF_ALU|BPF_ADD|BPF_X));
                sappend(s, new_stmt(BPF_MISC|BPF_TAX));


@@ -4553,6 +5514,12 @@ gen_load(proto, index, size)
                tmp->s.k = off_nl;
                sappend(index->s, s);
 
                tmp->s.k = off_nl;
                sappend(index->s, s);
 

+               /*
+                * Do the computation only if the packet contains
+                * the protocol in question - which is true only
+                * if this is an IP datagram and is the first or
+                * only fragment of that datagram.
+                */

                gen_and(gen_proto_abbrev(proto), b = gen_ipfrag());
                if (index->b)
                        gen_and(index->b, b);
                gen_and(gen_proto_abbrev(proto), b = gen_ipfrag());
                if (index->b)
                        gen_and(index->b, b);


@@ -4778,6 +5745,16 @@ gen_less(n)
        return b;
 }
 
        return b;
 }
 

+/*
+ * This is for "byte {idx} {op} {val}"; "idx" is treated as relative to
+ * the beginning of the link-layer header.
+ * XXX - that means you can't test values in the radiotap header, but
+ * as that header is difficult if not impossible to parse generally
+ * without a loop, that might not be a severe problem.  A new keyword
+ * "radio" could be added for that, although what you'd really want
+ * would be a way of testing particular radio header values, which
+ * would generate code appropriate to the radio header in question.
+ */

 struct block *
 gen_byteop(op, idx, val)
        int op, idx, val;
 struct block *
 gen_byteop(op, idx, val)
        int op, idx, val;


@@ -4790,17 +5767,14 @@ gen_byteop(op, idx, val)
                abort();
 
        case '=':
                abort();
 
        case '=':

-               return gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
+               return gen_cmp(OR_LINK, (u_int)idx, BPF_B, (bpf_int32)val);

 
        case '<':
 
        case '<':

-               b = gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
-               b->s.code = JMP(BPF_JGE);
-               gen_not(b);
+               b = gen_cmp_lt(OR_LINK, (u_int)idx, BPF_B, (bpf_int32)val);

                return b;
 
        case '>':
                return b;
 
        case '>':

-               b = gen_cmp((u_int)idx, BPF_B, (bpf_int32)val);
-               b->s.code = JMP(BPF_JGT);
+               b = gen_cmp_gt(OR_LINK, (u_int)idx, BPF_B, (bpf_int32)val);

                return b;
 
        case '|':
                return b;
 
        case '|':


@@ -4833,25 +5807,32 @@ gen_broadcast(proto)
 
        case Q_DEFAULT:
        case Q_LINK:
 
        case Q_DEFAULT:
        case Q_LINK:

-               if (linktype == DLT_ARCNET || linktype == DLT_ARCNET_LINUX)
-                       return gen_ahostop(abroadcast, Q_DST);
-               if (linktype == DLT_EN10MB)
-                       return gen_ehostop(ebroadcast, Q_DST);
-               if (linktype == DLT_FDDI)
-                       return gen_fhostop(ebroadcast, Q_DST);
-               if (linktype == DLT_IEEE802)
-                       return gen_thostop(ebroadcast, Q_DST);
-               if (linktype == DLT_IEEE802_11)
-                       return gen_wlanhostop(ebroadcast, Q_DST);
-               if (linktype == DLT_IP_OVER_FC)
-                       return gen_ipfchostop(ebroadcast, Q_DST);
-               if (linktype == DLT_SUNATM && is_lane) {
+                switch (linktype) {
+                case DLT_ARCNET:
+                case DLT_ARCNET_LINUX:
+                    return gen_ahostop(abroadcast, Q_DST);
+                case DLT_EN10MB:    
+                    return gen_ehostop(ebroadcast, Q_DST);
+                case DLT_FDDI:
+                    return gen_fhostop(ebroadcast, Q_DST);
+                case DLT_IEEE802:
+                    return gen_thostop(ebroadcast, Q_DST);
+                case DLT_IEEE802_11:
+                case DLT_IEEE802_11_RADIO_AVS:
+                case DLT_IEEE802_11_RADIO:
+                case DLT_PRISM_HEADER:
+                    return gen_wlanhostop(ebroadcast, Q_DST);
+                case DLT_IP_OVER_FC:
+                    return gen_ipfchostop(ebroadcast, Q_DST);
+                case DLT_SUNATM:
+                    if (is_lane) {

                        /*
                         * Check that the packet doesn't begin with an
                         * LE Control marker.  (We've already generated
                         * a test for LANE.)
                         */
                        /*
                         * Check that the packet doesn't begin with an
                         * LE Control marker.  (We've already generated
                         * a test for LANE.)
                         */

-                       b1 = gen_cmp(SUNATM_PKT_BEGIN_POS, BPF_H, 0xFF00);
+                       b1 = gen_cmp(OR_LINK, SUNATM_PKT_BEGIN_POS, BPF_H,
+                           0xFF00);

                        gen_not(b1);
 
                        /*
                        gen_not(b1);
 
                        /*


@@ -4860,15 +5841,18 @@ gen_broadcast(proto)
                        b0 = gen_ehostop(ebroadcast, Q_DST);
                        gen_and(b1, b0);
                        return b0;
                        b0 = gen_ehostop(ebroadcast, Q_DST);
                        gen_and(b1, b0);
                        return b0;

-               }
-               bpf_error("not a broadcast link");
+                    }
+                    break;
+                default:
+                    bpf_error("not a broadcast link");
+                }

                break;
 
        case Q_IP:
                b0 = gen_linktype(ETHERTYPE_IP);
                hostmask = ~netmask;
                break;
 
        case Q_IP:
                b0 = gen_linktype(ETHERTYPE_IP);
                hostmask = ~netmask;

-               b1 = gen_mcmp(off_nl + 16, BPF_W, (bpf_int32)0, hostmask);
-               b2 = gen_mcmp(off_nl + 16, BPF_W,
+               b1 = gen_mcmp(OR_NET, 16, BPF_W, (bpf_int32)0, hostmask);
+               b2 = gen_mcmp(OR_NET, 16, BPF_W,

                              (bpf_int32)(~0 & hostmask), hostmask);
                gen_or(b1, b2);
                gen_and(b0, b2);
                              (bpf_int32)(~0 & hostmask), hostmask);
                gen_or(b1, b2);
                gen_and(b0, b2);


@@ -4890,8 +5874,7 @@ gen_mac_multicast(offset)
        register struct slist *s;
 
        /* link[offset] & 1 != 0 */
        register struct slist *s;
 
        /* link[offset] & 1 != 0 */

-       s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-       s->s.k = offset;
+       s = gen_load_a(OR_LINK, offset, BPF_B);

        b0 = new_block(JMP(BPF_JSET));
        b0->s.k = 1;
        b0->stmts = s;
        b0 = new_block(JMP(BPF_JSET));
        b0->s.k = 1;
        b0->stmts = s;


@@ -4909,184 +5892,177 @@ gen_multicast(proto)
 
        case Q_DEFAULT:
        case Q_LINK:
 
        case Q_DEFAULT:
        case Q_LINK:

-               if (linktype == DLT_ARCNET || linktype == DLT_ARCNET_LINUX)
-                       /* all ARCnet multicasts use the same address */
-                       return gen_ahostop(abroadcast, Q_DST);
-
-               if (linktype == DLT_EN10MB) {
-                       /* ether[0] & 1 != 0 */
-                       return gen_mac_multicast(0);
-               }
-
-               if (linktype == DLT_FDDI) {
-                       /*
-                        * XXX TEST THIS: MIGHT NOT PORT PROPERLY XXX
-                        *
-                        * XXX - was that referring to bit-order issues?
-                        */
-                       /* fddi[1] & 1 != 0 */
-                       return gen_mac_multicast(1);
-               }
-
-               if (linktype == DLT_IEEE802) {
-                       /* tr[2] & 1 != 0 */
-                       return gen_mac_multicast(2);
-               }
-
-               if (linktype == DLT_IEEE802_11) {
-                       /*
-                        * Oh, yuk.
-                        *
-                        *      For control frames, there is no DA.
-                        *
-                        *      For management frames, DA is at an
-                        *      offset of 4 from the beginning of
-                        *      the packet.
-                        *
-                        *      For data frames, DA is at an offset
-                        *      of 4 from the beginning of the packet
-                        *      if To DS is clear and at an offset of
-                        *      16 from the beginning of the packet
-                        *      if To DS is set.
-                        */
-
-                       /*
-                        * Generate the tests to be done for data frames.
-                        *
-                        * First, check for To DS set, i.e. "link[1] & 0x01".
-                        */
-                       s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-                       s->s.k = 1;
-                       b1 = new_block(JMP(BPF_JSET));
-                       b1->s.k = 0x01; /* To DS */
-                       b1->stmts = s;
-
-                       /*
-                        * If To DS is set, the DA is at 16.
-                        */
-                       b0 = gen_mac_multicast(16);
-                       gen_and(b1, b0);
-
-                       /*
-                        * Now, check for To DS not set, i.e. check
-                        * "!(link[1] & 0x01)".
-                        */
-                       s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-                       s->s.k = 1;
-                       b2 = new_block(JMP(BPF_JSET));
-                       b2->s.k = 0x01; /* To DS */
-                       b2->stmts = s;
-                       gen_not(b2);
-
-                       /*
-                        * If To DS is not set, the DA is at 4.
-                        */
-                       b1 = gen_mac_multicast(4);
-                       gen_and(b2, b1);
-
-                       /*
-                        * Now OR together the last two checks.  That gives
-                        * the complete set of checks for data frames.
-                        */
-                       gen_or(b1, b0);
-
-                       /*
-                        * Now check for a data frame.
-                        * I.e, check "link[0] & 0x08".
-                        */
-                       s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-                       s->s.k = 0;
-                       b1 = new_block(JMP(BPF_JSET));
-                       b1->s.k = 0x08;
-                       b1->stmts = s;
-
-                       /*
-                        * AND that with the checks done for data frames.
-                        */
-                       gen_and(b1, b0);
-
-                       /*
-                        * If the high-order bit of the type value is 0, this
-                        * is a management frame.
-                        * I.e, check "!(link[0] & 0x08)".
-                        */
-                       s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-                       s->s.k = 0;
-                       b2 = new_block(JMP(BPF_JSET));
-                       b2->s.k = 0x08;
-                       b2->stmts = s;
-                       gen_not(b2);
-
-                       /*
-                        * For management frames, the DA is at 4.
-                        */
-                       b1 = gen_mac_multicast(4);
-                       gen_and(b2, b1);
-
-                       /*
-                        * OR that with the checks done for data frames.
-                        * That gives the checks done for management and
-                        * data frames.
-                        */
-                       gen_or(b1, b0);
-
-                       /*
-                        * If the low-order bit of the type value is 1,
-                        * this is either a control frame or a frame
-                        * with a reserved type, and thus not a
-                        * frame with an SA.
-                        *
-                        * I.e., check "!(link[0] & 0x04)".
-                        */
-                       s = new_stmt(BPF_LD|BPF_B|BPF_ABS);
-                       s->s.k = 0;
-                       b1 = new_block(JMP(BPF_JSET));
-                       b1->s.k = 0x04;
-                       b1->stmts = s;
-                       gen_not(b1);
-
-                       /*
-                        * AND that with the checks for data and management
-                        * frames.
-                        */
-                       gen_and(b1, b0);
-                       return b0;
-               }
-
-               if (linktype == DLT_IP_OVER_FC) {
-                       b0 = gen_mac_multicast(2);
-                       return b0;
-               }
-
-               if (linktype == DLT_SUNATM && is_lane) {
+                switch (linktype) {
+                case DLT_ARCNET:
+                case DLT_ARCNET_LINUX:
+                    /* all ARCnet multicasts use the same address */
+                    return gen_ahostop(abroadcast, Q_DST);
+                case  DLT_EN10MB:
+                    /* ether[0] & 1 != 0 */
+                    return gen_mac_multicast(0);
+                case DLT_FDDI:
+                    /*
+                     * XXX TEST THIS: MIGHT NOT PORT PROPERLY XXX
+                     *
+                     * XXX - was that referring to bit-order issues?
+                     */
+                    /* fddi[1] & 1 != 0 */
+                    return gen_mac_multicast(1);
+                case DLT_IEEE802:
+                    /* tr[2] & 1 != 0 */
+                    return gen_mac_multicast(2);
+                case DLT_IEEE802_11:
+                case DLT_IEEE802_11_RADIO_AVS:
+                case DLT_IEEE802_11_RADIO:
+                case DLT_PRISM_HEADER:
+                    /*
+                     * Oh, yuk.
+                     *
+                     * For control frames, there is no DA.
+                     *
+                     * For management frames, DA is at an
+                     * offset of 4 from the beginning of
+                     * the packet.
+                     *
+                     * For data frames, DA is at an offset
+                     * of 4 from the beginning of the packet
+                     * if To DS is clear and at an offset of
+                     * 16 from the beginning of the packet
+                     * if To DS is set.
+                     */
+                    
+                    /*
+                     * Generate the tests to be done for data frames.
+                     *
+                     * First, check for To DS set, i.e. "link[1] & 0x01".
+                     */
+                    s = gen_load_a(OR_LINK, 1, BPF_B);
+                    b1 = new_block(JMP(BPF_JSET));
+                    b1->s.k = 0x01;    /* To DS */
+                    b1->stmts = s;
+                    
+                    /*
+                     * If To DS is set, the DA is at 16.
+                     */
+                    b0 = gen_mac_multicast(16);
+                    gen_and(b1, b0);
+                    
+                    /*
+                     * Now, check for To DS not set, i.e. check
+                     * "!(link[1] & 0x01)".
+                     */
+                    s = gen_load_a(OR_LINK, 1, BPF_B);
+                    b2 = new_block(JMP(BPF_JSET));
+                    b2->s.k = 0x01;    /* To DS */
+                    b2->stmts = s;
+                    gen_not(b2);
+                    
+                    /*
+                     * If To DS is not set, the DA is at 4.
+                     */
+                    b1 = gen_mac_multicast(4);
+                    gen_and(b2, b1);
+                    
+                    /*
+                     * Now OR together the last two checks.  That gives
+                     * the complete set of checks for data frames.
+                     */
+                    gen_or(b1, b0);
+                    
+                    /*
+                     * Now check for a data frame.
+                     * I.e, check "link[0] & 0x08".
+                     */
+                    s = gen_load_a(OR_LINK, 0, BPF_B);
+                    b1 = new_block(JMP(BPF_JSET));
+                    b1->s.k = 0x08;
+                    b1->stmts = s;
+                    
+                    /*
+                     * AND that with the checks done for data frames.
+                     */
+                    gen_and(b1, b0);
+                    
+                    /*
+                     * If the high-order bit of the type value is 0, this
+                     * is a management frame.
+                     * I.e, check "!(link[0] & 0x08)".
+                     */
+                    s = gen_load_a(OR_LINK, 0, BPF_B);
+                    b2 = new_block(JMP(BPF_JSET));
+                    b2->s.k = 0x08;
+                    b2->stmts = s;
+                    gen_not(b2);
+                    
+                    /*
+                     * For management frames, the DA is at 4.
+                     */
+                    b1 = gen_mac_multicast(4);
+                    gen_and(b2, b1);
+                    
+                    /*
+                     * OR that with the checks done for data frames.
+                     * That gives the checks done for management and
+                     * data frames.
+                     */
+                    gen_or(b1, b0);
+                    
+                    /*
+                     * If the low-order bit of the type value is 1,
+                     * this is either a control frame or a frame
+                     * with a reserved type, and thus not a
+                     * frame with an SA.
+                     *
+                     * I.e., check "!(link[0] & 0x04)".
+                     */
+                    s = gen_load_a(OR_LINK, 0, BPF_B);
+                    b1 = new_block(JMP(BPF_JSET));
+                    b1->s.k = 0x04;
+                    b1->stmts = s;
+                    gen_not(b1);
+                    
+                    /*
+                     * AND that with the checks for data and management
+                     * frames.
+                     */
+                    gen_and(b1, b0);
+                    return b0;
+                case DLT_IP_OVER_FC:
+                    b0 = gen_mac_multicast(2);
+                    return b0;
+                case DLT_SUNATM:
+                    if (is_lane) {

                        /*
                         * Check that the packet doesn't begin with an
                         * LE Control marker.  (We've already generated
                         * a test for LANE.)
                         */
                        /*
                         * Check that the packet doesn't begin with an
                         * LE Control marker.  (We've already generated
                         * a test for LANE.)
                         */

-                       b1 = gen_cmp(SUNATM_PKT_BEGIN_POS, BPF_H, 0xFF00);
+                       b1 = gen_cmp(OR_LINK, SUNATM_PKT_BEGIN_POS, BPF_H,
+                           0xFF00);

                        gen_not(b1);
 
                        /* ether[off_mac] & 1 != 0 */
                        b0 = gen_mac_multicast(off_mac);
                        gen_and(b1, b0);
                        return b0;
                        gen_not(b1);
 
                        /* ether[off_mac] & 1 != 0 */
                        b0 = gen_mac_multicast(off_mac);
                        gen_and(b1, b0);
                        return b0;

-               }
-
-               /* Link not known to support multicasts */
-               break;
+                    }
+                    break;
+                default:
+                    break;
+                }
+                /* Link not known to support multicasts */
+                break;

 
        case Q_IP:
                b0 = gen_linktype(ETHERTYPE_IP);
 
        case Q_IP:
                b0 = gen_linktype(ETHERTYPE_IP);

-               b1 = gen_cmp(off_nl + 16, BPF_B, (bpf_int32)224);
-               b1->s.code = JMP(BPF_JGE);
+               b1 = gen_cmp_ge(OR_NET, 16, BPF_B, (bpf_int32)224);

                gen_and(b0, b1);
                return b1;
 
 #ifdef INET6
        case Q_IPV6:
                b0 = gen_linktype(ETHERTYPE_IPV6);
                gen_and(b0, b1);
                return b1;
 
 #ifdef INET6
        case Q_IPV6:
                b0 = gen_linktype(ETHERTYPE_IPV6);

-               b1 = gen_cmp(off_nl + 24, BPF_B, (bpf_int32)255);
+               b1 = gen_cmp(OR_NET, 24, BPF_B, (bpf_int32)255);

                gen_and(b0, b1);
                return b1;
 #endif /* INET6 */
                gen_and(b0, b1);
                return b1;
 #endif /* INET6 */


@@ -5122,7 +6098,7 @@ gen_inbound(dir)
                        /*
                         * Match packets sent by this machine.
                         */
                        /*
                         * Match packets sent by this machine.
                         */

-                       b0 = gen_cmp(0, BPF_H, LINUX_SLL_OUTGOING);
+                       b0 = gen_cmp(OR_LINK, 0, BPF_H, LINUX_SLL_OUTGOING);

                } else {
                        /*
                         * Match packets sent to this machine.
                } else {
                        /*
                         * Match packets sent to this machine.


@@ -5134,37 +6110,48 @@ gen_inbound(dir)
                         * shouldn't be matched, but what about broadcast
                         * or multicast packets we received?
                         */
                         * shouldn't be matched, but what about broadcast
                         * or multicast packets we received?
                         */

-                       b0 = gen_cmp(0, BPF_H, LINUX_SLL_HOST);
+                       b0 = gen_cmp(OR_LINK, 0, BPF_H, LINUX_SLL_HOST);

                }
                break;
 
        case DLT_PFLOG:
                }
                break;
 
        case DLT_PFLOG:

-               b0 = gen_cmp(offsetof(struct pfloghdr, dir), BPF_B,
+               b0 = gen_cmp(OR_LINK, offsetof(struct pfloghdr, dir), BPF_B,

                    (bpf_int32)((dir == 0) ? PF_IN : PF_OUT));
                break;
 
        case DLT_PPP_PPPD:
                if (dir) {
                        /* match outgoing packets */
                    (bpf_int32)((dir == 0) ? PF_IN : PF_OUT));
                break;
 
        case DLT_PPP_PPPD:
                if (dir) {
                        /* match outgoing packets */

-                       b0 = gen_cmp(0, BPF_B, PPP_PPPD_OUT);
+                       b0 = gen_cmp(OR_LINK, 0, BPF_B, PPP_PPPD_OUT);

                } else {
                        /* match incoming packets */
                } else {
                        /* match incoming packets */

-                       b0 = gen_cmp(0, BPF_B, PPP_PPPD_IN);
+                       b0 = gen_cmp(OR_LINK, 0, BPF_B, PPP_PPPD_IN);

                }
                break;
 
                }
                break;
 

+        case DLT_JUNIPER_MFR:

         case DLT_JUNIPER_MLFR:
         case DLT_JUNIPER_MLPPP:
        case DLT_JUNIPER_ATM1:
        case DLT_JUNIPER_ATM2:
         case DLT_JUNIPER_MLFR:
         case DLT_JUNIPER_MLPPP:
        case DLT_JUNIPER_ATM1:
        case DLT_JUNIPER_ATM2:

+       case DLT_JUNIPER_PPPOE:
+       case DLT_JUNIPER_PPPOE_ATM:
+        case DLT_JUNIPER_GGSN:
+        case DLT_JUNIPER_ES:
+        case DLT_JUNIPER_MONITOR:
+        case DLT_JUNIPER_SERVICES:
+        case DLT_JUNIPER_ETHER:
+        case DLT_JUNIPER_PPP:
+        case DLT_JUNIPER_FRELAY:
+        case DLT_JUNIPER_CHDLC:

                /* juniper flags (including direction) are stored
                 * the byte after the 3-byte magic number */
                if (dir) {
                        /* match outgoing packets */
                /* juniper flags (including direction) are stored
                 * the byte after the 3-byte magic number */
                if (dir) {
                        /* match outgoing packets */

-                       b0 = gen_mcmp(3, BPF_B, 0, 0x01);
+                       b0 = gen_mcmp(OR_LINK, 3, BPF_B, 0, 0x01);

                } else {
                        /* match incoming packets */
                } else {
                        /* match incoming packets */

-                       b0 = gen_mcmp(3, BPF_B, 1, 0x01);
+                       b0 = gen_mcmp(OR_LINK, 3, BPF_B, 1, 0x01);

                }
            break;
 
                }
            break;
 


@@ -5196,11 +6183,11 @@ gen_pf_ifname(const char *ifname)
                    len-1);
                /* NOTREACHED */
        }
                    len-1);
                /* NOTREACHED */
        }

-       b0 = gen_bcmp(off, strlen(ifname), (const u_char *)ifname);
+       b0 = gen_bcmp(OR_LINK, off, strlen(ifname), (const u_char *)ifname);

        return (b0);
 }
 
        return (b0);
 }
 

-/* PF firewall log matched interface */
+/* PF firewall log ruleset name */

 struct block *
 gen_pf_ruleset(char *ruleset)
 {
 struct block *
 gen_pf_ruleset(char *ruleset)
 {


@@ -5215,7 +6202,7 @@ gen_pf_ruleset(char *ruleset)
                    (long)(sizeof(((struct pfloghdr *)0)->ruleset) - 1));
                /* NOTREACHED */
        }
                    (long)(sizeof(((struct pfloghdr *)0)->ruleset) - 1));
                /* NOTREACHED */
        }

-       b0 = gen_bcmp(offsetof(struct pfloghdr, ruleset),
+       b0 = gen_bcmp(OR_LINK, offsetof(struct pfloghdr, ruleset),

            strlen(ruleset), (const u_char *)ruleset);
        return (b0);
 }
            strlen(ruleset), (const u_char *)ruleset);
        return (b0);
 }


@@ -5227,7 +6214,7 @@ gen_pf_rnr(int rnr)
        struct block *b0;
 
        if (linktype == DLT_PFLOG) {
        struct block *b0;
 
        if (linktype == DLT_PFLOG) {

-               b0 = gen_cmp(offsetof(struct pfloghdr, rulenr), BPF_W,
+               b0 = gen_cmp(OR_LINK, offsetof(struct pfloghdr, rulenr), BPF_W,

                         (bpf_int32)rnr);
        } else {
                bpf_error("rnr not supported on linktype 0x%x", linktype);
                         (bpf_int32)rnr);
        } else {
                bpf_error("rnr not supported on linktype 0x%x", linktype);


@@ -5248,7 +6235,7 @@ gen_pf_srnr(int srnr)
                /* NOTREACHED */
        }
 
                /* NOTREACHED */
        }
 

-       b0 = gen_cmp(offsetof(struct pfloghdr, subrulenr), BPF_W,
+       b0 = gen_cmp(OR_LINK, offsetof(struct pfloghdr, subrulenr), BPF_W,

            (bpf_int32)srnr);
        return (b0);
 }
            (bpf_int32)srnr);
        return (b0);
 }


@@ -5260,7 +6247,7 @@ gen_pf_reason(int reason)
        struct block *b0;
 
        if (linktype == DLT_PFLOG) {
        struct block *b0;
 
        if (linktype == DLT_PFLOG) {

-               b0 = gen_cmp(offsetof(struct pfloghdr, reason), BPF_B,
+               b0 = gen_cmp(OR_LINK, offsetof(struct pfloghdr, reason), BPF_B,

                    (bpf_int32)reason);
        } else {
                bpf_error("reason not supported on linktype 0x%x", linktype);
                    (bpf_int32)reason);
        } else {
                bpf_error("reason not supported on linktype 0x%x", linktype);


@@ -5277,7 +6264,7 @@ gen_pf_action(int action)
        struct block *b0;
 
        if (linktype == DLT_PFLOG) {
        struct block *b0;
 
        if (linktype == DLT_PFLOG) {

-               b0 = gen_cmp(offsetof(struct pfloghdr, action), BPF_B,
+               b0 = gen_cmp(OR_LINK, offsetof(struct pfloghdr, action), BPF_B,

                    (bpf_int32)action);
        } else {
                bpf_error("action not supported on linktype 0x%x", linktype);
                    (bpf_int32)action);
        } else {
                bpf_error("action not supported on linktype 0x%x", linktype);


@@ -5310,10 +6297,10 @@ gen_ahostop(eaddr, dir)
        switch (dir) {
        /* src comes first, different from Ethernet */
        case Q_SRC:
        switch (dir) {
        /* src comes first, different from Ethernet */
        case Q_SRC:

-               return gen_bcmp(0, 1, eaddr);
+               return gen_bcmp(OR_LINK, 0, 1, eaddr);

 
        case Q_DST:
 
        case Q_DST:

-               return gen_bcmp(1, 1, eaddr);
+               return gen_bcmp(OR_LINK, 1, 1, eaddr);

 
        case Q_AND:
                b0 = gen_ahostop(eaddr, Q_SRC);
 
        case Q_AND:
                b0 = gen_ahostop(eaddr, Q_SRC);


@@ -5339,7 +6326,11 @@ struct block *
 gen_vlan(vlan_num)
        int vlan_num;
 {
 gen_vlan(vlan_num)
        int vlan_num;
 {

-       struct  block   *b0;
+       struct  block   *b0, *b1;
+
+       /* can't check for VLAN-encapsulated packets inside MPLS */
+       if (label_stack_depth > 0)
+               bpf_error("no VLAN match after MPLS");

 
        /*
         * Change the offsets to point to the type and data fields within
 
        /*
         * Change the offsets to point to the type and data fields within


@@ -5371,32 +6362,30 @@ gen_vlan(vlan_num)
         * be done assuming a VLAN, even though the "or" could be viewed
         * as meaning "or, if this isn't a VLAN packet...".
         */
         * be done assuming a VLAN, even though the "or" could be viewed
         * as meaning "or, if this isn't a VLAN packet...".
         */

-        orig_linktype = off_linktype;  /* save original values */
-        orig_nl = off_nl;
-        orig_nl_nosnap = off_nl_nosnap;
+       orig_linktype = off_linktype;   /* save original values */
+       orig_nl = off_nl;

 
 

-        switch (linktype) {
+       switch (linktype) {

 
 

-        case DLT_EN10MB:
-                off_linktype += 4;
-                off_nl_nosnap += 4;
-                off_nl += 4;
-                break;
+       case DLT_EN10MB:
+               off_linktype += 4;
+               off_nl_nosnap += 4;
+               off_nl += 4;
+               break;

 
 

-        default:
-                bpf_error("no VLAN support for data link type %d",
-                      linktype);
-            /*NOTREACHED*/
-        }
+       default:
+               bpf_error("no VLAN support for data link type %d",
+                     linktype);
+               /*NOTREACHED*/
+       }

 
        /* check for VLAN */
 
        /* check for VLAN */

-       b0 = gen_cmp(orig_linktype, BPF_H, (bpf_int32)ETHERTYPE_8021Q);
+       b0 = gen_cmp(OR_LINK, orig_linktype, BPF_H, (bpf_int32)ETHERTYPE_8021Q);

 
        /* If a specific VLAN is requested, check VLAN id */
        if (vlan_num >= 0) {
 
        /* If a specific VLAN is requested, check VLAN id */
        if (vlan_num >= 0) {

-               struct block *b1;
-
-               b1 = gen_mcmp(orig_nl, BPF_H, (bpf_int32)vlan_num, 0x0fff);
+               b1 = gen_mcmp(OR_LINK, orig_nl, BPF_H, (bpf_int32)vlan_num,
+                   0x0fff);

                gen_and(b0, b1);
                b0 = b1;
        }
                gen_and(b0, b1);
                b0 = b1;
        }


@@ -5411,7 +6400,7 @@ struct block *
 gen_mpls(label_num)
        int label_num;
 {
 gen_mpls(label_num)
        int label_num;
 {

-       struct  block   *b0;
+       struct  block   *b0,*b1;

 
        /*
         * Change the offsets to point to the type and data fields within
 
        /*
         * Change the offsets to point to the type and data fields within


@@ -5422,58 +6411,135 @@ gen_mpls(label_num)
         *
         * XXX - this is a bit of a kludge.  See comments in gen_vlan().
         */
         *
         * XXX - this is a bit of a kludge.  See comments in gen_vlan().
         */

-        orig_linktype = off_linktype;  /* save original values */

         orig_nl = off_nl;
         orig_nl = off_nl;

-        orig_nl_nosnap = off_nl_nosnap;
-
-        switch (linktype) {
-            
-        case DLT_C_HDLC: /* fall through */
-        case DLT_EN10MB:
-                off_linktype += 4;
-                off_nl_nosnap += 4;
-                off_nl += 4;
-                        
-                b0 = gen_cmp(orig_linktype, BPF_H, (bpf_int32)ETHERTYPE_MPLS);
-                break;
-
-        case DLT_PPP:
-                off_linktype += 4;
-                off_nl_nosnap += 4;
-                off_nl += 4;
-
-                b0 = gen_cmp(orig_linktype, BPF_H, (bpf_int32)PPP_MPLS_UCAST);
-                break;
-
-                /* FIXME add other DLT_s ...
-                 * for Frame-Relay/and ATM this may get messy due to SNAP headers
-                 * leave it for now */

 
 

-        default:
-                bpf_error("no MPLS support for data link type %d",
+        if (label_stack_depth > 0) {
+            /* just match the bottom-of-stack bit clear */
+            b0 = gen_mcmp(OR_LINK, orig_nl-2, BPF_B, 0, 0x01);
+        } else {
+            /*
+             * Indicate that we're checking MPLS-encapsulated headers,
+             * to make sure higher level code generators don't try to
+             * match against IP-related protocols such as Q_ARP, Q_RARP
+             * etc.
+             */
+            switch (linktype) {
+                
+            case DLT_C_HDLC: /* fall through */
+            case DLT_EN10MB:
+                    b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
+                                 (bpf_int32)ETHERTYPE_MPLS);
+                    break;
+                
+            case DLT_PPP:
+                    b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
+                                 (bpf_int32)PPP_MPLS_UCAST);
+                    break;
+                
+                    /* FIXME add other DLT_s ...
+                     * for Frame-Relay/and ATM this may get messy due to SNAP headers
+                     * leave it for now */
+                
+            default:
+                    bpf_error("no MPLS support for data link type %d",

                           linktype);
                           linktype);

-                b0 = NULL;
-                /*NOTREACHED*/
-                break;
+                    b0 = NULL;
+                    /*NOTREACHED*/
+                    break;
+            }

         }
 
        /* If a specific MPLS label is requested, check it */
        if (label_num >= 0) {
         }
 
        /* If a specific MPLS label is requested, check it */
        if (label_num >= 0) {

-               struct block *b1;
-

                label_num = label_num << 12; /* label is shifted 12 bits on the wire */
                label_num = label_num << 12; /* label is shifted 12 bits on the wire */

-               b1 = gen_mcmp(orig_nl, BPF_W, (bpf_int32)label_num, 0xfffff000); /* only compare the first 20 bits */
+               b1 = gen_mcmp(OR_LINK, orig_nl, BPF_W, (bpf_int32)label_num,
+                   0xfffff000); /* only compare the first 20 bits */

                gen_and(b0, b1);
                b0 = b1;
        }
 
                gen_and(b0, b1);
                b0 = b1;
        }
 

+        off_nl_nosnap += 4;
+        off_nl += 4;
+        label_stack_depth++;

        return (b0);
 }
 
        return (b0);
 }
 

+/*
+ * Support PPPOE discovery and session.
+ */
+struct block *
+gen_pppoed()
+{
+       /* check for PPPoE discovery */
+       return gen_linktype((bpf_int32)ETHERTYPE_PPPOED);
+}
+
+struct block *
+gen_pppoes()
+{
+       struct block *b0;
+
+       /*
+        * Test against the PPPoE session link-layer type.
+        */
+       b0 = gen_linktype((bpf_int32)ETHERTYPE_PPPOES);
+
+       /*
+        * Change the offsets to point to the type and data fields within
+        * the PPP packet.
+        *
+        * XXX - this is a bit of a kludge.  If we were to split the
+        * compiler into a parser that parses an expression and
+        * generates an expression tree, and a code generator that
+        * takes an expression tree (which could come from our
+        * parser or from some other parser) and generates BPF code,
+        * we could perhaps make the offsets parameters of routines
+        * and, in the handler for an "AND" node, pass to subnodes
+        * other than the PPPoE node the adjusted offsets.
+        *
+        * This would mean that "pppoes" would, instead of changing the
+        * behavior of *all* tests after it, change only the behavior
+        * of tests ANDed with it.  That would change the documented
+        * semantics of "pppoes", which might break some expressions.
+        * However, it would mean that "(pppoes and ip) or ip" would check
+        * both for VLAN-encapsulated IP and IP-over-Ethernet, rather than
+        * checking only for VLAN-encapsulated IP, so that could still
+        * be considered worth doing; it wouldn't break expressions
+        * that are of the form "pppoes and ..." which I suspect are the
+        * most common expressions involving "pppoes".  "pppoes or ..."
+        * doesn't necessarily do what the user would really want, now,
+        * as all the "or ..." tests would be done assuming PPPoE, even
+        * though the "or" could be viewed as meaning "or, if this isn't
+        * a PPPoE packet...".
+        */
+       orig_linktype = off_linktype;   /* save original values */
+       orig_nl = off_nl;
+
+       /*
+        * The "network-layer" protocol is PPPoE, which has a 6-byte
+        * PPPoE header, followed by PPP payload, so we set the
+        * offsets to the network layer offset plus 6 bytes for
+        * the PPPoE header plus the values appropriate for PPP when
+        * encapsulated in Ethernet (which means there's no HDLC
+        * encapsulation).
+        */
+       off_linktype = orig_nl + 6;
+       off_nl = orig_nl + 6 + 2;
+       off_nl_nosnap = orig_nl + 6 + 2;
+
+       /*
+        * Set the link-layer type to PPP, as all subsequent tests will
+        * be on the encapsulated PPP header.
+        */
+       linktype = DLT_PPP;
+
+       return b0;
+}
+

 struct block *
 gen_atmfield_code(atmfield, jvalue, jtype, reverse)
        int atmfield;
 struct block *
 gen_atmfield_code(atmfield, jvalue, jtype, reverse)
        int atmfield;

-       bpf_u_int32 jvalue;
+       bpf_int32 jvalue;

        bpf_u_int32 jtype;
        int reverse;
 {
        bpf_u_int32 jtype;
        int reverse;
 {


@@ -5486,8 +6552,8 @@ gen_atmfield_code(atmfield, jvalue, jtype, reverse)
                        bpf_error("'vpi' supported only on raw ATM");
                if (off_vpi == (u_int)-1)
                        abort();
                        bpf_error("'vpi' supported only on raw ATM");
                if (off_vpi == (u_int)-1)
                        abort();

-               b0 = gen_ncmp(BPF_B, off_vpi, 0xffffffff, (u_int)jtype,
-                   (u_int)jvalue, reverse);
+               b0 = gen_ncmp(OR_LINK, off_vpi, BPF_B, 0xffffffff, jtype,
+                   reverse, jvalue);

                break;
 
        case A_VCI:
                break;
 
        case A_VCI:


@@ -5495,22 +6561,22 @@ gen_atmfield_code(atmfield, jvalue, jtype, reverse)
                        bpf_error("'vci' supported only on raw ATM");
                if (off_vci == (u_int)-1)
                        abort();
                        bpf_error("'vci' supported only on raw ATM");
                if (off_vci == (u_int)-1)
                        abort();

-               b0 = gen_ncmp(BPF_H, off_vci, 0xffffffff, (u_int)jtype,
-                   (u_int)jvalue, reverse);
+               b0 = gen_ncmp(OR_LINK, off_vci, BPF_H, 0xffffffff, jtype,
+                   reverse, jvalue);

                break;
 
        case A_PROTOTYPE:
                if (off_proto == (u_int)-1)
                        abort();        /* XXX - this isn't on FreeBSD */
                break;
 
        case A_PROTOTYPE:
                if (off_proto == (u_int)-1)
                        abort();        /* XXX - this isn't on FreeBSD */

-               b0 = gen_ncmp(BPF_B, off_proto, 0x0f, (u_int)jtype,
-                   (u_int)jvalue, reverse);
+               b0 = gen_ncmp(OR_LINK, off_proto, BPF_B, 0x0f, jtype,
+                   reverse, jvalue);

                break;
 
        case A_MSGTYPE:
                if (off_payload == (u_int)-1)
                        abort();
                break;
 
        case A_MSGTYPE:
                if (off_payload == (u_int)-1)
                        abort();

-               b0 = gen_ncmp(BPF_B, off_payload + MSG_TYPE_POS, 0xffffffff,
-                   (u_int)jtype, (u_int)jvalue, reverse);
+               b0 = gen_ncmp(OR_LINK, off_payload + MSG_TYPE_POS, BPF_B,
+                   0xffffffff, jtype, reverse, jvalue);

                break;
 
        case A_CALLREFTYPE:
                break;
 
        case A_CALLREFTYPE:


@@ -5518,8 +6584,8 @@ gen_atmfield_code(atmfield, jvalue, jtype, reverse)
                        bpf_error("'callref' supported only on raw ATM");
                if (off_proto == (u_int)-1)
                        abort();
                        bpf_error("'callref' supported only on raw ATM");
                if (off_proto == (u_int)-1)
                        abort();

-               b0 = gen_ncmp(BPF_B, off_proto, 0xffffffff, (u_int)jtype,
-                   (u_int)jvalue, reverse);
+               b0 = gen_ncmp(OR_LINK, off_proto, BPF_B, 0xffffffff,
+                   jtype, reverse, jvalue);

                break;
 
        default:
                break;
 
        default:


@@ -5629,6 +6695,86 @@ gen_atmtype_abbrev(type)
        return b1;
 }
 
        return b1;
 }
 

+struct block *
+gen_mtp3field_code(mtp3field, jvalue, jtype, reverse)
+       int mtp3field;
+       bpf_u_int32 jvalue;
+       bpf_u_int32 jtype;
+       int reverse;
+{
+       struct block *b0;
+       bpf_u_int32 val1 , val2 , val3;
+
+       switch (mtp3field) {
+
+       case M_SIO:
+               if (off_sio == (u_int)-1)
+                       bpf_error("'sio' supported only on SS7");
+               /* sio coded on 1 byte so max value 255 */
+               if(jvalue > 255)
+                       bpf_error("sio value %u too big; max value = 255",
+                           jvalue);
+               b0 = gen_ncmp(OR_PACKET, off_sio, BPF_B, 0xffffffff,
+                   (u_int)jtype, reverse, (u_int)jvalue);
+               break;
+
+        case M_OPC:
+               if (off_opc == (u_int)-1)
+                       bpf_error("'opc' supported only on SS7");
+               /* opc coded on 14 bits so max value 16383 */
+               if (jvalue > 16383)
+                       bpf_error("opc value %u too big; max value = 16383",
+                           jvalue);
+               /* the following instructions are made to convert jvalue
+                * to the form used to write opc in an ss7 message*/
+               val1 = jvalue & 0x00003c00;
+               val1 = val1 >>10;
+               val2 = jvalue & 0x000003fc;
+               val2 = val2 <<6;
+               val3 = jvalue & 0x00000003;
+               val3 = val3 <<22;
+               jvalue = val1 + val2 + val3;
+               b0 = gen_ncmp(OR_PACKET, off_opc, BPF_W, 0x00c0ff0f,
+                   (u_int)jtype, reverse, (u_int)jvalue);
+               break;
+
+       case M_DPC:
+               if (off_dpc == (u_int)-1)
+                       bpf_error("'dpc' supported only on SS7");
+               /* dpc coded on 14 bits so max value 16383 */
+               if (jvalue > 16383)
+                       bpf_error("dpc value %u too big; max value = 16383",
+                           jvalue);
+               /* the following instructions are made to convert jvalue
+                * to the forme used to write dpc in an ss7 message*/
+               val1 = jvalue & 0x000000ff;
+               val1 = val1 << 24;
+               val2 = jvalue & 0x00003f00;
+               val2 = val2 << 8;
+               jvalue = val1 + val2;
+               b0 = gen_ncmp(OR_PACKET, off_dpc, BPF_W, 0xff3f0000,
+                   (u_int)jtype, reverse, (u_int)jvalue);
+               break;
+
+       case M_SLS:
+               if (off_sls == (u_int)-1)
+                       bpf_error("'sls' supported only on SS7");
+               /* sls coded on 4 bits so max value 15 */
+               if (jvalue > 15)
+                        bpf_error("sls value %u too big; max value = 15",
+                            jvalue);
+               /* the following instruction is made to convert jvalue
+                * to the forme used to write sls in an ss7 message*/
+               jvalue = jvalue << 4;
+               b0 = gen_ncmp(OR_PACKET, off_sls, BPF_B, 0xf0,
+                   (u_int)jtype,reverse, (u_int)jvalue);
+               break;
+
+       default:
+               abort();
+       }
+       return b0;
+}

 
 static struct block *
 gen_msg_abbrev(type)
 
 static struct block *
 gen_msg_abbrev(type)