/*

 * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998

 *  The Regents of the University of California.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that: (1) source code distributions

 * retain the above copyright notice and this paragraph in its entirety, (2)

 * distributions including binary code include the above copyright notice and

 * this paragraph in its entirety in the documentation or other materials

 * provided with the distribution, and (3) all advertising materials mentioning

 * features or use of this software display the following acknowledgement:

 * ``This product includes software developed by the University of California,

 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of

 * the University nor the names of its contributors may be used to endorse

 * or promote products derived from this software without specific prior

 * written permission.

 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED

 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#ifdef _WIN32

  #include <ws2tcpip.h>

#else

  #include <sys/socket.h>

  #ifdef __NetBSD__

    #include <sys/param.h>

  #endif

  #include <netinet/in.h>

  #include <arpa/inet.h>

#endif /* _WIN32 */

#include <stdlib.h>

#include <string.h>

#include <memory.h>

#include <setjmp.h>

#include <stdarg.h>

#include <stdio.h>

#include "pcap-int.h"

#include "extract.h"

#include "ethertype.h"

#include "nlpid.h"

#include "llc.h"

#include "gencode.h"

#include "ieee80211.h"

#include "atmuni31.h"

#include "sunatmpos.h"

#include "pflog.h"

#include "ppp.h"

#include "pcap/sll.h"

#include "pcap/ipnet.h"

#include "arcnet.h"

#include "diag-control.h"

#include "scanner.h"

#if defined(linux)

#include <linux/types.h>

#include <linux/if_packet.h>

#include <linux/filter.h>

#endif

#ifndef offsetof

#define offsetof(s, e) ((size_t)&((s *)0)->e)

#endif

#ifdef _WIN32

  #ifdef INET6

    #if defined(__MINGW32__) && defined(DEFINE_ADDITIONAL_IPV6_STUFF)

/* IPv6 address */

struct in6_addr

  {

    union

      {

  uint8_t   u6_addr8[16];

  uint16_t  u6_addr16[8];

  uint32_t  u6_addr32[4];

      } in6_u;

#define s6_addr     in6_u.u6_addr8

#define s6_addr16   in6_u.u6_addr16

#define s6_addr32   in6_u.u6_addr32

#define s6_addr64   in6_u.u6_addr64

  };

typedef unsigned short  sa_family_t;

#define __SOCKADDR_COMMON(sa_prefix) \

  sa_family_t sa_prefix##family

/* Ditto, for IPv6.  */

struct sockaddr_in6

  {

    __SOCKADDR_COMMON (sin6_);

    uint16_t sin6_port;   /* Transport layer port # */

    uint32_t sin6_flowinfo; /* IPv6 flow information */

    struct in6_addr sin6_addr;  /* IPv6 address */

  };

      #ifndef EAI_ADDRFAMILY

struct addrinfo {

  int ai_flags; /* AI_PASSIVE, AI_CANONNAME */

  int ai_family;  /* PF_xxx */

  int ai_socktype;  /* SOCK_xxx */

  int ai_protocol;  /* 0 or IPPROTO_xxx for IPv4 and IPv6 */

  size_t  ai_addrlen; /* length of ai_addr */

  char  *ai_canonname;  /* canonical name for hostname */

  struct sockaddr *ai_addr; /* binary address */

  struct addrinfo *ai_next; /* next structure in linked list */

};

      #endif /* EAI_ADDRFAMILY */

    #endif /* defined(__MINGW32__) && defined(DEFINE_ADDITIONAL_IPV6_STUFF) */

  #endif /* INET6 */

#else /* _WIN32 */

  #include <netdb.h>  /* for "struct addrinfo" */

#endif /* _WIN32 */

#include <pcap/namedb.h>

#include "nametoaddr.h"

#define ETHERMTU  1500

#ifndef IPPROTO_HOPOPTS

#define IPPROTO_HOPOPTS 0

#endif

#ifndef IPPROTO_ROUTING

#define IPPROTO_ROUTING 43

#endif

#ifndef IPPROTO_FRAGMENT

#define IPPROTO_FRAGMENT 44

#endif

#ifndef IPPROTO_DSTOPTS

#define IPPROTO_DSTOPTS 60

#endif

#ifndef IPPROTO_SCTP

