Merge libpcap 0.5

10 files changed, 1153 insertions, 53 deletions

diff --git a/contrib/libpcap/bpf/net/bpf.h b/contrib/libpcap/bpf/net/bpf.h
index 8a997aa..c6910b6 100644
--- a/contrib/libpcap/bpf/net/bpf.h
+++ b/contrib/libpcap/bpf/net/bpf.h
@@ -37,7 +37,8 @@
  *
  *      @(#)bpf.h       7.1 (Berkeley) 5/7/91
  *
- * @(#) $Header: /tcpdump/master/libpcap/bpf/net/bpf.h,v 1.37 1999/10/19 15:18:31 itojun Exp $ (LBL)
+ * $FreeBSD$
+ * @(#) $Header: bpf.h,v 1.36 97/06/12 14:29:53 leres Exp $ (LBL)
  */
 
 #ifndef BPF_MAJOR_VERSION
@@ -52,11 +53,7 @@ typedef	u_int bpf_u_int32;
  * Alignment macros.  BPF_WORDALIGN rounds up to the next 
  * even multiple of BPF_ALIGNMENT. 
  */
-#ifndef __NetBSD__
 #define BPF_ALIGNMENT sizeof(bpf_int32)
-#else
-#define BPF_ALIGNMENT sizeof(long)
-#endif
 #define BPF_WORDALIGN(x) (((x)+(BPF_ALIGNMENT-1))&~(BPF_ALIGNMENT-1))
 
 #define BPF_MAXINSNS 512
@@ -172,21 +169,10 @@ struct bpf_hdr {
 #define DLT_SLIP	8	/* Serial Line IP */
 #define DLT_PPP		9	/* Point-to-point Protocol */
 #define DLT_FDDI	10	/* FDDI */
-#ifdef __FreeBSD__
-#define DLT_ATM_RFC1483	11	/* LLC/SNAP encapsulated atm */
-#endif
-#ifdef __OpenBSD__
 #define DLT_ATM_RFC1483	11	/* LLC/SNAP encapsulated atm */
-#define DLT_LOOP	12	/* loopback */
-#endif
-/* offset to avoid collision with BSD/OS values */
-#ifndef DLT_ATM_RFC1483
-#define DLT_ATM_RFC1483	100	/* LLC/SNAP encapsulated atm */
-#endif
-#define DLT_RAW		101	/* raw IP */
-#define DLT_SLIP_BSDOS	102	/* BSD/OS Serial Line IP */
-#define DLT_PPP_BSDOS	103	/* BSD/OS Point-to-point Protocol */
-#define DLT_CHDLC	104	/* Cisco HDLC */
+#define DLT_RAW		12	/* raw IP */
+#define DLT_SLIP_BSDOS	13	/* BSD/OS Serial Line IP */
+#define DLT_PPP_BSDOS	14	/* BSD/OS Point-to-point Protocol */
 
 /*
  * The instruction encondings.
diff --git a/contrib/libpcap/gencode.c b/contrib/libpcap/gencode.c
index b966e3e..11ee283 100644
--- a/contrib/libpcap/gencode.c
+++ b/contrib/libpcap/gencode.c
@@ -1,3 +1,4 @@
+/*#define CHASE_CHAIN*/
 /*
  * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998
  *	The Regents of the University of California.  All rights reserved.
@@ -17,15 +18,20 @@
  * 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.
+ *
+ * $FreeBSD$
  */
 #ifndef lint
 static const char rcsid[] =
-    "@(#) $Header: gencode.c,v 1.94 98/07/12 13:06:49 leres Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/libpcap/gencode.c,v 1.100 1999/12/08 19:54:03 mcr Exp $ (LBL)";
 #endif
 
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/time.h>
+#ifdef __NetBSD__
+#include <sys/param.h>
+#endif
 
 #if __STDC__
 struct mbuf;
@@ -54,6 +60,10 @@ struct rtentry;
 #include "gencode.h"
 #include "ppp.h"
 #include <pcap-namedb.h>
+#ifdef INET6
+#include <netdb.h>
+#include <sys/socket.h>
+#endif /*INET6*/
 
 #include "gnuc.h"
 #ifdef HAVE_OS_PROTO_H
@@ -137,15 +147,28 @@ static inline struct block *gen_true(void);
 static inline struct block *gen_false(void);
 static struct block *gen_linktype(int);
 static struct block *gen_hostop(bpf_u_int32, bpf_u_int32, int, int, u_int, u_int);
+#ifdef INET6
+static struct block *gen_hostop6(struct in6_addr *, struct in6_addr *, int, int, u_int, u_int);
+#endif
 static struct block *gen_ehostop(const u_char *, int);
 static struct block *gen_fhostop(const u_char *, int);
 static struct block *gen_dnhostop(bpf_u_int32, int, u_int);
 static struct block *gen_host(bpf_u_int32, bpf_u_int32, int, int);
+#ifdef INET6
+static struct block *gen_host6(struct in6_addr *, struct in6_addr *, int, int);
+#endif
 static struct block *gen_gateway(const u_char *, bpf_u_int32 **, int, int);
 static struct block *gen_ipfrag(void);
 static struct block *gen_portatom(int, bpf_int32);
+#ifdef INET6
+static struct block *gen_portatom6(int, bpf_int32);
+#endif
 struct block *gen_portop(int, int, int);
 static struct block *gen_port(int, int, int);
+#ifdef INET6
+struct block *gen_portop6(int, int, int);
+static struct block *gen_port6(int, int, int);
+#endif
 static int lookup_proto(const char *, int);
 static struct block *gen_proto(int, int, int);
 static struct slist *xfer_to_x(struct arth *);
@@ -159,8 +182,13 @@ newchunk(n)
 	struct chunk *cp;
 	int k, size;
 
+#ifndef __NetBSD__
 	/* XXX Round up to nearest long. */
 	n = (n + sizeof(long) - 1) & ~(sizeof(long) - 1);
+#else
+	/* XXX Round up to structure boundary. */
+	n = ALIGN(n);
+#endif
 
 	cp = &chunks[cur_chunk];
 	if (n > cp->n_left) {
@@ -248,6 +276,7 @@ syntax()
 
 static bpf_u_int32 netmask;
 static int snaplen;
+int no_optimize;
 
 int
 pcap_compile(pcap_t *p, struct bpf_program *program,
@@ -256,6 +285,7 @@ pcap_compile(pcap_t *p, struct bpf_program *program,
 	extern int n_errors;
 	int len;
 
+	no_optimize = 0;
 	n_errors = 0;
 	root = NULL;
 	bpf_pcap = p;
@@ -277,6 +307,54 @@ pcap_compile(pcap_t *p, struct bpf_program *program,
 	if (root == NULL)
 		root = gen_retblk(snaplen);
 
+	if (optimize && !no_optimize) {
+		bpf_optimize(&root);
+		if (root == NULL ||
+		    (root->s.code == (BPF_RET|BPF_K) && root->s.k == 0))
+			bpf_error("expression rejects all packets");
+	}
+	program->bf_insns = icode_to_fcode(root, &len);
+	program->bf_len = len;
+
+	freechunks();
+	return (0);
+}
+
+/*
+ * 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,
+	     char *buf, int optimize, bpf_u_int32 mask)
+{
+	extern int n_errors;
+	int len;
+
+	n_errors = 0;
+	root = NULL;
+	bpf_pcap = NULL;
+	if (setjmp(top_ctx)) {
+		freechunks();
+		return (-1);
+	}
+
+	netmask = mask;
+
+	/* XXX needed? I don't grok the use of globals here. */
+	snaplen = snaplen_arg;
+
+	lex_init(buf ? buf : "");
+	init_linktype(linktype_arg);
+	(void)pcap_parse();
+
+	if (n_errors)
+		syntax();
+
+	if (root == NULL)
+		root = gen_retblk(snaplen_arg);
+
 	if (optimize) {
 		bpf_optimize(&root);
 		if (root == NULL ||
@@ -489,6 +567,9 @@ init_linktype(type)
 		return;
 
 	case DLT_PPP:
+#ifdef DLT_CHDLC
+	case DLT_CHDLC:
+#endif
 		off_linktype = 2;
 		off_nl = 4;
 		return;
@@ -582,6 +663,10 @@ gen_linktype(proto)
 	case DLT_PPP:
 		if (proto == ETHERTYPE_IP)
 			proto = PPP_IP;			/* XXX was 0x21 */
+#ifdef INET6
+		else if (proto == ETHERTYPE_IPV6)
+			proto = PPP_IPV6;
+#endif
 		break;
 
 	case DLT_PPP_BSDOS:
@@ -595,6 +680,13 @@ gen_linktype(proto)
 			gen_or(b1, b0);
 			return b0;
 
+#ifdef INET6
+		case ETHERTYPE_IPV6:
+			proto = PPP_IPV6;
+			/* more to go? */
+			break;
+#endif
+
 		case ETHERTYPE_DN:
 			proto = PPP_DECNET;
 			break;
@@ -613,6 +705,10 @@ gen_linktype(proto)
 		/* XXX */
 		if (proto == ETHERTYPE_IP)
 			return (gen_cmp(0, BPF_W, (bpf_int32)htonl(AF_INET)));
+#ifdef INET6
+		else if (proto == ETHERTYPE_IPV6)
+			return (gen_cmp(0, BPF_W, (bpf_int32)htonl(AF_INET6)));
+#endif
 		else
 			return gen_false();
 	case DLT_EN10MB:
@@ -679,6 +775,60 @@ gen_hostop(addr, mask, dir, proto, src_off, dst_off)
 	return b1;
 }
 
+#ifdef INET6
+static struct block *
+gen_hostop6(addr, mask, dir, proto, src_off, dst_off)
+	struct in6_addr *addr;
+	struct in6_addr *mask;
+	int dir, proto;
+	u_int src_off, dst_off;
+{
+	struct block *b0, *b1;
+	u_int offset;
+	u_int32_t *a, *m;
+
+	switch (dir) {
+
+	case Q_SRC:
+		offset = src_off;
+		break;
+
+	case Q_DST:
+		offset = dst_off;
+		break;
+
+	case Q_AND:
+		b0 = gen_hostop6(addr, mask, Q_SRC, proto, src_off, dst_off);
+		b1 = gen_hostop6(addr, mask, Q_DST, proto, src_off, dst_off);
+		gen_and(b0, b1);
+		return b1;
+
+	case Q_OR:
+	case Q_DEFAULT:
+		b0 = gen_hostop6(addr, mask, Q_SRC, proto, src_off, dst_off);
+		b1 = gen_hostop6(addr, mask, Q_DST, proto, src_off, dst_off);
+		gen_or(b0, b1);
+		return b1;
+
+	default:
+		abort();
+	}
+	/* this order is important */
+	a = (u_int32_t *)addr;
+	m = (u_int32_t *)mask;
+	b1 = gen_mcmp(offset + 12, BPF_W, ntohl(a[3]), ntohl(m[3]));
+	b0 = gen_mcmp(offset + 8, BPF_W, ntohl(a[2]), ntohl(m[2]));
+	gen_and(b0, b1);
+	b0 = gen_mcmp(offset + 4, BPF_W, ntohl(a[1]), ntohl(m[1]));
+	gen_and(b0, b1);
+	b0 = gen_mcmp(offset + 0, BPF_W, ntohl(a[0]), ntohl(m[0]));
+	gen_and(b0, b1);
+	b0 = gen_linktype(proto);
+	gen_and(b0, b1);
+	return b1;
+}
+#endif /*INET6*/
+
 static struct block *
 gen_ehostop(eaddr, dir)
 	register const u_char *eaddr;
@@ -886,6 +1036,9 @@ gen_host(addr, mask, proto, dir)
 	case Q_IGRP:
 		bpf_error("'igrp' modifier applied to host");
 
+	case Q_PIM:
+		bpf_error("'pim' modifier applied to host");
+
 	case Q_ATALK:
 		bpf_error("ATALK host filtering not implemented");
 
@@ -906,13 +1059,107 @@ gen_host(addr, mask, proto, dir)
 
 	case Q_ISO:
 	        bpf_error("ISO host filtering not implemented");
-		
+
+#ifdef INET6
+	case Q_IPV6:
+		bpf_error("'ip6' modifier applied to ip host");
+
+	case Q_ICMPV6:
+		bpf_error("'icmp6' modifier applied to host");
+#endif /* INET6 */
+
+	case Q_AH:
+		bpf_error("'ah' modifier applied to host");
+
+	case Q_ESP:
+		bpf_error("'esp' modifier applied to host");
+
 	default:
 		abort();
 	}
 	/* NOTREACHED */
 }
 
+#ifdef INET6
+static struct block *
+gen_host6(addr, mask, proto, dir)
+	struct in6_addr *addr;
+	struct in6_addr *mask;
+	int proto;
+	int dir;
+{
+	struct block *b0, *b1;
+
+	switch (proto) {
+
+	case Q_DEFAULT:
+		return gen_host6(addr, mask, Q_IPV6, dir);
+
+	case Q_IP:
+		bpf_error("'ip' modifier applied to ip6 host");
+
+	case Q_RARP:
+		bpf_error("'rarp' modifier applied to ip6 host");
+
+	case Q_ARP:
+		bpf_error("'arp' modifier applied to ip6 host");
+
+	case Q_TCP:
+		bpf_error("'tcp' modifier applied to host");
+
+	case Q_UDP:
+		bpf_error("'udp' modifier applied to host");
+
+	case Q_ICMP:
+		bpf_error("'icmp' modifier applied to host");
+
+	case Q_IGMP:
+		bpf_error("'igmp' modifier applied to host");
+
+	case Q_IGRP:
+		bpf_error("'igrp' modifier applied to host");
+
+	case Q_PIM:
+		bpf_error("'pim' modifier applied to host");
+
+	case Q_ATALK:
+		bpf_error("ATALK host filtering not implemented");
+
+	case Q_DECNET:
+		bpf_error("'decnet' modifier applied to ip6 host");
+
+	case Q_SCA:
+		bpf_error("SCA host filtering not implemented");
+
+	case Q_LAT:
+		bpf_error("LAT host filtering not implemented");
+
+	case Q_MOPDL:
+		bpf_error("MOPDL host filtering not implemented");
+
+	case Q_MOPRC:
+		bpf_error("MOPRC host filtering not implemented");
+
+	case Q_IPV6:
+		return gen_hostop6(addr, mask, dir, ETHERTYPE_IPV6,
+				  off_nl + 8, off_nl + 24);
+
+	case Q_ICMPV6:
+		bpf_error("'icmp6' modifier applied to host");
+
+	case Q_AH:
+		bpf_error("'ah' modifier applied to host");
+
+	case Q_ESP:
+		bpf_error("'esp' modifier applied to host");
+
+	default:
+		abort();
+	}
+	/* NOTREACHED */
+}
+#endif /*INET6*/
+
 static struct block *
 gen_gateway(eaddr, alist, proto, dir)
 	const u_char *eaddr;
@@ -961,36 +1208,46 @@ gen_proto_abbrev(proto)
 	switch (proto) {
 
 	case Q_TCP:
-		b0 = gen_linktype(ETHERTYPE_IP);
-		b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)IPPROTO_TCP);
-		gen_and(b0, b1);
+		b1 = gen_proto(IPPROTO_TCP, Q_IP, Q_DEFAULT);
+#ifdef INET6
+		b0 = gen_proto(IPPROTO_TCP, Q_IPV6, Q_DEFAULT);
+		gen_or(b0, b1);
+#endif
 		break;
 
 	case Q_UDP:
-		b0 =  gen_linktype(ETHERTYPE_IP);
-		b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)IPPROTO_UDP);
-		gen_and(b0, b1);
+		b1 = gen_proto(IPPROTO_UDP, Q_IP, Q_DEFAULT);
+#ifdef INET6
+		b0 = gen_proto(IPPROTO_UDP, Q_IPV6, Q_DEFAULT);
+		gen_or(b0, b1);
+#endif
 		break;
 
 	case Q_ICMP:
-		b0 =  gen_linktype(ETHERTYPE_IP);
-		b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)IPPROTO_ICMP);
-		gen_and(b0, b1);
+		b1 = gen_proto(IPPROTO_ICMP, Q_IP, Q_DEFAULT);
 		break;
 
 	case Q_IGMP:
-		b0 =  gen_linktype(ETHERTYPE_IP);
-		b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)2);
-		gen_and(b0, b1);
+		b1 = gen_proto(2, Q_IP, Q_DEFAULT);
 		break;
 
 #ifndef	IPPROTO_IGRP
 #define	IPPROTO_IGRP	9
 #endif
 	case Q_IGRP:
-		b0 = gen_linktype(ETHERTYPE_IP);
-		b1 = gen_cmp(off_nl + 9, BPF_B, (long)IPPROTO_IGRP);
-		gen_and(b0, b1);
+		b1 = gen_proto(IPPROTO_IGRP, Q_IP, Q_DEFAULT);
+		break;
+
+#ifndef IPPROTO_PIM
+#define IPPROTO_PIM	103
+#endif
+
+	case Q_PIM:
+		b1 = gen_proto(IPPROTO_PIM, Q_IP, Q_DEFAULT);
+#ifdef INET6
+		b0 = gen_proto(IPPROTO_PIM, Q_IPV6, Q_DEFAULT);
+		gen_or(b0, b1);
+#endif
 		break;
 
 	case Q_IP:
@@ -1032,6 +1289,41 @@ gen_proto_abbrev(proto)
 		b1 =  gen_linktype(ETHERTYPE_MOPRC);
 		break;
 
+#ifdef INET6
+	case Q_IPV6:
+		b1 = gen_linktype(ETHERTYPE_IPV6);
+		break;
+
+#ifndef IPPROTO_ICMPV6
+#define IPPROTO_ICMPV6	58
+#endif
+	case Q_ICMPV6:
+		b1 = gen_proto(IPPROTO_ICMPV6, Q_IPV6, Q_DEFAULT);
+		break;
+#endif /* INET6 */
+
+#ifndef IPPROTO_AH
+#define IPPROTO_AH	51
+#endif
+	case Q_AH:
+		b1 = gen_proto(IPPROTO_AH, Q_IP, Q_DEFAULT);
+#ifdef INET6
+		b0 = gen_proto(IPPROTO_AH, Q_IPV6, Q_DEFAULT);
+		gen_or(b0, b1);
+#endif
+		break;
+
+#ifndef IPPROTO_ESP
+#define IPPROTO_ESP	50
+#endif
+	case Q_ESP:
+		b1 = gen_proto(IPPROTO_ESP, Q_IP, Q_DEFAULT);
+#ifdef INET6
+		b0 = gen_proto(IPPROTO_ESP, Q_IPV6, Q_DEFAULT);
+		gen_or(b0, b1);
+#endif
+		break;
+
 	case Q_ISO:
 	        b1 = gen_linktype(LLC_ISO_LSAP);
 		break;
