Consolidate MAC-48 address matching code.

[libpcap] / gencode.c

diff --git a/gencode.c b/gencode.c
index be32973a013177de29437c42bbb830b74f72be49..eed4863cbb7189c5730d1fb5ddec4969295dfb3e 100644 (file)
--- a/gencode.c
+++ b/gencode.c
@@ -254,6 +254,12 @@ struct addrinfo {
 #define ISIS_L2_CSNP         25
 #define ISIS_L1_PSNP         26
 #define ISIS_L2_PSNP         27
 #define ISIS_L2_CSNP         25
 #define ISIS_L1_PSNP         26
 #define ISIS_L2_PSNP         27

+/*
+ * The maximum possible value can also be used as a bit mask because the
+ * "PDU Type" field comprises the least significant 5 bits of a particular
+ * octet, see sections 9.5~9.13 of ISO/IEC 10589:2002(E).
+ */
+#define ISIS_PDU_TYPE_MAX 0x1FU

 
 #ifndef ISO8878A_CONS
 #define        ISO8878A_CONS           0x84
 
 #ifndef ISO8878A_CONS
 #define        ISO8878A_CONS           0x84


@@ -629,10 +635,18 @@ static struct block *gen_cmp_lt(compiler_state_t *, enum e_offrel, u_int,
     u_int, bpf_u_int32);
 static struct block *gen_cmp_le(compiler_state_t *, enum e_offrel, u_int,
     u_int, bpf_u_int32);
     u_int, bpf_u_int32);
 static struct block *gen_cmp_le(compiler_state_t *, enum e_offrel, u_int,
     u_int, bpf_u_int32);

+static struct block *gen_cmp_ne(compiler_state_t *, enum e_offrel, u_int,
+    u_int size, bpf_u_int32);

 static struct block *gen_mcmp(compiler_state_t *, enum e_offrel, u_int,
     u_int, bpf_u_int32, bpf_u_int32);
 static struct block *gen_mcmp(compiler_state_t *, enum e_offrel, u_int,
     u_int, bpf_u_int32, bpf_u_int32);

+static struct block *gen_mcmp_ne(compiler_state_t *, enum e_offrel, u_int,
+    u_int, bpf_u_int32, bpf_u_int32);

 static struct block *gen_bcmp(compiler_state_t *, enum e_offrel, u_int,
     u_int, const u_char *);
 static struct block *gen_bcmp(compiler_state_t *, enum e_offrel, u_int,
     u_int, const u_char *);

+static struct block *gen_jmp(compiler_state_t *, int, bpf_u_int32,
+    struct slist *);
+static struct block *gen_set(compiler_state_t *, bpf_u_int32, struct slist *);
+static struct block *gen_unset(compiler_state_t *, bpf_u_int32, struct slist *);

 static struct block *gen_ncmp(compiler_state_t *, enum e_offrel, u_int,
     u_int, bpf_u_int32, int, int, bpf_u_int32);
 static struct slist *gen_load_absoffsetrel(compiler_state_t *, bpf_abs_offset *,
 static struct block *gen_ncmp(compiler_state_t *, enum e_offrel, u_int,
     u_int, bpf_u_int32, int, int, bpf_u_int32);
 static struct slist *gen_load_absoffsetrel(compiler_state_t *, bpf_abs_offset *,


@@ -654,7 +668,7 @@ static struct slist *gen_load_ppi_llprefixlen(compiler_state_t *);
 static void insert_compute_vloffsets(compiler_state_t *, struct block *);
 static struct slist *gen_abs_offset_varpart(compiler_state_t *,
     bpf_abs_offset *);
 static void insert_compute_vloffsets(compiler_state_t *, struct block *);
 static struct slist *gen_abs_offset_varpart(compiler_state_t *,
     bpf_abs_offset *);

-static bpf_u_int32 ethertype_to_ppptype(bpf_u_int32);
+static uint16_t ethertype_to_ppptype(compiler_state_t *, bpf_u_int32);

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


@@ -665,11 +679,10 @@ static struct block *gen_hostop6(compiler_state_t *, struct in6_addr *,
     struct in6_addr *, int, u_int, u_int);
 #endif
 static struct block *gen_ahostop(compiler_state_t *, const uint8_t, int);
     struct in6_addr *, int, u_int, u_int);
 #endif
 static struct block *gen_ahostop(compiler_state_t *, const uint8_t, int);

-static struct block *gen_ehostop(compiler_state_t *, const u_char *, int);
-static struct block *gen_fhostop(compiler_state_t *, const u_char *, int);
-static struct block *gen_thostop(compiler_state_t *, const u_char *, int);

 static struct block *gen_wlanhostop(compiler_state_t *, const u_char *, int);
 static struct block *gen_wlanhostop(compiler_state_t *, const u_char *, int);

-static struct block *gen_ipfchostop(compiler_state_t *, const u_char *, int);
+static unsigned char is_mac48_linktype(const int);
+static struct block *gen_mac48host(compiler_state_t *, const u_char *,
+    const u_char, const char *);

 static struct block *gen_dnhostop(compiler_state_t *, bpf_u_int32, int);
 static struct block *gen_mpls_linktype(compiler_state_t *, bpf_u_int32);
 static struct block *gen_host(compiler_state_t *, bpf_u_int32, bpf_u_int32,
 static struct block *gen_dnhostop(compiler_state_t *, bpf_u_int32, int);
 static struct block *gen_mpls_linktype(compiler_state_t *, bpf_u_int32);
 static struct block *gen_host(compiler_state_t *, bpf_u_int32, bpf_u_int32,


@@ -680,30 +693,30 @@ static struct block *gen_host6(compiler_state_t *, struct in6_addr *,
 #endif
 #ifndef INET6
 static struct block *gen_gateway(compiler_state_t *, const u_char *,
 #endif
 #ifndef INET6
 static struct block *gen_gateway(compiler_state_t *, const u_char *,

-    struct addrinfo *, int, int);
+    struct addrinfo *, int);

 #endif
 #endif

+static struct block *gen_ip_proto(compiler_state_t *, const uint8_t);
+static struct block *gen_ip6_proto(compiler_state_t *, const uint8_t);

 static struct block *gen_ipfrag(compiler_state_t *);
 static struct block *gen_ipfrag(compiler_state_t *);

-static struct block *gen_portatom(compiler_state_t *, int, bpf_u_int32);
-static struct block *gen_portrangeatom(compiler_state_t *, u_int, bpf_u_int32,
-    bpf_u_int32);
-static struct block *gen_portatom6(compiler_state_t *, int, bpf_u_int32);
-static struct block *gen_portrangeatom6(compiler_state_t *, u_int, bpf_u_int32,
-    bpf_u_int32);
-static struct block *gen_portop(compiler_state_t *, u_int, u_int, int);
-static struct block *gen_port(compiler_state_t *, u_int, int, int);
-static struct block *gen_portrangeop(compiler_state_t *, u_int, u_int,
-    bpf_u_int32, int);
-static struct block *gen_portrange(compiler_state_t *, u_int, u_int, int, int);
-struct block *gen_portop6(compiler_state_t *, u_int, u_int, int);
-static struct block *gen_port6(compiler_state_t *, u_int, int, int);
-static struct block *gen_portrangeop6(compiler_state_t *, u_int, u_int,
-    bpf_u_int32, int);
-static struct block *gen_portrange6(compiler_state_t *, u_int, u_int, int, int);
+static struct block *gen_portatom(compiler_state_t *, int, uint16_t);
+static struct block *gen_portrangeatom(compiler_state_t *, u_int, uint16_t,
+    uint16_t);
+static struct block *gen_portatom6(compiler_state_t *, int, uint16_t);
+static struct block *gen_portrangeatom6(compiler_state_t *, u_int, uint16_t,
+    uint16_t);
+static struct block *gen_port(compiler_state_t *, uint16_t, int, int);
+static struct block *gen_port_common(compiler_state_t *, int, struct block *);
+static struct block *gen_portrange(compiler_state_t *, uint16_t, uint16_t,
+    int, int);
+static struct block *gen_port6(compiler_state_t *, uint16_t, int, int);
+static struct block *gen_port6_common(compiler_state_t *, int, struct block *);
+static struct block *gen_portrange6(compiler_state_t *, uint16_t, uint16_t,
+    int, int);

 static int lookup_proto(compiler_state_t *, const char *, int);
 #if !defined(NO_PROTOCHAIN)
 static struct block *gen_protochain(compiler_state_t *, bpf_u_int32, int);
 #endif /* !defined(NO_PROTOCHAIN) */
 static int lookup_proto(compiler_state_t *, const char *, int);
 #if !defined(NO_PROTOCHAIN)
 static struct block *gen_protochain(compiler_state_t *, bpf_u_int32, int);
 #endif /* !defined(NO_PROTOCHAIN) */

-static struct block *gen_proto(compiler_state_t *, bpf_u_int32, int, int);
+static struct block *gen_proto(compiler_state_t *, bpf_u_int32, int);

 static struct slist *xfer_to_x(compiler_state_t *, struct arth *);
 static struct slist *xfer_to_a(compiler_state_t *, struct arth *);
 static struct block *gen_mac_multicast(compiler_state_t *, int);
 static struct slist *xfer_to_x(compiler_state_t *, struct arth *);
 static struct slist *xfer_to_a(compiler_state_t *, struct arth *);
 static struct block *gen_mac_multicast(compiler_state_t *, int);


@@ -713,7 +726,10 @@ static struct block *gen_encap_ll_check(compiler_state_t *cstate);
 static struct block *gen_atmfield_code_internal(compiler_state_t *, int,
     bpf_u_int32, int, int);
 static struct block *gen_atmtype_llc(compiler_state_t *);
 static struct block *gen_atmfield_code_internal(compiler_state_t *, int,
     bpf_u_int32, int, int);
 static struct block *gen_atmtype_llc(compiler_state_t *);

-static struct block *gen_msg_abbrev(compiler_state_t *, int type);
+static struct block *gen_msg_abbrev(compiler_state_t *, const uint8_t);
+static struct block *gen_atm_prototype(compiler_state_t *, const uint8_t);
+static struct block *gen_atm_vpi(compiler_state_t *, const uint8_t);
+static struct block *gen_atm_vci(compiler_state_t *, const uint16_t);

 
 static void
 initchunks(compiler_state_t *cstate)
 
 static void
 initchunks(compiler_state_t *cstate)


@@ -961,16 +977,8 @@ atmkw(const unsigned id)
                [A_OAM] = "oam",
                [A_OAMF4] = "oamf4",
                [A_LANE] = "lane",
                [A_OAM] = "oam",
                [A_OAMF4] = "oamf4",
                [A_LANE] = "lane",

-               // no keyword for A_SETUP
-               // no keyword for A_CALLPROCEED
-               // no keyword for A_CONNECT
-               // no keyword for A_CONNECTACK
-               // no keyword for A_RELEASE
-               // no keyword for A_RELEASE_DONE

                [A_VPI] = "vpi",
                [A_VCI] = "vci",
                [A_VPI] = "vpi",
                [A_VCI] = "vci",

-               // no keyword for A_PROTOTYPE
-               // no keyword for A_MSGTYPE

                [A_CONNECTMSG] = "connectmsg",
                [A_METACONNECT] = "metaconnect",
        };
                [A_CONNECTMSG] = "connectmsg",
                [A_METACONNECT] = "metaconnect",
        };


@@ -1058,6 +1066,24 @@ assert_maxval(compiler_state_t *cstate, const char *name,
 
 #define ERRSTR_802_11_ONLY_KW "'%s' is valid for 802.11 syntax only"
 #define ERRSTR_INVALID_QUAL "'%s' is not a valid qualifier for '%s'"
 
 #define ERRSTR_802_11_ONLY_KW "'%s' is valid for 802.11 syntax only"
 #define ERRSTR_INVALID_QUAL "'%s' is not a valid qualifier for '%s'"

+#define ERRSTR_UNKNOWN_MAC48HOST "unknown Ethernet-like host '%s'"
+
+// Validate a port/portrange proto qualifier and map to an IP protocol number.
+static int
+port_pq_to_ipproto(compiler_state_t *cstate, const int proto, const char *kw)
+{
+       switch (proto) {
+       case Q_UDP:
+               return IPPROTO_UDP;
+       case Q_TCP:
+               return IPPROTO_TCP;
+       case Q_SCTP:
+               return IPPROTO_SCTP;
+       case Q_DEFAULT:
+               return PROTO_UNDEF;
+       }
+       bpf_error(cstate, ERRSTR_INVALID_QUAL, pqkw(proto), kw);
+}

 
 int
 pcap_compile(pcap_t *p, struct bpf_program *program,
 
 int
 pcap_compile(pcap_t *p, struct bpf_program *program,


@@ -1420,13 +1446,40 @@ gen_cmp_le(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
        return gen_ncmp(cstate, offrel, offset, size, 0xffffffff, BPF_JGT, 1, v);
 }
 
        return gen_ncmp(cstate, offrel, offset, size, 0xffffffff, BPF_JGT, 1, v);
 }
 

+static struct block *
+gen_cmp_ne(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
+    u_int size, bpf_u_int32 v)
+{
+       return gen_ncmp(cstate, offrel, offset, size, 0xffffffff, BPF_JEQ, 1, v);
+}
+

 static struct block *
 gen_mcmp(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
     u_int size, bpf_u_int32 v, bpf_u_int32 mask)
 {
 static struct block *
 gen_mcmp(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
     u_int size, bpf_u_int32 v, bpf_u_int32 mask)
 {

+       /*
+        * For any A: if mask == 0, it means A & mask == 0, so the result is
+        * true iff v == 0.  In this case ideally the caller should have
+        * skipped this invocation and have fewer statement blocks to juggle.
+        * If the caller could have skipped, but has not, produce a block with
+        * fewer statements.
+        *
+        * This could be done in gen_ncmp() in a more generic way, but this
+        * function is the only code path that can have mask == 0.
+        */
+       if (mask == 0)
+               return v ? gen_false(cstate) : gen_true(cstate);
+

        return gen_ncmp(cstate, offrel, offset, size, mask, BPF_JEQ, 0, v);
 }
 
        return gen_ncmp(cstate, offrel, offset, size, mask, BPF_JEQ, 0, v);
 }
 

+static struct block *
+gen_mcmp_ne(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
+    u_int size, bpf_u_int32 v, bpf_u_int32 mask)
+{
+       return gen_ncmp(cstate, offrel, offset, size, mask, BPF_JEQ, 1, v);
+}
+

 static struct block *
 gen_bcmp(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
     u_int size, const u_char *v)
 static struct block *
 gen_bcmp(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
     u_int size, const u_char *v)


@@ -1463,6 +1516,29 @@ gen_bcmp(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
        return b;
 }
 
        return b;
 }
 

+static struct block *
+gen_jmp(compiler_state_t *cstate, int jtype, bpf_u_int32 v, struct slist *stmts)
+{
+       struct block *b = new_block(cstate, JMP(jtype));
+       b->s.k = v;
+       b->stmts = stmts;
+       return b;
+}
+
+static struct block *
+gen_set(compiler_state_t *cstate, bpf_u_int32 v, struct slist *stmts)
+{
+       return gen_jmp(cstate, BPF_JSET, v, stmts);
+}
+
+static struct block *
+gen_unset(compiler_state_t *cstate, bpf_u_int32 v, struct slist *stmts)
+{
+       struct block *b = gen_set(cstate, v, stmts);
+       gen_not(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"
 /*
  * 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"


@@ -1485,9 +1561,7 @@ gen_ncmp(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
                sappend(s, s2);
        }
 
                sappend(s, s2);
        }
 

-       b = new_block(cstate, JMP(jtype));
-       b->stmts = s;
-       b->s.k = v;
+       b = gen_jmp(cstate, jtype, v, s);

        if (reverse)
                gen_not(b);
        return b;
        if (reverse)
                gen_not(b);
        return b;


@@ -2280,15 +2354,11 @@ gen_loadx_iphdrlen(compiler_state_t *cstate)
 static struct block *
 gen_uncond(compiler_state_t *cstate, int rsense)
 {
 static struct block *
 gen_uncond(compiler_state_t *cstate, int rsense)
 {

-       struct block *b;

        struct slist *s;
 
        s = new_stmt(cstate, BPF_LD|BPF_IMM);
        s->s.k = !rsense;
        struct slist *s;
 
        s = new_stmt(cstate, BPF_LD|BPF_IMM);
        s->s.k = !rsense;

-       b = new_block(cstate, JMP(BPF_JEQ));
-       b->stmts = s;
-
-       return b;
+       return gen_jmp(cstate, BPF_JEQ, 0, s);

 }
 
 static inline struct block *
 }
 
 static inline struct block *


@@ -2449,6 +2519,7 @@ gen_ether_linktype(compiler_state_t *cstate, bpf_u_int32 ll_proto)
 
        default:
                if (ll_proto <= ETHERMTU) {
 
        default:
                if (ll_proto <= ETHERMTU) {

+                       assert_maxval(cstate, "LLC DSAP", ll_proto, UINT8_MAX);

                        /*
                         * This is an LLC SAP value, so the frames
                         * that match would be 802.2 frames.
                        /*
                         * This is an LLC SAP value, so the frames
                         * that match would be 802.2 frames.


@@ -2462,6 +2533,7 @@ gen_ether_linktype(compiler_state_t *cstate, bpf_u_int32 ll_proto)
                        gen_and(b0, b1);
                        return b1;
                } else {
                        gen_and(b0, b1);
                        return b1;
                } else {

+                       assert_maxval(cstate, "EtherType", ll_proto, UINT16_MAX);

                        /*
                         * This is an Ethernet type, so compare
                         * the length/type field with it (if
                        /*
                         * This is an Ethernet type, so compare
                         * the length/type field with it (if


@@ -2661,6 +2733,7 @@ gen_linux_sll_linktype(compiler_state_t *cstate, bpf_u_int32 ll_proto)
 
        default:
                if (ll_proto <= ETHERMTU) {
 
        default:
                if (ll_proto <= ETHERMTU) {

+                       assert_maxval(cstate, "LLC DSAP", ll_proto, UINT8_MAX);

                        /*
                         * This is an LLC SAP value, so the frames
                         * that match would be 802.2 frames.
                        /*
                         * This is an LLC SAP value, so the frames
                         * that match would be 802.2 frames.


@@ -2674,6 +2747,7 @@ gen_linux_sll_linktype(compiler_state_t *cstate, bpf_u_int32 ll_proto)
                        gen_and(b0, b1);
                        return b1;
                } else {
                        gen_and(b0, b1);
                        return b1;
                } else {

+                       assert_maxval(cstate, "EtherType", ll_proto, UINT16_MAX);

                        /*
                         * This is an Ethernet type, so compare
                         * the length/type field with it (if
                        /*
                         * This is an Ethernet type, so compare
                         * the length/type field with it (if


@@ -3105,7 +3179,7 @@ gen_load_802_11_header_len(compiler_state_t *cstate, struct slist *s, struct sli
         * 0x04 bit (b2) clear.
         */
        sjset_data_frame_1 = new_stmt(cstate, JMP(BPF_JSET));
         * 0x04 bit (b2) clear.
         */
        sjset_data_frame_1 = new_stmt(cstate, JMP(BPF_JSET));

-       sjset_data_frame_1->s.k = 0x08;
+       sjset_data_frame_1->s.k = IEEE80211_FC0_TYPE_DATA;

        sappend(s, sjset_data_frame_1);
 
        /*
        sappend(s, sjset_data_frame_1);
 
        /*


@@ -3113,7 +3187,7 @@ gen_load_802_11_header_len(compiler_state_t *cstate, struct slist *s, struct sli
         * the rest of the program.
         */
        sjset_data_frame_1->s.jt = sjset_data_frame_2 = new_stmt(cstate, JMP(BPF_JSET));
         * the rest of the program.
         */
        sjset_data_frame_1->s.jt = sjset_data_frame_2 = new_stmt(cstate, JMP(BPF_JSET));

-       sjset_data_frame_2->s.k = 0x04;
+       sjset_data_frame_2->s.k = IEEE80211_FC0_TYPE_CTL;

        sappend(s, sjset_data_frame_2);
        sjset_data_frame_1->s.jf = snext;
 
        sappend(s, sjset_data_frame_2);
        sjset_data_frame_1->s.jf = snext;
 


@@ -3124,7 +3198,7 @@ gen_load_802_11_header_len(compiler_state_t *cstate, struct slist *s, struct sli
         */
        sjset_data_frame_2->s.jt = snext;
        sjset_data_frame_2->s.jf = sjset_qos = new_stmt(cstate, JMP(BPF_JSET));
         */
        sjset_data_frame_2->s.jt = snext;
        sjset_data_frame_2->s.jf = sjset_qos = new_stmt(cstate, JMP(BPF_JSET));

-       sjset_qos->s.k = 0x80;  /* QoS bit */
+       sjset_qos->s.k = IEEE80211_FC0_SUBTYPE_QOS;

        sappend(s, sjset_qos);
 
        /*
        sappend(s, sjset_qos);
 
        /*


@@ -3415,34 +3489,28 @@ gen_abs_offset_varpart(compiler_state_t *cstate, bpf_abs_offset *off)
 /*
  * Map an Ethernet type to the equivalent PPP type.
  */
 /*
  * Map an Ethernet type to the equivalent PPP type.
  */

-static bpf_u_int32
-ethertype_to_ppptype(bpf_u_int32 ll_proto)
+static uint16_t
+ethertype_to_ppptype(compiler_state_t *cstate, bpf_u_int32 ll_proto)

 {
        switch (ll_proto) {
 
        case ETHERTYPE_IP:
 {
        switch (ll_proto) {
 
        case ETHERTYPE_IP:

-               ll_proto = PPP_IP;
-               break;
+               return PPP_IP;

 
        case ETHERTYPE_IPV6:
 
        case ETHERTYPE_IPV6:

-               ll_proto = PPP_IPV6;
-               break;
+               return PPP_IPV6;

 
        case ETHERTYPE_DN:
 
        case ETHERTYPE_DN:

-               ll_proto = PPP_DECNET;
-               break;
+               return PPP_DECNET;

 
        case ETHERTYPE_ATALK:
 
        case ETHERTYPE_ATALK:

-               ll_proto = PPP_APPLE;
-               break;
+               return PPP_APPLE;

 
        case ETHERTYPE_NS:
 
        case ETHERTYPE_NS:

-               ll_proto = PPP_NS;
-               break;
+               return PPP_NS;

 
        case LLCSAP_ISONS:
 
        case LLCSAP_ISONS:

-               ll_proto = PPP_OSI;
-               break;
+               return PPP_OSI;

 
        case LLCSAP_8021D:
                /*
 
        case LLCSAP_8021D:
                /*


@@ -3450,14 +3518,13 @@ ethertype_to_ppptype(bpf_u_int32 ll_proto)
                 * over PPP are Spanning Tree Protocol
                 * Bridging PDUs.
                 */
                 * over PPP are Spanning Tree Protocol
                 * Bridging PDUs.
                 */

-               ll_proto = PPP_BRPDU;
-               break;
+               return PPP_BRPDU;

 
        case LLCSAP_IPX:
 
        case LLCSAP_IPX:

-               ll_proto = PPP_IPX;
-               break;
+               return PPP_IPX;

        }
        }

-       return (ll_proto);
+       assert_maxval(cstate, "PPP protocol", ll_proto, UINT16_MAX);
+       return (uint16_t)ll_proto;

 }
 
 /*
 }
 
 /*


@@ -3469,8 +3536,6 @@ ethertype_to_ppptype(bpf_u_int32 ll_proto)
 static struct block *
 gen_prevlinkhdr_check(compiler_state_t *cstate)
 {
 static struct block *
 gen_prevlinkhdr_check(compiler_state_t *cstate)
 {

-       struct block *b0;
-

        if (cstate->is_encap)
                return gen_encap_ll_check(cstate);
 
        if (cstate->is_encap)
                return gen_encap_ll_check(cstate);
 


@@ -3484,9 +3549,7 @@ gen_prevlinkhdr_check(compiler_state_t *cstate)
                 *
                 * (We've already generated a test for LANE.)
                 */
                 *
                 * (We've already generated a test for LANE.)
                 */

-               b0 = gen_cmp(cstate, OR_PREVLINKHDR, SUNATM_PKT_BEGIN_POS, BPF_H, 0xFF00);
-               gen_not(b0);
-               return b0;
+               return gen_cmp_ne(cstate, OR_PREVLINKHDR, SUNATM_PKT_BEGIN_POS, BPF_H, 0xFF00);

 
        default:
                /*
 
        default:
                /*


@@ -3541,6 +3604,7 @@ gen_linktype(compiler_state_t *cstate, bpf_u_int32 ll_proto)
 
        case DLT_C_HDLC:
        case DLT_HDLC:
 
        case DLT_C_HDLC:
        case DLT_HDLC:

+               assert_maxval(cstate, "HDLC protocol", ll_proto, UINT16_MAX);

                switch (ll_proto) {
 
                case LLCSAP_ISONS:
                switch (ll_proto) {
 
                case LLCSAP_ISONS:


@@ -3600,7 +3664,7 @@ gen_linktype(compiler_state_t *cstate, bpf_u_int32 ll_proto)
                 *
                 * Check for LLC encapsulation and then check the protocol.
                 */
                 *
                 * Check for LLC encapsulation and then check the protocol.
                 */

-               b0 = gen_atmfield_code_internal(cstate, A_PROTOTYPE, PT_LLC, BPF_JEQ, 0);
+               b0 = gen_atm_prototype(cstate, PT_LLC);

                b1 = gen_llc_linktype(cstate, ll_proto);
                gen_and(b0, b1);
                return b1;
                b1 = gen_llc_linktype(cstate, ll_proto);
                gen_and(b0, b1);
                return b1;


@@ -3666,7 +3730,7 @@ gen_linktype(compiler_state_t *cstate, bpf_u_int32 ll_proto)
                 * map them to the corresponding PPP protocol types.
                 */
                return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H,
                 * map them to the corresponding PPP protocol types.
                 */
                return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H,

-                   ethertype_to_ppptype(ll_proto));
+                   ethertype_to_ppptype(cstate, ll_proto));

                /*NOTREACHED*/
 
        case DLT_PPP_BSDOS:
                /*NOTREACHED*/
 
        case DLT_PPP_BSDOS:


@@ -3690,7 +3754,7 @@ gen_linktype(compiler_state_t *cstate, bpf_u_int32 ll_proto)
 
                default:
                        return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H,
 
                default:
                        return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H,

-                           ethertype_to_ppptype(ll_proto));
+                           ethertype_to_ppptype(cstate, ll_proto));

                }
                /*NOTREACHED*/
 
                }
                /*NOTREACHED*/
 


@@ -3967,6 +4031,7 @@ gen_linktype(compiler_state_t *cstate, bpf_u_int32 ll_proto)
                         * it's not, it needs to be handled specially
                         * above.)
                         */
                         * it's not, it needs to be handled specially
                         * above.)
                         */

