X-Git-Url: https://git.tcpdump.org/libpcap/blobdiff_plain/43b6c2d818975c0515036b69e9f83c5574b47dbc..c980b57bc984223ff6b44f70b51e02ef8edea4cd:/pcap-dag.c

diff --git a/pcap-dag.c b/pcap-dag.c
index 207f5f3c..ea1c0959 100644
--- a/pcap-dag.c
+++ b/pcap-dag.c
@@ -1,5 +1,5 @@
 /*
- * pcap-dag.c: Packet capture interface for Endace DAG card.
+ * pcap-dag.c: Packet capture interface for Emulex EndaceDAG cards.
  *
  * The functionality of this code attempts to mimic that of pcap-linux as much
  * as possible.  This code is compiled in several different ways depending on
@@ -10,16 +10,11 @@
  * called as required from their pcap-linux/bpf equivalents.
  *
  * Authors: Richard Littin, Sean Irvine ({richard,sean}@reeltwo.com)
- * Modifications: Jesper Peterson  <support@endace.com>
- *                Koryn Grant      <support@endace.com>
- *                Stephen Donnelly <support@endace.com>
+ * Modifications: Jesper Peterson
+ *                Koryn Grant
+ *                Stephen Donnelly <stephen.donnelly@emulex.com>
  */
 
-#ifndef lint
-static const char rcsid[] _U_ =
-	"@(#) $Header: /tcpdump/master/libpcap/pcap-dag.c,v 1.36 2008-02-02 20:42:35 guy Exp $ (LBL)";
-#endif
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -45,9 +40,112 @@ struct rtentry;		/* declarations in <net/if.h> */
 
 #include "dagnew.h"
 #include "dagapi.h"
+#include "dagpci.h"
 
 #include "pcap-dag.h"
 
+/*
+ * DAG devices have names beginning with "dag", followed by a number
+ * from 0 to DAG_MAX_BOARDS, then optionally a colon and a stream number
+ * from 0 to DAG_STREAM_MAX.
+ */
+#ifndef DAG_MAX_BOARDS
+#define DAG_MAX_BOARDS 32
+#endif
+
+
+#ifndef TYPE_AAL5
+#define TYPE_AAL5               4
+#endif
+
+#ifndef TYPE_MC_HDLC
+#define TYPE_MC_HDLC            5
+#endif
+
+#ifndef TYPE_MC_RAW
+#define TYPE_MC_RAW             6
+#endif
+
+#ifndef TYPE_MC_ATM
+#define TYPE_MC_ATM             7
+#endif
+
+#ifndef TYPE_MC_RAW_CHANNEL
+#define TYPE_MC_RAW_CHANNEL     8
+#endif
+
+#ifndef TYPE_MC_AAL5
+#define TYPE_MC_AAL5            9
+#endif
+
+#ifndef TYPE_COLOR_HDLC_POS
+#define TYPE_COLOR_HDLC_POS     10
+#endif
+
+#ifndef TYPE_COLOR_ETH
+#define TYPE_COLOR_ETH          11
+#endif
+
+#ifndef TYPE_MC_AAL2
+#define TYPE_MC_AAL2            12
+#endif
+
+#ifndef TYPE_IP_COUNTER
+#define TYPE_IP_COUNTER         13
+#endif
+
+#ifndef TYPE_TCP_FLOW_COUNTER
+#define TYPE_TCP_FLOW_COUNTER   14
+#endif
+
+#ifndef TYPE_DSM_COLOR_HDLC_POS
+#define TYPE_DSM_COLOR_HDLC_POS 15
+#endif
+
+#ifndef TYPE_DSM_COLOR_ETH
+#define TYPE_DSM_COLOR_ETH      16
+#endif
+
+#ifndef TYPE_COLOR_MC_HDLC_POS
+#define TYPE_COLOR_MC_HDLC_POS  17
+#endif
+
+#ifndef TYPE_AAL2
+#define TYPE_AAL2               18
+#endif
+
+#ifndef TYPE_COLOR_HASH_POS
+#define TYPE_COLOR_HASH_POS     19
+#endif
+
+#ifndef TYPE_COLOR_HASH_ETH
+#define TYPE_COLOR_HASH_ETH     20
+#endif
+
+#ifndef TYPE_INFINIBAND
+#define TYPE_INFINIBAND         21
+#endif
+
+#ifndef TYPE_IPV4
+#define TYPE_IPV4               22
+#endif
+
+#ifndef TYPE_IPV6
+#define TYPE_IPV6               23
+#endif
+
+#ifndef TYPE_RAW_LINK
+#define TYPE_RAW_LINK           24
+#endif
+
+#ifndef TYPE_INFINIBAND_LINK
+#define TYPE_INFINIBAND_LINK    25
+#endif
+
+#ifndef TYPE_PAD
+#define TYPE_PAD                48
+#endif
+
 #define ATM_CELL_SIZE		52
 #define ATM_HDR_SIZE		4
 
@@ -70,6 +168,27 @@ struct sunatm_hdr {
 	unsigned short	vci;		/* VCI */
 };
 
