1 /*
2 * pcap-dag.c: Packet capture interface for Emulex EndaceDAG cards.
3 *
4 * The functionality of this code attempts to mimic that of pcap-linux as much
5 * as possible. This code is compiled in several different ways depending on
6 * whether DAG_ONLY and HAVE_DAG_API are defined. If HAVE_DAG_API is not
7 * defined it should not get compiled in, otherwise if DAG_ONLY is defined then
8 * the 'dag_' function calls are renamed to 'pcap_' equivalents. If DAG_ONLY
9 * is not defined then nothing is altered - the dag_ functions will be
10 * called as required from their pcap-linux/bpf equivalents.
11 *
12 * Authors: Richard Littin, Sean Irvine ({richard,sean}@reeltwo.com)
13 * Modifications: Jesper Peterson
14 * Koryn Grant
15 * Stephen Donnelly <stephen.donnelly@emulex.com>
16 */
17
18 #ifdef HAVE_CONFIG_H
19 #include "config.h"
20 #endif
21
22 #include <sys/param.h> /* optionally get BSD define */
23
24 #include <stdlib.h>
25 #include <string.h>
26 #include <errno.h>
27
28 #include "pcap-int.h"
29
30 #include <ctype.h>
31 #include <netinet/in.h>
32 #include <sys/mman.h>
33 #include <sys/socket.h>
34 #include <sys/types.h>
35 #include <unistd.h>
36
37 struct mbuf; /* Squelch compiler warnings on some platforms for */
38 struct rtentry; /* declarations in <net/if.h> */
39 #include <net/if.h>
40
41 #include "dagnew.h"
42 #include "dagapi.h"
43 #include "dagpci.h"
44
45 #include "pcap-dag.h"
46
47 /*
48 * DAG devices have names beginning with "dag", followed by a number
49 * from 0 to DAG_MAX_BOARDS, then optionally a colon and a stream number
50 * from 0 to DAG_STREAM_MAX.
51 */
52 #ifndef DAG_MAX_BOARDS
53 #define DAG_MAX_BOARDS 32
54 #endif
55
56
57 #ifndef TYPE_AAL5
58 #define TYPE_AAL5 4
59 #endif
60
61 #ifndef TYPE_MC_HDLC
62 #define TYPE_MC_HDLC 5
63 #endif
64
65 #ifndef TYPE_MC_RAW
66 #define TYPE_MC_RAW 6
67 #endif
68
69 #ifndef TYPE_MC_ATM
70 #define TYPE_MC_ATM 7
71 #endif
72
73 #ifndef TYPE_MC_RAW_CHANNEL
74 #define TYPE_MC_RAW_CHANNEL 8
75 #endif
76
77 #ifndef TYPE_MC_AAL5
78 #define TYPE_MC_AAL5 9
79 #endif
80
81 #ifndef TYPE_COLOR_HDLC_POS
82 #define TYPE_COLOR_HDLC_POS 10
83 #endif
84
85 #ifndef TYPE_COLOR_ETH
86 #define TYPE_COLOR_ETH 11
87 #endif
88
89 #ifndef TYPE_MC_AAL2
90 #define TYPE_MC_AAL2 12
91 #endif
92
93 #ifndef TYPE_IP_COUNTER
94 #define TYPE_IP_COUNTER 13
95 #endif
96
97 #ifndef TYPE_TCP_FLOW_COUNTER
98 #define TYPE_TCP_FLOW_COUNTER 14
99 #endif
100
101 #ifndef TYPE_DSM_COLOR_HDLC_POS
102 #define TYPE_DSM_COLOR_HDLC_POS 15
103 #endif
104
105 #ifndef TYPE_DSM_COLOR_ETH
106 #define TYPE_DSM_COLOR_ETH 16
107 #endif
108
109 #ifndef TYPE_COLOR_MC_HDLC_POS
110 #define TYPE_COLOR_MC_HDLC_POS 17
111 #endif
112
113 #ifndef TYPE_AAL2
114 #define TYPE_AAL2 18
115 #endif
116
117 #ifndef TYPE_COLOR_HASH_POS
118 #define TYPE_COLOR_HASH_POS 19
119 #endif
120
121 #ifndef TYPE_COLOR_HASH_ETH
122 #define TYPE_COLOR_HASH_ETH 20
123 #endif
124
125 #ifndef TYPE_INFINIBAND
126 #define TYPE_INFINIBAND 21
127 #endif
128
129 #ifndef TYPE_IPV4
130 #define TYPE_IPV4 22
131 #endif
132
133 #ifndef TYPE_IPV6
134 #define TYPE_IPV6 23
135 #endif
136
137 #ifndef TYPE_RAW_LINK
138 #define TYPE_RAW_LINK 24
139 #endif
140
141 #ifndef TYPE_INFINIBAND_LINK
142 #define TYPE_INFINIBAND_LINK 25
143 #endif
144
145 #ifndef TYPE_PAD
146 #define TYPE_PAD 48
147 #endif
148
149 #define ATM_CELL_SIZE 52
150 #define ATM_HDR_SIZE 4
151
152 /*
153 * A header containing additional MTP information.
154 */
155 #define MTP2_SENT_OFFSET 0 /* 1 byte */
156 #define MTP2_ANNEX_A_USED_OFFSET 1 /* 1 byte */
157 #define MTP2_LINK_NUMBER_OFFSET 2 /* 2 bytes */
158 #define MTP2_HDR_LEN 4 /* length of the header */
159
160 #define MTP2_ANNEX_A_NOT_USED 0
161 #define MTP2_ANNEX_A_USED 1
162 #define MTP2_ANNEX_A_USED_UNKNOWN 2
163
164 /* SunATM pseudo header */
165 struct sunatm_hdr {
166 unsigned char flags; /* destination and traffic type */
167 unsigned char vpi; /* VPI */
168 unsigned short vci; /* VCI */
169 };
170
171 /*
172 * Private data for capturing on DAG devices.
173 */
174 struct pcap_dag {
175 struct pcap_stat stat;
176 #ifdef HAVE_DAG_STREAMS_API
177 u_char *dag_mem_bottom; /* DAG card current memory bottom pointer */
178 u_char *dag_mem_top; /* DAG card current memory top pointer */
179 #else /* HAVE_DAG_STREAMS_API */
180 void *dag_mem_base; /* DAG card memory base address */
181 u_int dag_mem_bottom; /* DAG card current memory bottom offset */
182 u_int dag_mem_top; /* DAG card current memory top offset */
183 #endif /* HAVE_DAG_STREAMS_API */
184 int dag_fcs_bits; /* Number of checksum bits from link layer */
185 int dag_offset_flags; /* Flags to pass to dag_offset(). */
186 int dag_stream; /* DAG stream number */
187 int dag_timeout; /* timeout specified to pcap_open_live.
188 * Same as in linux above, introduce
189 * generally? */
190 };
191
192 typedef struct pcap_dag_node {
193 struct pcap_dag_node *next;
194 pcap_t *p;
195 pid_t pid;
196 } pcap_dag_node_t;
197
198 static pcap_dag_node_t *pcap_dags = NULL;
199 static int atexit_handler_installed = 0;
200 static const unsigned short endian_test_word = 0x0100;
201
202 #define IS_BIGENDIAN() (*((unsigned char *)&endian_test_word))
203
204 #define MAX_DAG_PACKET 65536
205
206 static unsigned char TempPkt[MAX_DAG_PACKET];
207
208 static int dag_setfilter(pcap_t *p, struct bpf_program *fp);
209 static int dag_stats(pcap_t *p, struct pcap_stat *ps);
210 static int dag_set_datalink(pcap_t *p, int dlt);
211 static int dag_get_datalink(pcap_t *p);
212 static int dag_setnonblock(pcap_t *p, int nonblock, char *errbuf);
213
214 static void
delete_pcap_dag(pcap_t * p)215 delete_pcap_dag(pcap_t *p)
216 {
217 pcap_dag_node_t *curr = NULL, *prev = NULL;
218
219 for (prev = NULL, curr = pcap_dags; curr != NULL && curr->p != p; prev = curr, curr = curr->next) {
220 /* empty */
221 }
222
223 if (curr != NULL && curr->p == p) {
224 if (prev != NULL) {
225 prev->next = curr->next;
226 } else {
227 pcap_dags = curr->next;
228 }
229 }
230 }
231
232 /*
233 * Performs a graceful shutdown of the DAG card, frees dynamic memory held
234 * in the pcap_t structure, and closes the file descriptor for the DAG card.
235 */
236
237 static void
dag_platform_cleanup(pcap_t * p)238 dag_platform_cleanup(pcap_t *p)
239 {
240 struct pcap_dag *pd = p->pr;
241
242 #ifdef HAVE_DAG_STREAMS_API
243 if(dag_stop_stream(p->fd, pd->dag_stream) < 0)
244 fprintf(stderr,"dag_stop_stream: %s\n", strerror(errno));
245
246 if(dag_detach_stream(p->fd, pd->dag_stream) < 0)
247 fprintf(stderr,"dag_detach_stream: %s\n", strerror(errno));
248 #else
249 if(dag_stop(p->fd) < 0)
250 fprintf(stderr,"dag_stop: %s\n", strerror(errno));
251 #endif /* HAVE_DAG_STREAMS_API */
252 if(p->fd != -1) {
253 if(dag_close(p->fd) < 0)
254 fprintf(stderr,"dag_close: %s\n", strerror(errno));
255 p->fd = -1;
256 }
257 delete_pcap_dag(p);
258 pcap_cleanup_live_common(p);
259 /* Note: don't need to call close(p->fd) here as dag_close(p->fd) does this. */
260 }
261
262 static void
atexit_handler(void)263 atexit_handler(void)
264 {
265 while (pcap_dags != NULL) {
266 if (pcap_dags->pid == getpid()) {
267 if (pcap_dags->p != NULL)
268 dag_platform_cleanup(pcap_dags->p);
269 } else {
270 delete_pcap_dag(pcap_dags->p);
271 }
272 }
273 }
274
275 static int
new_pcap_dag(pcap_t * p)276 new_pcap_dag(pcap_t *p)
277 {
278 pcap_dag_node_t *node = NULL;
279
280 if ((node = malloc(sizeof(pcap_dag_node_t))) == NULL) {
281 return -1;
282 }
283
284 if (!atexit_handler_installed) {
285 atexit(atexit_handler);
286 atexit_handler_installed = 1;
287 }
288
289 node->next = pcap_dags;
290 node->p = p;
291 node->pid = getpid();
292
293 pcap_dags = node;
294
295 return 0;
296 }
297
298 static unsigned int
dag_erf_ext_header_count(uint8_t * erf,size_t len)299 dag_erf_ext_header_count(uint8_t * erf, size_t len)
300 {
301 uint32_t hdr_num = 0;
302 uint8_t hdr_type;
303
304 /* basic sanity checks */
305 if ( erf == NULL )
306 return 0;
307 if ( len < 16 )
308 return 0;
309
310 /* check if we have any extension headers */
311 if ( (erf[8] & 0x80) == 0x00 )
312 return 0;
313
314 /* loop over the extension headers */
315 do {
316
317 /* sanity check we have enough bytes */
318 if ( len < (24 + (hdr_num * 8)) )
319 return hdr_num;
320
321 /* get the header type */
322 hdr_type = erf[(16 + (hdr_num * 8))];
323 hdr_num++;
324
325 } while ( hdr_type & 0x80 );
326
327 return hdr_num;
328 }
329
330 /*
331 * Read at most max_packets from the capture stream and call the callback
332 * for each of them. Returns the number of packets handled, -1 if an
333 * error occured, or -2 if we were told to break out of the loop.
334 */
335 static int
dag_read(pcap_t * p,int cnt,pcap_handler callback,u_char * user)336 dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
337 {
338 struct pcap_dag *pd = p->priv;
339 unsigned int processed = 0;
340 int flags = pd->dag_offset_flags;
341 unsigned int nonblocking = flags & DAGF_NONBLOCK;
342 unsigned int num_ext_hdr = 0;
343 unsigned int ticks_per_second;
344
345 /* Get the next bufferful of packets (if necessary). */
346 while (pd->dag_mem_top - pd->dag_mem_bottom < dag_record_size) {
347
348 /*
349 * Has "pcap_breakloop()" been called?
350 */
351 if (p->break_loop) {
352 /*
353 * Yes - clear the flag that indicates that
354 * it has, and return -2 to indicate that
355 * we were told to break out of the loop.
356 */
357 p->break_loop = 0;
358 return -2;
359 }
360
361 #ifdef HAVE_DAG_STREAMS_API
362 /* dag_advance_stream() will block (unless nonblock is called)
363 * until 64kB of data has accumulated.
364 * If to_ms is set, it will timeout before 64kB has accumulated.
365 * We wait for 64kB because processing a few packets at a time
366 * can cause problems at high packet rates (>200kpps) due
367 * to inefficiencies.
368 * This does mean if to_ms is not specified the capture may 'hang'
369 * for long periods if the data rate is extremely slow (<64kB/sec)
370 * If non-block is specified it will return immediately. The user
371 * is then responsible for efficiency.
372 */
373 if ( NULL == (pd->dag_mem_top = dag_advance_stream(p->fd, pd->dag_stream, &(pd->dag_mem_bottom))) ) {
374 return -1;
375 }
376 #else
377 /* dag_offset does not support timeouts */
378 pd->dag_mem_top = dag_offset(p->fd, &(pd->dag_mem_bottom), flags);
379 #endif /* HAVE_DAG_STREAMS_API */
380
381 if (nonblocking && (pd->dag_mem_top - pd->dag_mem_bottom < dag_record_size))
382 {
383 /* Pcap is configured to process only available packets, and there aren't any, return immediately. */
384 return 0;
385 }
386
387 if(!nonblocking &&
388 pd->dag_timeout &&
389 (pd->dag_mem_top - pd->dag_mem_bottom < dag_record_size))
390 {
391 /* Blocking mode, but timeout set and no data has arrived, return anyway.*/
392 return 0;
393 }
394
395 }
396
397 /* Process the packets. */
398 while (pd->dag_mem_top - pd->dag_mem_bottom >= dag_record_size) {
399
400 unsigned short packet_len = 0;
401 int caplen = 0;
402 struct pcap_pkthdr pcap_header;
403
404 #ifdef HAVE_DAG_STREAMS_API
405 dag_record_t *header = (dag_record_t *)(pd->dag_mem_bottom);
406 #else
407 dag_record_t *header = (dag_record_t *)(pd->dag_mem_base + pd->dag_mem_bottom);
408 #endif /* HAVE_DAG_STREAMS_API */
409
410 u_char *dp = ((u_char *)header); /* + dag_record_size; */
411 unsigned short rlen;
412
413 /*
414 * Has "pcap_breakloop()" been called?
415 */
416 if (p->break_loop) {
417 /*
418 * Yes - clear the flag that indicates that
419 * it has, and return -2 to indicate that
420 * we were told to break out of the loop.
421 */
422 p->break_loop = 0;
423 return -2;
424 }
425
426 rlen = ntohs(header->rlen);
427 if (rlen < dag_record_size)
428 {
429 strncpy(p->errbuf, "dag_read: record too small", PCAP_ERRBUF_SIZE);
430 return -1;
431 }
432 pd->dag_mem_bottom += rlen;
433
434 /* Count lost packets. */
435 switch((header->type & 0x7f)) {
436 /* in these types the color value overwrites the lctr */
437 case TYPE_COLOR_HDLC_POS:
438 case TYPE_COLOR_ETH:
439 case TYPE_DSM_COLOR_HDLC_POS:
440 case TYPE_DSM_COLOR_ETH:
441 case TYPE_COLOR_MC_HDLC_POS:
442 case TYPE_COLOR_HASH_ETH:
443 case TYPE_COLOR_HASH_POS:
444 break;
445
446 default:
447 if (header->lctr) {
448 if (pd->stat.ps_drop > (UINT_MAX - ntohs(header->lctr))) {
449 pd->stat.ps_drop = UINT_MAX;
450 } else {
451 pd->stat.ps_drop += ntohs(header->lctr);
452 }
453 }
454 }
455
456 if ((header->type & 0x7f) == TYPE_PAD) {
457 continue;
458 }
459
460 num_ext_hdr = dag_erf_ext_header_count(dp, rlen);
461
462 /* ERF encapsulation */
463 /* The Extensible Record Format is not dropped for this kind of encapsulation,
464 * and will be handled as a pseudo header by the decoding application.
465 * The information carried in the ERF header and in the optional subheader (if present)
466 * could be merged with the libpcap information, to offer a better decoding.
467 * The packet length is
468 * o the length of the packet on the link (header->wlen),
469 * o plus the length of the ERF header (dag_record_size), as the length of the
470 * pseudo header will be adjusted during the decoding,
471 * o plus the length of the optional subheader (if present).
472 *
473 * The capture length is header.rlen and the byte stuffing for alignment will be dropped
474 * if the capture length is greater than the packet length.
475 */
476 if (p->linktype == DLT_ERF) {
477 packet_len = ntohs(header->wlen) + dag_record_size;
478 caplen = rlen;
479 switch ((header->type & 0x7f)) {
480 case TYPE_MC_AAL5:
481 case TYPE_MC_ATM:
482 case TYPE_MC_HDLC:
483 case TYPE_MC_RAW_CHANNEL:
484 case TYPE_MC_RAW:
485 case TYPE_MC_AAL2:
486 case TYPE_COLOR_MC_HDLC_POS:
487 packet_len += 4; /* MC header */
488 break;
489
490 case TYPE_COLOR_HASH_ETH:
491 case TYPE_DSM_COLOR_ETH:
492 case TYPE_COLOR_ETH:
493 case TYPE_ETH:
494 packet_len += 2; /* ETH header */
495 break;
496 } /* switch type */
497
498 /* Include ERF extension headers */
499 packet_len += (8 * num_ext_hdr);
500
501 if (caplen > packet_len) {
502 caplen = packet_len;
503 }
504 } else {
505 /* Other kind of encapsulation according to the header Type */
506
507 /* Skip over generic ERF header */
508 dp += dag_record_size;
509 /* Skip over extension headers */
510 dp += 8 * num_ext_hdr;
511
512 switch((header->type & 0x7f)) {
513 case TYPE_ATM:
514 case TYPE_AAL5:
515 if (header->type == TYPE_AAL5) {
516 packet_len = ntohs(header->wlen);
517 caplen = rlen - dag_record_size;
518 }
519 case TYPE_MC_ATM:
520 if (header->type == TYPE_MC_ATM) {
521 caplen = packet_len = ATM_CELL_SIZE;
522 dp+=4;
523 }
524 case TYPE_MC_AAL5:
525 if (header->type == TYPE_MC_AAL5) {
526 packet_len = ntohs(header->wlen);
527 caplen = rlen - dag_record_size - 4;
528 dp+=4;
529 }
530 /* Skip over extension headers */
531 caplen -= (8 * num_ext_hdr);
532
533 if (header->type == TYPE_ATM) {
534 caplen = packet_len = ATM_CELL_SIZE;
535 }
536 if (p->linktype == DLT_SUNATM) {
537 struct sunatm_hdr *sunatm = (struct sunatm_hdr *)dp;
538 unsigned long rawatm;
539
540 rawatm = ntohl(*((unsigned long *)dp));
541 sunatm->vci = htons((rawatm >> 4) & 0xffff);
542 sunatm->vpi = (rawatm >> 20) & 0x00ff;
543 sunatm->flags = ((header->flags.iface & 1) ? 0x80 : 0x00) |
544 ((sunatm->vpi == 0 && sunatm->vci == htons(5)) ? 6 :
545 ((sunatm->vpi == 0 && sunatm->vci == htons(16)) ? 5 :
546 ((dp[ATM_HDR_SIZE] == 0xaa &&
547 dp[ATM_HDR_SIZE+1] == 0xaa &&
548 dp[ATM_HDR_SIZE+2] == 0x03) ? 2 : 1)));
549
550 } else {
551 packet_len -= ATM_HDR_SIZE;
552 caplen -= ATM_HDR_SIZE;
553 dp += ATM_HDR_SIZE;
554 }
555 break;
556
557 case TYPE_COLOR_HASH_ETH:
558 case TYPE_DSM_COLOR_ETH:
559 case TYPE_COLOR_ETH:
560 case TYPE_ETH:
561 packet_len = ntohs(header->wlen);
562 packet_len -= (pd->dag_fcs_bits >> 3);
563 caplen = rlen - dag_record_size - 2;
564 /* Skip over extension headers */
565 caplen -= (8 * num_ext_hdr);
566 if (caplen > packet_len) {
567 caplen = packet_len;
568 }
569 dp += 2;
570 break;
571
572 case TYPE_COLOR_HASH_POS:
573 case TYPE_DSM_COLOR_HDLC_POS:
574 case TYPE_COLOR_HDLC_POS:
575 case TYPE_HDLC_POS:
576 packet_len = ntohs(header->wlen);
577 packet_len -= (pd->dag_fcs_bits >> 3);
578 caplen = rlen - dag_record_size;
579 /* Skip over extension headers */
580 caplen -= (8 * num_ext_hdr);
581 if (caplen > packet_len) {
582 caplen = packet_len;
583 }
584 break;
585
586 case TYPE_COLOR_MC_HDLC_POS:
587 case TYPE_MC_HDLC:
588 packet_len = ntohs(header->wlen);
589 packet_len -= (pd->dag_fcs_bits >> 3);
590 caplen = rlen - dag_record_size - 4;
591 /* Skip over extension headers */
592 caplen -= (8 * num_ext_hdr);
593 if (caplen > packet_len) {
594 caplen = packet_len;
595 }
596 /* jump the MC_HDLC_HEADER */
597 dp += 4;
598 #ifdef DLT_MTP2_WITH_PHDR
599 if (p->linktype == DLT_MTP2_WITH_PHDR) {
600 /* Add the MTP2 Pseudo Header */
601 caplen += MTP2_HDR_LEN;
602 packet_len += MTP2_HDR_LEN;
603
604 TempPkt[MTP2_SENT_OFFSET] = 0;
605 TempPkt[MTP2_ANNEX_A_USED_OFFSET] = MTP2_ANNEX_A_USED_UNKNOWN;
606 *(TempPkt+MTP2_LINK_NUMBER_OFFSET) = ((header->rec.mc_hdlc.mc_header>>16)&0x01);
607 *(TempPkt+MTP2_LINK_NUMBER_OFFSET+1) = ((header->rec.mc_hdlc.mc_header>>24)&0xff);
608 memcpy(TempPkt+MTP2_HDR_LEN, dp, caplen);
609 dp = TempPkt;
610 }
611 #endif
612 break;
613
614 case TYPE_IPV4:
615 case TYPE_IPV6:
616 packet_len = ntohs(header->wlen);
617 caplen = rlen - dag_record_size;
618 /* Skip over extension headers */
619 caplen -= (8 * num_ext_hdr);
620 if (caplen > packet_len) {
621 caplen = packet_len;
622 }
623 break;
624
625 /* These types have no matching 'native' DLT, but can be used with DLT_ERF above */
626 case TYPE_MC_RAW:
627 case TYPE_MC_RAW_CHANNEL:
628 case TYPE_IP_COUNTER:
629 case TYPE_TCP_FLOW_COUNTER:
630 case TYPE_INFINIBAND:
631 case TYPE_RAW_LINK:
632 case TYPE_INFINIBAND_LINK:
633 default:
634 /* Unhandled ERF type.
635 * Ignore rather than generating error
636 */
637 continue;
638 } /* switch type */
639
640 } /* ERF encapsulation */
641
642 if (caplen > p->snapshot)
643 caplen = p->snapshot;
644
645 /* Run the packet filter if there is one. */
646 if ((p->fcode.bf_insns == NULL) || bpf_filter(p->fcode.bf_insns, dp, packet_len, caplen)) {
647
648 /* convert between timestamp formats */
649 register unsigned long long ts;
650
651 if (IS_BIGENDIAN()) {
652 ts = SWAPLL(header->ts);
653 } else {
654 ts = header->ts;
655 }
656
657 switch (p->opt.tstamp_precision) {
658 case PCAP_TSTAMP_PRECISION_NANO:
659 ticks_per_second = 1000000000;
660 break;
661 case PCAP_TSTAMP_PRECISION_MICRO:
662 default:
663 ticks_per_second = 1000000;
664 break;
665
666 }
667 pcap_header.ts.tv_sec = ts >> 32;
668 ts = (ts & 0xffffffffULL) * ticks_per_second;
669 ts += 0x80000000; /* rounding */
670 pcap_header.ts.tv_usec = ts >> 32;
671 if (pcap_header.ts.tv_usec >= ticks_per_second) {
672 pcap_header.ts.tv_usec -= ticks_per_second;
673 pcap_header.ts.tv_sec++;
674 }
675
676 /* Fill in our own header data */
677 pcap_header.caplen = caplen;
678 pcap_header.len = packet_len;
679
680 /* Count the packet. */
681 pd->stat.ps_recv++;
682
683 /* Call the user supplied callback function */
684 callback(user, &pcap_header, dp);
685
686 /* Only count packets that pass the filter, for consistency with standard Linux behaviour. */
687 processed++;
688 if (processed == cnt && !PACKET_COUNT_IS_UNLIMITED(cnt))
689 {
690 /* Reached the user-specified limit. */
691 return cnt;
692 }
693 }
694 }
695
696 return processed;
697 }
698
699 static int
dag_inject(pcap_t * p,const void * buf _U_,size_t size _U_)700 dag_inject(pcap_t *p, const void *buf _U_, size_t size _U_)
701 {
702 strlcpy(p->errbuf, "Sending packets isn't supported on DAG cards",
703 PCAP_ERRBUF_SIZE);
704 return (-1);
705 }
706
707 /*
708 * Get a handle for a live capture from the given DAG device. Passing a NULL
709 * device will result in a failure. The promisc flag is ignored because DAG
710 * cards are always promiscuous. The to_ms parameter is used in setting the
711 * API polling parameters.
712 *
713 * snaplen is now also ignored, until we get per-stream slen support. Set
714 * slen with approprite DAG tool BEFORE pcap_activate().
715 *
716 * See also pcap(3).
717 */
dag_activate(pcap_t * handle)718 static int dag_activate(pcap_t* handle)
719 {
720 struct pcap_dag *handlep = handle->priv;
721 #if 0
722 char conf[30]; /* dag configure string */
723 #endif
724 char *s;
725 int n;
726 daginf_t* daginf;
727 char * newDev = NULL;
728 char * device = handle->opt.device;
729 #ifdef HAVE_DAG_STREAMS_API
730 uint32_t mindata;
731 struct timeval maxwait;
732 struct timeval poll;
733 #endif
734
735 if (device == NULL) {
736 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "device is NULL: %s", pcap_strerror(errno));
737 return -1;
738 }
739
740 /* Initialize some components of the pcap structure. */
741
742 #ifdef HAVE_DAG_STREAMS_API
743 newDev = (char *)malloc(strlen(device) + 16);
744 if (newDev == NULL) {
745 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s", pcap_strerror(errno));
746 goto fail;
747 }
748
749 /* Parse input name to get dag device and stream number if provided */
750 if (dag_parse_name(device, newDev, strlen(device) + 16, &handlep->dag_stream) < 0) {
751 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_parse_name: %s", pcap_strerror(errno));
752 goto fail;
753 }
754 device = newDev;
755
756 if (handlep->dag_stream%2) {
757 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_parse_name: tx (even numbered) streams not supported for capture");
758 goto fail;
759 }
760 #else
761 if (strncmp(device, "/dev/", 5) != 0) {
762 newDev = (char *)malloc(strlen(device) + 5);
763 if (newDev == NULL) {
764 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't allocate string for device name: %s", pcap_strerror(errno));
765 goto fail;
766 }
767 strcpy(newDev, "/dev/");
768 strcat(newDev, device);
769 device = newDev;
770 }
771 #endif /* HAVE_DAG_STREAMS_API */
772
773 /* setup device parameters */
774 if((handle->fd = dag_open((char *)device)) < 0) {
775 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_open %s: %s", device, pcap_strerror(errno));
776 goto fail;
777 }
778
779 #ifdef HAVE_DAG_STREAMS_API
780 /* Open requested stream. Can fail if already locked or on error */
781 if (dag_attach_stream(handle->fd, handlep->dag_stream, 0, 0) < 0) {
782 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_attach_stream: %s", pcap_strerror(errno));
783 goto failclose;
784 }
785
786 /* Set up default poll parameters for stream
787 * Can be overridden by pcap_set_nonblock()
788 */
789 if (dag_get_stream_poll(handle->fd, handlep->dag_stream,
790 &mindata, &maxwait, &poll) < 0) {
791 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s", pcap_strerror(errno));
792 goto faildetach;
793 }
794
795 if (handle->opt.immediate) {
796 /* Call callback immediately.
797 * XXX - is this the right way to handle this?
798 */
799 mindata = 0;
800 } else {
801 /* Amount of data to collect in Bytes before calling callbacks.
802 * Important for efficiency, but can introduce latency
803 * at low packet rates if to_ms not set!
804 */
805 mindata = 65536;
806 }
807
808 /* Obey opt.timeout (was to_ms) if supplied. This is a good idea!
809 * Recommend 10-100ms. Calls will time out even if no data arrived.
810 */
811 maxwait.tv_sec = handle->opt.timeout/1000;
812 maxwait.tv_usec = (handle->opt.timeout%1000) * 1000;
813
814 if (dag_set_stream_poll(handle->fd, handlep->dag_stream,
815 mindata, &maxwait, &poll) < 0) {
816 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s", pcap_strerror(errno));
817 goto faildetach;
818 }
819
820 #else
821 if((handlep->dag_mem_base = dag_mmap(handle->fd)) == MAP_FAILED) {
822 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,"dag_mmap %s: %s", device, pcap_strerror(errno));
823 goto failclose;
824 }
825
826 #endif /* HAVE_DAG_STREAMS_API */
827
828 /* XXX Not calling dag_configure() to set slen; this is unsafe in
829 * multi-stream environments as the gpp config is global.
830 * Once the firmware provides 'per-stream slen' this can be supported
831 * again via the Config API without side-effects */
832 #if 0
833 /* set the card snap length to the specified snaplen parameter */
834 /* This is a really bad idea, as different cards have different
835 * valid slen ranges. Should fix in Config API. */
836 if (handle->snapshot == 0 || handle->snapshot > MAX_DAG_SNAPLEN) {
837 handle->snapshot = MAX_DAG_SNAPLEN;
838 } else if (snaplen < MIN_DAG_SNAPLEN) {
839 handle->snapshot = MIN_DAG_SNAPLEN;
840 }
841 /* snap len has to be a multiple of 4 */
842 pcap_snprintf(conf, 30, "varlen slen=%d", (snaplen + 3) & ~3);
843
844 if(dag_configure(handle->fd, conf) < 0) {
845 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,"dag_configure %s: %s", device, pcap_strerror(errno));
846 goto faildetach;
847 }
848 #endif
849
850 #ifdef HAVE_DAG_STREAMS_API
851 if(dag_start_stream(handle->fd, handlep->dag_stream) < 0) {
852 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_start_stream %s: %s", device, pcap_strerror(errno));
853 goto faildetach;
854 }
855 #else
856 if(dag_start(handle->fd) < 0) {
857 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "dag_start %s: %s", device, pcap_strerror(errno));
858 goto failclose;
859 }
860 #endif /* HAVE_DAG_STREAMS_API */
861
862 /*
863 * Important! You have to ensure bottom is properly
864 * initialized to zero on startup, it won't give you
865 * a compiler warning if you make this mistake!
866 */
867 handlep->dag_mem_bottom = 0;
868 handlep->dag_mem_top = 0;
869
870 /*
871 * Find out how many FCS bits we should strip.
872 * First, query the card to see if it strips the FCS.
873 */
874 daginf = dag_info(handle->fd);
875 if ((0x4200 == daginf->device_code) || (0x4230 == daginf->device_code)) {
876 /* DAG 4.2S and 4.23S already strip the FCS. Stripping the final word again truncates the packet. */
877 handlep->dag_fcs_bits = 0;
878
879 /* Note that no FCS will be supplied. */
880 handle->linktype_ext = LT_FCS_DATALINK_EXT(0);
881 } else {
882 /*
883 * Start out assuming it's 32 bits.
884 */
885 handlep->dag_fcs_bits = 32;
886
887 /* Allow an environment variable to override. */
888 if ((s = getenv("ERF_FCS_BITS")) != NULL) {
889 if ((n = atoi(s)) == 0 || n == 16 || n == 32) {
890 handlep->dag_fcs_bits = n;
891 } else {
892 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
893 "pcap_activate %s: bad ERF_FCS_BITS value (%d) in environment", device, n);
894 goto failstop;
895 }
896 }
897
898 /*
899 * Did the user request that they not be stripped?
900 */
901 if ((s = getenv("ERF_DONT_STRIP_FCS")) != NULL) {
902 /* Yes. Note the number of bytes that will be
903 supplied. */
904 handle->linktype_ext = LT_FCS_DATALINK_EXT(handlep->dag_fcs_bits/16);
905
906 /* And don't strip them. */
907 handlep->dag_fcs_bits = 0;
908 }
909 }
910
911 handlep->dag_timeout = handle->opt.timeout;
912
913 handle->linktype = -1;
914 if (dag_get_datalink(handle) < 0)
915 goto failstop;
916
917 handle->bufsize = 0;
918
919 if (new_pcap_dag(handle) < 0) {
920 pcap_snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "new_pcap_dag %s: %s", device, pcap_strerror(errno));
921 goto failstop;
922 }
923
924 /*
925 * "select()" and "poll()" don't work on DAG device descriptors.
926 */
927 handle->selectable_fd = -1;
928
929 if (newDev != NULL) {
930 free((char *)newDev);
931 }
932
933 handle->read_op = dag_read;
934 handle->inject_op = dag_inject;
935 handle->setfilter_op = dag_setfilter;
936 handle->setdirection_op = NULL; /* Not implemented.*/
937 handle->set_datalink_op = dag_set_datalink;
938 handle->getnonblock_op = pcap_getnonblock_fd;
939 handle->setnonblock_op = dag_setnonblock;
940 handle->stats_op = dag_stats;
941 handle->cleanup_op = dag_platform_cleanup;
942 handlep->stat.ps_drop = 0;
943 handlep->stat.ps_recv = 0;
944 handlep->stat.ps_ifdrop = 0;
945 return 0;
946
947 #ifdef HAVE_DAG_STREAMS_API
948 failstop:
949 if (dag_stop_stream(handle->fd, handlep->dag_stream) < 0) {
950 fprintf(stderr,"dag_stop_stream: %s\n", strerror(errno));
951 }
952
953 faildetach:
954 if (dag_detach_stream(handle->fd, handlep->dag_stream) < 0)
955 fprintf(stderr,"dag_detach_stream: %s\n", strerror(errno));
956 #else
957 failstop:
958 if (dag_stop(handle->fd) < 0)
959 fprintf(stderr,"dag_stop: %s\n", strerror(errno));
960 #endif /* HAVE_DAG_STREAMS_API */
961
962 failclose:
963 if (dag_close(handle->fd) < 0)
964 fprintf(stderr,"dag_close: %s\n", strerror(errno));
965 delete_pcap_dag(handle);
966
967 fail:
968 pcap_cleanup_live_common(handle);
969 if (newDev != NULL) {
970 free((char *)newDev);
971 }
972
973 return PCAP_ERROR;
974 }
975
dag_create(const char * device,char * ebuf,int * is_ours)976 pcap_t *dag_create(const char *device, char *ebuf, int *is_ours)
977 {
978 const char *cp;
979 char *cpend;
980 long devnum;
981 pcap_t *p;
982 #ifdef HAVE_DAG_STREAMS_API
983 long stream = 0;
984 #endif
985
986 /* Does this look like a DAG device? */
987 cp = strrchr(device, '/');
988 if (cp == NULL)
989 cp = device;
990 /* Does it begin with "dag"? */
991 if (strncmp(cp, "dag", 3) != 0) {
992 /* Nope, doesn't begin with "dag" */
993 *is_ours = 0;
994 return NULL;
995 }
996 /* Yes - is "dag" followed by a number from 0 to DAG_MAX_BOARDS-1 */
997 cp += 3;
998 devnum = strtol(cp, &cpend, 10);
999 #ifdef HAVE_DAG_STREAMS_API
1000 if (*cpend == ':') {
1001 /* Followed by a stream number. */
1002 stream = strtol(++cpend, &cpend, 10);
1003 }
1004 #endif
1005 if (cpend == cp || *cpend != '\0') {
1006 /* Not followed by a number. */
1007 *is_ours = 0;
1008 return NULL;
1009 }
1010 if (devnum < 0 || devnum >= DAG_MAX_BOARDS) {
1011 /* Followed by a non-valid number. */
1012 *is_ours = 0;
1013 return NULL;
1014 }
1015 #ifdef HAVE_DAG_STREAMS_API
1016 if (stream <0 || stream >= DAG_STREAM_MAX) {
1017 /* Followed by a non-valid stream number. */
1018 *is_ours = 0;
1019 return NULL;
1020 }
1021 #endif
1022
1023 /* OK, it's probably ours. */
1024 *is_ours = 1;
1025
1026 p = pcap_create_common(ebuf, sizeof (struct pcap_dag));
1027 if (p == NULL)
1028 return NULL;
1029
1030 p->activate_op = dag_activate;
1031
1032 /*
1033 * We claim that we support microsecond and nanosecond time
1034 * stamps.
1035 *
1036 * XXX Our native precision is 2^-32s, but libpcap doesn't support
1037 * power of two precisions yet. We can convert to either MICRO or NANO.
1038 */
1039 p->tstamp_precision_count = 2;
1040 p->tstamp_precision_list = malloc(2 * sizeof(u_int));
1041 if (p->tstamp_precision_list == NULL) {
1042 pcap_snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
1043 pcap_strerror(errno));
1044 pcap_close(p);
1045 return NULL;
1046 }
1047 p->tstamp_precision_list[0] = PCAP_TSTAMP_PRECISION_MICRO;
1048 p->tstamp_precision_list[1] = PCAP_TSTAMP_PRECISION_NANO;
1049 return p;
1050 }
1051
1052 static int
dag_stats(pcap_t * p,struct pcap_stat * ps)1053 dag_stats(pcap_t *p, struct pcap_stat *ps) {
1054 struct pcap_dag *pd = p->priv;
1055
1056 /* This needs to be filled out correctly. Hopefully a dagapi call will
1057 provide all necessary information.
1058 */
1059 /*pd->stat.ps_recv = 0;*/
1060 /*pd->stat.ps_drop = 0;*/
1061
1062 *ps = pd->stat;
1063
1064 return 0;
1065 }
1066
1067 /*
1068 * Previously we just generated a list of all possible names and let
1069 * pcap_add_if() attempt to open each one, but with streams this adds up
1070 * to 81 possibilities which is inefficient.
1071 *
1072 * Since we know more about the devices we can prune the tree here.
1073 * pcap_add_if() will still retest each device but the total number of
1074 * open attempts will still be much less than the naive approach.
1075 */
1076 int
dag_findalldevs(pcap_if_t ** devlistp,char * errbuf)1077 dag_findalldevs(pcap_if_t **devlistp, char *errbuf)
1078 {
1079 char name[12]; /* XXX - pick a size */
1080 int ret = 0;
1081 int c;
1082 char dagname[DAGNAME_BUFSIZE];
1083 int dagstream;
1084 int dagfd;
1085 dag_card_inf_t *inf;
1086 char *description;
1087
1088 /* Try all the DAGs 0-DAG_MAX_BOARDS */
1089 for (c = 0; c < DAG_MAX_BOARDS; c++) {
1090 pcap_snprintf(name, 12, "dag%d", c);
1091 if (-1 == dag_parse_name(name, dagname, DAGNAME_BUFSIZE, &dagstream))
1092 {
1093 return -1;
1094 }
1095 description = NULL;
1096 if ( (dagfd = dag_open(dagname)) >= 0 ) {
1097 if ((inf = dag_pciinfo(dagfd)))
1098 description = dag_device_name(inf->device_code, 1);
1099 if (pcap_add_if(devlistp, name, 0, description, errbuf) == -1) {
1100 /*
1101 * Failure.
1102 */
1103 ret = -1;
1104 }
1105 #ifdef HAVE_DAG_STREAMS_API
1106 {
1107 int stream, rxstreams;
1108 rxstreams = dag_rx_get_stream_count(dagfd);
1109 for(stream=0;stream<DAG_STREAM_MAX;stream+=2) {
1110 if (0 == dag_attach_stream(dagfd, stream, 0, 0)) {
1111 dag_detach_stream(dagfd, stream);
1112
1113 pcap_snprintf(name, 10, "dag%d:%d", c, stream);
1114 if (pcap_add_if(devlistp, name, 0, description, errbuf) == -1) {
1115 /*
1116 * Failure.
1117 */
1118 ret = -1;
1119 }
1120
1121 rxstreams--;
1122 if(rxstreams <= 0) {
1123 break;
1124 }
1125 }
1126 }
1127 }
1128 #endif /* HAVE_DAG_STREAMS_API */
1129 dag_close(dagfd);
1130 }
1131
1132 }
1133 return (ret);
1134 }
1135
1136 /*
1137 * Installs the given bpf filter program in the given pcap structure. There is
1138 * no attempt to store the filter in kernel memory as that is not supported
1139 * with DAG cards.
1140 */
1141 static int
dag_setfilter(pcap_t * p,struct bpf_program * fp)1142 dag_setfilter(pcap_t *p, struct bpf_program *fp)
1143 {
1144 if (!p)
1145 return -1;
1146 if (!fp) {
1147 strncpy(p->errbuf, "setfilter: No filter specified",
1148 sizeof(p->errbuf));
1149 return -1;
1150 }
1151
1152 /* Make our private copy of the filter */
1153
1154 if (install_bpf_program(p, fp) < 0)
1155 return -1;
1156
1157 return (0);
1158 }
1159
1160 static int
dag_set_datalink(pcap_t * p,int dlt)1161 dag_set_datalink(pcap_t *p, int dlt)
1162 {
1163 p->linktype = dlt;
1164
1165 return (0);
1166 }
1167
1168 static int
dag_setnonblock(pcap_t * p,int nonblock,char * errbuf)1169 dag_setnonblock(pcap_t *p, int nonblock, char *errbuf)
1170 {
1171 struct pcap_dag *pd = p->priv;
1172
1173 /*
1174 * Set non-blocking mode on the FD.
1175 * XXX - is that necessary? If not, don't bother calling it,
1176 * and have a "dag_getnonblock()" function that looks at
1177 * "pd->dag_offset_flags".
1178 */
1179 if (pcap_setnonblock_fd(p, nonblock, errbuf) < 0)
1180 return (-1);
1181 #ifdef HAVE_DAG_STREAMS_API
1182 {
1183 uint32_t mindata;
1184 struct timeval maxwait;
1185 struct timeval poll;
1186
1187 if (dag_get_stream_poll(p->fd, pd->dag_stream,
1188 &mindata, &maxwait, &poll) < 0) {
1189 pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_get_stream_poll: %s", pcap_strerror(errno));
1190 return -1;
1191 }
1192
1193 /* Amount of data to collect in Bytes before calling callbacks.
1194 * Important for efficiency, but can introduce latency
1195 * at low packet rates if to_ms not set!
1196 */
1197 if(nonblock)
1198 mindata = 0;
1199 else
1200 mindata = 65536;
1201
1202 if (dag_set_stream_poll(p->fd, pd->dag_stream,
1203 mindata, &maxwait, &poll) < 0) {
1204 pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "dag_set_stream_poll: %s", pcap_strerror(errno));
1205 return -1;
1206 }
1207 }
1208 #endif /* HAVE_DAG_STREAMS_API */
1209 if (nonblock) {
1210 pd->dag_offset_flags |= DAGF_NONBLOCK;
1211 } else {
1212 pd->dag_offset_flags &= ~DAGF_NONBLOCK;
1213 }
1214 return (0);
1215 }
1216
1217 static int
dag_get_datalink(pcap_t * p)1218 dag_get_datalink(pcap_t *p)
1219 {
1220 struct pcap_dag *pd = p->priv;
1221 int index=0, dlt_index=0;
1222 uint8_t types[255];
1223
1224 memset(types, 0, 255);
1225
1226 if (p->dlt_list == NULL && (p->dlt_list = malloc(255*sizeof(*(p->dlt_list)))) == NULL) {
1227 (void)pcap_snprintf(p->errbuf, sizeof(p->errbuf), "malloc: %s", pcap_strerror(errno));
1228 return (-1);
1229 }
1230
1231 p->linktype = 0;
1232
1233 #ifdef HAVE_DAG_GET_STREAM_ERF_TYPES
1234 /* Get list of possible ERF types for this card */
1235 if (dag_get_stream_erf_types(p->fd, pd->dag_stream, types, 255) < 0) {
1236 pcap_snprintf(p->errbuf, sizeof(p->errbuf), "dag_get_stream_erf_types: %s", pcap_strerror(errno));
1237 return (-1);
1238 }
1239
1240 while (types[index]) {
1241
1242 #elif defined HAVE_DAG_GET_ERF_TYPES
1243 /* Get list of possible ERF types for this card */
1244 if (dag_get_erf_types(p->fd, types, 255) < 0) {
1245 pcap_snprintf(p->errbuf, sizeof(p->errbuf), "dag_get_erf_types: %s", pcap_strerror(errno));
1246 return (-1);
1247 }
1248
1249 while (types[index]) {
1250 #else
1251 /* Check the type through a dagapi call. */
1252 types[index] = dag_linktype(p->fd);
1253
1254 {
1255 #endif
1256 switch((types[index] & 0x7f)) {
1257
1258 case TYPE_HDLC_POS:
1259 case TYPE_COLOR_HDLC_POS:
1260 case TYPE_DSM_COLOR_HDLC_POS:
1261 case TYPE_COLOR_HASH_POS:
1262
1263 if (p->dlt_list != NULL) {
1264 p->dlt_list[dlt_index++] = DLT_CHDLC;
1265 p->dlt_list[dlt_index++] = DLT_PPP_SERIAL;
1266 p->dlt_list[dlt_index++] = DLT_FRELAY;
1267 }
1268 if(!p->linktype)
1269 p->linktype = DLT_CHDLC;
1270 break;
1271
1272 case TYPE_ETH:
1273 case TYPE_COLOR_ETH:
1274 case TYPE_DSM_COLOR_ETH:
1275 case TYPE_COLOR_HASH_ETH:
1276 /*
1277 * This is (presumably) a real Ethernet capture; give it a
1278 * link-layer-type list with DLT_EN10MB and DLT_DOCSIS, so
1279 * that an application can let you choose it, in case you're
1280 * capturing DOCSIS traffic that a Cisco Cable Modem
1281 * Termination System is putting out onto an Ethernet (it
1282 * doesn't put an Ethernet header onto the wire, it puts raw
1283 * DOCSIS frames out on the wire inside the low-level
1284 * Ethernet framing).
1285 */
1286 if (p->dlt_list != NULL) {
1287 p->dlt_list[dlt_index++] = DLT_EN10MB;
1288 p->dlt_list[dlt_index++] = DLT_DOCSIS;
1289 }
1290 if(!p->linktype)
1291 p->linktype = DLT_EN10MB;
1292 break;
1293
1294 case TYPE_ATM:
1295 case TYPE_AAL5:
1296 case TYPE_MC_ATM:
1297 case TYPE_MC_AAL5:
1298 if (p->dlt_list != NULL) {
1299 p->dlt_list[dlt_index++] = DLT_ATM_RFC1483;
1300 p->dlt_list[dlt_index++] = DLT_SUNATM;
1301 }
1302 if(!p->linktype)
1303 p->linktype = DLT_ATM_RFC1483;
1304 break;
1305
1306 case TYPE_COLOR_MC_HDLC_POS:
1307 case TYPE_MC_HDLC:
1308 if (p->dlt_list != NULL) {
1309 p->dlt_list[dlt_index++] = DLT_CHDLC;
1310 p->dlt_list[dlt_index++] = DLT_PPP_SERIAL;
1311 p->dlt_list[dlt_index++] = DLT_FRELAY;
1312 p->dlt_list[dlt_index++] = DLT_MTP2;
1313 p->dlt_list[dlt_index++] = DLT_MTP2_WITH_PHDR;
1314 p->dlt_list[dlt_index++] = DLT_LAPD;
1315 }
1316 if(!p->linktype)
1317 p->linktype = DLT_CHDLC;
1318 break;
1319
1320 case TYPE_IPV4:
1321 case TYPE_IPV6:
1322 if(!p->linktype)
1323 p->linktype = DLT_RAW;
1324 break;
1325
1326 case TYPE_LEGACY:
1327 case TYPE_MC_RAW:
1328 case TYPE_MC_RAW_CHANNEL:
1329 case TYPE_IP_COUNTER:
1330 case TYPE_TCP_FLOW_COUNTER:
1331 case TYPE_INFINIBAND:
1332 case TYPE_RAW_LINK:
1333 case TYPE_INFINIBAND_LINK:
1334 default:
1335 /* Libpcap cannot deal with these types yet */
1336 /* Add no 'native' DLTs, but still covered by DLT_ERF */
1337 break;
1338
1339 } /* switch */
1340 index++;
1341 }
1342
1343 p->dlt_list[dlt_index++] = DLT_ERF;
1344
1345 p->dlt_count = dlt_index;
1346
1347 if(!p->linktype)
1348 p->linktype = DLT_ERF;
1349
1350 return p->linktype;
1351 }
1352
1353 #ifdef DAG_ONLY
1354 /*
1355 * This libpcap build supports only DAG cards, not regular network
1356 * interfaces.
1357 */
1358
1359 /*
1360 * There are no regular interfaces, just DAG interfaces.
1361 */
1362 int
1363 pcap_platform_finddevs(pcap_if_t **alldevsp, char *errbuf)
1364 {
1365 *alldevsp = NULL;
1366 return (0);
1367 }
1368
1369 /*
1370 * Attempts to open a regular interface fail.
1371 */
1372 pcap_t *
1373 pcap_create_interface(const char *device, char *errbuf)
1374 {
1375 pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE,
1376 "This version of libpcap only supports DAG cards");
1377 return NULL;
1378 }
1379 #endif
1380