#define IPPROTO_SCTP 132

#endif

#define GENEVE_PORT 6081

#ifdef HAVE_OS_PROTO_H

#include "os-proto.h"

#endif

#define JMP(c) ((c)|BPF_JMP|BPF_K)

/*

 * "Push" the current value of the link-layer header type and link-layer

 * header offset onto a "stack", and set a new value.  (It's not a

 * full-blown stack; we keep only the top two items.)

 */

#define PUSH_LINKHDR(cs, new_linktype, new_is_variable, new_constant_part, new_reg) \

{ \

  (cs)->prevlinktype = (cs)->linktype; \

  (cs)->off_prevlinkhdr = (cs)->off_linkhdr; \

  (cs)->linktype = (new_linktype); \

  (cs)->off_linkhdr.is_variable = (new_is_variable); \

  (cs)->off_linkhdr.constant_part = (new_constant_part); \

  (cs)->off_linkhdr.reg = (new_reg); \

  (cs)->is_geneve = 0; \

}

/*

 * Offset "not set" value.

 */

#define OFFSET_NOT_SET  0xffffffffU

/*

 * Absolute offsets, which are offsets from the beginning of the raw

 * packet data, are, in the general case, the sum of a variable value

 * and a constant value; the variable value may be absent, in which

 * case the offset is only the constant value, and the constant value

 * may be zero, in which case the offset is only the variable value.

 *

 * bpf_abs_offset is a structure containing all that information:

 *

 *   is_variable is 1 if there's a variable part.

 *

 *   constant_part is the constant part of the value, possibly zero;

 *

 *   if is_variable is 1, reg is the register number for a register

 *   containing the variable value if the register has been assigned,

 *   and -1 otherwise.

 */

typedef struct {

  int is_variable;

  u_int constant_part;

  int reg;

} bpf_abs_offset;

/*

 * Value passed to gen_load_a() to indicate what the offset argument

 * is relative to the beginning of.

 */

enum e_offrel {

  OR_PACKET,    /* full packet data */

  OR_LINKHDR,   /* link-layer header */

  OR_PREVLINKHDR,   /* previous link-layer header */

  OR_LLC,     /* 802.2 LLC header */

  OR_PREVMPLSHDR,   /* previous MPLS header */

  OR_LINKTYPE,    /* link-layer type */

  OR_LINKPL,    /* link-layer payload */

  OR_LINKPL_NOSNAP, /* link-layer payload, with no SNAP header at the link layer */

  OR_TRAN_IPV4,   /* transport-layer header, with IPv4 network layer */

  OR_TRAN_IPV6    /* transport-layer header, with IPv6 network layer */

};

/*

 * We divvy out chunks of memory rather than call malloc each time so

 * we don't have to worry about leaking memory.  It's probably

 * not a big deal if all this memory was wasted but if this ever

 * goes into a library that would probably not be a good idea.

 *

 * XXX - this *is* in a library....

 */

#define NCHUNKS 16

#define CHUNK0SIZE 1024

struct chunk {

  size_t n_left;

  void *m;

};

/*

 * A chunk can store any of:

 *  - a string (guaranteed alignment 1 but present for completeness)

 *  - a block

 *  - an slist

 *  - an arth

 * For this simple allocator every allocated chunk gets rounded up to the

 * alignment needed for any chunk.

 */

struct chunk_align {

  char dummy;

  union {

    char c;

    struct block b;

    struct slist s;

    struct arth a;

  } u;

};

#define CHUNK_ALIGN (offsetof(struct chunk_align, u))

/* Code generator state */

struct _compiler_state {

  jmp_buf top_ctx;

  pcap_t *bpf_pcap;

  int error_set;

  struct icode ic;

  int snaplen;

  int linktype;

  int prevlinktype;

  int outermostlinktype;

  bpf_u_int32 netmask;

  int no_optimize;

  /* Hack for handling VLAN and MPLS stacks. */

  u_int label_stack_depth;

  u_int vlan_stack_depth;

  /* XXX */

  u_int pcap_fddipad;

  /*

   * As errors are handled by a longjmp, anything allocated must

   * be freed in the longjmp handler, so it must be reachable

   * from that handler.

   *

   * One thing that's allocated is the result of pcap_nametoaddrinfo();

   * it must be freed with freeaddrinfo().  This variable points to

   * any addrinfo structure that would need to be freed.

   */

