Adding support for Large stream buffers on Endace DAG cards

Support for stream buffers larger than 2GB on newer cards.
Removed support for building against DAG versions without STREAMS support (before dag-3.0.0 2007).

diff --git a/configure.ac b/configure.ac
index 02f4110d115f5bd87c454c5c969f9e8f2cbcd3f2..a2b31d4a8887a35dd5eb396a02362a70c2824983 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -852,7 +852,7 @@ if test "$want_dag" != no; then
                # included if there's a found-action (arg 3).
                saved_ldflags=$LDFLAGS
                LDFLAGS="-L$dag_lib_dir"
                # included if there's a found-action (arg 3).
                saved_ldflags=$LDFLAGS
                LDFLAGS="-L$dag_lib_dir"

-               AC_CHECK_LIB([dag], [dag_attach_stream], [dag_streams="1"], [dag_streams="0"])
+               AC_CHECK_LIB([dag], [dag_attach_stream64], [dag_large_streams="1"], [dag_large_streams="0"])

                AC_CHECK_LIB([dag],[dag_get_erf_types], [
                        AC_DEFINE(HAVE_DAG_GET_ERF_TYPES, 1, [define if you have dag_get_erf_types()])])
                AC_CHECK_LIB([dag],[dag_get_stream_erf_types], [
                AC_CHECK_LIB([dag],[dag_get_erf_types], [
                        AC_DEFINE(HAVE_DAG_GET_ERF_TYPES, 1, [define if you have dag_get_erf_types()])])
                AC_CHECK_LIB([dag],[dag_get_stream_erf_types], [


@@ -860,8 +860,8 @@ if test "$want_dag" != no; then
 
                LDFLAGS=$saved_ldflags
 
 
                LDFLAGS=$saved_ldflags
 

-               if test "$dag_streams" = 1; then
-                       AC_DEFINE(HAVE_DAG_STREAMS_API, 1, [define if you have streams capable DAG API])
+               if test "$dag_large_streams" = 1; then
+                       AC_DEFINE(HAVE_DAG_LARGE_STREAMS_API, 1, [define if you have large streams capable DAG API])

                        LIBS="$LIBS -ldag"
                        LDFLAGS="$LDFLAGS -L$dag_lib_dir"
 
                        LIBS="$LIBS -ldag"
                        LDFLAGS="$LDFLAGS -L$dag_lib_dir"
 

diff --git a/pcap-dag.c b/pcap-dag.c
index fbd1297398121175cae1c736470f8ae933c75fe6..6a6019b5a5e6851441a867a13ab1bea21f9ca97e 100644 (file)
--- a/pcap-dag.c
+++ b/pcap-dag.c
@@ -54,96 +54,100 @@ struct rtentry;            /* declarations in <net/if.h> */
 #endif
 
 
 #endif
 
 

-#ifndef TYPE_AAL5
-#define TYPE_AAL5               4
+#ifndef ERF_TYPE_AAL5
+#define ERF_TYPE_AAL5               4

 #endif
 
 #endif
 

-#ifndef TYPE_MC_HDLC
-#define TYPE_MC_HDLC            5
+#ifndef ERF_TYPE_MC_HDLC
+#define ERF_TYPE_MC_HDLC            5

 #endif
 
 #endif
 

-#ifndef TYPE_MC_RAW
-#define TYPE_MC_RAW             6
+#ifndef ERF_TYPE_MC_RAW
+#define ERF_TYPE_MC_RAW             6

 #endif
 
 #endif
 

-#ifndef TYPE_MC_ATM
-#define TYPE_MC_ATM             7
+#ifndef ERF_TYPE_MC_ATM
+#define ERF_TYPE_MC_ATM             7

 #endif
 
 #endif
 

-#ifndef TYPE_MC_RAW_CHANNEL
-#define TYPE_MC_RAW_CHANNEL     8
+#ifndef ERF_TYPE_MC_RAW_CHANNEL
+#define ERF_TYPE_MC_RAW_CHANNEL     8

 #endif
 
 #endif
 

-#ifndef TYPE_MC_AAL5
-#define TYPE_MC_AAL5            9
+#ifndef ERF_TYPE_MC_AAL5
+#define ERF_TYPE_MC_AAL5            9

 #endif
 
 #endif
 

-#ifndef TYPE_COLOR_HDLC_POS
-#define TYPE_COLOR_HDLC_POS     10
+#ifndef ERF_TYPE_COLOR_HDLC_POS
+#define ERF_TYPE_COLOR_HDLC_POS     10

 #endif
 
 #endif
 

-#ifndef TYPE_COLOR_ETH
-#define TYPE_COLOR_ETH          11
+#ifndef ERF_TYPE_COLOR_ETH
+#define ERF_TYPE_COLOR_ETH          11

 #endif
 
 #endif
 

-#ifndef TYPE_MC_AAL2
-#define TYPE_MC_AAL2            12
+#ifndef ERF_TYPE_MC_AAL2
+#define ERF_TYPE_MC_AAL2            12

 #endif
 
 #endif
 

-#ifndef TYPE_IP_COUNTER
-#define TYPE_IP_COUNTER         13
+#ifndef ERF_TYPE_IP_COUNTER
+#define ERF_TYPE_IP_COUNTER         13

 #endif
 
 #endif
 

-#ifndef TYPE_TCP_FLOW_COUNTER
-#define TYPE_TCP_FLOW_COUNTER   14
+#ifndef ERF_TYPE_TCP_FLOW_COUNTER
+#define ERF_TYPE_TCP_FLOW_COUNTER   14

 #endif
 
 #endif
 

-#ifndef TYPE_DSM_COLOR_HDLC_POS
-#define TYPE_DSM_COLOR_HDLC_POS 15
+#ifndef ERF_TYPE_DSM_COLOR_HDLC_POS
+#define ERF_TYPE_DSM_COLOR_HDLC_POS 15

 #endif
 
 #endif
 

-#ifndef TYPE_DSM_COLOR_ETH
-#define TYPE_DSM_COLOR_ETH      16
+#ifndef ERF_TYPE_DSM_COLOR_ETH
+#define ERF_TYPE_DSM_COLOR_ETH      16

 #endif
 
 #endif
 

-#ifndef TYPE_COLOR_MC_HDLC_POS
-#define TYPE_COLOR_MC_HDLC_POS  17
+#ifndef ERF_TYPE_COLOR_MC_HDLC_POS
+#define ERF_TYPE_COLOR_MC_HDLC_POS  17

 #endif
 
 #endif
 

-#ifndef TYPE_AAL2
-#define TYPE_AAL2               18
+#ifndef ERF_TYPE_AAL2
+#define ERF_TYPE_AAL2               18

 #endif
 
 #endif
 

-#ifndef TYPE_COLOR_HASH_POS
-#define TYPE_COLOR_HASH_POS     19
+#ifndef ERF_TYPE_COLOR_HASH_POS
+#define ERF_TYPE_COLOR_HASH_POS     19

 #endif
 
 #endif
 

-#ifndef TYPE_COLOR_HASH_ETH
-#define TYPE_COLOR_HASH_ETH     20
+#ifndef ERF_TYPE_COLOR_HASH_ETH
+#define ERF_TYPE_COLOR_HASH_ETH     20

 #endif
 
 #endif
 

-#ifndef TYPE_INFINIBAND
-#define TYPE_INFINIBAND         21
+#ifndef ERF_TYPE_INFINIBAND
+#define ERF_TYPE_INFINIBAND         21

 #endif
 
 #endif
 

-#ifndef TYPE_IPV4
-#define TYPE_IPV4               22
+#ifndef ERF_TYPE_IPV4
+#define ERF_TYPE_IPV4               22

 #endif
 
 #endif
 

-#ifndef TYPE_IPV6
-#define TYPE_IPV6               23
+#ifndef ERF_TYPE_IPV6
+#define ERF_TYPE_IPV6               23

 #endif
 
 #endif
 

-#ifndef TYPE_RAW_LINK
-#define TYPE_RAW_LINK           24
+#ifndef ERF_TYPE_RAW_LINK
+#define ERF_TYPE_RAW_LINK           24

 #endif
 
 #endif
 

-#ifndef TYPE_INFINIBAND_LINK
-#define TYPE_INFINIBAND_LINK    25
+#ifndef ERF_TYPE_INFINIBAND_LINK
+#define ERF_TYPE_INFINIBAND_LINK    25

 #endif
 
 #endif
 

-#ifndef TYPE_PAD
-#define TYPE_PAD                48
+#ifndef ERF_TYPE_META
+#define ERF_TYPE_META               27
+#endif
+
+#ifndef ERF_TYPE_PAD
+#define ERF_TYPE_PAD                48

 #endif
 
 #define ATM_CELL_SIZE          52
 #endif
 
 #define ATM_CELL_SIZE          52


@@ -173,16 +177,10 @@ struct sunatm_hdr {
  */
 struct pcap_dag {
        struct pcap_stat stat;
  */
 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 */
        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_fcs_bits;   /* Number of checksum bits from link layer */

-       int     dag_offset_flags; /* Flags to pass to dag_offset(). */
+       int     dag_flags;      /* Flags */

        int     dag_stream;     /* DAG stream number */
        int     dag_timeout;    /* timeout specified to pcap_open_live.
                                 * Same as in linux above, introduce
        int     dag_stream;     /* DAG stream number */
        int     dag_timeout;    /* timeout specified to pcap_open_live.
                                 * Same as in linux above, introduce


@@ -205,6 +203,13 @@ static const unsigned short endian_test_word = 0x0100;
 
 static unsigned char TempPkt[MAX_DAG_PACKET];
 
 
 static unsigned char TempPkt[MAX_DAG_PACKET];
 

+#ifndef HAVE_DAG_LARGE_STREAMS_API
+#define dag_attach_stream64(a, b, c, d) dag_attach_stream(a, b, c, d)
+#define dag_get_stream_poll64(a, b, c, d, e) dag_get_stream_poll(a, b, c, d, e)
+#define dag_set_stream_poll64(a, b, c, d, e) dag_set_stream_poll(a, b, c, d, e)
+#define dag_size_t uint32_t
+#endif
+

 static int dag_setfilter(pcap_t *p, struct bpf_program *fp);
 static int dag_stats(pcap_t *p, struct pcap_stat *ps);
 static int dag_set_datalink(pcap_t *p, int dlt);
 static int dag_setfilter(pcap_t *p, struct bpf_program *fp);
 static int dag_stats(pcap_t *p, struct pcap_stat *ps);
 static int dag_set_datalink(pcap_t *p, int dlt);


@@ -239,16 +244,12 @@ dag_platform_cleanup(pcap_t *p)
 {
        struct pcap_dag *pd = p->priv;
 
 {
        struct pcap_dag *pd = p->priv;
 

-#ifdef HAVE_DAG_STREAMS_API

        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));
        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));
-#endif /* HAVE_DAG_STREAMS_API */
+

        if(p->fd != -1) {
                if(dag_close(p->fd) < 0)
                        fprintf(stderr,"dag_close: %s\n", strerror(errno));
        if(p->fd != -1) {
                if(dag_close(p->fd) < 0)
                        fprintf(stderr,"dag_close: %s\n", strerror(errno));


@@ -337,8 +338,7 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 {
        struct pcap_dag *pd = p->priv;
        unsigned int processed = 0;
 {
        struct pcap_dag *pd = p->priv;
        unsigned int processed = 0;

-       int flags = pd->dag_offset_flags;
-       unsigned int nonblocking = flags & DAGF_NONBLOCK;
+       unsigned int nonblocking = pd->dag_flags & DAGF_NONBLOCK;

        unsigned int num_ext_hdr = 0;
        unsigned int ticks_per_second;
 
        unsigned int num_ext_hdr = 0;
        unsigned int ticks_per_second;
 


@@ -358,7 +358,6 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                        return -2;
                }
 
                        return -2;
                }
 

-#ifdef HAVE_DAG_STREAMS_API

                /* dag_advance_stream() will block (unless nonblock is called)
                 * until 64kB of data has accumulated.
                 * If to_ms is set, it will timeout before 64kB has accumulated.
                /* dag_advance_stream() will block (unless nonblock is called)
                 * until 64kB of data has accumulated.
                 * If to_ms is set, it will timeout before 64kB has accumulated.


@@ -373,10 +372,6 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                if ( NULL == (pd->dag_mem_top = dag_advance_stream(p->fd, pd->dag_stream, &(pd->dag_mem_bottom))) ) {
                     return -1;
                }
                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 */
-               pd->dag_mem_top = dag_offset(p->fd, &(pd->dag_mem_bottom), flags);
-#endif /* HAVE_DAG_STREAMS_API */

 
                if (nonblocking && (pd->dag_mem_top - pd->dag_mem_bottom < dag_record_size))
                {
 
                if (nonblocking && (pd->dag_mem_top - pd->dag_mem_bottom < dag_record_size))
                {


@@ -401,11 +396,7 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                int caplen = 0;
                struct pcap_pkthdr      pcap_header;
 
                int caplen = 0;
                struct pcap_pkthdr      pcap_header;
 

-#ifdef HAVE_DAG_STREAMS_API

                dag_record_t *header = (dag_record_t *)(pd->dag_mem_bottom);
                dag_record_t *header = (dag_record_t *)(pd->dag_mem_bottom);

-#else
-               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;
 
                u_char *dp = ((u_char *)header); /* + dag_record_size; */
                unsigned short rlen;


@@ -434,13 +425,13 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                /* Count lost packets. */
                switch((header->type & 0x7f)) {
                        /* in these types the color value overwrites the lctr */
                /* Count lost packets. */
                switch((header->type & 0x7f)) {
                        /* in these types the color value overwrites the lctr */

-               case TYPE_COLOR_HDLC_POS:
-               case TYPE_COLOR_ETH:
-               case TYPE_DSM_COLOR_HDLC_POS:
-               case TYPE_DSM_COLOR_ETH:
-               case TYPE_COLOR_MC_HDLC_POS:
-               case TYPE_COLOR_HASH_ETH:
-               case TYPE_COLOR_HASH_POS:
+               case ERF_TYPE_COLOR_HDLC_POS:
+               case ERF_TYPE_COLOR_ETH:
+               case ERF_TYPE_DSM_COLOR_HDLC_POS:
+               case ERF_TYPE_DSM_COLOR_ETH:
+               case ERF_TYPE_COLOR_MC_HDLC_POS:
+               case ERF_TYPE_COLOR_HASH_ETH:
+               case ERF_TYPE_COLOR_HASH_POS:

                        break;
 
                default:
                        break;
 
                default:


@@ -453,7 +444,7 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                        }
                }
 
                        }
                }
 

-               if ((header->type & 0x7f) == TYPE_PAD) {
+               if ((header->type & 0x7f) == ERF_TYPE_PAD) {

                        continue;
                }
 
                        continue;
                }
 


@@ -477,20 +468,20 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                        packet_len = ntohs(header->wlen) + dag_record_size;
                        caplen = rlen;
                        switch ((header->type & 0x7f)) {
                        packet_len = ntohs(header->wlen) + dag_record_size;
                        caplen = rlen;
                        switch ((header->type & 0x7f)) {

-                       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:
+                       case ERF_TYPE_MC_AAL5:
+                       case ERF_TYPE_MC_ATM:
+                       case ERF_TYPE_MC_HDLC:
+                       case ERF_TYPE_MC_RAW_CHANNEL:
+                       case ERF_TYPE_MC_RAW:
+                       case ERF_TYPE_MC_AAL2:
+                       case ERF_TYPE_COLOR_MC_HDLC_POS:

                                packet_len += 4; /* MC header */
                                break;
 
                                packet_len += 4; /* MC header */
                                break;
 

-                       case TYPE_COLOR_HASH_ETH:
-                       case TYPE_DSM_COLOR_ETH:
-                       case TYPE_COLOR_ETH:
-                       case TYPE_ETH:
+                       case ERF_TYPE_COLOR_HASH_ETH:
+                       case ERF_TYPE_DSM_COLOR_ETH:
+                       case ERF_TYPE_COLOR_ETH:
+                       case ERF_TYPE_ETH:

                                packet_len += 2; /* ETH header */
                                break;
                        } /* switch type */
                                packet_len += 2; /* ETH header */
                                break;
                        } /* switch type */


@@ -510,19 +501,19 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                        dp += 8 * num_ext_hdr;
 
                        switch((header->type & 0x7f)) {
                        dp += 8 * num_ext_hdr;
 
                        switch((header->type & 0x7f)) {

-                       case TYPE_ATM:
-                       case TYPE_AAL5:
-                               if (header->type == TYPE_AAL5) {
+                       case ERF_TYPE_ATM:
+                       case ERF_TYPE_AAL5:
+                               if ((header->type & 0x7f) == ERF_TYPE_AAL5) {

                                        packet_len = ntohs(header->wlen);
                                        caplen = rlen - dag_record_size;
                                }
                                        packet_len = ntohs(header->wlen);
                                        caplen = rlen - dag_record_size;
                                }

-                       case TYPE_MC_ATM:
-                               if (header->type == TYPE_MC_ATM) {
+                       case ERF_TYPE_MC_ATM:
+                               if ((header->type & 0x7f) == ERF_TYPE_MC_ATM) {

                                        caplen = packet_len = ATM_CELL_SIZE;
                                        dp+=4;
                                }
                                        caplen = packet_len = ATM_CELL_SIZE;
                                        dp+=4;
                                }

-                       case TYPE_MC_AAL5:
-                               if (header->type == TYPE_MC_AAL5) {
+                       case ERF_TYPE_MC_AAL5:
+                               if ((header->type & 0x7f) == ERF_TYPE_MC_AAL5) {

                                        packet_len = ntohs(header->wlen);
                                        caplen = rlen - dag_record_size - 4;
                                        dp+=4;
                                        packet_len = ntohs(header->wlen);
                                        caplen = rlen - dag_record_size - 4;
                                        dp+=4;


@@ -530,7 +521,7 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                                /* Skip over extension headers */
                                caplen -= (8 * num_ext_hdr);
 
                                /* Skip over extension headers */
                                caplen -= (8 * num_ext_hdr);
 

-                               if (header->type == TYPE_ATM) {
+                               if ((header->type & 0x7f) == ERF_TYPE_ATM) {

                                        caplen = packet_len = ATM_CELL_SIZE;
                                }
                                if (p->linktype == DLT_SUNATM) {
                                        caplen = packet_len = ATM_CELL_SIZE;
                                }
                                if (p->linktype == DLT_SUNATM) {


@@ -547,17 +538,21 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                                                    dp[ATM_HDR_SIZE+1] == 0xaa &&
                                                    dp[ATM_HDR_SIZE+2] == 0x03) ? 2 : 1)));
 
                                                    dp[ATM_HDR_SIZE+1] == 0xaa &&
                                                    dp[ATM_HDR_SIZE+2] == 0x03) ? 2 : 1)));
 

-                               } else {
+                               } else if (p->linktype == DLT_ATM_RFC1483) {

                                        packet_len -= ATM_HDR_SIZE;
                                        caplen -= ATM_HDR_SIZE;
                                        dp += ATM_HDR_SIZE;
                                        packet_len -= ATM_HDR_SIZE;
                                        caplen -= ATM_HDR_SIZE;
                                        dp += ATM_HDR_SIZE;

-                               }
+                               } else
+                                       continue;

                                break;
 
                                break;
 

-                       case TYPE_COLOR_HASH_ETH:
-                       case TYPE_DSM_COLOR_ETH:
-                       case TYPE_COLOR_ETH:
-                       case TYPE_ETH:
+                       case ERF_TYPE_COLOR_HASH_ETH:
+                       case ERF_TYPE_DSM_COLOR_ETH:
+                       case ERF_TYPE_COLOR_ETH:
+                       case ERF_TYPE_ETH:
+                               if ((p->linktype != DLT_EN10MB) &&
+                                   (p->linktype != DLT_DOCSIS))
+                                       continue;

                                packet_len = ntohs(header->wlen);
                                packet_len -= (pd->dag_fcs_bits >> 3);
                                caplen = rlen - dag_record_size - 2;
                                packet_len = ntohs(header->wlen);
                                packet_len -= (pd->dag_fcs_bits >> 3);
                                caplen = rlen - dag_record_size - 2;


@@ -569,10 +564,14 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                                dp += 2;
                                break;
 
                                dp += 2;
                                break;
 

-                       case TYPE_COLOR_HASH_POS:
-                       case TYPE_DSM_COLOR_HDLC_POS:
-                       case TYPE_COLOR_HDLC_POS:
-                       case TYPE_HDLC_POS:
+                       case ERF_TYPE_COLOR_HASH_POS:
+                       case ERF_TYPE_DSM_COLOR_HDLC_POS:
+                       case ERF_TYPE_COLOR_HDLC_POS:
+                       case ERF_TYPE_HDLC_POS:
+                               if ((p->linktype != DLT_CHDLC) &&
+                                   (p->linktype != DLT_PPP_SERIAL) &&
+                                   (p->linktype != DLT_FRELAY))
+                                       continue;

                                packet_len = ntohs(header->wlen);
                                packet_len -= (pd->dag_fcs_bits >> 3);
                                caplen = rlen - dag_record_size;
                                packet_len = ntohs(header->wlen);
                                packet_len -= (pd->dag_fcs_bits >> 3);
                                caplen = rlen - dag_record_size;


@@ -583,8 +582,15 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                                }
                                break;
 
                                }
                                break;
 

-                       case TYPE_COLOR_MC_HDLC_POS:
-                       case TYPE_MC_HDLC:
+                       case ERF_TYPE_COLOR_MC_HDLC_POS:
+                       case ERF_TYPE_MC_HDLC:
+                               if ((p->linktype != DLT_CHDLC) &&
+                                   (p->linktype != DLT_PPP_SERIAL) &&
+                                   (p->linktype != DLT_FRELAY) &&
+                                   (p->linktype != DLT_MTP2) &&
+                                   (p->linktype != DLT_MTP2_WITH_PHDR) &&
+                                   (p->linktype != DLT_LAPD))
+                                       continue;

                                packet_len = ntohs(header->wlen);
                                packet_len -= (pd->dag_fcs_bits >> 3);
                                caplen = rlen - dag_record_size - 4;
                                packet_len = ntohs(header->wlen);
                                packet_len -= (pd->dag_fcs_bits >> 3);
                                caplen = rlen - dag_record_size - 4;


@@ -611,8 +617,23 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 #endif
                                break;
 
 #endif
                                break;
 

-                       case TYPE_IPV4:
-                       case TYPE_IPV6:
+                       case ERF_TYPE_IPV4:
+                               if ((p->linktype != DLT_RAW) &&
+                                   (p->linktype != DLT_IPV4))
+                                       continue;
+                               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;
+
+                       case ERF_TYPE_IPV6:
+                               if ((p->linktype != DLT_RAW) &&
+                                   (p->linktype != DLT_IPV6))
+                                       continue;

                                packet_len = ntohs(header->wlen);
                                caplen = rlen - dag_record_size;
                                /* Skip over extension headers */
                                packet_len = ntohs(header->wlen);
                                caplen = rlen - dag_record_size;
                                /* Skip over extension headers */


@@ -623,13 +644,13 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
                                break;
 
                        /* These types have no matching 'native' DLT, but can be used with DLT_ERF above */
                                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:
+                       case ERF_TYPE_MC_RAW:
+                       case ERF_TYPE_MC_RAW_CHANNEL:
+                       case ERF_TYPE_IP_COUNTER:
+                       case ERF_TYPE_TCP_FLOW_COUNTER:
+                       case ERF_TYPE_INFINIBAND:
+                       case ERF_TYPE_RAW_LINK:
+                       case ERF_TYPE_INFINIBAND_LINK:

                        default:
                                /* Unhandled ERF type.
                                 * Ignore rather than generating error
                        default:
                                /* Unhandled ERF type.
                                 * Ignore rather than generating error


@@ -718,19 +739,14 @@ dag_inject(pcap_t *p, const void *buf _U_, size_t size _U_)
 static int dag_activate(pcap_t* handle)
 {
        struct pcap_dag *handlep = handle->priv;
 static int dag_activate(pcap_t* handle)
 {
        struct pcap_dag *handlep = handle->priv;

-#if 0
-       char conf[30]; /* dag configure string */
-#endif

        char *s;
        int n;
        daginf_t* daginf;
        char * newDev = NULL;
        char * device = handle->opt.device;
        char *s;
        int n;
        daginf_t* daginf;
        char * newDev = NULL;
        char * device = handle->opt.device;

-#ifdef HAVE_DAG_STREAMS_API
-       uint32_t mindata;
+       dag_size_t mindata;

        struct timeval maxwait;
        struct timeval poll;
        struct timeval maxwait;
        struct timeval poll;

-#endif

 
        if (device == NULL) {
                pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "device is NULL: %s", pcap_strerror(errno));
 
        if (device == NULL) {
                pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "device is NULL: %s", pcap_strerror(errno));


@@ -738,8 +754,6 @@ static int dag_activate(pcap_t* handle)
        }
 
        /* Initialize some components of the pcap structure. */
        }
 
        /* Initialize some components of the pcap structure. */

