From: Stephen Donnelly Date: Fri, 27 Jan 2017 01:37:18 +0000 (+1300) Subject: Adding support for Large stream buffers on Endace DAG cards X-Git-Tag: libpcap-1.9-bp~925^2~1 X-Git-Url: https://git.tcpdump.org/libpcap/commitdiff_plain/df9093be981d182052f5f6fecb0f57e39ddd6bb4 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 02f4110d..a2b31d4a 100644 --- 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" - 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], [ @@ -860,8 +860,8 @@ if test "$want_dag" != no; then 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" diff --git a/pcap-dag.c b/pcap-dag.c index fbd12973..6a6019b5 100644 --- a/pcap-dag.c +++ b/pcap-dag.c @@ -54,96 +54,100 @@ struct rtentry; /* declarations in */ #endif -#ifndef TYPE_AAL5 -#define TYPE_AAL5 4 +#ifndef ERF_TYPE_AAL5 +#define ERF_TYPE_AAL5 4 #endif -#ifndef TYPE_MC_HDLC -#define TYPE_MC_HDLC 5 +#ifndef ERF_TYPE_MC_HDLC +#define ERF_TYPE_MC_HDLC 5 #endif -#ifndef TYPE_MC_RAW -#define TYPE_MC_RAW 6 +#ifndef ERF_TYPE_MC_RAW +#define ERF_TYPE_MC_RAW 6 #endif -#ifndef TYPE_MC_ATM -#define TYPE_MC_ATM 7 +#ifndef ERF_TYPE_MC_ATM +#define ERF_TYPE_MC_ATM 7 #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 -#ifndef TYPE_MC_AAL5 -#define TYPE_MC_AAL5 9 +#ifndef ERF_TYPE_MC_AAL5 +#define ERF_TYPE_MC_AAL5 9 #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 -#ifndef TYPE_COLOR_ETH -#define TYPE_COLOR_ETH 11 +#ifndef ERF_TYPE_COLOR_ETH +#define ERF_TYPE_COLOR_ETH 11 #endif -#ifndef TYPE_MC_AAL2 -#define TYPE_MC_AAL2 12 +#ifndef ERF_TYPE_MC_AAL2 +#define ERF_TYPE_MC_AAL2 12 #endif -#ifndef TYPE_IP_COUNTER -#define TYPE_IP_COUNTER 13 +#ifndef ERF_TYPE_IP_COUNTER +#define ERF_TYPE_IP_COUNTER 13 #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 -#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 -#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 -#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 -#ifndef TYPE_AAL2 -#define TYPE_AAL2 18 +#ifndef ERF_TYPE_AAL2 +#define ERF_TYPE_AAL2 18 #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 -#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 -#ifndef TYPE_INFINIBAND -#define TYPE_INFINIBAND 21 +#ifndef ERF_TYPE_INFINIBAND +#define ERF_TYPE_INFINIBAND 21 #endif -#ifndef TYPE_IPV4 -#define TYPE_IPV4 22 +#ifndef ERF_TYPE_IPV4 +#define ERF_TYPE_IPV4 22 #endif -#ifndef TYPE_IPV6 -#define TYPE_IPV6 23 +#ifndef ERF_TYPE_IPV6 +#define ERF_TYPE_IPV6 23 #endif -#ifndef TYPE_RAW_LINK -#define TYPE_RAW_LINK 24 +#ifndef ERF_TYPE_RAW_LINK +#define ERF_TYPE_RAW_LINK 24 #endif -#ifndef TYPE_INFINIBAND_LINK -#define TYPE_INFINIBAND_LINK 25 +#ifndef ERF_TYPE_INFINIBAND_LINK +#define ERF_TYPE_INFINIBAND_LINK 25 #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 @@ -173,16 +177,10 @@ struct sunatm_hdr { */ 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_flags; /* Flags */ 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]; +#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); @@ -239,16 +244,12 @@ dag_platform_cleanup(pcap_t *p) { 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)); -#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)); @@ -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; - 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; @@ -358,7 +358,6 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user) 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. @@ -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; } -#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)) { @@ -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; -#ifdef HAVE_DAG_STREAMS_API 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; @@ -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 */ - 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: @@ -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; } @@ -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)) { - 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; - 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 */ @@ -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)) { - 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; } - 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; } - 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; @@ -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); - if (header->type == TYPE_ATM) { + if ((header->type & 0x7f) == ERF_TYPE_ATM) { 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))); - } else { + } else if (p->linktype == DLT_ATM_RFC1483) { packet_len -= ATM_HDR_SIZE; caplen -= ATM_HDR_SIZE; dp += ATM_HDR_SIZE; - } + } else + continue; 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; @@ -569,10 +564,14 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user) 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; @@ -583,8 +582,15 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user) } 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; @@ -611,8 +617,23 @@ dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user) #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 */ @@ -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 */ - 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 @@ -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; -#if 0 - char conf[30]; /* dag configure string */ -#endif 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; -#endif 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. */ - -#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)); @@ -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; } -#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) { @@ -776,9 +778,8 @@ static int dag_activate(pcap_t* handle) goto fail; } -#ifdef HAVE_DAG_STREAMS_API /* 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; } @@ -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() */ - 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; @@ -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; - 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; } -#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 @@ -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 */ - 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 -#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; } -#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 @@ -944,7 +924,6 @@ static int dag_activate(pcap_t* handle) 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)); @@ -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)); -#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) @@ -979,9 +953,7 @@ pcap_t *dag_create(const char *device, char *ebuf, int *is_ours) 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, '/'); @@ -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); -#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 /* 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 stream, rxstreams; /* 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; } -#ifdef HAVE_DAG_STREAMS_API - { - int stream, rxstreams; - rxstreams = dag_rx_get_stream_count(dagfd); - for(stream=0;streampriv; + 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 - * "pd->dag_offset_flags". + * "pd->dag_flags". */ 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) { - pd->dag_offset_flags |= DAGF_NONBLOCK; + pd->dag_flags |= DAGF_NONBLOCK; } else { - pd->dag_offset_flags &= ~DAGF_NONBLOCK; + pd->dag_flags &= ~DAGF_NONBLOCK; } return (0); } @@ -1251,10 +1215,10 @@ dag_get_datalink(pcap_t *p) #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; @@ -1265,10 +1229,10 @@ dag_get_datalink(pcap_t *p) 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 @@ -1287,10 +1251,10 @@ dag_get_datalink(pcap_t *p) 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; @@ -1299,8 +1263,8 @@ dag_get_datalink(pcap_t *p) 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; @@ -1313,20 +1277,33 @@ dag_get_datalink(pcap_t *p) 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; - 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 */