+                       assert_maxval(cstate, "EtherType", ll_proto, UINT16_MAX);

                        return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, ll_proto);
                        /*NOTREACHED */
                }
                        return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, ll_proto);
                        /*NOTREACHED */
                }


@@ -4019,8 +4084,7 @@ gen_llc_internal(compiler_state_t *cstate)
                 * Now check for the purported DSAP and SSAP not being
                 * 0xFF, to rule out NetWare-over-802.3.
                 */
                 * Now check for the purported DSAP and SSAP not being
                 * 0xFF, to rule out NetWare-over-802.3.
                 */

-               b1 = gen_cmp(cstate, OR_LLC, 0, BPF_H, 0xFFFF);
-               gen_not(b1);
+               b1 = gen_cmp_ne(cstate, OR_LLC, 0, BPF_H, 0xFFFF);

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


@@ -4028,8 +4092,7 @@ gen_llc_internal(compiler_state_t *cstate)
                /*
                 * We check for LLC traffic.
                 */
                /*
                 * We check for LLC traffic.
                 */

-               b0 = gen_atmtype_llc(cstate);
-               return b0;
+               return gen_atmtype_llc(cstate);

 
        case DLT_IEEE802:       /* Token Ring */
                /*
 
        case DLT_IEEE802:       /* Token Ring */
                /*


@@ -4108,10 +4171,8 @@ gen_llc_i(compiler_state_t *cstate)
         * be clear for I frames.
         */
        s = gen_load_a(cstate, OR_LLC, 2, BPF_B);
         * be clear for I frames.
         */
        s = gen_load_a(cstate, OR_LLC, 2, BPF_B);

-       b1 = new_block(cstate, JMP(BPF_JSET));
-       b1->s.k = 0x01;
-       b1->stmts = s;
-       gen_not(b1);
+       b1 = gen_unset(cstate, 0x01, s);
+

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


@@ -4274,12 +4335,14 @@ gen_llc_linktype(compiler_state_t *cstate, bpf_u_int32 ll_proto)
                 * here, but should we check for the IPX Ethertype?
                 */
                if (ll_proto <= ETHERMTU) {
                 * here, but should we check for the IPX Ethertype?
                 */
                if (ll_proto <= ETHERMTU) {

+                       assert_maxval(cstate, "LLC DSAP", ll_proto, UINT8_MAX);

                        /*
                         * This is an LLC SAP value, so check
                         * the DSAP.
                         */
                        return gen_cmp(cstate, OR_LLC, 0, BPF_B, ll_proto);
                } else {
                        /*
                         * This is an LLC SAP value, so check
                         * the DSAP.
                         */
                        return gen_cmp(cstate, OR_LLC, 0, BPF_B, ll_proto);
                } else {

+                       assert_maxval(cstate, "EtherType", ll_proto, UINT16_MAX);

                        /*
                         * This is an Ethernet type; we assume that it's
                         * unlikely that it'll appear in the right place
                        /*
                         * This is an Ethernet type; we assume that it's
                         * unlikely that it'll appear in the right place


@@ -4407,139 +4470,24 @@ gen_hostop6(compiler_state_t *cstate, struct in6_addr *addr,
        /* this order is important */
        memcpy(a, addr, sizeof(a));
        memcpy(m, mask, sizeof(m));
        /* this order is important */
        memcpy(a, addr, sizeof(a));
        memcpy(m, mask, sizeof(m));

-       b1 = gen_mcmp(cstate, OR_LINKPL, offset + 12, BPF_W, ntohl(a[3]), ntohl(m[3]));
-       b0 = gen_mcmp(cstate, OR_LINKPL, offset + 8, BPF_W, ntohl(a[2]), ntohl(m[2]));
-       gen_and(b0, b1);
-       b0 = gen_mcmp(cstate, OR_LINKPL, offset + 4, BPF_W, ntohl(a[1]), ntohl(m[1]));
-       gen_and(b0, b1);
-       b0 = gen_mcmp(cstate, OR_LINKPL, offset + 0, BPF_W, ntohl(a[0]), ntohl(m[0]));
-       gen_and(b0, b1);
-       return b1;
-}
-#endif
-
-static struct block *
-gen_ehostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
-{
-       register struct block *b0, *b1;
-
-       switch (dir) {
-       case Q_SRC:
-               return gen_bcmp(cstate, OR_LINKHDR, 6, 6, eaddr);
-
-       case Q_DST:
-               return gen_bcmp(cstate, OR_LINKHDR, 0, 6, eaddr);
-
-       case Q_AND:
-               b0 = gen_ehostop(cstate, eaddr, Q_SRC);
-               b1 = gen_ehostop(cstate, eaddr, Q_DST);
-               gen_and(b0, b1);
-               return b1;
-
-       case Q_DEFAULT:
-       case Q_OR:
-               b0 = gen_ehostop(cstate, eaddr, Q_SRC);
-               b1 = gen_ehostop(cstate, eaddr, Q_DST);
-               gen_or(b0, b1);
-               return b1;
-
-       case Q_ADDR1:
-       case Q_ADDR2:
-       case Q_ADDR3:
-       case Q_ADDR4:
-       case Q_RA:
-       case Q_TA:
-               bpf_error(cstate, ERRSTR_802_11_ONLY_KW, dqkw(dir));
-               /*NOTREACHED*/
-       }
-       abort();
-       /*NOTREACHED*/
-}
-
-/*
- * Like gen_ehostop, but for DLT_FDDI
- */
-static struct block *
-gen_fhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
-{
-       struct block *b0, *b1;
-
-       switch (dir) {
-       case Q_SRC:
-               return gen_bcmp(cstate, OR_LINKHDR, 6 + 1 + cstate->pcap_fddipad, 6, eaddr);
-
-       case Q_DST:
-               return gen_bcmp(cstate, OR_LINKHDR, 0 + 1 + cstate->pcap_fddipad, 6, eaddr);
-
-       case Q_AND:
-               b0 = gen_fhostop(cstate, eaddr, Q_SRC);
-               b1 = gen_fhostop(cstate, eaddr, Q_DST);
-               gen_and(b0, b1);
-               return b1;
-
-       case Q_DEFAULT:
-       case Q_OR:
-               b0 = gen_fhostop(cstate, eaddr, Q_SRC);
-               b1 = gen_fhostop(cstate, eaddr, Q_DST);
-               gen_or(b0, b1);
-               return b1;
-
-       case Q_ADDR1:
-       case Q_ADDR2:
-       case Q_ADDR3:
-       case Q_ADDR4:
-       case Q_RA:
-       case Q_TA:
-               bpf_error(cstate, ERRSTR_802_11_ONLY_KW, dqkw(dir));
-               /*NOTREACHED*/
-       }
-       abort();
-       /*NOTREACHED*/
-}
-
-/*
- * Like gen_ehostop, but for DLT_IEEE802 (Token Ring)
- */
-static struct block *
-gen_thostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
-{
-       register struct block *b0, *b1;
-
-       switch (dir) {
-       case Q_SRC:
-               return gen_bcmp(cstate, OR_LINKHDR, 8, 6, eaddr);
-
-       case Q_DST:
-               return gen_bcmp(cstate, OR_LINKHDR, 2, 6, eaddr);
-
-       case Q_AND:
-               b0 = gen_thostop(cstate, eaddr, Q_SRC);
-               b1 = gen_thostop(cstate, eaddr, Q_DST);
-               gen_and(b0, b1);
-               return b1;
-
-       case Q_DEFAULT:
-       case Q_OR:
-               b0 = gen_thostop(cstate, eaddr, Q_SRC);
-               b1 = gen_thostop(cstate, eaddr, Q_DST);
-               gen_or(b0, b1);
-               return b1;
-
-       case Q_ADDR1:
-       case Q_ADDR2:
-       case Q_ADDR3:
-       case Q_ADDR4:
-       case Q_RA:
-       case Q_TA:
-               bpf_error(cstate, ERRSTR_802_11_ONLY_KW, dqkw(dir));
-               /*NOTREACHED*/
+       b1 = NULL;
+       for (int i = 3; i >= 0; i--) {
+               // Same as the Q_IP case in gen_host().
+               if (m[i] == 0 && a[i] == 0)
+                       continue;
+               b0 = gen_mcmp(cstate, OR_LINKPL, offset + 4 * i, BPF_W,
+                   ntohl(a[i]), ntohl(m[i]));
+               if (b1)
+                       gen_and(b0, b1);
+               else
+                       b1 = b0;

        }
        }

-       abort();
-       /*NOTREACHED*/
+       return b1 ? b1 : gen_true(cstate);

 }
 }

+#endif

 
 /*
 
 /*

- * Like gen_ehostop, but for DLT_IEEE802_11 (802.11 wireless LAN) and
+ * Like gen_mac48host(), but for DLT_IEEE802_11 (802.11 wireless LAN) and

  * various 802.11 + radio headers.
  */
 static struct block *
  * various 802.11 + radio headers.
  */
 static struct block *


@@ -4586,9 +4534,7 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * First, check for To DS set, i.e. check "link[1] & 0x01".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);
                 * First, check for To DS set, i.e. check "link[1] & 0x01".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);

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

 
                /*
                 * If To DS is set, the SA is at 24.
 
                /*
                 * If To DS is set, the SA is at 24.


@@ -4601,10 +4547,7 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * "!(link[1] & 0x01)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);
                 * "!(link[1] & 0x01)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);

-               b2 = new_block(cstate, JMP(BPF_JSET));
-               b2->s.k = 0x01; /* To DS */
-               b2->stmts = s;
-               gen_not(b2);
+               b2 = gen_unset(cstate, IEEE80211_FC1_DIR_TODS, s);

 
                /*
                 * If To DS is not set, the SA is at 16.
 
                /*
                 * If To DS is not set, the SA is at 16.


@@ -4624,19 +4567,14 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * the ORed-together checks.
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);
                 * the ORed-together checks.
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);

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

                gen_and(b1, b0);
 
                /*
                 * Now check for data frames with From DS not set.
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);
                gen_and(b1, b0);
 
                /*
                 * Now check for data frames with From DS not set.
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);

-               b2 = new_block(cstate, JMP(BPF_JSET));
-               b2->s.k = 0x02; /* From DS */
-               b2->stmts = s;
-               gen_not(b2);
+               b2 = gen_unset(cstate, IEEE80211_FC1_DIR_FROMDS, s);

 
                /*
                 * If From DS isn't set, the SA is at 10.
 
                /*
                 * If From DS isn't set, the SA is at 10.


@@ -4656,9 +4594,7 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * I.e, check "link[0] & 0x08".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);
                 * I.e, check "link[0] & 0x08".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);

-               b1 = new_block(cstate, JMP(BPF_JSET));
-               b1->s.k = 0x08;
-               b1->stmts = s;
+               b1 = gen_set(cstate, IEEE80211_FC0_TYPE_DATA, s);

 
                /*
                 * AND that with the checks done for data frames.
 
                /*
                 * AND that with the checks done for data frames.


@@ -4671,10 +4607,7 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * I.e, check "!(link[0] & 0x08)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);
                 * I.e, check "!(link[0] & 0x08)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);

-               b2 = new_block(cstate, JMP(BPF_JSET));
-               b2->s.k = 0x08;
-               b2->stmts = s;
-               gen_not(b2);
+               b2 = gen_unset(cstate, IEEE80211_FC0_TYPE_DATA, s);

 
                /*
                 * For management frames, the SA is at 10.
 
                /*
                 * For management frames, the SA is at 10.


@@ -4698,10 +4631,7 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * I.e., check "!(link[0] & 0x04)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);
                 * I.e., check "!(link[0] & 0x04)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);

-               b1 = new_block(cstate, JMP(BPF_JSET));
-               b1->s.k = 0x04;
-               b1->stmts = s;
-               gen_not(b1);
+               b1 = gen_unset(cstate, IEEE80211_FC0_TYPE_CTL, s);

 
                /*
                 * AND that with the checks for data and management
 
                /*
                 * AND that with the checks for data and management


@@ -4733,9 +4663,7 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * First, check for To DS set, i.e. "link[1] & 0x01".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);
                 * First, check for To DS set, i.e. "link[1] & 0x01".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);

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

 
                /*
                 * If To DS is set, the DA is at 16.
 
                /*
                 * If To DS is set, the DA is at 16.


@@ -4748,10 +4676,7 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * "!(link[1] & 0x01)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);
                 * "!(link[1] & 0x01)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);

-               b2 = new_block(cstate, JMP(BPF_JSET));
-               b2->s.k = 0x01; /* To DS */
-               b2->stmts = s;
-               gen_not(b2);
+               b2 = gen_unset(cstate, IEEE80211_FC1_DIR_TODS, s);

 
                /*
                 * If To DS is not set, the DA is at 4.
 
                /*
                 * If To DS is not set, the DA is at 4.


@@ -4770,9 +4695,7 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * I.e, check "link[0] & 0x08".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);
                 * I.e, check "link[0] & 0x08".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);

-               b1 = new_block(cstate, JMP(BPF_JSET));
-               b1->s.k = 0x08;
-               b1->stmts = s;
+               b1 = gen_set(cstate, IEEE80211_FC0_TYPE_DATA, s);

 
                /*
                 * AND that with the checks done for data frames.
 
                /*
                 * AND that with the checks done for data frames.


@@ -4785,10 +4708,7 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * I.e, check "!(link[0] & 0x08)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);
                 * I.e, check "!(link[0] & 0x08)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);

-               b2 = new_block(cstate, JMP(BPF_JSET));
-               b2->s.k = 0x08;
-               b2->stmts = s;
-               gen_not(b2);
+               b2 = gen_unset(cstate, IEEE80211_FC0_TYPE_DATA, s);

 
                /*
                 * For management frames, the DA is at 4.
 
                /*
                 * For management frames, the DA is at 4.


@@ -4812,10 +4732,7 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * I.e., check "!(link[0] & 0x04)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);
                 * I.e., check "!(link[0] & 0x04)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);

-               b1 = new_block(cstate, JMP(BPF_JSET));
-               b1->s.k = 0x04;
-               b1->stmts = s;
-               gen_not(b1);
+               b1 = gen_unset(cstate, IEEE80211_FC0_TYPE_CTL, s);

 
                /*
                 * AND that with the checks for data and management
 
                /*
                 * AND that with the checks for data and management


@@ -4847,15 +4764,12 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                /*
                 * Not present in CTS or ACK control frames.
                 */
                /*
                 * Not present in CTS or ACK control frames.
                 */