-
-#ifdef HAVE_DAG_STREAMS_API

        newDev = (char *)malloc(strlen(device) + 16);
        if (newDev == NULL) {
                pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s", pcap_strerror(errno));
        newDev = (char *)malloc(strlen(device) + 16);
        if (newDev == NULL) {
                pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s", pcap_strerror(errno));


@@ -757,18 +771,6 @@ static int dag_activate(pcap_t* handle)
                pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_parse_name: tx (even numbered) streams not supported for capture");
                goto fail;
        }
                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) {
-                       pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s", pcap_strerror(errno));
-                       goto fail;
-               }
-               strcpy(newDev, "/dev/");
-               strcat(newDev, device);
-               device = newDev;
-       }
-#endif /* HAVE_DAG_STREAMS_API */

 
        /* setup device parameters */
        if((handle->fd = dag_open((char *)device)) < 0) {
 
        /* setup device parameters */
        if((handle->fd = dag_open((char *)device)) < 0) {


@@ -776,9 +778,8 @@ static int dag_activate(pcap_t* handle)
                goto fail;
        }
 
                goto fail;
        }
 

-#ifdef HAVE_DAG_STREAMS_API

        /* Open requested stream. Can fail if already locked or on error */
        /* Open requested stream. Can fail if already locked or on error */

