*/
enum e_offrel {
OR_PACKET, /* full packet data */
- OR_LINK, /* link-layer header */
- OR_OUTERLINK, /* outer link-layer header */
+ OR_LINKHDR, /* link-layer header */
+ OR_PREVLINKHDR, /* previous link-layer header */
OR_LLC, /* 802.2 LLC header */
OR_LINKPL, /* link-layer payload */
OR_MPLSPL, /* MPLS payload */
static struct block *gen_bcmp(enum e_offrel, u_int, u_int, const u_char *);
static struct block *gen_ncmp(enum e_offrel, bpf_u_int32, bpf_u_int32,
bpf_u_int32, bpf_u_int32, int, bpf_int32);
-static struct slist *gen_load_llrel(u_int, u_int);
-static struct slist *gen_load_outerllrel(u_int, u_int);
+static struct slist *gen_load_linkhdrrel(u_int, u_int);
+static struct slist *gen_load_prevlinkhdrrel(u_int, u_int);
static struct slist *gen_load_linkplrel(u_int, u_int);
static struct slist *gen_load_a(enum e_offrel, u_int, u_int);
static struct slist *gen_loadx_iphdrlen(void);
static struct slist *gen_load_ppi_llprefixlen(void);
static void insert_compute_vloffsets(struct block *);
static struct slist *gen_llprefixlen(void);
-static struct slist *gen_outerllprefixlen(void);
+static struct slist *gen_prevlinkhdrprefixlen(void);
static struct slist *gen_off_linkpl(void);
static int ethertype_to_ppptype(int);
static struct block *gen_linktype(int);
*
* It's usually 0, except for 802.11 with a fixed-length radio header.
* (For 802.11 with a variable-length radio header, we have to generate
- * code to compute that offset; off_ll is 0 in that case.)
+ * code to compute that offset; off_linkhdr is 0 in that case.)
*/
-static u_int off_ll;
+static u_int off_linkhdr;
/*
* If there's a variable-length header preceding the link-layer header,
- * "reg_off_ll" is the register number for a register containing the
+ * "reg_off_linkhdr" is the register number for a register containing the
* length of that header, and therefore the offset of the link-layer
* header from the beginning of the raw packet data. Otherwise,
- * "reg_off_ll" is -1.
+ * "reg_off_linkhdr" is -1.
*/
-static int reg_off_ll;
+static int reg_off_linkhdr;
/*
* If we're checking a link-layer header for a packet encapsulated in
- * another protocol layer, this is the offset of the outer layers'
+ * another protocol layer, this is the offset of the previous layers'
* link-layer header from the beginning of the raw packet data.
*/
-static u_int off_outerll;
+static u_int off_prevlinkhdr;
/*
* This is the offset of the outermost layers' link-layer header from
* the beginning of the raw packet data.
*/
-static u_int off_outermostll;
+static u_int off_outermostlinkhdr;
/*
* The offset of the beginning of the link-layer payload, from the beginning
/*
* "off_linktype" is the offset to information in the link-layer header
* giving the packet type. This offset is relative to the beginning
- * of the link-layer header - i.e., it doesn't include off_ll - so
+ * of the link-layer header - i.e., it doesn't include off_linkhdr - so
* loads with an offset that includes "off_linktype" should use
- * OR_LINK.
+ * OR_LINKHDR.
*
* For Ethernet, it's the offset of the Ethernet type field; this
* means that it must have a value that skips VLAN tags.
/*
* These are offsets to the beginning of the network-layer header.
* They are relative to the beginning of the link-layer payload (i.e.,
- * they don't include off_ll or off_linkpl).
+ * they don't include off_linkhdr or off_linkpl).
*
* If the link layer never uses 802.2 LLC:
*
static u_int off_nl_nosnap;
static int linktype;
-static int outerlinktype;
+static int prevlinktype;
static int outermostlinktype;
static void
{
outermostlinktype = pcap_datalink(p);
pcap_fddipad = p->fddipad;
- outerlinktype = outermostlinktype;
- off_outermostll = 0;
+ prevlinktype = outermostlinktype;
+ off_outermostlinkhdr = 0;
/*
* No link-layer header inside the payload for another
* protocol, for now.
*/
- linktype = outerlinktype;
- off_outerll = 0;
+ linktype = prevlinktype;
+ off_prevlinkhdr = 0;
/*
* Assume it's not raw ATM with a pseudo-header, for now.
/*
* Also assume it's not 802.11.
*/
- off_ll = 0;
+ off_linkhdr = 0;
off_linkpl_constant_part = 0;
off_linkpl_is_variable = 0;
label_stack_depth = 0;
vlan_stack_depth = 0;
- reg_off_ll = -1;
+ reg_off_linkhdr = -1;
reg_off_linkpl = -1;
switch (linktype) {
return;
case DLT_NETANALYZER:
- off_ll = 4; /* Ethernet header is past 4-byte pseudo-header */
+ off_linkhdr = 4; /* Ethernet header is past 4-byte pseudo-header */
off_linktype = 12;
- off_linkpl_constant_part = off_ll + 14; /* pseudo-header+Ethernet header length */
+ off_linkpl_constant_part = off_linkhdr + 14; /* pseudo-header+Ethernet header length */
off_nl = 0; /* Ethernet II */
off_nl_nosnap = 3; /* 802.3+802.2 */
return;
case DLT_NETANALYZER_TRANSPARENT:
- off_ll = 12; /* MAC header is past 4-byte pseudo-header, preamble, and SFD */
+ off_linkhdr = 12; /* MAC header is past 4-byte pseudo-header, preamble, and SFD */
off_linktype = 12;
- off_linkpl_constant_part = off_ll + 14; /* pseudo-header+preamble+SFD+Ethernet header length */
+ off_linkpl_constant_part = off_linkhdr + 14; /* pseudo-header+preamble+SFD+Ethernet header length */
off_nl = 0; /* Ethernet II */
off_nl_nosnap = 3; /* 802.3+802.2 */
return;
* radio information.
*/
static struct slist *
-gen_load_llrel(offset, size)
+gen_load_linkhdrrel(offset, size)
u_int offset, size;
{
struct slist *s, *s2;
* header.
*
* Otherwise, the length of the prefix preceding the link-layer
- * header is "off_ll".
+ * header is "off_linkhdr".
*/
if (s != NULL) {
/*
} else {
/*
* There is no variable-length header preceding the
- * link-layer header; add in off_ll, which, if there's
+ * link-layer header; add in off_linkhdr, which, if there's
* a fixed-length header preceding the link-layer header,
* is the length of that header.
*/
s = new_stmt(BPF_LD|BPF_ABS|size);
- s->s.k = offset + off_ll;
+ s->s.k = offset + off_linkhdr;
}
return s;
}
/*
- * Load a value relative to the beginning of the outer link-layer header,
+ * Load a value relative to the beginning of the previous link-layer header,
* if we're also looking at an inner link-layer header encapsulated
* within other protocol layers.
*
* radio information.
*/
static struct slist *
-gen_load_outerllrel(offset, size)
+gen_load_prevlinkhdrrel(offset, size)
u_int offset, size;
{
struct slist *s, *s2;
- s = gen_outerllprefixlen();
+ s = gen_prevlinkhdrprefixlen();
/*
* If "s" is non-null, it has code to arrange that the X register
* header.
*
* Otherwise, the length of the prefix preceding the link-layer
- * header is "off_outerll".
+ * header is "off_prevlinkhdr".
*/
if (s != NULL) {
/*
} else {
/*
* There is no variable-length header preceding the
- * link-layer header; add in outer_off_ll, which, if there's
+ * link-layer header; add in off_prevlinkhdr, which, if there's
* a fixed-length header preceding the link-layer header,
* is the length of that header.
*/
s = new_stmt(BPF_LD|BPF_ABS|size);
- s->s.k = off_outerll + offset;
+ s->s.k = off_prevlinkhdr + offset;
}
return s;
}
s->s.k = offset;
break;
- case OR_LINK:
- s = gen_load_llrel(offset, size);
+ case OR_LINKHDR:
+ s = gen_load_linkhdrrel(offset, size);
break;
- case OR_OUTERLINK:
- s = gen_load_outerllrel(offset, size);
+ case OR_PREVLINKHDR:
+ s = gen_load_prevlinkhdrrel(offset, size);
break;
case OR_LLC:
* DSAP, as we do for other types <= ETHERMTU
* (i.e., other SAP values)?
*/
- b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
+ b0 = gen_cmp_gt(OR_LINKHDR, off_linktype, BPF_H, ETHERMTU);
gen_not(b0);
b1 = gen_cmp(OR_LLC, 0, BPF_H, (bpf_int32)
((proto << 8) | proto));
* Now we generate code to check for 802.3
* frames in general.
*/
- b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
+ b0 = gen_cmp_gt(OR_LINKHDR, off_linktype, BPF_H, ETHERMTU);
gen_not(b0);
/*
* do that before checking for the other frame
* types.
*/
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_H,
(bpf_int32)ETHERTYPE_IPX);
gen_or(b0, b1);
return b1;
* we check for an Ethernet type field less than
* 1500, which means it's an 802.3 length field.
*/
- b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
+ b0 = gen_cmp_gt(OR_LINKHDR, off_linktype, BPF_H, ETHERMTU);
gen_not(b0);
/*
* phase 1?); we just check for the Ethernet
* protocol type.
*/
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_H, (bpf_int32)proto);
gen_or(b0, b1);
return b1;
* a length field, <= ETHERMTU) and
* then check the DSAP.
*/
- b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
+ b0 = gen_cmp_gt(OR_LINKHDR, off_linktype, BPF_H, ETHERMTU);
gen_not(b0);
- b1 = gen_cmp(OR_LINK, off_linktype + 2, BPF_B,
+ b1 = gen_cmp(OR_LINKHDR, off_linktype + 2, BPF_B,
(bpf_int32)proto);
gen_and(b0, b1);
return b1;
* will fail and the frame won't match,
* which is what we want).
*/
- return gen_cmp(OR_LINK, off_linktype, BPF_H,
+ return gen_cmp(OR_LINKHDR, off_linktype, BPF_H,
(bpf_int32)proto);
}
}
switch (proto) {
case ETHERTYPE_IP:
- return gen_cmp(OR_LINK, off_linktype, BPF_B,
+ return gen_cmp(OR_LINKHDR, off_linktype, BPF_B,
(bpf_int32)IPH_AF_INET);
/* NOTREACHED */
case ETHERTYPE_IPV6:
- return gen_cmp(OR_LINK, off_linktype, BPF_B,
+ return gen_cmp(OR_LINKHDR, off_linktype, BPF_B,
(bpf_int32)IPH_AF_INET6);
/* NOTREACHED */
* DSAP, as we do for other types <= ETHERMTU
* (i.e., other SAP values)?
*/
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_H, LINUX_SLL_P_802_2);
b1 = gen_cmp(OR_LLC, 0, BPF_H, (bpf_int32)
((proto << 8) | proto));
gen_and(b0, b1);
b0 = gen_cmp(OR_LLC, 0, BPF_B, (bpf_int32)LLCSAP_IPX);
b1 = gen_snap(0x000000, ETHERTYPE_IPX);
gen_or(b0, b1);
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_H, LINUX_SLL_P_802_2);
gen_and(b0, b1);
/*
* Now check for 802.3 frames and OR that with
* the previous test.
*/
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_3);
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_H, LINUX_SLL_P_802_3);
gen_or(b0, b1);
/*
* do that before checking for the other frame
* types.
*/
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_H,
(bpf_int32)ETHERTYPE_IPX);
gen_or(b0, b1);
return b1;
* we check for the 802.2 protocol type in the
* "Ethernet type" field.
*/
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_H, LINUX_SLL_P_802_2);
/*
* 802.2-encapsulated ETHERTYPE_ATALK packets are
* phase 1?); we just check for the Ethernet
* protocol type.
*/
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_H, (bpf_int32)proto);
gen_or(b0, b1);
return b1;
* in the "Ethernet type" field, and
* then check the DSAP.
*/
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_H,
LINUX_SLL_P_802_2);
- b1 = gen_cmp(OR_LINK, off_linkpl_constant_part, BPF_B,
+ b1 = gen_cmp(OR_LINKHDR, off_linkpl_constant_part, BPF_B,
(bpf_int32)proto);
gen_and(b0, b1);
return b1;
* will fail and the frame won't match,
* which is what we want).
*/
- return gen_cmp(OR_LINK, off_linktype, BPF_H,
+ return gen_cmp(OR_LINKHDR, off_linktype, BPF_H,
(bpf_int32)proto);
}
}
* but no known software generates headers that aren't 144
* bytes long.
*/
- if (reg_off_ll != -1) {
+ if (reg_off_linkhdr != -1) {
/*
* Load the cookie.
*/
* loading the length of the AVS header.
*/
s2 = new_stmt(BPF_ST);
- s2->s.k = reg_off_ll;
+ s2->s.k = reg_off_linkhdr;
sappend(s1, s2);
sjcommon->s.jf = s2;
* generated uses that prefix, so we don't need to generate any
* code to load it.)
*/
- if (reg_off_ll != -1) {
+ if (reg_off_linkhdr != -1) {
/*
* The 4 bytes at an offset of 4 from the beginning of
* the AVS header are the length of the AVS header.
* it.
*/
s2 = new_stmt(BPF_ST);
- s2->s.k = reg_off_ll;
+ s2->s.k = reg_off_linkhdr;
sappend(s1, s2);
/*
* generated uses that prefix, so we don't need to generate any
* code to load it.)
*/
- if (reg_off_ll != -1) {
+ if (reg_off_linkhdr != -1) {
/*
* The 2 bytes at offsets of 2 and 3 from the beginning
* of the radiotap header are the length of the radiotap
* it.
*/
s2 = new_stmt(BPF_ST);
- s2->s.k = reg_off_ll;
+ s2->s.k = reg_off_linkhdr;
sappend(s1, s2);
/*
* into the register assigned to hold that length, if one has
* been assigned.
*/
- if (reg_off_ll != -1) {
+ if (reg_off_linkhdr != -1) {
/*
* The 2 bytes at offsets of 2 and 3 from the beginning
* of the radiotap header are the length of the radiotap
* it.
*/
s2 = new_stmt(BPF_ST);
- s2->s.k = reg_off_ll;
+ s2->s.k = reg_off_linkhdr;
sappend(s1, s2);
/*
* header.
*
* Otherwise, the length of the prefix preceding the link-layer
- * header is "off_outermostll".
+ * header is "off_outermostlinkhdr".
*/
if (s == NULL) {
/*
* Load the length of the fixed-length prefix preceding
* the link-layer header (if any) into the X register,
* and store it in the reg_off_linkpl register.
- * That length is off_outermostll.
+ * That length is off_outermostlinkhdr.
*/
s = new_stmt(BPF_LDX|BPF_IMM);
- s->s.k = off_outermostll;
+ s->s.k = off_outermostlinkhdr;
}
/*
{
struct slist *s;
- if (reg_off_ll == -1) {
+ if (reg_off_linkhdr == -1) {
/*
* We haven't yet assigned a register for the length
* of the radio header; allocate one.
*/
- reg_off_ll = alloc_reg();
+ reg_off_linkhdr = alloc_reg();
}
/*
* into the X register.
*/
s = new_stmt(BPF_LDX|BPF_MEM);
- s->s.k = reg_off_ll;
+ s->s.k = reg_off_linkhdr;
return s;
}
{
struct slist *s;
- if (reg_off_ll == -1) {
+ if (reg_off_linkhdr == -1) {
/*
* We haven't yet assigned a register for the length
* of the AVS header; allocate one.
*/
- reg_off_ll = alloc_reg();
+ reg_off_linkhdr = alloc_reg();
}
/*
* into the X register.
*/
s = new_stmt(BPF_LDX|BPF_MEM);
- s->s.k = reg_off_ll;
+ s->s.k = reg_off_linkhdr;
return s;
}
{
struct slist *s;
- if (reg_off_ll == -1) {
+ if (reg_off_linkhdr == -1) {
/*
* We haven't yet assigned a register for the length
* of the radiotap header; allocate one.
*/
- reg_off_ll = alloc_reg();
+ reg_off_linkhdr = alloc_reg();
}
/*
* into the X register.
*/
s = new_stmt(BPF_LDX|BPF_MEM);
- s->s.k = reg_off_ll;
+ s->s.k = reg_off_linkhdr;
return s;
}
{
struct slist *s;
- if (reg_off_ll == -1) {
+ if (reg_off_linkhdr == -1) {
/*
* We haven't yet assigned a register for the length
* of the radiotap header; allocate one.
*/
- reg_off_ll = alloc_reg();
+ reg_off_linkhdr = alloc_reg();
}
/*
* into the X register.
*/
s = new_stmt(BPF_LDX|BPF_MEM);
- s->s.k = reg_off_ll;
+ s->s.k = reg_off_linkhdr;
return s;
}
}
/*
- * Generate code to compute the outer link-layer header length, if necessary,
+ * Generate code to compute the previous link-layer header length, if necessary,
* putting it into the X register, and to return either a pointer to a
* "struct slist" for the list of statements in that code, or NULL if
* no code is necessary.
*/
static struct slist *
-gen_outerllprefixlen(void)
+gen_prevlinkhdrprefixlen(void)
{
- switch (outerlinktype) {
+ switch (prevlinktype) {
case DLT_PRISM_HEADER:
return gen_prism_llprefixlen();
* for that encapsulation).
*/
static struct block *
-gen_outerll_check(void)
+gen_prevlinkhdr_check(void)
{
struct block *b0;
- switch (outerlinktype) {
+ switch (prevlinktype) {
case DLT_SUNATM:
/*
*
* (We've already generated a test for LANE.)
*/
- b0 = gen_cmp(OR_OUTERLINK, SUNATM_PKT_BEGIN_POS, BPF_H, 0xFF00);
+ b0 = gen_cmp(OR_PREVLINKHDR, SUNATM_PKT_BEGIN_POS, BPF_H, 0xFF00);
gen_not(b0);
return b0;
case DLT_EN10MB:
case DLT_NETANALYZER:
case DLT_NETANALYZER_TRANSPARENT:
- b0 = gen_outerll_check();
+ b0 = gen_prevlinkhdr_check();
b1 = gen_ether_linktype(proto);
if (b0 != NULL)
gen_and(b0, b1);
/* fall through */
default:
- return gen_cmp(OR_LINK, off_linktype, BPF_H,
+ return gen_cmp(OR_LINKHDR, off_linktype, BPF_H,
(bpf_int32)proto);
/*NOTREACHED*/
break;
case ETHERTYPE_IP:
/* Check for a version number of 4. */
- return gen_mcmp(OR_LINK, 0, BPF_B, 0x40, 0xF0);
+ return gen_mcmp(OR_LINKHDR, 0, BPF_B, 0x40, 0xF0);
case ETHERTYPE_IPV6:
/* Check for a version number of 6. */
- return gen_mcmp(OR_LINK, 0, BPF_B, 0x60, 0xF0);
+ return gen_mcmp(OR_LINKHDR, 0, BPF_B, 0x60, 0xF0);
default:
return gen_false(); /* always false */
* map them to the corresponding PPP protocol types.
*/
proto = ethertype_to_ppptype(proto);
- return gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
+ return gen_cmp(OR_LINKHDR, off_linktype, BPF_H, (bpf_int32)proto);
/*NOTREACHED*/
break;
* Also check for Van Jacobson-compressed IP.
* XXX - do this for other forms of PPP?
*/
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_IP);
- b1 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_VJC);
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_H, PPP_IP);
+ b1 = gen_cmp(OR_LINKHDR, off_linktype, BPF_H, PPP_VJC);
gen_or(b0, b1);
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_VJNC);
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_H, PPP_VJNC);
gen_or(b1, b0);
return b0;
default:
proto = ethertype_to_ppptype(proto);
- return gen_cmp(OR_LINK, off_linktype, BPF_H,
+ return gen_cmp(OR_LINKHDR, off_linktype, BPF_H,
(bpf_int32)proto);
}
/*NOTREACHED*/
proto = SWAPLONG(proto);
proto = htonl(proto);
}
- return (gen_cmp(OR_LINK, 0, BPF_W, (bpf_int32)proto));
+ return (gen_cmp(OR_LINKHDR, 0, BPF_W, (bpf_int32)proto));
#ifdef HAVE_NET_PFVAR_H
case DLT_PFLOG:
* the packet.
*/
if (proto == ETHERTYPE_IP)
- return (gen_cmp(OR_LINK, offsetof(struct pfloghdr, af),
+ return (gen_cmp(OR_LINKHDR, offsetof(struct pfloghdr, af),
BPF_B, (bpf_int32)AF_INET));
else if (proto == ETHERTYPE_IPV6)
- return (gen_cmp(OR_LINK, offsetof(struct pfloghdr, af),
+ return (gen_cmp(OR_LINKHDR, offsetof(struct pfloghdr, af),
BPF_B, (bpf_int32)AF_INET6));
else
return gen_false();
return gen_false();
case ETHERTYPE_IPV6:
- return (gen_cmp(OR_LINK, off_linktype, BPF_B,
+ return (gen_cmp(OR_LINKHDR, off_linktype, BPF_B,
(bpf_int32)ARCTYPE_INET6));
case ETHERTYPE_IP:
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_B,
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_B,
(bpf_int32)ARCTYPE_IP);
- b1 = gen_cmp(OR_LINK, off_linktype, BPF_B,
+ b1 = gen_cmp(OR_LINKHDR, off_linktype, BPF_B,
(bpf_int32)ARCTYPE_IP_OLD);
gen_or(b0, b1);
return (b1);
case ETHERTYPE_ARP:
- b0 = gen_cmp(OR_LINK, off_linktype, BPF_B,
+ b0 = gen_cmp(OR_LINKHDR, off_linktype, BPF_B,
(bpf_int32)ARCTYPE_ARP);
- b1 = gen_cmp(OR_LINK, off_linktype, BPF_B,
+ b1 = gen_cmp(OR_LINKHDR, off_linktype, BPF_B,
(bpf_int32)ARCTYPE_ARP_OLD);
gen_or(b0, b1);
return (b1);
case ETHERTYPE_REVARP:
- return (gen_cmp(OR_LINK, off_linktype, BPF_B,
+ return (gen_cmp(OR_LINKHDR, off_linktype, BPF_B,
(bpf_int32)ARCTYPE_REVARP));
case ETHERTYPE_ATALK:
- return (gen_cmp(OR_LINK, off_linktype, BPF_B,
+ return (gen_cmp(OR_LINKHDR, off_linktype, BPF_B,
(bpf_int32)ARCTYPE_ATALK));
}
/*NOTREACHED*/
/*
* Check for the special NLPID for IP.
*/
- return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | 0xcc);
+ return gen_cmp(OR_LINKHDR, 2, BPF_H, (0x03<<8) | 0xcc);
case ETHERTYPE_IPV6:
/*
* Check for the special NLPID for IPv6.
*/
- return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | 0x8e);
+ return gen_cmp(OR_LINKHDR, 2, BPF_H, (0x03<<8) | 0x8e);
case LLCSAP_ISONS:
/*
* control field of UI, i.e. 0x03 followed
* by the NLPID.
*/
- b0 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO8473_CLNP);
- b1 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO9542_ESIS);
- b2 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO10589_ISIS);
+ b0 = gen_cmp(OR_LINKHDR, 2, BPF_H, (0x03<<8) | ISO8473_CLNP);
+ b1 = gen_cmp(OR_LINKHDR, 2, BPF_H, (0x03<<8) | ISO9542_ESIS);
+ b2 = gen_cmp(OR_LINKHDR, 2, BPF_H, (0x03<<8) | ISO10589_ISIS);
gen_or(b1, b2);
gen_or(b0, b2);
return b2;
*
* FIXME encapsulation specific BPF_ filters
*/
- return gen_mcmp(OR_LINK, 0, BPF_W, 0x4d474300, 0xffffff00); /* compare the magic number */
+ return gen_mcmp(OR_LINKHDR, 0, BPF_W, 0x4d474300, 0xffffff00); /* compare the magic number */
case DLT_BACNET_MS_TP:
- return gen_mcmp(OR_LINK, 0, BPF_W, 0x55FF0000, 0xffff0000);
+ return gen_mcmp(OR_LINKHDR, 0, BPF_W, 0x55FF0000, 0xffff0000);
case DLT_IPNET:
return gen_ipnet_linktype(proto);
* it's not, it needs to be handled specially
* above.)
*/
- return gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
+ return gen_cmp(OR_LINKHDR, off_linktype, BPF_H, (bpf_int32)proto);
} else {
/*
* No; report an error.
* We check for an Ethernet type field less than
* 1500, which means it's an 802.3 length field.
*/
- b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
+ b0 = gen_cmp_gt(OR_LINKHDR, off_linktype, BPF_H, ETHERMTU);
gen_not(b0);
/*
switch (dir) {
case Q_SRC:
- return gen_bcmp(OR_LINK, 6, 6, eaddr);
+ return gen_bcmp(OR_LINKHDR, 6, 6, eaddr);
case Q_DST:
- return gen_bcmp(OR_LINK, 0, 6, eaddr);
+ return gen_bcmp(OR_LINKHDR, 0, 6, eaddr);
case Q_AND:
b0 = gen_ehostop(eaddr, Q_SRC);
switch (dir) {
case Q_SRC:
- return gen_bcmp(OR_LINK, 6 + 1 + pcap_fddipad, 6, eaddr);
+ return gen_bcmp(OR_LINKHDR, 6 + 1 + pcap_fddipad, 6, eaddr);
case Q_DST:
- return gen_bcmp(OR_LINK, 0 + 1 + pcap_fddipad, 6, eaddr);
+ return gen_bcmp(OR_LINKHDR, 0 + 1 + pcap_fddipad, 6, eaddr);
case Q_AND:
b0 = gen_fhostop(eaddr, Q_SRC);
switch (dir) {
case Q_SRC:
- return gen_bcmp(OR_LINK, 8, 6, eaddr);
+ return gen_bcmp(OR_LINKHDR, 8, 6, eaddr);
case Q_DST:
- return gen_bcmp(OR_LINK, 2, 6, eaddr);
+ return gen_bcmp(OR_LINKHDR, 2, 6, eaddr);
case Q_AND:
b0 = gen_thostop(eaddr, Q_SRC);
*
* First, check for To DS set, i.e. check "link[1] & 0x01".
*/
- s = gen_load_a(OR_LINK, 1, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 1, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x01; /* To DS */
b1->stmts = s;
/*
* If To DS is set, the SA is at 24.
*/
- b0 = gen_bcmp(OR_LINK, 24, 6, eaddr);
+ b0 = gen_bcmp(OR_LINKHDR, 24, 6, eaddr);
gen_and(b1, b0);
/*
* Now, check for To DS not set, i.e. check
* "!(link[1] & 0x01)".
*/
- s = gen_load_a(OR_LINK, 1, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 1, BPF_B);
b2 = new_block(JMP(BPF_JSET));
b2->s.k = 0x01; /* To DS */
b2->stmts = s;
/*
* If To DS is not set, the SA is at 16.
*/
- b1 = gen_bcmp(OR_LINK, 16, 6, eaddr);
+ b1 = gen_bcmp(OR_LINKHDR, 16, 6, eaddr);
gen_and(b2, b1);
/*
* Now check for From DS being set, and AND that with
* the ORed-together checks.
*/
- s = gen_load_a(OR_LINK, 1, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 1, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x02; /* From DS */
b1->stmts = s;
/*
* Now check for data frames with From DS not set.
*/
- s = gen_load_a(OR_LINK, 1, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 1, BPF_B);
b2 = new_block(JMP(BPF_JSET));
b2->s.k = 0x02; /* From DS */
b2->stmts = s;
/*
* If From DS isn't set, the SA is at 10.
*/
- b1 = gen_bcmp(OR_LINK, 10, 6, eaddr);
+ b1 = gen_bcmp(OR_LINKHDR, 10, 6, eaddr);
gen_and(b2, b1);
/*
* Now check for a data frame.
* I.e, check "link[0] & 0x08".
*/
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x08;
b1->stmts = s;
* is a management frame.
* I.e, check "!(link[0] & 0x08)".
*/
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b2 = new_block(JMP(BPF_JSET));
b2->s.k = 0x08;
b2->stmts = s;
/*
* For management frames, the SA is at 10.
*/
- b1 = gen_bcmp(OR_LINK, 10, 6, eaddr);
+ b1 = gen_bcmp(OR_LINKHDR, 10, 6, eaddr);
gen_and(b2, b1);
/*
*
* I.e., check "!(link[0] & 0x04)".
*/
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x04;
b1->stmts = s;
*
* First, check for To DS set, i.e. "link[1] & 0x01".
*/
- s = gen_load_a(OR_LINK, 1, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 1, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x01; /* To DS */
b1->stmts = s;
/*
* If To DS is set, the DA is at 16.
*/
- b0 = gen_bcmp(OR_LINK, 16, 6, eaddr);
+ b0 = gen_bcmp(OR_LINKHDR, 16, 6, eaddr);
gen_and(b1, b0);
/*
* Now, check for To DS not set, i.e. check
* "!(link[1] & 0x01)".
*/
- s = gen_load_a(OR_LINK, 1, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 1, BPF_B);
b2 = new_block(JMP(BPF_JSET));
b2->s.k = 0x01; /* To DS */
b2->stmts = s;
/*
* If To DS is not set, the DA is at 4.
*/
- b1 = gen_bcmp(OR_LINK, 4, 6, eaddr);
+ b1 = gen_bcmp(OR_LINKHDR, 4, 6, eaddr);
gen_and(b2, b1);
/*
* Now check for a data frame.
* I.e, check "link[0] & 0x08".
*/
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x08;
b1->stmts = s;
* is a management frame.
* I.e, check "!(link[0] & 0x08)".
*/
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b2 = new_block(JMP(BPF_JSET));
b2->s.k = 0x08;
b2->stmts = s;
/*
* For management frames, the DA is at 4.
*/
- b1 = gen_bcmp(OR_LINK, 4, 6, eaddr);
+ b1 = gen_bcmp(OR_LINKHDR, 4, 6, eaddr);
gen_and(b2, b1);
/*
*
* I.e., check "!(link[0] & 0x04)".
*/
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x04;
b1->stmts = s;
* is a management frame.
* I.e, check "(link[0] & 0x08)".
*/
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x08;
b1->stmts = s;
/*
* Check addr1.
*/
- b0 = gen_bcmp(OR_LINK, 4, 6, eaddr);
+ b0 = gen_bcmp(OR_LINKHDR, 4, 6, eaddr);
/*
* AND that with the check of addr1.
/*
* Not present in CTS or ACK control frames.
*/
- b0 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,
+ b0 = gen_mcmp(OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,
IEEE80211_FC0_TYPE_MASK);
gen_not(b0);
- b1 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_SUBTYPE_CTS,
+ b1 = gen_mcmp(OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_SUBTYPE_CTS,
IEEE80211_FC0_SUBTYPE_MASK);
gen_not(b1);
- b2 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_SUBTYPE_ACK,
+ b2 = gen_mcmp(OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_SUBTYPE_ACK,
IEEE80211_FC0_SUBTYPE_MASK);
gen_not(b2);
gen_and(b1, b2);
* is a management frame.
* I.e, check "(link[0] & 0x08)".
*/
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x08;
b1->stmts = s;
/*
* Check addr2.
*/
- b1 = gen_bcmp(OR_LINK, 10, 6, eaddr);
+ b1 = gen_bcmp(OR_LINKHDR, 10, 6, eaddr);
gen_and(b2, b1);
return b1;
* XXX - add BSSID keyword?
*/
case Q_ADDR1:
- return (gen_bcmp(OR_LINK, 4, 6, eaddr));
+ return (gen_bcmp(OR_LINKHDR, 4, 6, eaddr));
case Q_ADDR2:
/*
* Not present in CTS or ACK control frames.
*/
- b0 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,
+ b0 = gen_mcmp(OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,
IEEE80211_FC0_TYPE_MASK);
gen_not(b0);
- b1 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_SUBTYPE_CTS,
+ b1 = gen_mcmp(OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_SUBTYPE_CTS,
IEEE80211_FC0_SUBTYPE_MASK);
gen_not(b1);
- b2 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_SUBTYPE_ACK,
+ b2 = gen_mcmp(OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_SUBTYPE_ACK,
IEEE80211_FC0_SUBTYPE_MASK);
gen_not(b2);
gen_and(b1, b2);
gen_or(b0, b2);
- b1 = gen_bcmp(OR_LINK, 10, 6, eaddr);
+ b1 = gen_bcmp(OR_LINKHDR, 10, 6, eaddr);
gen_and(b2, b1);
return b1;
/*
* Not present in control frames.
*/
- b0 = gen_mcmp(OR_LINK, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,
+ b0 = gen_mcmp(OR_LINKHDR, 0, BPF_B, IEEE80211_FC0_TYPE_CTL,
IEEE80211_FC0_TYPE_MASK);
gen_not(b0);
- b1 = gen_bcmp(OR_LINK, 16, 6, eaddr);
+ b1 = gen_bcmp(OR_LINKHDR, 16, 6, eaddr);
gen_and(b0, b1);
return b1;
* frames should have both of those set, so we don't
* check the frame type.
*/
- b0 = gen_mcmp(OR_LINK, 1, BPF_B,
+ b0 = gen_mcmp(OR_LINKHDR, 1, BPF_B,
IEEE80211_FC1_DIR_DSTODS, IEEE80211_FC1_DIR_MASK);
- b1 = gen_bcmp(OR_LINK, 24, 6, eaddr);
+ b1 = gen_bcmp(OR_LINKHDR, 24, 6, eaddr);
gen_and(b0, b1);
return b1;
switch (dir) {
case Q_SRC:
- return gen_bcmp(OR_LINK, 10, 6, eaddr);
+ return gen_bcmp(OR_LINKHDR, 10, 6, eaddr);
case Q_DST:
- return gen_bcmp(OR_LINK, 2, 6, eaddr);
+ return gen_bcmp(OR_LINKHDR, 2, 6, eaddr);
case Q_AND:
b0 = gen_ipfchostop(eaddr, Q_SRC);
case DLT_EN10MB:
case DLT_NETANALYZER:
case DLT_NETANALYZER_TRANSPARENT:
- b1 = gen_outerll_check();
+ b1 = gen_prevlinkhdr_check();
b0 = gen_ehostop(eaddr, Q_OR);
if (b1 != NULL)
gen_and(b1, b0);
* A data frame has the 0x08 bit (b3) in the frame control field set
* and the 0x04 bit (b2) clear.
*/
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b0 = new_block(JMP(BPF_JSET));
b0->s.k = 0x08;
b0->stmts = s;
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x04;
b1->stmts = s;
*
* XXX - what about SNAP-encapsulated frames?
*/
- return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | v);
+ return gen_cmp(OR_LINKHDR, 2, BPF_H, (0x03<<8) | v);
/*NOTREACHED*/
break;
if (eaddr == NULL)
bpf_error(
"unknown ether host '%s'", name);
- tmp = gen_outerll_check();
+ tmp = gen_prevlinkhdr_check();
b = gen_ehostop(eaddr, dir);
if (tmp != NULL)
gen_and(tmp, b);
case DLT_EN10MB:
case DLT_NETANALYZER:
case DLT_NETANALYZER_TRANSPARENT:
- tmp = gen_outerll_check();
+ tmp = gen_prevlinkhdr_check();
b = gen_ehostop(eaddr, (int)q.dir);
if (tmp != NULL)
gen_and(tmp, b);
* into the X register and then added to the index).
*/
tmp = new_stmt(BPF_LD|BPF_IND|size);
- tmp->s.k = off_ll;
+ tmp->s.k = off_linkhdr;
sappend(s, tmp);
sappend(inst->s, s);
break;
abort();
case '=':
- return gen_cmp(OR_LINK, (u_int)idx, BPF_B, (bpf_int32)val);
+ return gen_cmp(OR_LINKHDR, (u_int)idx, BPF_B, (bpf_int32)val);
case '<':
- b = gen_cmp_lt(OR_LINK, (u_int)idx, BPF_B, (bpf_int32)val);
+ b = gen_cmp_lt(OR_LINKHDR, (u_int)idx, BPF_B, (bpf_int32)val);
return b;
case '>':
- b = gen_cmp_gt(OR_LINK, (u_int)idx, BPF_B, (bpf_int32)val);
+ b = gen_cmp_gt(OR_LINKHDR, (u_int)idx, BPF_B, (bpf_int32)val);
return b;
case '|':
case DLT_EN10MB:
case DLT_NETANALYZER:
case DLT_NETANALYZER_TRANSPARENT:
- b1 = gen_outerll_check();
+ b1 = gen_prevlinkhdr_check();
b0 = gen_ehostop(ebroadcast, Q_DST);
if (b1 != NULL)
gen_and(b1, b0);
register struct slist *s;
/* link[offset] & 1 != 0 */
- s = gen_load_a(OR_LINK, offset, BPF_B);
+ s = gen_load_a(OR_LINKHDR, offset, BPF_B);
b0 = new_block(JMP(BPF_JSET));
b0->s.k = 1;
b0->stmts = s;
case DLT_EN10MB:
case DLT_NETANALYZER:
case DLT_NETANALYZER_TRANSPARENT:
- b1 = gen_outerll_check();
+ b1 = gen_prevlinkhdr_check();
/* ether[0] & 1 != 0 */
b0 = gen_mac_multicast(0);
if (b1 != NULL)
*
* First, check for To DS set, i.e. "link[1] & 0x01".
*/
- s = gen_load_a(OR_LINK, 1, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 1, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x01; /* To DS */
b1->stmts = s;
* Now, check for To DS not set, i.e. check
* "!(link[1] & 0x01)".
*/
- s = gen_load_a(OR_LINK, 1, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 1, BPF_B);
b2 = new_block(JMP(BPF_JSET));
b2->s.k = 0x01; /* To DS */
b2->stmts = s;
* Now check for a data frame.
* I.e, check "link[0] & 0x08".
*/
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x08;
b1->stmts = s;
* is a management frame.
* I.e, check "!(link[0] & 0x08)".
*/
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b2 = new_block(JMP(BPF_JSET));
b2->s.k = 0x08;
b2->stmts = s;
*
* I.e., check "!(link[0] & 0x04)".
*/
- s = gen_load_a(OR_LINK, 0, BPF_B);
+ s = gen_load_a(OR_LINKHDR, 0, BPF_B);
b1 = new_block(JMP(BPF_JSET));
b1->s.k = 0x04;
b1->stmts = s;
case DLT_IPNET:
if (dir) {
/* match outgoing packets */
- b0 = gen_cmp(OR_LINK, 2, BPF_H, IPNET_OUTBOUND);
+ b0 = gen_cmp(OR_LINKHDR, 2, BPF_H, IPNET_OUTBOUND);
} else {
/* match incoming packets */
- b0 = gen_cmp(OR_LINK, 2, BPF_H, IPNET_INBOUND);
+ b0 = gen_cmp(OR_LINKHDR, 2, BPF_H, IPNET_INBOUND);
}
break;
case DLT_LINUX_SLL:
/* match outgoing packets */
- b0 = gen_cmp(OR_LINK, 0, BPF_H, LINUX_SLL_OUTGOING);
+ b0 = gen_cmp(OR_LINKHDR, 0, BPF_H, LINUX_SLL_OUTGOING);
if (!dir) {
/* to filter on inbound traffic, invert the match */
gen_not(b0);
#ifdef HAVE_NET_PFVAR_H
case DLT_PFLOG:
- b0 = gen_cmp(OR_LINK, offsetof(struct pfloghdr, dir), BPF_B,
+ b0 = gen_cmp(OR_LINKHDR, offsetof(struct pfloghdr, dir), BPF_B,
(bpf_int32)((dir == 0) ? PF_IN : PF_OUT));
break;
#endif
case DLT_PPP_PPPD:
if (dir) {
/* match outgoing packets */
- b0 = gen_cmp(OR_LINK, 0, BPF_B, PPP_PPPD_OUT);
+ b0 = gen_cmp(OR_LINKHDR, 0, BPF_B, PPP_PPPD_OUT);
} else {
/* match incoming packets */
- b0 = gen_cmp(OR_LINK, 0, BPF_B, PPP_PPPD_IN);
+ b0 = gen_cmp(OR_LINKHDR, 0, BPF_B, PPP_PPPD_IN);
}
break;
* the byte after the 3-byte magic number */
if (dir) {
/* match outgoing packets */
- b0 = gen_mcmp(OR_LINK, 3, BPF_B, 0, 0x01);
+ b0 = gen_mcmp(OR_LINKHDR, 3, BPF_B, 0, 0x01);
} else {
/* match incoming packets */
- b0 = gen_mcmp(OR_LINK, 3, BPF_B, 1, 0x01);
+ b0 = gen_mcmp(OR_LINKHDR, 3, BPF_B, 1, 0x01);
}
break;
/* NOTREACHED */
}
/* match outgoing packets */
- b0 = gen_cmp(OR_LINK, SKF_AD_OFF + SKF_AD_PKTTYPE, BPF_H,
+ b0 = gen_cmp(OR_LINKHDR, SKF_AD_OFF + SKF_AD_PKTTYPE, BPF_H,
PACKET_OUTGOING);
if (!dir) {
/* to filter on inbound traffic, invert the match */
len-1);
/* NOTREACHED */
}
- b0 = gen_bcmp(OR_LINK, off, strlen(ifname), (const u_char *)ifname);
+ b0 = gen_bcmp(OR_LINKHDR, off, strlen(ifname), (const u_char *)ifname);
return (b0);
}
/* NOTREACHED */
}
- b0 = gen_bcmp(OR_LINK, offsetof(struct pfloghdr, ruleset),
+ b0 = gen_bcmp(OR_LINKHDR, offsetof(struct pfloghdr, ruleset),
strlen(ruleset), (const u_char *)ruleset);
return (b0);
}
/* NOTREACHED */
}
- b0 = gen_cmp(OR_LINK, offsetof(struct pfloghdr, rulenr), BPF_W,
+ b0 = gen_cmp(OR_LINKHDR, offsetof(struct pfloghdr, rulenr), BPF_W,
(bpf_int32)rnr);
return (b0);
}
/* NOTREACHED */
}
- b0 = gen_cmp(OR_LINK, offsetof(struct pfloghdr, subrulenr), BPF_W,
+ b0 = gen_cmp(OR_LINKHDR, offsetof(struct pfloghdr, subrulenr), BPF_W,
(bpf_int32)srnr);
return (b0);
}
/* NOTREACHED */
}
- b0 = gen_cmp(OR_LINK, offsetof(struct pfloghdr, reason), BPF_B,
+ b0 = gen_cmp(OR_LINKHDR, offsetof(struct pfloghdr, reason), BPF_B,
(bpf_int32)reason);
return (b0);
}
/* NOTREACHED */
}
- b0 = gen_cmp(OR_LINK, offsetof(struct pfloghdr, action), BPF_B,
+ b0 = gen_cmp(OR_LINKHDR, offsetof(struct pfloghdr, action), BPF_B,
(bpf_int32)action);
return (b0);
}
case DLT_PRISM_HEADER:
case DLT_IEEE802_11_RADIO_AVS:
case DLT_IEEE802_11_RADIO:
- b0 = gen_mcmp(OR_LINK, 0, BPF_B, (bpf_int32)type,
+ b0 = gen_mcmp(OR_LINKHDR, 0, BPF_B, (bpf_int32)type,
(bpf_int32)mask);
break;
/* NOTREACHED */
}
- b0 = gen_mcmp(OR_LINK, 1, BPF_B, (bpf_int32)fcdir,
+ b0 = gen_mcmp(OR_LINKHDR, 1, BPF_B, (bpf_int32)fcdir,
(bpf_u_int32)IEEE80211_FC1_DIR_MASK);
return (b0);
switch (dir) {
/* src comes first, different from Ethernet */
case Q_SRC:
- return gen_bcmp(OR_LINK, 0, 1, eaddr);
+ return gen_bcmp(OR_LINKHDR, 0, 1, eaddr);
case Q_DST:
- return gen_bcmp(OR_LINK, 1, 1, eaddr);
+ return gen_bcmp(OR_LINKHDR, 1, 1, eaddr);
case Q_AND:
b0 = gen_ahostop(eaddr, Q_SRC);
/* If a specific VLAN is requested, check VLAN id */
if (vlan_num >= 0) {
- b1 = gen_mcmp(OR_LINKPL, 0, BPF_H,
+ b1 = gen_mcmp(OR_LINKHDR, 0, BPF_H,
(bpf_int32)vlan_num, 0x0fff);
gen_and(b0, b1);
b0 = b1;
/* If a specific session is requested, check PPPoE session id */
if (sess_num >= 0) {
- b1 = gen_mcmp(OR_LINKPL, off_nl, BPF_W,
+ b1 = gen_mcmp(OR_LINKHDR, off_nl, BPF_W,
(bpf_int32)sess_num, 0x0000ffff);
gen_and(b0, b1);
b0 = b1;
* it's 6 bytes past off_nl.
*/
linktype = DLT_PPP;
- off_ll = off_linkpl_constant_part + off_nl + 6; /* 6 bytes past the PPPoE header */
+ off_linkhdr = off_linkpl_constant_part + off_nl + 6; /* 6 bytes past the PPPoE header */
off_linktype = 0;
- off_linkpl_constant_part = off_ll + 2;
+ off_linkpl_constant_part = off_linkhdr + 2;
off_nl = 0;
off_nl_nosnap = 0; /* no 802.2 LLC */
bpf_error("'vpi' supported only on raw ATM");
if (off_vpi == (u_int)-1)
abort();
- b0 = gen_ncmp(OR_LINK, off_vpi, BPF_B, 0xffffffff, jtype,
+ b0 = gen_ncmp(OR_LINKHDR, off_vpi, BPF_B, 0xffffffff, jtype,
reverse, jvalue);
break;
bpf_error("'vci' supported only on raw ATM");
if (off_vci == (u_int)-1)
abort();
- b0 = gen_ncmp(OR_LINK, off_vci, BPF_H, 0xffffffff, jtype,
+ b0 = gen_ncmp(OR_LINKHDR, off_vci, BPF_H, 0xffffffff, jtype,
reverse, jvalue);
break;
case A_PROTOTYPE:
if (off_proto == (u_int)-1)
abort(); /* XXX - this isn't on FreeBSD */
- b0 = gen_ncmp(OR_LINK, off_proto, BPF_B, 0x0f, jtype,
+ b0 = gen_ncmp(OR_LINKHDR, off_proto, BPF_B, 0x0f, jtype,
reverse, jvalue);
break;
case A_MSGTYPE:
if (off_payload == (u_int)-1)
abort();
- b0 = gen_ncmp(OR_LINK, off_payload + MSG_TYPE_POS, BPF_B,
+ b0 = gen_ncmp(OR_LINKHDR, off_payload + MSG_TYPE_POS, BPF_B,
0xffffffff, jtype, reverse, jvalue);
break;
bpf_error("'callref' supported only on raw ATM");
if (off_proto == (u_int)-1)
abort();
- b0 = gen_ncmp(OR_LINK, off_proto, BPF_B, 0xffffffff,
+ b0 = gen_ncmp(OR_LINKHDR, off_proto, BPF_B, 0xffffffff,
jtype, reverse, jvalue);
break;
* We assume LANE means Ethernet, not Token Ring.
*/
linktype = DLT_EN10MB;
- off_ll = off_payload + 2; /* Ethernet header */
+ off_linkhdr = off_payload + 2; /* Ethernet header */
off_linktype = 12;
- off_linkpl_constant_part = off_ll + 14; /* Ethernet */
+ off_linkpl_constant_part = off_linkhdr + 14; /* Ethernet */
off_nl = 0; /* Ethernet II */
off_nl_nosnap = 3; /* 802.3+802.2 */
break;
if (!is_atm)
bpf_error("'llc' supported only on raw ATM");
b1 = gen_atmfield_code(A_PROTOTYPE, PT_LLC, BPF_JEQ, 0);
- linktype = outerlinktype;
+ linktype = prevlinktype;
break;
default:
projects / libpcap / commitdiff