  struct addrinfo *ai;

  /*

   * Another thing that's allocated is the result of pcap_ether_aton();

   * it must be freed with free().  This variable points to any

   * address that would need to be freed.

   */

  u_char *e;

  /*

   * Various code constructs need to know the layout of the packet.

   * These values give the necessary offsets from the beginning

   * of the packet data.

   */

  /*

   * Absolute offset of the beginning of the link-layer header.

   */

  bpf_abs_offset off_linkhdr;

  /*

   * If we're checking a link-layer header for a packet encapsulated

   * in another protocol layer, this is the equivalent information

   * for the previous layers' link-layer header from the beginning

   * of the raw packet data.

   */

  bpf_abs_offset off_prevlinkhdr;

  /*

   * This is the equivalent information for the outermost layers'

   * link-layer header.

   */

  bpf_abs_offset off_outermostlinkhdr;

  /*

   * Absolute offset of the beginning of the link-layer payload.

   */

  bpf_abs_offset off_linkpl;

  /*

   * "off_linktype" is the offset to information in the link-layer

   * header giving the packet type. This is an absolute offset

   * from the beginning of the packet.

   *

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

   * means that it must have a value that skips VLAN tags.

   *

   * For link-layer types that always use 802.2 headers, it's the

   * offset of the LLC header; this means that it must have a value

   * that skips VLAN tags.

   *

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

   *

   * For Cisco HDLC, it's the offset of the CHDLC type field.

   *

   * For BSD loopback, it's the offset of the AF_ value.

   *

   * For Linux cooked sockets, it's the offset of the type field.

   *

   * off_linktype.constant_part is set to OFFSET_NOT_SET for no

   * encapsulation, in which case, IP is assumed.

   */

  bpf_abs_offset off_linktype;

  /*

   * TRUE if the link layer includes an ATM pseudo-header.

   */

  int is_atm;

  /*

   * TRUE if "geneve" appeared in the filter; it causes us to

   * generate code that checks for a Geneve header and assume

   * that later filters apply to the encapsulated payload.

   */

  int is_geneve;

  /*

   * TRUE if we need variable length part of VLAN offset

   */

  int is_vlan_vloffset;

  /*

   * These are offsets for the ATM pseudo-header.

   */

  u_int off_vpi;

  u_int off_vci;

  u_int off_proto;

  /*

   * These are offsets for the MTP2 fields.

   */

  u_int off_li;

  u_int off_li_hsl;

  /*

   * These are offsets for the MTP3 fields.

   */

  u_int off_sio;

  u_int off_opc;

  u_int off_dpc;

  u_int off_sls;

  /*

   * This is the offset of the first byte after the ATM pseudo_header,

   * or -1 if there is no ATM pseudo-header.

   */

  u_int off_payload;

  /*

   * These are offsets to the beginning of the network-layer header.

   * They are relative to the beginning of the link-layer payload

   * (i.e., they don't include off_linkhdr.constant_part or

   * off_linkpl.constant_part).

   *

   * If the link layer never uses 802.2 LLC:

   *

   *  "off_nl" and "off_nl_nosnap" are the same.

   *

   * If the link layer always uses 802.2 LLC:

   *

   *  "off_nl" is the offset if there's a SNAP header following

   *  the 802.2 header;

   *

   *  "off_nl_nosnap" is the offset if there's no SNAP header.

   *

   * If the link layer is Ethernet:

   *

   *  "off_nl" is the offset if the packet is an Ethernet II packet

   *  (we assume no 802.3+802.2+SNAP);

   *

   *  "off_nl_nosnap" is the offset if the packet is an 802.3 packet

   *  with an 802.2 header following it.

   */

  u_int off_nl;

  u_int off_nl_nosnap;

  /*

   * Here we handle simple allocation of the scratch registers.

   * If too many registers are alloc'd, the allocator punts.

   */

  int regused[BPF_MEMWORDS];

  int curreg;

  /*

   * Memory chunks.

   */

  struct chunk chunks[NCHUNKS];

  int cur_chunk;

};

/*

 * For use by routines outside this file.

 */

/* VARARGS */

void