@@ -1088,6 +1380,16 @@ gen_portatom(off, v)
 	return b;
 }
 
+#ifdef INET6
+static struct block *
+gen_portatom6(off, v)
+	int off;
+	bpf_int32 v;
+{
+	return gen_cmp(off_nl + 40 + off, BPF_H, v);
+}
+#endif/*INET6*/
+
 struct block *
 gen_portop(port, proto, dir)
 	int port, proto, dir;
@@ -1159,6 +1461,77 @@ gen_port(port, ip_proto, dir)
 	return b1;
 }
 
+#ifdef INET6
+struct block *
+gen_portop6(port, proto, dir)
+	int port, proto, dir;
+{
+	struct block *b0, *b1, *tmp;
+
+	/* ip proto 'proto' */
+	b0 = gen_cmp(off_nl + 6, BPF_B, (bpf_int32)proto);
+
+	switch (dir) {
+	case Q_SRC:
+		b1 = gen_portatom6(0, (bpf_int32)port);
+		break;
+
+	case Q_DST:
+		b1 = gen_portatom6(2, (bpf_int32)port);
+		break;
+
+	case Q_OR:
+	case Q_DEFAULT:
+		tmp = gen_portatom6(0, (bpf_int32)port);
+		b1 = gen_portatom6(2, (bpf_int32)port);
+		gen_or(tmp, b1);
+		break;
+
+	case Q_AND:
+		tmp = gen_portatom6(0, (bpf_int32)port);
+		b1 = gen_portatom6(2, (bpf_int32)port);
+		gen_and(tmp, b1);
+		break;
+
+	default:
+		abort();
+	}
+	gen_and(b0, b1);
+
+	return b1;
+}
+
+static struct block *
+gen_port6(port, ip_proto, dir)
+	int port;
+	int ip_proto;
+	int dir;
+{
+	struct block *b0, *b1, *tmp;
+
+	/* ether proto ip */
+	b0 =  gen_linktype(ETHERTYPE_IPV6);
+
+	switch (ip_proto) {
+	case IPPROTO_UDP:
+	case IPPROTO_TCP:
+		b1 = gen_portop6(port, ip_proto, dir);
+		break;
+
+	case PROTO_UNDEF:
+		tmp = gen_portop6(port, IPPROTO_TCP, dir);
+		b1 = gen_portop6(port, IPPROTO_UDP, dir);
+		gen_or(tmp, b1);
+		break;
+
+	default:
+		abort();
+	}
+	gen_and(b0, b1);
+	return b1;
+}
+#endif /* INET6 */
+
 static int
 lookup_proto(name, proto)
 	register const char *name;
@@ -1189,6 +1562,317 @@ lookup_proto(name, proto)
 	return v;
 }
 