-               b0 = gen_mcmp(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,
+               b0 = gen_mcmp_ne(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,

                        IEEE80211_FC0_TYPE_MASK);
                        IEEE80211_FC0_TYPE_MASK);

-               gen_not(b0);
-               b1 = gen_mcmp(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_SUBTYPE_CTS,
+               b1 = gen_mcmp_ne(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_SUBTYPE_CTS,

                        IEEE80211_FC0_SUBTYPE_MASK);
                        IEEE80211_FC0_SUBTYPE_MASK);

-               gen_not(b1);
-               b2 = gen_mcmp(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_SUBTYPE_ACK,
+               b2 = gen_mcmp_ne(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_SUBTYPE_ACK,

                        IEEE80211_FC0_SUBTYPE_MASK);
                        IEEE80211_FC0_SUBTYPE_MASK);

-               gen_not(b2);

                gen_and(b1, b2);
                gen_or(b0, b2);
                b1 = gen_bcmp(cstate, OR_LINKHDR, 10, 6, eaddr);
                gen_and(b1, b2);
                gen_or(b0, b2);
                b1 = gen_bcmp(cstate, OR_LINKHDR, 10, 6, eaddr);


@@ -4866,9 +4780,8 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                /*
                 * Not present in control frames.
                 */
                /*
                 * Not present in control frames.
                 */

-               b0 = gen_mcmp(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,
+               b0 = gen_mcmp_ne(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,

                        IEEE80211_FC0_TYPE_MASK);
                        IEEE80211_FC0_TYPE_MASK);

-               gen_not(b0);

                b1 = gen_bcmp(cstate, OR_LINKHDR, 16, 6, eaddr);
                gen_and(b0, b1);
                return b1;
                b1 = gen_bcmp(cstate, OR_LINKHDR, 16, 6, eaddr);
                gen_and(b0, b1);
                return b1;


@@ -4898,9 +4811,7 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * I.e, check "(link[0] & 0x08)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);
                 * I.e, check "(link[0] & 0x08)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);

-               b1 = new_block(cstate, JMP(BPF_JSET));
-               b1->s.k = 0x08;
-               b1->stmts = s;
+               b1 = gen_set(cstate, IEEE80211_FC0_TYPE_DATA, s);

 
                /*
                 * Check addr1.
 
                /*
                 * Check addr1.


@@ -4922,15 +4833,12 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                /*
                 * Not present in CTS or ACK control frames.
                 */
                /*
                 * Not present in CTS or ACK control frames.
                 */

-               b0 = gen_mcmp(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,
+               b0 = gen_mcmp_ne(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,

                        IEEE80211_FC0_TYPE_MASK);
                        IEEE80211_FC0_TYPE_MASK);

-               gen_not(b0);
-               b1 = gen_mcmp(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_SUBTYPE_CTS,
+               b1 = gen_mcmp_ne(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_SUBTYPE_CTS,

                        IEEE80211_FC0_SUBTYPE_MASK);
                        IEEE80211_FC0_SUBTYPE_MASK);

-               gen_not(b1);
-               b2 = gen_mcmp(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_SUBTYPE_ACK,
+               b2 = gen_mcmp_ne(cstate, OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_SUBTYPE_ACK,

                        IEEE80211_FC0_SUBTYPE_MASK);
                        IEEE80211_FC0_SUBTYPE_MASK);

-               gen_not(b2);

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


@@ -4940,9 +4848,7 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
                 * I.e, check "(link[0] & 0x08)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);
                 * I.e, check "(link[0] & 0x08)".
                 */
                s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);

-               b1 = new_block(cstate, JMP(BPF_JSET));
-               b1->s.k = 0x08;
-               b1->stmts = s;
+               b1 = gen_set(cstate, IEEE80211_FC0_TYPE_DATA, s);

 
                /*
                 * AND that with the check for frames other than
 
                /*
                 * AND that with the check for frames other than


@@ -4961,49 +4867,6 @@ gen_wlanhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
        /*NOTREACHED*/
 }
 
        /*NOTREACHED*/
 }
 

-/*
- * Like gen_ehostop, but for RFC 2625 IP-over-Fibre-Channel.
- * (We assume that the addresses are IEEE 48-bit MAC addresses,
- * as the RFC states.)
- */
-static struct block *
-gen_ipfchostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
-{
-       register struct block *b0, *b1;
-
-       switch (dir) {
-       case Q_SRC:
-               return gen_bcmp(cstate, OR_LINKHDR, 10, 6, eaddr);
-
-       case Q_DST:
-               return gen_bcmp(cstate, OR_LINKHDR, 2, 6, eaddr);
-
-       case Q_AND:
-               b0 = gen_ipfchostop(cstate, eaddr, Q_SRC);
-               b1 = gen_ipfchostop(cstate, eaddr, Q_DST);
-               gen_and(b0, b1);
-               return b1;
-
-       case Q_DEFAULT:
-       case Q_OR:
-               b0 = gen_ipfchostop(cstate, eaddr, Q_SRC);
-               b1 = gen_ipfchostop(cstate, eaddr, Q_DST);
-               gen_or(b0, b1);
-               return b1;
-
-       case Q_ADDR1:
-       case Q_ADDR2:
-       case Q_ADDR3:
-       case Q_ADDR4:
-       case Q_RA:
-       case Q_TA:
-               bpf_error(cstate, ERRSTR_802_11_ONLY_KW, dqkw(dir));
-               /*NOTREACHED*/
-       }
-       abort();
-       /*NOTREACHED*/
-}
-

 /*
  * This is quite tricky because there may be pad bytes in front of the
  * DECNET header, and then there are two possible data packet formats that
 /*
  * This is quite tricky because there may be pad bytes in front of the
  * DECNET header, and then there are two possible data packet formats that


@@ -5159,16 +5022,16 @@ gen_mpls_linktype(compiler_state_t *cstate, bpf_u_int32 ll_proto)
        case ETHERTYPE_IPV6:
                /* match the bottom-of-stack bit */
                b0 = gen_mcmp(cstate, OR_LINKPL, (u_int)-2, BPF_B, 0x01, 0x01);
        case ETHERTYPE_IPV6:
                /* match the bottom-of-stack bit */
                b0 = gen_mcmp(cstate, OR_LINKPL, (u_int)-2, BPF_B, 0x01, 0x01);

-               /* match the IPv4 version number */
+               /* match the IPv6 version number */

                b1 = gen_mcmp(cstate, OR_LINKPL, 0, BPF_B, 0x60, 0xf0);
                gen_and(b0, b1);
                return b1;
 
                b1 = gen_mcmp(cstate, OR_LINKPL, 0, BPF_B, 0x60, 0xf0);
                gen_and(b0, b1);
                return b1;
 

- default:
-        /* FIXME add other L3 proto IDs */
-        bpf_error(cstate, "unsupported protocol over mpls");
-        /*NOTREACHED*/
- }
+       default:
+               /* FIXME add other L3 proto IDs */
+               bpf_error(cstate, "unsupported protocol over mpls");
+               /*NOTREACHED*/
+       }

 }
 
 static struct block *
 }
 
 static struct block *


@@ -5194,22 +5057,38 @@ gen_host(compiler_state_t *cstate, bpf_u_int32 addr, bpf_u_int32 mask,
                return b0;
 
        case Q_LINK:
                return b0;
 
        case Q_LINK:

+               // "link net NETNAME" and variations thereof

                break; // invalid qualifier
 
        case Q_IP:
                b0 = gen_linktype(cstate, ETHERTYPE_IP);
                break; // invalid qualifier
 
        case Q_IP:
                b0 = gen_linktype(cstate, ETHERTYPE_IP);

+               /*
+                * Belt and braces: if other code works correctly, any host
+                * bits are clear and mask == 0 means addr == 0.  In this case
+                * the call to gen_hostop() would produce an "always true"
+                * instruction block and ANDing it with the link type check
+                * would be a no-op.
+                */
+               if (mask == 0 && addr == 0)
+                       return b0;

                b1 = gen_hostop(cstate, addr, mask, dir, 12, 16);
                gen_and(b0, b1);
                return b1;
 
        case Q_RARP:
                b0 = gen_linktype(cstate, ETHERTYPE_REVARP);
                b1 = gen_hostop(cstate, addr, mask, dir, 12, 16);
                gen_and(b0, b1);
                return b1;
 
        case Q_RARP:
                b0 = gen_linktype(cstate, ETHERTYPE_REVARP);

+               // Same as for Q_IP above.
+               if (mask == 0 && addr == 0)
+                       return b0;

                b1 = gen_hostop(cstate, addr, mask, dir, 14, 24);
                gen_and(b0, b1);
                return b1;
 
        case Q_ARP:
                b0 = gen_linktype(cstate, ETHERTYPE_ARP);
                b1 = gen_hostop(cstate, addr, mask, dir, 14, 24);
                gen_and(b0, b1);
                return b1;
 
        case Q_ARP:
                b0 = gen_linktype(cstate, ETHERTYPE_ARP);

+               // Same as for Q_IP above.
+               if (mask == 0 && addr == 0)
+                       return b0;

                b1 = gen_hostop(cstate, addr, mask, dir, 14, 24);
                gen_and(b0, b1);
                return b1;
                b1 = gen_hostop(cstate, addr, mask, dir, 14, 24);
                gen_and(b0, b1);
                return b1;


@@ -5278,6 +5157,12 @@ gen_host6(compiler_state_t *cstate, struct in6_addr *addr,
        case Q_DEFAULT:
        case Q_IPV6:
                b0 = gen_linktype(cstate, ETHERTYPE_IPV6);
        case Q_DEFAULT:
        case Q_IPV6:
                b0 = gen_linktype(cstate, ETHERTYPE_IPV6);

+               // Same as the Q_IP case in gen_host().
+               if (
+                       ! memcmp(mask, &in6addr_any, sizeof(struct in6_addr)) &&
+                       ! memcmp(addr, &in6addr_any, sizeof(struct in6_addr))
+               )
+                       return b0;

                b1 = gen_hostop6(cstate, addr, mask, dir, 8, 24);
                gen_and(b0, b1);
                return b1;
                b1 = gen_hostop6(cstate, addr, mask, dir, 8, 24);
                gen_and(b0, b1);
                return b1;


@@ -5331,59 +5216,123 @@ gen_host6(compiler_state_t *cstate, struct in6_addr *addr,
 }
 #endif
 
 }
 #endif
 

-#ifndef INET6
-static struct block *
-gen_gateway(compiler_state_t *cstate, const u_char *eaddr,
-    struct addrinfo *alist, int proto, int dir)
+static unsigned char
+is_mac48_linktype(const int linktype)

 {
 {

-       struct block *b0, *b1, *tmp;
-       struct addrinfo *ai;
-       struct sockaddr_in *sin;
+       switch (linktype) {
+       case DLT_EN10MB:
+       case DLT_FDDI:
+       case DLT_IEEE802:
+       case DLT_IEEE802_11:
+       case DLT_IEEE802_11_RADIO:
+       case DLT_IEEE802_11_RADIO_AVS:
+       case DLT_IP_OVER_FC:
+       case DLT_NETANALYZER:
+       case DLT_NETANALYZER_TRANSPARENT:
+       case DLT_PPI:
+       case DLT_PRISM_HEADER:
+               return 1;
+       default:
+               return 0;
+       }
+}

 
 

-       if (dir != 0)
-               bpf_error(cstate, "direction applied to 'gateway'");
+static struct block *
+gen_mac48host(compiler_state_t *cstate, const u_char *eaddr, const u_char dir,
+    const char *keyword)
+{
+       struct block *b1 = NULL;
+       u_int src_off, dst_off;

 
 

-       switch (proto) {
-       case Q_DEFAULT:
-       case Q_IP:
-       case Q_ARP:
-       case Q_RARP:
-               switch (cstate->linktype) {
-               case DLT_EN10MB:
-               case DLT_NETANALYZER:
-               case DLT_NETANALYZER_TRANSPARENT:
-                       b1 = gen_prevlinkhdr_check(cstate);
-                       b0 = gen_ehostop(cstate, eaddr, Q_OR);
-                       if (b1 != NULL)
-                               gen_and(b1, b0);
-                       break;
-               case DLT_FDDI:
-                       b0 = gen_fhostop(cstate, eaddr, Q_OR);
-                       break;
-               case DLT_IEEE802:
-                       b0 = gen_thostop(cstate, eaddr, Q_OR);
-                       break;
-               case DLT_IEEE802_11:
-               case DLT_PRISM_HEADER:
-               case DLT_IEEE802_11_RADIO_AVS:
-               case DLT_IEEE802_11_RADIO:
-               case DLT_PPI:
-                       b0 = gen_wlanhostop(cstate, eaddr, Q_OR);
-                       break;
-               case DLT_IP_OVER_FC:
-                       b0 = gen_ipfchostop(cstate, eaddr, Q_OR);
-                       break;
-               case DLT_SUNATM:
-                       /*
-                        * This is LLC-multiplexed traffic; if it were
-                        * LANE, cstate->linktype would have been set to
-                        * DLT_EN10MB.
-                        */
-                        /* FALLTHROUGH */
-               default:
-                       bpf_error(cstate,
-                           "'gateway' supported only on ethernet/FDDI/token ring/802.11/ATM LANE/Fibre Channel");
-               }
+       switch (cstate->linktype) {
+       case DLT_EN10MB:
+       case DLT_NETANALYZER:
+       case DLT_NETANALYZER_TRANSPARENT:
+               b1 = gen_prevlinkhdr_check(cstate);
+               src_off = 6;
+               dst_off = 0;
+               break;
+       case DLT_FDDI:
+               src_off = 6 + 1 + cstate->pcap_fddipad;
+               dst_off = 0 + 1 + cstate->pcap_fddipad;
+               break;
+       case DLT_IEEE802:
+               src_off = 8;
+               dst_off = 2;
+               break;
+       case DLT_IEEE802_11:
+       case DLT_PRISM_HEADER:
+       case DLT_IEEE802_11_RADIO_AVS:
+       case DLT_IEEE802_11_RADIO:
+       case DLT_PPI:
+               return gen_wlanhostop(cstate, eaddr, dir);
+       case DLT_IP_OVER_FC:
+               /*
+                * Assume that the addresses are IEEE 48-bit MAC addresses,
+                * as RFC 2625 states.
+                */
+               src_off = 10;
+               dst_off = 2;
+               break;
+       case DLT_SUNATM:
+               /*
+                * This is LLC-multiplexed traffic; if it were
+                * LANE, cstate->linktype would have been set to
+                * DLT_EN10MB.
+                */
+                /* FALLTHROUGH */
+       default:
+               fail_kw_on_dlt(cstate, keyword);
+       }
+
+       struct block *b0, *tmp;
+
+       switch (dir) {
+       case Q_SRC:
+               b0 = gen_bcmp(cstate, OR_LINKHDR, src_off, 6, eaddr);
+               break;
+       case Q_DST:
+               b0 = gen_bcmp(cstate, OR_LINKHDR, dst_off, 6, eaddr);
+               break;
+       case Q_AND:
+               tmp = gen_bcmp(cstate, OR_LINKHDR, src_off, 6, eaddr);
+               b0 = gen_bcmp(cstate, OR_LINKHDR, dst_off, 6, eaddr);
+               gen_and(tmp, b0);
+               break;
+       case Q_DEFAULT:
+       case Q_OR:
+               tmp = gen_bcmp(cstate, OR_LINKHDR, src_off, 6, eaddr);
+               b0 = gen_bcmp(cstate, OR_LINKHDR, dst_off, 6, eaddr);
+               gen_or(tmp, b0);
+               break;
+       default:
+               bpf_error(cstate, ERRSTR_802_11_ONLY_KW, dqkw(dir));
+       }
+
+       if (b1 != NULL)
+               gen_and(b1, b0);
+       return b0;
+}
+
+#ifndef INET6
+/*
+ * This primitive is non-directional by design, so the grammar does not allow
+ * to qualify it with a direction.
+ */
+static struct block *
+gen_gateway(compiler_state_t *cstate, const u_char *eaddr,
+    struct addrinfo *alist, int proto)
+{
+       struct block *b0, *b1, *tmp;
+       struct addrinfo *ai;
+       struct sockaddr_in *sin;
+
+       switch (proto) {
+       case Q_DEFAULT:
+       case Q_IP:
+       case Q_ARP:
+       case Q_RARP:
+               b0 = gen_mac48host(cstate, eaddr, Q_OR, "gateway");

                b1 = NULL;
                for (ai = alist; ai != NULL; ai = ai->ai_next) {
                        /*
                b1 = NULL;
                for (ai = alist; ai != NULL; ai = ai->ai_next) {
                        /*


@@ -5440,220 +5389,190 @@ static struct block *
 gen_proto_abbrev_internal(compiler_state_t *cstate, int proto)
 {
        struct block *b0;
 gen_proto_abbrev_internal(compiler_state_t *cstate, int proto)
 {
        struct block *b0;

-       struct block *b1 = NULL;
+       struct block *b1;

 
        switch (proto) {
 
        case Q_SCTP:
 
        switch (proto) {
 
        case Q_SCTP:

-               b1 = gen_proto(cstate, IPPROTO_SCTP, Q_DEFAULT, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, IPPROTO_SCTP, Q_DEFAULT);

 
        case Q_TCP:
 
        case Q_TCP:

-               b1 = gen_proto(cstate, IPPROTO_TCP, Q_DEFAULT, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, IPPROTO_TCP, Q_DEFAULT);

 
        case Q_UDP:
 
        case Q_UDP:

-               b1 = gen_proto(cstate, IPPROTO_UDP, Q_DEFAULT, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, IPPROTO_UDP, Q_DEFAULT);

 
        case Q_ICMP:
 
        case Q_ICMP:

-               b1 = gen_proto(cstate, IPPROTO_ICMP, Q_IP, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, IPPROTO_ICMP, Q_IP);

 
 #ifndef        IPPROTO_IGMP
 #define        IPPROTO_IGMP    2
 #endif
 
        case Q_IGMP:
 
 #ifndef        IPPROTO_IGMP
 #define        IPPROTO_IGMP    2
 #endif
 
        case Q_IGMP:

-               b1 = gen_proto(cstate, IPPROTO_IGMP, Q_IP, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, IPPROTO_IGMP, Q_IP);

 
 #ifndef        IPPROTO_IGRP
 #define        IPPROTO_IGRP    9
 #endif
        case Q_IGRP:
 
 #ifndef        IPPROTO_IGRP
 #define        IPPROTO_IGRP    9
 #endif
        case Q_IGRP:

-               b1 = gen_proto(cstate, IPPROTO_IGRP, Q_IP, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, IPPROTO_IGRP, Q_IP);

 
 #ifndef IPPROTO_PIM
 #define IPPROTO_PIM    103
 #endif
 
        case Q_PIM:
 
 #ifndef IPPROTO_PIM
 #define IPPROTO_PIM    103
 #endif
 
        case Q_PIM:

-               b1 = gen_proto(cstate, IPPROTO_PIM, Q_DEFAULT, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, IPPROTO_PIM, Q_DEFAULT);

 
 #ifndef IPPROTO_VRRP
 #define IPPROTO_VRRP   112
 #endif
 
        case Q_VRRP:
 
 #ifndef IPPROTO_VRRP
 #define IPPROTO_VRRP   112
 #endif
 
        case Q_VRRP:

-               b1 = gen_proto(cstate, IPPROTO_VRRP, Q_IP, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, IPPROTO_VRRP, Q_IP);

 
 #ifndef IPPROTO_CARP
 #define IPPROTO_CARP   112
 #endif
 
        case Q_CARP:
 
 #ifndef IPPROTO_CARP
 #define IPPROTO_CARP   112
 #endif
 
        case Q_CARP:

-               b1 = gen_proto(cstate, IPPROTO_CARP, Q_IP, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, IPPROTO_CARP, Q_IP);

 
        case Q_IP:
 
        case Q_IP:

-               b1 = gen_linktype(cstate, ETHERTYPE_IP);
-               break;
+               return gen_linktype(cstate, ETHERTYPE_IP);

 
        case Q_ARP:
 
        case Q_ARP:

-               b1 = gen_linktype(cstate, ETHERTYPE_ARP);
-               break;
+               return gen_linktype(cstate, ETHERTYPE_ARP);

 
        case Q_RARP:
 
        case Q_RARP:

-               b1 = gen_linktype(cstate, ETHERTYPE_REVARP);
-               break;
+               return gen_linktype(cstate, ETHERTYPE_REVARP);

 
        case Q_LINK:
                break; // invalid syntax
 
        case Q_ATALK:
 
        case Q_LINK:
                break; // invalid syntax
 
        case Q_ATALK:

-               b1 = gen_linktype(cstate, ETHERTYPE_ATALK);
-               break;
+               return gen_linktype(cstate, ETHERTYPE_ATALK);

 
        case Q_AARP:
 
        case Q_AARP:

-               b1 = gen_linktype(cstate, ETHERTYPE_AARP);
-               break;
+               return gen_linktype(cstate, ETHERTYPE_AARP);

 
        case Q_DECNET:
 
        case Q_DECNET:

-               b1 = gen_linktype(cstate, ETHERTYPE_DN);
-               break;
+               return gen_linktype(cstate, ETHERTYPE_DN);

 
        case Q_SCA:
 
        case Q_SCA:

-               b1 = gen_linktype(cstate, ETHERTYPE_SCA);
-               break;
+               return gen_linktype(cstate, ETHERTYPE_SCA);

 
        case Q_LAT:
 
        case Q_LAT:

-               b1 = gen_linktype(cstate, ETHERTYPE_LAT);
-               break;
+               return gen_linktype(cstate, ETHERTYPE_LAT);

 
        case Q_MOPDL:
 
        case Q_MOPDL:

-               b1 = gen_linktype(cstate, ETHERTYPE_MOPDL);
-               break;
+               return gen_linktype(cstate, ETHERTYPE_MOPDL);

 
        case Q_MOPRC:
 
        case Q_MOPRC:

-               b1 = gen_linktype(cstate, ETHERTYPE_MOPRC);
-               break;
+               return gen_linktype(cstate, ETHERTYPE_MOPRC);

 
        case Q_IPV6:
 
        case Q_IPV6:

-               b1 = gen_linktype(cstate, ETHERTYPE_IPV6);
-               break;
+               return gen_linktype(cstate, ETHERTYPE_IPV6);

 
 #ifndef IPPROTO_ICMPV6
 #define IPPROTO_ICMPV6 58
 #endif
        case Q_ICMPV6:
 
 #ifndef IPPROTO_ICMPV6
 #define IPPROTO_ICMPV6 58
 #endif
        case Q_ICMPV6:

-               b1 = gen_proto(cstate, IPPROTO_ICMPV6, Q_IPV6, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, IPPROTO_ICMPV6, Q_IPV6);

 
 #ifndef IPPROTO_AH
 #define IPPROTO_AH     51
 #endif
        case Q_AH:
 
 #ifndef IPPROTO_AH
 #define IPPROTO_AH     51
 #endif
        case Q_AH:

-               b1 = gen_proto(cstate, IPPROTO_AH, Q_DEFAULT, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, IPPROTO_AH, Q_DEFAULT);

 
 #ifndef IPPROTO_ESP
 #define IPPROTO_ESP    50
 #endif
        case Q_ESP:
 
 #ifndef IPPROTO_ESP
 #define IPPROTO_ESP    50
 #endif
        case Q_ESP:

-               b1 = gen_proto(cstate, IPPROTO_ESP, Q_DEFAULT, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, IPPROTO_ESP, Q_DEFAULT);

 
        case Q_ISO:
 
        case Q_ISO:

-               b1 = gen_linktype(cstate, LLCSAP_ISONS);
-               break;
+               return gen_linktype(cstate, LLCSAP_ISONS);

 
        case Q_ESIS:
 
        case Q_ESIS:

-               b1 = gen_proto(cstate, ISO9542_ESIS, Q_ISO, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, ISO9542_ESIS, Q_ISO);

 
        case Q_ISIS:
 
        case Q_ISIS:

-               b1 = gen_proto(cstate, ISO10589_ISIS, Q_ISO, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, ISO10589_ISIS, Q_ISO);

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

-               b0 = gen_proto(cstate, ISIS_L1_LAN_IIH, Q_ISIS, Q_DEFAULT);
-               b1 = gen_proto(cstate, ISIS_PTP_IIH, Q_ISIS, Q_DEFAULT); /* FIXME extract the circuit-type bits */
+               b0 = gen_proto(cstate, ISIS_L1_LAN_IIH, Q_ISIS);
+               b1 = gen_proto(cstate, ISIS_PTP_IIH, Q_ISIS); /* FIXME extract the circuit-type bits */

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

-               b0 = gen_proto(cstate, ISIS_L1_LSP, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L1_LSP, Q_ISIS);

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

-               b0 = gen_proto(cstate, ISIS_L1_CSNP, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L1_CSNP, Q_ISIS);

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

-               b0 = gen_proto(cstate, ISIS_L1_PSNP, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L1_PSNP, Q_ISIS);

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

-               break;
+               return b1;

 
        case Q_ISIS_L2: /* all IS-IS Level2 PDU-Types */
 
        case Q_ISIS_L2: /* all IS-IS Level2 PDU-Types */

-               b0 = gen_proto(cstate, ISIS_L2_LAN_IIH, Q_ISIS, Q_DEFAULT);
-               b1 = gen_proto(cstate, ISIS_PTP_IIH, Q_ISIS, Q_DEFAULT); /* FIXME extract the circuit-type bits */
+               b0 = gen_proto(cstate, ISIS_L2_LAN_IIH, Q_ISIS);
+               b1 = gen_proto(cstate, ISIS_PTP_IIH, Q_ISIS); /* FIXME extract the circuit-type bits */

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

-               b0 = gen_proto(cstate, ISIS_L2_LSP, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L2_LSP, Q_ISIS);

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

-               b0 = gen_proto(cstate, ISIS_L2_CSNP, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L2_CSNP, Q_ISIS);

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

-               b0 = gen_proto(cstate, ISIS_L2_PSNP, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L2_PSNP, Q_ISIS);

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

-               break;
+               return b1;

 
        case Q_ISIS_IIH: /* all IS-IS Hello PDU-Types */
 
        case Q_ISIS_IIH: /* all IS-IS Hello PDU-Types */

-               b0 = gen_proto(cstate, ISIS_L1_LAN_IIH, Q_ISIS, Q_DEFAULT);
-               b1 = gen_proto(cstate, ISIS_L2_LAN_IIH, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L1_LAN_IIH, Q_ISIS);
+               b1 = gen_proto(cstate, ISIS_L2_LAN_IIH, Q_ISIS);

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

-               b0 = gen_proto(cstate, ISIS_PTP_IIH, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_PTP_IIH, Q_ISIS);

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

-               break;
+               return b1;

 
        case Q_ISIS_LSP:
 
        case Q_ISIS_LSP:

-               b0 = gen_proto(cstate, ISIS_L1_LSP, Q_ISIS, Q_DEFAULT);
-               b1 = gen_proto(cstate, ISIS_L2_LSP, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L1_LSP, Q_ISIS);
+               b1 = gen_proto(cstate, ISIS_L2_LSP, Q_ISIS);

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

-               break;
+               return b1;

 
        case Q_ISIS_SNP:
 
        case Q_ISIS_SNP:

-               b0 = gen_proto(cstate, ISIS_L1_CSNP, Q_ISIS, Q_DEFAULT);
-               b1 = gen_proto(cstate, ISIS_L2_CSNP, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L1_CSNP, Q_ISIS);
+               b1 = gen_proto(cstate, ISIS_L2_CSNP, Q_ISIS);

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

-               b0 = gen_proto(cstate, ISIS_L1_PSNP, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L1_PSNP, Q_ISIS);

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

-               b0 = gen_proto(cstate, ISIS_L2_PSNP, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L2_PSNP, Q_ISIS);

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

-               break;
+               return b1;

 
        case Q_ISIS_CSNP:
 
        case Q_ISIS_CSNP:

-               b0 = gen_proto(cstate, ISIS_L1_CSNP, Q_ISIS, Q_DEFAULT);
-               b1 = gen_proto(cstate, ISIS_L2_CSNP, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L1_CSNP, Q_ISIS);
+               b1 = gen_proto(cstate, ISIS_L2_CSNP, Q_ISIS);

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

-               break;
+               return b1;

 
        case Q_ISIS_PSNP:
 
        case Q_ISIS_PSNP:

-               b0 = gen_proto(cstate, ISIS_L1_PSNP, Q_ISIS, Q_DEFAULT);
-               b1 = gen_proto(cstate, ISIS_L2_PSNP, Q_ISIS, Q_DEFAULT);
+               b0 = gen_proto(cstate, ISIS_L1_PSNP, Q_ISIS);
+               b1 = gen_proto(cstate, ISIS_L2_PSNP, Q_ISIS);

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

-               break;
+               return b1;

 
        case Q_CLNP:
 
        case Q_CLNP:

-               b1 = gen_proto(cstate, ISO8473_CLNP, Q_ISO, Q_DEFAULT);
-               break;
+               return gen_proto(cstate, ISO8473_CLNP, Q_ISO);

 
        case Q_STP:
 
        case Q_STP:

-               b1 = gen_linktype(cstate, LLCSAP_8021D);
-               break;
+               return gen_linktype(cstate, LLCSAP_8021D);

 
        case Q_IPX:
 
        case Q_IPX:

-               b1 = gen_linktype(cstate, LLCSAP_IPX);
-               break;
+               return gen_linktype(cstate, LLCSAP_IPX);

 
        case Q_NETBEUI:
 
        case Q_NETBEUI:

-               b1 = gen_linktype(cstate, LLCSAP_NETBEUI);
-               break;
+               return gen_linktype(cstate, LLCSAP_NETBEUI);

 
        case Q_RADIO:
                break; // invalid syntax
 
        case Q_RADIO:
                break; // invalid syntax


@@ -5661,8 +5580,6 @@ gen_proto_abbrev_internal(compiler_state_t *cstate, int proto)
        default:
                abort();
        }
        default:
                abort();
        }

-       if (b1)
-               return b1;

        bpf_error(cstate, "'%s' cannot be used as an abbreviation", pqkw(proto));
 }
 
        bpf_error(cstate, "'%s' cannot be used as an abbreviation", pqkw(proto));
 }
 


@@ -5679,20 +5596,26 @@ gen_proto_abbrev(compiler_state_t *cstate, int proto)
        return gen_proto_abbrev_internal(cstate, proto);
 }
 
        return gen_proto_abbrev_internal(cstate, proto);
 }
 