bpf_set_error(compiler_state_t *cstate, const char *fmt, ...)

{

  va_list ap;

  /*

   * If we've already set an error, don't override it.

   * The lexical analyzer reports some errors by setting

   * the error and then returning a LEX_ERROR token, which

   * is not recognized by any grammar rule, and thus forces

   * the parse to stop.  We don't want the error reported

   * by the lexical analyzer to be overwritten by the syntax

   * error.

   */

  if (!cstate->error_set) {

    va_start(ap, fmt);

    (void)vsnprintf(cstate->bpf_pcap->errbuf, PCAP_ERRBUF_SIZE,

        fmt, ap);

    va_end(ap);

    cstate->error_set = 1;

  }

}

/*

 * For use *ONLY* in routines in this file.

 */

static void PCAP_NORETURN bpf_error(compiler_state_t *, const char *, ...)

    PCAP_PRINTFLIKE(2, 3);

/* VARARGS */

static void PCAP_NORETURN

bpf_error(compiler_state_t *cstate, const char *fmt, ...)

{

  va_list ap;

  va_start(ap, fmt);

  (void)vsnprintf(cstate->bpf_pcap->errbuf, PCAP_ERRBUF_SIZE,

      fmt, ap);

  va_end(ap);

  longjmp(cstate->top_ctx, 1);

  /*NOTREACHED*/

#ifdef _AIX

  PCAP_UNREACHABLE

#endif /* _AIX */

}

static int init_linktype(compiler_state_t *, pcap_t *);

static void init_regs(compiler_state_t *);

static int alloc_reg(compiler_state_t *);

static void free_reg(compiler_state_t *, int);

static void initchunks(compiler_state_t *cstate);

static void *newchunk_nolongjmp(compiler_state_t *cstate, size_t);

static void *newchunk(compiler_state_t *cstate, size_t);

static void freechunks(compiler_state_t *cstate);

static inline struct block *new_block(compiler_state_t *cstate, int);

static inline struct slist *new_stmt(compiler_state_t *cstate, int);

static struct block *gen_retblk(compiler_state_t *cstate, int);

static inline void syntax(compiler_state_t *cstate);

static void backpatch(struct block *, struct block *);

static void merge(struct block *, struct block *);

static struct block *gen_cmp(compiler_state_t *, enum e_offrel, u_int,

    u_int, bpf_u_int32);

static struct block *gen_cmp_gt(compiler_state_t *, enum e_offrel, u_int,

    u_int, bpf_u_int32);

static struct block *gen_cmp_ge(compiler_state_t *, enum e_offrel, u_int,

    u_int, bpf_u_int32);

static struct block *gen_cmp_lt(compiler_state_t *, enum e_offrel, u_int,

    u_int, bpf_u_int32);

static struct block *gen_cmp_le(compiler_state_t *, enum e_offrel, u_int,

    u_int, bpf_u_int32);

static struct block *gen_mcmp(compiler_state_t *, enum e_offrel, u_int,

    u_int, bpf_u_int32, bpf_u_int32);

static struct block *gen_bcmp(compiler_state_t *, enum e_offrel, u_int,

    u_int, const u_char *);

static struct block *gen_ncmp(compiler_state_t *, enum e_offrel, u_int,

    u_int, bpf_u_int32, int, int, bpf_u_int32);

static struct slist *gen_load_absoffsetrel(compiler_state_t *, bpf_abs_offset *,

    u_int, u_int);

static struct slist *gen_load_a(compiler_state_t *, enum e_offrel, u_int,

    u_int);

static struct slist *gen_loadx_iphdrlen(compiler_state_t *);

static struct block *gen_uncond(compiler_state_t *, int);

static inline struct block *gen_true(compiler_state_t *);

static inline struct block *gen_false(compiler_state_t *);

static struct block *gen_ether_linktype(compiler_state_t *, bpf_u_int32);

static struct block *gen_ipnet_linktype(compiler_state_t *, bpf_u_int32);

static struct block *gen_linux_sll_linktype(compiler_state_t *, bpf_u_int32);

static struct slist *gen_load_pflog_llprefixlen(compiler_state_t *);

static struct slist *gen_load_prism_llprefixlen(compiler_state_t *);