-       if (dag_attach_stream(handle->fd, handlep->dag_stream, 0, 0) < 0) {
+       if (dag_attach_stream64(handle->fd, handlep->dag_stream, 0, 0) < 0) {

                pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_attach_stream: %s", pcap_strerror(errno));
                goto failclose;
        }
                pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_attach_stream: %s", pcap_strerror(errno));
                goto failclose;
        }


@@ -786,7 +787,7 @@ static int dag_activate(pcap_t* handle)
        /* Set up default poll parameters for stream
         * Can be overridden by pcap_set_nonblock()
         */
        /* Set up default poll parameters for stream
         * Can be overridden by pcap_set_nonblock()
         */

-       if (dag_get_stream_poll(handle->fd, handlep->dag_stream,
+       if (dag_get_stream_poll64(handle->fd, handlep->dag_stream,

                                &mindata, &maxwait, &poll) < 0) {
                pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s", pcap_strerror(errno));
                goto faildetach;
                                &mindata, &maxwait, &poll) < 0) {
                pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s", pcap_strerror(errno));
                goto faildetach;


@@ -811,20 +812,12 @@ static int dag_activate(pcap_t* handle)
        maxwait.tv_sec = handle->opt.timeout/1000;
        maxwait.tv_usec = (handle->opt.timeout%1000) * 1000;
 
        maxwait.tv_sec = handle->opt.timeout/1000;
        maxwait.tv_usec = (handle->opt.timeout%1000) * 1000;
 

-       if (dag_set_stream_poll(handle->fd, handlep->dag_stream,
+       if (dag_set_stream_poll64(handle->fd, handlep->dag_stream,

                                mindata, &maxwait, &poll) < 0) {
                pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s", pcap_strerror(errno));
                goto faildetach;
        }
 
                                mindata, &maxwait, &poll) < 0) {
                pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s", pcap_strerror(errno));
                goto faildetach;
        }
 

-#else
-       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;
-       }
-
-#endif /* HAVE_DAG_STREAMS_API */
-

         /* XXX Not calling dag_configure() to set slen; this is unsafe in
         * multi-stream environments as the gpp config is global.
          * Once the firmware provides 'per-stream slen' this can be supported
         /* XXX Not calling dag_configure() to set slen; this is unsafe in
         * multi-stream environments as the gpp config is global.
          * Once the firmware provides 'per-stream slen' this can be supported


@@ -839,25 +832,12 @@ static int dag_activate(pcap_t* handle)
                handle->snapshot = MIN_DAG_SNAPLEN;
        }
        /* snap len has to be a multiple of 4 */
                handle->snapshot = MIN_DAG_SNAPLEN;
        }
        /* snap len has to be a multiple of 4 */