+static struct block *
+gen_ip_proto(compiler_state_t *cstate, const uint8_t proto)
+{
+       return gen_cmp(cstate, OR_LINKPL, 9, BPF_B, proto);
+}
+
+static struct block *
+gen_ip6_proto(compiler_state_t *cstate, const uint8_t proto)
+{
+       return gen_cmp(cstate, OR_LINKPL, 6, BPF_B, proto);
+}
+

 static struct block *
 gen_ipfrag(compiler_state_t *cstate)
 {
        struct slist *s;
 static struct block *
 gen_ipfrag(compiler_state_t *cstate)
 {
        struct slist *s;

-       struct block *b;

 
        /* not IPv4 frag other than the first frag */
        s = gen_load_a(cstate, OR_LINKPL, 6, BPF_H);
 
        /* not IPv4 frag other than the first frag */
        s = gen_load_a(cstate, OR_LINKPL, 6, BPF_H);

-       b = new_block(cstate, JMP(BPF_JSET));
-       b->s.k = 0x1fff;
-       b->stmts = s;
-       gen_not(b);
-
-       return b;
+       return gen_unset(cstate, 0x1fff, s);

 }
 
 /*
 }
 
 /*


@@ -5705,26 +5628,21 @@ gen_ipfrag(compiler_state_t *cstate)
  * headers).
  */
 static struct block *
  * headers).
  */
 static struct block *

-gen_portatom(compiler_state_t *cstate, int off, bpf_u_int32 v)
+gen_portatom(compiler_state_t *cstate, int off, uint16_t v)

 {
        return gen_cmp(cstate, OR_TRAN_IPV4, off, BPF_H, v);
 }
 
 static struct block *
 {
        return gen_cmp(cstate, OR_TRAN_IPV4, off, BPF_H, v);
 }
 
 static struct block *

-gen_portatom6(compiler_state_t *cstate, int off, bpf_u_int32 v)
+gen_portatom6(compiler_state_t *cstate, int off, uint16_t v)

 {
        return gen_cmp(cstate, OR_TRAN_IPV6, off, BPF_H, v);
 }
 
 static struct block *
 {
        return gen_cmp(cstate, OR_TRAN_IPV6, off, BPF_H, v);
 }
 
 static struct block *

-gen_portop(compiler_state_t *cstate, u_int port, u_int proto, int dir)
+gen_port(compiler_state_t *cstate, uint16_t port, int proto, int dir)

 {
 {

-       struct block *b0, *b1, *tmp;
-
-       /* ip proto 'proto' and not a fragment other than the first fragment */
-       tmp = gen_cmp(cstate, OR_LINKPL, 9, BPF_B, proto);
-       b0 = gen_ipfrag(cstate);
-       gen_and(tmp, b0);
+       struct block *b1, *tmp;

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


@@ -5761,15 +5679,14 @@ gen_portop(compiler_state_t *cstate, u_int port, u_int proto, int dir)
                abort();
                /*NOTREACHED*/
        }
                abort();
                /*NOTREACHED*/
        }

-       gen_and(b0, b1);

 
 

-       return b1;
+       return gen_port_common(cstate, proto, b1);

 }
 
 static struct block *
 }
 
 static struct block *

-gen_port(compiler_state_t *cstate, u_int port, int ip_proto, int dir)
+gen_port_common(compiler_state_t *cstate, int proto, struct block *b1)

 {
 {

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

 
        /*
         * ether proto ip
 
        /*
         * ether proto ip


@@ -5787,39 +5704,47 @@ gen_port(compiler_state_t *cstate, u_int port, int ip_proto, int dir)
         * encapsulation with LLCSAP_IP.
         *
         * So we always check for ETHERTYPE_IP.
         * encapsulation with LLCSAP_IP.
         *
         * So we always check for ETHERTYPE_IP.

+        *
+        * At the time of this writing all three L4 protocols the "port" and
+        * "portrange" primitives support (TCP, UDP and SCTP) have the source
+        * and the destination ports identically encoded in the transport
+        * protocol header.  So without a proto qualifier the only difference
+        * between the implemented cases is the protocol number and all other
+        * checks need to be made exactly once.
+        *
+        * If the expression syntax in future starts to support ports for
+        * another L4 protocol that has unsigned integer ports encoded using a
+        * different size and/or offset, this will require a different code.

         */
         */

-       b0 = gen_linktype(cstate, ETHERTYPE_IP);
-
-       switch (ip_proto) {
+       switch (proto) {

        case IPPROTO_UDP:
        case IPPROTO_TCP:
        case IPPROTO_SCTP:
        case IPPROTO_UDP:
        case IPPROTO_TCP:
        case IPPROTO_SCTP:

-               b1 = gen_portop(cstate, port, (u_int)ip_proto, dir);
+               tmp = gen_ip_proto(cstate, (uint8_t)proto);

                break;
 
        case PROTO_UNDEF:
                break;
 
        case PROTO_UNDEF:

-               tmp = gen_portop(cstate, port, IPPROTO_TCP, dir);
-               b1 = gen_portop(cstate, port, IPPROTO_UDP, dir);
-               gen_or(tmp, b1);
-               tmp = gen_portop(cstate, port, IPPROTO_SCTP, dir);
-               gen_or(tmp, b1);
+               tmp = gen_ip_proto(cstate, IPPROTO_UDP);
+               gen_or(gen_ip_proto(cstate, IPPROTO_TCP), tmp);
+               gen_or(gen_ip_proto(cstate, IPPROTO_SCTP), tmp);

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

+       // Not a fragment other than the first fragment.
+       b0 = gen_ipfrag(cstate);
+       gen_and(tmp, b0);

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

+       // "link proto \ip"
+       gen_and(gen_linktype(cstate, ETHERTYPE_IP), b1);

        return b1;
 }
 
        return b1;
 }
 

-struct block *
-gen_portop6(compiler_state_t *cstate, u_int port, u_int proto, int dir)
+static struct block *
+gen_port6(compiler_state_t *cstate, uint16_t port, int proto, int dir)

 {
 {

-       struct block *b0, *b1, *tmp;
-
-       /* ip6 proto 'proto' */
-       /* XXX - catch the first fragment of a fragmented packet? */
-       b0 = gen_cmp(cstate, OR_LINKPL, 6, BPF_B, proto);
+       struct block *b1, *tmp;

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


@@ -5846,61 +5771,52 @@ gen_portop6(compiler_state_t *cstate, u_int port, u_int proto, int dir)
        default:
                abort();
        }
        default:
                abort();
        }

-       gen_and(b0, b1);

 
 

-       return b1;
+       return gen_port6_common(cstate, proto, b1);

 }
 
 static struct block *
 }
 
 static struct block *