static struct slist *gen_load_avs_llprefixlen(compiler_state_t *);

static struct slist *gen_load_radiotap_llprefixlen(compiler_state_t *);

static struct slist *gen_load_ppi_llprefixlen(compiler_state_t *);

static void insert_compute_vloffsets(compiler_state_t *, struct block *);

static struct slist *gen_abs_offset_varpart(compiler_state_t *,

    bpf_abs_offset *);

static bpf_u_int32 ethertype_to_ppptype(bpf_u_int32);

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

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

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

static struct block *gen_hostop(compiler_state_t *, bpf_u_int32, bpf_u_int32,

    int, bpf_u_int32, u_int, u_int);

#ifdef INET6

static struct block *gen_hostop6(compiler_state_t *, struct in6_addr *,

    struct in6_addr *, int, bpf_u_int32, u_int, u_int);

#endif

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

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

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

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

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

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

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

static struct block *gen_mpls_linktype(compiler_state_t *, bpf_u_int32);

static struct block *gen_host(compiler_state_t *, bpf_u_int32, bpf_u_int32,

    int, int, int);

#ifdef INET6

static struct block *gen_host6(compiler_state_t *, struct in6_addr *,

    struct in6_addr *, int, int, int);

#endif

#ifndef INET6

static struct block *gen_gateway(compiler_state_t *, const u_char *,

    struct addrinfo *, int, int);

#endif

static struct block *gen_ipfrag(compiler_state_t *);

static struct block *gen_portatom(compiler_state_t *, int, bpf_u_int32);

static struct block *gen_portrangeatom(compiler_state_t *, u_int, bpf_u_int32,

    bpf_u_int32);

static struct block *gen_portatom6(compiler_state_t *, int, bpf_u_int32);

static struct block *gen_portrangeatom6(compiler_state_t *, u_int, bpf_u_int32,

    bpf_u_int32);

static struct block *gen_portop(compiler_state_t *, u_int, u_int, int);

static struct block *gen_port(compiler_state_t *, u_int, int, int);

static struct block *gen_portrangeop(compiler_state_t *, u_int, u_int,

    bpf_u_int32, int);

static struct block *gen_portrange(compiler_state_t *, u_int, u_int, int, int);

struct block *gen_portop6(compiler_state_t *, u_int, u_int, int);

static struct block *gen_port6(compiler_state_t *, u_int, int, int);

static struct block *gen_portrangeop6(compiler_state_t *, u_int, u_int,

    bpf_u_int32, int);

static struct block *gen_portrange6(compiler_state_t *, u_int, u_int, int, int);

static int lookup_proto(compiler_state_t *, const char *, int);

#if !defined(NO_PROTOCHAIN)

static struct block *gen_protochain(compiler_state_t *, bpf_u_int32, int);

#endif /* !defined(NO_PROTOCHAIN) */

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

static struct slist *xfer_to_x(compiler_state_t *, struct arth *);

static struct slist *xfer_to_a(compiler_state_t *, struct arth *);

static struct block *gen_mac_multicast(compiler_state_t *, int);

static struct block *gen_len(compiler_state_t *, int, int);

static struct block *gen_check_802_11_data_frame(compiler_state_t *);

static struct block *gen_geneve_ll_check(compiler_state_t *cstate);

static struct block *gen_ppi_dlt_check(compiler_state_t *);

static struct block *gen_atmfield_code_internal(compiler_state_t *, int,

    bpf_u_int32, int, int);

static struct block *gen_atmtype_llc(compiler_state_t *);

static struct block *gen_msg_abbrev(compiler_state_t *, int type);

static void

initchunks(compiler_state_t *cstate)

{

  int i;

  for (i = 0; i < NCHUNKS; i++) {

    cstate->chunks[i].n_left = 0;

    cstate->chunks[i].m = NULL;

  }

  cstate->cur_chunk = 0;

}

static void *

newchunk_nolongjmp(compiler_state_t *cstate, size_t n)

