Changeset 97c5f8e8 in rtems-libbsd


Ignore:
Timestamp:
Oct 9, 2017, 7:59:36 AM (22 months ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
5283630d2c9d40deb0183696d278e02644fe4326, bc2ba9a9cdc7381c2a4f2ae6ee303be636f31368
Children:
a53da0d
Parents:
67cbb9d
git-author:
Sebastian Huber <sebastian.huber@…> (10/09/17 07:59:36)
git-committer:
Sebastian Huber <sebastian.huber@…> (10/09/17 11:58:08)
Message:

Update libpcap to FreeBSD head 2017-04-04

Update libpcap from Git mirror commit
99a648a912e81e29d9c4c159cbbe263462f2d719 to
642b174daddbd0efd9bb5f242c43f4ab4db6869f.

Files:
9 added
39 edited
1 moved

Legend:

Unmodified
Added
Removed
  • Makefile.todo

    r67cbb9d r97c5f8e8  
    3838GENERATED += rtemsbsd/include/machine/rtems-bsd-regdomain.h
    3939GENERATED += rtemsbsd/rtems/rtems-bsd-regdomain.c
     40GENERATED += freebsd/contrib/libpcap/grammar.h
     41GENERATED += freebsd/contrib/libpcap/grammar.c
     42GENERATED += freebsd/contrib/libpcap/pcap_version.h
     43GENERATED += freebsd/contrib/libpcap/scanner.h
     44GENERATED += freebsd/contrib/libpcap/scanner.c
    4045
    4146all: $(GENERATED)
     
    199204        rtems-bin2c -C $< $@
    200205
     206freebsd/contrib/libpcap/grammar.h: freebsd/contrib/libpcap/grammar.c
     207
     208freebsd/contrib/libpcap/grammar.c: freebsd-org/contrib/libpcap/grammar.y
     209        cd freebsd-org/contrib/libpcap && yacc -p pcap_ -o grammar.c -d grammar.y
     210        mv freebsd-org/contrib/libpcap/grammar.h freebsd/contrib/libpcap/grammar.h
     211        mv freebsd-org/contrib/libpcap/grammar.c $@
     212
     213freebsd/contrib/libpcap/pcap_version.h: freebsd-org/contrib/libpcap/VERSION
     214        freebsd-org/contrib/libpcap/gen_version_header.sh $< freebsd-org/contrib/libpcap/pcap_version.h.in $@
     215
     216freebsd/contrib/libpcap/scanner.h: freebsd/contrib/libpcap/scanner.c
     217
     218freebsd/contrib/libpcap/scanner.c: freebsd-org/contrib/libpcap/scanner.l
     219        cd freebsd-org/contrib/libpcap && lex -P pcap_ --header-file=scanner.h --nounput -o scanner.c scanner.l
     220        mv freebsd-org/contrib/libpcap/scanner.h freebsd/contrib/libpcap/scanner.h
     221        mv freebsd-org/contrib/libpcap/scanner.c $@
     222
    201223clean:
    202224        rm $(GENERATED)
  • freebsd/contrib/libpcap/arcnet.h

    r67cbb9d r97c5f8e8  
    3131 * SUCH DAMAGE.
    3232 *
    33  * @(#) $Id: arcnet.h,v 1.2 2001-04-24 02:17:52 guy Exp $ (LBL)
    34  *
    3533 * from: NetBSD: if_arc.h,v 1.13 1999/11/19 20:41:19 thorpej Exp
    3634 */
  • freebsd/contrib/libpcap/atmuni31.h

    r67cbb9d r97c5f8e8  
    2929 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
    3030 * POSSIBILITY OF SUCH DAMAGE.
    31  *
    32  * @(#) $Header: /tcpdump/master/libpcap/atmuni31.h,v 1.3 2007-10-22 19:28:58 guy Exp $ (LBL)
    3331 */
    3432
  • freebsd/contrib/libpcap/bpf_image.c

    r67cbb9d r97c5f8e8  
    2222 */
    2323
    24 #ifndef lint
    25 static const char rcsid[] _U_ =
    26     "@(#) $Header: /tcpdump/master/libpcap/bpf_image.c,v 1.28 2008-01-02 04:16:46 guy Exp $ (LBL)";
    27 #endif
    28 
    2924#ifdef HAVE_CONFIG_H
    3025#include "config.h"
    3126#endif
    3227
    33 #ifdef WIN32
     28#ifdef _WIN32
    3429#include <pcap-stdinc.h>
    35 #else /* WIN32 */
     30#else /* _WIN32 */
    3631#if HAVE_INTTYPES_H
    3732#include <inttypes.h>
     
    4338#endif
    4439#include <sys/types.h>
    45 #endif /* WIN32 */
     40#endif /* _WIN32 */
    4641
    4742#include <stdio.h>
     
    5651char *
    5752bpf_image(p, n)
    58         struct bpf_insn *p;
     53        const struct bpf_insn *p;
    5954        int n;
    6055{
     
    219214                break;
    220215
     216        case BPF_ALU|BPF_MOD|BPF_X:
     217                op = "mod";
     218                fmt = "x";
     219                break;
     220
    221221        case BPF_ALU|BPF_AND|BPF_X:
    222222                op = "and";
     
    229229                break;
    230230
     231        case BPF_ALU|BPF_XOR|BPF_X:
     232                op = "xor";
     233                fmt = "x";
     234                break;
     235
    231236        case BPF_ALU|BPF_LSH|BPF_X:
    232237                op = "lsh";
     
    259264                break;
    260265
     266        case BPF_ALU|BPF_MOD|BPF_K:
     267                op = "mod";
     268                fmt = "#%d";
     269                break;
     270
    261271        case BPF_ALU|BPF_AND|BPF_K:
    262272                op = "and";
     
    266276        case BPF_ALU|BPF_OR|BPF_K:
    267277                op = "or";
     278                fmt = "#0x%x";
     279                break;
     280
     281        case BPF_ALU|BPF_XOR|BPF_K:
     282                op = "xor";
    268283                fmt = "#0x%x";
    269284                break;
     
    294309                break;
    295310        }
    296         (void)snprintf(operand, sizeof operand, fmt, v);
     311        (void)pcap_snprintf(operand, sizeof operand, fmt, v);
    297312        if (BPF_CLASS(p->code) == BPF_JMP && BPF_OP(p->code) != BPF_JA) {
    298                 (void)snprintf(image, sizeof image,
     313                (void)pcap_snprintf(image, sizeof image,
    299314                              "(%03d) %-8s %-16s jt %d\tjf %d",
    300315                              n, op, operand, n + 1 + p->jt, n + 1 + p->jf);
    301316        } else {
    302                 (void)snprintf(image, sizeof image,
     317                (void)pcap_snprintf(image, sizeof image,
    303318                              "(%03d) %-8s %s",
    304319                              n, op, operand);
  • freebsd/contrib/libpcap/etherent.c

    r67cbb9d r97c5f8e8  
    2222 */
    2323
    24 #ifndef lint
    25 static const char rcsid[] _U_ =
    26     "@(#) $Header: /tcpdump/master/libpcap/etherent.c,v 1.23 2006-10-04 18:09:22 guy Exp $ (LBL)";
    27 #endif
    28 
    2924#ifdef HAVE_CONFIG_H
    3025#include "config.h"
    3126#endif
    3227
    33 #ifdef WIN32
     28#ifdef _WIN32
    3429#include <pcap-stdinc.h>
    35 #else /* WIN32 */
     30#else /* _WIN32 */
    3631#if HAVE_INTTYPES_H
    3732#include <inttypes.h>
     
    4338#endif
    4439#include <sys/types.h>
    45 #endif /* WIN32 */
     40#endif /* _WIN32 */
    4641
    4742#include <ctype.h>
  • freebsd/contrib/libpcap/ethertype.h

    r67cbb9d r97c5f8e8  
    1818 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
    1919 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
    20  *
    21  * @(#) $Header: /tcpdump/master/libpcap/ethertype.h,v 1.14 2005-09-05 09:06:58 guy Exp $ (LBL)
    2220 */
    2321
     
    115113#define ETHERTYPE_PPPOES        0x8864
    116114#endif
     115#ifndef ETHERTYPE_8021AD
     116#define ETHERTYPE_8021AD        0x88a8
     117#endif
    117118#ifndef ETHERTYPE_LOOPBACK
    118119#define ETHERTYPE_LOOPBACK      0x9000
  • freebsd/contrib/libpcap/fad-getad.c

    r67cbb9d r97c5f8e8  
    3535 */
    3636
    37 #ifndef lint
    38 static const char rcsid[] _U_ =
    39     "@(#) $Header: /tcpdump/master/libpcap/fad-getad.c,v 1.12 2007-09-14 00:44:55 guy Exp $ (LBL)";
    40 #endif
    41 
    4237#ifdef HAVE_CONFIG_H
    4338#include "config.h"
     
    6358#endif
    6459
    65 #ifdef AF_PACKET
     60/*
     61 * We don't do this on Solaris 11 and later, as it appears there aren't
     62 * any AF_PACKET addresses on interfaces, so we don't need this, and
     63 * we end up including both the OS's <net/bpf.h> and our <pcap/bpf.h>,
     64 * and their definitions of some data structures collide.
     65 */
     66#if (defined(linux) || defined(__Lynx__)) && defined(AF_PACKET)
    6667# ifdef HAVE_NETPACKET_PACKET_H
    67 /* Solaris 11 and later, Linux distributions with newer glibc */
     68/* Linux distributions with newer glibc */
    6869#  include <netpacket/packet.h>
    6970# else /* HAVE_NETPACKET_PACKET_H */
     
    7879# endif /* __Lynx__ */
    7980# endif /* HAVE_NETPACKET_PACKET_H */
    80 #endif /* AF_PACKET */
     81#endif /* (defined(linux) || defined(__Lynx__)) && defined(AF_PACKET) */
    8182
    8283/*
     
    123124#endif
    124125
    125 #ifdef AF_PACKET
     126#if (defined(linux) || defined(__Lynx__)) && defined(AF_PACKET)
    126127        case AF_PACKET:
    127128                return (sizeof (struct sockaddr_ll));
     
    143144 * Returns -1 on error, 0 otherwise.
    144145 * The list, as returned through "alldevsp", may be null if no interfaces
    145  * were up and could be opened.
     146 * could be opened.
    146147 */
    147148int
    148 pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf)
     149pcap_findalldevs_interfaces(pcap_if_t **alldevsp, char *errbuf,
     150    int (*check_usable)(const char *))
    149151{
    150152        pcap_if_t *devlist = NULL;
     
    159161         *
    160162         * Note: this won't return information about interfaces
    161          * with no addresses; are there any such interfaces
    162          * that would be capable of receiving packets?
    163          * (Interfaces incapable of receiving packets aren't
    164          * very interesting from libpcap's point of view.)
     163         * with no addresses, so, if a platform has interfaces
     164         * with no interfaces on which traffic can be captured,
     165         * we must check for those interfaces as well (see, for
     166         * example, what's done on Linux).
    165167         *
    166168         * LAN interfaces will probably have link-layer
     
    170172         */
    171173        if (getifaddrs(&ifap) != 0) {
    172                 (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
     174                (void)pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
    173175                    "getifaddrs: %s", pcap_strerror(errno));
    174176                return (-1);
    175177        }
    176178        for (ifa = ifap; ifa != NULL; ifa = ifa->ifa_next) {
    177                 /*
    178                  * Is this interface up?
    179                  */
    180                 if (!(ifa->ifa_flags & IFF_UP)) {
    181                         /*
    182                          * No, so don't add it to the list.
    183                          */
    184                         continue;
    185                 }
    186 
    187                 /*
    188                  * "ifa_addr" was apparently null on at least one
    189                  * interface on some system.
    190                  *
    191                  * "ifa_broadaddr" may be non-null even on
    192                  * non-broadcast interfaces, and was null on
    193                  * at least one OpenBSD 3.4 system on at least
    194                  * one interface with IFF_BROADCAST set.
    195                  *
    196                  * "ifa_dstaddr" was, on at least one FreeBSD 4.1
    197                  * system, non-null on a non-point-to-point
    198                  * interface.
    199                  *
    200                  * Therefore, we supply the address and netmask only
    201                  * if "ifa_addr" is non-null (if there's no address,
    202                  * there's obviously no netmask), and supply the
    203                  * broadcast and destination addresses if the appropriate
    204                  * flag is set *and* the appropriate "ifa_" entry doesn't
    205                  * evaluate to a null pointer.
    206                  */
    207                 if (ifa->ifa_addr != NULL) {
    208                         addr = ifa->ifa_addr;
    209                         addr_size = SA_LEN(addr);
    210                         netmask = ifa->ifa_netmask;
    211                 } else {
    212                         addr = NULL;
    213                         addr_size = 0;
    214                         netmask = NULL;
    215                 }
    216                 if (ifa->ifa_flags & IFF_BROADCAST &&
    217                     ifa->ifa_broadaddr != NULL) {
    218                         broadaddr = ifa->ifa_broadaddr;
    219                         broadaddr_size = SA_LEN(broadaddr);
    220                 } else {
    221                         broadaddr = NULL;
    222                         broadaddr_size = 0;
    223                 }
    224                 if (ifa->ifa_flags & IFF_POINTOPOINT &&
    225                     ifa->ifa_dstaddr != NULL) {
    226                         dstaddr = ifa->ifa_dstaddr;
    227                         dstaddr_size = SA_LEN(ifa->ifa_dstaddr);
    228                 } else {
    229                         dstaddr = NULL;
    230                         dstaddr_size = 0;
    231                 }
    232 
    233179                /*
    234180                 * If this entry has a colon followed by a number at
     
    261207
    262208                /*
     209                 * Can we capture on this device?
     210                 */
     211                if (!(*check_usable)(ifa->ifa_name)) {
     212                        /*
     213                         * No.
     214                         */
     215                        continue;
     216                }
     217
     218                /*
     219                 * "ifa_addr" was apparently null on at least one
     220                 * interface on some system.  Therefore, we supply
     221                 * the address and netmask only if "ifa_addr" is
     222                 * non-null (if there's no address, there's obviously
     223                 * no netmask).
     224                 */
     225                if (ifa->ifa_addr != NULL) {
     226                        addr = ifa->ifa_addr;
     227                        addr_size = SA_LEN(addr);
     228                        netmask = ifa->ifa_netmask;
     229                } else {
     230                        addr = NULL;
     231                        addr_size = 0;
     232                        netmask = NULL;
     233                }
     234
     235                /*
     236                 * Note that, on some platforms, ifa_broadaddr and
     237                 * ifa_dstaddr could be the same field (true on at
     238                 * least some versions of *BSD and OS X), so we
     239                 * can't just check whether the broadcast address
     240                 * is null and add it if so and check whether the
     241                 * destination address is null and add it if so.
     242                 *
     243                 * Therefore, we must also check the IFF_BROADCAST
     244                 * flag, and only add a broadcast address if it's
     245                 * set, and check the IFF_POINTTOPOINT flag, and
     246                 * only add a destination address if it's set (as
     247                 * per man page recommendations on some of those
     248                 * platforms).
     249                 */
     250                if (ifa->ifa_flags & IFF_BROADCAST &&
     251                    ifa->ifa_broadaddr != NULL) {
     252                        broadaddr = ifa->ifa_broadaddr;
     253                        broadaddr_size = SA_LEN(broadaddr);
     254                } else {
     255                        broadaddr = NULL;
     256                        broadaddr_size = 0;
     257                }
     258                if (ifa->ifa_flags & IFF_POINTOPOINT &&
     259                    ifa->ifa_dstaddr != NULL) {
     260                        dstaddr = ifa->ifa_dstaddr;
     261                        dstaddr_size = SA_LEN(ifa->ifa_dstaddr);
     262                } else {
     263                        dstaddr = NULL;
     264                        dstaddr_size = 0;
     265                }
     266
     267                /*
    263268                 * Add information for this address to the list.
    264269                 */
    265270                if (add_addr_to_iflist(&devlist, ifa->ifa_name,
    266                     ifa->ifa_flags, addr, addr_size, netmask, addr_size,
     271                    if_flags_to_pcap_flags(ifa->ifa_name, ifa->ifa_flags),
     272                    addr, addr_size, netmask, addr_size,
    267273                    broadaddr, broadaddr_size, dstaddr, dstaddr_size,
    268274                    errbuf) < 0) {
  • freebsd/contrib/libpcap/gencode.c

    r67cbb9d r97c5f8e8  
    2424 * $FreeBSD$
    2525 */
    26 #ifndef lint
    27 static const char rcsid[] _U_ =
    28     "@(#) $Header: /tcpdump/master/libpcap/gencode.c,v 1.309 2008-12-23 20:13:29 guy Exp $ (LBL)";
    29 #endif
    3026
    3127#ifdef HAVE_CONFIG_H
     
    3329#endif
    3430
    35 #ifdef WIN32
     31#ifdef _WIN32
    3632#include <pcap-stdinc.h>
    37 #else /* WIN32 */
     33#else /* _WIN32 */
    3834#if HAVE_INTTYPES_H
    3935#include <inttypes.h>
     
    4642#include <sys/types.h>
    4743#include <sys/socket.h>
    48 #endif /* WIN32 */
    49 
    50 /*
    51  * XXX - why was this included even on UNIX?
    52  */
    53 #ifdef __MINGW32__
    54 #include "ip6_misc.h"
    55 #endif
    56 
    57 #ifndef WIN32
     44#endif /* _WIN32 */
     45
     46#ifndef _WIN32
    5847
    5948#ifdef __NetBSD__
     
    6453#include <arpa/inet.h>
    6554
    66 #endif /* WIN32 */
     55#endif /* _WIN32 */
    6756
    6857#include <stdlib.h>
     
    8978#include "pcap/ipnet.h"
    9079#include "arcnet.h"
    91 #if defined(PF_PACKET) && defined(SO_ATTACH_FILTER)
     80
     81#include "grammar.h"
     82#include "scanner.h"
     83
     84#if defined(linux) && defined(PF_PACKET) && defined(SO_ATTACH_FILTER)
    9285#include <linux/types.h>
    9386#include <linux/if_packet.h>
    9487#include <linux/filter.h>
    9588#endif
     89
    9690#ifdef HAVE_NET_PFVAR_H
    9791#include <sys/socket.h>
     
    10094#include <net/if_pflog.h>
    10195#endif
     96
    10297#ifndef offsetof
    10398#define offsetof(s, e) ((size_t)&((s *)0)->e)
    10499#endif
     100
    105101#ifdef INET6
    106 #ifndef WIN32
     102#ifdef _WIN32
     103#if defined(__MINGW32__) && defined(DEFINE_ADDITIONAL_IPV6_STUFF)
     104/* IPv6 address */
     105struct in6_addr
     106  {
     107    union
     108      {
     109        u_int8_t                u6_addr8[16];
     110        u_int16_t       u6_addr16[8];
     111        u_int32_t       u6_addr32[4];
     112      } in6_u;
     113#define s6_addr                 in6_u.u6_addr8
     114#define s6_addr16               in6_u.u6_addr16
     115#define s6_addr32               in6_u.u6_addr32
     116#define s6_addr64               in6_u.u6_addr64
     117  };
     118
     119typedef unsigned short  sa_family_t;
     120
     121#define __SOCKADDR_COMMON(sa_prefix) \
     122  sa_family_t sa_prefix##family
     123
     124/* Ditto, for IPv6.  */
     125struct sockaddr_in6
     126  {
     127    __SOCKADDR_COMMON (sin6_);
     128    u_int16_t sin6_port;                /* Transport layer port # */
     129    u_int32_t sin6_flowinfo;    /* IPv6 flow information */
     130    struct in6_addr sin6_addr;  /* IPv6 address */
     131  };
     132
     133#ifndef EAI_ADDRFAMILY
     134struct addrinfo {
     135        int     ai_flags;       /* AI_PASSIVE, AI_CANONNAME */
     136        int     ai_family;      /* PF_xxx */
     137        int     ai_socktype;    /* SOCK_xxx */
     138        int     ai_protocol;    /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
     139        size_t  ai_addrlen;     /* length of ai_addr */
     140        char    *ai_canonname;  /* canonical name for hostname */
     141        struct sockaddr *ai_addr;       /* binary address */
     142        struct addrinfo *ai_next;       /* next structure in linked list */
     143};
     144#endif /* EAI_ADDRFAMILY */
     145#endif /* defined(__MINGW32__) && defined(DEFINE_ADDITIONAL_IPV6_STUFF) */
     146#else /* _WIN32 */
    107147#include <netdb.h>      /* for "struct addrinfo" */
    108 #endif /* WIN32 */
    109 #endif /*INET6*/
     148#endif /* _WIN32 */
     149#endif /* INET6 */
    110150#include <pcap/namedb.h>
    111151
     152#include "nametoaddr.h"
     153
    112154#define ETHERMTU        1500
     155
     156#ifndef ETHERTYPE_TEB
     157#define ETHERTYPE_TEB 0x6558
     158#endif
    113159
    114160#ifndef IPPROTO_HOPOPTS
     
    128174#endif
    129175
     176#define GENEVE_PORT 6081
     177
    130178#ifdef HAVE_OS_PROTO_H
    131179#include "os-proto.h"
     
    134182#define JMP(c) ((c)|BPF_JMP|BPF_K)
    135183
    136 /* Locals */
    137 static jmp_buf top_ctx;
    138 static pcap_t *bpf_pcap;
    139 
    140 /* Hack for updating VLAN, MPLS, and PPPoE offsets. */
    141 #ifdef WIN32
    142 static u_int    orig_linktype = (u_int)-1, orig_nl = (u_int)-1, label_stack_depth = (u_int)-1;
    143 #else
    144 static u_int    orig_linktype = -1U, orig_nl = -1U, label_stack_depth = -1U;
    145 #endif
    146 
    147 /* XXX */
    148 #ifdef PCAP_FDDIPAD
    149 static int      pcap_fddipad;
    150 #endif
    151 
    152 /* VARARGS */
    153 void
    154 bpf_error(const char *fmt, ...)
    155 {
    156         va_list ap;
    157 
    158         va_start(ap, fmt);
    159         if (bpf_pcap != NULL)
    160                 (void)vsnprintf(pcap_geterr(bpf_pcap), PCAP_ERRBUF_SIZE,
    161                     fmt, ap);
    162         va_end(ap);
    163         longjmp(top_ctx, 1);
    164         /* NOTREACHED */
    165 }
    166 
    167 static void init_linktype(pcap_t *);
    168 
    169 static void init_regs(void);
    170 static int alloc_reg(void);
    171 static void free_reg(int);
    172 
    173 static struct block *root;
     184/*
     185 * "Push" the current value of the link-layer header type and link-layer
     186 * header offset onto a "stack", and set a new value.  (It's not a
     187 * full-blown stack; we keep only the top two items.)
     188 */
     189#define PUSH_LINKHDR(cs, new_linktype, new_is_variable, new_constant_part, new_reg) \
     190{ \
     191        (cs)->prevlinktype = (cs)->linktype; \
     192        (cs)->off_prevlinkhdr = (cs)->off_linkhdr; \
     193        (cs)->linktype = (new_linktype); \
     194        (cs)->off_linkhdr.is_variable = (new_is_variable); \
     195        (cs)->off_linkhdr.constant_part = (new_constant_part); \
     196        (cs)->off_linkhdr.reg = (new_reg); \
     197        (cs)->is_geneve = 0; \
     198}
     199
     200/*
     201 * Offset "not set" value.
     202 */
     203#define OFFSET_NOT_SET  0xffffffffU
     204
     205/*
     206 * Absolute offsets, which are offsets from the beginning of the raw
     207 * packet data, are, in the general case, the sum of a variable value
     208 * and a constant value; the variable value may be absent, in which
     209 * case the offset is only the constant value, and the constant value
     210 * may be zero, in which case the offset is only the variable value.
     211 *
     212 * bpf_abs_offset is a structure containing all that information:
     213 *
     214 *   is_variable is 1 if there's a variable part.
     215 *
     216 *   constant_part is the constant part of the value, possibly zero;
     217 *
     218 *   if is_variable is 1, reg is the register number for a register
     219 *   containing the variable value if the register has been assigned,
     220 *   and -1 otherwise.
     221 */
     222typedef struct {
     223        int     is_variable;
     224        u_int   constant_part;
     225        int     reg;
     226} bpf_abs_offset;
    174227
    175228/*
    176229 * Value passed to gen_load_a() to indicate what the offset argument
    177  * is relative to.
     230 * is relative to the beginning of.
    178231 */
    179232enum e_offrel {
    180         OR_PACKET,      /* relative to the beginning of the packet */
    181         OR_LINK,        /* relative to the beginning of the link-layer header */
    182         OR_MACPL,       /* relative to the end of the MAC-layer header */
    183         OR_NET,         /* relative to the network-layer header */
    184         OR_NET_NOSNAP,  /* relative to the network-layer header, with no SNAP header at the link layer */
    185         OR_TRAN_IPV4,   /* relative to the transport-layer header, with IPv4 network layer */
    186         OR_TRAN_IPV6    /* relative to the transport-layer header, with IPv6 network layer */
     233        OR_PACKET,              /* full packet data */
     234        OR_LINKHDR,             /* link-layer header */
     235        OR_PREVLINKHDR,         /* previous link-layer header */
     236        OR_LLC,                 /* 802.2 LLC header */
     237        OR_PREVMPLSHDR,         /* previous MPLS header */
     238        OR_LINKTYPE,            /* link-layer type */
     239        OR_LINKPL,              /* link-layer payload */
     240        OR_LINKPL_NOSNAP,       /* link-layer payload, with no SNAP header at the link layer */
     241        OR_TRAN_IPV4,           /* transport-layer header, with IPv4 network layer */
     242        OR_TRAN_IPV6            /* transport-layer header, with IPv6 network layer */
    187243};
    188 
    189 #ifdef INET6
    190 /*
    191  * As errors are handled by a longjmp, anything allocated must be freed
    192  * in the longjmp handler, so it must be reachable from that handler.
    193  * One thing that's allocated is the result of pcap_nametoaddrinfo();
    194  * it must be freed with freeaddrinfo().  This variable points to any
    195  * addrinfo structure that would need to be freed.
    196  */
    197 static struct addrinfo *ai;
    198 #endif
    199244
    200245/*
     
    209254#define CHUNK0SIZE 1024
    210255struct chunk {
    211         u_int n_left;
     256        size_t n_left;
    212257        void *m;
    213258};
    214259
    215 static struct chunk chunks[NCHUNKS];
    216 static int cur_chunk;
    217 
    218 static void *newchunk(u_int);
    219 static void freechunks(void);
    220 static inline struct block *new_block(int);
    221 static inline struct slist *new_stmt(int);
    222 static struct block *gen_retblk(int);
    223 static inline void syntax(void);
     260/* Code generator state */
     261
     262struct _compiler_state {
     263        jmp_buf top_ctx;
     264        pcap_t *bpf_pcap;
     265
     266        struct icode ic;
     267
     268        int snaplen;
     269
     270        int linktype;
     271        int prevlinktype;
     272        int outermostlinktype;
     273
     274        bpf_u_int32 netmask;
     275        int no_optimize;
     276
     277        /* Hack for handling VLAN and MPLS stacks. */
     278        u_int label_stack_depth;
     279        u_int vlan_stack_depth;
     280
     281        /* XXX */
     282        u_int pcap_fddipad;
     283
     284#ifdef INET6
     285        /*
     286         * As errors are handled by a longjmp, anything allocated must
     287         * be freed in the longjmp handler, so it must be reachable
     288         * from that handler.
     289         *
     290         * One thing that's allocated is the result of pcap_nametoaddrinfo();
     291         * it must be freed with freeaddrinfo().  This variable points to
     292         * any addrinfo structure that would need to be freed.
     293         */
     294        struct addrinfo *ai;
     295#endif
     296
     297        /*
     298         * Various code constructs need to know the layout of the packet.
     299         * These values give the necessary offsets from the beginning
     300         * of the packet data.
     301         */
     302
     303        /*
     304         * Absolute offset of the beginning of the link-layer header.
     305         */
     306        bpf_abs_offset off_linkhdr;
     307
     308        /*
     309         * If we're checking a link-layer header for a packet encapsulated
     310         * in another protocol layer, this is the equivalent information
     311         * for the previous layers' link-layer header from the beginning
     312         * of the raw packet data.
     313         */
     314        bpf_abs_offset off_prevlinkhdr;
     315
     316        /*
     317         * This is the equivalent information for the outermost layers'
     318         * link-layer header.
     319         */
     320        bpf_abs_offset off_outermostlinkhdr;
     321
     322        /*
     323         * Absolute offset of the beginning of the link-layer payload.
     324         */
     325        bpf_abs_offset off_linkpl;
     326
     327        /*
     328         * "off_linktype" is the offset to information in the link-layer
     329         * header giving the packet type. This is an absolute offset
     330         * from the beginning of the packet.
     331         *
     332         * For Ethernet, it's the offset of the Ethernet type field; this
     333         * means that it must have a value that skips VLAN tags.
     334         *
     335         * For link-layer types that always use 802.2 headers, it's the
     336         * offset of the LLC header; this means that it must have a value
     337         * that skips VLAN tags.
     338         *
     339         * For PPP, it's the offset of the PPP type field.
     340         *
     341         * For Cisco HDLC, it's the offset of the CHDLC type field.
     342         *
     343         * For BSD loopback, it's the offset of the AF_ value.
     344         *
     345         * For Linux cooked sockets, it's the offset of the type field.
     346         *
     347         * off_linktype.constant_part is set to OFFSET_NOT_SET for no
     348         * encapsulation, in which case, IP is assumed.
     349         */
     350        bpf_abs_offset off_linktype;
     351
     352        /*
     353         * TRUE if the link layer includes an ATM pseudo-header.
     354         */
     355        int is_atm;
     356
     357        /*
     358         * TRUE if "geneve" appeared in the filter; it causes us to
     359         * generate code that checks for a Geneve header and assume
     360         * that later filters apply to the encapsulated payload.
     361         */
     362        int is_geneve;
     363
     364        /*
     365         * These are offsets for the ATM pseudo-header.
     366         */
     367        u_int off_vpi;
     368        u_int off_vci;
     369        u_int off_proto;
     370
     371        /*
     372         * These are offsets for the MTP2 fields.
     373         */
     374        u_int off_li;
     375        u_int off_li_hsl;
     376
     377        /*
     378         * These are offsets for the MTP3 fields.
     379         */
     380        u_int off_sio;
     381        u_int off_opc;
     382        u_int off_dpc;
     383        u_int off_sls;
     384
     385        /*
     386         * This is the offset of the first byte after the ATM pseudo_header,
     387         * or -1 if there is no ATM pseudo-header.
     388         */
     389        u_int off_payload;
     390
     391        /*
     392         * These are offsets to the beginning of the network-layer header.
     393         * They are relative to the beginning of the link-layer payload
     394         * (i.e., they don't include off_linkhdr.constant_part or
     395         * off_linkpl.constant_part).
     396         *
     397         * If the link layer never uses 802.2 LLC:
     398         *
     399         *      "off_nl" and "off_nl_nosnap" are the same.
     400         *
     401         * If the link layer always uses 802.2 LLC:
     402         *
     403         *      "off_nl" is the offset if there's a SNAP header following
     404         *      the 802.2 header;
     405         *
     406         *      "off_nl_nosnap" is the offset if there's no SNAP header.
     407         *
     408         * If the link layer is Ethernet:
     409         *
     410         *      "off_nl" is the offset if the packet is an Ethernet II packet
     411         *      (we assume no 802.3+802.2+SNAP);
     412         *
     413         *      "off_nl_nosnap" is the offset if the packet is an 802.3 packet
     414         *      with an 802.2 header following it.
     415         */
     416        u_int off_nl;
     417        u_int off_nl_nosnap;
     418
     419        /*
     420         * Here we handle simple allocation of the scratch registers.
     421         * If too many registers are alloc'd, the allocator punts.
     422         */
     423        int regused[BPF_MEMWORDS];
     424        int curreg;
     425
     426        /*
     427         * Memory chunks.
     428         */
     429        struct chunk chunks[NCHUNKS];
     430        int cur_chunk;
     431};
     432
     433void
     434bpf_syntax_error(compiler_state_t *cstate, const char *msg)
     435{
     436        bpf_error(cstate, "syntax error in filter expression: %s", msg);
     437        /* NOTREACHED */
     438}
     439
     440/* VARARGS */
     441void
     442bpf_error(compiler_state_t *cstate, const char *fmt, ...)
     443{
     444        va_list ap;
     445
     446        va_start(ap, fmt);
     447        if (cstate->bpf_pcap != NULL)
     448                (void)pcap_vsnprintf(pcap_geterr(cstate->bpf_pcap),
     449                    PCAP_ERRBUF_SIZE, fmt, ap);
     450        va_end(ap);
     451        longjmp(cstate->top_ctx, 1);
     452        /* NOTREACHED */
     453}
     454
     455static void init_linktype(compiler_state_t *, pcap_t *);
     456
     457static void init_regs(compiler_state_t *);
     458static int alloc_reg(compiler_state_t *);
     459static void free_reg(compiler_state_t *, int);
     460
     461static void initchunks(compiler_state_t *cstate);
     462static void *newchunk(compiler_state_t *cstate, size_t);
     463static void freechunks(compiler_state_t *cstate);
     464static inline struct block *new_block(compiler_state_t *cstate, int);
     465static inline struct slist *new_stmt(compiler_state_t *cstate, int);
     466static struct block *gen_retblk(compiler_state_t *cstate, int);
     467static inline void syntax(compiler_state_t *cstate);
    224468
    225469static void backpatch(struct block *, struct block *);
    226470static void merge(struct block *, struct block *);
    227 static struct block *gen_cmp(enum e_offrel, u_int, u_int, bpf_int32);
    228 static struct block *gen_cmp_gt(enum e_offrel, u_int, u_int, bpf_int32);
    229 static struct block *gen_cmp_ge(enum e_offrel, u_int, u_int, bpf_int32);
    230 static struct block *gen_cmp_lt(enum e_offrel, u_int, u_int, bpf_int32);
    231 static struct block *gen_cmp_le(enum e_offrel, u_int, u_int, bpf_int32);
    232 static struct block *gen_mcmp(enum e_offrel, u_int, u_int, bpf_int32,
    233     bpf_u_int32);
    234 static struct block *gen_bcmp(enum e_offrel, u_int, u_int, const u_char *);
    235 static struct block *gen_ncmp(enum e_offrel, bpf_u_int32, bpf_u_int32,
    236     bpf_u_int32, bpf_u_int32, int, bpf_int32);
    237 static struct slist *gen_load_llrel(u_int, u_int);
    238 static struct slist *gen_load_macplrel(u_int, u_int);
    239 static struct slist *gen_load_a(enum e_offrel, u_int, u_int);
    240 static struct slist *gen_loadx_iphdrlen(void);
    241 static struct block *gen_uncond(int);
    242 static inline struct block *gen_true(void);
    243 static inline struct block *gen_false(void);
    244 static struct block *gen_ether_linktype(int);
    245 static struct block *gen_ipnet_linktype(int);
    246 static struct block *gen_linux_sll_linktype(int);
    247 static struct slist *gen_load_prism_llprefixlen(void);
    248 static struct slist *gen_load_avs_llprefixlen(void);
    249 static struct slist *gen_load_radiotap_llprefixlen(void);
    250 static struct slist *gen_load_ppi_llprefixlen(void);
    251 static void insert_compute_vloffsets(struct block *);
    252 static struct slist *gen_llprefixlen(void);
    253 static struct slist *gen_off_macpl(void);
     471static struct block *gen_cmp(compiler_state_t *, enum e_offrel, u_int,
     472    u_int, bpf_int32);
     473static struct block *gen_cmp_gt(compiler_state_t *, enum e_offrel, u_int,
     474    u_int, bpf_int32);
     475static struct block *gen_cmp_ge(compiler_state_t *, enum e_offrel, u_int,
     476    u_int, bpf_int32);
     477static struct block *gen_cmp_lt(compiler_state_t *, enum e_offrel, u_int,
     478    u_int, bpf_int32);
     479static struct block *gen_cmp_le(compiler_state_t *, enum e_offrel, u_int,
     480    u_int, bpf_int32);
     481static struct block *gen_mcmp(compiler_state_t *, enum e_offrel, u_int,
     482    u_int, bpf_int32, bpf_u_int32);
     483static struct block *gen_bcmp(compiler_state_t *, enum e_offrel, u_int,
     484    u_int, const u_char *);
     485static struct block *gen_ncmp(compiler_state_t *, enum e_offrel, bpf_u_int32,
     486    bpf_u_int32, bpf_u_int32, bpf_u_int32, int, bpf_int32);
     487static struct slist *gen_load_absoffsetrel(compiler_state_t *, bpf_abs_offset *,
     488    u_int, u_int);
     489static struct slist *gen_load_a(compiler_state_t *, enum e_offrel, u_int,
     490    u_int);
     491static struct slist *gen_loadx_iphdrlen(compiler_state_t *);
     492static struct block *gen_uncond(compiler_state_t *, int);
     493static inline struct block *gen_true(compiler_state_t *);
     494static inline struct block *gen_false(compiler_state_t *);
     495static struct block *gen_ether_linktype(compiler_state_t *, int);
     496static struct block *gen_ipnet_linktype(compiler_state_t *, int);
     497static struct block *gen_linux_sll_linktype(compiler_state_t *, int);
     498static struct slist *gen_load_prism_llprefixlen(compiler_state_t *);
     499static struct slist *gen_load_avs_llprefixlen(compiler_state_t *);
     500static struct slist *gen_load_radiotap_llprefixlen(compiler_state_t *);
     501static struct slist *gen_load_ppi_llprefixlen(compiler_state_t *);
     502static void insert_compute_vloffsets(compiler_state_t *, struct block *);
     503static struct slist *gen_abs_offset_varpart(compiler_state_t *,
     504    bpf_abs_offset *);
    254505static int ethertype_to_ppptype(int);
    255 static struct block *gen_linktype(int);
    256 static struct block *gen_snap(bpf_u_int32, bpf_u_int32);
    257 static struct block *gen_llc_linktype(int);
    258 static struct block *gen_hostop(bpf_u_int32, bpf_u_int32, int, int, u_int, u_int);
     506static struct block *gen_linktype(compiler_state_t *, int);
     507static struct block *gen_snap(compiler_state_t *, bpf_u_int32, bpf_u_int32);
     508static struct block *gen_llc_linktype(compiler_state_t *, int);
     509static struct block *gen_hostop(compiler_state_t *, bpf_u_int32, bpf_u_int32,
     510    int, int, u_int, u_int);
    259511#ifdef INET6
    260 static struct block *gen_hostop6(struct in6_addr *, struct in6_addr *, int, int, u_int, u_int);
     512static struct block *gen_hostop6(compiler_state_t *, struct in6_addr *,
     513    struct in6_addr *, int, int, u_int, u_int);
    261514#endif
    262 static struct block *gen_ahostop(const u_char *, int);
    263 static struct block *gen_ehostop(const u_char *, int);
    264 static struct block *gen_fhostop(const u_char *, int);
    265 static struct block *gen_thostop(const u_char *, int);
    266 static struct block *gen_wlanhostop(const u_char *, int);
    267 static struct block *gen_ipfchostop(const u_char *, int);
    268 static struct block *gen_dnhostop(bpf_u_int32, int);
    269 static struct block *gen_mpls_linktype(int);
    270 static struct block *gen_host(bpf_u_int32, bpf_u_int32, int, int, int);
     515static struct block *gen_ahostop(compiler_state_t *, const u_char *, int);
     516static struct block *gen_ehostop(compiler_state_t *, const u_char *, int);
     517static struct block *gen_fhostop(compiler_state_t *, const u_char *, int);
     518static struct block *gen_thostop(compiler_state_t *, const u_char *, int);
     519static struct block *gen_wlanhostop(compiler_state_t *, const u_char *, int);
     520static struct block *gen_ipfchostop(compiler_state_t *, const u_char *, int);
     521static struct block *gen_dnhostop(compiler_state_t *, bpf_u_int32, int);
     522static struct block *gen_mpls_linktype(compiler_state_t *, int);
     523static struct block *gen_host(compiler_state_t *, bpf_u_int32, bpf_u_int32,
     524    int, int, int);
    271525#ifdef INET6
    272 static struct block *gen_host6(struct in6_addr *, struct in6_addr *, int, int, int);
     526static struct block *gen_host6(compiler_state_t *, struct in6_addr *,
     527    struct in6_addr *, int, int, int);
    273528#endif
    274529#ifndef INET6
    275 static struct block *gen_gateway(const u_char *, bpf_u_int32 **, int, int);
     530static struct block *gen_gateway(compiler_state_t *, const u_char *,
     531    bpf_u_int32 **, int, int);
    276532#endif
    277 static struct block *gen_ipfrag(void);
    278 static struct block *gen_portatom(int, bpf_int32);
    279 static struct block *gen_portrangeatom(int, bpf_int32, bpf_int32);
    280 static struct block *gen_portatom6(int, bpf_int32);
    281 static struct block *gen_portrangeatom6(int, bpf_int32, bpf_int32);
    282 struct block *gen_portop(int, int, int);
    283 static struct block *gen_port(int, int, int);
    284 struct block *gen_portrangeop(int, int, int, int);
    285 static struct block *gen_portrange(int, int, int, int);
    286 struct block *gen_portop6(int, int, int);
    287 static struct block *gen_port6(int, int, int);
    288 struct block *gen_portrangeop6(int, int, int, int);
    289 static struct block *gen_portrange6(int, int, int, int);
    290 static int lookup_proto(const char *, int);
    291 static struct block *gen_protochain(int, int, int);
    292 static struct block *gen_proto(int, int, int);
    293 static struct slist *xfer_to_x(struct arth *);
    294 static struct slist *xfer_to_a(struct arth *);
    295 static struct block *gen_mac_multicast(int);
    296 static struct block *gen_len(int, int);
    297 static struct block *gen_check_802_11_data_frame(void);
    298 
    299 static struct block *gen_ppi_dlt_check(void);
    300 static struct block *gen_msg_abbrev(int type);
     533static struct block *gen_ipfrag(compiler_state_t *);
     534static struct block *gen_portatom(compiler_state_t *, int, bpf_int32);
     535static struct block *gen_portrangeatom(compiler_state_t *, int, bpf_int32,
     536    bpf_int32);
     537static struct block *gen_portatom6(compiler_state_t *, int, bpf_int32);
     538static struct block *gen_portrangeatom6(compiler_state_t *, int, bpf_int32,
     539    bpf_int32);
     540struct block *gen_portop(compiler_state_t *, int, int, int);
     541static struct block *gen_port(compiler_state_t *, int, int, int);
     542struct block *gen_portrangeop(compiler_state_t *, int, int, int, int);
     543static struct block *gen_portrange(compiler_state_t *, int, int, int, int);
     544struct block *gen_portop6(compiler_state_t *, int, int, int);
     545static struct block *gen_port6(compiler_state_t *, int, int, int);
     546struct block *gen_portrangeop6(compiler_state_t *, int, int, int, int);
     547static struct block *gen_portrange6(compiler_state_t *, int, int, int, int);
     548static int lookup_proto(compiler_state_t *, const char *, int);
     549static struct block *gen_protochain(compiler_state_t *, int, int, int);
     550static struct block *gen_proto(compiler_state_t *, int, int, int);
     551static struct slist *xfer_to_x(compiler_state_t *, struct arth *);
     552static struct slist *xfer_to_a(compiler_state_t *, struct arth *);
     553static struct block *gen_mac_multicast(compiler_state_t *, int);
     554static struct block *gen_len(compiler_state_t *, int, int);
     555static struct block *gen_check_802_11_data_frame(compiler_state_t *);
     556static struct block *gen_geneve_ll_check(compiler_state_t *cstate);
     557
     558static struct block *gen_ppi_dlt_check(compiler_state_t *);
     559static struct block *gen_msg_abbrev(compiler_state_t *, int type);
     560
     561static void
     562initchunks(compiler_state_t *cstate)
     563{
     564        int i;
     565
     566        for (i = 0; i < NCHUNKS; i++) {
     567                cstate->chunks[i].n_left = 0;
     568                cstate->chunks[i].m = NULL;
     569        }
     570        cstate->cur_chunk = 0;
     571}
    301572
    302573static void *
    303 newchunk(n)
    304         u_int n;
     574newchunk(compiler_state_t *cstate, size_t n)
    305575{
    306576        struct chunk *cp;
     
    316586#endif
    317587
    318         cp = &chunks[cur_chunk];
     588        cp = &cstate->chunks[cstate->cur_chunk];
    319589        if (n > cp->n_left) {
    320                 ++cp, k = ++cur_chunk;
     590                ++cp, k = ++cstate->cur_chunk;
    321591                if (k >= NCHUNKS)
    322                         bpf_error("out of memory");
     592                        bpf_error(cstate, "out of memory");
    323593                size = CHUNK0SIZE << k;
    324594                cp->m = (void *)malloc(size);
    325595                if (cp->m == NULL)
    326                         bpf_error("out of memory");
     596                        bpf_error(cstate, "out of memory");
    327597                memset((char *)cp->m, 0, size);
    328598                cp->n_left = size;
    329599                if (n > size)
    330                         bpf_error("out of memory");
     600                        bpf_error(cstate, "out of memory");
    331601        }
    332602        cp->n_left -= n;
     
    335605
    336606static void
    337 freechunks()
     607freechunks(compiler_state_t *cstate)
    338608{
    339609        int i;
    340610
    341         cur_chunk = 0;
    342611        for (i = 0; i < NCHUNKS; ++i)
    343                 if (chunks[i].m != NULL) {
    344                         free(chunks[i].m);
    345                         chunks[i].m = NULL;
    346                 }
     612                if (cstate->chunks[i].m != NULL)
     613                        free(cstate->chunks[i].m);
    347614}
    348615
     
    351618 */
    352619char *
    353 sdup(s)
    354         register const char *s;
    355 {
    356         int n = strlen(s) + 1;
    357         char *cp = newchunk(n);
     620sdup(compiler_state_t *cstate, const char *s)
     621{
     622        size_t n = strlen(s) + 1;
     623        char *cp = newchunk(cstate, n);
    358624
    359625        strlcpy(cp, s, n);
     
    362628
    363629static inline struct block *
    364 new_block(code)
    365         int code;
     630new_block(compiler_state_t *cstate, int code)
    366631{
    367632        struct block *p;
    368633
    369         p = (struct block *)newchunk(sizeof(*p));
     634        p = (struct block *)newchunk(cstate, sizeof(*p));
    370635        p->s.code = code;
    371636        p->head = p;
     
    375640
    376641static inline struct slist *
    377 new_stmt(code)
    378         int code;
     642new_stmt(compiler_state_t *cstate, int code)
    379643{
    380644        struct slist *p;
    381645
    382         p = (struct slist *)newchunk(sizeof(*p));
     646        p = (struct slist *)newchunk(cstate, sizeof(*p));
    383647        p->s.code = code;
    384648
     
    387651
    388652static struct block *
    389 gen_retblk(v)
    390         int v;
    391 {
    392         struct block *b = new_block(BPF_RET|BPF_K);
     653gen_retblk(compiler_state_t *cstate, int v)
     654{
     655        struct block *b = new_block(cstate, BPF_RET|BPF_K);
    393656
    394657        b->s.k = v;
     
    397660
    398661static inline void
    399 syntax()
    400 {
    401         bpf_error("syntax error in filter expression");
    402 }
    403 
    404 static bpf_u_int32 netmask;
    405 static int snaplen;
    406 int no_optimize;
    407 #ifdef WIN32
    408 static int
    409 pcap_compile_unsafe(pcap_t *p, struct bpf_program *program,
    410              const char *buf, int optimize, bpf_u_int32 mask);
     662syntax(compiler_state_t *cstate)
     663{
     664        bpf_error(cstate, "syntax error in filter expression");
     665}
    411666
    412667int
     
    414669             const char *buf, int optimize, bpf_u_int32 mask)
    415670{
    416         int result;
    417 
    418         EnterCriticalSection(&g_PcapCompileCriticalSection);
    419 
    420         result = pcap_compile_unsafe(p, program, buf, optimize, mask);
    421 
    422         LeaveCriticalSection(&g_PcapCompileCriticalSection);
    423 
    424         return result;
    425 }
    426 
    427 static int
    428 pcap_compile_unsafe(pcap_t *p, struct bpf_program *program,
    429              const char *buf, int optimize, bpf_u_int32 mask)
    430 #else /* WIN32 */
    431 int
    432 pcap_compile(pcap_t *p, struct bpf_program *program,
    433              const char *buf, int optimize, bpf_u_int32 mask)
    434 #endif /* WIN32 */
    435 {
    436 #ifdef __rtems__
    437         int n_errors;
    438 #else
    439         extern int n_errors;
    440 #endif /* __rtems__ */
     671        compiler_state_t cstate;
    441672        const char * volatile xbuf = buf;
     673        yyscan_t scanner = NULL;
     674        YY_BUFFER_STATE in_buffer = NULL;
    442675        u_int len;
     676        int  rc;
     677
     678#ifdef _WIN32
     679        static int done = 0;
     680
     681        if (!done)
     682                pcap_wsockinit();
     683        done = 1;
     684#endif
    443685
    444686        /*
     
    447689         */
    448690        if (!p->activated) {
    449                 snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
     691                pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
    450692                    "not-yet-activated pcap_t passed to pcap_compile");
    451                 return (-1);
    452         }
    453         no_optimize = 0;
    454         n_errors = 0;
    455         root = NULL;
    456         bpf_pcap = p;
    457         init_regs();
    458         if (setjmp(top_ctx)) {
     693                rc = -1;
     694                goto quit;
     695        }
     696        initchunks(&cstate);
     697        cstate.no_optimize = 0;
    459698#ifdef INET6
    460                 if (ai != NULL) {
    461                         freeaddrinfo(ai);
    462                         ai = NULL;
    463                 }
     699        cstate.ai = NULL;
    464700#endif
    465                 lex_cleanup();
    466                 freechunks();
    467                 return (-1);
    468         }
    469 
    470         netmask = mask;
    471 
    472         snaplen = pcap_snapshot(p);
    473         if (snaplen == 0) {
    474                 snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
     701        cstate.ic.root = NULL;
     702        cstate.ic.cur_mark = 0;
     703        cstate.bpf_pcap = p;
     704        init_regs(&cstate);
     705
     706        if (setjmp(cstate.top_ctx)) {
     707#ifdef INET6
     708                if (cstate.ai != NULL)
     709                        freeaddrinfo(cstate.ai);
     710#endif
     711                rc = -1;
     712                goto quit;
     713        }
     714
     715        cstate.netmask = mask;
     716
     717        cstate.snaplen = pcap_snapshot(p);
     718        if (cstate.snaplen == 0) {
     719                pcap_snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
    475720                         "snaplen of 0 rejects all packets");
    476                 return -1;
    477         }
    478 
    479         lex_init(xbuf ? xbuf : "");
    480         init_linktype(p);
    481         (void)pcap_parse();
    482 
    483         if (n_errors)
    484                 syntax();
    485 
    486         if (root == NULL)
    487                 root = gen_retblk(snaplen);
    488 
    489         if (optimize && !no_optimize) {
    490                 bpf_optimize(&root);
    491                 if (root == NULL ||
    492                     (root->s.code == (BPF_RET|BPF_K) && root->s.k == 0))
    493                         bpf_error("expression rejects all packets");
    494         }
    495         program->bf_insns = icode_to_fcode(root, &len);
     721                rc = -1;
     722                goto quit;
     723        }
     724
     725        if (pcap_lex_init(&scanner) != 0)
     726                bpf_error(&cstate, "can't initialize scanner: %s", pcap_strerror(errno));
     727        in_buffer = pcap__scan_string(xbuf ? xbuf : "", scanner);
     728
     729        /*
     730         * Associate the compiler state with the lexical analyzer
     731         * state.
     732         */
     733        pcap_set_extra(&cstate, scanner);
     734
     735        init_linktype(&cstate, p);
     736        (void)pcap_parse(scanner, &cstate);
     737
     738        if (cstate.ic.root == NULL)
     739                cstate.ic.root = gen_retblk(&cstate, cstate.snaplen);
     740
     741        if (optimize && !cstate.no_optimize) {
     742                bpf_optimize(&cstate, &cstate.ic);
     743                if (cstate.ic.root == NULL ||
     744                    (cstate.ic.root->s.code == (BPF_RET|BPF_K) && cstate.ic.root->s.k == 0))
     745                        bpf_error(&cstate, "expression rejects all packets");
     746        }
     747        program->bf_insns = icode_to_fcode(&cstate, &cstate.ic, cstate.ic.root, &len);
    496748        program->bf_len = len;
    497749
    498         lex_cleanup();
    499         freechunks();
    500         return (0);
     750        rc = 0;  /* We're all okay */
     751
     752quit:
     753        /*
     754         * Clean up everything for the lexical analyzer.
     755         */
     756        if (in_buffer != NULL)
     757                pcap__delete_buffer(in_buffer, scanner);
     758        if (scanner != NULL)
     759                pcap_lex_destroy(scanner);
     760
     761        /*
     762         * Clean up our own allocated memory.
     763         */
     764        freechunks(&cstate);
     765
     766        return (rc);
    501767}
    502768
     
    578844
    579845void
    580 finish_parse(p)
    581         struct block *p;
     846finish_parse(compiler_state_t *cstate, struct block *p)
    582847{
    583848        struct block *ppi_dlt_check;
     
    602867         * worth the effort.
    603868         */
    604         insert_compute_vloffsets(p->head);
     869        insert_compute_vloffsets(cstate, p->head);
    605870
    606871        /*
    607872         * For DLT_PPI captures, generate a check of the per-packet
    608873         * DLT value to make sure it's DLT_IEEE802_11.
     874         *
     875         * XXX - TurboCap cards use DLT_PPI for Ethernet.
     876         * Can we just define some DLT_ETHERNET_WITH_PHDR pseudo-header
     877         * with appropriate Ethernet information and use that rather
     878         * than using something such as DLT_PPI where you don't know
     879         * the link-layer header type until runtime, which, in the
     880         * general case, would force us to generate both Ethernet *and*
     881         * 802.11 code (*and* anything else for which PPI is used)
     882         * and choose between them early in the BPF program?
    609883         */
    610         ppi_dlt_check = gen_ppi_dlt_check();
     884        ppi_dlt_check = gen_ppi_dlt_check(cstate);
    611885        if (ppi_dlt_check != NULL)
    612886                gen_and(ppi_dlt_check, p);
    613887
    614         backpatch(p, gen_retblk(snaplen));
     888        backpatch(p, gen_retblk(cstate, cstate->snaplen));
    615889        p->sense = !p->sense;
    616         backpatch(p, gen_retblk(0));
    617         root = p->head;
     890        backpatch(p, gen_retblk(cstate, 0));
     891        cstate->ic.root = p->head;
    618892}
    619893
     
    649923
    650924static struct block *
    651 gen_cmp(offrel, offset, size, v)
    652         enum e_offrel offrel;
    653         u_int offset, size;
    654         bpf_int32 v;
    655 {
    656         return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JEQ, 0, v);
     925gen_cmp(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
     926    u_int size, bpf_int32 v)
     927{
     928        return gen_ncmp(cstate, offrel, offset, size, 0xffffffff, BPF_JEQ, 0, v);
    657929}
    658930
    659931static struct block *
    660 gen_cmp_gt(offrel, offset, size, v)
    661         enum e_offrel offrel;
    662         u_int offset, size;
    663         bpf_int32 v;
    664 {
    665         return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGT, 0, v);
     932gen_cmp_gt(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
     933    u_int size, bpf_int32 v)
     934{
     935        return gen_ncmp(cstate, offrel, offset, size, 0xffffffff, BPF_JGT, 0, v);
    666936}
    667937
    668938static struct block *
    669 gen_cmp_ge(offrel, offset, size, v)
    670         enum e_offrel offrel;
    671         u_int offset, size;
    672         bpf_int32 v;
    673 {
    674         return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGE, 0, v);
     939gen_cmp_ge(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
     940    u_int size, bpf_int32 v)
     941{
     942        return gen_ncmp(cstate, offrel, offset, size, 0xffffffff, BPF_JGE, 0, v);
    675943}
    676944
    677945static struct block *
    678 gen_cmp_lt(offrel, offset, size, v)
    679         enum e_offrel offrel;
    680         u_int offset, size;
    681         bpf_int32 v;
    682 {
    683         return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGE, 1, v);
     946gen_cmp_lt(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
     947    u_int size, bpf_int32 v)
     948{
     949        return gen_ncmp(cstate, offrel, offset, size, 0xffffffff, BPF_JGE, 1, v);
    684950}
    685951
    686952static struct block *
    687 gen_cmp_le(offrel, offset, size, v)
    688         enum e_offrel offrel;
    689         u_int offset, size;
    690         bpf_int32 v;
    691 {
    692         return gen_ncmp(offrel, offset, size, 0xffffffff, BPF_JGT, 1, v);
     953gen_cmp_le(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
     954    u_int size, bpf_int32 v)
     955{
     956        return gen_ncmp(cstate, offrel, offset, size, 0xffffffff, BPF_JGT, 1, v);
    693957}
    694958
    695959static struct block *
    696 gen_mcmp(offrel, offset, size, v, mask)
    697         enum e_offrel offrel;
    698         u_int offset, size;
    699         bpf_int32 v;
    700         bpf_u_int32 mask;
    701 {
    702         return gen_ncmp(offrel, offset, size, mask, BPF_JEQ, 0, v);
     960gen_mcmp(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
     961    u_int size, bpf_int32 v, bpf_u_int32 mask)
     962{
     963        return gen_ncmp(cstate, offrel, offset, size, mask, BPF_JEQ, 0, v);
    703964}
    704965
    705966static struct block *
    706 gen_bcmp(offrel, offset, size, v)
    707         enum e_offrel offrel;
    708         register u_int offset, size;
    709         register const u_char *v;
     967gen_bcmp(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
     968    u_int size, const u_char *v)
    710969{
    711970        register struct block *b, *tmp;
     
    717976                    ((bpf_int32)p[1] << 16) | ((bpf_int32)p[2] << 8) | p[3];
    718977
    719                 tmp = gen_cmp(offrel, offset + size - 4, BPF_W, w);
     978                tmp = gen_cmp(cstate, offrel, offset + size - 4, BPF_W, w);
    720979                if (b != NULL)
    721980                        gen_and(b, tmp);
     
    727986                bpf_int32 w = ((bpf_int32)p[0] << 8) | p[1];
    728987
    729                 tmp = gen_cmp(offrel, offset + size - 2, BPF_H, w);
     988                tmp = gen_cmp(cstate, offrel, offset + size - 2, BPF_H, w);
    730989                if (b != NULL)
    731990                        gen_and(b, tmp);
     
    734993        }
    735994        if (size > 0) {
    736                 tmp = gen_cmp(offrel, offset, BPF_B, (bpf_int32)v[0]);
     995                tmp = gen_cmp(cstate, offrel, offset, BPF_B, (bpf_int32)v[0]);
    737996                if (b != NULL)
    738997                        gen_and(b, tmp);
     
    7491008 */
    7501009static struct block *
    751 gen_ncmp(offrel, offset, size, mask, jtype, reverse, v)
    752         enum e_offrel offrel;
    753         bpf_int32 v;
    754         bpf_u_int32 offset, size, mask, jtype;
    755         int reverse;
     1010gen_ncmp(compiler_state_t *cstate, enum e_offrel offrel, bpf_u_int32 offset,
     1011    bpf_u_int32 size, bpf_u_int32 mask, bpf_u_int32 jtype, int reverse,
     1012    bpf_int32 v)
    7561013{
    7571014        struct slist *s, *s2;
    7581015        struct block *b;
    7591016
    760         s = gen_load_a(offrel, offset, size);
     1017        s = gen_load_a(cstate, offrel, offset, size);
    7611018
    7621019        if (mask != 0xffffffff) {
    763                 s2 = new_stmt(BPF_ALU|BPF_AND|BPF_K);
     1020                s2 = new_stmt(cstate, BPF_ALU|BPF_AND|BPF_K);
    7641021                s2->s.k = mask;
    7651022                sappend(s, s2);
    7661023        }
    7671024
    768         b = new_block(JMP(jtype));
     1025        b = new_block(cstate, JMP(jtype));
    7691026        b->stmts = s;
    7701027        b->s.k = v;
     
    7741031}
    7751032
    776 /*
    777  * Various code constructs need to know the layout of the data link
    778  * layer.  These variables give the necessary offsets from the beginning
    779  * of the packet data.
    780  */
    781 
    782 /*
    783  * This is the offset of the beginning of the link-layer header from
    784  * the beginning of the raw packet data.
    785  *
    786  * It's usually 0, except for 802.11 with a fixed-length radio header.
    787  * (For 802.11 with a variable-length radio header, we have to generate
    788  * code to compute that offset; off_ll is 0 in that case.)
    789  */
    790 static u_int off_ll;
    791 
    792 /*
    793  * If there's a variable-length header preceding the link-layer header,
    794  * "reg_off_ll" is the register number for a register containing the
    795  * length of that header, and therefore the offset of the link-layer
    796  * header from the beginning of the raw packet data.  Otherwise,
    797  * "reg_off_ll" is -1.
    798  */
    799 static int reg_off_ll;
    800 
    801 /*
    802  * This is the offset of the beginning of the MAC-layer header from
    803  * the beginning of the link-layer header.
    804  * It's usually 0, except for ATM LANE, where it's the offset, relative
    805  * to the beginning of the raw packet data, of the Ethernet header, and
    806  * for Ethernet with various additional information.
    807  */
    808 static u_int off_mac;
    809 
    810 /*
    811  * This is the offset of the beginning of the MAC-layer payload,
    812  * from the beginning of the raw packet data.
    813  *
    814  * I.e., it's the sum of the length of the link-layer header (without,
    815  * for example, any 802.2 LLC header, so it's the MAC-layer
    816  * portion of that header), plus any prefix preceding the
    817  * link-layer header.
    818  */
    819 static u_int off_macpl;
    820 
    821 /*
    822  * This is 1 if the offset of the beginning of the MAC-layer payload
    823  * from the beginning of the link-layer header is variable-length.
    824  */
    825 static int off_macpl_is_variable;
    826 
    827 /*
    828  * If the link layer has variable_length headers, "reg_off_macpl"
    829  * is the register number for a register containing the length of the
    830  * link-layer header plus the length of any variable-length header
    831  * preceding the link-layer header.  Otherwise, "reg_off_macpl"
    832  * is -1.
    833  */
    834 static int reg_off_macpl;
    835 
    836 /*
    837  * "off_linktype" is the offset to information in the link-layer header
    838  * giving the packet type.  This offset is relative to the beginning
    839  * of the link-layer header (i.e., it doesn't include off_ll).
    840  *
    841  * For Ethernet, it's the offset of the Ethernet type field.
    842  *
    843  * For link-layer types that always use 802.2 headers, it's the
    844  * offset of the LLC header.
    845  *
    846  * For PPP, it's the offset of the PPP type field.
    847  *
    848  * For Cisco HDLC, it's the offset of the CHDLC type field.
    849  *
    850  * For BSD loopback, it's the offset of the AF_ value.
    851  *
    852  * For Linux cooked sockets, it's the offset of the type field.
    853  *
    854  * It's set to -1 for no encapsulation, in which case, IP is assumed.
    855  */
    856 static u_int off_linktype;
    857 
    858 /*
    859  * TRUE if "pppoes" appeared in the filter; it causes link-layer type
    860  * checks to check the PPP header, assumed to follow a LAN-style link-
    861  * layer header and a PPPoE session header.
    862  */
    863 static int is_pppoes = 0;
    864 
    865 /*
    866  * TRUE if the link layer includes an ATM pseudo-header.
    867  */
    868 static int is_atm = 0;
    869 
    870 /*
    871  * TRUE if "lane" appeared in the filter; it causes us to generate
    872  * code that assumes LANE rather than LLC-encapsulated traffic in SunATM.
    873  */
    874 static int is_lane = 0;
    875 
    876 /*
    877  * These are offsets for the ATM pseudo-header.
    878  */
    879 static u_int off_vpi;
    880 static u_int off_vci;
    881 static u_int off_proto;
    882 
    883 /*
    884  * These are offsets for the MTP2 fields.
    885  */
    886 static u_int off_li;
    887 
    888 /*
    889  * These are offsets for the MTP3 fields.
    890  */
    891 static u_int off_sio;
    892 static u_int off_opc;
    893 static u_int off_dpc;
    894 static u_int off_sls;
    895 
    896 /*
    897  * This is the offset of the first byte after the ATM pseudo_header,
    898  * or -1 if there is no ATM pseudo-header.
    899  */
    900 static u_int off_payload;
    901 
    902 /*
    903  * These are offsets to the beginning of the network-layer header.
    904  * They are relative to the beginning of the MAC-layer payload (i.e.,
    905  * they don't include off_ll or off_macpl).
    906  *
    907  * If the link layer never uses 802.2 LLC:
    908  *
    909  *      "off_nl" and "off_nl_nosnap" are the same.
    910  *
    911  * If the link layer always uses 802.2 LLC:
    912  *
    913  *      "off_nl" is the offset if there's a SNAP header following
    914  *      the 802.2 header;
    915  *
    916  *      "off_nl_nosnap" is the offset if there's no SNAP header.
    917  *
    918  * If the link layer is Ethernet:
    919  *
    920  *      "off_nl" is the offset if the packet is an Ethernet II packet
    921  *      (we assume no 802.3+802.2+SNAP);
    922  *
    923  *      "off_nl_nosnap" is the offset if the packet is an 802.3 packet
    924  *      with an 802.2 header following it.
    925  */
    926 static u_int off_nl;
    927 static u_int off_nl_nosnap;
    928 
    929 static int linktype;
    930 
    9311033static void
    932 init_linktype(p)
    933         pcap_t *p;
    934 {
    935         linktype = pcap_datalink(p);
    936 #ifdef PCAP_FDDIPAD
    937         pcap_fddipad = p->fddipad;
    938 #endif
     1034init_linktype(compiler_state_t *cstate, pcap_t *p)
     1035{
     1036        cstate->pcap_fddipad = p->fddipad;
     1037
     1038        /*
     1039         * We start out with only one link-layer header.
     1040         */
     1041        cstate->outermostlinktype = pcap_datalink(p);
     1042        cstate->off_outermostlinkhdr.constant_part = 0;
     1043        cstate->off_outermostlinkhdr.is_variable = 0;
     1044        cstate->off_outermostlinkhdr.reg = -1;
     1045
     1046        cstate->prevlinktype = cstate->outermostlinktype;
     1047        cstate->off_prevlinkhdr.constant_part = 0;
     1048        cstate->off_prevlinkhdr.is_variable = 0;
     1049        cstate->off_prevlinkhdr.reg = -1;
     1050
     1051        cstate->linktype = cstate->outermostlinktype;
     1052        cstate->off_linkhdr.constant_part = 0;
     1053        cstate->off_linkhdr.is_variable = 0;
     1054        cstate->off_linkhdr.reg = -1;
     1055
     1056        /*
     1057         * XXX
     1058         */
     1059        cstate->off_linkpl.constant_part = 0;
     1060        cstate->off_linkpl.is_variable = 0;
     1061        cstate->off_linkpl.reg = -1;
     1062
     1063        cstate->off_linktype.constant_part = 0;
     1064        cstate->off_linktype.is_variable = 0;
     1065        cstate->off_linktype.reg = -1;
    9391066
    9401067        /*
    9411068         * Assume it's not raw ATM with a pseudo-header, for now.
    9421069         */
    943         off_mac = 0;
    944         is_atm = 0;
    945         is_lane = 0;
    946         off_vpi = -1;
    947         off_vci = -1;
    948         off_proto = -1;
    949         off_payload = -1;
     1070        cstate->is_atm = 0;
     1071        cstate->off_vpi = -1;
     1072        cstate->off_vci = -1;
     1073        cstate->off_proto = -1;
     1074        cstate->off_payload = -1;
    9501075
    9511076        /*
    952          * And that we're not doing PPPoE.
     1077         * And not Geneve.
    9531078         */
    954         is_pppoes = 0;
     1079        cstate->is_geneve = 0;
    9551080
    9561081        /*
    9571082         * And assume we're not doing SS7.
    9581083         */
    959         off_li = -1;
    960         off_sio = -1;
    961         off_opc = -1;
    962         off_dpc = -1;
    963         off_sls = -1;
    964 
    965         /*
    966          * Also assume it's not 802.11.
    967          */
    968         off_ll = 0;
    969         off_macpl = 0;
    970         off_macpl_is_variable = 0;
    971 
    972         orig_linktype = -1;
    973         orig_nl = -1;
    974         label_stack_depth = 0;
    975 
    976         reg_off_ll = -1;
    977         reg_off_macpl = -1;
    978 
    979         switch (linktype) {
     1084        cstate->off_li = -1;
     1085        cstate->off_li_hsl = -1;
     1086        cstate->off_sio = -1;
     1087        cstate->off_opc = -1;
     1088        cstate->off_dpc = -1;
     1089        cstate->off_sls = -1;
     1090
     1091        cstate->label_stack_depth = 0;
     1092        cstate->vlan_stack_depth = 0;
     1093
     1094        switch (cstate->linktype) {
    9801095
    9811096        case DLT_ARCNET:
    982                 off_linktype = 2;
    983                 off_macpl = 6;
    984                 off_nl = 0;             /* XXX in reality, variable! */
    985                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    986                 return;
     1097                cstate->off_linktype.constant_part = 2;
     1098                cstate->off_linkpl.constant_part = 6;
     1099                cstate->off_nl = 0;     /* XXX in reality, variable! */
     1100                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1101                break;
    9871102
    9881103        case DLT_ARCNET_LINUX:
    989                 off_linktype = 4;
    990                 off_macpl = 8;
    991                 off_nl = 0;             /* XXX in reality, variable! */
    992                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    993                 return;
     1104                cstate->off_linktype.constant_part = 4;
     1105                cstate->off_linkpl.constant_part = 8;
     1106                cstate->off_nl = 0;             /* XXX in reality, variable! */
     1107                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1108                break;
    9941109
    9951110        case DLT_EN10MB:
    996                 off_linktype = 12;
    997                 off_macpl = 14;         /* Ethernet header length */
    998                 off_nl = 0;             /* Ethernet II */
    999                 off_nl_nosnap = 3;      /* 802.3+802.2 */
    1000                 return;
     1111                cstate->off_linktype.constant_part = 12;
     1112                cstate->off_linkpl.constant_part = 14;  /* Ethernet header length */
     1113                cstate->off_nl = 0;             /* Ethernet II */
     1114                cstate->off_nl_nosnap = 3;      /* 802.3+802.2 */
     1115                break;
    10011116
    10021117        case DLT_SLIP:
     
    10051120                 * header is hacked into our SLIP driver.
    10061121                 */
    1007                 off_linktype = -1;
    1008                 off_macpl = 16;
    1009                 off_nl = 0;
    1010                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1011                 return;
     1122                cstate->off_linktype.constant_part = OFFSET_NOT_SET;
     1123                cstate->off_linkpl.constant_part = 16;
     1124                cstate->off_nl = 0;
     1125                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1126                break;
    10121127
    10131128        case DLT_SLIP_BSDOS:
    10141129                /* XXX this may be the same as the DLT_PPP_BSDOS case */
    1015                 off_linktype = -1;
     1130                cstate->off_linktype.constant_part = OFFSET_NOT_SET;
    10161131                /* XXX end */
    1017                 off_macpl = 24;
    1018                 off_nl = 0;
    1019                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1020                 return;
     1132                cstate->off_linkpl.constant_part = 24;
     1133                cstate->off_nl = 0;
     1134                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1135                break;
    10211136
    10221137        case DLT_NULL:
    10231138        case DLT_LOOP:
    1024                 off_linktype = 0;
    1025                 off_macpl = 4;
    1026                 off_nl = 0;
    1027                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1028                 return;
     1139                cstate->off_linktype.constant_part = 0;
     1140                cstate->off_linkpl.constant_part = 4;
     1141                cstate->off_nl = 0;
     1142                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1143                break;
    10291144
    10301145        case DLT_ENC:
    1031                 off_linktype = 0;
    1032                 off_macpl = 12;
    1033                 off_nl = 0;
    1034                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1035                 return;
     1146                cstate->off_linktype.constant_part = 0;
     1147                cstate->off_linkpl.constant_part = 12;
     1148                cstate->off_nl = 0;
     1149                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1150                break;
    10361151
    10371152        case DLT_PPP:
     
    10391154        case DLT_C_HDLC:                /* BSD/OS Cisco HDLC */
    10401155        case DLT_PPP_SERIAL:            /* NetBSD sync/async serial PPP */
    1041                 off_linktype = 2;
    1042                 off_macpl = 4;
    1043                 off_nl = 0;
    1044                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1045                 return;
     1156                cstate->off_linktype.constant_part = 2; /* skip HDLC-like framing */
     1157                cstate->off_linkpl.constant_part = 4;   /* skip HDLC-like framing and protocol field */
     1158                cstate->off_nl = 0;
     1159                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1160                break;
    10461161
    10471162        case DLT_PPP_ETHER:
     
    10501165                 * only covers session state.
    10511166                 */
    1052                 off_linktype = 6;
    1053                 off_macpl = 8;
    1054                 off_nl = 0;
    1055                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1056                 return;
     1167                cstate->off_linktype.constant_part = 6;
     1168                cstate->off_linkpl.constant_part = 8;
     1169                cstate->off_nl = 0;
     1170                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1171                break;
    10571172
    10581173        case DLT_PPP_BSDOS:
    1059                 off_linktype = 5;
    1060                 off_macpl = 24;
    1061                 off_nl = 0;
    1062                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1063                 return;
     1174                cstate->off_linktype.constant_part = 5;
     1175                cstate->off_linkpl.constant_part = 24;
     1176                cstate->off_nl = 0;
     1177                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1178                break;
    10641179
    10651180        case DLT_FDDI:
     
    10721187                 * XXX - should we generate code to check for SNAP?
    10731188                 */
    1074                 off_linktype = 13;
    1075 #ifdef PCAP_FDDIPAD
    1076                 off_linktype += pcap_fddipad;
    1077 #endif
    1078                 off_macpl = 13;         /* FDDI MAC header length */
    1079 #ifdef PCAP_FDDIPAD
    1080                 off_macpl += pcap_fddipad;
    1081 #endif
    1082                 off_nl = 8;             /* 802.2+SNAP */
    1083                 off_nl_nosnap = 3;      /* 802.2 */
    1084                 return;
     1189                cstate->off_linktype.constant_part = 13;
     1190                cstate->off_linktype.constant_part += cstate->pcap_fddipad;
     1191                cstate->off_linkpl.constant_part = 13;  /* FDDI MAC header length */
     1192                cstate->off_linkpl.constant_part += cstate->pcap_fddipad;
     1193                cstate->off_nl = 8;             /* 802.2+SNAP */
     1194                cstate->off_nl_nosnap = 3;      /* 802.2 */
     1195                break;
    10851196
    10861197        case DLT_IEEE802:
     
    11081219                 * 8 - figure out which byte that is).
    11091220                 */
    1110                 off_linktype = 14;
    1111                 off_macpl = 14;         /* Token Ring MAC header length */
    1112                 off_nl = 8;             /* 802.2+SNAP */
    1113                 off_nl_nosnap = 3;      /* 802.2 */
    1114                 return;
    1115 
    1116         case DLT_IEEE802_11:
     1221                cstate->off_linktype.constant_part = 14;
     1222                cstate->off_linkpl.constant_part = 14;  /* Token Ring MAC header length */
     1223                cstate->off_nl = 8;             /* 802.2+SNAP */
     1224                cstate->off_nl_nosnap = 3;      /* 802.2 */
     1225                break;
     1226
    11171227        case DLT_PRISM_HEADER:
    11181228        case DLT_IEEE802_11_RADIO_AVS:
    11191229        case DLT_IEEE802_11_RADIO:
     1230                cstate->off_linkhdr.is_variable = 1;
     1231                /* Fall through, 802.11 doesn't have a variable link
     1232                 * prefix but is otherwise the same. */
     1233
     1234        case DLT_IEEE802_11:
    11201235                /*
    11211236                 * 802.11 doesn't really have a link-level type field.
    1122                  * We set "off_linktype" to the offset of the LLC header.
     1237                 * We set "off_linktype.constant_part" to the offset of
     1238                 * the LLC header.
    11231239                 *
    11241240                 * To check for Ethernet types, we assume that SSAP = SNAP
     
    11351251                 * variable-length.
    11361252                 */
    1137                 off_linktype = 24;
    1138                 off_macpl = 0;          /* link-layer header is variable-length */
    1139                 off_macpl_is_variable = 1;
    1140                 off_nl = 8;             /* 802.2+SNAP */
    1141                 off_nl_nosnap = 3;      /* 802.2 */
    1142                 return;
     1253                cstate->off_linktype.constant_part = 24;
     1254                cstate->off_linkpl.constant_part = 0;   /* link-layer header is variable-length */
     1255                cstate->off_linkpl.is_variable = 1;
     1256                cstate->off_nl = 8;             /* 802.2+SNAP */
     1257                cstate->off_nl_nosnap = 3;      /* 802.2 */
     1258                break;
    11431259
    11441260        case DLT_PPI:
     
    11521268                 * generate code to check for this too.
    11531269                 */
    1154                 off_linktype = 24;
    1155                 off_macpl = 0;          /* link-layer header is variable-length */
    1156                 off_macpl_is_variable = 1;
    1157                 off_nl = 8;             /* 802.2+SNAP */
    1158                 off_nl_nosnap = 3;      /* 802.2 */
    1159                 return;
     1270                cstate->off_linktype.constant_part = 24;
     1271                cstate->off_linkpl.constant_part = 0;   /* link-layer header is variable-length */
     1272                cstate->off_linkpl.is_variable = 1;
     1273                cstate->off_linkhdr.is_variable = 1;
     1274                cstate->off_nl = 8;             /* 802.2+SNAP */
     1275                cstate->off_nl_nosnap = 3;      /* 802.2 */
     1276                break;
    11601277
    11611278        case DLT_ATM_RFC1483:
     
    11721289                 * PPPo{A,E} and a PPP protocol of IP and....
    11731290                 */
    1174                 off_linktype = 0;
    1175                 off_macpl = 0;          /* packet begins with LLC header */
    1176                 off_nl = 8;             /* 802.2+SNAP */
    1177                 off_nl_nosnap = 3;      /* 802.2 */
    1178                 return;
     1291                cstate->off_linktype.constant_part = 0;
     1292                cstate->off_linkpl.constant_part = 0;   /* packet begins with LLC header */
     1293                cstate->off_nl = 8;             /* 802.2+SNAP */
     1294                cstate->off_nl_nosnap = 3;      /* 802.2 */
     1295                break;
    11791296
    11801297        case DLT_SUNATM:
     
    11831300                 * pseudo-header.
    11841301                 */
    1185                 is_atm = 1;
    1186                 off_vpi = SUNATM_VPI_POS;
    1187                 off_vci = SUNATM_VCI_POS;
    1188                 off_proto = PROTO_POS;
    1189                 off_mac = -1;   /* assume LLC-encapsulated, so no MAC-layer header */
    1190                 off_payload = SUNATM_PKT_BEGIN_POS;
    1191                 off_linktype = off_payload;
    1192                 off_macpl = off_payload;        /* if LLC-encapsulated */
    1193                 off_nl = 8;             /* 802.2+SNAP */
    1194                 off_nl_nosnap = 3;      /* 802.2 */
    1195                 return;
     1302                cstate->is_atm = 1;
     1303                cstate->off_vpi = SUNATM_VPI_POS;
     1304                cstate->off_vci = SUNATM_VCI_POS;
     1305                cstate->off_proto = PROTO_POS;
     1306                cstate->off_payload = SUNATM_PKT_BEGIN_POS;
     1307                cstate->off_linktype.constant_part = cstate->off_payload;
     1308                cstate->off_linkpl.constant_part = cstate->off_payload; /* if LLC-encapsulated */
     1309                cstate->off_nl = 8;             /* 802.2+SNAP */
     1310                cstate->off_nl_nosnap = 3;      /* 802.2 */
     1311                break;
    11961312
    11971313        case DLT_RAW:
    11981314        case DLT_IPV4:
    11991315        case DLT_IPV6:
    1200                 off_linktype = -1;
    1201                 off_macpl = 0;
    1202                 off_nl = 0;
    1203                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1204                 return;
     1316                cstate->off_linktype.constant_part = OFFSET_NOT_SET;
     1317                cstate->off_linkpl.constant_part = 0;
     1318                cstate->off_nl = 0;
     1319                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1320                break;
    12051321
    12061322        case DLT_LINUX_SLL:     /* fake header for Linux cooked socket */
    1207                 off_linktype = 14;
    1208                 off_macpl = 16;
    1209                 off_nl = 0;
    1210                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1211                 return;
     1323                cstate->off_linktype.constant_part = 14;
     1324                cstate->off_linkpl.constant_part = 16;
     1325                cstate->off_nl = 0;
     1326                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1327                break;
    12121328
    12131329        case DLT_LTALK:
     
    12171333                 * "long" DDP packet following.
    12181334                 */
    1219                 off_linktype = -1;
    1220                 off_macpl = 0;
    1221                 off_nl = 0;
    1222                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1223                 return;
     1335                cstate->off_linktype.constant_part = OFFSET_NOT_SET;
     1336                cstate->off_linkpl.constant_part = 0;
     1337                cstate->off_nl = 0;
     1338                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1339                break;
    12241340
    12251341        case DLT_IP_OVER_FC:
     
    12341350                 * 2625 says SNAP should be used.
    12351351                 */
    1236                 off_linktype = 16;
    1237                 off_macpl = 16;
    1238                 off_nl = 8;             /* 802.2+SNAP */
    1239                 off_nl_nosnap = 3;      /* 802.2 */
    1240                 return;
     1352                cstate->off_linktype.constant_part = 16;
     1353                cstate->off_linkpl.constant_part = 16;
     1354                cstate->off_nl = 8;             /* 802.2+SNAP */
     1355                cstate->off_nl_nosnap = 3;      /* 802.2 */
     1356                break;
    12411357
    12421358        case DLT_FRELAY:
     
    12451361                 * frames (NLPID of 0x80).
    12461362                 */
    1247                 off_linktype = -1;
    1248                 off_macpl = 0;
    1249                 off_nl = 0;
    1250                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1251                 return;
     1363                cstate->off_linktype.constant_part = OFFSET_NOT_SET;
     1364                cstate->off_linkpl.constant_part = 0;
     1365                cstate->off_nl = 0;
     1366                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1367                break;
    12521368
    12531369                /*
     
    12571373                 */
    12581374        case DLT_MFR:
    1259                 off_linktype = -1;
    1260                 off_macpl = 0;
    1261                 off_nl = 4;
    1262                 off_nl_nosnap = 0;      /* XXX - for now -> no 802.2 LLC */
    1263                 return;
     1375                cstate->off_linktype.constant_part = OFFSET_NOT_SET;
     1376                cstate->off_linkpl.constant_part = 0;
     1377                cstate->off_nl = 4;
     1378                cstate->off_nl_nosnap = 0;      /* XXX - for now -> no 802.2 LLC */
     1379                break;
    12641380
    12651381        case DLT_APPLE_IP_OVER_IEEE1394:
    1266                 off_linktype = 16;
    1267                 off_macpl = 18;
    1268                 off_nl = 0;
    1269                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1270                 return;
     1382                cstate->off_linktype.constant_part = 16;
     1383                cstate->off_linkpl.constant_part = 18;
     1384                cstate->off_nl = 0;
     1385                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1386                break;
    12711387
    12721388        case DLT_SYMANTEC_FIREWALL:
    1273                 off_linktype = 6;
    1274                 off_macpl = 44;
    1275                 off_nl = 0;             /* Ethernet II */
    1276                 off_nl_nosnap = 0;      /* XXX - what does it do with 802.3 packets? */
    1277                 return;
     1389                cstate->off_linktype.constant_part = 6;
     1390                cstate->off_linkpl.constant_part = 44;
     1391                cstate->off_nl = 0;             /* Ethernet II */
     1392                cstate->off_nl_nosnap = 0;      /* XXX - what does it do with 802.3 packets? */
     1393                break;
    12781394
    12791395#ifdef HAVE_NET_PFVAR_H
    12801396        case DLT_PFLOG:
    1281                 off_linktype = 0;
    1282                 off_macpl = PFLOG_HDRLEN;
    1283                 off_nl = 0;
    1284                 off_nl_nosnap = 0;      /* no 802.2 LLC */
    1285                 return;
     1397                cstate->off_linktype.constant_part = 0;
     1398                cstate->off_linkpl.constant_part = PFLOG_HDRLEN;
     1399                cstate->off_nl = 0;
     1400                cstate->off_nl_nosnap = 0;      /* no 802.2 LLC */
     1401                break;
    12861402#endif
    12871403
     
    12921408        case DLT_JUNIPER_CHDLC:
    12931409        case DLT_JUNIPER_FRELAY:
    1294                 off_linktype = 4;
    1295                 off_macpl = 4;
    1296                 off_nl = 0;
    1297                 off_nl_nosnap = -1;     /* no 802.2 LLC */
    1298                 return;
     1410                cstate->off_linktype.constant_part = 4;
     1411                cstate->off_linkpl.constant_part = 4;
     1412                cstate->off_nl = 0;
     1413                cstate->off_nl_nosnap = -1;     /* no 802.2 LLC */
     1414                break;
    12991415
    13001416        case DLT_JUNIPER_ATM1:
    1301                 off_linktype = 4;       /* in reality variable between 4-8 */
    1302                 off_macpl = 4;  /* in reality variable between 4-8 */
    1303                 off_nl = 0;
    1304                 off_nl_nosnap = 10;
    1305                 return;
     1417                cstate->off_linktype.constant_part = 4;         /* in reality variable between 4-8 */
     1418                cstate->off_linkpl.constant_part = 4;   /* in reality variable between 4-8 */
     1419                cstate->off_nl = 0;
     1420                cstate->off_nl_nosnap = 10;
     1421                break;
    13061422
    13071423        case DLT_JUNIPER_ATM2:
    1308                 off_linktype = 8;       /* in reality variable between 8-12 */
    1309                 off_macpl = 8;  /* in reality variable between 8-12 */
    1310                 off_nl = 0;
    1311                 off_nl_nosnap = 10;
    1312                 return;
     1424                cstate->off_linktype.constant_part = 8;         /* in reality variable between 8-12 */
     1425                cstate->off_linkpl.constant_part = 8;   /* in reality variable between 8-12 */
     1426                cstate->off_nl = 0;
     1427                cstate->off_nl_nosnap = 10;
     1428                break;
    13131429
    13141430                /* frames captured on a Juniper PPPoE service PIC
     
    13161432        case DLT_JUNIPER_PPPOE:
    13171433        case DLT_JUNIPER_ETHER:
    1318                 off_macpl = 14;
    1319                 off_linktype = 16;
    1320                 off_nl = 18;            /* Ethernet II */
    1321                 off_nl_nosnap = 21;     /* 802.3+802.2 */
    1322                 return;
     1434                cstate->off_linkpl.constant_part = 14;
     1435                cstate->off_linktype.constant_part = 16;
     1436                cstate->off_nl = 18;            /* Ethernet II */
     1437                cstate->off_nl_nosnap = 21;     /* 802.3+802.2 */
     1438                break;
    13231439
    13241440        case DLT_JUNIPER_PPPOE_ATM:
    1325                 off_linktype = 4;
    1326                 off_macpl = 6;
    1327                 off_nl = 0;
    1328                 off_nl_nosnap = -1;     /* no 802.2 LLC */
    1329                 return;
     1441                cstate->off_linktype.constant_part = 4;
     1442                cstate->off_linkpl.constant_part = 6;
     1443                cstate->off_nl = 0;
     1444                cstate->off_nl_nosnap = -1;     /* no 802.2 LLC */
     1445                break;
    13301446
    13311447        case DLT_JUNIPER_GGSN:
    1332                 off_linktype = 6;
    1333                 off_macpl = 12;
    1334                 off_nl = 0;
    1335                 off_nl_nosnap = -1;     /* no 802.2 LLC */
    1336                 return;
     1448                cstate->off_linktype.constant_part = 6;
     1449                cstate->off_linkpl.constant_part = 12;
     1450                cstate->off_nl = 0;
     1451                cstate->off_nl_nosnap = -1;     /* no 802.2 LLC */
     1452                break;
    13371453
    13381454        case DLT_JUNIPER_ES:
    1339                 off_linktype = 6;
    1340                 off_macpl = -1;         /* not really a network layer but raw IP addresses */
    1341                 off_nl = -1;            /* not really a network layer but raw IP addresses */
    1342                 off_nl_nosnap = -1;     /* no 802.2 LLC */
    1343                 return;
     1455                cstate->off_linktype.constant_part = 6;
     1456                cstate->off_linkpl.constant_part = OFFSET_NOT_SET;      /* not really a network layer but raw IP addresses */
     1457                cstate->off_nl = -1;            /* not really a network layer but raw IP addresses */
     1458                cstate->off_nl_nosnap = -1;     /* no 802.2 LLC */
     1459                break;
    13441460
    13451461        case DLT_JUNIPER_MONITOR:
    1346                 off_linktype = 12;
    1347                 off_macpl = 12;
    1348                 off_nl = 0;             /* raw IP/IP6 header */
    1349                 off_nl_nosnap = -1;     /* no 802.2 LLC */
    1350                 return;
     1462                cstate->off_linktype.constant_part = 12;
     1463                cstate->off_linkpl.constant_part = 12;
     1464                cstate->off_nl = 0;             /* raw IP/IP6 header */
     1465                cstate->off_nl_nosnap = -1;     /* no 802.2 LLC */
     1466                break;
     1467
     1468        case DLT_BACNET_MS_TP:
     1469                cstate->off_linktype.constant_part = OFFSET_NOT_SET;
     1470                cstate->off_linkpl.constant_part = OFFSET_NOT_SET;
     1471                cstate->off_nl = -1;
     1472                cstate->off_nl_nosnap = -1;
     1473                break;
    13511474
    13521475        case DLT_JUNIPER_SERVICES:
    1353                 off_linktype = 12;
    1354                 off_macpl = -1;         /* L3 proto location dep. on cookie type */
    1355                 off_nl = -1;            /* L3 proto location dep. on cookie type */
    1356                 off_nl_nosnap = -1;     /* no 802.2 LLC */
    1357                 return;
     1476                cstate->off_linktype.constant_part = 12;
     1477                cstate->off_linkpl.constant_part = OFFSET_NOT_SET;      /* L3 proto location dep. on cookie type */
     1478                cstate->off_nl = -1;            /* L3 proto location dep. on cookie type */
     1479                cstate->off_nl_nosnap = -1;     /* no 802.2 LLC */
     1480                break;
    13581481
    13591482        case DLT_JUNIPER_VP:
    1360                 off_linktype = 18;
    1361                 off_macpl = -1;
    1362                 off_nl = -1;
    1363                 off_nl_nosnap = -1;
    1364                 return;
     1483                cstate->off_linktype.constant_part = 18;
     1484                cstate->off_linkpl.constant_part = OFFSET_NOT_SET;
     1485                cstate->off_nl = -1;
     1486                cstate->off_nl_nosnap = -1;
     1487                break;
    13651488
    13661489        case DLT_JUNIPER_ST:
    1367                 off_linktype = 18;
    1368                 off_macpl = -1;
    1369                 off_nl = -1;
    1370                 off_nl_nosnap = -1;
    1371                 return;
     1490                cstate->off_linktype.constant_part = 18;
     1491                cstate->off_linkpl.constant_part = OFFSET_NOT_SET;
     1492                cstate->off_nl = -1;
     1493                cstate->off_nl_nosnap = -1;
     1494                break;
    13721495
    13731496        case DLT_JUNIPER_ISM:
    1374                 off_linktype = 8;
    1375                 off_macpl = -1;
    1376                 off_nl = -1;
    1377                 off_nl_nosnap = -1;
    1378                 return;
     1497                cstate->off_linktype.constant_part = 8;
     1498                cstate->off_linkpl.constant_part = OFFSET_NOT_SET;
     1499                cstate->off_nl = -1;
     1500                cstate->off_nl_nosnap = -1;
     1501                break;
    13791502
    13801503        case DLT_JUNIPER_VS:
     
    13821505        case DLT_JUNIPER_FIBRECHANNEL:
    13831506        case DLT_JUNIPER_ATM_CEMIC:
    1384                 off_linktype = 8;
    1385                 off_macpl = -1;
    1386                 off_nl = -1;
    1387                 off_nl_nosnap = -1;
    1388                 return;
     1507                cstate->off_linktype.constant_part = 8;
     1508                cstate->off_linkpl.constant_part = OFFSET_NOT_SET;
     1509                cstate->off_nl = -1;
     1510                cstate->off_nl_nosnap = -1;
     1511                break;
    13891512
    13901513        case DLT_MTP2:
    1391                 off_li = 2;
    1392                 off_sio = 3;
    1393                 off_opc = 4;
    1394                 off_dpc = 4;
    1395                 off_sls = 7;
    1396                 off_linktype = -1;
    1397                 off_macpl = -1;
    1398                 off_nl = -1;
    1399                 off_nl_nosnap = -1;
    1400                 return;
     1514                cstate->off_li = 2;
     1515                cstate->off_li_hsl = 4;
     1516                cstate->off_sio = 3;
     1517                cstate->off_opc = 4;
     1518                cstate->off_dpc = 4;
     1519                cstate->off_sls = 7;
     1520                cstate->off_linktype.constant_part = OFFSET_NOT_SET;
     1521                cstate->off_linkpl.constant_part = OFFSET_NOT_SET;
     1522                cstate->off_nl = -1;
     1523                cstate->off_nl_nosnap = -1;
     1524                break;
    14011525
    14021526        case DLT_MTP2_WITH_PHDR:
    1403                 off_li = 6;
    1404                 off_sio = 7;
    1405                 off_opc = 8;
    1406                 off_dpc = 8;
    1407                 off_sls = 11;
    1408                 off_linktype = -1;
    1409                 off_macpl = -1;
    1410                 off_nl = -1;
    1411                 off_nl_nosnap = -1;
    1412                 return;
     1527                cstate->off_li = 6;
     1528                cstate->off_li_hsl = 8;
     1529                cstate->off_sio = 7;
     1530                cstate->off_opc = 8;
     1531                cstate->off_dpc = 8;
     1532                cstate->off_sls = 11;
     1533                cstate->off_linktype.constant_part = OFFSET_NOT_SET;
     1534                cstate->off_linkpl.constant_part = OFFSET_NOT_SET;
     1535                cstate->off_nl = -1;
     1536                cstate->off_nl_nosnap = -1;
     1537                break;
    14131538
    14141539        case DLT_ERF:
    1415                 off_li = 22;
    1416                 off_sio = 23;
    1417                 off_opc = 24;
    1418                 off_dpc = 24;
    1419                 off_sls = 27;
    1420                 off_linktype = -1;
    1421                 off_macpl = -1;
    1422                 off_nl = -1;
    1423                 off_nl_nosnap = -1;
    1424                 return;
     1540                cstate->off_li = 22;
     1541                cstate->off_li_hsl = 24;
     1542                cstate->off_sio = 23;
     1543                cstate->off_opc = 24;
     1544                cstate->off_dpc = 24;
     1545                cstate->off_sls = 27;
     1546                cstate->off_linktype.constant_part = OFFSET_NOT_SET;
     1547                cstate->off_linkpl.constant_part = OFFSET_NOT_SET;
     1548                cstate->off_nl = -1;
     1549                cstate->off_nl_nosnap = -1;
     1550                break;
    14251551
    14261552        case DLT_PFSYNC:
    1427                 off_linktype = -1;
    1428                 off_macpl = 4;
    1429                 off_nl = 0;
    1430                 off_nl_nosnap = 0;
    1431                 return;
     1553                cstate->off_linktype.constant_part = OFFSET_NOT_SET;
     1554                cstate->off_linkpl.constant_part = 4;
     1555                cstate->off_nl = 0;
     1556                cstate->off_nl_nosnap = 0;
     1557                break;
    14321558
    14331559        case DLT_AX25_KISS:
     
    14351561                 * Currently, only raw "link[N:M]" filtering is supported.
    14361562                 */
    1437                 off_linktype = -1;      /* variable, min 15, max 71 steps of 7 */
    1438                 off_macpl = -1;
    1439                 off_nl = -1;            /* variable, min 16, max 71 steps of 7 */
    1440                 off_nl_nosnap = -1;     /* no 802.2 LLC */
    1441                 off_mac = 1;            /* step over the kiss length byte */
    1442                 return;
     1563                cstate->off_linktype.constant_part = OFFSET_NOT_SET;    /* variable, min 15, max 71 steps of 7 */
     1564                cstate->off_linkpl.constant_part = OFFSET_NOT_SET;
     1565                cstate->off_nl = -1;            /* variable, min 16, max 71 steps of 7 */
     1566                cstate->off_nl_nosnap = -1;     /* no 802.2 LLC */
     1567                break;
    14431568
    14441569        case DLT_IPNET:
    1445                 off_linktype = 1;
    1446                 off_macpl = 24;         /* ipnet header length */
    1447                 off_nl = 0;
    1448                 off_nl_nosnap = -1;
    1449                 return;
     1570                cstate->off_linktype.constant_part = 1;
     1571                cstate->off_linkpl.constant_part = 24;  /* ipnet header length */
     1572                cstate->off_nl = 0;
     1573                cstate->off_nl_nosnap = -1;
     1574                break;
    14501575
    14511576        case DLT_NETANALYZER:
    1452                 off_mac = 4;            /* MAC header is past 4-byte pseudo-header */
    1453                 off_linktype = 16;      /* includes 4-byte pseudo-header */
    1454                 off_macpl = 18;         /* pseudo-header+Ethernet header length */
    1455                 off_nl = 0;             /* Ethernet II */
    1456                 off_nl_nosnap = 3;      /* 802.3+802.2 */
    1457                 return;
     1577                cstate->off_linkhdr.constant_part = 4;  /* Ethernet header is past 4-byte pseudo-header */
     1578                cstate->off_linktype.constant_part = cstate->off_linkhdr.constant_part + 12;
     1579                cstate->off_linkpl.constant_part = cstate->off_linkhdr.constant_part + 14;      /* pseudo-header+Ethernet header length */
     1580                cstate->off_nl = 0;             /* Ethernet II */
     1581                cstate->off_nl_nosnap = 3;      /* 802.3+802.2 */
     1582                break;
    14581583
    14591584        case DLT_NETANALYZER_TRANSPARENT:
    1460                 off_mac = 12;           /* MAC header is past 4-byte pseudo-header, preamble, and SFD */
    1461                 off_linktype = 24;      /* includes 4-byte pseudo-header+preamble+SFD */
    1462                 off_macpl = 26;         /* pseudo-header+preamble+SFD+Ethernet header length */
    1463                 off_nl = 0;             /* Ethernet II */
    1464                 off_nl_nosnap = 3;      /* 802.3+802.2 */
    1465                 return;
     1585                cstate->off_linkhdr.constant_part = 12; /* MAC header is past 4-byte pseudo-header, preamble, and SFD */
     1586                cstate->off_linktype.constant_part = cstate->off_linkhdr.constant_part + 12;
     1587                cstate->off_linkpl.constant_part = cstate->off_linkhdr.constant_part + 14;      /* pseudo-header+preamble+SFD+Ethernet header length */
     1588                cstate->off_nl = 0;             /* Ethernet II */
     1589                cstate->off_nl_nosnap = 3;      /* 802.3+802.2 */
     1590                break;
    14661591
    14671592        default:
     
    14701595                 * DLT_ values, only raw "link[N:M]" filtering is supported.
    14711596                 */
    1472                 if (linktype >= DLT_MATCHING_MIN &&
    1473                     linktype <= DLT_MATCHING_MAX) {
    1474                         off_linktype = -1;
    1475                         off_macpl = -1;
    1476                         off_nl = -1;
    1477                         off_nl_nosnap = -1;
    1478                         return;
     1597                if (cstate->linktype >= DLT_MATCHING_MIN &&
     1598                    cstate->linktype <= DLT_MATCHING_MAX) {
     1599                        cstate->off_linktype.constant_part = OFFSET_NOT_SET;
     1600                        cstate->off_linkpl.constant_part = OFFSET_NOT_SET;
     1601                        cstate->off_nl = -1;
     1602                        cstate->off_nl_nosnap = -1;
     1603                } else {
     1604                        bpf_error(cstate, "unknown data link type %d", cstate->linktype);
    14791605                }
    1480 
    1481         }
    1482         bpf_error("unknown data link type %d", linktype);
    1483         /* NOTREACHED */
     1606                break;
     1607        }
     1608
     1609        cstate->off_outermostlinkhdr = cstate->off_prevlinkhdr = cstate->off_linkhdr;
    14841610}
    14851611
    14861612/*
    1487  * Load a value relative to the beginning of the link-layer header.
    1488  * The link-layer header doesn't necessarily begin at the beginning
    1489  * of the packet data; there might be a variable-length prefix containing
    1490  * radio information.
     1613 * Load a value relative to the specified absolute offset.
    14911614 */
    14921615static struct slist *
    1493 gen_load_llrel(offset, size)
    1494         u_int offset, size;
     1616gen_load_absoffsetrel(compiler_state_t *cstate, bpf_abs_offset *abs_offset,
     1617    u_int offset, u_int size)
    14951618{
    14961619        struct slist *s, *s2;
    14971620
    1498         s = gen_llprefixlen();
     1621        s = gen_abs_offset_varpart(cstate, abs_offset);
    14991622
    15001623        /*
    15011624         * If "s" is non-null, it has code to arrange that the X register
    1502          * contains the length of the prefix preceding the link-layer
    1503          * header.
     1625         * contains the variable part of the absolute offset, so we
     1626         * generate a load relative to that, with an offset of
     1627         * abs_offset->constant_part + offset.
    15041628         *
    1505          * Otherwise, the length of the prefix preceding the link-layer
    1506          * header is "off_ll".
     1629         * Otherwise, we can do an absolute load with an offset of
     1630         * abs_offset->constant_part + offset.
    15071631         */
    15081632        if (s != NULL) {
    15091633                /*
    1510                  * There's a variable-length prefix preceding the
    1511                  * link-layer header.  "s" points to a list of statements
    1512                  * that put the length of that prefix into the X register.
    1513                  * do an indirect load, to use the X register as an offset.
    1514                  */
    1515                 s2 = new_stmt(BPF_LD|BPF_IND|size);
    1516                 s2->s.k = offset;
     1634                 * "s" points to a list of statements that puts the
     1635                 * variable part of the absolute offset into the X register.
     1636                 * Do an indirect load, to use the X register as an offset.
     1637                 */
     1638                s2 = new_stmt(cstate, BPF_LD|BPF_IND|size);
     1639                s2->s.k = abs_offset->constant_part + offset;
    15171640                sappend(s, s2);
    15181641        } else {
    15191642                /*
    1520                  * There is no variable-length header preceding the
    1521                  * link-layer header; add in off_ll, which, if there's
    1522                  * a fixed-length header preceding the link-layer header,
    1523                  * is the length of that header.
    1524                  */
    1525                 s = new_stmt(BPF_LD|BPF_ABS|size);
    1526                 s->s.k = offset + off_ll;
    1527         }
    1528         return s;
    1529 }
    1530 
    1531 /*
    1532  * Load a value relative to the beginning of the MAC-layer payload.
    1533  */
    1534 static struct slist *
    1535 gen_load_macplrel(offset, size)
    1536         u_int offset, size;
    1537 {
    1538         struct slist *s, *s2;
    1539 
    1540         s = gen_off_macpl();
    1541 
    1542         /*
    1543          * If s is non-null, the offset of the MAC-layer payload is
    1544          * variable, and s points to a list of instructions that
    1545          * arrange that the X register contains that offset.
    1546          *
    1547          * Otherwise, the offset of the MAC-layer payload is constant,
    1548          * and is in off_macpl.
    1549          */
    1550         if (s != NULL) {
    1551                 /*
    1552                  * The offset of the MAC-layer payload is in the X
    1553                  * register.  Do an indirect load, to use the X register
    1554                  * as an offset.
    1555                  */
    1556                 s2 = new_stmt(BPF_LD|BPF_IND|size);
    1557                 s2->s.k = offset;
    1558                 sappend(s, s2);
    1559         } else {
    1560                 /*
    1561                  * The offset of the MAC-layer payload is constant,
    1562                  * and is in off_macpl; load the value at that offset
    1563                  * plus the specified offset.
    1564                  */
    1565                 s = new_stmt(BPF_LD|BPF_ABS|size);
    1566                 s->s.k = off_macpl + offset;
     1643                 * There is no variable part of the absolute offset, so
     1644                 * just do an absolute load.
     1645                 */
     1646                s = new_stmt(cstate, BPF_LD|BPF_ABS|size);
     1647                s->s.k = abs_offset->constant_part + offset;
    15671648        }
    15681649        return s;
     
    15731654 */
    15741655static struct slist *
    1575 gen_load_a(offrel, offset, size)
    1576         enum e_offrel offrel;
    1577         u_int offset, size;
     1656gen_load_a(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,
     1657    u_int size)
    15781658{
    15791659        struct slist *s, *s2;
     
    15821662
    15831663        case OR_PACKET:
    1584                 s = new_stmt(BPF_LD|BPF_ABS|size);
     1664                s = new_stmt(cstate, BPF_LD|BPF_ABS|size);
    15851665                s->s.k = offset;
    15861666                break;
    15871667
    1588         case OR_LINK:
    1589                 s = gen_load_llrel(offset, size);
    1590                 break;
    1591 
    1592         case OR_MACPL:
    1593                 s = gen_load_macplrel(offset, size);
    1594                 break;
    1595 
    1596         case OR_NET:
    1597                 s = gen_load_macplrel(off_nl + offset, size);
    1598                 break;
    1599 
    1600         case OR_NET_NOSNAP:
    1601                 s = gen_load_macplrel(off_nl_nosnap + offset, size);
     1668        case OR_LINKHDR:
     1669                s = gen_load_absoffsetrel(cstate, &cstate->off_linkhdr, offset, size);
     1670                break;
     1671
     1672        case OR_PREVLINKHDR:
     1673                s = gen_load_absoffsetrel(cstate, &cstate->off_prevlinkhdr, offset, size);
     1674                break;
     1675
     1676        case OR_LLC:
     1677                s = gen_load_absoffsetrel(cstate, &cstate->off_linkpl, offset, size);
     1678                break;
     1679
     1680        case OR_PREVMPLSHDR:
     1681                s = gen_load_absoffsetrel(cstate, &cstate->off_linkpl, cstate->off_nl - 4 + offset, size);
     1682                break;
     1683
     1684        case OR_LINKPL:
     1685                s = gen_load_absoffsetrel(cstate, &cstate->off_linkpl, cstate->off_nl + offset, size);
     1686                break;
     1687
     1688        case OR_LINKPL_NOSNAP:
     1689                s = gen_load_absoffsetrel(cstate, &cstate->off_linkpl, cstate->off_nl_nosnap + offset, size);
     1690                break;
     1691
     1692        case OR_LINKTYPE:
     1693                s = gen_load_absoffsetrel(cstate, &cstate->off_linktype, offset, size);
    16021694                break;
    16031695
     
    16091701                 * header), in bytes.
    16101702                 */
    1611                 s = gen_loadx_iphdrlen();
    1612 
    1613                 /*
    1614                  * Load the item at {offset of the MAC-layer payload} +
    1615                  * {offset, relative to the start of the MAC-layer
     1703                s = gen_loadx_iphdrlen(cstate);
     1704
     1705                /*
     1706                 * Load the item at {offset of the link-layer payload} +
     1707                 * {offset, relative to the start of the link-layer
    16161708                 * paylod, of the IPv4 header} + {length of the IPv4 header} +
    16171709                 * {specified offset}.
    16181710                 *
    1619                  * (If the offset of the MAC-layer payload is variable,
    1620                  * it's included in the value in the X register, and
    1621                  * off_macpl is 0.)
    1622                  */
    1623                 s2 = new_stmt(BPF_LD|BPF_IND|size);
    1624                 s2->s.k = off_macpl + off_nl + offset;
     1711                 * If the offset of the link-layer payload is variable,
     1712                 * the variable part of that offset is included in the
     1713                 * value in the X register, and we include the constant
     1714                 * part in the offset of the load.
     1715                 */
     1716                s2 = new_stmt(cstate, BPF_LD|BPF_IND|size);
     1717                s2->s.k = cstate->off_linkpl.constant_part + cstate->off_nl + offset;
    16251718                sappend(s, s2);
    16261719                break;
    16271720
    16281721        case OR_TRAN_IPV6:
    1629                 s = gen_load_macplrel(off_nl + 40 + offset, size);
     1722                s = gen_load_absoffsetrel(cstate, &cstate->off_linkpl, cstate->off_nl + 40 + offset, size);
    16301723                break;
    16311724
     
    16391732/*
    16401733 * Generate code to load into the X register the sum of the length of
    1641  * the IPv4 header and any variable-length header preceding the link-layer
    1642  * header.
     1734 * the IPv4 header and the variable part of the offset of the link-layer
     1735 * payload.
    16431736 */
    16441737static struct slist *
    1645 gen_loadx_iphdrlen()
     1738gen_loadx_iphdrlen(compiler_state_t *cstate)
    16461739{
    16471740        struct slist *s, *s2;
    16481741
    1649         s = gen_off_macpl();
     1742        s = gen_abs_offset_varpart(cstate, &cstate->off_linkpl);
    16501743        if (s != NULL) {
    16511744                /*
    1652                  * There's a variable-length prefix preceding the
    1653                  * link-layer header, or the link-layer header is itself
    1654                  * variable-length.  "s" points to a list of statements
    1655                  * that put the offset of the MAC-layer payload into
    1656                  * the X register.
     1745                 * The offset of the link-layer payload has a variable
     1746                 * part.  "s" points to a list of statements that put
     1747                 * the variable part of that offset into the X register.
    16571748                 *
    16581749                 * The 4*([k]&0xf) addressing mode can't be used, as we
     
    16611752                 * the value from the X register.
    16621753                 */
    1663                 s2 = new_stmt(BPF_LD|BPF_IND|BPF_B);
    1664                 s2->s.k = off_nl;
     1754                s2 = new_stmt(cstate, BPF_LD|BPF_IND|BPF_B);
     1755                s2->s.k = cstate->off_linkpl.constant_part + cstate->off_nl;
    16651756                sappend(s, s2);
    1666                 s2 = new_stmt(BPF_ALU|BPF_AND|BPF_K);
     1757                s2 = new_stmt(cstate, BPF_ALU|BPF_AND|BPF_K);
    16671758                s2->s.k = 0xf;
    16681759                sappend(s, s2);
    1669                 s2 = new_stmt(BPF_ALU|BPF_LSH|BPF_K);
     1760                s2 = new_stmt(cstate, BPF_ALU|BPF_LSH|BPF_K);
    16701761                s2->s.k = 2;
    16711762                sappend(s, s2);
    16721763
    16731764                /*
    1674                  * The A register now contains the length of the
    1675                  * IP header.  We need to add to it the offset of
    1676                  * the MAC-layer payload, which is still in the X
     1765                 * The A register now contains the length of the IP header.
     1766                 * We need to add to it the variable part of the offset of
     1767                 * the link-layer payload, which is still in the X
    16771768                 * register, and move the result into the X register.
    16781769                 */
    1679                 sappend(s, new_stmt(BPF_ALU|BPF_ADD|BPF_X));
    1680                 sappend(s, new_stmt(BPF_MISC|BPF_TAX));
     1770                sappend(s, new_stmt(cstate, BPF_ALU|BPF_ADD|BPF_X));
     1771                sappend(s, new_stmt(cstate, BPF_MISC|BPF_TAX));
    16811772        } else {
    16821773                /*
    1683                  * There is no variable-length header preceding the
    1684                  * link-layer header, and the link-layer header is
    1685                  * fixed-length; load the length of the IPv4 header,
    1686                  * which is at an offset of off_nl from the beginning
    1687                  * of the MAC-layer payload, and thus at an offset
    1688                  * of off_mac_pl + off_nl from the beginning of the
    1689                  * raw packet data.
    1690                  */
    1691                 s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
    1692                 s->s.k = off_macpl + off_nl;
     1774                 * The offset of the link-layer payload is a constant,
     1775                 * so no code was generated to load the (non-existent)
     1776                 * variable part of that offset.
     1777                 *
     1778                 * This means we can use the 4*([k]&0xf) addressing
     1779                 * mode.  Load the length of the IPv4 header, which
     1780                 * is at an offset of cstate->off_nl from the beginning of
     1781                 * the link-layer payload, and thus at an offset of
     1782                 * cstate->off_linkpl.constant_part + cstate->off_nl from the beginning
     1783                 * of the raw packet data, using that addressing mode.
     1784                 */
     1785                s = new_stmt(cstate, BPF_LDX|BPF_MSH|BPF_B);
     1786                s->s.k = cstate->off_linkpl.constant_part + cstate->off_nl;
    16931787        }
    16941788        return s;
     
    16961790
    16971791static struct block *
    1698 gen_uncond(rsense)
    1699         int rsense;
     1792gen_uncond(compiler_state_t *cstate, int rsense)
    17001793{
    17011794        struct block *b;
    17021795        struct slist *s;
    17031796
    1704         s = new_stmt(BPF_LD|BPF_IMM);
     1797        s = new_stmt(cstate, BPF_LD|BPF_IMM);
    17051798        s->s.k = !rsense;
    1706         b = new_block(JMP(BPF_JEQ));
     1799        b = new_block(cstate, JMP(BPF_JEQ));
    17071800        b->stmts = s;
    17081801
     
    17111804
    17121805static inline struct block *
    1713 gen_true()
    1714 {
    1715         return gen_uncond(1);
     1806gen_true(compiler_state_t *cstate)
     1807{
     1808        return gen_uncond(cstate, 1);
    17161809}
    17171810
    17181811static inline struct block *
    1719 gen_false()
    1720 {
    1721         return gen_uncond(0);
     1812gen_false(compiler_state_t *cstate)
     1813{
     1814        return gen_uncond(cstate, 0);
    17221815}
    17231816
     
    17401833 */
    17411834static struct block *
    1742 gen_ether_linktype(proto)
    1743         register int proto;
     1835gen_ether_linktype(compiler_state_t *cstate, int proto)
    17441836{
    17451837        struct block *b0, *b1;
     
    17621854                 * (i.e., other SAP values)?
    17631855                 */
    1764                 b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
     1856                b0 = gen_cmp_gt(cstate, OR_LINKTYPE, 0, BPF_H, ETHERMTU);
    17651857                gen_not(b0);
    1766                 b1 = gen_cmp(OR_MACPL, 0, BPF_H, (bpf_int32)
     1858                b1 = gen_cmp(cstate, OR_LLC, 0, BPF_H, (bpf_int32)
    17671859                             ((proto << 8) | proto));
    17681860                gen_and(b0, b1);
     
    18021894                 * IPX LSAP (Ethernet_802.2) and for Ethernet_802.3.
    18031895                 */
    1804                 b0 = gen_cmp(OR_MACPL, 0, BPF_B, (bpf_int32)LLCSAP_IPX);
    1805                 b1 = gen_cmp(OR_MACPL, 0, BPF_H, (bpf_int32)0xFFFF);
     1896                b0 = gen_cmp(cstate, OR_LLC, 0, BPF_B, (bpf_int32)LLCSAP_IPX);
     1897                b1 = gen_cmp(cstate, OR_LLC, 0, BPF_H, (bpf_int32)0xFFFF);
    18061898                gen_or(b0, b1);
    18071899
     
    18101902                 * ETHERTYPE_IPX, i.e. Ethernet_SNAP.
    18111903                 */
    1812                 b0 = gen_snap(0x000000, ETHERTYPE_IPX);
     1904                b0 = gen_snap(cstate, 0x000000, ETHERTYPE_IPX);
    18131905                gen_or(b0, b1);
    18141906
     
    18171909                 * frames in general.
    18181910                 */
    1819                 b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
     1911                b0 = gen_cmp_gt(cstate, OR_LINKTYPE, 0, BPF_H, ETHERMTU);
    18201912                gen_not(b0);
    18211913
     
    18331925                 * types.
    18341926                 */
    1835                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
    1836                     (bpf_int32)ETHERTYPE_IPX);
     1927                b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, (bpf_int32)ETHERTYPE_IPX);
    18371928                gen_or(b0, b1);
    18381929                return b1;
     
    18501941                 * 1500, which means it's an 802.3 length field.
    18511942                 */
    1852                 b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
     1943                b0 = gen_cmp_gt(cstate, OR_LINKTYPE, 0, BPF_H, ETHERMTU);
    18531944                gen_not(b0);
    18541945
     
    18651956                 */
    18661957                if (proto == ETHERTYPE_ATALK)
    1867                         b1 = gen_snap(0x080007, ETHERTYPE_ATALK);
     1958                        b1 = gen_snap(cstate, 0x080007, ETHERTYPE_ATALK);
    18681959                else    /* proto == ETHERTYPE_AARP */
    1869                         b1 = gen_snap(0x000000, ETHERTYPE_AARP);
     1960                        b1 = gen_snap(cstate, 0x000000, ETHERTYPE_AARP);
    18701961                gen_and(b0, b1);
    18711962
     
    18751966                 * protocol type.
    18761967                 */
    1877                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
     1968                b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, (bpf_int32)proto);
    18781969
    18791970                gen_or(b0, b1);
     
    18901981                         * then check the DSAP.
    18911982                         */
    1892                         b0 = gen_cmp_gt(OR_LINK, off_linktype, BPF_H, ETHERMTU);
     1983                        b0 = gen_cmp_gt(cstate, OR_LINKTYPE, 0, BPF_H, ETHERMTU);
    18931984                        gen_not(b0);
    1894                         b1 = gen_cmp(OR_LINK, off_linktype + 2, BPF_B,
    1895                             (bpf_int32)proto);
     1985                        b1 = gen_cmp(cstate, OR_LINKTYPE, 2, BPF_B, (bpf_int32)proto);
    18961986                        gen_and(b0, b1);
    18971987                        return b1;
     
    19061996                         * which is what we want).
    19071997                         */
    1908                         return gen_cmp(OR_LINK, off_linktype, BPF_H,
     1998                        return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H,
    19091999                            (bpf_int32)proto);
    19102000                }
    19112001        }
     2002}
     2003
     2004static struct block *
     2005gen_loopback_linktype(compiler_state_t *cstate, int proto)
     2006{
     2007        /*
     2008         * For DLT_NULL, the link-layer header is a 32-bit word
     2009         * containing an AF_ value in *host* byte order, and for
     2010         * DLT_ENC, the link-layer header begins with a 32-bit
     2011         * word containing an AF_ value in host byte order.
     2012         *
     2013         * In addition, if we're reading a saved capture file,
     2014         * the host byte order in the capture may not be the
     2015         * same as the host byte order on this machine.
     2016         *
     2017         * For DLT_LOOP, the link-layer header is a 32-bit
     2018         * word containing an AF_ value in *network* byte order.
     2019         */
     2020        if (cstate->linktype == DLT_NULL || cstate->linktype == DLT_ENC) {
     2021                /*
     2022                 * The AF_ value is in host byte order, but the BPF
     2023                 * interpreter will convert it to network byte order.
     2024                 *
     2025                 * If this is a save file, and it's from a machine
     2026                 * with the opposite byte order to ours, we byte-swap
     2027                 * the AF_ value.
     2028                 *
     2029                 * Then we run it through "htonl()", and generate
     2030                 * code to compare against the result.
     2031                 */
     2032                if (cstate->bpf_pcap->rfile != NULL && cstate->bpf_pcap->swapped)
     2033                        proto = SWAPLONG(proto);
     2034                proto = htonl(proto);
     2035        }
     2036        return (gen_cmp(cstate, OR_LINKHDR, 0, BPF_W, (bpf_int32)proto));
    19122037}
    19132038
     
    19172042 */
    19182043static struct block *
    1919 gen_ipnet_linktype(proto)
    1920         register int proto;
     2044gen_ipnet_linktype(compiler_state_t *cstate, int proto)
    19212045{
    19222046        switch (proto) {
    19232047
    19242048        case ETHERTYPE_IP:
    1925                 return gen_cmp(OR_LINK, off_linktype, BPF_B,
    1926                     (bpf_int32)IPH_AF_INET);
     2049                return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_B, (bpf_int32)IPH_AF_INET);
    19272050                /* NOTREACHED */
    19282051
    19292052        case ETHERTYPE_IPV6:
    1930                 return gen_cmp(OR_LINK, off_linktype, BPF_B,
     2053                return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_B,
    19312054                    (bpf_int32)IPH_AF_INET6);
    19322055                /* NOTREACHED */
     
    19362059        }
    19372060
    1938         return gen_false();
     2061        return gen_false(cstate);
    19392062}
    19402063
     
    19482071 */
    19492072static struct block *
    1950 gen_linux_sll_linktype(proto)
    1951         register int proto;
     2073gen_linux_sll_linktype(compiler_state_t *cstate, int proto)
    19522074{
    19532075        struct block *b0, *b1;
     
    19702092                 * (i.e., other SAP values)?
    19712093                 */
    1972                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
    1973                 b1 = gen_cmp(OR_MACPL, 0, BPF_H, (bpf_int32)
     2094                b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, LINUX_SLL_P_802_2);
     2095                b1 = gen_cmp(cstate, OR_LLC, 0, BPF_H, (bpf_int32)
    19742096                             ((proto << 8) | proto));
    19752097                gen_and(b0, b1);
     
    20022124                 * before it.
    20032125                 */
    2004                 b0 = gen_cmp(OR_MACPL, 0, BPF_B, (bpf_int32)LLCSAP_IPX);
    2005                 b1 = gen_snap(0x000000, ETHERTYPE_IPX);
     2126                b0 = gen_cmp(cstate, OR_LLC, 0, BPF_B, (bpf_int32)LLCSAP_IPX);
     2127                b1 = gen_snap(cstate, 0x000000, ETHERTYPE_IPX);
    20062128                gen_or(b0, b1);
    2007                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
     2129                b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, LINUX_SLL_P_802_2);
    20082130                gen_and(b0, b1);
    20092131
     
    20122134                 * the previous test.
    20132135                 */
    2014                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_3);
     2136                b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, LINUX_SLL_P_802_3);
    20152137                gen_or(b0, b1);
    20162138
     
    20202142                 * types.
    20212143                 */
    2022                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
    2023                     (bpf_int32)ETHERTYPE_IPX);
     2144                b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, (bpf_int32)ETHERTYPE_IPX);
    20242145                gen_or(b0, b1);
    20252146                return b1;
     
    20372158                 * "Ethernet type" field.
    20382159                 */
    2039                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, LINUX_SLL_P_802_2);
     2160                b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, LINUX_SLL_P_802_2);
    20402161
    20412162                /*
     
    20512172                 */
    20522173                if (proto == ETHERTYPE_ATALK)
    2053                         b1 = gen_snap(0x080007, ETHERTYPE_ATALK);
     2174                        b1 = gen_snap(cstate, 0x080007, ETHERTYPE_ATALK);
    20542175                else    /* proto == ETHERTYPE_AARP */
    2055                         b1 = gen_snap(0x000000, ETHERTYPE_AARP);
     2176                        b1 = gen_snap(cstate, 0x000000, ETHERTYPE_AARP);
    20562177                gen_and(b0, b1);
    20572178
     
    20612182                 * protocol type.
    20622183                 */
    2063                 b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
     2184                b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, (bpf_int32)proto);
    20642185
    20652186                gen_or(b0, b1);
     
    20752196                         * then check the DSAP.
    20762197                         */
    2077                         b0 = gen_cmp(OR_LINK, off_linktype, BPF_H,
    2078                             LINUX_SLL_P_802_2);
    2079                         b1 = gen_cmp(OR_LINK, off_macpl, BPF_B,
     2198                        b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, LINUX_SLL_P_802_2);
     2199                        b1 = gen_cmp(cstate, OR_LINKHDR, cstate->off_linkpl.constant_part, BPF_B,
    20802200                             (bpf_int32)proto);
    20812201                        gen_and(b0, b1);
     
    20912211                         * which is what we want).
    20922212                         */
    2093                         return gen_cmp(OR_LINK, off_linktype, BPF_H,
    2094                             (bpf_int32)proto);
     2213                        return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, (bpf_int32)proto);
    20952214                }
    20962215        }
     
    20982217
    20992218static struct slist *
    2100 gen_load_prism_llprefixlen()
     2219gen_load_prism_llprefixlen(compiler_state_t *cstate)
    21012220{
    21022221        struct slist *s1, *s2;
     
    21092228         * slist of instructions
    21102229         */
    2111         no_optimize = 1;
     2230        cstate->no_optimize = 1;
    21122231
    21132232        /*
     
    21302249         * bytes long.
    21312250         */
    2132         if (reg_off_ll != -1) {
     2251        if (cstate->off_linkhdr.reg != -1) {
    21332252                /*
    21342253                 * Load the cookie.
    21352254                 */
    2136                 s1 = new_stmt(BPF_LD|BPF_W|BPF_ABS);
     2255                s1 = new_stmt(cstate, BPF_LD|BPF_W|BPF_ABS);
    21372256                s1->s.k = 0;
    21382257
     
    21402259                 * AND it with 0xFFFFF000.
    21412260                 */
    2142                 s2 = new_stmt(BPF_ALU|BPF_AND|BPF_K);
     2261                s2 = new_stmt(cstate, BPF_ALU|BPF_AND|BPF_K);
    21432262                s2->s.k = 0xFFFFF000;
    21442263                sappend(s1, s2);
     
    21472266                 * Compare with 0x80211000.
    21482267                 */
    2149                 sjeq_avs_cookie = new_stmt(JMP(BPF_JEQ));
     2268                sjeq_avs_cookie = new_stmt(cstate, JMP(BPF_JEQ));
    21502269                sjeq_avs_cookie->s.k = 0x80211000;
    21512270                sappend(s1, sjeq_avs_cookie);
     
    21582277                 * That field is big-endian.
    21592278                 */
    2160                 s2 = new_stmt(BPF_LD|BPF_W|BPF_ABS);
     2279                s2 = new_stmt(cstate, BPF_LD|BPF_W|BPF_ABS);
    21612280                s2->s.k = 4;
    21622281                sappend(s1, s2);
     
    21712290                 * over a single instruction, it should be 1.)
    21722291                 */
    2173                 sjcommon = new_stmt(JMP(BPF_JA));
     2292                sjcommon = new_stmt(cstate, JMP(BPF_JA));
    21742293                sjcommon->s.k = 1;
    21752294                sappend(s1, sjcommon);
     
    21812300                 * header branch here if we don't have an AVS header.
    21822301                 */
    2183                 s2 = new_stmt(BPF_LD|BPF_W|BPF_IMM);
     2302                s2 = new_stmt(cstate, BPF_LD|BPF_W|BPF_IMM);
    21842303                s2->s.k = 144;
    21852304                sappend(s1, s2);
     
    21912310                 * loading the length of the AVS header.
    21922311                 */
    2193                 s2 = new_stmt(BPF_ST);
    2194                 s2->s.k = reg_off_ll;
     2312                s2 = new_stmt(cstate, BPF_ST);
     2313                s2->s.k = cstate->off_linkhdr.reg;
    21952314                sappend(s1, s2);
    21962315                sjcommon->s.jf = s2;
     
    21992318                 * Now move it into the X register.
    22002319                 */
    2201                 s2 = new_stmt(BPF_MISC|BPF_TAX);
     2320                s2 = new_stmt(cstate, BPF_MISC|BPF_TAX);
    22022321                sappend(s1, s2);
    22032322
     
    22082327
    22092328static struct slist *
    2210 gen_load_avs_llprefixlen()
     2329gen_load_avs_llprefixlen(compiler_state_t *cstate)
    22112330{
    22122331        struct slist *s1, *s2;
     
    22192338         * code to load it.)
    22202339         */
    2221         if (reg_off_ll != -1) {
     2340        if (cstate->off_linkhdr.reg != -1) {
    22222341                /*
    22232342                 * The 4 bytes at an offset of 4 from the beginning of
     
    22252344                 * That field is big-endian.
    22262345                 */
    2227                 s1 = new_stmt(BPF_LD|BPF_W|BPF_ABS);
     2346                s1 = new_stmt(cstate, BPF_LD|BPF_W|BPF_ABS);
    22282347                s1->s.k = 4;
    22292348
     
    22322351                 * it.
    22332352                 */
    2234                 s2 = new_stmt(BPF_ST);
    2235                 s2->s.k = reg_off_ll;
     2353                s2 = new_stmt(cstate, BPF_ST);
     2354                s2->s.k = cstate->off_linkhdr.reg;
    22362355                sappend(s1, s2);
    22372356
     
    22392358                 * Now move it into the X register.
    22402359                 */
    2241                 s2 = new_stmt(BPF_MISC|BPF_TAX);
     2360                s2 = new_stmt(cstate, BPF_MISC|BPF_TAX);
    22422361                sappend(s1, s2);
    22432362
     
    22482367
    22492368static struct slist *
    2250 gen_load_radiotap_llprefixlen()
     2369gen_load_radiotap_llprefixlen(compiler_state_t *cstate)
    22512370{
    22522371        struct slist *s1, *s2;
     
    22592378         * code to load it.)
    22602379         */
    2261         if (reg_off_ll != -1) {
     2380        if (cstate->off_linkhdr.reg != -1) {
    22622381                /*
    22632382                 * The 2 bytes at offsets of 2 and 3 from the beginning
     
    22712390                 * left a byte, and put the result in the X register.
    22722391                 */
    2273                 s1 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
     2392                s1 = new_stmt(cstate, BPF_LD|BPF_B|BPF_ABS);
    22742393                s1->s.k = 3;
    2275                 s2 = new_stmt(BPF_ALU|BPF_LSH|BPF_K);
     2394                s2 = new_stmt(cstate, BPF_ALU|BPF_LSH|BPF_K);
    22762395                sappend(s1, s2);
    22772396                s2->s.k = 8;
    2278                 s2 = new_stmt(BPF_MISC|BPF_TAX);
     2397                s2 = new_stmt(cstate, BPF_MISC|BPF_TAX);
    22792398                sappend(s1, s2);
    22802399
     
    22832402                 * value from the X register into it.
    22842403                 */
    2285                 s2 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
     2404                s2 = new_stmt(cstate, BPF_LD|BPF_B|BPF_ABS);
    22862405                sappend(s1, s2);
    22872406                s2->s.k = 2;
    2288                 s2 = new_stmt(BPF_ALU|BPF_OR|BPF_X);
     2407                s2 = new_stmt(cstate, BPF_ALU|BPF_OR|BPF_X);
    22892408                sappend(s1, s2);
    22902409
     
    22932412                 * it.
    22942413                 */
    2295                 s2 = new_stmt(BPF_ST);
    2296                 s2->s.k = reg_off_ll;
     2414                s2 = new_stmt(cstate, BPF_ST);
     2415                s2->s.k = cstate->off_linkhdr.reg;
    22972416                sappend(s1, s2);
    22982417
     
    23002419                 * Now move it into the X register.
    23012420                 */
    2302                 s2 = new_stmt(BPF_MISC|BPF_TAX);
     2421                s2 = new_stmt(cstate, BPF_MISC|BPF_TAX);
    23032422                sappend(s1, s2);
    23042423
     
    23182437 */
    23192438static struct slist *
    2320 gen_load_ppi_llprefixlen()
     2439gen_load_ppi_llprefixlen(compiler_state_t *cstate)
    23212440{
    23222441        struct slist *s1, *s2;
     
    23272446         * been assigned.
    23282447         */
    2329         if (reg_off_ll != -1) {
     2448        if (cstate->off_linkhdr.reg != -1) {
    23302449                /*
    23312450                 * The 2 bytes at offsets of 2 and 3 from the beginning
     
    23392458                 * left a byte, and put the result in the X register.
    23402459                 */
    2341                 s1 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
     2460                s1 = new_stmt(cstate, BPF_LD|BPF_B|BPF_ABS);
    23422461                s1->s.k = 3;
    2343                 s2 = new_stmt(BPF_ALU|BPF_LSH|BPF_K);
     2462                s2 = new_stmt(cstate, BPF_ALU|BPF_LSH|BPF_K);
    23442463                sappend(s1, s2);
    23452464                s2->s.k = 8;
    2346                 s2 = new_stmt(BPF_MISC|BPF_TAX);
     2465                s2 = new_stmt(cstate, BPF_MISC|BPF_TAX);
    23472466                sappend(s1, s2);
    23482467
     
    23512470                 * value from the X register into it.
    23522471                 */
    2353                 s2 = new_stmt(BPF_LD|BPF_B|BPF_ABS);
     2472                s2 = new_stmt(cstate, BPF_LD|BPF_B|BPF_ABS);
    23542473                sappend(s1, s2);
    23552474                s2->s.k = 2;
    2356                 s2 = new_stmt(BPF_ALU|BPF_OR|BPF_X);
     2475                s2 = new_stmt(cstate, BPF_ALU|BPF_OR|BPF_X);
    23572476                sappend(s1, s2);
    23582477
     
    23612480                 * it.
    23622481                 */
    2363                 s2 = new_stmt(BPF_ST);
    2364                 s2->s.k = reg_off_ll;
     2482                s2 = new_stmt(cstate, BPF_ST);
     2483                s2->s.k = cstate->off_linkhdr.reg;
    23652484                sappend(s1, s2);
    23662485
     
    23682487                 * Now move it into the X register.
    23692488                 */
    2370                 s2 = new_stmt(BPF_MISC|BPF_TAX);
     2489                s2 = new_stmt(cstate, BPF_MISC|BPF_TAX);
    23712490                sappend(s1, s2);
    23722491
     
    23842503 */
    23852504static struct slist *
    2386 gen_load_802_11_header_len(struct slist *s, struct slist *snext)
     2505gen_load_802_11_header_len(compiler_state_t *cstate, struct slist *s, struct slist *snext)
    23872506{
    23882507        struct slist *s2;
     
    23902509        struct slist *sjset_data_frame_2;
    23912510        struct slist *sjset_qos;
    2392         struct slist *sjset_radiotap_flags;
    2393         struct slist *sjset_radiotap_tsft;
     2511        struct slist *sjset_radiotap_flags_present;
     2512        struct slist *sjset_radiotap_ext_present;
     2513        struct slist *sjset_radiotap_tsft_present;
    23942514        struct slist *sjset_tsft_datapad, *sjset_notsft_datapad;
    23952515        struct slist *s_roundup;
    23962516
    2397         if (reg_off_macpl == -1) {
     2517        if (cstate->off_linkpl.reg == -1) {
    23982518                /*
    23992519                 * No register has been assigned to the offset of
    2400                  * the MAC-layer payload, which means nobody needs
     2520                 * the link-layer payload, which means nobody needs
    24012521                 * it; don't bother computing it - just return
    24022522                 * what we already have.
     
    24102530         * slist of instructions
    24112531         */
    2412         no_optimize = 1;
     2532        cstate->no_optimize = 1;
    24132533
    24142534        /*
     
    24182538         *
    24192539         * Otherwise, the length of the prefix preceding the link-layer
    2420          * header is "off_ll".
     2540         * header is "off_outermostlinkhdr.constant_part".
    24212541         */
    24222542        if (s == NULL) {
     
    24272547                 * Load the length of the fixed-length prefix preceding
    24282548                 * the link-layer header (if any) into the X register,
    2429                  * and store it in the reg_off_macpl register.
    2430                  * That length is off_ll.
    2431                  */
    2432                 s = new_stmt(BPF_LDX|BPF_IMM);
    2433                 s->s.k = off_ll;
     2549                 * and store it in the cstate->off_linkpl.reg register.
     2550                 * That length is off_outermostlinkhdr.constant_part.
     2551                 */
     2552                s = new_stmt(cstate, BPF_LDX|BPF_IMM);
     2553                s->s.k = cstate->off_outermostlinkhdr.constant_part;
    24342554        }
    24352555
     
    24382558         * link-layer header; add 24, which is the minimum length
    24392559         * of the MAC header for a data frame, to that, and store it
    2440          * in reg_off_macpl, and then load the Frame Control field,
     2560         * in cstate->off_linkpl.reg, and then load the Frame Control field,
    24412561         * which is at the offset in the X register, with an indexed load.
    24422562         */
    2443         s2 = new_stmt(BPF_MISC|BPF_TXA);
     2563        s2 = new_stmt(cstate, BPF_MISC|BPF_TXA);
    24442564        sappend(s, s2);
    2445         s2 = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
     2565        s2 = new_stmt(cstate, BPF_ALU|BPF_ADD|BPF_K);
    24462566        s2->s.k = 24;
    24472567        sappend(s, s2);
    2448         s2 = new_stmt(BPF_ST);
    2449         s2->s.k = reg_off_macpl;
     2568        s2 = new_stmt(cstate, BPF_ST);
     2569        s2->s.k = cstate->off_linkpl.reg;
    24502570        sappend(s, s2);
    24512571
    2452         s2 = new_stmt(BPF_LD|BPF_IND|BPF_B);
     2572        s2 = new_stmt(cstate, BPF_LD|BPF_IND|BPF_B);
    24532573        s2->s.k = 0;
    24542574        sappend(s, s2);
     
    24592579         * 0x04 bit (b2) clear.
    24602580         */
    2461         sjset_data_frame_1 = new_stmt(JMP(BPF_JSET));
     2581        sjset_data_frame_1 = new_stmt(cstate, JMP(BPF_JSET));
    24622582        sjset_data_frame_1->s.k = 0x08;
    24632583        sappend(s, sjset_data_frame_1);
     
    24672587         * the rest of the program.
    24682588         */
    2469         sjset_data_frame_1->s.jt = sjset_data_frame_2 = new_stmt(JMP(BPF_JSET));
     2589        sjset_data_frame_1->s.jt = sjset_data_frame_2 = new_stmt(cstate, JMP(BPF_JSET));
    24702590        sjset_data_frame_2->s.k = 0x04;
    24712591        sappend(s, sjset_data_frame_2);
     
    24782598         */
    24792599        sjset_data_frame_2->s.jt = snext;
    2480         sjset_data_frame_2->s.jf = sjset_qos = new_stmt(JMP(BPF_JSET));
     2600        sjset_data_frame_2->s.jf = sjset_qos = new_stmt(cstate, JMP(BPF_JSET));
    24812601        sjset_qos->s.k = 0x80;  /* QoS bit */
    24822602        sappend(s, sjset_qos);
    24832603
    24842604        /*
    2485          * If it's set, add 2 to reg_off_macpl, to skip the QoS
     2605         * If it's set, add 2 to cstate->off_linkpl.reg, to skip the QoS
    24862606         * field.
    24872607         * Otherwise, go to the first statement of the rest of the
    24882608         * program.
    24892609         */
    2490         sjset_qos->s.jt = s2 = new_stmt(BPF_LD|BPF_MEM);
    2491         s2->s.k = reg_off_macpl;
     2610        sjset_qos->s.jt = s2 = new_stmt(cstate, BPF_LD|BPF_MEM);
     2611        s2->s.k = cstate->off_linkpl.reg;
    24922612        sappend(s, s2);
    2493         s2 = new_stmt(BPF_ALU|BPF_ADD|BPF_IMM);
     2613        s2 = new_stmt(cstate, BPF_ALU|BPF_ADD|BPF_IMM);
    24942614        s2->s.k = 2;
    24952615        sappend(s, s2);
    2496         s2 = new_stmt(BPF_ST);
    2497         s2->s.k = reg_off_macpl;
     2616        s2 = new_stmt(cstate, BPF_ST);
     2617        s2->s.k = cstate->off_linkpl.reg;
    24982618        sappend(s, s2);
    24992619
     
    25072627         * we test against, as they will be loaded as big-endian
    25082628         * values.
     2629         *
     2630         * XXX - in the general case, we would have to scan through
     2631         * *all* the presence bits, if there's more than one word of
     2632         * presence bits.  That would require a loop, meaning that
     2633         * we wouldn't be able to run the filter in the kernel.
     2634         *
     2635         * We assume here that the Atheros adapters that insert the
     2636         * annoying padding don't have multiple antennae and therefore
     2637         * do not generate radiotap headers with multiple presence words.
    25092638         */
    2510         if (linktype == DLT_IEEE802_11_RADIO) {
     2639        if (cstate->linktype == DLT_IEEE802_11_RADIO) {
    25112640                /*
    25122641                 * Is the IEEE80211_RADIOTAP_FLAGS bit (0x0000002) set
    2513                  * in the presence flag?
    2514                  */
    2515                 sjset_qos->s.jf = s2 = new_stmt(BPF_LD|BPF_ABS|BPF_W);
     2642                 * in the first presence flag word?
     2643                 */
     2644                sjset_qos->s.jf = s2 = new_stmt(cstate, BPF_LD|BPF_ABS|BPF_W);
    25162645                s2->s.k = 4;
    25172646                sappend(s, s2);
    25182647
    2519                 sjset_radiotap_flags = new_stmt(JMP(BPF_JSET));
    2520                 sjset_radiotap_flags->s.k = SWAPLONG(0x00000002);
    2521                 sappend(s, sjset_radiotap_flags);
     2648                sjset_radiotap_flags_present = new_stmt(cstate, JMP(BPF_JSET));
     2649                sjset_radiotap_flags_present->s.k = SWAPLONG(0x00000002);
     2650                sappend(s, sjset_radiotap_flags_present);
    25222651
    25232652                /*
    25242653                 * If not, skip all of this.
    25252654                 */
    2526                 sjset_radiotap_flags->s.jf = snext;
     2655                sjset_radiotap_flags_present->s.jf = snext;
     2656
     2657                /*
     2658                 * Otherwise, is the "extension" bit set in that word?
     2659                 */
     2660                sjset_radiotap_ext_present = new_stmt(cstate, JMP(BPF_JSET));
     2661                sjset_radiotap_ext_present->s.k = SWAPLONG(0x80000000);
     2662                sappend(s, sjset_radiotap_ext_present);
     2663                sjset_radiotap_flags_present->s.jt = sjset_radiotap_ext_present;
     2664
     2665                /*
     2666                 * If so, skip all of this.
     2667                 */
     2668                sjset_radiotap_ext_present->s.jt = snext;
    25272669
    25282670                /*
    25292671                 * Otherwise, is the IEEE80211_RADIOTAP_TSFT bit set?
    25302672                 */
    2531                 sjset_radiotap_tsft = sjset_radiotap_flags->s.jt =
    2532                     new_stmt(JMP(BPF_JSET));
    2533                 sjset_radiotap_tsft->s.k = SWAPLONG(0x00000001);
    2534                 sappend(s, sjset_radiotap_tsft);
     2673                sjset_radiotap_tsft_present = new_stmt(cstate, JMP(BPF_JSET));
     2674                sjset_radiotap_tsft_present->s.k = SWAPLONG(0x00000001);
     2675                sappend(s, sjset_radiotap_tsft_present);
     2676                sjset_radiotap_ext_present->s.jf = sjset_radiotap_tsft_present;
    25352677
    25362678                /*
     
    25432685                 * is set.
    25442686                 */
    2545                 sjset_radiotap_tsft->s.jt = s2 = new_stmt(BPF_LD|BPF_ABS|BPF_B);
     2687                s2 = new_stmt(cstate, BPF_LD|BPF_ABS|BPF_B);
    25462688                s2->s.k = 16;
    25472689                sappend(s, s2);
    2548 
    2549                 sjset_tsft_datapad = new_stmt(JMP(BPF_JSET));
     2690                sjset_radiotap_tsft_present->s.jt = s2;
     2691
     2692                sjset_tsft_datapad = new_stmt(cstate, JMP(BPF_JSET));
    25502693                sjset_tsft_datapad->s.k = 0x20;
    25512694                sappend(s, sjset_tsft_datapad);
     
    25592702                 * is set.
    25602703                 */
    2561                 sjset_radiotap_tsft->s.jf = s2 = new_stmt(BPF_LD|BPF_ABS|BPF_B);
     2704                s2 = new_stmt(cstate, BPF_LD|BPF_ABS|BPF_B);
    25622705                s2->s.k = 8;
    25632706                sappend(s, s2);
    2564 
    2565                 sjset_notsft_datapad = new_stmt(JMP(BPF_JSET));
     2707                sjset_radiotap_tsft_present->s.jf = s2;
     2708
     2709                sjset_notsft_datapad = new_stmt(cstate, JMP(BPF_JSET));
    25662710                sjset_notsft_datapad->s.k = 0x20;
    25672711                sappend(s, sjset_notsft_datapad);
     
    25742718                 * ANDing with ~3.
    25752719                 */
    2576                 s_roundup = new_stmt(BPF_LD|BPF_MEM);
    2577                 s_roundup->s.k = reg_off_macpl;
     2720                s_roundup = new_stmt(cstate, BPF_LD|BPF_MEM);
     2721                s_roundup->s.k = cstate->off_linkpl.reg;
    25782722                sappend(s, s_roundup);
    2579                 s2 = new_stmt(BPF_ALU|BPF_ADD|BPF_IMM);
     2723                s2 = new_stmt(cstate, BPF_ALU|BPF_ADD|BPF_IMM);
    25802724                s2->s.k = 3;
    25812725                sappend(s, s2);
    2582                 s2 = new_stmt(BPF_ALU|BPF_AND|BPF_IMM);
     2726                s2 = new_stmt(cstate, BPF_ALU|BPF_AND|BPF_IMM);
    25832727                s2->s.k = ~3;
    25842728                sappend(s, s2);
    2585                 s2 = new_stmt(BPF_ST);
    2586                 s2->s.k = reg_off_macpl;
     2729                s2 = new_stmt(cstate, BPF_ST);
     2730                s2->s.k = cstate->off_linkpl.reg;
    25872731                sappend(s, s2);
    25882732
     
    25982742
    25992743static void
    2600 insert_compute_vloffsets(b)
    2601         struct block *b;
     2744insert_compute_vloffsets(compiler_state_t *cstate, struct block *b)
    26022745{
    26032746        struct slist *s;
     2747
     2748        /* There is an implicit dependency between the link
     2749         * payload and link header since the payload computation
     2750         * includes the variable part of the header. Therefore,
     2751         * if nobody else has allocated a register for the link
     2752         * header and we need it, do it now. */
     2753        if (cstate->off_linkpl.reg != -1 && cstate->off_linkhdr.is_variable &&
     2754            cstate->off_linkhdr.reg == -1)
     2755                cstate->off_linkhdr.reg = alloc_reg(cstate);
    26042756
    26052757        /*
     
    26082760         * the offset of the link-layer header into the register
    26092761         * assigned to that offset, if any.
     2762         *
     2763         * XXX - this, and the next switch statement, won't handle
     2764         * encapsulation of 802.11 or 802.11+radio information in
     2765         * some other protocol stack.  That's significantly more
     2766         * complicated.
    26102767         */
    2611         switch (linktype) {
     2768        switch (cstate->outermostlinktype) {
    26122769
    26132770        case DLT_PRISM_HEADER:
    2614                 s = gen_load_prism_llprefixlen();
     2771                s = gen_load_prism_llprefixlen(cstate);
    26152772                break;
    26162773
    26172774        case DLT_IEEE802_11_RADIO_AVS:
    2618                 s = gen_load_avs_llprefixlen();
     2775                s = gen_load_avs_llprefixlen(cstate);
    26192776                break;
    26202777
    26212778        case DLT_IEEE802_11_RADIO:
    2622                 s = gen_load_radiotap_llprefixlen();
     2779                s = gen_load_radiotap_llprefixlen(cstate);
    26232780                break;
    26242781
    26252782        case DLT_PPI:
    2626                 s = gen_load_ppi_llprefixlen();
     2783                s = gen_load_ppi_llprefixlen(cstate);
    26272784                break;
    26282785
     
    26342791        /*
    26352792         * For link-layer types that have a variable-length link-layer
    2636          * header, generate code to load the offset of the MAC-layer
     2793         * header, generate code to load the offset of the link-layer
    26372794         * payload into the register assigned to that offset, if any.
    26382795         */
    2639         switch (linktype) {
     2796        switch (cstate->outermostlinktype) {
    26402797
    26412798        case DLT_IEEE802_11:
     
    26442801        case DLT_IEEE802_11_RADIO:
    26452802        case DLT_PPI:
    2646                 s = gen_load_802_11_header_len(s, b->stmts);
     2803                s = gen_load_802_11_header_len(cstate, s, b->stmts);
    26472804                break;
    26482805        }
     
    26612818
    26622819static struct block *
    2663 gen_ppi_dlt_check(void)
     2820gen_ppi_dlt_check(compiler_state_t *cstate)
    26642821{
    26652822        struct slist *s_load_dlt;
    26662823        struct block *b;
    26672824
    2668         if (linktype == DLT_PPI)
     2825        if (cstate->linktype == DLT_PPI)
    26692826        {
    26702827                /* Create the statements that check for the DLT
    26712828                 */
    2672                 s_load_dlt = new_stmt(BPF_LD|BPF_W|BPF_ABS);
     2829                s_load_dlt = new_stmt(cstate, BPF_LD|BPF_W|BPF_ABS);
    26732830                s_load_dlt->s.k = 4;
    26742831
    2675                 b = new_block(JMP(BPF_JEQ));
     2832                b = new_block(cstate, JMP(BPF_JEQ));
    26762833
    26772834                b->stmts = s_load_dlt;
     
    26862843}
    26872844
    2688 static struct slist *
    2689 gen_prism_llprefixlen(void)
    2690 {
    2691         struct slist *s;
    2692 
    2693         if (reg_off_ll == -1) {
    2694                 /*
    2695                  * We haven't yet assigned a register for the length
    2696                  * of the radio header; allocate one.
    2697                  */
    2698                 reg_off_ll = alloc_reg();
    2699         }
    2700 
    2701         /*
    2702          * Load the register containing the radio length
    2703          * into the X register.
    2704          */
    2705         s = new_stmt(BPF_LDX|BPF_MEM);
    2706         s->s.k = reg_off_ll;
    2707         return s;
    2708 }
    2709 
    2710 static struct slist *
    2711 gen_avs_llprefixlen(void)
    2712 {
    2713         struct slist *s;
    2714 
    2715         if (reg_off_ll == -1) {
    2716                 /*
    2717                  * We haven't yet assigned a register for the length
    2718                  * of the AVS header; allocate one.
    2719                  */
    2720                 reg_off_ll = alloc_reg();
    2721         }
    2722 
    2723         /*
    2724          * Load the register containing the AVS length
    2725          * into the X register.
    2726          */
    2727         s = new_stmt(BPF_LDX|BPF_MEM);
    2728         s->s.k = reg_off_ll;
    2729         return s;
    2730 }
    2731 
    2732 static struct slist *
    2733 gen_radiotap_llprefixlen(void)
    2734 {
    2735         struct slist *s;
    2736 
    2737         if (reg_off_ll == -1) {
    2738                 /*
    2739                  * We haven't yet assigned a register for the length
    2740                  * of the radiotap header; allocate one.
    2741                  */
    2742                 reg_off_ll = alloc_reg();
    2743         }
    2744 
    2745         /*
    2746          * Load the register containing the radiotap length
    2747          * into the X register.
    2748          */
    2749         s = new_stmt(BPF_LDX|BPF_MEM);
    2750         s->s.k = reg_off_ll;
    2751         return s;
    2752 }
    2753 
    27542845/*
    2755  * At the moment we treat PPI as normal Radiotap encoded
    2756  * packets. The difference is in the function that generates
    2757  * the code at the beginning to compute the header length.
    2758  * Since this code generator of PPI supports bare 802.11
    2759  * encapsulation only (i.e. the encapsulated DLT should be
    2760  * DLT_IEEE802_11) we generate code to check for this too.
     2846 * Take an absolute offset, and:
     2847 *
     2848 *    if it has no variable part, return NULL;
     2849 *
     2850 *    if it has a variable part, generate code to load the register
     2851 *    containing that variable part into the X register, returning
     2852 *    a pointer to that code - if no register for that offset has
     2853 *    been allocated, allocate it first.
     2854 *
     2855 * (The code to set that register will be generated later, but will
     2856 * be placed earlier in the code sequence.)
    27612857 */
    27622858static struct slist *
    2763 gen_ppi_llprefixlen(void)
     2859gen_abs_offset_varpart(compiler_state_t *cstate, bpf_abs_offset *off)
    27642860{
    27652861        struct slist *s;
    27662862
    2767         if (reg_off_ll == -1) {
    2768                 /*
    2769                  * We haven't yet assigned a register for the length
    2770                  * of the radiotap header; allocate one.
    2771                  */
    2772                 reg_off_ll = alloc_reg();
    2773         }
    2774 
    2775         /*
    2776          * Load the register containing the PPI length
    2777          * into the X register.
    2778          */
    2779         s = new_stmt(BPF_LDX|BPF_MEM);
    2780         s->s.k = reg_off_ll;
    2781         return s;
    2782 }
    2783 
    2784 /*
    2785  * Generate code to compute the link-layer header length, if necessary,
    2786  * putting it into the X register, and to return either a pointer to a
    2787  * "struct slist" for the list of statements in that code, or NULL if
    2788  * no code is necessary.
    2789  */
    2790 static struct slist *
    2791 gen_llprefixlen(void)
    2792 {
    2793         switch (linktype) {
    2794 
    2795         case DLT_PRISM_HEADER:
    2796                 return gen_prism_llprefixlen();
    2797 
    2798         case DLT_IEEE802_11_RADIO_AVS:
    2799                 return gen_avs_llprefixlen();
    2800 
    2801         case DLT_IEEE802_11_RADIO:
    2802                 return gen_radiotap_llprefixlen();
    2803 
    2804         case DLT_PPI:
    2805                 return gen_ppi_llprefixlen();
    2806 
    2807         default:
    2808                 return NULL;
    2809         }
    2810 }
    2811 
    2812 /*
    2813  * Generate code to load the register containing the offset of the
    2814  * MAC-layer payload into the X register; if no register for that offset
    2815  * has been allocated, allocate it first.
    2816  */
    2817 static struct slist *
    2818 gen_off_macpl(void)
    2819 {
    2820         struct slist *s;
    2821 
    2822         if (off_macpl_is_variable) {
    2823                 if (reg_off_macpl == -1) {
     2863        if (off->is_variable) {
     2864                if (off->reg == -1) {
    28242865                        /*
    2825                          * We haven't yet assigned a register for the offset
    2826                          * of the MAC-layer payload; allocate one.
     2866                         * We haven't yet assigned a register for the
     2867                         * variable part of the offset of the link-layer
     2868                         * header; allocate one.
    28272869                         */
    2828                         reg_off_macpl = alloc_reg();
     2870                        off->reg = alloc_reg(cstate);
    28292871                }
    28302872
    28312873                /*
    2832                  * Load the register containing the offset of the MAC-layer
    2833                  * payload into the X register.
    2834                  */
    2835                 s = new_stmt(BPF_LDX|BPF_MEM);
    2836                 s->s.k = reg_off_macpl;
     2874                 * Load the register containing the variable part of the
     2875                 * offset of the link-layer header into the X register.
     2876                 */
     2877                s = new_stmt(cstate, BPF_LDX|BPF_MEM);
     2878                s->s.k = off->reg;
    28372879                return s;
    28382880        } else {
    28392881                /*
    2840                  * That offset isn't variable, so we don't need to
    2841                  * generate any code.
     2882                 * That offset isn't variable, there's no variable part,
     2883                 * so we don't need to generate any code.
    28422884                 */
    28432885                return NULL;
     
    28932935        return (proto);
    28942936}
     2937
     2938/*
     2939 * Generate any tests that, for encapsulation of a link-layer packet
     2940 * inside another protocol stack, need to be done to check for those
     2941 * link-layer packets (and that haven't already been done by a check
     2942 * for that encapsulation).
     2943 */
     2944static struct block *
     2945gen_prevlinkhdr_check(compiler_state_t *cstate)
     2946{
     2947        struct block *b0;
     2948
     2949        if (cstate->is_geneve)
     2950                return gen_geneve_ll_check(cstate);
     2951
     2952        switch (cstate->prevlinktype) {
     2953
     2954        case DLT_SUNATM:
     2955                /*
     2956                 * This is LANE-encapsulated Ethernet; check that the LANE
     2957                 * packet doesn't begin with an LE Control marker, i.e.
     2958                 * that it's data, not a control message.
     2959                 *
     2960                 * (We've already generated a test for LANE.)
     2961                 */
     2962                b0 = gen_cmp(cstate, OR_PREVLINKHDR, SUNATM_PKT_BEGIN_POS, BPF_H, 0xFF00);
     2963                gen_not(b0);
     2964                return b0;
     2965
     2966        default:
     2967                /*
     2968                 * No such tests are necessary.
     2969                 */
     2970                return NULL;
     2971        }
     2972        /*NOTREACHED*/
     2973}
     2974
     2975/*
     2976 * The three different values we should check for when checking for an
     2977 * IPv6 packet with DLT_NULL.
     2978 */
     2979#define BSD_AFNUM_INET6_BSD     24      /* NetBSD, OpenBSD, BSD/OS, Npcap */
     2980#define BSD_AFNUM_INET6_FREEBSD 28      /* FreeBSD */
     2981#define BSD_AFNUM_INET6_DARWIN  30      /* OS X, iOS, other Darwin-based OSes */
    28952982
    28962983/*
     
    29022989 */
    29032990static struct block *
    2904 gen_linktype(proto)
    2905         register int proto;
     2991gen_linktype(compiler_state_t *cstate, int proto)
    29062992{
    29072993        struct block *b0, *b1, *b2;
     2994        const char *description;
    29082995
    29092996        /* are we checking MPLS-encapsulated packets? */
    2910         if (label_stack_depth > 0) {
     2997        if (cstate->label_stack_depth > 0) {
    29112998                switch (proto) {
    29122999                case ETHERTYPE_IP:
    29133000                case PPP_IP:
    29143001                        /* FIXME add other L3 proto IDs */
    2915                         return gen_mpls_linktype(Q_IP);
     3002                        return gen_mpls_linktype(cstate, Q_IP);
    29163003
    29173004                case ETHERTYPE_IPV6:
    29183005                case PPP_IPV6:
    29193006                        /* FIXME add other L3 proto IDs */
    2920                         return gen_mpls_linktype(Q_IPV6);
     3007                        return gen_mpls_linktype(cstate, Q_IPV6);
    29213008
    29223009                default:
    2923                         bpf_error("unsupported protocol over mpls");
     3010                        bpf_error(cstate, "unsupported protocol over mpls");
    29243011                        /* NOTREACHED */
    29253012                }
    29263013        }
    29273014
    2928         /*
    2929          * Are we testing PPPoE packets?
    2930          */
    2931         if (is_pppoes) {
    2932                 /*
    2933                  * The PPPoE session header is part of the
    2934                  * MAC-layer payload, so all references
    2935                  * should be relative to the beginning of
    2936                  * that payload.
    2937                  */
    2938 
    2939                 /*
    2940                  * We use Ethernet protocol types inside libpcap;
    2941                  * map them to the corresponding PPP protocol types.
    2942                  */
    2943                 proto = ethertype_to_ppptype(proto);
    2944                 return gen_cmp(OR_MACPL, off_linktype, BPF_H, (bpf_int32)proto);
    2945         }
    2946 
    2947         switch (linktype) {
     3015        switch (cstate->linktype) {
    29483016
    29493017        case DLT_EN10MB:
    29503018        case DLT_NETANALYZER:
    29513019        case DLT_NETANALYZER_TRANSPARENT:
    2952                 return gen_ether_linktype(proto);
     3020                /* Geneve has an EtherType regardless of whether there is an
     3021                 * L2 header. */
     3022                if (!cstate->is_geneve)
     3023                        b0 = gen_prevlinkhdr_check(cstate);
     3024                else
     3025                        b0 = NULL;
     3026
     3027                b1 = gen_ether_linktype(cstate, proto);
     3028                if (b0 != NULL)
     3029                        gen_and(b0, b1);
     3030                return b1;
    29533031                /*NOTREACHED*/
    29543032                break;
     
    29623040
    29633041                default:
    2964                         return gen_cmp(OR_LINK, off_linktype, BPF_H,
    2965                             (bpf_int32)proto);
     3042                        return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, (bpf_int32)proto);
    29663043                        /*NOTREACHED*/
    29673044                        break;
     
    29773054                 * Check that we have a data frame.
    29783055                 */
    2979                 b0 = gen_check_802_11_data_frame();
     3056                b0 = gen_check_802_11_data_frame(cstate);
    29803057
    29813058                /*
    29823059                 * Now check for the specified link-layer type.
    29833060                 */
    2984                 b1 = gen_llc_linktype(proto);
     3061                b1 = gen_llc_linktype(cstate, proto);
    29853062                gen_and(b0, b1);
    29863063                return b1;
     
    29903067        case DLT_FDDI:
    29913068                /*
    2992                  * XXX - check for asynchronous frames, as per RFC 1103.
    2993                  */
    2994                 return gen_llc_linktype(proto);
     3069                 * XXX - check for LLC frames.
     3070                 */
     3071                return gen_llc_linktype(cstate, proto);
    29953072                /*NOTREACHED*/
    29963073                break;
     
    30003077                 * XXX - check for LLC PDUs, as per IEEE 802.5.
    30013078                 */
    3002                 return gen_llc_linktype(proto);
     3079                return gen_llc_linktype(cstate, proto);
    30033080                /*NOTREACHED*/
    30043081                break;
     
    30073084        case DLT_ATM_CLIP:
    30083085        case DLT_IP_OVER_FC:
    3009                 return gen_llc_linktype(proto);
     3086                return gen_llc_linktype(cstate, proto);
    30103087                /*NOTREACHED*/
    30113088                break;
     
    30133090        case DLT_SUNATM:
    30143091                /*
    3015                  * If "is_lane" is set, check for a LANE-encapsulated
    3016                  * version of this protocol, otherwise check for an
    3017                  * LLC-encapsulated version of this protocol.
     3092                 * Check for an LLC-encapsulated version of this protocol;
     3093                 * if we were checking for LANE, linktype would no longer
     3094                 * be DLT_SUNATM.
    30183095                 *
    3019                  * We assume LANE means Ethernet, not Token Ring.
    3020                  */
    3021                 if (is_lane) {
    3022                         /*
    3023                          * Check that the packet doesn't begin with an
    3024                          * LE Control marker.  (We've already generated
    3025                          * a test for LANE.)
    3026                          */
    3027                         b0 = gen_cmp(OR_LINK, SUNATM_PKT_BEGIN_POS, BPF_H,
    3028                             0xFF00);
    3029                         gen_not(b0);
    3030 
    3031                         /*
    3032                          * Now generate an Ethernet test.
    3033                          */
    3034                         b1 = gen_ether_linktype(proto);
    3035                         gen_and(b0, b1);
    3036                         return b1;
    3037                 } else {
    3038                         /*
    3039                          * Check for LLC encapsulation and then check the
    3040                          * protocol.
    3041                          */
    3042                         b0 = gen_atmfield_code(A_PROTOTYPE, PT_LLC, BPF_JEQ, 0);
    3043                         b1 = gen_llc_linktype(proto);
    3044                         gen_and(b0, b1);
    3045                         return b1;
    3046                 }
     3096                 * Check for LLC encapsulation and then check the protocol.
     3097                 */
     3098                b0 = gen_atmfield_code(cstate, A_PROTOTYPE, PT_LLC, BPF_JEQ, 0);
     3099                b1 = gen_llc_linktype(cstate, proto);
     3100                gen_and(b0, b1);
     3101                return b1;
    30473102                /*NOTREACHED*/
    30483103                break;
    30493104
    30503105        case DLT_LINUX_SLL:
    3051                 return gen_linux_sll_linktype(proto);
     3106                return gen_linux_sll_linktype(cstate, proto);
    30523107                /*NOTREACHED*/
    30533108                break;
     
    30673122                case ETHERTYPE_IP:
    30683123                        /* Check for a version number of 4. */
    3069                         return gen_mcmp(OR_LINK, 0, BPF_B, 0x40, 0xF0);
     3124                        return gen_mcmp(cstate, OR_LINKHDR, 0, BPF_B, 0x40, 0xF0);
    30703125
    30713126                case ETHERTYPE_IPV6:
    30723127                        /* Check for a version number of 6. */
    3073                         return gen_mcmp(OR_LINK, 0, BPF_B, 0x60, 0xF0);
     3128                        return gen_mcmp(cstate, OR_LINKHDR, 0, BPF_B, 0x60, 0xF0);
    30743129
    30753130                default:
    3076                         return gen_false();             /* always false */
     3131                        return gen_false(cstate);       /* always false */
    30773132                }
    30783133                /*NOTREACHED*/
     
    30843139                 */
    30853140                if (proto == ETHERTYPE_IP)
    3086                         return gen_true();              /* always true */
     3141                        return gen_true(cstate);        /* always true */
    30873142
    30883143                /* Checking for something other than IPv4; always false */
    3089                 return gen_false();
     3144                return gen_false(cstate);
    30903145                /*NOTREACHED*/
    30913146                break;
     
    30963151                 */
    30973152                if (proto == ETHERTYPE_IPV6)
    3098                         return gen_true();              /* always true */
     3153                        return gen_true(cstate);        /* always true */
    30993154
    31003155                /* Checking for something other than IPv6; always false */
    3101                 return gen_false();
     3156                return gen_false(cstate);
    31023157                /*NOTREACHED*/
    31033158                break;
     
    31123167                 */
    31133168                proto = ethertype_to_ppptype(proto);
    3114                 return gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
     3169                return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, (bpf_int32)proto);
    31153170                /*NOTREACHED*/
    31163171                break;
     
    31283183                         * XXX - do this for other forms of PPP?
    31293184                         */
    3130                         b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_IP);
    3131                         b1 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_VJC);
     3185                        b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, PPP_IP);
     3186                        b1 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, PPP_VJC);
    31323187                        gen_or(b0, b1);
    3133                         b0 = gen_cmp(OR_LINK, off_linktype, BPF_H, PPP_VJNC);
     3188                        b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, PPP_VJNC);
    31343189                        gen_or(b1, b0);
    31353190                        return b0;
     
    31373192                default:
    31383193                        proto = ethertype_to_ppptype(proto);
    3139                         return gen_cmp(OR_LINK, off_linktype, BPF_H,
     3194                        return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H,
    31403195                                (bpf_int32)proto);
    31413196                }
     
    31463201        case DLT_LOOP:
    31473202        case DLT_ENC:
    3148                 /*
    3149                  * For DLT_NULL, the link-layer header is a 32-bit
    3150                  * word containing an AF_ value in *host* byte order,
    3151                  * and for DLT_ENC, the link-layer header begins
    3152                  * with a 32-bit work containing an AF_ value in
    3153                  * host byte order.
    3154                  *
    3155                  * In addition, if we're reading a saved capture file,
    3156                  * the host byte order in the capture may not be the
    3157                  * same as the host byte order on this machine.
    3158                  *
    3159                  * For DLT_LOOP, the link-layer header is a 32-bit
    3160                  * word containing an AF_ value in *network* byte order.
    3161                  *
    3162                  * XXX - AF_ values may, unfortunately, be platform-
    3163                  * dependent; for example, FreeBSD's AF_INET6 is 24
    3164                  * whilst NetBSD's and OpenBSD's is 26.
    3165                  *
    3166                  * This means that, when reading a capture file, just
    3167                  * checking for our AF_INET6 value won't work if the
    3168                  * capture file came from another OS.
    3169                  */
    31703203                switch (proto) {
    31713204
    31723205                case ETHERTYPE_IP:
    3173                         proto = AF_INET;
    3174                         break;
    3175 
    3176 #ifdef INET6
     3206                        return (gen_loopback_linktype(cstate, AF_INET));
     3207
    31773208                case ETHERTYPE_IPV6:
    3178                         proto = AF_INET6;
    3179                         break;
    3180 #endif
     3209                        /*
     3210                         * AF_ values may, unfortunately, be platform-
     3211                         * dependent; AF_INET isn't, because everybody
     3212                         * used 4.2BSD's value, but AF_INET6 is, because
     3213                         * 4.2BSD didn't have a value for it (given that
     3214                         * IPv6 didn't exist back in the early 1980's),
     3215                         * and they all picked their own values.
     3216                         *
     3217                         * This means that, if we're reading from a
     3218                         * savefile, we need to check for all the
     3219                         * possible values.
     3220                         *
     3221                         * If we're doing a live capture, we only need
     3222                         * to check for this platform's value; however,
     3223                         * Npcap uses 24, which isn't Windows's AF_INET6
     3224                         * value.  (Given the multiple different values,
     3225                         * programs that read pcap files shouldn't be
     3226                         * checking for their platform's AF_INET6 value
     3227                         * anyway, they should check for all of the
     3228                         * possible values. and they might as well do
     3229                         * that even for live captures.)
     3230                         */
     3231                        if (cstate->bpf_pcap->rfile != NULL) {
     3232                                /*
     3233                                 * Savefile - check for all three
     3234                                 * possible IPv6 values.
     3235                                 */
     3236                                b0 = gen_loopback_linktype(cstate, BSD_AFNUM_INET6_BSD);
     3237                                b1 = gen_loopback_linktype(cstate, BSD_AFNUM_INET6_FREEBSD);
     3238                                gen_or(b0, b1);
     3239                                b0 = gen_loopback_linktype(cstate, BSD_AFNUM_INET6_DARWIN);
     3240                                gen_or(b0, b1);
     3241                                return (b1);
     3242                        } else {
     3243                                /*
     3244                                 * Live capture, so we only need to
     3245                                 * check for the value used on this
     3246                                 * platform.
     3247                                 */
     3248#ifdef _WIN32
     3249                                /*
     3250                                 * Npcap doesn't use Windows's AF_INET6,
     3251                                 * as that collides with AF_IPX on
     3252                                 * some BSDs (both have the value 23).
     3253                                 * Instead, it uses 24.
     3254                                 */
     3255                                return (gen_loopback_linktype(cstate, 24));
     3256#else /* _WIN32 */
     3257#ifdef AF_INET6
     3258                                return (gen_loopback_linktype(cstate, AF_INET6));
     3259#else /* AF_INET6 */
     3260                                /*
     3261                                 * I guess this platform doesn't support
     3262                                 * IPv6, so we just reject all packets.
     3263                                 */
     3264                                return gen_false(cstate);
     3265#endif /* AF_INET6 */
     3266#endif /* _WIN32 */
     3267                        }
    31813268
    31823269                default:
     
    31863273                         * #defined on this platform, at least?
    31873274                         */
    3188                         return gen_false();
     3275                        return gen_false(cstate);
    31893276                }
    3190 
    3191                 if (linktype == DLT_NULL || linktype == DLT_ENC) {
    3192                         /*
    3193                          * The AF_ value is in host byte order, but
    3194                          * the BPF interpreter will convert it to
    3195                          * network byte order.
    3196                          *
    3197                          * If this is a save file, and it's from a
    3198                          * machine with the opposite byte order to
    3199                          * ours, we byte-swap the AF_ value.
    3200                          *
    3201                          * Then we run it through "htonl()", and
    3202                          * generate code to compare against the result.
    3203                          */
    3204                         if (bpf_pcap->sf.rfile != NULL &&
    3205                             bpf_pcap->sf.swapped)
    3206                                 proto = SWAPLONG(proto);
    3207                         proto = htonl(proto);
    3208                 }
    3209                 return (gen_cmp(OR_LINK, 0, BPF_W, (bpf_int32)proto));
    32103277
    32113278#ifdef HAVE_NET_PFVAR_H
     
    32163283                 */
    32173284                if (proto == ETHERTYPE_IP)
    3218                         return (gen_cmp(OR_LINK, offsetof(struct pfloghdr, af),
     3285                        return (gen_cmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, af),
    32193286                            BPF_B, (bpf_int32)AF_INET));
    32203287                else if (proto == ETHERTYPE_IPV6)
    3221                         return (gen_cmp(OR_LINK, offsetof(struct pfloghdr, af),
     3288                        return (gen_cmp(cstate, OR_LINKHDR, offsetof(struct pfloghdr, af),
    32223289                            BPF_B, (bpf_int32)AF_INET6));
    32233290                else
    3224                         return gen_false();
     3291                        return gen_false(cstate);
    32253292                /*NOTREACHED*/
    32263293                break;
     
    32363303
    32373304                default:
    3238                         return gen_false();
     3305                        return gen_false(cstate);
    32393306
    32403307                case ETHERTYPE_IPV6:
    3241                         return (gen_cmp(OR_LINK, off_linktype, BPF_B,
     3308                        return (gen_cmp(cstate, OR_LINKTYPE, 0, BPF_B,
    32423309                                (bpf_int32)ARCTYPE_INET6));
    32433310
    32443311                case ETHERTYPE_IP:
    3245                         b0 = gen_cmp(OR_LINK, off_linktype, BPF_B,
     3312                        b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_B,
    32463313                                     (bpf_int32)ARCTYPE_IP);
    3247                         b1 = gen_cmp(OR_LINK, off_linktype, BPF_B,
     3314                        b1 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_B,
    32483315                                     (bpf_int32)ARCTYPE_IP_OLD);
    32493316                        gen_or(b0, b1);
     
    32513318
    32523319                case ETHERTYPE_ARP:
    3253                         b0 = gen_cmp(OR_LINK, off_linktype, BPF_B,
     3320                        b0 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_B,
    32543321                                     (bpf_int32)ARCTYPE_ARP);
    3255                         b1 = gen_cmp(OR_LINK, off_linktype, BPF_B,
     3322                        b1 = gen_cmp(cstate, OR_LINKTYPE, 0, BPF_B,
    32563323                                     (bpf_int32)ARCTYPE_ARP_OLD);
    32573324                        gen_or(b0, b1);
     
    32593326
    32603327                case ETHERTYPE_REVARP:
    3261                         return (gen_cmp(OR_LINK, off_linktype, BPF_B,
     3328                        return (gen_cmp(cstate, OR_LINKTYPE, 0, BPF_B,
    32623329                                        (bpf_int32)ARCTYPE_REVARP));
    32633330
    32643331                case ETHERTYPE_ATALK:
    3265                         return (gen_cmp(OR_LINK, off_linktype, BPF_B,
     3332                        return (gen_cmp(cstate, OR_LINKTYPE, 0, BPF_B,
    32663333                                        (bpf_int32)ARCTYPE_ATALK));
    32673334                }
     
    32723339                switch (proto) {
    32733340                case ETHERTYPE_ATALK:
    3274                         return gen_true();
     3341                        return gen_true(cstate);
    32753342                default:
    3276                         return gen_false();
     3343                        return gen_false(cstate);
    32773344                }
    32783345                /*NOTREACHED*/
     
    32903357                         * Check for the special NLPID for IP.
    32913358                         */
    3292                         return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | 0xcc);
     3359                        return gen_cmp(cstate, OR_LINKHDR, 2, BPF_H, (0x03<<8) | 0xcc);
    32933360
    32943361                case ETHERTYPE_IPV6:
     
    32963363                         * Check for the special NLPID for IPv6.
    32973364                         */
    3298                         return gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | 0x8e);
     3365                        return gen_cmp(cstate, OR_LINKHDR, 2, BPF_H, (0x03<<8) | 0x8e);
    32993366
    33003367                case LLCSAP_ISONS:
     
    33103377                         * by the NLPID.
    33113378                         */
    3312                         b0 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO8473_CLNP);
    3313                         b1 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO9542_ESIS);
    3314                         b2 = gen_cmp(OR_LINK, 2, BPF_H, (0x03<<8) | ISO10589_ISIS);
     3379                        b0 = gen_cmp(cstate, OR_LINKHDR, 2, BPF_H, (0x03<<8) | ISO8473_CLNP);
     3380                        b1 = gen_cmp(cstate, OR_LINKHDR, 2, BPF_H, (0x03<<8) | ISO9542_ESIS);
     3381                        b2 = gen_cmp(cstate, OR_LINKHDR, 2, BPF_H, (0x03<<8) | ISO10589_ISIS);
    33153382                        gen_or(b1, b2);
    33163383                        gen_or(b0, b2);
     
    33183385
    33193386                default:
    3320                         return gen_false();
     3387                        return gen_false(cstate);
    33213388                }
    33223389                /*NOTREACHED*/
     
    33243391
    33253392        case DLT_MFR:
    3326                 bpf_error("Multi-link Frame Relay link-layer type filtering not implemented");
     3393                bpf_error(cstate, "Multi-link Frame Relay link-layer type filtering not implemented");
    33273394
    33283395        case DLT_JUNIPER_MFR:
     
    33563423                 * FIXME encapsulation specific BPF_ filters
    33573424                 */
    3358                 return gen_mcmp(OR_LINK, 0, BPF_W, 0x4d474300, 0xffffff00); /* compare the magic number */
     3425                return gen_mcmp(cstate, OR_LINKHDR, 0, BPF_W, 0x4d474300, 0xffffff00); /* compare the magic number */
     3426
     3427        case DLT_BACNET_MS_TP:
     3428                return gen_mcmp(cstate, OR_LINKHDR, 0, BPF_W, 0x55FF0000, 0xffff0000);
    33593429
    33603430        case DLT_IPNET:
    3361                 return gen_ipnet_linktype(proto);
     3431                return gen_ipnet_linktype(cstate, proto);
    33623432
    33633433        case DLT_LINUX_IRDA:
    3364                 bpf_error("IrDA link-layer type filtering not implemented");
     3434                bpf_error(cstate, "IrDA link-layer type filtering not implemented");
    33653435
    33663436        case DLT_DOCSIS:
    3367                 bpf_error("DOCSIS link-layer type filtering not implemented");
     3437                bpf_error(cstate, "DOCSIS link-layer type filtering not implemented");
    33683438
    33693439        case DLT_MTP2:
    33703440        case DLT_MTP2_WITH_PHDR:
    3371                 bpf_error("MTP2 link-layer type filtering not implemented");
     3441                bpf_error(cstate, "MTP2 link-layer type filtering not implemented");
    33723442
    33733443        case DLT_ERF:
    3374                 bpf_error("ERF link-layer type filtering not implemented");
     3444                bpf_error(cstate, "ERF link-layer type filtering not implemented");
    33753445
    33763446        case DLT_PFSYNC:
    3377                 bpf_error("PFSYNC link-layer type filtering not implemented");
     3447                bpf_error(cstate, "PFSYNC link-layer type filtering not implemented");
    33783448
    33793449        case DLT_LINUX_LAPD:
    3380                 bpf_error("LAPD link-layer type filtering not implemented");
    3381 
    3382         case DLT_USB:
     3450                bpf_error(cstate, "LAPD link-layer type filtering not implemented");
     3451
     3452        case DLT_USB_FREEBSD:
    33833453        case DLT_USB_LINUX:
    33843454        case DLT_USB_LINUX_MMAPPED:
    3385                 bpf_error("USB link-layer type filtering not implemented");
     3455        case DLT_USBPCAP:
     3456                bpf_error(cstate, "USB link-layer type filtering not implemented");
    33863457
    33873458        case DLT_BLUETOOTH_HCI_H4:
    33883459        case DLT_BLUETOOTH_HCI_H4_WITH_PHDR:
    3389                 bpf_error("Bluetooth link-layer type filtering not implemented");
     3460                bpf_error(cstate, "Bluetooth link-layer type filtering not implemented");
    33903461
    33913462        case DLT_CAN20B:
    33923463        case DLT_CAN_SOCKETCAN:
    3393                 bpf_error("CAN link-layer type filtering not implemented");
     3464                bpf_error(cstate, "CAN link-layer type filtering not implemented");
    33943465
    33953466        case DLT_IEEE802_15_4:
     
    33973468        case DLT_IEEE802_15_4_NONASK_PHY:
    33983469        case DLT_IEEE802_15_4_NOFCS:
    3399                 bpf_error("IEEE 802.15.4 link-layer type filtering not implemented");
     3470                bpf_error(cstate, "IEEE 802.15.4 link-layer type filtering not implemented");
    34003471
    34013472        case DLT_IEEE802_16_MAC_CPS_RADIO:
    3402                 bpf_error("IEEE 802.16 link-layer type filtering not implemented");
     3473                bpf_error(cstate, "IEEE 802.16 link-layer type filtering not implemented");
    34033474
    34043475        case DLT_SITA:
    3405                 bpf_error("SITA link-layer type filtering not implemented");
     3476                bpf_error(cstate, "SITA link-layer type filtering not implemented");
    34063477
    34073478        case DLT_RAIF1:
    3408                 bpf_error("RAIF1 link-layer type filtering not implemented");
     3479                bpf_error(cstate, "RAIF1 link-layer type filtering not implemented");
    34093480
    34103481        case DLT_IPMB:
    3411                 bpf_error("IPMB link-layer type filtering not implemented");
     3482                bpf_error(cstate, "IPMB link-layer type filtering not implemented");
    34123483
    34133484        case DLT_AX25_KISS:
    3414                 bpf_error("AX.25 link-layer type filtering not implemented");
    3415         }
    3416 
    3417         /*
    3418          * All the types that have no encapsulation should either be
    3419          * handled as DLT_SLIP, DLT_SLIP_BSDOS, and DLT_RAW are, if
    3420          * all packets are IP packets, or should be handled in some
    3421          * special case, if none of them are (if some are and some
    3422          * aren't, the lack of encapsulation is a problem, as we'd
    3423          * have to find some other way of determining the packet type).
    3424          *
    3425          * Therefore, if "off_linktype" is -1, there's an error.
    3426          */
    3427         if (off_linktype == (u_int)-1)
    3428                 abort();
    3429 
    3430         /*
    3431          * Any type not handled above should always have an Ethernet
    3432          * type at an offset of "off_linktype".
    3433          */
    3434         return gen_cmp(OR_LINK, off_linktype, BPF_H, (bpf_int32)proto);
     3485                bpf_error(cstate, "AX.25 link-layer type filtering not implemented");
     3486
     3487        case DLT_NFLOG:
     3488                /* Using the fixed-size NFLOG header it is possible to tell only
     3489                 * the address family of the packet, other meaningful data is
     3490                 * either missing or behind TLVs.
     3491                 */
     3492                bpf_error(cstate, "NFLOG link-layer type filtering not implemented");
     3493
     3494        default:
     3495                /*
     3496                 * Does this link-layer header type have a field
     3497                 * indicating the type of the next protocol?  If
     3498                 * so, off_linktype.constant_part will be the offset of that
     3499                 * field in the packet; if not, it will be OFFSET_NOT_SET.
     3500                 */
     3501                if (cstate->off_linktype.constant_part != OFFSET_NOT_SET) {
     3502                        /*
     3503                         * Yes; assume it's an Ethernet type.  (If
     3504                         * it's not, it needs to be handled specially
     3505                         * above.)
     3506                         */
     3507                        return gen_cmp(cstate, OR_LINKTYPE, 0, BPF_H, (bpf_int32)proto);
     3508                } else {
     3509                        /*
     3510                         * No; report an error.
     3511                         */
     3512                        description = pcap_datalink_val_to_description(cstate->linktype);
     3513                        if (description != NULL) {
     3514                                bpf_error(cstate, "%s link-layer type filtering not implemented",
     3515                                    description);
     3516                        } else {
     3517                                bpf_error(cstate, "DLT %u link-layer type filtering not implemented",
     3518                                    cstate->linktype);
     3519                        }
     3520                }
     3521                break;
     3522        }
    34353523}
    34363524
     
    34433531 */
    34443532static struct block *
    3445 gen_snap(orgcode, ptype)
    3446         bpf_u_int32 orgcode;
    3447         bpf_u_int32 ptype;
     3533gen_snap(compiler_state_t *cstate, bpf_u_int32 orgcode, bpf_u_int32 ptype)
    34483534{
    34493535        u_char snapblock[8];
     
    34573543        snapblock[6] = (ptype >> 8);    /* upper 8 bits of protocol type */
    34583544        snapblock[7] = (ptype >> 0);    /* lower 8 bits of protocol type */
    3459         return gen_bcmp(OR_MACPL, 0, 8, snapblock);
     3545        return gen_bcmp(cstate, OR_LLC, 0, 8, snapblock);
     3546}
     3547
     3548/*
     3549 * Generate code to match frames with an LLC header.
     3550 */
     3551struct block *
     3552gen_llc(compiler_state_t *cstate)
     3553{
     3554        struct block *b0, *b1;
     3555
     3556        switch (cstate->linktype) {
     3557
     3558        case DLT_EN10MB:
     3559                /*
     3560                 * We check for an Ethernet type field less than
     3561                 * 1500, which means it's an 802.3 length field.
     3562                 */
     3563                b0 = gen_cmp_gt(cstate, OR_LINKTYPE, 0, BPF_H, ETHERMTU);
     3564                gen_not(b0);
     3565
     3566                /*
     3567                 * Now check for the purported DSAP and SSAP not being
     3568                 * 0xFF, to rule out NetWare-over-802.3.
     3569                 */
     3570                b1 = gen_cmp(cstate, OR_LLC, 0, BPF_H, (bpf_int32)0xFFFF);
     3571                gen_not(b1);
     3572                gen_and(b0, b1);
     3573                return b1;
     3574
     3575        case DLT_SUNATM:
     3576                /*
     3577                 * We check for LLC traffic.
     3578                 */
     3579                b0 = gen_atmtype_abbrev(cstate, A_LLC);
     3580                return b0;
     3581
     3582        case DLT_IEEE802:       /* Token Ring */
     3583                /*
     3584                 * XXX - check for LLC frames.
     3585                 */
     3586                return gen_true(cstate);
     3587
     3588        case DLT_FDDI:
     3589                /*
     3590                 * XXX - check for LLC frames.
     3591                 */
     3592                return gen_true(cstate);
     3593
     3594        case DLT_ATM_RFC1483:
     3595                /*
     3596                 * For LLC encapsulation, these are defined to have an
     3597                 * 802.2 LLC header.
     3598                 *
     3599                 * For VC encapsulation, they don't, but there's no
     3600                 * way to check for that; the protocol used on the VC
     3601                 * is negotiated out of band.
     3602                 */
     3603                return gen_true(cstate);
     3604
     3605        case DLT_IEEE802_11:
     3606        case DLT_PRISM_HEADER:
     3607        case DLT_IEEE802_11_RADIO:
     3608        case DLT_IEEE802_11_RADIO_AVS:
     3609        case DLT_PPI:
     3610                /*
     3611                 * Check that we have a data frame.
     3612                 */
     3613                b0 = gen_check_802_11_data_frame(cstate);
     3614                return b0;
     3615
     3616        default:
     3617                bpf_error(cstate, "'llc' not supported for linktype %d", cstate->linktype);
     3618                /* NOTREACHED */
     3619        }
     3620}
     3621
     3622struct block *
     3623gen_llc_i(compiler_state_t *cstate)
     3624{
     3625        struct block *b0, *b1;
     3626        struct slist *s;
     3627
     3628        /*
     3629         * Check whether this is an LLC frame.
     3630         */
     3631        b0 = gen_llc(cstate);
     3632
     3633        /*
     3634         * Load the control byte and test the low-order bit; it must
     3635         * be clear for I frames.
     3636         */
     3637        s = gen_load_a(cstate, OR_LLC, 2, BPF_B);
     3638        b1 = new_block(cstate, JMP(BPF_JSET));
     3639        b1->s.k = 0x01;
     3640        b1->stmts = s;
     3641        gen_not(b1);
     3642        gen_and(b0, b1);
     3643        return b1;
     3644}
     3645
     3646struct block *
     3647gen_llc_s(compiler_state_t *cstate)
     3648{
     3649        struct block *b0, *b1;
     3650
     3651        /*
     3652         * Check whether this is an LLC frame.
     3653         */
     3654        b0 = gen_llc(cstate);
     3655
     3656        /*
     3657         * Now compare the low-order 2 bit of the control byte against
     3658         * the appropriate value for S frames.
     3659         */
     3660        b1 = gen_mcmp(cstate, OR_LLC, 2, BPF_B, LLC_S_FMT, 0x03);
     3661        gen_and(b0, b1);
     3662        return b1;
     3663}
     3664
     3665struct block *
     3666gen_llc_u(compiler_state_t *cstate)
     3667{
     3668        struct block *b0, *b1;
     3669
     3670        /*
     3671         * Check whether this is an LLC frame.
     3672         */
     3673        b0 = gen_llc(cstate);
     3674
     3675        /*
     3676         * Now compare the low-order 2 bit of the control byte against
     3677         * the appropriate value for U frames.
     3678         */
     3679        b1 = gen_mcmp(cstate, OR_LLC, 2, BPF_B, LLC_U_FMT, 0x03);
     3680        gen_and(b0, b1);
     3681        return b1;
     3682}
     3683
     3684struct block *
     3685gen_llc_s_subtype(compiler_state_t *cstate, bpf_u_int32 subtype)
     3686{
     3687        struct block *b0, *b1;
     3688
     3689        /*
     3690         * Check whether this is an LLC frame.
     3691         */
     3692        b0 = gen_llc(cstate);
     3693
     3694        /*
     3695         * Now check for an S frame with the appropriate type.
     3696         */
     3697        b1 = gen_mcmp(cstate, OR_LLC, 2, BPF_B, subtype, LLC_S_CMD_MASK);
     3698        gen_and(b0, b1);
     3699        return b1;
     3700}
     3701
     3702struct block *
     3703gen_llc_u_subtype(compiler_state_t *cstate, bpf_u_int32 subtype)
     3704{
     3705        struct block *b0, *b1;
     3706
     3707        /*
     3708         * Check whether this is an LLC frame.
     3709         */
     3710        b0 = gen_llc(cstate);
     3711
     3712        /*
     3713         * Now check for a U frame with the appropriate type.
     3714         */
     3715        b1 = gen_mcmp(cstate, OR_LLC, 2, BPF_B, subtype, LLC_U_CMD_MASK);
     3716        gen_and(b0, b1);
     3717        return b1;
    34603718}
    34613719
     
    34733731 */
    34743732static struct block *
    3475 gen_llc_linktype(proto)
    3476         int proto;
     3733gen_llc_linktype(compiler_state_t *cstate, int proto)
    34773734{
    34783735        /*
     
    34873744                 * XXX - should we check both the DSAP and the
    34883745                 * SSAP, like this, or should we check just the
    3489                  * DSAP, as we do for other types <= ETHERMTU
    3490                  * (i.e., other SAP values)?
    3491                  */
    3492                 return gen_cmp(OR_MACPL, 0, BPF_H, (bpf_u_int32)
     3746                 * DSAP, as we do for other SAP values?
     3747                 */
     3748                return gen_cmp(cstate, OR_LLC, 0, BPF_H, (bpf_u_int32)
    34933749                             ((proto << 8) | proto));
    34943750
     
    34983754                 * non-Ethernet 802.x networks?
    34993755                 */
    3500                 return gen_cmp(OR_MACPL, 0, BPF_B,
     3756                return gen_cmp(cstate, OR_LLC, 0, BPF_B,
    35013757                    (bpf_int32)LLCSAP_IPX);
    35023758
     
    35113767                 * encapsulated Ethernet as well?
    35123768                 */
    3513                 return gen_snap(0x080007, ETHERTYPE_ATALK);
     3769                return gen_snap(cstate, 0x080007, ETHERTYPE_ATALK);
    35143770
    35153771        default:
     
    35233779                         * the DSAP.
    35243780                         */
    3525                         return gen_cmp(OR_MACPL, 0, BPF_B, (bpf_int32)proto);
     3781                        return gen_cmp(cstate, OR_LLC, 0, BPF_B, (bpf_int32)proto);
    35263782                } else {
    35273783                        /*
     
    35383794                         * Ethernet), we'd do
    35393795                         *
    3540                          *      return gen_snap(0x000000, proto);
     3796                         *      return gen_snap(cstate, 0x000000, proto);
    35413797                         *
    35423798                         * here; for now, we don't, as per the above.
     
    35443800                         * time to do the right check or not.
    35453801                         */
    3546                         return gen_cmp(OR_MACPL, 6, BPF_H, (bpf_int32)proto);
     3802                        return gen_cmp(cstate, OR_LLC, 6, BPF_H, (bpf_int32)proto);
    35473803                }
    35483804        }
     
    35503806
    35513807static struct block *
    3552 gen_hostop(addr, mask, dir, proto, src_off, dst_off)
    3553         bpf_u_int32 addr;
    3554         bpf_u_int32 mask;
    3555         int dir, proto;
    3556         u_int src_off, dst_off;
     3808gen_hostop(compiler_state_t *cstate, bpf_u_int32 addr, bpf_u_int32 mask,
     3809    int dir, int proto, u_int src_off, u_int dst_off)
    35573810{
    35583811        struct block *b0, *b1;
     
    35703823
    35713824        case Q_AND:
    3572                 b0 = gen_hostop(addr, mask, Q_SRC, proto, src_off, dst_off);
    3573                 b1 = gen_hostop(addr, mask, Q_DST, proto, src_off, dst_off);
     3825                b0 = gen_hostop(cstate, addr, mask, Q_SRC, proto, src_off, dst_off);
     3826                b1 = gen_hostop(cstate, addr, mask, Q_DST, proto, src_off, dst_off);
    35743827                gen_and(b0, b1);
    35753828                return b1;
     
    35773830        case Q_OR:
    35783831        case Q_DEFAULT:
    3579                 b0 = gen_hostop(addr, mask, Q_SRC, proto, src_off, dst_off);
    3580                 b1 = gen_hostop(addr, mask, Q_DST, proto, src_off, dst_off);
     3832                b0 = gen_hostop(cstate, addr, mask, Q_SRC, proto, src_off, dst_off);
     3833                b1 = gen_hostop(cstate, addr, mask, Q_DST, proto, src_off, dst_off);
    35813834                gen_or(b0, b1);
    35823835                return b1;
     
    35853838                abort();
    35863839        }
    3587         b0 = gen_linktype(proto);
    3588         b1 = gen_mcmp(OR_NET, offset, BPF_W, (bpf_int32)addr, mask);
     3840        b0 = gen_linktype(cstate, proto);
     3841        b1 = gen_mcmp(cstate, OR_LINKPL, offset, BPF_W, (bpf_int32)addr, mask);
    35893842        gen_and(b0, b1);
    35903843        return b1;
     
    35933846#ifdef INET6
    35943847static struct block *
    3595 gen_hostop6(addr, mask, dir, proto, src_off, dst_off)
    3596         struct in6_addr *addr;
    3597         struct in6_addr *mask;
    3598         int dir, proto;
    3599         u_int src_off, dst_off;
     3848gen_hostop6(compiler_state_t *cstate, struct in6_addr *addr,
     3849    struct in6_addr *mask, int dir, int proto, u_int src_off, u_int dst_off)
    36003850{
    36013851        struct block *b0, *b1;
     
    36143864
    36153865        case Q_AND:
    3616                 b0 = gen_hostop6(addr, mask, Q_SRC, proto, src_off, dst_off);
    3617                 b1 = gen_hostop6(addr, mask, Q_DST, proto, src_off, dst_off);
     3866                b0 = gen_hostop6(cstate, addr, mask, Q_SRC, proto, src_off, dst_off);
     3867                b1 = gen_hostop6(cstate, addr, mask, Q_DST, proto, src_off, dst_off);
    36183868                gen_and(b0, b1);
    36193869                return b1;
     
    36213871        case Q_OR:
    36223872        case Q_DEFAULT:
    3623                 b0 = gen_hostop6(addr, mask, Q_SRC, proto, src_off, dst_off);
    3624                 b1 = gen_hostop6(addr, mask, Q_DST, proto, src_off, dst_off);
     3873                b0 = gen_hostop6(cstate, addr, mask, Q_SRC, proto, src_off, dst_off);
     3874                b1 = gen_hostop6(cstate, addr, mask, Q_DST, proto, src_off, dst_off);
    36253875                gen_or(b0, b1);
    36263876                return b1;
     
    36323882        a = (u_int32_t *)addr;
    36333883        m = (u_int32_t *)mask;
    3634         b1 = gen_mcmp(OR_NET, offset + 12, BPF_W, ntohl(a[3]), ntohl(m[3]));
    3635         b0 = gen_mcmp(OR_NET, offset + 8, BPF_W, ntohl(a[2]), ntohl(m[2]));
     3884        b1 = gen_mcmp(cstate, OR_LINKPL, offset + 12, BPF_W, ntohl(a[3]), ntohl(m[3]));
     3885        b0 = gen_mcmp(cstate, OR_LINKPL, offset + 8, BPF_W, ntohl(a[2]), ntohl(m[2]));
    36363886        gen_and(b0, b1);
    3637         b0 = gen_mcmp(OR_NET, offset + 4, BPF_W, ntohl(a[1]), ntohl(m[1]));
     3887        b0 = gen_mcmp(cstate, OR_LINKPL, offset + 4, BPF_W, ntohl(a[1]), ntohl(m[1]));
    36383888        gen_and(b0, b1);
    3639         b0 = gen_mcmp(OR_NET, offset + 0, BPF_W, ntohl(a[0]), ntohl(m[0]));
     3889        b0 = gen_mcmp(cstate, OR_LINKPL, offset + 0, BPF_W, ntohl(a[0]), ntohl(m[0]));
    36403890        gen_and(b0, b1);
    3641         b0 = gen_linktype(proto);
     3891        b0 = gen_linktype(cstate, proto);
    36423892        gen_and(b0, b1);
    36433893        return b1;
     
    36463896
    36473897static struct block *
    3648 gen_ehostop(eaddr, dir)
    3649         register const u_char *eaddr;
    3650         register int dir;
     3898gen_ehostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
    36513899{
    36523900        register struct block *b0, *b1;
     
    36543902        switch (dir) {
    36553903        case Q_SRC:
    3656                 return gen_bcmp(OR_LINK, off_mac + 6, 6, eaddr);
     3904                return gen_bcmp(cstate, OR_LINKHDR, 6, 6, eaddr);
    36573905
    36583906        case Q_DST:
    3659                 return gen_bcmp(OR_LINK, off_mac + 0, 6, eaddr);
     3907                return gen_bcmp(cstate, OR_LINKHDR, 0, 6, eaddr);
    36603908
    36613909        case Q_AND:
    3662                 b0 = gen_ehostop(eaddr, Q_SRC);
    3663                 b1 = gen_ehostop(eaddr, Q_DST);
     3910                b0 = gen_ehostop(cstate, eaddr, Q_SRC);
     3911                b1 = gen_ehostop(cstate, eaddr, Q_DST);
    36643912                gen_and(b0, b1);
    36653913                return b1;
     
    36673915        case Q_DEFAULT:
    36683916        case Q_OR:
    3669                 b0 = gen_ehostop(eaddr, Q_SRC);
    3670                 b1 = gen_ehostop(eaddr, Q_DST);
     3917                b0 = gen_ehostop(cstate, eaddr, Q_SRC);
     3918                b1 = gen_ehostop(cstate, eaddr, Q_DST);
    36713919                gen_or(b0, b1);
    36723920                return b1;
    36733921
    36743922        case Q_ADDR1:
    3675                 bpf_error("'addr1' is only supported on 802.11 with 802.11 headers");
     3923                bpf_error(cstate, "'addr1' is only supported on 802.11 with 802.11 headers");
    36763924                break;
    36773925
    36783926        case Q_ADDR2:
    3679                 bpf_error("'addr2' is only supported on 802.11 with 802.11 headers");
     3927                bpf_error(cstate, "'addr2' is only supported on 802.11 with 802.11 headers");
    36803928                break;
    36813929
    36823930        case Q_ADDR3:
    3683                 bpf_error("'addr3' is only supported on 802.11 with 802.11 headers");
     3931                bpf_error(cstate, "'addr3' is only supported on 802.11 with 802.11 headers");
    36843932                break;
    36853933
    36863934        case Q_ADDR4:
    3687                 bpf_error("'addr4' is only supported on 802.11 with 802.11 headers");
     3935                bpf_error(cstate, "'addr4' is only supported on 802.11 with 802.11 headers");
    36883936                break;
    36893937
    36903938        case Q_RA:
    3691                 bpf_error("'ra' is only supported on 802.11 with 802.11 headers");
     3939                bpf_error(cstate, "'ra' is only supported on 802.11 with 802.11 headers");
    36923940                break;
    36933941
    36943942        case Q_TA:
    3695                 bpf_error("'ta' is only supported on 802.11 with 802.11 headers");
     3943                bpf_error(cstate, "'ta' is only supported on 802.11 with 802.11 headers");
    36963944                break;
    36973945        }
     
    37043952 */
    37053953static struct block *
    3706 gen_fhostop(eaddr, dir)
    3707         register const u_char *eaddr;
    3708         register int dir;
     3954gen_fhostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
    37093955{
    37103956        struct block *b0, *b1;
     
    37123958        switch (dir) {
    37133959        case Q_SRC:
    3714 #ifdef PCAP_FDDIPAD
    3715                 return gen_bcmp(OR_LINK, 6 + 1 + pcap_fddipad, 6, eaddr);
    3716 #else
    3717                 return gen_bcmp(OR_LINK, 6 + 1, 6, eaddr);
    3718 #endif
     3960                return gen_bcmp(cstate, OR_LINKHDR, 6 + 1 + cstate->pcap_fddipad, 6, eaddr);
    37193961
    37203962        case Q_DST:
    3721 #ifdef PCAP_FDDIPAD
    3722                 return gen_bcmp(OR_LINK, 0 + 1 + pcap_fddipad, 6, eaddr);
    3723 #else
    3724                 return gen_bcmp(OR_LINK, 0 + 1, 6, eaddr);
    3725 #endif
     3963                return gen_bcmp(cstate, OR_LINKHDR, 0 + 1 + cstate->pcap_fddipad, 6, eaddr);
    37263964
    37273965        case Q_AND:
    3728                 b0 = gen_fhostop(eaddr, Q_SRC);
    3729                 b1 = gen_fhostop(eaddr, Q_DST);
     3966                b0 = gen_fhostop(cstate, eaddr, Q_SRC);
     3967                b1 = gen_fhostop(cstate, eaddr, Q_DST);
    37303968                gen_and(b0, b1);
    37313969                return b1;
     
    37333971        case Q_DEFAULT:
    37343972        case Q_OR:
    3735                 b0 = gen_fhostop(eaddr, Q_SRC);
    3736                 b1 = gen_fhostop(eaddr, Q_DST);
     3973                b0 = gen_fhostop(cstate, eaddr, Q_SRC);
     3974                b1 = gen_fhostop(cstate, eaddr, Q_DST);
    37373975                gen_or(b0, b1);
    37383976                return b1;
    37393977
    37403978        case Q_ADDR1:
    3741                 bpf_error("'addr1' is only supported on 802.11");
     3979                bpf_error(cstate, "'addr1' is only supported on 802.11");
    37423980                break;
    37433981
    37443982        case Q_ADDR2:
    3745                 bpf_error("'addr2' is only supported on 802.11");
     3983                bpf_error(cstate, "'addr2' is only supported on 802.11");
    37463984                break;
    37473985
    37483986        case Q_ADDR3:
    3749                 bpf_error("'addr3' is only supported on 802.11");
     3987                bpf_error(cstate, "'addr3' is only supported on 802.11");
    37503988                break;
    37513989
    37523990        case Q_ADDR4:
    3753                 bpf_error("'addr4' is only supported on 802.11");
     3991                bpf_error(cstate, "'addr4' is only supported on 802.11");
    37543992                break;
    37553993
    37563994        case Q_RA:
    3757                 bpf_error("'ra' is only supported on 802.11");
     3995                bpf_error(cstate, "'ra' is only supported on 802.11");
    37583996                break;
    37593997
    37603998        case Q_TA:
    3761                 bpf_error("'ta' is only supported on 802.11");
     3999                bpf_error(cstate, "'ta' is only supported on 802.11");
    37624000                break;
    37634001        }
     
    37704008 */
    37714009static struct block *
    3772 gen_thostop(eaddr, dir)
    3773         register const u_char *eaddr;
    3774         register int dir;
     4010gen_thostop(compiler_state_t *cstate, const u_char *eaddr, int dir)
    37754011{
    37764012        register struct block *b0, *b1;
     
    377840