-gen_port6(compiler_state_t *cstate, u_int port, int ip_proto, int dir)
+gen_port6_common(compiler_state_t *cstate, int proto, struct block *b1)

 {
 {

-       struct block *b0, *b1, *tmp;
-
-       /* link proto ip6 */
-       b0 = gen_linktype(cstate, ETHERTYPE_IPV6);
+       struct block *tmp;

 
 

-       switch (ip_proto) {
+       // "ip6 proto 'ip_proto'"
+       switch (proto) {

        case IPPROTO_UDP:
        case IPPROTO_TCP:
        case IPPROTO_SCTP:
        case IPPROTO_UDP:
        case IPPROTO_TCP:
        case IPPROTO_SCTP:

-               b1 = gen_portop6(cstate, port, (u_int)ip_proto, dir);
+               tmp = gen_ip6_proto(cstate, (uint8_t)proto);

                break;
 
        case PROTO_UNDEF:
                break;
 
        case PROTO_UNDEF:

-               tmp = gen_portop6(cstate, port, IPPROTO_TCP, dir);
-               b1 = gen_portop6(cstate, port, IPPROTO_UDP, dir);
-               gen_or(tmp, b1);
-               tmp = gen_portop6(cstate, port, IPPROTO_SCTP, dir);
-               gen_or(tmp, b1);
+               // Same as in gen_port_common().
+               tmp = gen_ip6_proto(cstate, IPPROTO_UDP);
+               gen_or(gen_ip6_proto(cstate, IPPROTO_TCP), tmp);
+               gen_or(gen_ip6_proto(cstate, IPPROTO_SCTP), tmp);

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

-       gen_and(b0, b1);
+       // XXX - catch the first fragment of a fragmented packet?
+       gen_and(tmp, b1);
+       // "link proto \ip6"
+       gen_and(gen_linktype(cstate, ETHERTYPE_IPV6), b1);

        return b1;
 }
 
 /* gen_portrange code */
 static struct block *
        return b1;
 }
 
 /* gen_portrange code */
 static struct block *

-gen_portrangeatom(compiler_state_t *cstate, u_int off, bpf_u_int32 v1,
-    bpf_u_int32 v2)
+gen_portrangeatom(compiler_state_t *cstate, u_int off, uint16_t v1,
+    uint16_t v2)

 {
 {

-       struct block *b1, *b2;
+       if (v1 == v2)
+               return gen_portatom(cstate, off, v1);

 
 

-       if (v1 > v2) {
-               /*
-                * Reverse the order of the ports, so v1 is the lower one.
-                */
-               bpf_u_int32 vtemp;
-
-               vtemp = v1;
-               v1 = v2;
-               v2 = vtemp;
-       }
+       struct block *b1, *b2;

 
 

-       b1 = gen_cmp_ge(cstate, OR_TRAN_IPV4, off, BPF_H, v1);
-       b2 = gen_cmp_le(cstate, OR_TRAN_IPV4, off, BPF_H, v2);
+       b1 = gen_cmp_ge(cstate, OR_TRAN_IPV4, off, BPF_H, min(v1, v2));
+       b2 = gen_cmp_le(cstate, OR_TRAN_IPV4, off, BPF_H, max(v1, v2));

 
        gen_and(b1, b2);
 
 
        gen_and(b1, b2);
 


@@ -5908,15 +5824,10 @@ gen_portrangeatom(compiler_state_t *cstate, u_int off, bpf_u_int32 v1,
 }
 
 static struct block *
 }
 
 static struct block *

-gen_portrangeop(compiler_state_t *cstate, u_int port1, u_int port2,
-    bpf_u_int32 proto, int dir)
+gen_portrange(compiler_state_t *cstate, uint16_t port1, uint16_t port2,
+    int proto, int dir)

 {
 {

-       struct block *b0, *b1, *tmp;
-
-       /* ip proto 'proto' and not a fragment other than the first fragment */
-       tmp = gen_cmp(cstate, OR_LINKPL, 9, BPF_B, proto);
-       b0 = gen_ipfrag(cstate);
-       gen_and(tmp, b0);
+       struct block *b1, *tmp;

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


@@ -5953,62 +5864,21 @@ gen_portrangeop(compiler_state_t *cstate, u_int port1, u_int port2,
                abort();
                /*NOTREACHED*/
        }
                abort();
                /*NOTREACHED*/
        }

-       gen_and(b0, b1);

 
 

-       return b1;
+       return gen_port_common(cstate, proto, b1);

 }
 
 static struct block *
 }
 
 static struct block *

-gen_portrange(compiler_state_t *cstate, u_int port1, u_int port2, int ip_proto,
-    int dir)
+gen_portrangeatom6(compiler_state_t *cstate, u_int off, uint16_t v1,
+    uint16_t v2)

 {
 {

-       struct block *b0, *b1, *tmp;
-
-       /* link proto ip */
-       b0 = gen_linktype(cstate, ETHERTYPE_IP);
-
-       switch (ip_proto) {
-       case IPPROTO_UDP:
-       case IPPROTO_TCP:
-       case IPPROTO_SCTP:
-               b1 = gen_portrangeop(cstate, port1, port2, (bpf_u_int32)ip_proto,
-                   dir);
-               break;
-
-       case PROTO_UNDEF:
-               tmp = gen_portrangeop(cstate, port1, port2, IPPROTO_TCP, dir);
-               b1 = gen_portrangeop(cstate, port1, port2, IPPROTO_UDP, dir);
-               gen_or(tmp, b1);
-               tmp = gen_portrangeop(cstate, port1, port2, IPPROTO_SCTP, dir);
-               gen_or(tmp, b1);
-               break;
-
-       default:
-               abort();
-       }
-       gen_and(b0, b1);
-       return b1;
-}
+       if (v1 == v2)
+               return gen_portatom6(cstate, off, v1);

 
 

-static struct block *
-gen_portrangeatom6(compiler_state_t *cstate, u_int off, bpf_u_int32 v1,
-    bpf_u_int32 v2)
-{

        struct block *b1, *b2;
 
        struct block *b1, *b2;
 

-       if (v1 > v2) {
-               /*
-                * Reverse the order of the ports, so v1 is the lower one.
-                */
-               bpf_u_int32 vtemp;
-
-               vtemp = v1;
-               v1 = v2;
-               v2 = vtemp;
-       }
-
-       b1 = gen_cmp_ge(cstate, OR_TRAN_IPV6, off, BPF_H, v1);
-       b2 = gen_cmp_le(cstate, OR_TRAN_IPV6, off, BPF_H, v2);
+       b1 = gen_cmp_ge(cstate, OR_TRAN_IPV6, off, BPF_H, min(v1, v2));
+       b2 = gen_cmp_le(cstate, OR_TRAN_IPV6, off, BPF_H, max(v1, v2));

 
        gen_and(b1, b2);
 
 
        gen_and(b1, b2);
 


@@ -6016,14 +5886,10 @@ gen_portrangeatom6(compiler_state_t *cstate, u_int off, bpf_u_int32 v1,
 }
 
 static struct block *
 }
 
 static struct block *

-gen_portrangeop6(compiler_state_t *cstate, u_int port1, u_int port2,
-    bpf_u_int32 proto, int dir)
+gen_portrange6(compiler_state_t *cstate, uint16_t port1, uint16_t port2,
+    int proto, int dir)

 {
 {

-       struct block *b0, *b1, *tmp;
-
-       /* ip6 proto 'proto' */
-       /* XXX - catch the first fragment of a fragmented packet? */
-       b0 = gen_cmp(cstate, OR_LINKPL, 6, BPF_B, proto);
+       struct block *b1, *tmp;

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


@@ -6050,41 +5916,8 @@ gen_portrangeop6(compiler_state_t *cstate, u_int port1, u_int port2,
        default:
                abort();
        }
        default:
                abort();
        }

-       gen_and(b0, b1);

 
 

-       return b1;
-}
-
-static struct block *
-gen_portrange6(compiler_state_t *cstate, u_int port1, u_int port2, int ip_proto,
-    int dir)
-{
-       struct block *b0, *b1, *tmp;
-
-       /* link proto ip6 */
-       b0 = gen_linktype(cstate, ETHERTYPE_IPV6);
-
-       switch (ip_proto) {
-       case IPPROTO_UDP:
-       case IPPROTO_TCP:
-       case IPPROTO_SCTP:
-               b1 = gen_portrangeop6(cstate, port1, port2, (bpf_u_int32)ip_proto,
-                   dir);
-               break;
-
-       case PROTO_UNDEF:
-               tmp = gen_portrangeop6(cstate, port1, port2, IPPROTO_TCP, dir);
-               b1 = gen_portrangeop6(cstate, port1, port2, IPPROTO_UDP, dir);
-               gen_or(tmp, b1);
-               tmp = gen_portrangeop6(cstate, port1, port2, IPPROTO_SCTP, dir);
-               gen_or(tmp, b1);
-               break;
-
-       default:
-               abort();
-       }
-       gen_and(b0, b1);
-       return b1;
+       return gen_port6_common(cstate, proto, b1);

 }
 
 static int
 }
 
 static int


@@ -6131,6 +5964,10 @@ lookup_proto(compiler_state_t *cstate, const char *name, int proto)
 }
 
 #if !defined(NO_PROTOCHAIN)
 }
 
 #if !defined(NO_PROTOCHAIN)