{

  struct chunk *cp;

  int k;

  size_t size;

  /* Round up to chunk alignment. */

  n = (n + CHUNK_ALIGN - 1) & ~(CHUNK_ALIGN - 1);

  cp = &cstate->chunks[cstate->cur_chunk];

  if (n > cp->n_left) {

    ++cp;

    k = ++cstate->cur_chunk;

    if (k >= NCHUNKS) {

      bpf_set_error(cstate, "out of memory");

      return (NULL);

    }

    size = CHUNK0SIZE << k;

    cp->m = (void *)malloc(size);

    if (cp->m == NULL) {

      bpf_set_error(cstate, "out of memory");

      return (NULL);

    }

    memset((char *)cp->m, 0, size);

    cp->n_left = size;

    if (n > size) {

      bpf_set_error(cstate, "out of memory");

      return (NULL);

    }

  }

  cp->n_left -= n;

  return (void *)((char *)cp->m + cp->n_left);

}

static void *

newchunk(compiler_state_t *cstate, size_t n)

{

  void *p;

  p = newchunk_nolongjmp(cstate, n);

  if (p == NULL) {

    longjmp(cstate->top_ctx, 1);

    /*NOTREACHED*/

  }

  return (p);

}

static void

freechunks(compiler_state_t *cstate)

{

  int i;

  for (i = 0; i < NCHUNKS; ++i)

    if (cstate->chunks[i].m != NULL)

      free(cstate->chunks[i].m);

}

/*

 * A strdup whose allocations are freed after code generation is over.

 * This is used by the lexical analyzer, so it can't longjmp; it just

 * returns NULL on an allocation error, and the callers must check

 * for it.

 */

char *

sdup(compiler_state_t *cstate, const char *s)

{

  size_t n = strlen(s) + 1;

  char *cp = newchunk_nolongjmp(cstate, n);

  if (cp == NULL)

    return (NULL);

  pcap_strlcpy(cp, s, n);

  return (cp);

}

static inline struct block *

new_block(compiler_state_t *cstate, int code)

{

  struct block *p;

  p = (struct block *)newchunk(cstate, sizeof(*p));

  p->s.code = code;

  p->head = p;

  return p;

}

static inline struct slist *

new_stmt(compiler_state_t *cstate, int code)

{

  struct slist *p;

  p = (struct slist *)newchunk(cstate, sizeof(*p));

  p->s.code = code;

  return p;

}

static struct block *

gen_retblk(compiler_state_t *cstate, int v)

{

  struct block *b = new_block(cstate, BPF_RET|BPF_K);

  b->s.k = v;

  return b;

}

static inline PCAP_NORETURN_DEF void

syntax(compiler_state_t *cstate)

{

  bpf_error(cstate, "syntax error in filter expression");

}

int

pcap_compile(pcap_t *p, struct bpf_program *program,

       const char *buf, int optimize, bpf_u_int32 mask)

{

#ifdef _WIN32

  static int done = 0;

#endif

  compiler_state_t cstate;

  const char * volatile xbuf = buf;

  yyscan_t scanner = NULL;

  volatile YY_BUFFER_STATE in_buffer = NULL;

  u_int len;

  int rc;

  /*

   * If this pcap_t hasn't been activated, it doesn't have a

   * link-layer type, so we can't use it.

   */

  if (!p->activated) {

    (void)snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

        "not-yet-activated pcap_t passed to pcap_compile");

    return (PCAP_ERROR);

  }

#ifdef _WIN32

  if (!done) {

    pcap_wsockinit();

    done = 1;

  }

#endif

#ifdef ENABLE_REMOTE

  /*

   * If the device on which we're capturing need to be notified

   * that a new filter is being compiled, do so.

   *

   * This allows them to save a copy of it, in case, for example,

   * they're implementing a form of remote packet capture, and

   * want the remote machine to filter out the packets in which

   * it's sending the packets it's captured.

   *

   * XXX - the fact that we happen to be compiling a filter

   * doesn't necessarily mean we'll be installing it as the

   * filter for this pcap_t; we might be running it from userland

   * on captured packets to do packet classification.  We really

   * need a better way of handling this, but this is all that

   * the WinPcap remote capture code did.

   */

  if (p->save_current_filter_op != NULL)

    (p->save_current_filter_op)(p, buf);

#endif

  initchunks(&cstate);

  cstate.no_optimize = 0;

#ifdef INET6

  cstate.ai = NULL;