+struct stmt *
+gen_joinsp(s, n)
+	struct stmt **s;
+	int n;
+{
+}
+
+struct block *
+gen_protochain(v, proto, dir)
+	int v;
+	int proto;
+	int dir;
+{
+#ifdef NO_PROTOCHAIN
+	return gen_proto(v, proto, dir);
+#else
+	struct block *b0, *b;
+	struct slist *s[100], *sp;
+	int fix2, fix3, fix4, fix5;
+	int ahcheck, again, end;
+	int i, max;
+	int reg1 = alloc_reg();
+	int reg2 = alloc_reg();
+
+	memset(s, 0, sizeof(s));
+	fix2 = fix3 = fix4 = fix5 = 0;
+
+	switch (proto) {
+	case Q_IP:
+	case Q_IPV6:
+		break;
+	case Q_DEFAULT:
+		b0 = gen_protochain(v, Q_IP, dir);
+		b = gen_protochain(v, Q_IPV6, dir);
+		gen_or(b0, b);
+		return b;
+	default:
+		bpf_error("bad protocol applied for 'protochain'");
+		/*NOTREACHED*/
+	}
+
+	no_optimize = 1; /*this code is not compatible with optimzer yet */
+
+	/*
+	 * s[0] is a dummy entry to protect other BPF insn from damaged
+	 * by s[fix] = foo with uninitialized variable "fix".  It is somewhat
+	 * hard to find interdependency made by jump table fixup.
+	 */
+	i = 0;
+	s[i] = new_stmt(0);	/*dummy*/
+	i++;
+
+	switch (proto) {
+	case Q_IP:
+		b0 = gen_linktype(ETHERTYPE_IP);
+
+		/* A = ip->ip_p */
+		s[i] = new_stmt(BPF_LD|BPF_ABS|BPF_B);
+		s[i]->s.k = off_nl + 9;
+		i++;
+		/* X = ip->ip_hl << 2 */
+		s[i] = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
+		s[i]->s.k = off_nl;
+		i++;
+		break;
+#ifdef INET6
+	case Q_IPV6:
+		b0 = gen_linktype(ETHERTYPE_IPV6);
+
+		/* A = ip6->ip_nxt */
+		s[i] = new_stmt(BPF_LD|BPF_ABS|BPF_B);
+		s[i]->s.k = off_nl + 6;
+		i++;
+		/* X = sizeof(struct ip6_hdr) */
+		s[i] = new_stmt(BPF_LDX|BPF_IMM);
+		s[i]->s.k = 40;
+		i++;
+		break;
+#endif
+	default:
+		bpf_error("unsupported proto to gen_protochain");
+		/*NOTREACHED*/
+	}
+
+	/* again: if (A == v) goto end; else fall through; */
+	again = i;
+	s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
+	s[i]->s.k = v;
+	s[i]->s.jt = NULL;		/*later*/
+	s[i]->s.jf = NULL;		/*update in next stmt*/
+	fix5 = i;
+	i++;
+
+#ifndef IPPROTO_NONE
+#define IPPROTO_NONE	59
+#endif
+	/* if (A == IPPROTO_NONE) goto end */
+	s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
+	s[i]->s.jt = NULL;	/*later*/
+	s[i]->s.jf = NULL;	/*update in next stmt*/
+	s[i]->s.k = IPPROTO_NONE;
+	s[fix5]->s.jf = s[i];
+	fix2 = i;
+	i++;
+
+#ifdef INET6
+	if (proto == Q_IPV6) {
+		int v6start, v6end, v6advance, j;
+
+		v6start = i;
+		/* if (A == IPPROTO_HOPOPTS) goto v6advance */
+		s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
+		s[i]->s.jt = NULL;	/*later*/
+		s[i]->s.jf = NULL;	/*update in next stmt*/
+		s[i]->s.k = IPPROTO_HOPOPTS;
+		s[fix2]->s.jf = s[i];
+		i++;
+		/* if (A == IPPROTO_DSTOPTS) goto v6advance */
+		s[i - 1]->s.jf = s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
+		s[i]->s.jt = NULL;	/*later*/
+		s[i]->s.jf = NULL;	/*update in next stmt*/
+		s[i]->s.k = IPPROTO_DSTOPTS;
+		i++;
+		/* if (A == IPPROTO_ROUTING) goto v6advance */
+		s[i - 1]->s.jf = s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
+		s[i]->s.jt = NULL;	/*later*/
+		s[i]->s.jf = NULL;	/*update in next stmt*/
+		s[i]->s.k = IPPROTO_ROUTING;
+		i++;
+		/* if (A == IPPROTO_FRAGMENT) goto v6advance; else goto ahcheck; */
+		s[i - 1]->s.jf = s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
+		s[i]->s.jt = NULL;	/*later*/
+		s[i]->s.jf = NULL;	/*later*/
+		s[i]->s.k = IPPROTO_FRAGMENT;
+		fix3 = i;
+		v6end = i;
+		i++;
+
+		/* v6advance: */
+		v6advance = i;
+
+		/*
+		 * in short,
+		 * A = P[X + 1];
+		 * X = X + (P[X] + 1) * 8;
+		 */
+		/* A = X */
+		s[i] = new_stmt(BPF_MISC|BPF_TXA);
+		i++;
+		/* MEM[reg1] = A */
+		s[i] = new_stmt(BPF_ST);
+		s[i]->s.k = reg1;
+		i++;
+		/* A += 1 */
+		s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
+		s[i]->s.k = 1;
+		i++;
+		/* X = A */
+		s[i] = new_stmt(BPF_MISC|BPF_TAX);
+		i++;
+		/* A = P[X + packet head]; */
+		s[i] = new_stmt(BPF_LD|BPF_IND|BPF_B);
+		s[i]->s.k = off_nl;
+		i++;
+		/* MEM[reg2] = A */
+		s[i] = new_stmt(BPF_ST);
+		s[i]->s.k = reg2;
+		i++;
+		/* X = MEM[reg1] */
+		s[i] = new_stmt(BPF_LDX|BPF_MEM);
+		s[i]->s.k = reg1;
+		i++;
+		/* A = P[X + packet head] */
+		s[i] = new_stmt(BPF_LD|BPF_IND|BPF_B);
+		s[i]->s.k = off_nl;
+		i++;
+		/* A += 1 */
+		s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
+		s[i]->s.k = 1;
+		i++;
+		/* A *= 8 */
+		s[i] = new_stmt(BPF_ALU|BPF_MUL|BPF_K);
+		s[i]->s.k = 8;
+		i++;
+		/* X = A; */
+		s[i] = new_stmt(BPF_MISC|BPF_TAX);
+		i++;
+		/* A = MEM[reg2] */
+		s[i] = new_stmt(BPF_LD|BPF_MEM);
+		s[i]->s.k = reg2;
+		i++;
+
+		/* goto again; (must use BPF_JA for backward jump) */
+		s[i] = new_stmt(BPF_JMP|BPF_JA);
+		s[i]->s.k = again - i - 1;
+		s[i - 1]->s.jf = s[i];
+		i++;
+
+		/* fixup */
+		for (j = v6start; j <= v6end; j++)
+			s[j]->s.jt = s[v6advance];
+	} else
+#endif
+	{
+		/* nop */
+		s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
+		s[i]->s.k = 0;
+		s[fix2]->s.jf = s[i];
+		i++;
+	}
+
+	/* ahcheck: */
+	ahcheck = i;
+	/* if (A == IPPROTO_AH) then fall through; else goto end; */
+	s[i] = new_stmt(BPF_JMP|BPF_JEQ|BPF_K);
+	s[i]->s.jt = NULL;	/*later*/
+	s[i]->s.jf = NULL;	/*later*/
+	s[i]->s.k = IPPROTO_AH;
+	if (fix3)
+		s[fix3]->s.jf = s[ahcheck];
+	fix4 = i;
+	i++;
+
+	/*
+	 * in short,
+	 * A = P[X + 1];
+	 * X = X + (P[X] + 2) * 4;
+	 */
+	/* A = X */
+	s[i - 1]->s.jt = s[i] = new_stmt(BPF_MISC|BPF_TXA);
+	i++;
+	/* MEM[reg1] = A */
+	s[i] = new_stmt(BPF_ST);
+	s[i]->s.k = reg1;
+	i++;
+	/* A += 1 */
+	s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
+	s[i]->s.k = 1;
+	i++;
+	/* X = A */
+	s[i] = new_stmt(BPF_MISC|BPF_TAX);
+	i++;
+	/* A = P[X + packet head]; */
+	s[i] = new_stmt(BPF_LD|BPF_IND|BPF_B);
+	s[i]->s.k = off_nl;
+	i++;
+	/* MEM[reg2] = A */
+	s[i] = new_stmt(BPF_ST);
+	s[i]->s.k = reg2;
+	i++;
+	/* X = MEM[reg1] */
+	s[i] = new_stmt(BPF_LDX|BPF_MEM);
+	s[i]->s.k = reg1;
+	i++;
+	/* A = P[X + packet head] */
+	s[i] = new_stmt(BPF_LD|BPF_IND|BPF_B);
+	s[i]->s.k = off_nl;
+	i++;
+	/* A += 2 */
+	s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
+	s[i]->s.k = 2;
+	i++;
+	/* A *= 4 */
+	s[i] = new_stmt(BPF_ALU|BPF_MUL|BPF_K);
+	s[i]->s.k = 4;
+	i++;
+	/* X = A; */
+	s[i] = new_stmt(BPF_MISC|BPF_TAX);
+	i++;
+	/* A = MEM[reg2] */
+	s[i] = new_stmt(BPF_LD|BPF_MEM);
+	s[i]->s.k = reg2;
+	i++;
+
+	/* goto again; (must use BPF_JA for backward jump) */
+	s[i] = new_stmt(BPF_JMP|BPF_JA);
+	s[i]->s.k = again - i - 1;
+	i++;
+
+	/* end: nop */
+	end = i;
+	s[i] = new_stmt(BPF_ALU|BPF_ADD|BPF_K);
+	s[i]->s.k = 0;
+	s[fix2]->s.jt = s[end];
+	s[fix4]->s.jf = s[end];
+	s[fix5]->s.jt = s[end];
+	i++;
+
+	/*
+	 * make slist chain
+	 */
+	max = i;
+	for (i = 0; i < max - 1; i++)
+		s[i]->next = s[i + 1];
+	s[max - 1]->next = NULL;
+
+	/*
+	 * emit final check
+	 */
+	b = new_block(JMP(BPF_JEQ));
+	b->stmts = s[1];	/*remember, s[0] is dummy*/
+	b->s.k = v;
+
+	free_reg(reg1);
+	free_reg(reg2);
+
+	gen_and(b0, b);
+	return b;
+#endif
+}
+
 static struct block *
 gen_proto(v, proto, dir)
 	int v;