+/*
+ * This primitive is non-directional by design, so the grammar does not allow
+ * to qualify it with a direction.
+ */

 static struct block *
 gen_protochain(compiler_state_t *cstate, bpf_u_int32 v, int proto)
 {
 static struct block *
 gen_protochain(compiler_state_t *cstate, bpf_u_int32 v, int proto)
 {


@@ -6147,6 +5984,7 @@ gen_protochain(compiler_state_t *cstate, bpf_u_int32 v, int proto)
        switch (proto) {
        case Q_IP:
        case Q_IPV6:
        switch (proto) {
        case Q_IP:
        case Q_IPV6:

+               assert_maxval(cstate, "protocol number", v, UINT8_MAX);

                break;
        case Q_DEFAULT:
                b0 = gen_protochain(cstate, v, Q_IP);
                break;
        case Q_DEFAULT:
                b0 = gen_protochain(cstate, v, Q_IP);


@@ -6353,12 +6191,10 @@ gen_protochain(compiler_state_t *cstate, bpf_u_int32 v, int proto)
         * A = P[X];
         * X = X + (P[X + 1] + 2) * 4;
         */
         * A = P[X];
         * X = X + (P[X + 1] + 2) * 4;
         */

-       /* A = X */
-       s[i - 1]->s.jt = s[i] = new_stmt(cstate, BPF_MISC|BPF_TXA);
-       i++;

        /* A = P[X + packet head]; */
        s[i] = new_stmt(cstate, BPF_LD|BPF_IND|BPF_B);
        s[i]->s.k = cstate->off_linkpl.constant_part + cstate->off_nl;
        /* A = P[X + packet head]; */
        s[i] = new_stmt(cstate, BPF_LD|BPF_IND|BPF_B);
        s[i]->s.k = cstate->off_linkpl.constant_part + cstate->off_nl;

+       s[i - 1]->s.jt = s[i];

        i++;
        /* MEM[reg2] = A */
        s[i] = new_stmt(cstate, BPF_ST);
        i++;
        /* MEM[reg2] = A */
        s[i] = new_stmt(cstate, BPF_ST);


@@ -6418,10 +6254,9 @@ gen_protochain(compiler_state_t *cstate, bpf_u_int32 v, int proto)
 
        /*
         * emit final check
 
        /*
         * emit final check

+        * Remember, s[0] is dummy.

         */
         */

-       b = new_block(cstate, JMP(BPF_JEQ));
-       b->stmts = s[1];        /*remember, s[0] is dummy*/
-       b->s.k = v;
+       b = gen_jmp(cstate, BPF_JEQ, v, s[1]);

 
        free_reg(cstate, reg2);
 
 
        free_reg(cstate, reg2);
 


@@ -6438,20 +6273,20 @@ gen_protochain(compiler_state_t *cstate, bpf_u_int32 v, int proto)
  *
  * If <proto> is Q_DEFAULT, i.e. just "proto" was specified, it checks
  * against Q_IP and Q_IPV6.
  *
  * If <proto> is Q_DEFAULT, i.e. just "proto" was specified, it checks
  * against Q_IP and Q_IPV6.

+ *
+ * This primitive is non-directional by design, so the grammar does not allow
+ * to qualify it with a direction.

  */
 static struct block *
  */
 static struct block *

-gen_proto(compiler_state_t *cstate, bpf_u_int32 v, int proto, int dir)
+gen_proto(compiler_state_t *cstate, bpf_u_int32 v, int proto)

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

-       if (dir != Q_DEFAULT)
-               bpf_error(cstate, "direction applied to 'proto'");
-

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

-               b0 = gen_proto(cstate, v, Q_IP, dir);
-               b1 = gen_proto(cstate, v, Q_IPV6, dir);
+               b0 = gen_proto(cstate, v, Q_IP);
+               b1 = gen_proto(cstate, v, Q_IPV6);

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


@@ -6459,6 +6294,7 @@ gen_proto(compiler_state_t *cstate, bpf_u_int32 v, int proto, int dir)
                return gen_linktype(cstate, v);
 
        case Q_IP:
                return gen_linktype(cstate, v);
 
        case Q_IP:

+               assert_maxval(cstate, "protocol number", v, UINT8_MAX);

                /*
                 * For FDDI, RFC 1188 says that SNAP encapsulation is used,
                 * not LLC encapsulation with LLCSAP_IP.
                /*
                 * For FDDI, RFC 1188 says that SNAP encapsulation is used,
                 * not LLC encapsulation with LLCSAP_IP.


@@ -6475,7 +6311,8 @@ gen_proto(compiler_state_t *cstate, bpf_u_int32 v, int proto, int dir)
                 * So we always check for ETHERTYPE_IP.
                 */
                b0 = gen_linktype(cstate, ETHERTYPE_IP);
                 * So we always check for ETHERTYPE_IP.
                 */
                b0 = gen_linktype(cstate, ETHERTYPE_IP);

-               b1 = gen_cmp(cstate, OR_LINKPL, 9, BPF_B, v);
+               // 0 <= v <= UINT8_MAX
+               b1 = gen_ip_proto(cstate, (uint8_t)v);

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


@@ -6496,15 +6333,17 @@ gen_proto(compiler_state_t *cstate, bpf_u_int32 v, int proto, int dir)
                break; // invalid qualifier
 
        case Q_IPV6:
                break; // invalid qualifier
 
        case Q_IPV6:

+               assert_maxval(cstate, "protocol number", v, UINT8_MAX);

                b0 = gen_linktype(cstate, ETHERTYPE_IPV6);
                /*
                 * Also check for a fragment header before the final
                 * header.
                 */
                b0 = gen_linktype(cstate, ETHERTYPE_IPV6);
                /*
                 * Also check for a fragment header before the final
                 * header.
                 */

-               b2 = gen_cmp(cstate, OR_LINKPL, 6, BPF_B, IPPROTO_FRAGMENT);
+               b2 = gen_ip6_proto(cstate, IPPROTO_FRAGMENT);

                b1 = gen_cmp(cstate, OR_LINKPL, 40, BPF_B, v);
                gen_and(b2, b1);
                b1 = gen_cmp(cstate, OR_LINKPL, 40, BPF_B, v);
                gen_and(b2, b1);

-               b2 = gen_cmp(cstate, OR_LINKPL, 6, BPF_B, v);
+               // 0 <= v <= UINT8_MAX
+               b2 = gen_ip6_proto(cstate, (uint8_t)v);

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


@@ -6518,6 +6357,7 @@ gen_proto(compiler_state_t *cstate, bpf_u_int32 v, int proto, int dir)
                break; // invalid qualifier
 
        case Q_ISO:
                break; // invalid qualifier
 
        case Q_ISO:

+               assert_maxval(cstate, "ISO protocol", v, UINT8_MAX);

                switch (cstate->linktype) {
 
                case DLT_FRELAY:
                switch (cstate->linktype) {
 
                case DLT_FRELAY:


@@ -6565,12 +6405,24 @@ gen_proto(compiler_state_t *cstate, bpf_u_int32 v, int proto, int dir)
                break; // invalid qualifier
 
        case Q_ISIS:
                break; // invalid qualifier
 
        case Q_ISIS:

-               b0 = gen_proto(cstate, ISO10589_ISIS, Q_ISO, Q_DEFAULT);
+               assert_maxval(cstate, "IS-IS PDU type", v, ISIS_PDU_TYPE_MAX);
+               b0 = gen_proto(cstate, ISO10589_ISIS, Q_ISO);

                /*
                 * 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.

+                * Except when it is not, see above.

                 */
                 */

-               b1 = gen_cmp(cstate, OR_LINKPL_NOSNAP, 4, BPF_B, v);
+               unsigned pdu_type_offset;
+               switch (cstate->linktype) {
+               case DLT_C_HDLC:
+               case DLT_HDLC:
+                       pdu_type_offset = 5;
+                       break;
+               default:
+                       pdu_type_offset = 4;
+               }
+               b1 = gen_mcmp(cstate, OR_LINKPL_NOSNAP, pdu_type_offset, BPF_B,
+                   v, ISIS_PDU_TYPE_MAX);

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


@@ -6871,7 +6723,8 @@ gen_scode(compiler_state_t *cstate, const char *name, struct qual q)
        int proto = q.proto;
        int dir = q.dir;
        int tproto;
        int proto = q.proto;
        int dir = q.dir;
        int tproto;

-       u_char *eaddr;
+       u_char *eaddrp;
+       u_char eaddr[6];

        bpf_u_int32 mask, addr;
        struct addrinfo *res, *res0;
        struct sockaddr_in *sin4;
        bpf_u_int32 mask, addr;
        struct addrinfo *res, *res0;
        struct sockaddr_in *sin4;


@@ -6908,64 +6761,15 @@ gen_scode(compiler_state_t *cstate, const char *name, struct qual q)
        case Q_DEFAULT:
        case Q_HOST:
                if (proto == Q_LINK) {
        case Q_DEFAULT:
        case Q_HOST:
                if (proto == Q_LINK) {

-                       switch (cstate->linktype) {
-
-                       case DLT_EN10MB:
-                       case DLT_NETANALYZER:
-                       case DLT_NETANALYZER_TRANSPARENT:
-                               eaddr = pcap_ether_hostton(name);
-                               if (eaddr == NULL)
-                                       bpf_error(cstate,
-                                           "unknown ether host '%s'", name);
-                               tmp = gen_prevlinkhdr_check(cstate);
-                               b = gen_ehostop(cstate, eaddr, dir);
-                               if (tmp != NULL)
-                                       gen_and(tmp, b);
-                               free(eaddr);
-                               return b;
-
-                       case DLT_FDDI:
-                               eaddr = pcap_ether_hostton(name);
-                               if (eaddr == NULL)
-                                       bpf_error(cstate,
-                                           "unknown FDDI host '%s'", name);
-                               b = gen_fhostop(cstate, eaddr, dir);
-                               free(eaddr);
-                               return b;
-
-                       case DLT_IEEE802:
-                               eaddr = pcap_ether_hostton(name);
-                               if (eaddr == NULL)
-                                       bpf_error(cstate,
-                                           "unknown token ring host '%s'", name);
-                               b = gen_thostop(cstate, eaddr, dir);
-                               free(eaddr);
-                               return b;
-
-                       case DLT_IEEE802_11:
-                       case DLT_PRISM_HEADER:
-                       case DLT_IEEE802_11_RADIO_AVS:
-                       case DLT_IEEE802_11_RADIO:
-                       case DLT_PPI:
-                               eaddr = pcap_ether_hostton(name);
-                               if (eaddr == NULL)
-                                       bpf_error(cstate,
-                                           "unknown 802.11 host '%s'", name);
-                               b = gen_wlanhostop(cstate, eaddr, dir);
-                               free(eaddr);
-                               return b;
-
-                       case DLT_IP_OVER_FC:
-                               eaddr = pcap_ether_hostton(name);
-                               if (eaddr == NULL)
-                                       bpf_error(cstate,
-                                           "unknown Fibre Channel host '%s'", name);
-                               b = gen_ipfchostop(cstate, eaddr, dir);
-                               free(eaddr);
-                               return b;
-                       }
-
-                       bpf_error(cstate, "only ethernet/FDDI/token ring/802.11/ATM LANE/Fibre Channel supports link-level host name");
+                       const char *context = "link host NAME";
+                       if (! is_mac48_linktype(cstate->linktype))
+                               fail_kw_on_dlt(cstate, context);
+                       eaddrp = pcap_ether_hostton(name);
+                       if (eaddrp == NULL)
+                               bpf_error(cstate, ERRSTR_UNKNOWN_MAC48HOST, name);
+                       memcpy(eaddr, eaddrp, sizeof(eaddr));
+                       free(eaddrp);
+                       return gen_mac48host(cstate, eaddr, q.dir, context);

                } else if (proto == Q_DECNET) {
                        /*
                         * A long time ago on Ultrix libpcap supported
                } else if (proto == Q_DECNET) {
                        /*
                         * A long time ago on Ultrix libpcap supported


@@ -7036,9 +6840,7 @@ gen_scode(compiler_state_t *cstate, const char *name, struct qual q)
                }
 
        case Q_PORT:
                }
 
        case Q_PORT:

-               if (proto != Q_DEFAULT &&
-                   proto != Q_UDP && proto != Q_TCP && proto != Q_SCTP)
-                       bpf_error(cstate, "illegal qualifier of 'port'");
+               (void)port_pq_to_ipproto(cstate, proto, "port"); // validate only

                if (pcap_nametoport(name, &port, &real_proto) == 0)
                        bpf_error(cstate, "unknown port '%s'", name);
                if (proto == Q_UDP) {
                if (pcap_nametoport(name, &port, &real_proto) == 0)
                        bpf_error(cstate, "unknown port '%s'", name);
                if (proto == Q_UDP) {


@@ -7074,14 +6876,13 @@ gen_scode(compiler_state_t *cstate, const char *name, struct qual q)
                        bpf_error(cstate, "illegal port number %d < 0", port);
                if (port > 65535)
                        bpf_error(cstate, "illegal port number %d > 65535", port);
                        bpf_error(cstate, "illegal port number %d < 0", port);
                if (port > 65535)
                        bpf_error(cstate, "illegal port number %d > 65535", port);

-               b = gen_port(cstate, port, real_proto, dir);
-               gen_or(gen_port6(cstate, port, real_proto, dir), b);
+               // real_proto can be PROTO_UNDEF
+               b = gen_port(cstate, (uint16_t)port, real_proto, dir);
+               gen_or(gen_port6(cstate, (uint16_t)port, real_proto, dir), b);

                return b;
 
        case Q_PORTRANGE:
                return b;
 
        case Q_PORTRANGE:

-               if (proto != Q_DEFAULT &&
-                   proto != Q_UDP && proto != Q_TCP && proto != Q_SCTP)
-                       bpf_error(cstate, "illegal qualifier of 'portrange'");
+               (void)port_pq_to_ipproto(cstate, proto, "portrange"); // validate only

                stringtoportrange(cstate, name, &port1, &port2, &real_proto);
                if (proto == Q_UDP) {
                        if (real_proto == IPPROTO_TCP)
                stringtoportrange(cstate, name, &port1, &port2, &real_proto);
                if (proto == Q_UDP) {
                        if (real_proto == IPPROTO_TCP)


@@ -7115,24 +6916,30 @@ gen_scode(compiler_state_t *cstate, const char *name, struct qual q)
                if (port2 > 65535)
                        bpf_error(cstate, "illegal port number %d > 65535", port2);
 
                if (port2 > 65535)
                        bpf_error(cstate, "illegal port number %d > 65535", port2);
 

-               b = gen_portrange(cstate, port1, port2, real_proto, dir);
-               gen_or(gen_portrange6(cstate, port1, port2, real_proto, dir), b);
+               // real_proto can be PROTO_UNDEF
+               b = gen_portrange(cstate, (uint16_t)port1, (uint16_t)port2,
+                   real_proto, dir);
+               gen_or(gen_portrange6(cstate, (uint16_t)port1, (uint16_t)port2,
+                   real_proto, dir), b);

                return b;
 
        case Q_GATEWAY:
 #ifndef INET6
                return b;
 
        case Q_GATEWAY:
 #ifndef INET6

-               eaddr = pcap_ether_hostton(name);
-               if (eaddr == NULL)
-                       bpf_error(cstate, "unknown ether host: %s", name);
+               if (! is_mac48_linktype(cstate->linktype))
+                       fail_kw_on_dlt(cstate, "gateway");
+               eaddrp = pcap_ether_hostton(name);
+               if (eaddrp == NULL)
+                       bpf_error(cstate, ERRSTR_UNKNOWN_MAC48HOST, name);
+               memcpy(eaddr, eaddrp, sizeof(eaddr));
+               free(eaddrp);

 
                res = pcap_nametoaddrinfo(name);
                cstate->ai = res;
                if (res == NULL)
                        bpf_error(cstate, "unknown host '%s'", name);
 
                res = pcap_nametoaddrinfo(name);
                cstate->ai = res;
                if (res == NULL)
                        bpf_error(cstate, "unknown host '%s'", name);

-               b = gen_gateway(cstate, eaddr, res, proto, dir);
+               b = gen_gateway(cstate, eaddr, res, proto);

                cstate->ai = NULL;
                freeaddrinfo(res);
                cstate->ai = NULL;
                freeaddrinfo(res);

-               free(eaddr);

                if (b == NULL)
                        bpf_error(cstate, "unknown host '%s'", name);
                return b;
                if (b == NULL)
                        bpf_error(cstate, "unknown host '%s'", name);
                return b;


@@ -7143,7 +6950,7 @@ gen_scode(compiler_state_t *cstate, const char *name, struct qual q)
        case Q_PROTO:
                real_proto = lookup_proto(cstate, name, proto);
                if (real_proto >= 0)
        case Q_PROTO:
                real_proto = lookup_proto(cstate, name, proto);
                if (real_proto >= 0)

-                       return gen_proto(cstate, real_proto, proto, dir);
+                       return gen_proto(cstate, real_proto, proto);

                else
                        bpf_error(cstate, "unknown protocol: %s", name);
 
                else
                        bpf_error(cstate, "unknown protocol: %s", name);
 


@@ -7211,6 +7018,7 @@ gen_mcode(compiler_state_t *cstate, const char *s1, const char *s2,
                return gen_host(cstate, n, m, q.proto, q.dir, q.addr);
 
        default:
                return gen_host(cstate, n, m, q.proto, q.dir, q.addr);
 
        default:

+               // Q_HOST and Q_GATEWAY only (see the grammar)

                bpf_error(cstate, "Mask syntax for networks only");
                /*NOTREACHED*/
        }
                bpf_error(cstate, "Mask syntax for networks only");
                /*NOTREACHED*/
        }


@@ -7276,6 +7084,7 @@ gen_ncode(compiler_state_t *cstate, const char *s, bpf_u_int32 v, struct qual q)
                if (proto == Q_DECNET)
                        return gen_host(cstate, v, 0, proto, dir, q.addr);
                else if (proto == Q_LINK) {
                if (proto == Q_DECNET)
                        return gen_host(cstate, v, 0, proto, dir, q.addr);
                else if (proto == Q_LINK) {

+                       // "link (host|net) IPV4ADDR" and variations thereof

                        bpf_error(cstate, "illegal link layer address");
                } else {
                        mask = 0xffffffff;
                        bpf_error(cstate, "illegal link layer address");
                } else {
                        mask = 0xffffffff;


@@ -7294,46 +7103,32 @@ gen_ncode(compiler_state_t *cstate, const char *s, bpf_u_int32 v, struct qual q)
                }
 
        case Q_PORT:
                }
 
        case Q_PORT:

-               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(cstate, "illegal qualifier of 'port'");
+               proto = port_pq_to_ipproto(cstate, proto, "port");

 
                if (v > 65535)
                        bpf_error(cstate, "illegal port number %u > 65535", v);
 
 
                if (v > 65535)
                        bpf_error(cstate, "illegal port number %u > 65535", v);
 

+               // proto can be PROTO_UNDEF

            {
                struct block *b;
            {
                struct block *b;

-               b = gen_port(cstate, v, proto, dir);
-               gen_or(gen_port6(cstate, v, proto, dir), b);
+               b = gen_port(cstate, (uint16_t)v, proto, dir);
+               gen_or(gen_port6(cstate, (uint16_t)v, proto, dir), b);

                return b;
            }
 
        case Q_PORTRANGE:
                return b;
            }
 
        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(cstate, "illegal qualifier of 'portrange'");
+               proto = port_pq_to_ipproto(cstate, proto, "portrange");

 
                if (v > 65535)
                        bpf_error(cstate, "illegal port number %u > 65535", v);
 
 
                if (v > 65535)
                        bpf_error(cstate, "illegal port number %u > 65535", v);
 

+               // proto can be PROTO_UNDEF

            {
                struct block *b;
            {
                struct block *b;

-               b = gen_portrange(cstate, v, v, proto, dir);
-               gen_or(gen_portrange6(cstate, v, v, proto, dir), b);
+               b = gen_portrange(cstate, (uint16_t)v, (uint16_t)v,
+                   proto, dir);
+               gen_or(gen_portrange6(cstate, (uint16_t)v, (uint16_t)v,
+                   proto, dir), b);

                return b;
            }
 
                return b;
            }
 


@@ -7342,7 +7137,7 @@ gen_ncode(compiler_state_t *cstate, const char *s, bpf_u_int32 v, struct qual q)
                /*NOTREACHED*/
 
        case Q_PROTO:
                /*NOTREACHED*/
 
        case Q_PROTO:

-               return gen_proto(cstate, v, proto, dir);
+               return gen_proto(cstate, v, proto);

 
 #if !defined(NO_PROTOCHAIN)
        case Q_PROTOCHAIN:
 
 #if !defined(NO_PROTOCHAIN)
        case Q_PROTOCHAIN:


@@ -7417,6 +7212,7 @@ gen_mcode6(compiler_state_t *cstate, const char *s, bpf_u_int32 masklen,
                return b;
 
        default:
                return b;
 
        default:

+               // Q_GATEWAY only (see the grammar)

                bpf_error(cstate, "invalid qualifier against IPv6 address");
                /*NOTREACHED*/
        }
                bpf_error(cstate, "invalid qualifier against IPv6 address");
                /*NOTREACHED*/
        }


@@ -7426,8 +7222,6 @@ gen_mcode6(compiler_state_t *cstate, const char *s, bpf_u_int32 masklen,
 struct block *
 gen_ecode(compiler_state_t *cstate, const char *s, struct qual q)
 {
 struct block *
 gen_ecode(compiler_state_t *cstate, const char *s, struct qual q)
 {

-       struct block *b, *tmp;
-

        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.
        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.


@@ -7436,40 +7230,13 @@ gen_ecode(compiler_state_t *cstate, const char *s, struct qual q)
                return (NULL);
 
        if ((q.addr == Q_HOST || q.addr == Q_DEFAULT) && q.proto == Q_LINK) {
                return (NULL);
 
        if ((q.addr == Q_HOST || q.addr == Q_DEFAULT) && q.proto == Q_LINK) {

+               const char *context = "link host XX:XX:XX:XX:XX:XX";
+               if (! is_mac48_linktype(cstate->linktype))
+                       fail_kw_on_dlt(cstate, context);

                cstate->e = pcap_ether_aton(s);
                if (cstate->e == NULL)
                        bpf_error(cstate, "malloc");
                cstate->e = pcap_ether_aton(s);
                if (cstate->e == NULL)
                        bpf_error(cstate, "malloc");

-               switch (cstate->linktype) {
-               case DLT_EN10MB:
-               case DLT_NETANALYZER:
-               case DLT_NETANALYZER_TRANSPARENT:
-                       tmp = gen_prevlinkhdr_check(cstate);
-                       b = gen_ehostop(cstate, cstate->e, (int)q.dir);
-                       if (tmp != NULL)
-                               gen_and(tmp, b);
-                       break;
-               case DLT_FDDI:
-                       b = gen_fhostop(cstate, cstate->e, (int)q.dir);
-                       break;
-               case DLT_IEEE802:
-                       b = gen_thostop(cstate, cstate->e, (int)q.dir);
-                       break;
-               case DLT_IEEE802_11:
-               case DLT_PRISM_HEADER:
-               case DLT_IEEE802_11_RADIO_AVS:
-               case DLT_IEEE802_11_RADIO:
-               case DLT_PPI:
-                       b = gen_wlanhostop(cstate, cstate->e, (int)q.dir);
-                       break;
-               case DLT_IP_OVER_FC:
-                       b = gen_ipfchostop(cstate, cstate->e, (int)q.dir);
-                       break;
-               default:
-                       free(cstate->e);
-                       cstate->e = NULL;
-                       bpf_error(cstate, "ethernet addresses supported only on ethernet/FDDI/token ring/802.11/ATM LANE/Fibre Channel");
-                       /*NOTREACHED*/
-               }
+               struct block *b = gen_mac48host(cstate, cstate->e, q.dir, context);

                free(cstate->e);
                cstate->e = NULL;
                return (b);
                free(cstate->e);
                cstate->e = NULL;
                return (b);


@@ -7744,7 +7511,7 @@ gen_load_internal(compiler_state_t *cstate, int proto, struct arth *inst,
                /*
                 * Check if we have an icmp6 next header
                 */
                /*
                 * Check if we have an icmp6 next header
                 */

-               b = gen_cmp(cstate, OR_LINKPL, 6, BPF_B, 58);
+               b = gen_ip6_proto(cstate, 58);

                if (inst->b)
                        gen_and(inst->b, b);
                inst->b = b;
                if (inst->b)
                        gen_and(inst->b, b);
                inst->b = b;


@@ -8049,14 +7816,9 @@ static struct block *
 gen_len(compiler_state_t *cstate, int jmp, int n)
 {
        struct slist *s;
 gen_len(compiler_state_t *cstate, int jmp, int n)
 {
        struct slist *s;

-       struct block *b;

 
        s = new_stmt(cstate, BPF_LD|BPF_LEN);
 
        s = new_stmt(cstate, BPF_LD|BPF_LEN);

-       b = new_block(cstate, JMP(jmp));
-       b->stmts = s;
-       b->s.k = n;
-
-       return b;
+       return gen_jmp(cstate, jmp, n, s);

 }
 
 struct block *
 }
 
 struct block *


@@ -8116,6 +7878,8 @@ gen_byteop(compiler_state_t *cstate, int op, int idx, bpf_u_int32 val)
        if (setjmp(cstate->top_ctx))
                return (NULL);
 
        if (setjmp(cstate->top_ctx))
                return (NULL);
 

+       assert_maxval(cstate, "byte argument", val, UINT8_MAX);
+

        switch (op) {
        default:
                abort();
        switch (op) {
        default:
                abort();


@@ -8124,12 +7888,10 @@ gen_byteop(compiler_state_t *cstate, int op, int idx, bpf_u_int32 val)
                return gen_cmp(cstate, OR_LINKHDR, (u_int)idx, BPF_B, val);
 
        case '<':
                return gen_cmp(cstate, OR_LINKHDR, (u_int)idx, BPF_B, val);
 
        case '<':

-               b = gen_cmp_lt(cstate, OR_LINKHDR, (u_int)idx, BPF_B, val);
-               return b;
+               return gen_cmp_lt(cstate, OR_LINKHDR, (u_int)idx, BPF_B, val);

 
        case '>':
 
        case '>':

-               b = gen_cmp_gt(cstate, OR_LINKHDR, (u_int)idx, BPF_B, val);
-               return b;
+               return gen_cmp_gt(cstate, OR_LINKHDR, (u_int)idx, BPF_B, val);

 
        case '|':
                s = new_stmt(cstate, BPF_ALU|BPF_OR|BPF_K);
 
        case '|':
                s = new_stmt(cstate, BPF_ALU|BPF_OR|BPF_K);


@@ -8140,8 +7902,10 @@ gen_byteop(compiler_state_t *cstate, int op, int idx, bpf_u_int32 val)
                break;
        }
        s->s.k = val;
                break;
        }
        s->s.k = val;

-       b = new_block(cstate, JMP(BPF_JEQ));
-       b->stmts = s;
+       // Load the required byte first.
+       struct slist *s0 = gen_load_a(cstate, OR_LINKHDR, idx, BPF_B);
+       sappend(s0, s);
+       b = gen_jmp(cstate, BPF_JEQ, 0, s0);

        gen_not(b);
 
        return b;
        gen_not(b);
 
        return b;


@@ -8170,28 +7934,8 @@ gen_broadcast(compiler_state_t *cstate, int proto)
                case DLT_ARCNET_LINUX:
                        // ARCnet broadcast is [8-bit] destination address 0.
                        return gen_ahostop(cstate, 0, Q_DST);
                case DLT_ARCNET_LINUX:
                        // ARCnet broadcast is [8-bit] destination address 0.
                        return gen_ahostop(cstate, 0, Q_DST);

-               case DLT_EN10MB:
-               case DLT_NETANALYZER:
-               case DLT_NETANALYZER_TRANSPARENT:
-                       b1 = gen_prevlinkhdr_check(cstate);
-                       b0 = gen_ehostop(cstate, ebroadcast, Q_DST);
-                       if (b1 != NULL)
-                               gen_and(b1, b0);
-                       return b0;
-               case DLT_FDDI:
-                       return gen_fhostop(cstate, ebroadcast, Q_DST);
-               case DLT_IEEE802:
-                       return gen_thostop(cstate, ebroadcast, Q_DST);
-               case DLT_IEEE802_11:
-               case DLT_PRISM_HEADER:
-               case DLT_IEEE802_11_RADIO_AVS:
-               case DLT_IEEE802_11_RADIO:
-               case DLT_PPI:
-                       return gen_wlanhostop(cstate, ebroadcast, Q_DST);
-               case DLT_IP_OVER_FC:
-                       return gen_ipfchostop(cstate, ebroadcast, Q_DST);

                }
                }

-               fail_kw_on_dlt(cstate, "broadcast");
+               return gen_mac48host(cstate, ebroadcast, Q_DST, "broadcast");

                /*NOTREACHED*/
 
        case Q_IP:
                /*NOTREACHED*/
 
        case Q_IP:


@@ -8221,15 +7965,11 @@ gen_broadcast(compiler_state_t *cstate, int proto)
 static struct block *
 gen_mac_multicast(compiler_state_t *cstate, int offset)
 {
 static struct block *
 gen_mac_multicast(compiler_state_t *cstate, int offset)
 {

-       register struct block *b0;

        register struct slist *s;
 
        /* link[offset] & 1 != 0 */
        s = gen_load_a(cstate, OR_LINKHDR, offset, BPF_B);
        register struct slist *s;
 
        /* link[offset] & 1 != 0 */
        s = gen_load_a(cstate, OR_LINKHDR, offset, BPF_B);

-       b0 = new_block(cstate, JMP(BPF_JSET));
-       b0->s.k = 1;
-       b0->stmts = s;
-       return b0;
+       return gen_set(cstate, 1, s);

 }
 
 struct block *
 }
 
 struct block *


@@ -8301,9 +8041,7 @@ gen_multicast(compiler_state_t *cstate, int proto)
                         * First, check for To DS set, i.e. "link[1] & 0x01".
                         */
                        s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);
                         * First, check for To DS set, i.e. "link[1] & 0x01".
                         */
                        s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);

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

 
                        /*
                         * If To DS is set, the DA is at 16.
 
                        /*
                         * If To DS is set, the DA is at 16.


@@ -8316,10 +8054,7 @@ gen_multicast(compiler_state_t *cstate, int proto)
                         * "!(link[1] & 0x01)".
                         */
                        s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);
                         * "!(link[1] & 0x01)".
                         */
                        s = gen_load_a(cstate, OR_LINKHDR, 1, BPF_B);

-                       b2 = new_block(cstate, JMP(BPF_JSET));
-                       b2->s.k = 0x01; /* To DS */
-                       b2->stmts = s;
-                       gen_not(b2);
+                       b2 = gen_unset(cstate, IEEE80211_FC1_DIR_TODS, s);

 
                        /*
                         * If To DS is not set, the DA is at 4.
 
                        /*
                         * If To DS is not set, the DA is at 4.


@@ -8338,9 +8073,7 @@ gen_multicast(compiler_state_t *cstate, int proto)
                         * I.e, check "link[0] & 0x08".
                         */
                        s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);
                         * I.e, check "link[0] & 0x08".
                         */
                        s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);

-                       b1 = new_block(cstate, JMP(BPF_JSET));
-                       b1->s.k = 0x08;
-                       b1->stmts = s;
+                       b1 = gen_set(cstate, IEEE80211_FC0_TYPE_DATA, s);

 
                        /*
                         * AND that with the checks done for data frames.
 
                        /*
                         * AND that with the checks done for data frames.


@@ -8353,10 +8086,7 @@ gen_multicast(compiler_state_t *cstate, int proto)
                         * I.e, check "!(link[0] & 0x08)".
                         */
                        s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);
                         * I.e, check "!(link[0] & 0x08)".
                         */
                        s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);

-                       b2 = new_block(cstate, JMP(BPF_JSET));
-                       b2->s.k = 0x08;
-                       b2->stmts = s;
-                       gen_not(b2);
+                       b2 = gen_unset(cstate, IEEE80211_FC0_TYPE_DATA, s);

 
                        /*
                         * For management frames, the DA is at 4.
 
                        /*
                         * For management frames, the DA is at 4.


@@ -8380,10 +8110,7 @@ gen_multicast(compiler_state_t *cstate, int proto)
                         * I.e., check "!(link[0] & 0x04)".
                         */
                        s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);
                         * I.e., check "!(link[0] & 0x04)".
                         */
                        s = gen_load_a(cstate, OR_LINKHDR, 0, BPF_B);

-                       b1 = new_block(cstate, JMP(BPF_JSET));
-                       b1->s.k = 0x04;
-                       b1->stmts = s;
-                       gen_not(b1);
+                       b1 = gen_unset(cstate, IEEE80211_FC0_TYPE_CTL, s);

 
                        /*
                         * AND that with the checks for data and management
 
                        /*
                         * AND that with the checks for data and management


@@ -8392,8 +8119,7 @@ gen_multicast(compiler_state_t *cstate, int proto)
                        gen_and(b1, b0);
                        return b0;
                case DLT_IP_OVER_FC:
                        gen_and(b1, b0);
                        return b0;
                case DLT_IP_OVER_FC:

-                       b0 = gen_mac_multicast(cstate, 2);
-                       return b0;
+                       return gen_mac_multicast(cstate, 2);

                default:
                        break;
                }
                default:
                        break;
                }


@@ -8438,8 +8164,6 @@ require_basic_bpf_extensions(compiler_state_t *cstate, const char *keyword)
 struct block *
 gen_ifindex(compiler_state_t *cstate, int ifindex)
 {
 struct block *
 gen_ifindex(compiler_state_t *cstate, int ifindex)
 {

-       register struct block *b0;
-

        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.
        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.


@@ -8453,20 +8177,18 @@ gen_ifindex(compiler_state_t *cstate, int ifindex)
        switch (cstate->linktype) {
        case DLT_LINUX_SLL2:
                /* match packets on this interface */
        switch (cstate->linktype) {
        case DLT_LINUX_SLL2:
                /* match packets on this interface */

-               b0 = gen_cmp(cstate, OR_LINKHDR, 4, BPF_W, ifindex);
-               break;
+               return gen_cmp(cstate, OR_LINKHDR, 4, BPF_W, ifindex);

        default:
 #if defined(__linux__)
                require_basic_bpf_extensions(cstate, "ifindex");
                /* match ifindex */
        default:
 #if defined(__linux__)
                require_basic_bpf_extensions(cstate, "ifindex");
                /* match ifindex */

-               b0 = gen_cmp(cstate, OR_LINKHDR, SKF_AD_OFF + SKF_AD_IFINDEX, BPF_W,
+               return gen_cmp(cstate, OR_LINKHDR, SKF_AD_OFF + SKF_AD_IFINDEX, BPF_W,

                             ifindex);
 #else /* defined(__linux__) */
                fail_kw_on_dlt(cstate, "ifindex");
                /*NOTREACHED*/
 #endif /* defined(__linux__) */
        }
                             ifindex);
 #else /* defined(__linux__) */
                fail_kw_on_dlt(cstate, "ifindex");
                /*NOTREACHED*/
 #endif /* defined(__linux__) */
        }