-       pcap_snprintf(conf, 30, "varlen slen=%d", (snaplen + 3) & ~3);
-
-       if(dag_configure(handle->fd, conf) < 0) {
-               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, handlep->dag_stream) < 0) {
                pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_start_stream %s: %s", device, pcap_strerror(errno));
                goto faildetach;
        }
        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) {
-               pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_start %s: %s", device, pcap_strerror(errno));
-               goto failclose;
-       }
-#endif /* HAVE_DAG_STREAMS_API */

 
        /*
         * Important! You have to ensure bottom is properly
 
        /*
         * Important! You have to ensure bottom is properly


@@ -944,7 +924,6 @@ static int dag_activate(pcap_t* handle)
        handlep->stat.ps_ifdrop = 0;
        return 0;
 
        handlep->stat.ps_ifdrop = 0;
        return 0;
 

-#ifdef HAVE_DAG_STREAMS_API

 failstop:
        if (dag_stop_stream(handle->fd, handlep->dag_stream) < 0) {
                fprintf(stderr,"dag_stop_stream: %s\n", strerror(errno));
 failstop:
        if (dag_stop_stream(handle->fd, handlep->dag_stream) < 0) {
                fprintf(stderr,"dag_stop_stream: %s\n", strerror(errno));


@@ -953,11 +932,6 @@ failstop:
 faildetach:
        if (dag_detach_stream(handle->fd, handlep->dag_stream) < 0)
                fprintf(stderr,"dag_detach_stream: %s\n", strerror(errno));
 faildetach:
        if (dag_detach_stream(handle->fd, handlep->dag_stream) < 0)
                fprintf(stderr,"dag_detach_stream: %s\n", strerror(errno));

-#else
-failstop:
-       if (dag_stop(handle->fd) < 0)
-               fprintf(stderr,"dag_stop: %s\n", strerror(errno));
-#endif /* HAVE_DAG_STREAMS_API */

 
 failclose:
        if (dag_close(handle->fd) < 0)
 
 failclose:
        if (dag_close(handle->fd) < 0)