+/*
+ * Private data for capturing on DAG devices.
+ */
+struct pcap_dag {
+	struct pcap_stat stat;
+#ifdef HAVE_DAG_STREAMS_API
+	u_char	*dag_mem_bottom;	/* DAG card current memory bottom pointer */
+	u_char	*dag_mem_top;	/* DAG card current memory top pointer */
+#else /* HAVE_DAG_STREAMS_API */
+	void	*dag_mem_base;	/* DAG card memory base address */
+	u_int	dag_mem_bottom;	/* DAG card current memory bottom offset */
+	u_int	dag_mem_top;	/* DAG card current memory top offset */
+#endif /* HAVE_DAG_STREAMS_API */
+	int	dag_fcs_bits;	/* Number of checksum bits from link layer */
+	int	dag_offset_flags; /* Flags to pass to dag_offset(). */
+	int	dag_stream;	/* DAG stream number */
+	int	dag_timeout;	/* timeout specified to pcap_open_live.
+				 * Same as in linux above, introduce
+				 * generally? */
+};
+
 typedef struct pcap_dag_node {
 	struct pcap_dag_node *next;
 	pcap_t *p;
@@ -82,15 +201,6 @@ static const unsigned short endian_test_word = 0x0100;
 
 #define IS_BIGENDIAN() (*((unsigned char *)&endian_test_word))
 
-
-#ifdef DAG_ONLY
-/* This code is required when compiling for a DAG device only. */
-
-/* Replace dag function names with pcap equivalent. */
-#define dag_open_live pcap_open_live
-#define dag_platform_finddevs pcap_platform_finddevs
-#endif /* DAG_ONLY */
-
 #define MAX_DAG_PACKET 65536
 
 static unsigned char TempPkt[MAX_DAG_PACKET];
@@ -125,24 +235,27 @@ delete_pcap_dag(pcap_t *p)
  */
 
 static void
-dag_platform_close(pcap_t *p)
+dag_platform_cleanup(pcap_t *p)
 {
-	
-	if (p != NULL) {
+	struct pcap_dag *pd = p->priv;
+
 #ifdef HAVE_DAG_STREAMS_API
-		if(dag_stop_stream(p->fd, p->md.dag_stream) < 0)
-			fprintf(stderr,"dag_stop_stream: %s\n", strerror(errno));
-		
-		if(dag_detach_stream(p->fd, p->md.dag_stream) < 0)
-			fprintf(stderr,"dag_detach_stream: %s\n", strerror(errno));
+	if(dag_stop_stream(p->fd, pd->dag_stream) < 0)
+		fprintf(stderr,"dag_stop_stream: %s\n", strerror(errno));
+
+	if(dag_detach_stream(p->fd, pd->dag_stream) < 0)
+		fprintf(stderr,"dag_detach_stream: %s\n", strerror(errno));
 #else
-		if(dag_stop(p->fd) < 0)
-			fprintf(stderr,"dag_stop: %s\n", strerror(errno));
+	if(dag_stop(p->fd) < 0)
+		fprintf(stderr,"dag_stop: %s\n", strerror(errno));
 #endif /* HAVE_DAG_STREAMS_API */
+	if(p->fd != -1) {
 		if(dag_close(p->fd) < 0)
 			fprintf(stderr,"dag_close: %s\n", strerror(errno));
+		p->fd = -1;
 	}
 	delete_pcap_dag(p);
+	pcap_cleanup_live_common(p);
 	/* Note: don't need to call close(p->fd) here as dag_close(p->fd) does this. */
 }
 
@@ -151,7 +264,8 @@ atexit_handler(void)
 {
 	while (pcap_dags != NULL) {
 		if (pcap_dags->pid == getpid()) {
-			dag_platform_close(pcap_dags->p);
+			if (pcap_dags->p != NULL)
+				dag_platform_cleanup(pcap_dags->p);
 		} else {
 			delete_pcap_dag(pcap_dags->p);
 		}
@@ -199,9 +313,9 @@ dag_erf_ext_header_count(uint8_t * erf, size_t len)
 
 	/* loop over the extension headers */
 	do {
-	
+
 		/* sanity check we have enough bytes */
-		if ( len <= (24 + (hdr_num * 8)) )
+		if ( len < (24 + (hdr_num * 8)) )
 			return hdr_num;
 
 		/* get the header type */
@@ -221,14 +335,16 @@ dag_erf_ext_header_count(uint8_t * erf, size_t len)
 static int
 dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 {
+	struct pcap_dag *pd = p->priv;
 	unsigned int processed = 0;
-	int flags = p->md.dag_offset_flags;
+	int flags = pd->dag_offset_flags;
 	unsigned int nonblocking = flags & DAGF_NONBLOCK;
 	unsigned int num_ext_hdr = 0;
+	unsigned int ticks_per_second;
 
 	/* Get the next bufferful of packets (if necessary). */
-	while (p->md.dag_mem_top - p->md.dag_mem_bottom < dag_record_size) {
- 
+	while (pd->dag_mem_top - pd->dag_mem_bottom < dag_record_size) {
+
 		/*
 		 * Has "pcap_breakloop()" been called?
 		 */
@@ -254,46 +370,46 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 		 * If non-block is specified it will return immediately. The user
 		 * is then responsible for efficiency.
 		 */
-		if ( NULL == (p->md.dag_mem_top = dag_advance_stream(p->fd, p->md.dag_stream, &(p->md.dag_mem_bottom))) ) {
+		if ( NULL == (pd->dag_mem_top = dag_advance_stream(p->fd, pd->dag_stream, &(pd->dag_mem_bottom))) ) {
 		     return -1;
 		}
 #else
 		/* dag_offset does not support timeouts */
-		p->md.dag_mem_top = dag_offset(p->fd, &(p->md.dag_mem_bottom), flags);
+		pd->dag_mem_top = dag_offset(p->fd, &(pd->dag_mem_bottom), flags);
 #endif /* HAVE_DAG_STREAMS_API */
 
-		if (nonblocking && (p->md.dag_mem_top - p->md.dag_mem_bottom < dag_record_size))
+		if (nonblocking && (pd->dag_mem_top - pd->dag_mem_bottom < dag_record_size))
 		{
 			/* Pcap is configured to process only available packets, and there aren't any, return immediately. */
 			return 0;
 		}
-		
+
 		if(!nonblocking &&
-		   p->md.dag_timeout &&
-		   (p->md.dag_mem_top - p->md.dag_mem_bottom < dag_record_size))
+		   pd->dag_timeout &&
+		   (pd->dag_mem_top - pd->dag_mem_bottom < dag_record_size))
 		{
 			/* Blocking mode, but timeout set and no data has arrived, return anyway.*/
 			return 0;
 		}
 
 	}
-	
+
 	/* Process the packets. */
-	while (p->md.dag_mem_top - p->md.dag_mem_bottom >= dag_record_size) {
-		
+	while (pd->dag_mem_top - pd->dag_mem_bottom >= dag_record_size) {
+
 		unsigned short packet_len = 0;
 		int caplen = 0;
 		struct pcap_pkthdr	pcap_header;
-		
+
 #ifdef HAVE_DAG_STREAMS_API
-		dag_record_t *header = (dag_record_t *)(p->md.dag_mem_bottom);
+		dag_record_t *header = (dag_record_t *)(pd->dag_mem_bottom);
 #else
-		dag_record_t *header = (dag_record_t *)(p->md.dag_mem_base + p->md.dag_mem_bottom);
+		dag_record_t *header = (dag_record_t *)(pd->dag_mem_base + pd->dag_mem_bottom);
 #endif /* HAVE_DAG_STREAMS_API */
 
 		u_char *dp = ((u_char *)header); /* + dag_record_size; */
 		unsigned short rlen;
- 
+
 		/*
 		 * Has "pcap_breakloop()" been called?
 		 */
@@ -306,14 +422,14 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 			p->break_loop = 0;
 			return -2;
 		}
- 
+
 		rlen = ntohs(header->rlen);
 		if (rlen < dag_record_size)
 		{
 			strncpy(p->errbuf, "dag_read: record too small", PCAP_ERRBUF_SIZE);
 			return -1;
 		}
-		p->md.dag_mem_bottom += rlen;
+		pd->dag_mem_bottom += rlen;
 
 		/* Count lost packets. */
 		switch((header->type & 0x7f)) {
@@ -329,14 +445,14 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 
 		default:
 			if (header->lctr) {
-				if (p->md.stat.ps_drop > (UINT_MAX - ntohs(header->lctr))) {
-					p->md.stat.ps_drop = UINT_MAX;
+				if (pd->stat.ps_drop > (UINT_MAX - ntohs(header->lctr))) {
+					pd->stat.ps_drop = UINT_MAX;
 				} else {
-					p->md.stat.ps_drop += ntohs(header->lctr);
+					pd->stat.ps_drop += ntohs(header->lctr);
 				}
 			}
 		}
-		
+
 		if ((header->type & 0x7f) == TYPE_PAD) {
 			continue;
 		}
@@ -344,13 +460,13 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 		num_ext_hdr = dag_erf_ext_header_count(dp, rlen);
 
 		/* ERF encapsulation */
-		/* The Extensible Record Format is not dropped for this kind of encapsulation, 
+		/* The Extensible Record Format is not dropped for this kind of encapsulation,
 		 * and will be handled as a pseudo header by the decoding application.
 		 * The information carried in the ERF header and in the optional subheader (if present)
 		 * could be merged with the libpcap information, to offer a better decoding.
 		 * The packet length is
 		 * o the length of the packet on the link (header->wlen),
-		 * o plus the length of the ERF header (dag_record_size), as the length of the 
+		 * o plus the length of the ERF header (dag_record_size), as the length of the
 		 *   pseudo header will be adjusted during the decoding,
 		 * o plus the length of the optional subheader (if present).
 		 *
@@ -364,6 +480,10 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 			case TYPE_MC_AAL5:
 			case TYPE_MC_ATM:
 			case TYPE_MC_HDLC:
+			case TYPE_MC_RAW_CHANNEL:
+			case TYPE_MC_RAW:
+			case TYPE_MC_AAL2:
+			case TYPE_COLOR_MC_HDLC_POS:
 				packet_len += 4; /* MC header */
 				break;
 
@@ -388,7 +508,7 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 			dp += dag_record_size;
 			/* Skip over extension headers */
 			dp += 8 * num_ext_hdr;
-			
+
 			switch((header->type & 0x7f)) {
 			case TYPE_ATM:
 			case TYPE_AAL5:
@@ -407,19 +527,22 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 					caplen = rlen - dag_record_size - 4;
 					dp+=4;
 				}
+				/* Skip over extension headers */
+				caplen -= (8 * num_ext_hdr);
+
 				if (header->type == TYPE_ATM) {
 					caplen = packet_len = ATM_CELL_SIZE;
 				}
 				if (p->linktype == DLT_SUNATM) {
 					struct sunatm_hdr *sunatm = (struct sunatm_hdr *)dp;
 					unsigned long rawatm;
-					
+
 					rawatm = ntohl(*((unsigned long *)dp));
 					sunatm->vci = htons((rawatm >>  4) & 0xffff);
 					sunatm->vpi = (rawatm >> 20) & 0x00ff;
-					sunatm->flags = ((header->flags.iface & 1) ? 0x80 : 0x00) | 
+					sunatm->flags = ((header->flags.iface & 1) ? 0x80 : 0x00) |
 						((sunatm->vpi == 0 && sunatm->vci == htons(5)) ? 6 :
-						 ((sunatm->vpi == 0 && sunatm->vci == htons(16)) ? 5 : 
+						 ((sunatm->vpi == 0 && sunatm->vci == htons(16)) ? 5 :
 						  ((dp[ATM_HDR_SIZE] == 0xaa &&
 						    dp[ATM_HDR_SIZE+1] == 0xaa &&
 						    dp[ATM_HDR_SIZE+2] == 0x03) ? 2 : 1)));
@@ -436,8 +559,10 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 			case TYPE_COLOR_ETH:
 			case TYPE_ETH:
 				packet_len = ntohs(header->wlen);
-				packet_len -= (p->md.dag_fcs_bits >> 3);
+				packet_len -= (pd->dag_fcs_bits >> 3);
 				caplen = rlen - dag_record_size - 2;
+				/* Skip over extension headers */
+				caplen -= (8 * num_ext_hdr);
 				if (caplen > packet_len) {
 					caplen = packet_len;
 				}
@@ -449,8 +574,10 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 			case TYPE_COLOR_HDLC_POS:
 			case TYPE_HDLC_POS:
 				packet_len = ntohs(header->wlen);
-				packet_len -= (p->md.dag_fcs_bits >> 3);
+				packet_len -= (pd->dag_fcs_bits >> 3);
 				caplen = rlen - dag_record_size;
+				/* Skip over extension headers */
+				caplen -= (8 * num_ext_hdr);
 				if (caplen > packet_len) {
 					caplen = packet_len;
 				}
@@ -459,8 +586,10 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 			case TYPE_COLOR_MC_HDLC_POS:
 			case TYPE_MC_HDLC:
 				packet_len = ntohs(header->wlen);
-				packet_len -= (p->md.dag_fcs_bits >> 3);
+				packet_len -= (pd->dag_fcs_bits >> 3);
 				caplen = rlen - dag_record_size - 4;
+				/* Skip over extension headers */
+				caplen -= (8 * num_ext_hdr);
 				if (caplen > packet_len) {
 					caplen = packet_len;
 				}
@@ -471,7 +600,7 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 					/* Add the MTP2 Pseudo Header */
 					caplen += MTP2_HDR_LEN;
 					packet_len += MTP2_HDR_LEN;
-					
+
 					TempPkt[MTP2_SENT_OFFSET] = 0;
 					TempPkt[MTP2_ANNEX_A_USED_OFFSET] = MTP2_ANNEX_A_USED_UNKNOWN;
 					*(TempPkt+MTP2_LINK_NUMBER_OFFSET) = ((header->rec.mc_hdlc.mc_header>>16)&0x01);
@@ -483,13 +612,24 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 				break;
 
 			case TYPE_IPV4:
+			case TYPE_IPV6:
 				packet_len = ntohs(header->wlen);
 				caplen = rlen - dag_record_size;
+				/* Skip over extension headers */
+				caplen -= (8 * num_ext_hdr);
 				if (caplen > packet_len) {
 					caplen = packet_len;
 				}
 				break;
 
+			/* These types have no matching 'native' DLT, but can be used with DLT_ERF above */
+			case TYPE_MC_RAW:
+			case TYPE_MC_RAW_CHANNEL:
+			case TYPE_IP_COUNTER:
+			case TYPE_TCP_FLOW_COUNTER:
+			case TYPE_INFINIBAND:
+			case TYPE_RAW_LINK:
+			case TYPE_INFINIBAND_LINK:
 			default:
 				/* Unhandled ERF type.
 				 * Ignore rather than generating error
@@ -497,48 +637,55 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 				continue;
 			} /* switch type */
 
-			/* Skip over extension headers */
-			caplen -= (8 * num_ext_hdr);
-
 		} /* ERF encapsulation */
-		
+
 		if (caplen > p->snapshot)
 			caplen = p->snapshot;
 
 		/* Run the packet filter if there is one. */
 		if ((p->fcode.bf_insns == NULL) || bpf_filter(p->fcode.bf_insns, dp, packet_len, caplen)) {
-			
+
 			/* convert between timestamp formats */
 			register unsigned long long ts;
-				
+
 			if (IS_BIGENDIAN()) {
 				ts = SWAPLL(header->ts);
 			} else {
 				ts = header->ts;
 			}
 
+			switch (p->opt.tstamp_precision) {
+			case PCAP_TSTAMP_PRECISION_NANO:
+				ticks_per_second = 1000000000;
+				break;
+			case PCAP_TSTAMP_PRECISION_MICRO:
+			default:
+				ticks_per_second = 1000000;
+				break;
+
+			}
 			pcap_header.ts.tv_sec = ts >> 32;
-			ts = (ts & 0xffffffffULL) * 1000000;
+			ts = (ts & 0xffffffffULL) * ticks_per_second;
 			ts += 0x80000000; /* rounding */
-			pcap_header.ts.tv_usec = ts >> 32;		
-			if (pcap_header.ts.tv_usec >= 1000000) {
-				pcap_header.ts.tv_usec -= 1000000;
+			pcap_header.ts.tv_usec = ts >> 32;
+			if (pcap_header.ts.tv_usec >= ticks_per_second) {
+				pcap_header.ts.tv_usec -= ticks_per_second;
 				pcap_header.ts.tv_sec++;
 			}
 
 			/* Fill in our own header data */
 			pcap_header.caplen = caplen;
 			pcap_header.len = packet_len;
-	
+
 			/* Count the packet. */
-			p->md.stat.ps_recv++;
-	
+			pd->stat.ps_recv++;
+
 			/* Call the user supplied callback function */
 			callback(user, &pcap_header, dp);
-	
+
 			/* Only count packets that pass the filter, for consistency with standard Linux behaviour. */
 			processed++;
-			if (processed == cnt && cnt > 0)
+			if (processed == cnt && !PACKET_COUNT_IS_UNLIMITED(cnt))
 			{
 				/* Reached the user-specified limit. */
 				return cnt;
@@ -560,25 +707,25 @@ dag_inject(pcap_t *p, const void *buf _U_, size_t size _U_)
 /*
  *  Get a handle for a live capture from the given DAG device.  Passing a NULL
  *  device will result in a failure.  The promisc flag is ignored because DAG
- *  cards are always promiscuous.  The to_ms parameter is also ignored as it is
- *  not supported in hardware.
- *  
+ *  cards are always promiscuous.  The to_ms parameter is used in setting the
+ *  API polling parameters.
+ *
  *  snaplen is now also ignored, until we get per-stream slen support. Set
- *  slen with approprite DAG tool BEFORE pcap_open_live().
+ *  slen with approprite DAG tool BEFORE pcap_activate().
  *
  *  See also pcap(3).
  */
-pcap_t *
-dag_open_live(const char *device, int snaplen, int promisc, int to_ms, char *ebuf)
+static int dag_activate(pcap_t* handle)
 {
+	struct pcap_dag *handlep = handle->priv;
 #if 0
 	char conf[30]; /* dag configure string */
 #endif
-	pcap_t *handle;
 	char *s;
 	int n;
 	daginf_t* daginf;
 	char * newDev = NULL;
+	char * device = handle->opt.device;
 #ifdef HAVE_DAG_STREAMS_API
 	uint32_t mindata;
 	struct timeval maxwait;
@@ -586,44 +733,35 @@ dag_open_live(const char *device, int snaplen, int promisc, int to_ms, char *ebu
 #endif
 
 	if (device == NULL) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE, "device is NULL: %s", pcap_strerror(errno));
-		return NULL;
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "device is NULL: %s", pcap_strerror(errno));
+		return -1;
 	}
-	/* Allocate a handle for this session. */
 
-	handle = malloc(sizeof(*handle));
-	if (handle == NULL) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc %s: %s", device, pcap_strerror(errno));
-		return NULL;
-	}
-	
 	/* Initialize some components of the pcap structure. */
-	
-	memset(handle, 0, sizeof(*handle));
 
 #ifdef HAVE_DAG_STREAMS_API
 	newDev = (char *)malloc(strlen(device) + 16);
 	if (newDev == NULL) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s\n", pcap_strerror(errno));
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s", pcap_strerror(errno));
 		goto fail;
 	}
-	
+
 	/* Parse input name to get dag device and stream number if provided */
-	if (dag_parse_name(device, newDev, strlen(device) + 16, &handle->md.dag_stream) < 0) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE, "dag_parse_name: %s\n", pcap_strerror(errno));
+	if (dag_parse_name(device, newDev, strlen(device) + 16, &handlep->dag_stream) < 0) {
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_parse_name: %s", pcap_strerror(errno));
 		goto fail;
 	}
 	device = newDev;
 
-	if (handle->md.dag_stream%2) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE, "dag_parse_name: tx (even numbered) streams not supported for capture\n");
+	if (handlep->dag_stream%2) {
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_parse_name: tx (even numbered) streams not supported for capture");
 		goto fail;
 	}
 #else
 	if (strncmp(device, "/dev/", 5) != 0) {
 		newDev = (char *)malloc(strlen(device) + 5);
 		if (newDev == NULL) {
-			snprintf(ebuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s\n", pcap_strerror(errno));
+			pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s", pcap_strerror(errno));
 			goto fail;
 		}
 		strcpy(newDev, "/dev/");
@@ -634,47 +772,54 @@ dag_open_live(const char *device, int snaplen, int promisc, int to_ms, char *ebu
 
 	/* setup device parameters */
 	if((handle->fd = dag_open((char *)device)) < 0) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE, "dag_open %s: %s", device, pcap_strerror(errno));
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_open %s: %s", device, pcap_strerror(errno));
 		goto fail;
 	}
 
 #ifdef HAVE_DAG_STREAMS_API
 	/* Open requested stream. Can fail if already locked or on error */
-	if (dag_attach_stream(handle->fd, handle->md.dag_stream, 0, 0) < 0) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE, "dag_attach_stream: %s\n", pcap_strerror(errno));
+	if (dag_attach_stream(handle->fd, handlep->dag_stream, 0, 0) < 0) {
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_attach_stream: %s", pcap_strerror(errno));
 		goto failclose;
 	}
 
 	/* Set up default poll parameters for stream
 	 * Can be overridden by pcap_set_nonblock()
 	 */
-	if (dag_get_stream_poll(handle->fd, handle->md.dag_stream,
+	if (dag_get_stream_poll(handle->fd, handlep->dag_stream,
 				&mindata, &maxwait, &poll) < 0) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s\n", pcap_strerror(errno));
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s", pcap_strerror(errno));
 		goto faildetach;
 	}
-	
-	/* Amount of data to collect in Bytes before calling callbacks.
-	 * Important for efficiency, but can introduce latency
-	 * at low packet rates if to_ms not set!
-	 */
-	mindata = 65536;
 
-	/* Obey to_ms if supplied. This is a good idea!
+	if (handle->opt.immediate) {
+		/* Call callback immediately.
+		 * XXX - is this the right way to handle this?
+		 */
+		mindata = 0;
+	} else {
+		/* Amount of data to collect in Bytes before calling callbacks.
+		 * Important for efficiency, but can introduce latency
+		 * at low packet rates if to_ms not set!
+		 */
+		mindata = 65536;
+	}
+
+	/* Obey opt.timeout (was to_ms) if supplied. This is a good idea!
 	 * Recommend 10-100ms. Calls will time out even if no data arrived.
 	 */
-	maxwait.tv_sec = to_ms/1000;
-	maxwait.tv_usec = (to_ms%1000) * 1000;
+	maxwait.tv_sec = handle->opt.timeout/1000;
+	maxwait.tv_usec = (handle->opt.timeout%1000) * 1000;
 
-	if (dag_set_stream_poll(handle->fd, handle->md.dag_stream,
+	if (dag_set_stream_poll(handle->fd, handlep->dag_stream,
 				mindata, &maxwait, &poll) < 0) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s\n", pcap_strerror(errno));
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s", pcap_strerror(errno));
 		goto faildetach;
 	}
-		
+
 #else
-	if((handle->md.dag_mem_base = dag_mmap(handle->fd)) == MAP_FAILED) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE,"dag_mmap %s: %s\n", device, pcap_strerror(errno));
+	if((handlep->dag_mem_base = dag_mmap(handle->fd)) == MAP_FAILED) {
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,"dag_mmap %s: %s", device, pcap_strerror(errno));
 		goto failclose;
 	}
 
@@ -688,28 +833,28 @@ dag_open_live(const char *device, int snaplen, int promisc, int to_ms, char *ebu
 	/* set the card snap length to the specified snaplen parameter */
 	/* This is a really bad idea, as different cards have different
 	 * valid slen ranges. Should fix in Config API. */
-	if (snaplen == 0 || snaplen > MAX_DAG_SNAPLEN) {
-		snaplen = MAX_DAG_SNAPLEN;
+	if (handle->snapshot == 0 || handle->snapshot > MAX_DAG_SNAPLEN) {
+		handle->snapshot = MAX_DAG_SNAPLEN;
 	} else if (snaplen < MIN_DAG_SNAPLEN) {
-		snaplen = MIN_DAG_SNAPLEN;
+		handle->snapshot = MIN_DAG_SNAPLEN;
 	}
 	/* snap len has to be a multiple of 4 */
-	snprintf(conf, 30, "varlen slen=%d", (snaplen + 3) & ~3); 
+	pcap_snprintf(conf, 30, "varlen slen=%d", (snaplen + 3) & ~3);
 
 	if(dag_configure(handle->fd, conf) < 0) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE,"dag_configure %s: %s\n", device, pcap_strerror(errno));
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,"dag_configure %s: %s", device, pcap_strerror(errno));
 		goto faildetach;
 	}
-#endif	
-	
+#endif
+
 #ifdef HAVE_DAG_STREAMS_API
-	if(dag_start_stream(handle->fd, handle->md.dag_stream) < 0) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE, "dag_start_stream %s: %s\n", device, pcap_strerror(errno));
+	if(dag_start_stream(handle->fd, handlep->dag_stream) < 0) {
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_start_stream %s: %s", device, pcap_strerror(errno));
 		goto faildetach;
 	}
 #else
 	if(dag_start(handle->fd) < 0) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE, "dag_start %s: %s\n", device, pcap_strerror(errno));
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_start %s: %s", device, pcap_strerror(errno));
 		goto failclose;
 	}
 #endif /* HAVE_DAG_STREAMS_API */
@@ -719,8 +864,8 @@ dag_open_live(const char *device, int snaplen, int promisc, int to_ms, char *ebu
 	 * initialized to zero on startup, it won't give you
 	 * a compiler warning if you make this mistake!
 	 */
-	handle->md.dag_mem_bottom = 0;
-	handle->md.dag_mem_top = 0;
+	handlep->dag_mem_bottom = 0;
+	handlep->dag_mem_top = 0;
 
 	/*
 	 * Find out how many FCS bits we should strip.
@@ -729,7 +874,7 @@ dag_open_live(const char *device, int snaplen, int promisc, int to_ms, char *ebu
 	daginf = dag_info(handle->fd);
 	if ((0x4200 == daginf->device_code) || (0x4230 == daginf->device_code))	{
 		/* DAG 4.2S and 4.23S already strip the FCS.  Stripping the final word again truncates the packet. */
-		handle->md.dag_fcs_bits = 0;
+		handlep->dag_fcs_bits = 0;
 
 		/* Note that no FCS will be supplied. */
 		handle->linktype_ext = LT_FCS_DATALINK_EXT(0);
@@ -737,15 +882,15 @@ dag_open_live(const char *device, int snaplen, int promisc, int to_ms, char *ebu
 		/*
 		 * Start out assuming it's 32 bits.
 		 */
-		handle->md.dag_fcs_bits = 32;
+		handlep->dag_fcs_bits = 32;
 
 		/* Allow an environment variable to override. */
 		if ((s = getenv("ERF_FCS_BITS")) != NULL) {
 			if ((n = atoi(s)) == 0 || n == 16 || n == 32) {
-				handle->md.dag_fcs_bits = n;
+				handlep->dag_fcs_bits = n;
 			} else {
-				snprintf(ebuf, PCAP_ERRBUF_SIZE,
-					"pcap_open_live %s: bad ERF_FCS_BITS value (%d) in environment\n", device, n);
+				pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
+					"pcap_activate %s: bad ERF_FCS_BITS value (%d) in environment", device, n);
 				goto failstop;
 			}
 		}
@@ -756,26 +901,23 @@ dag_open_live(const char *device, int snaplen, int promisc, int to_ms, char *ebu
 		if ((s = getenv("ERF_DONT_STRIP_FCS")) != NULL) {
 			/* Yes.  Note the number of bytes that will be
 			   supplied. */
-			handle->linktype_ext = LT_FCS_DATALINK_EXT(handle->md.dag_fcs_bits/16);
+			handle->linktype_ext = LT_FCS_DATALINK_EXT(handlep->dag_fcs_bits/16);
 
 			/* And don't strip them. */
-			handle->md.dag_fcs_bits = 0;
+			handlep->dag_fcs_bits = 0;
 		}
 	}
 
-	handle->snapshot	= snaplen;
-	handle->md.dag_timeout	= to_ms;
+	handlep->dag_timeout	= handle->opt.timeout;
 
 	handle->linktype = -1;
-	if (dag_get_datalink(handle) < 0) {
-		strcpy(ebuf, handle->errbuf);
+	if (dag_get_datalink(handle) < 0)
 		goto failstop;
-	}
-	
+
 	handle->bufsize = 0;
 
 	if (new_pcap_dag(handle) < 0) {
-		snprintf(ebuf, PCAP_ERRBUF_SIZE, "new_pcap_dag %s: %s\n", device, pcap_strerror(errno));
+		pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "new_pcap_dag %s: %s", device, pcap_strerror(errno));
 		goto failstop;
 	}
 
@@ -796,66 +938,129 @@ dag_open_live(const char *device, int snaplen, int promisc, int to_ms, char *ebu
 	handle->getnonblock_op = pcap_getnonblock_fd;
 	handle->setnonblock_op = dag_setnonblock;
 	handle->stats_op = dag_stats;
-	handle->close_op = dag_platform_close;
-	handle->md.stat.ps_drop = 0;
-	handle->md.stat.ps_recv = 0;
-	return handle;
+	handle->cleanup_op = dag_platform_cleanup;
+	handlep->stat.ps_drop = 0;
+	handlep->stat.ps_recv = 0;
+	handlep->stat.ps_ifdrop = 0;
+	return 0;
 
-#ifdef HAVE_DAG_STREAMS_API 
+#ifdef HAVE_DAG_STREAMS_API
 failstop:
-	if (handle != NULL) {
-		if (dag_stop_stream(handle->fd, handle->md.dag_stream) < 0)
-			fprintf(stderr,"dag_stop_stream: %s\n", strerror(errno));
+	if (dag_stop_stream(handle->fd, handlep->dag_stream) < 0) {
+		fprintf(stderr,"dag_stop_stream: %s\n", strerror(errno));
 	}
-	
+
 faildetach:
-	if (handle != NULL) {
-		if (dag_detach_stream(handle->fd, handle->md.dag_stream) < 0)
-			fprintf(stderr,"dag_detach_stream: %s\n", strerror(errno));
-	}
-#else	
+	if (dag_detach_stream(handle->fd, handlep->dag_stream) < 0)
+		fprintf(stderr,"dag_detach_stream: %s\n", strerror(errno));
+#else
 failstop:
-	if (handle != NULL) {
-		if (dag_stop(handle->fd) < 0)
-			fprintf(stderr,"dag_stop: %s\n", strerror(errno));
-	}
+	if (dag_stop(handle->fd) < 0)
+		fprintf(stderr,"dag_stop: %s\n", strerror(errno));
 #endif /* HAVE_DAG_STREAMS_API */
-	
+
 failclose:
-	if (handle != NULL) {
-		if (dag_close(handle->fd) < 0)
-			fprintf(stderr,"dag_close: %s\n", strerror(errno));
-	}
-	if (handle != NULL)
-		delete_pcap_dag(handle);
-	
+	if (dag_close(handle->fd) < 0)
+		fprintf(stderr,"dag_close: %s\n", strerror(errno));
+	delete_pcap_dag(handle);
+
 fail:
+	pcap_cleanup_live_common(handle);
 	if (newDev != NULL) {
 		free((char *)newDev);
 	}
-	if (handle != NULL) {
-		/*
-		 * Get rid of any link-layer type list we allocated.
-		 */
-		if (handle->dlt_list != NULL) {
-			free(handle->dlt_list);
-		}
-		free(handle);
+
+	return PCAP_ERROR;
+}
+
+pcap_t *dag_create(const char *device, char *ebuf, int *is_ours)
+{
+	const char *cp;
+	char *cpend;
+	long devnum;
+	pcap_t *p;
+#ifdef HAVE_DAG_STREAMS_API
+	long stream = 0;
+#endif
+
+	/* Does this look like a DAG device? */
+	cp = strrchr(device, '/');
+	if (cp == NULL)
+		cp = device;
+	/* Does it begin with "dag"? */
+	if (strncmp(cp, "dag", 3) != 0) {
+		/* Nope, doesn't begin with "dag" */
+		*is_ours = 0;
+		return NULL;
+	}
+	/* Yes - is "dag" followed by a number from 0 to DAG_MAX_BOARDS-1 */
+	cp += 3;
+	devnum = strtol(cp, &cpend, 10);
+#ifdef HAVE_DAG_STREAMS_API
+	if (*cpend == ':') {
+		/* Followed by a stream number. */
+		stream = strtol(++cpend, &cpend, 10);
+	}
+#endif
+	if (cpend == cp || *cpend != '\0') {
+		/* Not followed by a number. */
+		*is_ours = 0;
+		return NULL;
+	}
+	if (devnum < 0 || devnum >= DAG_MAX_BOARDS) {
+		/* Followed by a non-valid number. */
+		*is_ours = 0;
+		return NULL;
+	}
+#ifdef HAVE_DAG_STREAMS_API
+	if (stream <0 || stream >= DAG_STREAM_MAX) {
+		/* Followed by a non-valid stream number. */
+		*is_ours = 0;
+		return NULL;
 	}
+#endif
 
-	return NULL;
+	/* OK, it's probably ours. */
+	*is_ours = 1;
+
+	p = pcap_create_common(ebuf, sizeof (struct pcap_dag));
+	if (p == NULL)
+		return NULL;
+
+	p->activate_op = dag_activate;
+
+	/*
+	 * We claim that we support microsecond and nanosecond time
+	 * stamps.
+	 *
+	 * XXX Our native precision is 2^-32s, but libpcap doesn't support
+	 * power of two precisions yet. We can convert to either MICRO or NANO.
+	 */
+	p->tstamp_precision_count = 2;
+	p->tstamp_precision_list = malloc(2 * sizeof(u_int));
+	if (p->tstamp_precision_list == NULL) {
+		pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
+		    pcap_strerror(errno));
+		pcap_close(p);
+		return NULL;
+	}
+	p->tstamp_precision_list[0] = PCAP_TSTAMP_PRECISION_MICRO;
+	p->tstamp_precision_list[1] = PCAP_TSTAMP_PRECISION_NANO;
+	return p;
 }
 
 static int
 dag_stats(pcap_t *p, struct pcap_stat *ps) {
+	struct pcap_dag *pd = p->priv;
+
 	/* This needs to be filled out correctly.  Hopefully a dagapi call will
 		 provide all necessary information.
 	*/
-	/*p->md.stat.ps_recv = 0;*/
-	/*p->md.stat.ps_drop = 0;*/
-	
-	*ps = p->md.stat;
- 
+	/*pd->stat.ps_recv = 0;*/
+	/*pd->stat.ps_drop = 0;*/
+
+	*ps = pd->stat;
+
 	return 0;
 }
 
@@ -869,7 +1074,7 @@ dag_stats(pcap_t *p, struct pcap_stat *ps) {
  * open attempts will still be much less than the naive approach.
  */
 int
-dag_platform_finddevs(pcap_if_t **devlistp, char *errbuf)
+dag_findalldevs(pcap_if_t **devlistp, char *errbuf)
 {
 	char name[12];	/* XXX - pick a size */
 	int ret = 0;
@@ -877,16 +1082,21 @@ dag_platform_finddevs(pcap_if_t **devlistp, char *errbuf)
 	char dagname[DAGNAME_BUFSIZE];
 	int dagstream;
 	int dagfd;
+	dag_card_inf_t *inf;
+	char *description;
 
-	/* Try all the DAGs 0-9 */
-	for (c = 0; c < 9; c++) {
-		snprintf(name, 12, "dag%d", c);
+	/* Try all the DAGs 0-DAG_MAX_BOARDS */
+	for (c = 0; c < DAG_MAX_BOARDS; c++) {
+		pcap_snprintf(name, 12, "dag%d", c);
 		if (-1 == dag_parse_name(name, dagname, DAGNAME_BUFSIZE, &dagstream))
 		{
 			return -1;
 		}
+		description = NULL;
 		if ( (dagfd = dag_open(dagname)) >= 0 ) {
-			if (pcap_add_if(devlistp, name, 0, NULL, errbuf) == -1) {
+			if ((inf = dag_pciinfo(dagfd)))
+				description = dag_device_name(inf->device_code, 1);
+			if (pcap_add_if(devlistp, name, 0, description, errbuf) == -1) {
 				/*
 				 * Failure.
 				 */
@@ -896,19 +1106,24 @@ dag_platform_finddevs(pcap_if_t **devlistp, char *errbuf)
 			{
 				int stream, rxstreams;
 				rxstreams = dag_rx_get_stream_count(dagfd);
-				for(stream=0;stream<16;stream+=2) {
+				for(stream=0;stream<DAG_STREAM_MAX;stream+=2) {
 					if (0 == dag_attach_stream(dagfd, stream, 0, 0)) {
 						dag_detach_stream(dagfd, stream);
 
-						snprintf(name,  10, "dag%d:%d", c, stream);
-						if (pcap_add_if(devlistp, name, 0, NULL, errbuf) == -1) {
+						pcap_snprintf(name,  10, "dag%d:%d", c, stream);
+						if (pcap_add_if(devlistp, name, 0, description, errbuf) == -1) {
 							/*
 							 * Failure.
 							 */
 							ret = -1;
 						}
+
+						rxstreams--;
+						if(rxstreams <= 0) {
+							break;
+						}
 					}
-				}				
+				}
 			}
 #endif  /* HAVE_DAG_STREAMS_API */
 			dag_close(dagfd);
@@ -939,8 +1154,6 @@ dag_setfilter(pcap_t *p, struct bpf_program *fp)
 	if (install_bpf_program(p, fp) < 0)
 		return -1;
 
-	p->md.use_bpf = 0;
-
 	return (0);
 }
 
@@ -955,11 +1168,13 @@ dag_set_datalink(pcap_t *p, int dlt)
 static int
 dag_setnonblock(pcap_t *p, int nonblock, char *errbuf)
 {
+	struct pcap_dag *pd = p->priv;
+
 	/*
 	 * Set non-blocking mode on the FD.
 	 * XXX - is that necessary?  If not, don't bother calling it,
 	 * and have a "dag_getnonblock()" function that looks at
-	 * "p->md.dag_offset_flags".
+	 * "pd->dag_offset_flags".
 	 */
 	if (pcap_setnonblock_fd(p, nonblock, errbuf) < 0)
 		return (-1);
@@ -968,13 +1183,13 @@ dag_setnonblock(pcap_t *p, int nonblock, char *errbuf)
 		uint32_t mindata;
 		struct timeval maxwait;
 		struct timeval poll;
-		
-		if (dag_get_stream_poll(p->fd, p->md.dag_stream,
+
+		if (dag_get_stream_poll(p->fd, pd->dag_stream,
 					&mindata, &maxwait, &poll) < 0) {
-			snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s\n", pcap_strerror(errno));
+			pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s", pcap_strerror(errno));
 			return -1;
 		}
-		
+
 		/* Amount of data to collect in Bytes before calling callbacks.
 		 * Important for efficiency, but can introduce latency
 		 * at low packet rates if to_ms not set!
@@ -983,32 +1198,33 @@ dag_setnonblock(pcap_t *p, int nonblock, char *errbuf)
 			mindata = 0;
 		else
 			mindata = 65536;
-		
-		if (dag_set_stream_poll(p->fd, p->md.dag_stream,
+
+		if (dag_set_stream_poll(p->fd, pd->dag_stream,
 					mindata, &maxwait, &poll) < 0) {
-			snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s\n", pcap_strerror(errno));
+			pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s", pcap_strerror(errno));
 			return -1;
 		}
 	}
 #endif /* HAVE_DAG_STREAMS_API */
 	if (nonblock) {
-		p->md.dag_offset_flags |= DAGF_NONBLOCK;
+		pd->dag_offset_flags |= DAGF_NONBLOCK;
 	} else {
-		p->md.dag_offset_flags &= ~DAGF_NONBLOCK;
+		pd->dag_offset_flags &= ~DAGF_NONBLOCK;
 	}
 	return (0);
 }
-		
+
 static int
 dag_get_datalink(pcap_t *p)
 {
+	struct pcap_dag *pd = p->priv;
 	int index=0, dlt_index=0;
 	uint8_t types[255];
 
 	memset(types, 0, 255);
 
 	if (p->dlt_list == NULL && (p->dlt_list = malloc(255*sizeof(*(p->dlt_list)))) == NULL) {
-		(void)snprintf(p->errbuf, sizeof(p->errbuf), "malloc: %s", pcap_strerror(errno));
+		(void)pcap_snprintf(p->errbuf, sizeof(p->errbuf), "malloc: %s", pcap_strerror(errno));
 		return (-1);
 	}
 
@@ -1016,20 +1232,20 @@ dag_get_datalink(pcap_t *p)
 
 #ifdef HAVE_DAG_GET_STREAM_ERF_TYPES
 	/* Get list of possible ERF types for this card */
-	if (dag_get_stream_erf_types(p->fd, p->md.dag_stream, types, 255) < 0) {
-		snprintf(p->errbuf, sizeof(p->errbuf), "dag_get_stream_erf_types: %s", pcap_strerror(errno));
-		return (-1);		
+	if (dag_get_stream_erf_types(p->fd, pd->dag_stream, types, 255) < 0) {
+		pcap_snprintf(p->errbuf, sizeof(p->errbuf), "dag_get_stream_erf_types: %s", pcap_strerror(errno));
+		return (-1);
 	}
-	
+
 	while (types[index]) {
 
 #elif defined HAVE_DAG_GET_ERF_TYPES
 	/* Get list of possible ERF types for this card */
 	if (dag_get_erf_types(p->fd, types, 255) < 0) {
-		snprintf(p->errbuf, sizeof(p->errbuf), "dag_get_erf_types: %s", pcap_strerror(errno));
-		return (-1);		
+		pcap_snprintf(p->errbuf, sizeof(p->errbuf), "dag_get_erf_types: %s", pcap_strerror(errno));
+		return (-1);
 	}
-	
+
 	while (types[index]) {
 #else
 	/* Check the type through a dagapi call. */
@@ -1075,7 +1291,7 @@ dag_get_datalink(pcap_t *p)
 				p->linktype = DLT_EN10MB;
 			break;
 
-		case TYPE_ATM: 
+		case TYPE_ATM:
 		case TYPE_AAL5:
 		case TYPE_MC_ATM:
 		case TYPE_MC_AAL5:
@@ -1102,6 +1318,7 @@ dag_get_datalink(pcap_t *p)
 			break;
 
 		case TYPE_IPV4:
+		case TYPE_IPV6:
 			if(!p->linktype)
 				p->linktype = DLT_RAW;
 			break;
@@ -1112,10 +1329,11 @@ dag_get_datalink(pcap_t *p)
 		case TYPE_IP_COUNTER:
 		case TYPE_TCP_FLOW_COUNTER:
 		case TYPE_INFINIBAND:
-		case TYPE_IPV6:
+		case TYPE_RAW_LINK:
+		case TYPE_INFINIBAND_LINK:
 		default:
 			/* Libpcap cannot deal with these types yet */
-			/* Add no DLTs, but still covered by DLT_ERF */
+			/* Add no 'native' DLTs, but still covered by DLT_ERF */
 			break;
 
 		} /* switch */
@@ -1131,3 +1349,31 @@ dag_get_datalink(pcap_t *p)
 
 	return p->linktype;
 }
+
+#ifdef DAG_ONLY
+/*
+ * This libpcap build supports only DAG cards, not regular network
+ * interfaces.
+ */
+
+/*
+ * There are no regular interfaces, just DAG interfaces.
+ */
+int
+pcap_platform_finddevs(pcap_if_t **alldevsp, char *errbuf)
+{
+	*alldevsp = NULL;
+	return (0);
+}
+
+/*
+ * Attempts to open a regular interface fail.
+ */
+pcap_t *
+pcap_create_interface(const char *device, char *errbuf)
+{
+	pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
+	    "This version of libpcap only supports DAG cards");
+	return NULL;
+}
+#endif