-       return (b0);

 }
 
 /*
 }
 
 /*


@@ -8495,14 +8217,12 @@ gen_inbound_outbound(compiler_state_t *cstate, const int outbound)
         */
        switch (cstate->linktype) {
        case DLT_SLIP:
         */
        switch (cstate->linktype) {
        case DLT_SLIP:

-               b0 = gen_cmp(cstate, OR_LINKHDR, 0, BPF_B,
+               return gen_cmp(cstate, OR_LINKHDR, 0, BPF_B,

                          outbound ? SLIPDIR_OUT : SLIPDIR_IN);
                          outbound ? SLIPDIR_OUT : SLIPDIR_IN);

-               break;

 
        case DLT_IPNET:
 
        case DLT_IPNET:

-               b0 = gen_cmp(cstate, OR_LINKHDR, 2, BPF_H,
+               return gen_cmp(cstate, OR_LINKHDR, 2, BPF_H,

                    outbound ? IPNET_OUTBOUND : IPNET_INBOUND);
                    outbound ? IPNET_OUTBOUND : IPNET_INBOUND);

-               break;

 
        case DLT_LINUX_SLL:
                /* match outgoing packets */
 
        case DLT_LINUX_SLL:
                /* match outgoing packets */


@@ -8511,7 +8231,7 @@ gen_inbound_outbound(compiler_state_t *cstate, const int outbound)
                        /* to filter on inbound traffic, invert the match */
                        gen_not(b0);
                }
                        /* to filter on inbound traffic, invert the match */
                        gen_not(b0);
                }

-               break;
+               return b0;

 
        case DLT_LINUX_SLL2:
                /* match outgoing packets */
 
        case DLT_LINUX_SLL2:
                /* match outgoing packets */


@@ -8520,16 +8240,14 @@ gen_inbound_outbound(compiler_state_t *cstate, const int outbound)
                        /* to filter on inbound traffic, invert the match */
                        gen_not(b0);
                }
                        /* to filter on inbound traffic, invert the match */
                        gen_not(b0);
                }

-               break;
+               return b0;

 
        case DLT_PFLOG:
 
        case DLT_PFLOG:

-               b0 = gen_cmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, dir), BPF_B,
+               return gen_cmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, dir), BPF_B,

                    outbound ? PF_OUT : PF_IN);
                    outbound ? PF_OUT : PF_IN);

-               break;

 
        case DLT_PPP_PPPD:
 
        case DLT_PPP_PPPD:

-               b0 = gen_cmp(cstate, OR_LINKHDR, 0, BPF_B, outbound ? PPP_PPPD_OUT : PPP_PPPD_IN);
-               break;
+               return gen_cmp(cstate, OR_LINKHDR, 0, BPF_B, outbound ? PPP_PPPD_OUT : PPP_PPPD_IN);

 
        case DLT_JUNIPER_MFR:
        case DLT_JUNIPER_MLFR:
 
        case DLT_JUNIPER_MFR:
        case DLT_JUNIPER_MLFR:


@@ -8555,8 +8273,7 @@ gen_inbound_outbound(compiler_state_t *cstate, const int outbound)
        case DLT_JUNIPER_ATM_CEMIC:
                /* juniper flags (including direction) are stored
                 * the byte after the 3-byte magic number */
        case DLT_JUNIPER_ATM_CEMIC:
                /* juniper flags (including direction) are stored
                 * the byte after the 3-byte magic number */

-               b0 = gen_mcmp(cstate, OR_LINKHDR, 3, BPF_B, outbound ? 0 : 1, 0x01);
-               break;
+               return gen_mcmp(cstate, OR_LINKHDR, 3, BPF_B, outbound ? 0 : 1, 0x01);

 
        default:
                /*
 
        default:
                /*


@@ -8583,19 +8300,18 @@ gen_inbound_outbound(compiler_state_t *cstate, const int outbound)
                        /* to filter on inbound traffic, invert the match */
                        gen_not(b0);
                }
                        /* to filter on inbound traffic, invert the match */
                        gen_not(b0);
                }

+               return b0;

 #else /* defined(__linux__) */
                fail_kw_on_dlt(cstate, outbound ? "outbound" : "inbound");
                /*NOTREACHED*/
 #endif /* defined(__linux__) */
        }
 #else /* defined(__linux__) */
                fail_kw_on_dlt(cstate, outbound ? "outbound" : "inbound");
                /*NOTREACHED*/
 #endif /* defined(__linux__) */
        }

-       return (b0);

 }
 
 /* PF firewall log matched interface */
 struct block *
 gen_pf_ifname(compiler_state_t *cstate, const char *ifname)
 {
 }
 
 /* PF firewall log matched interface */
 struct block *
 gen_pf_ifname(compiler_state_t *cstate, const char *ifname)
 {

-       struct block *b0;

        u_int len, off;
 
        /*
        u_int len, off;
 
        /*


@@ -8614,17 +8330,14 @@ gen_pf_ifname(compiler_state_t *cstate, const char *ifname)
                    len-1);
                /*NOTREACHED*/
        }
                    len-1);
                /*NOTREACHED*/
        }

-       b0 = gen_bcmp(cstate, OR_LINKHDR, off, (u_int)strlen(ifname),
+       return gen_bcmp(cstate, OR_LINKHDR, off, (u_int)strlen(ifname),

            (const u_char *)ifname);
            (const u_char *)ifname);

-       return (b0);

 }
 
 /* PF firewall log ruleset name */
 struct block *
 gen_pf_ruleset(compiler_state_t *cstate, char *ruleset)
 {
 }
 
 /* PF firewall log ruleset name */
 struct block *
 gen_pf_ruleset(compiler_state_t *cstate, char *ruleset)
 {

-       struct block *b0;
-

        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.
        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.


@@ -8640,17 +8353,14 @@ gen_pf_ruleset(compiler_state_t *cstate, char *ruleset)
                /*NOTREACHED*/
        }
 
                /*NOTREACHED*/
        }
 

-       b0 = gen_bcmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, ruleset),
+       return gen_bcmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, ruleset),

            (u_int)strlen(ruleset), (const u_char *)ruleset);
            (u_int)strlen(ruleset), (const u_char *)ruleset);

-       return (b0);

 }
 
 /* PF firewall log rule number */
 struct block *
 gen_pf_rnr(compiler_state_t *cstate, int rnr)
 {
 }
 
 /* PF firewall log rule number */
 struct block *
 gen_pf_rnr(compiler_state_t *cstate, int rnr)
 {

-       struct block *b0;
-

        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.
        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.


@@ -8660,17 +8370,14 @@ gen_pf_rnr(compiler_state_t *cstate, int rnr)
 
        assert_pflog(cstate, "rnr");
 
 
        assert_pflog(cstate, "rnr");
 

-       b0 = gen_cmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, rulenr), BPF_W,
+       return gen_cmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, rulenr), BPF_W,

                 (bpf_u_int32)rnr);
                 (bpf_u_int32)rnr);

-       return (b0);

 }
 
 /* PF firewall log sub-rule number */
 struct block *
 gen_pf_srnr(compiler_state_t *cstate, int srnr)
 {
 }
 
 /* PF firewall log sub-rule number */
 struct block *
 gen_pf_srnr(compiler_state_t *cstate, int srnr)
 {

-       struct block *b0;
-

        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.
        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.


@@ -8680,17 +8387,14 @@ gen_pf_srnr(compiler_state_t *cstate, int srnr)
 
        assert_pflog(cstate, "srnr");
 
 
        assert_pflog(cstate, "srnr");
 

-       b0 = gen_cmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, subrulenr), BPF_W,
+       return gen_cmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, subrulenr), BPF_W,

            (bpf_u_int32)srnr);
            (bpf_u_int32)srnr);

-       return (b0);

 }
 
 /* PF firewall log reason code */
 struct block *
 gen_pf_reason(compiler_state_t *cstate, int reason)
 {
 }
 
 /* PF firewall log reason code */
 struct block *
 gen_pf_reason(compiler_state_t *cstate, int reason)
 {

-       struct block *b0;
-

        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.
        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.


@@ -8700,17 +8404,14 @@ gen_pf_reason(compiler_state_t *cstate, int reason)
 
        assert_pflog(cstate, "reason");
 
 
        assert_pflog(cstate, "reason");
 

-       b0 = gen_cmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, reason), BPF_B,
+       return gen_cmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, reason), BPF_B,

            (bpf_u_int32)reason);
            (bpf_u_int32)reason);

-       return (b0);

 }
 
 /* PF firewall log action */
 struct block *
 gen_pf_action(compiler_state_t *cstate, int action)
 {
 }
 
 /* PF firewall log action */
 struct block *
 gen_pf_action(compiler_state_t *cstate, int action)
 {

-       struct block *b0;
-

        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.
        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.


@@ -8720,17 +8421,14 @@ gen_pf_action(compiler_state_t *cstate, int action)
 
        assert_pflog(cstate, "action");
 
 
        assert_pflog(cstate, "action");
 

-       b0 = gen_cmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, action), BPF_B,
+       return gen_cmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, action), BPF_B,

            (bpf_u_int32)action);
            (bpf_u_int32)action);

-       return (b0);

 }
 
 /* IEEE 802.11 wireless header */
 struct block *
 gen_p80211_type(compiler_state_t *cstate, bpf_u_int32 type, bpf_u_int32 mask)
 {
 }
 
 /* IEEE 802.11 wireless header */
 struct block *
 gen_p80211_type(compiler_state_t *cstate, bpf_u_int32 type, bpf_u_int32 mask)
 {

-       struct block *b0;
-

        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.
        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.


@@ -8745,22 +8443,17 @@ gen_p80211_type(compiler_state_t *cstate, bpf_u_int32 type, bpf_u_int32 mask)
        case DLT_IEEE802_11_RADIO_AVS:
        case DLT_IEEE802_11_RADIO:
        case DLT_PPI:
        case DLT_IEEE802_11_RADIO_AVS:
        case DLT_IEEE802_11_RADIO:
        case DLT_PPI:

-               b0 = gen_mcmp(cstate, OR_LINKHDR, 0, BPF_B, type, mask);
-               break;
+               return gen_mcmp(cstate, OR_LINKHDR, 0, BPF_B, type, mask);

 
        default:
                fail_kw_on_dlt(cstate, "type/subtype");
                /*NOTREACHED*/
        }
 
        default:
                fail_kw_on_dlt(cstate, "type/subtype");
                /*NOTREACHED*/
        }

-
-       return (b0);

 }
 
 struct block *
 gen_p80211_fcdir(compiler_state_t *cstate, bpf_u_int32 fcdir)
 {
 }
 
 struct block *
 gen_p80211_fcdir(compiler_state_t *cstate, bpf_u_int32 fcdir)
 {

-       struct block *b0;
-

        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.
        /*
         * Catch errors reported by us and routines below us, and return NULL
         * on an error.


@@ -8775,17 +8468,13 @@ gen_p80211_fcdir(compiler_state_t *cstate, bpf_u_int32 fcdir)
        case DLT_IEEE802_11_RADIO_AVS:
        case DLT_IEEE802_11_RADIO:
        case DLT_PPI:
        case DLT_IEEE802_11_RADIO_AVS:
        case DLT_IEEE802_11_RADIO:
        case DLT_PPI:

-               break;
+               return gen_mcmp(cstate, OR_LINKHDR, 1, BPF_B, fcdir,
+                   IEEE80211_FC1_DIR_MASK);

 
        default:
                fail_kw_on_dlt(cstate, "dir");
                /*NOTREACHED*/
        }
 
        default:
                fail_kw_on_dlt(cstate, "dir");
                /*NOTREACHED*/
        }

-
-       b0 = gen_mcmp(cstate, OR_LINKHDR, 1, BPF_B, fcdir,
-           IEEE80211_FC1_DIR_MASK);
-
-       return (b0);

 }
 
 // Process an ARCnet host address string.
 }
 
 // Process an ARCnet host address string.