@@ -1202,9 +1886,21 @@ gen_proto(v, proto, dir)
 
 	switch (proto) {
 	case Q_DEFAULT:
+#ifdef INET6
+		b0 = gen_proto(v, Q_IP, dir);
+		b1 = gen_proto(v, Q_IPV6, dir);
+		gen_or(b0, b1);
+		return b1;
+#else
+		/*FALLTHROUGH*/
+#endif
 	case Q_IP:
 		b0 = gen_linktype(ETHERTYPE_IP);
+#ifndef CHASE_CHAIN
 		b1 = gen_cmp(off_nl + 9, BPF_B, (bpf_int32)v);
+#else
+		b1 = gen_protochain(v, Q_IP);
+#endif
 		gen_and(b0, b1);
 		return b1;
 
@@ -1269,6 +1965,31 @@ gen_proto(v, proto, dir)
 		bpf_error("'igrp proto' is bogus");
 		/* NOTREACHED */
 
+	case Q_PIM:
+		bpf_error("'pim proto' is bogus");
+		/* NOTREACHED */
+
+#ifdef INET6
+	case Q_IPV6:
+		b0 = gen_linktype(ETHERTYPE_IPV6);
+#ifndef CHASE_CHAIN
+		b1 = gen_cmp(off_nl + 6, BPF_B, (bpf_int32)v);
+#else
+		b1 = gen_protochain(v, Q_IPV6);
+#endif
+		gen_and(b0, b1);
+		return b1;
+
+	case Q_ICMPV6:
+		bpf_error("'icmp6 proto' is bogus");
+#endif /* INET6 */
+
+	case Q_AH:
+		bpf_error("'ah proto' is bogus");
+
+	case Q_ESP:
+		bpf_error("'ah proto' is bogus");
+
 	default:
 		abort();
 		/* NOTREACHED */
@@ -1286,6 +2007,13 @@ gen_scode(name, q)
 	int tproto;
 	u_char *eaddr;
 	bpf_u_int32 mask, addr, **alist;
+#ifdef INET6
+	int tproto6;
+	struct sockaddr_in *sin;
+	struct sockaddr_in6 *sin6;
+	struct addrinfo *res, *res0;
+	struct in6_addr mask128;
+#endif /*INET6*/
 	struct block *b, *tmp;
 	int port, real_proto;
 
@@ -1335,6 +2063,7 @@ gen_scode(name, q)
 			 */
 			return (gen_host(dn_addr, 0, proto, dir));
 		} else {
+#ifndef INET6
 			alist = pcap_nametoaddr(name);
 			if (alist == NULL || *alist == NULL)
 				bpf_error("unknown host '%s'", name);
@@ -1349,6 +2078,41 @@ gen_scode(name, q)
 				b = tmp;
 			}
 			return b;
+#else
+			memset(&mask128, 0xff, sizeof(mask128));
+			res0 = res = pcap_nametoaddr(name);
+			if (res == NULL)
+				bpf_error("unknown host '%s'", name);
+			b = tmp = NULL;
+			tproto = tproto6 = proto;
+			if (off_linktype == -1 && tproto == Q_DEFAULT) {
+				tproto = Q_IP;
+				tproto6 = Q_IPV6;
+			}
+			while (res) {
+				switch (res->ai_family) {
+				case AF_INET:
+					sin = (struct sockaddr_in *)
+						res->ai_addr;
+					tmp = gen_host(ntohl(sin->sin_addr.s_addr),
+						0xffffffff, tproto, dir);
+					break;
+				case AF_INET6:
+					sin6 = (struct sockaddr_in6 *)
+						res->ai_addr;
+					tmp = gen_host6(&sin6->sin6_addr,
+						&mask128, tproto6, dir);
+					break;
+				}
+				if (b)
+					gen_or(b, tmp);
+				b = tmp;
+
+				res = res->ai_next;
+			}
+			freeaddrinfo(res0);
+			return b;
+#endif /*INET6*/
 		}
 
 	case Q_PORT:
@@ -1370,9 +2134,19 @@ gen_scode(name, q)
 				/* override PROTO_UNDEF */
 				real_proto = IPPROTO_TCP;
 		}
+#ifndef INET6
 		return gen_port(port, real_proto, dir);
+#else
+	    {
+		struct block *b;
+		b = gen_port(port, real_proto, dir);
+		gen_or(gen_port6(port, real_proto, dir), b);
+		return b;
+	    }
+#endif /* INET6 */
 
 	case Q_GATEWAY:
+#ifndef INET6
 		eaddr = pcap_ether_hostton(name);
 		if (eaddr == NULL)
 			bpf_error("unknown ether host: %s", name);
@@ -1381,6 +2155,9 @@ gen_scode(name, q)
 		if (alist == NULL || *alist == NULL)
 			bpf_error("unknown host '%s'", name);
 		return gen_gateway(eaddr, alist, proto, dir);
+#else
+		bpf_error("'gateway' not supported in this configuration");
+#endif /*INET6*/
 
 	case Q_PROTO:
 		real_proto = lookup_proto(name, proto);
@@ -1389,6 +2166,14 @@ gen_scode(name, q)
 		else
 			bpf_error("unknown protocol: %s", name);
 
+	case Q_PROTOCHAIN:
+		real_proto = lookup_proto(name, proto);
+		if (real_proto >= 0)
+			return gen_protochain(real_proto, proto, dir);
+		else
+			bpf_error("unknown protocol: %s", name);
+
+
 	case Q_UNDEF:
 		syntax();
 		/* NOTREACHED */
@@ -1491,7 +2276,16 @@ gen_ncode(s, v, q)
 		else
 			bpf_error("illegal qualifier of 'port'");
 
+#ifndef INET6
 		return gen_port((int)v, proto, dir);
+#else
+	    {
+		struct block *b;
+		b = gen_port((int)v, proto, dir);
+		gen_or(gen_port6((int)v, proto, dir), b);
+		return b;
+	    }
+#endif /* INET6 */
 
 	case Q_GATEWAY:
 		bpf_error("'gateway' requires a name");
@@ -1500,6 +2294,9 @@ gen_ncode(s, v, q)
 	case Q_PROTO:
 		return gen_proto((int)v, proto, dir);
 
+	case Q_PROTOCHAIN:
+		return gen_protochain((int)v, proto, dir);
+
 	case Q_UNDEF:
 		syntax();
 		/* NOTREACHED */
@@ -1511,6 +2308,64 @@ gen_ncode(s, v, q)
 	/* NOTREACHED */
 }
 
+#ifdef INET6
+struct block *
+gen_mcode6(s1, s2, masklen, q)
+	register const char *s1, *s2;
+	register int masklen;
+	struct qual q;
+{
+	struct addrinfo *res;
+	struct in6_addr *addr;
+	struct in6_addr mask;
+	struct block *b;
+	u_int32_t *a, *m;
+
+	if (s2)
+		bpf_error("no mask %s supported", s2);
+
+	res = pcap_nametoaddr(s1);
+	if (!res)
+		bpf_error("invalid ip6 address %s", s1);
+	if (res->ai_next)
+		bpf_error("%s resolved to multiple address", s1);
+	addr = &((struct sockaddr_in6 *)res->ai_addr)->sin6_addr;
+
+	if (sizeof(mask) * 8 < masklen)
+		bpf_error("mask length must be <= %u", (unsigned int)(sizeof(mask) * 8));
+	memset(&mask, 0xff, masklen / 8);
+	if (masklen % 8) {
+		mask.s6_addr[masklen / 8] =
+			(0xff << (8 - masklen % 8)) & 0xff;
+	}
+
+	a = (u_int32_t *)addr;
+	m = (u_int32_t *)&mask;
+	if ((a[0] & ~m[0]) || (a[1] & ~m[1])
+	 || (a[2] & ~m[2]) || (a[3] & ~m[3])) {
+		bpf_error("non-network bits set in \"%s/%d\"", s1, masklen);
+	}
+
+	switch (q.addr) {
+
+	case Q_DEFAULT:
+	case Q_HOST:
+		if (masklen != 128)
+			bpf_error("Mask syntax for networks only");
+		/* FALLTHROUGH */
+
+	case Q_NET:
+		b = gen_host6(addr, &mask, q.proto, q.dir);
+		freeaddrinfo(res);
+		return b;
+
+	default:
+		bpf_error("invalid qualifier against IPv6 address");
+		/* NOTREACHED */
+	}
+}
+#endif /*INET6*/
+
 struct block *
 gen_ecode(eaddr, q)
 	register const u_char *eaddr;
@@ -1609,6 +2464,9 @@ gen_load(proto, index, size)
 	case Q_LAT:
 	case Q_MOPRC:
 	case Q_MOPDL:
+#ifdef INET6
+	case Q_IPV6:
+#endif
 		/* XXX Note that we assume a fixed link header here. */
 		s = xfer_to_x(index);
 		tmp = new_stmt(BPF_LD|BPF_IND|size);
@@ -1627,6 +2485,7 @@ gen_load(proto, index, size)
 	case Q_ICMP:
 	case Q_IGMP:
 	case Q_IGRP:
+	case Q_PIM:
 		s = new_stmt(BPF_LDX|BPF_MSH|BPF_B);
 		s->s.k = off_nl;
 		sappend(s, xfer_to_a(index));
@@ -1639,8 +2498,16 @@ gen_load(proto, index, size)
 		gen_and(gen_proto_abbrev(proto), b = gen_ipfrag());
 		if (index->b)
 			gen_and(index->b, b);
+#ifdef INET6
+		gen_and(gen_proto_abbrev(Q_IP), b);
+#endif
 		index->b = b;
 		break;
+#ifdef INET6
+	case Q_ICMPV6:
+		bpf_error("IPv6 upper-layer protocol is not supported by proto[x]");
+		/*NOTREACHED*/
+#endif
 	}
 	index->regno = regno;
 	s = new_stmt(BPF_ST);
@@ -1966,6 +2833,14 @@ gen_multicast(proto)
 		b1->s.code = JMP(BPF_JGE);
 		gen_and(b0, b1);
 		return b1;
+
+#ifdef INET6
+	case Q_IPV6:
+		b0 = gen_linktype(ETHERTYPE_IPV6);
+		b1 = gen_cmp(off_nl + 24, BPF_B, (bpf_int32)255);
+		gen_and(b0, b1);
+		return b1;
+#endif /* INET6 */
 	}
 	bpf_error("only IP multicast filters supported on ethernet/FDDI");
 }
diff --git a/contrib/libpcap/gencode.h b/contrib/libpcap/gencode.h
index eb97ec2..85fa526 100644
--- a/contrib/libpcap/gencode.h
+++ b/contrib/libpcap/gencode.h
@@ -18,7 +18,8 @@
  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
- * @(#) $Header: gencode.h,v 1.36 96/07/17 00:11:34 leres Exp $ (LBL)
+ * $FreeBSD$
+ * @(#) $Header: /tcpdump/master/libpcap/gencode.h,v 1.37 1999/10/19 15:18:29 itojun Exp $ (LBL)
  */
 
 /*XXX*/
@@ -31,6 +32,7 @@
 #define Q_PORT		3
 #define Q_GATEWAY	4
 #define Q_PROTO		5
+#define Q_PROTOCHAIN	6
 
 /* Protocol qualifiers. */
 
@@ -51,9 +53,17 @@
 #define Q_SCA		13
 #define	Q_MOPRC		14
 #define	Q_MOPDL		15
-#define Q_ISO		16
-#define Q_ESIS		17
-#define Q_ISIS		18
+
+#define Q_IPV6		16
+#define Q_ICMPV6	17
+#define Q_AH		18
+#define Q_ESP		19
+
+#define Q_PIM		20
+
+#define Q_ISO		21
+#define Q_ESIS		22
+#define Q_ISIS		23
 
 /* Directional qualifiers. */
 
@@ -65,8 +75,12 @@
 #define Q_DEFAULT	0
 #define Q_UNDEF		255
 
+struct slist;
+
 struct stmt {
 	int code;
+	struct slist *jt;	/*only for relative jump in block*/
+	struct slist *jf;	/*only for relative jump in block*/
 	bpf_int32 k;
 };
 
@@ -153,6 +167,9 @@ void gen_not(struct block *);
 struct block *gen_scode(const char *, struct qual);
 struct block *gen_ecode(const u_char *, struct qual);
 struct block *gen_mcode(const char *, const char *, int, struct qual);
+#ifdef INET6
+struct block *gen_mcode6(const char *, const char *, int, struct qual);
+#endif
 struct block *gen_ncode(const char *, bpf_u_int32, struct qual);
 struct block *gen_proto_abbrev(int);
 struct block *gen_relation(int, struct arth *, struct arth *, int);
@@ -180,3 +197,5 @@ void sappend(struct slist *, struct slist *);
 /* XXX */
 #define JT(b)  ((b)->et.succ)
 #define JF(b)  ((b)->ef.succ)
+
+extern int no_optimize;
diff --git a/contrib/libpcap/grammar.y b/contrib/libpcap/grammar.y
index 0803c6d..cc4797f 100644
--- a/contrib/libpcap/grammar.y
+++ b/contrib/libpcap/grammar.y
@@ -19,10 +19,11 @@
  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  *
+ * $FreeBSD$
  */
 #ifndef lint
 static const char rcsid[] =
-    "@(#) $Header: grammar.y,v 1.56 96/11/02 21:54:55 leres Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/libpcap/grammar.y,v 1.57 1999/10/19 15:18:30 itojun Exp $ (LBL)";
 #endif
 
 #include <sys/types.h>
@@ -102,21 +103,22 @@ pcap_parse()
 %type	<rblk>	other
 
 %token  DST SRC HOST GATEWAY
-%token  NET MASK PORT LESS GREATER PROTO BYTE
-%token  ARP RARP IP TCP UDP ICMP IGMP IGRP
+%token  NET MASK PORT LESS GREATER PROTO PROTOCHAIN BYTE
+%token  ARP RARP IP TCP UDP ICMP IGMP IGRP PIM
 %token  ATALK DECNET LAT SCA MOPRC MOPDL
 %token  TK_BROADCAST TK_MULTICAST
 %token  NUM INBOUND OUTBOUND
 %token  LINK
 %token	GEQ LEQ NEQ
-%token	ID EID HID
+%token	ID EID HID HID6
 %token	LSH RSH
 %token  LEN
 %token  ISO ESIS ISIS
+%token  IPV6 ICMPV6 AH ESP
 
 %type	<s> ID
 %type	<e> EID
-%type	<s> HID
+%type	<s> HID HID6
 %type	<i> NUM
 
 %left OR AND
@@ -168,6 +170,24 @@ nid:	  ID			{ $$.b = gen_scode($1, $$.q = $<blk>0.q); }
 					break;
 				  }
 				}
+	| HID6 '/' NUM		{
+#ifdef INET6
+				  $$.b = gen_mcode6($1, NULL, $3,
+				    $$.q = $<blk>0.q);
+#else
+				  bpf_error("'ip6addr/prefixlen' not supported "
+					"in this configuration");
+#endif /*INET6*/
+				}
+	| HID6			{
+#ifdef INET6
+				  $$.b = gen_mcode6($1, 0, 128,
+				    $$.q = $<blk>0.q);
+#else
+				  bpf_error("'ip6addr' not supported "
+					"in this configuration");
+#endif /*INET6*/
+				}
 	| EID			{ $$.b = gen_ecode($1, $$.q = $<blk>0.q); }
 	| not id		{ gen_not($2.b); $$ = $2; }
 	;
@@ -190,6 +210,7 @@ head:	  pqual dqual aqual	{ QSET($$.q, $1, $2, $3); }
 	| pqual dqual		{ QSET($$.q, $1, $2, Q_DEFAULT); }
 	| pqual aqual		{ QSET($$.q, $1, Q_DEFAULT, $2); }
 	| pqual PROTO		{ QSET($$.q, $1, Q_DEFAULT, Q_PROTO); }
+	| pqual PROTOCHAIN	{ QSET($$.q, $1, Q_DEFAULT, Q_PROTOCHAIN); }
 	| pqual ndaqual		{ QSET($$.q, $1, Q_DEFAULT, $2); }
 	;
 rterm:	  head id		{ $$ = $2; }
@@ -230,12 +251,17 @@ pname:	  LINK			{ $$ = Q_LINK; }
 	| ICMP			{ $$ = Q_ICMP; }
 	| IGMP			{ $$ = Q_IGMP; }
 	| IGRP			{ $$ = Q_IGRP; }
+	| PIM			{ $$ = Q_PIM; }
 	| ATALK			{ $$ = Q_ATALK; }
 	| DECNET		{ $$ = Q_DECNET; }
 	| LAT			{ $$ = Q_LAT; }
 	| SCA			{ $$ = Q_SCA; }
 	| MOPDL			{ $$ = Q_MOPDL; }
 	| MOPRC			{ $$ = Q_MOPRC; }
+	| IPV6			{ $$ = Q_IPV6; }
+	| ICMPV6		{ $$ = Q_ICMPV6; }
+	| AH			{ $$ = Q_AH; }
+	| ESP			{ $$ = Q_ESP; }
 	| ISO			{ $$ = Q_ISO; }
 	| ESIS			{ $$ = Q_ESIS; }
 	| ISIS			{ $$ = Q_ISIS; }