#endif

  cstate.e = NULL;

  cstate.ic.root = NULL;

  cstate.ic.cur_mark = 0;

  cstate.bpf_pcap = p;

  cstate.error_set = 0;

  init_regs(&cstate);

  cstate.netmask = mask;

  cstate.snaplen = pcap_snapshot(p);

  if (cstate.snaplen == 0) {

    (void)snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

       "snaplen of 0 rejects all packets");

    rc = PCAP_ERROR;

    goto quit;

  }

  if (pcap_lex_init(&scanner) != 0) {

    pcap_fmt_errmsg_for_errno(p->errbuf, PCAP_ERRBUF_SIZE,

        errno, "can't initialize scanner");

    rc = PCAP_ERROR;

    goto quit;

  }

  in_buffer = pcap__scan_string(xbuf ? xbuf : "", scanner);

  /*

   * Associate the compiler state with the lexical analyzer

   * state.

   */

  pcap_set_extra(&cstate, scanner);

  if (init_linktype(&cstate, p) == -1) {

    rc = PCAP_ERROR;

    goto quit;

  }

  if (pcap_parse(scanner, &cstate) != 0) {

#ifdef INET6

    if (cstate.ai != NULL)

      freeaddrinfo(cstate.ai);

#endif

    if (cstate.e != NULL)

      free(cstate.e);

    rc = PCAP_ERROR;

    goto quit;

  }

  if (cstate.ic.root == NULL) {

    /*

     * Catch errors reported by gen_retblk().

     */

    if (setjmp(cstate.top_ctx)) {

      rc = PCAP_ERROR;

      goto quit;

    }

    cstate.ic.root = gen_retblk(&cstate, cstate.snaplen);

  }

  if (optimize && !cstate.no_optimize) {

    if (bpf_optimize(&cstate.ic, p->errbuf) == -1) {

      /* Failure */

      rc = PCAP_ERROR;

      goto quit;

    }

    if (cstate.ic.root == NULL ||

        (cstate.ic.root->s.code == (BPF_RET|BPF_K) && cstate.ic.root->s.k == 0)) {

      (void)snprintf(p->errbuf, PCAP_ERRBUF_SIZE,

          "expression rejects all packets");

      rc = PCAP_ERROR;

      goto quit;

    }

  }

  program->bf_insns = icode_to_fcode(&cstate.ic,

      cstate.ic.root, &len, p->errbuf);

  if (program->bf_insns == NULL) {

    /* Failure */

    rc = PCAP_ERROR;

    goto quit;

  }

  program->bf_len = len;

  rc = 0;  /* We're all okay */

quit:

  /*

   * Clean up everything for the lexical analyzer.

   */

  if (in_buffer != NULL)

    pcap__delete_buffer(in_buffer, scanner);

  if (scanner != NULL)

    pcap_lex_destroy(scanner);

  /*

   * Clean up our own allocated memory.

   */

  freechunks(&cstate);

  return (rc);

}

/*

 * entry point for using the compiler with no pcap open

 * pass in all the stuff that is needed explicitly instead.

 */

int

pcap_compile_nopcap(int snaplen_arg, int linktype_arg,

        struct bpf_program *program,

        const char *buf, int optimize, bpf_u_int32 mask)

{

  pcap_t *p;

  int ret;

  p = pcap_open_dead(linktype_arg, snaplen_arg);

  if (p == NULL)

    return (PCAP_ERROR);

  ret = pcap_compile(p, program, buf, optimize, mask);

  pcap_close(p);

  return (ret);

}

/*

 * Clean up a "struct bpf_program" by freeing all the memory allocated

 * in it.

 */

void

pcap_freecode(struct bpf_program *program)

{

  program->bf_len = 0;

  if (program->bf_insns != NULL) {

    free((char *)program->bf_insns);

    program->bf_insns = NULL;

  }

}

/*

 * Backpatch the blocks in 'list' to 'target'.  The 'sense' field indicates

 * which of the jt and jf fields has been resolved and which is a pointer

 * back to another unresolved block (or nil).  At least one of the fields

 * in each block is already resolved.

 */

static void

backpatch(struct block *list, struct block *target)

{

  struct block *next;

  while (list) {

    if (!list->sense) {

      next = JT(list);

      JT(list) = target;

    } else {

      next = JF(list);

      JF(list) = target;

    }

    list = next;

  }

}