@@ -979,9 +953,7 @@ pcap_t *dag_create(const char *device, char *ebuf, int *is_ours)
        char *cpend;
        long devnum;
        pcap_t *p;
        char *cpend;
        long devnum;
        pcap_t *p;

-#ifdef HAVE_DAG_STREAMS_API

        long stream = 0;
        long stream = 0;

-#endif

 
        /* Does this look like a DAG device? */
        cp = strrchr(device, '/');
 
        /* Does this look like a DAG device? */
        cp = strrchr(device, '/');


@@ -996,29 +968,28 @@ pcap_t *dag_create(const char *device, char *ebuf, int *is_ours)
        /* Yes - is "dag" followed by a number from 0 to DAG_MAX_BOARDS-1 */
        cp += 3;
        devnum = strtol(cp, &cpend, 10);
        /* 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);
        }
        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 (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;
        }
        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;
        }
        if (stream <0 || stream >= DAG_STREAM_MAX) {
                /* Followed by a non-valid stream number. */
                *is_ours = 0;
                return NULL;
        }

-#endif

 
        /* OK, it's probably ours. */
        *is_ours = 1;
 
        /* OK, it's probably ours. */
        *is_ours = 1;


@@ -1078,6 +1049,7 @@ dag_findalldevs(pcap_if_list_t *devlistp, char *errbuf)
        int dagfd;
        dag_card_inf_t *inf;
        char *description;
        int dagfd;
        dag_card_inf_t *inf;
        char *description;