diff --git a/contrib/libpcap/nametoaddr.c b/contrib/libpcap/nametoaddr.c
index 7b744c8..243f664 100644
--- a/contrib/libpcap/nametoaddr.c
+++ b/contrib/libpcap/nametoaddr.c
@@ -20,11 +20,13 @@
  *
  * Name to id translation routines used by the scanner.
  * These functions are not time critical.
+ *
+ * $FreeBSD$
  */
 
 #ifndef lint
 static const char rcsid[] =
-    "@(#) $Header: nametoaddr.c,v 1.48 98/07/12 13:15:36 leres Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/libpcap/nametoaddr.c,v 1.51 1999/11/25 08:25:35 itojun Exp $ (LBL)";
 #endif
 
 #include <sys/param.h>
@@ -41,6 +43,10 @@ struct rtentry;
 #include <net/ethernet.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#ifdef INET6
+#include <netdb.h>
+#include <sys/socket.h>
+#endif /*INET6*/
 
 #include <ctype.h>
 #include <errno.h>
@@ -70,6 +76,7 @@ static inline int xdtoi(int);
  *  Convert host name to internet address.
  *  Return 0 upon failure.
  */
+#ifndef INET6
 bpf_u_int32 **
 pcap_nametoaddr(const char *name)
 {
@@ -93,6 +100,23 @@ pcap_nametoaddr(const char *name)
 	else
 		return 0;
 }
+#else
+struct addrinfo *
+pcap_nametoaddr(const char *name)
+{
+	struct addrinfo hints, *res;
+	int error;
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = PF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;	/*not really*/
+	error = getaddrinfo(name, NULL, &hints, &res);
+	if (error)
+		return NULL;
+	else
+		return res;
+}
+#endif /*INET6*/
 
 /*
  *  Convert net name to internet address.
@@ -182,9 +206,21 @@ struct eproto {
 
 /* Static data base of ether protocol types. */
 struct eproto eproto_db[] = {
+#if 0
+	/* The FreeBSD elf linker generates a request to copy this array
+	 * (including its size) when you link with -lpcap.  In order to
+	 * not bump the major version number of this libpcap.so, we need
+	 * to ensure that the array stays the same size.  Since PUP is
+	 * likely never seen in real life any more, it's the first to
+	 * be sacrificed (in favor of ip6).
+	 */
 	{ "pup", ETHERTYPE_PUP },
+#endif
 	{ "xns", ETHERTYPE_NS },
 	{ "ip", ETHERTYPE_IP },
+#ifdef INET6
+	{ "ip6", ETHERTYPE_IPV6 },
+#endif
 	{ "arp", ETHERTYPE_ARP },
 	{ "rarp", ETHERTYPE_REVARP },
 	{ "sprite", ETHERTYPE_SPRITE },
@@ -330,7 +366,7 @@ pcap_ether_hostton(const char *name)
 }
 #else
 
-#ifndef sgi
+#if !defined(sgi) && !defined(__NetBSD__)
 extern int ether_hostton(char *, struct ether_addr *);
 #endif
 