@@ -9022,9 +8711,7 @@ gen_vlan_bpf_extensions(compiler_state_t *cstate, bpf_u_int32 vlan_num,
        s = new_stmt(cstate, BPF_LD|BPF_B|BPF_ABS);
        s->s.k = (bpf_u_int32)(SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT);
 
        s = new_stmt(cstate, BPF_LD|BPF_B|BPF_ABS);
        s->s.k = (bpf_u_int32)(SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT);
 

-       b0 = new_block(cstate, JMP(BPF_JEQ));
-       b0->stmts = s;
-       b0->s.k = 1;
+       b0 = gen_jmp(cstate, BPF_JEQ, 1, s);

 
        /*
         * This is tricky. We need to insert the statements updating variable
 
        /*
         * This is tricky. We need to insert the statements updating variable


@@ -9346,7 +9033,7 @@ gen_pppoes(compiler_state_t *cstate, bpf_u_int32 sess_num, int has_sess_num)
  * specified. Parameterized to handle both IPv4 and IPv6. */
 static struct block *
 gen_geneve_check(compiler_state_t *cstate,
  * specified. Parameterized to handle both IPv4 and IPv6. */
 static struct block *
 gen_geneve_check(compiler_state_t *cstate,

-    struct block *(*gen_portfn)(compiler_state_t *, u_int, int, int),
+    struct block *(*gen_portfn)(compiler_state_t *, uint16_t, int, int),

     enum e_offrel offrel, bpf_u_int32 vni, int has_vni)
 {
        struct block *b0, *b1;
     enum e_offrel offrel, bpf_u_int32 vni, int has_vni)
 {
        struct block *b0, *b1;


@@ -9393,9 +9080,7 @@ gen_geneve4(compiler_state_t *cstate, bpf_u_int32 vni, int has_vni)
        /* Forcibly append these statements to the true condition
         * of the protocol check by creating a new block that is
         * always true and ANDing them. */
        /* Forcibly append these statements to the true condition
         * of the protocol check by creating a new block that is
         * always true and ANDing them. */

-       b1 = new_block(cstate, BPF_JMP|BPF_JEQ|BPF_X);
-       b1->stmts = s;
-       b1->s.k = 0;
+       b1 = gen_jmp(cstate, BPF_JMP|BPF_JEQ|BPF_X, 0, s);

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


@@ -9432,9 +9117,7 @@ gen_geneve6(compiler_state_t *cstate, bpf_u_int32 vni, int has_vni)
        s1 = new_stmt(cstate, BPF_MISC|BPF_TAX);
        sappend(s, s1);
 
        s1 = new_stmt(cstate, BPF_MISC|BPF_TAX);
        sappend(s, s1);
 

-       b1 = new_block(cstate, BPF_JMP|BPF_JEQ|BPF_X);
-       b1->stmts = s;
-       b1->s.k = 0;
+       b1 = gen_jmp(cstate, BPF_JMP|BPF_JEQ|BPF_X, 0, s);

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


@@ -9619,7 +9302,7 @@ gen_geneve(compiler_state_t *cstate, bpf_u_int32 vni, int has_vni)
  * specified. Parameterized to handle both IPv4 and IPv6. */
 static struct block *
 gen_vxlan_check(compiler_state_t *cstate,
  * specified. Parameterized to handle both IPv4 and IPv6. */
 static struct block *
 gen_vxlan_check(compiler_state_t *cstate,

-    struct block *(*gen_portfn)(compiler_state_t *, u_int, int, int),
+    struct block *(*gen_portfn)(compiler_state_t *, uint16_t, int, int),

     enum e_offrel offrel, bpf_u_int32 vni, int has_vni)
 {
        struct block *b0, *b1;
     enum e_offrel offrel, bpf_u_int32 vni, int has_vni)
 {
        struct block *b0, *b1;


@@ -9665,9 +9348,7 @@ gen_vxlan4(compiler_state_t *cstate, bpf_u_int32 vni, int has_vni)
        /* Forcibly append these statements to the true condition
         * of the protocol check by creating a new block that is
         * always true and ANDing them. */
        /* Forcibly append these statements to the true condition
         * of the protocol check by creating a new block that is
         * always true and ANDing them. */

-       b1 = new_block(cstate, BPF_JMP|BPF_JEQ|BPF_X);
-       b1->stmts = s;
-       b1->s.k = 0;
+       b1 = gen_jmp(cstate, BPF_JMP|BPF_JEQ|BPF_X, 0, s);

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


@@ -9704,9 +9385,7 @@ gen_vxlan6(compiler_state_t *cstate, bpf_u_int32 vni, int has_vni)
        s1 = new_stmt(cstate, BPF_MISC|BPF_TAX);
        sappend(s, s1);
 
        s1 = new_stmt(cstate, BPF_MISC|BPF_TAX);
        sappend(s, s1);
 

-       b1 = new_block(cstate, BPF_JMP|BPF_JEQ|BPF_X);
-       b1->stmts = s;
-       b1->s.k = 0;
+       b1 = gen_jmp(cstate, BPF_JMP|BPF_JEQ|BPF_X, 0, s);

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


@@ -9837,9 +9516,7 @@ gen_encap_ll_check(compiler_state_t *cstate)
        s1->s.k = cstate->off_linkpl.reg;
        sappend(s, s1);
 
        s1->s.k = cstate->off_linkpl.reg;
        sappend(s, s1);
 

-       b0 = new_block(cstate, BPF_JMP|BPF_JEQ|BPF_X);
-       b0->stmts = s;
-       b0->s.k = 0;
+       b0 = gen_jmp(cstate, BPF_JMP|BPF_JEQ|BPF_X, 0, s);

        gen_not(b0);
 
        return b0;
        gen_not(b0);
 
        return b0;


@@ -9849,68 +9526,41 @@ static struct block *
 gen_atmfield_code_internal(compiler_state_t *cstate, int atmfield,
     bpf_u_int32 jvalue, int jtype, int reverse)
 {
 gen_atmfield_code_internal(compiler_state_t *cstate, int atmfield,
     bpf_u_int32 jvalue, int jtype, int reverse)
 {

-       struct block *b0;
-
-       /*
-        * This check is a no-op for A_MSGTYPE so long as the only incoming
-        * code path is from gen_atmmulti_abbrev(), which makes the same
-        * check first; also for A_PROTOTYPE so long as the only incoming code
-        * paths are from gen_atmtype_abbrev(), which makes the same check
-        * first, or from gen_llc_internal() or gen_linktype(), which restrict
-        * it to DLT_SUNATM.
-        */

        assert_atm(cstate, atmkw(atmfield));
 
        switch (atmfield) {
 
        case A_VPI:
                assert_maxval(cstate, "VPI", jvalue, UINT8_MAX);
        assert_atm(cstate, atmkw(atmfield));
 
        switch (atmfield) {
 
        case A_VPI:
                assert_maxval(cstate, "VPI", jvalue, UINT8_MAX);

-               b0 = gen_ncmp(cstate, OR_LINKHDR, cstate->off_vpi, BPF_B,
+               return gen_ncmp(cstate, OR_LINKHDR, cstate->off_vpi, BPF_B,

                    0xffffffffU, jtype, reverse, jvalue);
                    0xffffffffU, jtype, reverse, jvalue);

-               break;

 
        case A_VCI:
                assert_maxval(cstate, "VCI", jvalue, UINT16_MAX);
 
        case A_VCI:
                assert_maxval(cstate, "VCI", jvalue, UINT16_MAX);

-               b0 = gen_ncmp(cstate, OR_LINKHDR, cstate->off_vci, BPF_H,
-                   0xffffffffU, jtype, reverse, jvalue);
-               break;
-
-       case A_PROTOTYPE:
-               b0 = gen_ncmp(cstate, OR_LINKHDR, cstate->off_proto, BPF_B,
-                   0x0fU, jtype, reverse, jvalue);
-               break;
-
-       case A_MSGTYPE:
-               b0 = gen_ncmp(cstate, OR_LINKHDR, cstate->off_payload + MSG_TYPE_POS, BPF_B,
+               return gen_ncmp(cstate, OR_LINKHDR, cstate->off_vci, BPF_H,

                    0xffffffffU, jtype, reverse, jvalue);
                    0xffffffffU, jtype, reverse, jvalue);

-               break;

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

-       return b0;

 }
 
 static struct block *
 }
 
 static struct block *

-gen_atmtype_metac(compiler_state_t *cstate)
+gen_atm_vpi(compiler_state_t *cstate, const uint8_t v)

 {
 {

-       struct block *b0, *b1;
-
-       b0 = gen_atmfield_code_internal(cstate, A_VPI, 0, BPF_JEQ, 0);
-       b1 = gen_atmfield_code_internal(cstate, A_VCI, 1, BPF_JEQ, 0);
-       gen_and(b0, b1);
-       return b1;
+       return gen_atmfield_code_internal(cstate, A_VPI, v, BPF_JEQ, 0);

 }
 
 static struct block *
 }
 
 static struct block *

-gen_atmtype_sc(compiler_state_t *cstate)
+gen_atm_vci(compiler_state_t *cstate, const uint16_t v)

 {
 {

-       struct block *b0, *b1;
+       return gen_atmfield_code_internal(cstate, A_VCI, v, BPF_JEQ, 0);
+}

 
 

-       b0 = gen_atmfield_code_internal(cstate, A_VPI, 0, BPF_JEQ, 0);
-       b1 = gen_atmfield_code_internal(cstate, A_VCI, 5, BPF_JEQ, 0);
-       gen_and(b0, b1);
-       return b1;
+static struct block *
+gen_atm_prototype(compiler_state_t *cstate, const uint8_t v)
+{
+       return gen_mcmp(cstate, OR_LINKHDR, cstate->off_proto, BPF_B, v, 0x0fU);

 }
 
 static struct block *
 }
 
 static struct block *


@@ -9918,7 +9568,7 @@ gen_atmtype_llc(compiler_state_t *cstate)
 {
        struct block *b0;
 
 {
        struct block *b0;
 

-       b0 = gen_atmfield_code_internal(cstate, A_PROTOTYPE, PT_LLC, BPF_JEQ, 0);
+       b0 = gen_atm_prototype(cstate, PT_LLC);

        cstate->linktype = cstate->prevlinktype;
        return b0;
 }
        cstate->linktype = cstate->prevlinktype;
        return b0;
 }


@@ -9956,45 +9606,49 @@ gen_atmtype_abbrev(compiler_state_t *cstate, int type)
 
        case A_METAC:
                /* Get all packets in Meta signalling Circuit */
 
        case A_METAC:
                /* Get all packets in Meta signalling Circuit */

-               b1 = gen_atmtype_metac(cstate);
-               break;
+               b0 = gen_atm_vpi(cstate, 0);
+               b1 = gen_atm_vci(cstate, 1);
+               gen_and(b0, b1);
+               return b1;

 
        case A_BCC:
                /* Get all packets in Broadcast Circuit*/
 
        case A_BCC:
                /* Get all packets in Broadcast Circuit*/

-               b0 = gen_atmfield_code_internal(cstate, A_VPI, 0, BPF_JEQ, 0);
-               b1 = gen_atmfield_code_internal(cstate, A_VCI, 2, BPF_JEQ, 0);
+               b0 = gen_atm_vpi(cstate, 0);
+               b1 = gen_atm_vci(cstate, 2);

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

-               break;
+               return b1;

 
        case A_OAMF4SC:
                /* Get all cells in Segment OAM F4 circuit*/
 
        case A_OAMF4SC:
                /* Get all cells in Segment OAM F4 circuit*/

-               b0 = gen_atmfield_code_internal(cstate, A_VPI, 0, BPF_JEQ, 0);
-               b1 = gen_atmfield_code_internal(cstate, A_VCI, 3, BPF_JEQ, 0);
+               b0 = gen_atm_vpi(cstate, 0);
+               b1 = gen_atm_vci(cstate, 3);

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

-               break;
+               return b1;

 
        case A_OAMF4EC:
                /* Get all cells in End-to-End OAM F4 Circuit*/
 
        case A_OAMF4EC:
                /* Get all cells in End-to-End OAM F4 Circuit*/

-               b0 = gen_atmfield_code_internal(cstate, A_VPI, 0, BPF_JEQ, 0);
-               b1 = gen_atmfield_code_internal(cstate, A_VCI, 4, BPF_JEQ, 0);
+               b0 = gen_atm_vpi(cstate, 0);
+               b1 = gen_atm_vci(cstate, 4);

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

-               break;
+               return b1;

 
        case A_SC:
                /*  Get all packets in connection Signalling Circuit */
 
        case A_SC:
                /*  Get all packets in connection Signalling Circuit */

-               b1 = gen_atmtype_sc(cstate);
-               break;
+               b0 = gen_atm_vpi(cstate, 0);
+               b1 = gen_atm_vci(cstate, 5);
+               gen_and(b0, b1);
+               return b1;

 
        case A_ILMIC:
                /* Get all packets in ILMI Circuit */
 
        case A_ILMIC:
                /* Get all packets in ILMI Circuit */

-               b0 = gen_atmfield_code_internal(cstate, A_VPI, 0, BPF_JEQ, 0);
-               b1 = gen_atmfield_code_internal(cstate, A_VCI, 16, BPF_JEQ, 0);
+               b0 = gen_atm_vpi(cstate, 0);
+               b1 = gen_atm_vci(cstate, 16);

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

-               break;
+               return b1;

 
        case A_LANE:
                /* Get all LANE packets */
 
        case A_LANE:
                /* Get all LANE packets */

-               b1 = gen_atmfield_code_internal(cstate, A_PROTOTYPE, PT_LANE, BPF_JEQ, 0);
+               b1 = gen_atm_prototype(cstate, PT_LANE);

 
                /*
                 * Arrange that all subsequent tests assume LANE
 
                /*
                 * Arrange that all subsequent tests assume LANE


@@ -10011,12 +9665,11 @@ gen_atmtype_abbrev(compiler_state_t *cstate, int type)
                cstate->off_linkpl.constant_part = cstate->off_linkhdr.constant_part + 14;      /* Ethernet */
                cstate->off_nl = 0;                     /* Ethernet II */
                cstate->off_nl_nosnap = 3;              /* 802.3+802.2 */
                cstate->off_linkpl.constant_part = cstate->off_linkhdr.constant_part + 14;      /* Ethernet */
                cstate->off_nl = 0;                     /* Ethernet II */
                cstate->off_nl_nosnap = 3;              /* 802.3+802.2 */

-               break;
+               return b1;

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

-       return b1;

 }
 
 /*
 }
 
 /*


@@ -10043,10 +9696,8 @@ gen_mtp2type_abbrev(compiler_state_t *cstate, int type)
        switch (type) {
 
        case M_FISU:
        switch (type) {
 
        case M_FISU:

-               /* gen_ncmp(cstate, offrel, offset, size, mask, jtype, reverse, value) */
-               b0 = gen_ncmp(cstate, OR_PACKET, cstate->off_li, BPF_B,
+               return gen_ncmp(cstate, OR_PACKET, cstate->off_li, BPF_B,

                    0x3fU, BPF_JEQ, 0, 0U);
                    0x3fU, BPF_JEQ, 0, 0U);

-               break;

 
        case M_LSSU:
                b0 = gen_ncmp(cstate, OR_PACKET, cstate->off_li, BPF_B,
 
        case M_LSSU:
                b0 = gen_ncmp(cstate, OR_PACKET, cstate->off_li, BPF_B,


@@ -10054,18 +9705,15 @@ gen_mtp2type_abbrev(compiler_state_t *cstate, int type)
                b1 = gen_ncmp(cstate, OR_PACKET, cstate->off_li, BPF_B,
                    0x3fU, BPF_JGT, 0, 0U);
                gen_and(b1, b0);
                b1 = gen_ncmp(cstate, OR_PACKET, cstate->off_li, BPF_B,
                    0x3fU, BPF_JGT, 0, 0U);
                gen_and(b1, b0);

-               break;
+               return b0;

 
        case M_MSU:
 
        case M_MSU:

-               b0 = gen_ncmp(cstate, OR_PACKET, cstate->off_li, BPF_B,
+               return gen_ncmp(cstate, OR_PACKET, cstate->off_li, BPF_B,

                    0x3fU, BPF_JGT, 0, 2U);
                    0x3fU, BPF_JGT, 0, 2U);

-               break;

 
        case MH_FISU:
 
        case MH_FISU:

-               /* gen_ncmp(cstate, offrel, offset, size, mask, jtype, reverse, value) */
-               b0 = gen_ncmp(cstate, OR_PACKET, cstate->off_li_hsl, BPF_H,
+               return gen_ncmp(cstate, OR_PACKET, cstate->off_li_hsl, BPF_H,

                    0xff80U, BPF_JEQ, 0, 0U);
                    0xff80U, BPF_JEQ, 0, 0U);

-               break;

 
        case MH_LSSU:
                b0 = gen_ncmp(cstate, OR_PACKET, cstate->off_li_hsl, BPF_H,
 
        case MH_LSSU:
                b0 = gen_ncmp(cstate, OR_PACKET, cstate->off_li_hsl, BPF_H,


@@ -10073,17 +9721,15 @@ gen_mtp2type_abbrev(compiler_state_t *cstate, int type)
                b1 = gen_ncmp(cstate, OR_PACKET, cstate->off_li_hsl, BPF_H,
                    0xff80U, BPF_JGT, 0, 0U);
                gen_and(b1, b0);
                b1 = gen_ncmp(cstate, OR_PACKET, cstate->off_li_hsl, BPF_H,
                    0xff80U, BPF_JGT, 0, 0U);
                gen_and(b1, b0);

-               break;
+               return b0;

 
        case MH_MSU:
 
        case MH_MSU:

-               b0 = gen_ncmp(cstate, OR_PACKET, cstate->off_li_hsl, BPF_H,
+               return gen_ncmp(cstate, OR_PACKET, cstate->off_li_hsl, BPF_H,

                    0xff80U, BPF_JGT, 0, 0x0100U);
                    0xff80U, BPF_JGT, 0, 0x0100U);

-               break;

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

-       return b0;

 }
 
 /*
 }
 
 /*


@@ -10098,7 +9744,6 @@ static struct block *
 gen_mtp3field_code_internal(compiler_state_t *cstate, int mtp3field,
     bpf_u_int32 jvalue, int jtype, int reverse)
 {
 gen_mtp3field_code_internal(compiler_state_t *cstate, int mtp3field,
     bpf_u_int32 jvalue, int jtype, int reverse)
 {

-       struct block *b0;

        u_int newoff_sio;
        u_int newoff_opc;
        u_int newoff_dpc;
        u_int newoff_sio;
        u_int newoff_opc;
        u_int newoff_dpc;


@@ -10127,9 +9772,8 @@ gen_mtp3field_code_internal(compiler_state_t *cstate, int mtp3field,
        case M_SIO:
                assert_maxval(cstate, ss7kw(mtp3field), jvalue, MTP2_SIO_MAXVAL);
                // Here the bitmask means "do not apply a bitmask".
        case M_SIO:
                assert_maxval(cstate, ss7kw(mtp3field), jvalue, MTP2_SIO_MAXVAL);
                // Here the bitmask means "do not apply a bitmask".

-               b0 = gen_ncmp(cstate, OR_PACKET, newoff_sio, BPF_B, UINT32_MAX,
+               return gen_ncmp(cstate, OR_PACKET, newoff_sio, BPF_B, UINT32_MAX,

                    jtype, reverse, jvalue);
                    jtype, reverse, jvalue);

-               break;

 
        /*
         * See UTU-T Rec. Q.704, Section 2.2, Figure 3/Q.704.
 
        /*
         * See UTU-T Rec. Q.704, Section 2.2, Figure 3/Q.704.


@@ -10166,10 +9810,9 @@ gen_mtp3field_code_internal(compiler_state_t *cstate, int mtp3field,
                /* FALLTHROUGH */
        case M_OPC:
                assert_maxval(cstate, ss7kw(mtp3field), jvalue, MTP3_PC_MAXVAL);
                /* FALLTHROUGH */
        case M_OPC:
                assert_maxval(cstate, ss7kw(mtp3field), jvalue, MTP3_PC_MAXVAL);

-               b0 = gen_ncmp(cstate, OR_PACKET, newoff_opc, BPF_W,
+               return gen_ncmp(cstate, OR_PACKET, newoff_opc, BPF_W,

                    SWAPLONG(MTP3_PC_MAXVAL << 14), jtype, reverse,
                    SWAPLONG(jvalue << 14));
                    SWAPLONG(MTP3_PC_MAXVAL << 14), jtype, reverse,
                    SWAPLONG(jvalue << 14));

-               break;

 
        case MH_DPC:
                newoff_dpc += 3;
 
        case MH_DPC:
                newoff_dpc += 3;


@@ -10177,10 +9820,9 @@ gen_mtp3field_code_internal(compiler_state_t *cstate, int mtp3field,
 
        case M_DPC:
                assert_maxval(cstate, ss7kw(mtp3field), jvalue, MTP3_PC_MAXVAL);
 
        case M_DPC:
                assert_maxval(cstate, ss7kw(mtp3field), jvalue, MTP3_PC_MAXVAL);

-               b0 = gen_ncmp(cstate, OR_PACKET, newoff_dpc, BPF_H,
+               return gen_ncmp(cstate, OR_PACKET, newoff_dpc, BPF_H,

                    SWAPSHORT(MTP3_PC_MAXVAL), jtype, reverse,
                    SWAPSHORT(jvalue));
                    SWAPSHORT(MTP3_PC_MAXVAL), jtype, reverse,
                    SWAPSHORT(jvalue));

-               break;

 
        case MH_SLS:
                newoff_sls += 3;
 
        case MH_SLS:
                newoff_sls += 3;


@@ -10188,15 +9830,13 @@ gen_mtp3field_code_internal(compiler_state_t *cstate, int mtp3field,
 
        case M_SLS:
                assert_maxval(cstate, ss7kw(mtp3field), jvalue, MTP3_SLS_MAXVAL);
 
        case M_SLS:
                assert_maxval(cstate, ss7kw(mtp3field), jvalue, MTP3_SLS_MAXVAL);

-               b0 = gen_ncmp(cstate, OR_PACKET, newoff_sls, BPF_B,
+               return gen_ncmp(cstate, OR_PACKET, newoff_sls, BPF_B,

                    MTP3_SLS_MAXVAL << 4, jtype, reverse,
                    jvalue << 4);
                    MTP3_SLS_MAXVAL << 4, jtype, reverse,
                    jvalue << 4);

-               break;

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

-       return b0;

 }
 
 struct block *
 }
 
 struct block *


@@ -10215,44 +9855,14 @@ gen_mtp3field_code(compiler_state_t *cstate, int mtp3field,
 }
 
 static struct block *
 }
 
 static struct block *

-gen_msg_abbrev(compiler_state_t *cstate, int type)
+gen_msg_abbrev(compiler_state_t *cstate, const uint8_t type)

 {
 {

-       struct block *b1;
-

        /*
         * Q.2931 signalling protocol messages for handling virtual circuits
         * establishment and teardown
         */
        /*
         * Q.2931 signalling protocol messages for handling virtual circuits
         * establishment and teardown
         */

-       switch (type) {
-
-       case A_SETUP:
-               b1 = gen_atmfield_code_internal(cstate, A_MSGTYPE, SETUP, BPF_JEQ, 0);
-               break;
-
-       case A_CALLPROCEED:
-               b1 = gen_atmfield_code_internal(cstate, A_MSGTYPE, CALL_PROCEED, BPF_JEQ, 0);
-               break;
-
-       case A_CONNECT:
-               b1 = gen_atmfield_code_internal(cstate, A_MSGTYPE, CONNECT, BPF_JEQ, 0);
-               break;
-
-       case A_CONNECTACK:
-               b1 = gen_atmfield_code_internal(cstate, A_MSGTYPE, CONNECT_ACK, BPF_JEQ, 0);
-               break;
-
-       case A_RELEASE:
-               b1 = gen_atmfield_code_internal(cstate, A_MSGTYPE, RELEASE, BPF_JEQ, 0);
-               break;
-
-       case A_RELEASE_DONE:
-               b1 = gen_atmfield_code_internal(cstate, A_MSGTYPE, RELEASE_DONE, BPF_JEQ, 0);
-               break;
-
-       default:
-               abort();
-       }
-       return b1;
+       return gen_cmp(cstate, OR_LINKHDR, cstate->off_payload + MSG_TYPE_POS,
+           BPF_B, type);

 }
 
 struct block *
 }
 
 struct block *


@@ -10273,58 +9883,57 @@ gen_atmmulti_abbrev(compiler_state_t *cstate, int type)
 
        case A_OAM:
                /* OAM F4 type */
 
        case A_OAM:
                /* OAM F4 type */

-               b0 = gen_atmfield_code_internal(cstate, A_VCI, 3, BPF_JEQ, 0);
-               b1 = gen_atmfield_code_internal(cstate, A_VCI, 4, BPF_JEQ, 0);
+               b0 = gen_atm_vci(cstate, 3);
+               b1 = gen_atm_vci(cstate, 4);

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

-               b0 = gen_atmfield_code_internal(cstate, A_VPI, 0, BPF_JEQ, 0);
+               b0 = gen_atm_vpi(cstate, 0);

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

-               break;
+               return b1;

 
        case A_OAMF4:
                /* OAM F4 type */
 
        case A_OAMF4:
                /* OAM F4 type */

-               b0 = gen_atmfield_code_internal(cstate, A_VCI, 3, BPF_JEQ, 0);
-               b1 = gen_atmfield_code_internal(cstate, A_VCI, 4, BPF_JEQ, 0);
+               b0 = gen_atm_vci(cstate, 3);
+               b1 = gen_atm_vci(cstate, 4);

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

-               b0 = gen_atmfield_code_internal(cstate, A_VPI, 0, BPF_JEQ, 0);
+               b0 = gen_atm_vpi(cstate, 0);

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

-               break;
+               return b1;

 
        case A_CONNECTMSG:
                /*
                 * Get Q.2931 signalling messages for switched
                 * virtual connection
                 */
 
        case A_CONNECTMSG:
                /*
                 * Get Q.2931 signalling messages for switched
                 * virtual connection
                 */

-               b0 = gen_msg_abbrev(cstate, A_SETUP);
-               b1 = gen_msg_abbrev(cstate, A_CALLPROCEED);
+               b0 = gen_msg_abbrev(cstate, SETUP);
+               b1 = gen_msg_abbrev(cstate, CALL_PROCEED);

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

-               b0 = gen_msg_abbrev(cstate, A_CONNECT);
+               b0 = gen_msg_abbrev(cstate, CONNECT);

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

-               b0 = gen_msg_abbrev(cstate, A_CONNECTACK);
+               b0 = gen_msg_abbrev(cstate, CONNECT_ACK);

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

-               b0 = gen_msg_abbrev(cstate, A_RELEASE);
+               b0 = gen_msg_abbrev(cstate, RELEASE);

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

-               b0 = gen_msg_abbrev(cstate, A_RELEASE_DONE);
+               b0 = gen_msg_abbrev(cstate, RELEASE_DONE);

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

-               b0 = gen_atmtype_sc(cstate);
+               b0 = gen_atmtype_abbrev(cstate, A_SC);

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

-               break;
+               return b1;

 
        case A_METACONNECT:
 
        case A_METACONNECT:

-               b0 = gen_msg_abbrev(cstate, A_SETUP);
-               b1 = gen_msg_abbrev(cstate, A_CALLPROCEED);
+               b0 = gen_msg_abbrev(cstate, SETUP);
+               b1 = gen_msg_abbrev(cstate, CALL_PROCEED);

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

-               b0 = gen_msg_abbrev(cstate, A_CONNECT);
+               b0 = gen_msg_abbrev(cstate, CONNECT);

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

-               b0 = gen_msg_abbrev(cstate, A_RELEASE);
+               b0 = gen_msg_abbrev(cstate, RELEASE);

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

-               b0 = gen_msg_abbrev(cstate, A_RELEASE_DONE);
+               b0 = gen_msg_abbrev(cstate, RELEASE_DONE);

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

-               b0 = gen_atmtype_metac(cstate);
+               b0 = gen_atmtype_abbrev(cstate, A_METAC);

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

-               break;
+               return b1;

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

-       return b1;

 }
 }