+       int stream, rxstreams;

 
        /* Try all the DAGs 0-DAG_MAX_BOARDS */
        for (c = 0; c < DAG_MAX_BOARDS; c++) {
 
        /* Try all the DAGs 0-DAG_MAX_BOARDS */
        for (c = 0; c < DAG_MAX_BOARDS; c++) {


@@ -1098,33 +1070,28 @@ dag_findalldevs(pcap_if_list_t *devlistp, char *errbuf)
                                 */
                                ret = -1;
                        }
                                 */
                                ret = -1;
                        }

-#ifdef HAVE_DAG_STREAMS_API
-                       {
-                               int stream, rxstreams;
-                               rxstreams = dag_rx_get_stream_count(dagfd);
-                               for(stream=0;stream<DAG_STREAM_MAX;stream+=2) {
-                                       if (0 == dag_attach_stream(dagfd, stream, 0, 0)) {
-                                               dag_detach_stream(dagfd, stream);
-
-                                               pcap_snprintf(name,  10, "dag%d:%d", c, stream);
-                                               if (add_dev(devlistp, name, 0, description, errbuf) == NULL) {
-                                                       /*
-                                                        * Failure.
-                                                        */
-                                                       ret = -1;
-                                               }
-
-                                               rxstreams--;
-                                               if(rxstreams <= 0) {
-                                                       break;
-                                               }
+                       rxstreams = dag_rx_get_stream_count(dagfd);
+                       for(stream=0;stream<DAG_STREAM_MAX;stream+=2) {
+                               if (0 == dag_attach_stream(dagfd, stream, 0, 0)) {
+                                       dag_detach_stream(dagfd, stream);
+                                       
+                                       pcap_snprintf(name,  10, "dag%d:%d", c, stream);
+                                       if (add_dev(devlistp, name, 0, description, errbuf) == NULL) {
+                                               /*
+                                                * Failure.
+                                                */
+                                               ret = -1;
+                                       }
+                                       
+                                       rxstreams--;
+                                       if(rxstreams <= 0) {
+                                               break;

                                        }
                                }
                        }
                                        }
                                }
                        }