diff --git a/contrib/libpcap/pcap-int.h b/contrib/libpcap/pcap-int.h
index 1feda0b..fb9f913 100644
--- a/contrib/libpcap/pcap-int.h
+++ b/contrib/libpcap/pcap-int.h
@@ -30,7 +30,8 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * @(#) $Header: pcap-int.h,v 1.18 96/11/27 18:43:09 leres Exp $ (LBL)
+ * $FreeBSD$
+ * @(#) $Header: /tcpdump/master/libpcap/pcap-int.h,v 1.20 1999/11/21 01:10:20 assar Exp $ (LBL)
  */
 
 #ifndef pcap_int_h
@@ -101,6 +102,27 @@ struct pcap {
 	char errbuf[PCAP_ERRBUF_SIZE];
 };
 
+/*
+ * This is a timeval as stored in disk in a dumpfile.
+ * It has to use the same types everywhere, independent of the actual
+ * `struct timeval'
+ */
+
+struct pcap_timeval {
+    bpf_int32 tv_sec;		/* seconds */
+    bpf_int32 tv_usec;		/* microseconds */
+};
+
+/*
+ * How a `pcap_pkthdr' is actually stored in the dumpfile.
+ */
+
+struct pcap_sf_pkthdr {
+    struct pcap_timeval ts;	/* time stamp */
+    bpf_u_int32 caplen;		/* length of portion present */
+    bpf_u_int32 len;		/* length this packet (off wire) */
+};
+
 int	yylex(void);
 
 #ifndef min
@@ -112,7 +134,7 @@ int	pcap_offline_read(pcap_t *, int, pcap_handler, u_char *);
 int	pcap_read(pcap_t *, int cnt, pcap_handler, u_char *);
 
 /* Ultrix pads to make everything line up on a nice boundary */
-#if defined(ultrix) || defined(__alpha)
+#if defined(ultrix) || defined(__alpha) || defined(__NetBSD__)
 #define       PCAP_FDDIPAD 3
 #endif
 
diff --git a/contrib/libpcap/pcap-namedb.h b/contrib/libpcap/pcap-namedb.h
index 4310907..57e7598 100644
--- a/contrib/libpcap/pcap-namedb.h
+++ b/contrib/libpcap/pcap-namedb.h
@@ -30,7 +30,8 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * @(#) $Header: pcap-namedb.h,v 1.5 96/07/14 03:00:14 leres Exp $ (LBL)
+ * $FreeBSD$
+ * @(#) $Header: /tcpdump/master/libpcap/pcap-namedb.h,v 1.6 1999/10/19 15:18:31 itojun Exp $ (LBL)
  */
 
 #ifndef lib_pcap_ethers_h
@@ -59,7 +60,11 @@ struct	pcap_etherent *pcap_next_etherent(FILE *);
 u_char *pcap_ether_hostton(const char*);
 u_char *pcap_ether_aton(const char *);
 
+#ifndef INET6
 bpf_u_int32 **pcap_nametoaddr(const char *);
+#else
+struct addrinfo *pcap_nametoaddr(const char *);
+#endif
 bpf_u_int32 pcap_nametonetaddr(const char *);
 
 int	pcap_nametoport(const char *, int *, int *);
diff --git a/contrib/libpcap/pcap.3 b/contrib/libpcap/pcap.3
index 6c1eaea..0fb4a82 100644
--- a/contrib/libpcap/pcap.3
+++ b/contrib/libpcap/pcap.3
@@ -17,6 +17,7 @@
 .\" WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
 .\" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 .\"
+.\" $FreeBSD$
 .\" $Id$
 .\"
 .TH PCAP 3  "24 June 1998"
@@ -227,6 +228,15 @@ controls whether optimization on the resulting code is performed.
 .I netmask
 specifies the netmask of the local net.
 .PP
+.B pcap_compile_nopcap()
+is similar to
+.B pcap_compile()
+except that instead of passing a pcap structure, one passes the
+snaplen and linktype explicitly.  It is intended to be used for
+compiling filters for direct bpf usage, without necessarily having
+called
+.BR pcap_open() .
+.PP
 .B pcap_setfilter()
 is used to specify a filter program.
 .I fp
diff --git a/contrib/libpcap/pcap.h b/contrib/libpcap/pcap.h
index 0c860802..c21d38c 100644
--- a/contrib/libpcap/pcap.h
+++ b/contrib/libpcap/pcap.h
@@ -30,7 +30,8 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * @(#) $Header: pcap.h,v 1.21 97/10/15 21:59:13 leres Exp $ (LBL)
+ * $FreeBSD$
+ * @(#) $Header: /tcpdump/master/libpcap/pcap.h,v 1.22 1999/12/08 19:54:03 mcr Exp $ (LBL)
  */
 
 #ifndef lib_pcap_h
@@ -120,6 +121,8 @@ char	*pcap_strerror(int);
 char	*pcap_geterr(pcap_t *);
 int	pcap_compile(pcap_t *, struct bpf_program *, char *, int,
 	    bpf_u_int32);
+int	pcap_compile_nopcap(int, int, struct bpf_program *,
+	    char *, int, bpf_u_int32);
 /* XXX */
 int	pcap_freecode(pcap_t *, struct bpf_program *);
 int	pcap_datalink(pcap_t *);
diff --git a/contrib/libpcap/scanner.l b/contrib/libpcap/scanner.l
index a76491c..5414149 100644
--- a/contrib/libpcap/scanner.l
+++ b/contrib/libpcap/scanner.l
@@ -18,11 +18,13 @@
  * 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.
+ *
+ * $FreeBSD$
  */
 
 #ifndef lint
 static const char rcsid[] =
-    "@(#) $Header: scanner.l,v 1.56 97/07/21 13:31:50 leres Exp $ (LBL)";
+    "@(#) $Header: /tcpdump/master/libpcap/scanner.l,v 1.60 1999/11/17 04:09:58 assar Exp $ (LBL)";
 #endif
 
 #include <sys/types.h>
@@ -30,11 +32,16 @@ static const char rcsid[] =
 
 #include <ctype.h>
 #include <unistd.h>
+#include <string.h>
 
 #include "pcap-int.h"
 
 #include "gencode.h"
 #include <pcap-namedb.h>
+#ifdef INET6
+#include <netdb.h>
+#include <sys/socket.h>
+#endif /*INET6*/
 #include "tokdefs.h"
 
 #include "gnuc.h"
@@ -76,8 +83,91 @@ static char *in_buffer;
 
 N		([0-9]+|(0X|0x)[0-9A-Fa-f]+)
 B		([0-9A-Fa-f][0-9A-Fa-f]?)
+W		([0-9A-Fa-f][0-9A-Fa-f]?[0-9A-Fa-f]?[0-9A-Fa-f]?)
+
+%a 15000
+%o 17000
+%e 6000
+%k 4000
+%p 19000
+
+V680		{W}:{W}:{W}:{W}:{W}:{W}:{W}:{W}
+
+V670		::{W}:{W}:{W}:{W}:{W}:{W}:{W}
+V671		{W}::{W}:{W}:{W}:{W}:{W}:{W}
+V672		{W}:{W}::{W}:{W}:{W}:{W}:{W}
+V673		{W}:{W}:{W}::{W}:{W}:{W}:{W}
+V674		{W}:{W}:{W}:{W}::{W}:{W}:{W}
+V675		{W}:{W}:{W}:{W}:{W}::{W}:{W}
+V676		{W}:{W}:{W}:{W}:{W}:{W}::{W}
+V677		{W}:{W}:{W}:{W}:{W}:{W}:{W}::
+
+V660		::{W}:{W}:{W}:{W}:{W}:{W}
+V661		{W}::{W}:{W}:{W}:{W}:{W}
+V662		{W}:{W}::{W}:{W}:{W}:{W}
+V663		{W}:{W}:{W}::{W}:{W}:{W}
+V664		{W}:{W}:{W}:{W}::{W}:{W}
+V665		{W}:{W}:{W}:{W}:{W}::{W}
+V666		{W}:{W}:{W}:{W}:{W}:{W}::
+
+V650		::{W}:{W}:{W}:{W}:{W}
+V651		{W}::{W}:{W}:{W}:{W}
+V652		{W}:{W}::{W}:{W}:{W}
+V653		{W}:{W}:{W}::{W}:{W}
+V654		{W}:{W}:{W}:{W}::{W}
+V655		{W}:{W}:{W}:{W}:{W}::
+
+V640		::{W}:{W}:{W}:{W}
+V641		{W}::{W}:{W}:{W}
+V642		{W}:{W}::{W}:{W}
+V643		{W}:{W}:{W}::{W}
+V644		{W}:{W}:{W}:{W}::
+
+V630		::{W}:{W}:{W}
+V631		{W}::{W}:{W}
+V632		{W}:{W}::{W}
+V633		{W}:{W}:{W}::
+
+V620		::{W}:{W}
+V621		{W}::{W}
+V622		{W}:{W}::
+
+V610		::{W}
+V611		{W}::
+
+V600		::
+
+V6604		{W}:{W}:{W}:{W}:{W}:{W}:{N}\.{N}\.{N}\.{N}
 
-%a 3000
+V6504		::{W}:{W}:{W}:{W}:{W}:{N}\.{N}\.{N}\.{N}
+V6514		{W}::{W}:{W}:{W}:{W}:{N}\.{N}\.{N}\.{N}
+V6524		{W}:{W}::{W}:{W}:{W}:{N}\.{N}\.{N}\.{N}
+V6534		{W}:{W}:{W}::{W}:{W}:{N}\.{N}\.{N}\.{N}
+V6544		{W}:{W}:{W}:{W}::{W}:{N}\.{N}\.{N}\.{N}
+V6554		{W}:{W}:{W}:{W}:{W}::{N}\.{N}\.{N}\.{N}
+
+V6404		::{W}:{W}:{W}:{W}:{N}\.{N}\.{N}\.{N}
+V6414		{W}::{W}:{W}:{W}:{N}\.{N}\.{N}\.{N}
+V6424		{W}:{W}::{W}:{W}:{N}\.{N}\.{N}\.{N}
+V6434		{W}:{W}:{W}::{W}:{N}\.{N}\.{N}\.{N}
+V6444		{W}:{W}:{W}:{W}::{N}\.{N}\.{N}\.{N}
+
+V6304		::{W}:{W}:{W}:{N}\.{N}\.{N}\.{N}
+V6314		{W}::{W}:{W}:{N}\.{N}\.{N}\.{N}
+V6324		{W}:{W}::{W}:{N}\.{N}\.{N}\.{N}
+V6334		{W}:{W}:{W}::{N}\.{N}\.{N}\.{N}
+
+V6204		::{W}:{W}:{N}\.{N}\.{N}\.{N}
+V6214		{W}::{W}:{N}\.{N}\.{N}\.{N}
+V6224		{W}:{W}::{N}\.{N}\.{N}\.{N}
+
+V6104		::{W}:{N}\.{N}\.{N}\.{N}
+V6114		{W}::{N}\.{N}\.{N}\.{N}
+
+V6004		::{N}\.{N}\.{N}\.{N}
+
+
+V6		({V680}|{V670}|{V671}|{V672}|{V673}|{V674}|{V675}|{V676}|{V677}|{V660}|{V661}|{V662}|{V663}|{V664}|{V665}|{V666}|{V650}|{V651}|{V652}|{V653}|{V654}|{V655}|{V640}|{V641}|{V642}|{V643}|{V644}|{V630}|{V631}|{V632}|{V633}|{V620}|{V621}|{V622}|{V610}|{V611}|{V600}|{V6604}|{V6504}|{V6514}|{V6524}|{V6534}|{V6544}|{V6554}|{V6404}|{V6414}|{V6424}|{V6434}|{V6444}|{V6304}|{V6314}|{V6324}|{V6334}|{V6204}|{V6214}|{V6224}|{V6104}|{V6114}|{V6004})
 
 %%
 dst		return DST;
@@ -93,6 +183,12 @@ udp		return UDP;
 icmp		return ICMP;
 igmp		return IGMP;
 igrp		return IGRP;
+pim		return PIM;
+
+ip6		return IPV6;
+icmp6		return ICMPV6;
+ah		return AH;
+esp		return ESP;
 
 atalk		return ATALK;
 decnet		return DECNET;
@@ -112,6 +208,13 @@ net		return NET;
 mask		return MASK;
 port		return PORT;
 proto		return PROTO;
+protochain	{
+#ifdef NO_PROTOCHAIN
+		  bpf_error("%s not supported", yytext);
+#else
+		  return PROTOCHAIN;
+#endif
+		}
 
 gateway		return GATEWAY;
 
@@ -142,6 +245,21 @@ outbound	return OUTBOUND;
 			yylval.s = sdup((char *)yytext); return HID; }
 {B}:{B}:{B}:{B}:{B}:{B} { yylval.e = pcap_ether_aton((char *)yytext);
 			  return EID; }
+{V6}			{
+#ifdef INET6
+			  struct addrinfo hints, *res;
+			  memset(&hints, 0, sizeof(hints));
+			  hints.ai_family = AF_INET6;
+			  hints.ai_flags = AI_NUMERICHOST;
+			  if (getaddrinfo(yytext, NULL, &hints, &res))
+				bpf_error("bogus IPv6 address %s", yytext);
+			  else {
+				yylval.e = sdup((char *)yytext); return HID6;
+			  }
+#else
+			  bpf_error("IPv6 address %s not supported", yytext);
+#endif /*INET6*/
+			}
 {B}:+({B}:+)+		{ bpf_error("bogus ethernet address %s", yytext); }
 [A-Za-z0-9][-_.A-Za-z0-9]*[.A-Za-z0-9] {
 			 yylval.s = sdup((char *)yytext); return ID; }