/*

 * Merge the lists in b0 and b1, using the 'sense' field to indicate

 * which of jt and jf is the link.

 */

static void

merge(struct block *b0, struct block *b1)

{

  register struct block **p = &b0;

  /* Find end of list. */

  while (*p)

    p = !((*p)->sense) ? &JT(*p) : &JF(*p);

  /* Concatenate the lists. */

  *p = b1;

}

int

finish_parse(compiler_state_t *cstate, struct block *p)

{

  struct block *ppi_dlt_check;

  /*

   * Catch errors reported by us and routines below us, and return -1

   * on an error.

   */

  if (setjmp(cstate->top_ctx))

    return (-1);

  /*

   * Insert before the statements of the first (root) block any

   * statements needed to load the lengths of any variable-length

   * headers into registers.

   *

   * XXX - a fancier strategy would be to insert those before the

   * statements of all blocks that use those lengths and that

   * have no predecessors that use them, so that we only compute

   * the lengths if we need them.  There might be even better

   * approaches than that.

   *

   * However, those strategies would be more complicated, and

   * as we don't generate code to compute a length if the

   * program has no tests that use the length, and as most

   * tests will probably use those lengths, we would just

   * postpone computing the lengths so that it's not done

   * for tests that fail early, and it's not clear that's

   * worth the effort.

   */

  insert_compute_vloffsets(cstate, p->head);

  /*

   * For DLT_PPI captures, generate a check of the per-packet

   * DLT value to make sure it's DLT_IEEE802_11.

   *

   * XXX - TurboCap cards use DLT_PPI for Ethernet.

   * Can we just define some DLT_ETHERNET_WITH_PHDR pseudo-header

   * with appropriate Ethernet information and use that rather

   * than using something such as DLT_PPI where you don't know

   * the link-layer header type until runtime, which, in the

   * general case, would force us to generate both Ethernet *and*

   * 802.11 code (*and* anything else for which PPI is used)

   * and choose between them early in the BPF program?

   */

  ppi_dlt_check = gen_ppi_dlt_check(cstate);

  if (ppi_dlt_check != NULL)

    gen_and(ppi_dlt_check, p);

  backpatch(p, gen_retblk(cstate, cstate->snaplen));

  p->sense = !p->sense;

  backpatch(p, gen_retblk(cstate, 0));

  cstate->ic.root = p->head;

  return (0);

}

void

gen_and(struct block *b0, struct block *b1)

{

  backpatch(b0, b1->head);

  b0->sense = !b0->sense;

  b1->sense = !b1->sense;

  merge(b1, b0);

  b1->sense = !b1->sense;

  b1->head = b0->head;

}

void

gen_or(struct block *b0, struct block *b1)

{

  b0->sense = !b0->sense;

  backpatch(b0, b1->head);

  b0->sense = !b0->sense;

  merge(b1, b0);

  b1->head = b0->head;

}

void

gen_not(struct block *b)

{

  b->sense = !b->sense;

}

static struct block *

gen_cmp(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,

    u_int size, bpf_u_int32 v)

{

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

}

static struct block *

gen_cmp_gt(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,

    u_int size, bpf_u_int32 v)

{

  return gen_ncmp(cstate, offrel, offset, size, 0xffffffff, BPF_JGT, 0, v);

}

static struct block *

gen_cmp_ge(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,

    u_int size, bpf_u_int32 v)

{

  return gen_ncmp(cstate, offrel, offset, size, 0xffffffff, BPF_JGE, 0, v);

}

static struct block *

gen_cmp_lt(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,

    u_int size, bpf_u_int32 v)

{

  return gen_ncmp(cstate, offrel, offset, size, 0xffffffff, BPF_JGE, 1, v);

}

static struct block *

gen_cmp_le(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,

    u_int size, bpf_u_int32 v)

{

  return gen_ncmp(cstate, offrel, offset, size, 0xffffffff, BPF_JGT, 1, v);

}

static struct block *

gen_mcmp(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,

    u_int size, bpf_u_int32 v, bpf_u_int32 mask)

{

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

}

static struct block *

gen_bcmp(compiler_state_t *cstate, enum e_offrel offrel, u_int offset,

    u_int size, const u_char *v)

{

  register struct block *b, *tmp;