-#endif  /* HAVE_DAG_STREAMS_API */

                        dag_close(dagfd);
                }
                        dag_close(dagfd);
                }

-
+               

        }
        return (ret);
 }
        }
        return (ret);
 }


@@ -1165,47 +1132,44 @@ static int
 dag_setnonblock(pcap_t *p, int nonblock, char *errbuf)
 {
        struct pcap_dag *pd = p->priv;
 dag_setnonblock(pcap_t *p, int nonblock, char *errbuf)
 {
        struct pcap_dag *pd = p->priv;

+       dag_size_t mindata;
+       struct timeval maxwait;
+       struct timeval poll;

 
        /*
         * 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
 
        /*
         * 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

-        * "pd->dag_offset_flags".
+        * "pd->dag_flags".

         */
        if (pcap_setnonblock_fd(p, nonblock, errbuf) < 0)
                return (-1);
         */
        if (pcap_setnonblock_fd(p, nonblock, errbuf) < 0)
                return (-1);

-#ifdef HAVE_DAG_STREAMS_API
-       {
-               uint32_t mindata;
-               struct timeval maxwait;
-               struct timeval poll;

 
 

-               if (dag_get_stream_poll(p->fd, pd->dag_stream,
-                                       &mindata, &maxwait, &poll) < 0) {
-                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s", pcap_strerror(errno));
-                       return -1;
-               }
+       if (dag_get_stream_poll64(p->fd, pd->dag_stream,
+                               &mindata, &maxwait, &poll) < 0) {
+               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!
-                */
-               if(nonblock)
-                       mindata = 0;
-               else
-                       mindata = 65536;
-
-               if (dag_set_stream_poll(p->fd, pd->dag_stream,
-                                       mindata, &maxwait, &poll) < 0) {
-                       pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_set_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!
+        */
+       if(nonblock)
+               mindata = 0;
+       else
+               mindata = 65536;
+
+       if (dag_set_stream_poll64(p->fd, pd->dag_stream,
+                               mindata, &maxwait, &poll) < 0) {
+               pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s", pcap_strerror(errno));
+               return -1;

        }
        }

-#endif /* HAVE_DAG_STREAMS_API */
+

        if (nonblock) {
        if (nonblock) {

-               pd->dag_offset_flags |= DAGF_NONBLOCK;
+               pd->dag_flags |= DAGF_NONBLOCK;

        } else {
        } else {

-               pd->dag_offset_flags &= ~DAGF_NONBLOCK;
+               pd->dag_flags &= ~DAGF_NONBLOCK;

        }
        return (0);
 }
        }
        return (0);
 }


@@ -1251,10 +1215,10 @@ dag_get_datalink(pcap_t *p)
 #endif
                switch((types[index] & 0x7f)) {
 
 #endif
                switch((types[index] & 0x7f)) {
 

-               case TYPE_HDLC_POS:
-               case TYPE_COLOR_HDLC_POS:
-               case TYPE_DSM_COLOR_HDLC_POS:
-               case TYPE_COLOR_HASH_POS:
+               case ERF_TYPE_HDLC_POS:
+               case ERF_TYPE_COLOR_HDLC_POS:
+               case ERF_TYPE_DSM_COLOR_HDLC_POS:
+               case ERF_TYPE_COLOR_HASH_POS:

 
                        if (p->dlt_list != NULL) {
                                p->dlt_list[dlt_index++] = DLT_CHDLC;
 
                        if (p->dlt_list != NULL) {
                                p->dlt_list[dlt_index++] = DLT_CHDLC;


@@ -1265,10 +1229,10 @@ dag_get_datalink(pcap_t *p)
                                p->linktype = DLT_CHDLC;
                        break;
 
                                p->linktype = DLT_CHDLC;
                        break;
 

-               case TYPE_ETH:
-               case TYPE_COLOR_ETH:
-               case TYPE_DSM_COLOR_ETH:
-               case TYPE_COLOR_HASH_ETH:
+               case ERF_TYPE_ETH:
+               case ERF_TYPE_COLOR_ETH:
+               case ERF_TYPE_DSM_COLOR_ETH:
+               case ERF_TYPE_COLOR_HASH_ETH:

                        /*
                         * This is (presumably) a real Ethernet capture; give it a
                         * link-layer-type list with DLT_EN10MB and DLT_DOCSIS, so
                        /*
                         * This is (presumably) a real Ethernet capture; give it a
                         * link-layer-type list with DLT_EN10MB and DLT_DOCSIS, so


@@ -1287,10 +1251,10 @@ dag_get_datalink(pcap_t *p)
                                p->linktype = DLT_EN10MB;
                        break;
 
                                p->linktype = DLT_EN10MB;
                        break;
 

-               case TYPE_ATM:
-               case TYPE_AAL5:
-               case TYPE_MC_ATM:
-               case TYPE_MC_AAL5:
+               case ERF_TYPE_ATM:
+               case ERF_TYPE_AAL5:
+               case ERF_TYPE_MC_ATM:
+               case ERF_TYPE_MC_AAL5:

                        if (p->dlt_list != NULL) {
                                p->dlt_list[dlt_index++] = DLT_ATM_RFC1483;
                                p->dlt_list[dlt_index++] = DLT_SUNATM;
                        if (p->dlt_list != NULL) {
                                p->dlt_list[dlt_index++] = DLT_ATM_RFC1483;
                                p->dlt_list[dlt_index++] = DLT_SUNATM;


@@ -1299,8 +1263,8 @@ dag_get_datalink(pcap_t *p)
                                p->linktype = DLT_ATM_RFC1483;
                        break;
 
                                p->linktype = DLT_ATM_RFC1483;
                        break;
 

-               case TYPE_COLOR_MC_HDLC_POS:
-               case TYPE_MC_HDLC:
+               case ERF_TYPE_COLOR_MC_HDLC_POS:
+               case ERF_TYPE_MC_HDLC:

                        if (p->dlt_list != NULL) {
                                p->dlt_list[dlt_index++] = DLT_CHDLC;
                                p->dlt_list[dlt_index++] = DLT_PPP_SERIAL;
                        if (p->dlt_list != NULL) {
                                p->dlt_list[dlt_index++] = DLT_CHDLC;
                                p->dlt_list[dlt_index++] = DLT_PPP_SERIAL;


@@ -1313,20 +1277,33 @@ dag_get_datalink(pcap_t *p)
                                p->linktype = DLT_CHDLC;
                        break;
 
                                p->linktype = DLT_CHDLC;
                        break;
 

-               case TYPE_IPV4:
-               case TYPE_IPV6:
+               case ERF_TYPE_IPV4:
+                       if (p->dlt_list != NULL) {
+                               p->dlt_list[dlt_index++] = DLT_RAW;
+                               p->dlt_list[dlt_index++] = DLT_IPV4;
+                       }
+                       if(!p->linktype)
+                               p->linktype = DLT_RAW;
+                       break;
+                       
+               case ERF_TYPE_IPV6:
+                       if (p->dlt_list != NULL) {
+                               p->dlt_list[dlt_index++] = DLT_RAW;
+                               p->dlt_list[dlt_index++] = DLT_IPV6;
+                       }

                        if(!p->linktype)
                                p->linktype = DLT_RAW;
                        break;
 
                        if(!p->linktype)
                                p->linktype = DLT_RAW;
                        break;
 

-               case TYPE_LEGACY:
-               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:
+               case ERF_TYPE_LEGACY:
+               case ERF_TYPE_MC_RAW:
+               case ERF_TYPE_MC_RAW_CHANNEL:
+               case ERF_TYPE_IP_COUNTER:
+               case ERF_TYPE_TCP_FLOW_COUNTER:
+               case ERF_TYPE_INFINIBAND:
+               case ERF_TYPE_RAW_LINK:
+               case ERF_TYPE_INFINIBAND_LINK:
+               case ERF_TYPE_META:

                default:
                        /* Libpcap cannot deal with these types yet */
                        /* Add no 'native' DLTs, but still covered by DLT_ERF */
                default:
                        /* Libpcap cannot deal with these types yet */
                        /* Add no 'native' DLTs, but still covered by DLT_ERF */