The Tcpdump Group git mirrors - libpcap/blob - pcap-dag.c

   1 /*
   2  * pcap-dag.c: Packet capture interface for Endace DAG card.
   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, Koryn Grant <support@endace.com>
  14  */
  15
  16 #ifndef lint
  17 static const char rcsid[] _U_ =
  18         "@(#) $Header: /tcpdump/master/libpcap/pcap-dag.c,v 1.17 2004-01-30 02:23:53 guy Exp $ (LBL)";
  19 #endif
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <sys/param.h>                  /* optionally get BSD define */
  26
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <errno.h>
  30
  31 #include "pcap-int.h"
  32
  33 #include <ctype.h>
  34 #include <netinet/in.h>
  35 #include <sys/mman.h>
  36 #include <sys/socket.h>
  37 #include <sys/types.h>
  38 #include <unistd.h>
  39
  40 struct mbuf;            /* Squelch compiler warnings on some platforms for */
  41 struct rtentry;         /* declarations in <net/if.h> */
  42 #include <net/if.h>
  43
  44 #include <dagnew.h>
  45 #include <dagapi.h>
  46
  47 #define MIN_DAG_SNAPLEN         12
  48 #define MAX_DAG_SNAPLEN         2040
  49 #define ATM_CELL_SIZE           52
  50 #define ATM_HDR_SIZE            4
  51
  52 /* SunATM pseudo header */
  53 struct sunatm_hdr {
  54         unsigned char   flags;          /* destination and traffic type */
  55         unsigned char   vpi;            /* VPI */
  56         unsigned short  vci;            /* VCI */
  57 };
  58
  59 typedef struct pcap_dag_node {
  60         struct pcap_dag_node *next;
  61         pcap_t *p;
  62         pid_t pid;
  63 } pcap_dag_node_t;
  64
  65 static pcap_dag_node_t *pcap_dags = NULL;
  66 static int atexit_handler_installed = 0;
  67 static const unsigned short endian_test_word = 0x0100;
  68
  69 #define IS_BIGENDIAN() (*((unsigned char *)&endian_test_word))
  70
  71 /*
  72  * Swap byte ordering of unsigned long long timestamp on a big endian
  73  * machine.
  74  */
  75 #define SWAP_TS(ull)  ((ull & 0xff00000000000000LL) >> 56) | \
  76                       ((ull & 0x00ff000000000000LL) >> 40) | \
  77                       ((ull & 0x0000ff0000000000LL) >> 24) | \
  78                       ((ull & 0x000000ff00000000LL) >> 8)  | \
  79                       ((ull & 0x00000000ff000000LL) << 8)  | \
  80                       ((ull & 0x0000000000ff0000LL) << 24) | \
  81                       ((ull & 0x000000000000ff00LL) << 40) | \
  82                       ((ull & 0x00000000000000ffLL) << 56)
  83
  84
  85 #ifdef DAG_ONLY
  86 /* This code is required when compiling for a DAG device only. */
  87 #include "pcap-dag.h"
  88
  89 /* Replace dag function names with pcap equivalent. */
  90 #define dag_open_live pcap_open_live
  91 #define dag_platform_finddevs pcap_platform_finddevs
  92 #endif /* DAG_ONLY */
  93
  94 static int dag_setfilter(pcap_t *p, struct bpf_program *fp);
  95 static int dag_stats(pcap_t *p, struct pcap_stat *ps);
  96 static int dag_set_datalink(pcap_t *p, int dlt);
  97 static int dag_get_datalink(pcap_t *p);
  98 static int dag_setnonblock(pcap_t *p, int nonblock, char *errbuf);
  99
 100 static void
 101 delete_pcap_dag(pcap_t *p)
 102 {
 103         pcap_dag_node_t *curr = NULL, *prev = NULL;
 104
 105         for (prev = NULL, curr = pcap_dags; curr != NULL && curr->p != p; prev = curr, curr = curr->next) {
 106                 /* empty */
 107         }
 108
 109         if (curr != NULL && curr->p == p) {
 110                 if (prev != NULL) {
 111                         prev->next = curr->next;
 112                 } else {
 113                         pcap_dags = curr->next;
 114                 }
 115         }
 116 }
 117
 118 /*
 119  * Performs a graceful shutdown of the DAG card, frees dynamic memory held
 120  * in the pcap_t structure, and closes the file descriptor for the DAG card.
 121  */
 122
 123 static void
 124 dag_platform_close(pcap_t *p)
 125 {
 126
 127 #ifdef linux
 128         if (p != NULL && p->md.device != NULL) {
 129                 if(dag_stop(p->fd) < 0)
 130                         fprintf(stderr,"dag_stop %s: %s\n", p->md.device, strerror(errno));
 131                 if(dag_close(p->fd) < 0)
 132                         fprintf(stderr,"dag_close %s: %s\n", p->md.device, strerror(errno));
 133
 134                 free(p->md.device);
 135         }
 136 #else
 137         if (p != NULL) {
 138                 if(dag_stop(p->fd) < 0)
 139                         fprintf(stderr,"dag_stop: %s\n", strerror(errno));
 140                 if(dag_close(p->fd) < 0)
 141                         fprintf(stderr,"dag_close: %s\n", strerror(errno));
 142         }
 143 #endif
 144         delete_pcap_dag(p);
 145         /* Note: don't need to call close(p->fd) here as dag_close(p->fd) does this. */
 146 }
 147
 148 static void
 149 atexit_handler(void)
 150 {
 151         while (pcap_dags != NULL) {
 152                 if (pcap_dags->pid == getpid()) {
 153                         dag_platform_close(pcap_dags->p);
 154                 } else {
 155                         delete_pcap_dag(pcap_dags->p);
 156                 }
 157         }
 158 }
 159
 160 static int
 161 new_pcap_dag(pcap_t *p)
 162 {
 163         pcap_dag_node_t *node = NULL;
 164
 165         if ((node = malloc(sizeof(pcap_dag_node_t))) == NULL) {
 166                 return -1;
 167         }
 168
 169         if (!atexit_handler_installed) {
 170                 atexit(atexit_handler);
 171                 atexit_handler_installed = 1;
 172         }
 173
 174         node->next = pcap_dags;
 175         node->p = p;
 176         node->pid = getpid();
 177
 178         pcap_dags = node;
 179
 180         return 0;
 181 }
 182
 183 /*
 184  *  Read at most max_packets from the capture stream and call the callback
 185  *  for each of them. Returns the number of packets handled, -1 if an
 186  *  error occured, or -2 if we were told to break out of the loop.
 187  */
 188 static int
 189 dag_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 190 {
 191         unsigned int processed = 0;
 192         int flags = p->md.dag_offset_flags;
 193         unsigned int nonblocking = flags & DAGF_NONBLOCK;
 194
 195         for (;;)
 196         {
 197                 /* Get the next bufferful of packets (if necessary). */
 198                 while (p->md.dag_mem_top - p->md.dag_mem_bottom < dag_record_size) {
 199
 200                         /*
 201                          * Has "pcap_breakloop()" been called?
 202                          */
 203                         if (p->break_loop) {
 204                                 /*
 205                                  * Yes - clear the flag that indicates that
 206                                  * it has, and return -2 to indicate that
 207                                  * we were told to break out of the loop.
 208                                  */
 209                                 p->break_loop = 0;
 210                                 return -2;
 211                         }
 212
 213                         p->md.dag_mem_top = dag_offset(p->fd, &(p->md.dag_mem_bottom), flags);
 214                         if (nonblocking && (p->md.dag_mem_top - p->md.dag_mem_bottom < dag_record_size))
 215                         {
 216                                 /* Pcap is configured to process only available packets, and there aren't any. */
 217                                 return 0;
 218                         }
 219                 }
 220
 221                 /* Process the packets. */
 222                 while (p->md.dag_mem_top - p->md.dag_mem_bottom >= dag_record_size) {
 223
 224                         unsigned short packet_len = 0;
 225                         int caplen = 0;
 226                         struct pcap_pkthdr      pcap_header;
 227
 228                         dag_record_t *header = (dag_record_t *)(p->md.dag_mem_base + p->md.dag_mem_bottom);
 229                         u_char *dp = ((u_char *)header) + dag_record_size;
 230                         unsigned short rlen;
 231
 232                         /*
 233                          * Has "pcap_breakloop()" been called?
 234                          */
 235                         if (p->break_loop) {
 236                                 /*
 237                                  * Yes - clear the flag that indicates that
 238                                  * it has, and return -2 to indicate that
 239                                  * we were told to break out of the loop.
 240                                  */
 241                                 p->break_loop = 0;
 242                                 return -2;
 243                         }
 244
 245                         if (IS_BIGENDIAN()) {
 246                                 rlen = header->rlen;
 247                         } else {
 248                                 rlen = ntohs(header->rlen);
 249                         }
 250                         p->md.dag_mem_bottom += rlen;
 251
 252                         switch(header->type) {
 253                         case TYPE_AAL5:
 254                         case TYPE_ATM:
 255                                 if (header->type == TYPE_AAL5) {
 256                                         if (IS_BIGENDIAN()) {
 257                                                 packet_len = header->wlen;
 258                                         } else {
 259                                                 packet_len = ntohs(header->wlen);
 260                                         }
 261                                         caplen = rlen - dag_record_size;
 262                                 } else {
 263                                         caplen = packet_len = ATM_CELL_SIZE;
 264                                 }
 265                                 if (p->linktype == DLT_SUNATM) {
 266                                         struct sunatm_hdr *sunatm = (struct sunatm_hdr *)dp;
 267                                         unsigned long rawatm;
 268                                         if (IS_BIGENDIAN()) {
 269                                                 rawatm = *((unsigned long *)dp);
 270                                                 sunatm->vci = (rawatm >>  4) & 0xffff;
 271                                         } else {
 272                                                 rawatm = ntohl(*((unsigned long *)dp));
 273                                                 sunatm->vci = htons((rawatm >>  4) & 0xffff);
 274                                         }
 275                                         sunatm->vpi = (rawatm >> 20) & 0x00ff;
 276                                         sunatm->flags = ((header->flags.iface & 1) ? 0x80 : 0x00) |
 277                                                 ((sunatm->vpi == 0 && sunatm->vci == htons(5)) ? 6 :
 278                                                 ((sunatm->vpi == 0 && sunatm->vci == htons(16)) ? 5 :
 279                                                 ((dp[ATM_HDR_SIZE] == 0xaa &&
 280                                                         dp[ATM_HDR_SIZE+1] == 0xaa &&
 281                                                         dp[ATM_HDR_SIZE+2] == 0x03) ? 2 : 1)));
 282
 283                                 } else {
 284                                         packet_len -= ATM_HDR_SIZE;
 285                                         caplen -= ATM_HDR_SIZE;
 286                                         dp += ATM_HDR_SIZE;
 287                                 }
 288                                 break;
 289
 290                         case TYPE_ETH:
 291                                 if (IS_BIGENDIAN()) {
 292                                         packet_len = header->wlen;
 293                                 } else {
 294                                         packet_len = ntohs(header->wlen);
 295                                 }
 296                                 packet_len -= (p->md.dag_fcs_bits >> 3);
 297                                 caplen = rlen - dag_record_size - 2;
 298                                 if (caplen > packet_len) {
 299                                         caplen = packet_len;
 300                                 }
 301                                 dp += 2;
 302                                 break;
 303
 304                         case TYPE_HDLC_POS:
 305                                 if (IS_BIGENDIAN()) {
 306                                         packet_len = header->wlen;
 307                                 } else {
 308                                         packet_len = ntohs(header->wlen);
 309                                 }
 310                                 packet_len -= (p->md.dag_fcs_bits >> 3);
 311                                 caplen = rlen - dag_record_size;
 312                                 if (caplen > packet_len) {
 313                                         caplen = packet_len;
 314                                 }
 315                                 break;
 316                         }
 317
 318                         if (caplen > p->snapshot)
 319                                 caplen = p->snapshot;
 320
 321                         /* Count lost packets. */
 322                         if (header->lctr) {
 323                                 if (p->md.stat.ps_drop > (UINT_MAX - ntohs(header->lctr))) {
 324                                         p->md.stat.ps_drop = UINT_MAX;
 325                                 } else {
 326                                         p->md.stat.ps_drop += ntohs(header->lctr);
 327                                 }
 328                         }
 329
 330                         /* Run the packet filter if there is one. */
 331                         if ((p->fcode.bf_insns == NULL) || bpf_filter(p->fcode.bf_insns, dp, packet_len, caplen)) {
 332
 333                                 /* convert between timestamp formats */
 334                                 register unsigned long long ts;
 335
 336                                 if (IS_BIGENDIAN()) {
 337                                         ts = SWAP_TS(header->ts);
 338                                 } else {
 339                                         ts = header->ts;
 340                                 }
 341
 342                                 pcap_header.ts.tv_sec = ts >> 32;
 343                                 ts = (ts & 0xffffffffULL) * 1000000;
 344                                 ts += 0x80000000; /* rounding */
 345                                 pcap_header.ts.tv_usec = ts >> 32;
 346                                 if (pcap_header.ts.tv_usec >= 1000000) {
 347                                         pcap_header.ts.tv_usec -= 1000000;
 348                                         pcap_header.ts.tv_sec++;
 349                                 }
 350
 351                                 /* Fill in our own header data */
 352                                 pcap_header.caplen = caplen;
 353                                 pcap_header.len = packet_len;
 354
 355                                 /* Count the packet. */
 356                                 p->md.stat.ps_recv++;
 357
 358                                 /* Call the user supplied callback function */
 359                                 callback(user, &pcap_header, dp);
 360
 361                                 /* Only count packets that pass the filter, for consistency with standard Linux behaviour. */
 362                                 processed++;
 363                                 if (processed == cnt)
 364                                 {
 365                                         /* Reached the user-specified limit. */
 366                                         return cnt;
 367                                 }
 368                         }
 369                 }
 370
 371                 if (nonblocking || processed)
 372                 {
 373                         return processed;
 374                 }
 375         }
 376
 377         return processed;
 378 }
 379
 380 /*
 381  *  Get a handle for a live capture from the given DAG device.  Passing a NULL
 382  *  device will result in a failure.  The promisc flag is ignored because DAG
 383  *  cards are always promiscuous.  The to_ms parameter is also ignored as it is
 384  *  not supported in hardware.
 385  *
 386  *  See also pcap(3).
 387  */
 388 pcap_t *
 389 dag_open_live(const char *device, int snaplen, int promisc, int to_ms, char *ebuf)
 390 {
 391         char conf[30]; /* dag configure string */
 392         pcap_t *handle;
 393         char *s;
 394         int n;
 395
 396         if (device == NULL) {
 397                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "device is NULL: %s", pcap_strerror(errno));
 398                 return NULL;
 399         }
 400         /* Allocate a handle for this session. */
 401
 402         handle = malloc(sizeof(*handle));
 403         if (handle == NULL) {
 404                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc %s: %s", device, pcap_strerror(errno));
 405                 return NULL;
 406         }
 407
 408         /* Initialize some components of the pcap structure. */
 409
 410         memset(handle, 0, sizeof(*handle));
 411
 412         if (strstr(device, "/dev") == NULL) {
 413                 char * newDev = (char *)malloc(strlen(device) + 6);
 414                 newDev[0] = '\0';
 415                 strcat(newDev, "/dev/");
 416                 strcat(newDev,device);
 417                 device = newDev;
 418         } else {
 419                 device = strdup(device);
 420         }
 421
 422         if (device == NULL) {
 423                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "str_dup: %s\n", pcap_strerror(errno));
 424                 goto fail;
 425         }
 426
 427         /* setup device parameters */
 428         if((handle->fd = dag_open((char *)device)) < 0) {
 429                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "dag_open %s: %s", device, pcap_strerror(errno));
 430                 goto fail;
 431         }
 432
 433         /* set the card snap length to the specified snaplen parameter */
 434         if (snaplen == 0 || snaplen > MAX_DAG_SNAPLEN) {
 435                 snaplen = MAX_DAG_SNAPLEN;
 436         } else if (snaplen < MIN_DAG_SNAPLEN) {
 437                 snaplen = MIN_DAG_SNAPLEN;
 438         }
 439         /* snap len has to be a multiple of 4 */
 440         snprintf(conf, 30, "varlen slen=%d", (snaplen + 3) & ~3);
 441
 442         if(dag_configure(handle->fd, conf) < 0) {
 443                 snprintf(ebuf, PCAP_ERRBUF_SIZE,"dag_configure %s: %s\n", device, pcap_strerror(errno));
 444                 goto fail;
 445         }
 446
 447         if((handle->md.dag_mem_base = dag_mmap(handle->fd)) == MAP_FAILED) {
 448                 snprintf(ebuf, PCAP_ERRBUF_SIZE,"dag_mmap %s: %s\n", device, pcap_strerror(errno));
 449                 goto fail;
 450         }
 451
 452         if(dag_start(handle->fd) < 0) {
 453                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "dag_start %s: %s\n", device, pcap_strerror(errno));
 454                 goto fail;
 455         }
 456
 457         /*
 458          * Important! You have to ensure bottom is properly
 459          * initialized to zero on startup, it won't give you
 460          * a compiler warning if you make this mistake!
 461          */
 462         handle->md.dag_mem_bottom = 0;
 463         handle->md.dag_mem_top = 0;
 464
 465         /* TODO: query the card */
 466         handle->md.dag_fcs_bits = 32;
 467         if ((s = getenv("ERF_FCS_BITS")) != NULL) {
 468                 if ((n = atoi(s)) == 0 || n == 16|| n == 32) {
 469                         handle->md.dag_fcs_bits = n;
 470                 } else {
 471                         snprintf(ebuf, PCAP_ERRBUF_SIZE,
 472                                 "pcap_open_live %s: bad ERF_FCS_BITS value (%d) in environment\n", device, n);
 473                         goto fail;
 474                 }
 475         }
 476
 477         handle->snapshot        = snaplen;
 478         /*handle->md.timeout    = to_ms; */
 479
 480         handle->linktype = -1;
 481         if (dag_get_datalink(handle) < 0) {
 482                 strcpy(ebuf, handle->errbuf);
 483                 goto fail;
 484         }
 485
 486         handle->bufsize = 0;
 487
 488         if (new_pcap_dag(handle) < 0) {
 489                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "new_pcap_dag %s: %s\n", device, pcap_strerror(errno));
 490                 goto fail;
 491         }
 492
 493         /*
 494          * "select()" and "poll()" don't (yet) work on DAG device descriptors.
 495          */
 496         handle->selectable_fd = -1;
 497
 498 #ifdef linux
 499         handle->md.device = (char *)device;
 500 #else
 501         free((char *)device);
 502         device = NULL;
 503 #endif
 504
 505         handle->read_op = dag_read;
 506         handle->setfilter_op = dag_setfilter;
 507         handle->set_datalink_op = dag_set_datalink;
 508         handle->getnonblock_op = pcap_getnonblock_fd;
 509         handle->setnonblock_op = dag_setnonblock;
 510         handle->stats_op = dag_stats;
 511         handle->close_op = dag_platform_close;
 512
 513         return handle;
 514
 515 fail:
 516         if (device != NULL) {
 517                 free((char *)device);
 518         }
 519         if (handle != NULL) {
 520                 /*
 521                  * Get rid of any link-layer type list we allocated.
 522                  */
 523                 if (handle->dlt_list != NULL) {
 524                         free(handle->dlt_list);
 525                 }
 526                 free(handle);
 527         }
 528
 529         return NULL;
 530 }
 531
 532 static int
 533 dag_stats(pcap_t *p, struct pcap_stat *ps) {
 534         /* This needs to be filled out correctly.  Hopefully a dagapi call will
 535                  provide all necessary information.
 536         */
 537         /*p->md.stat.ps_recv = 0;*/
 538         /*p->md.stat.ps_drop = 0;*/
 539
 540         *ps = p->md.stat;
 541
 542         return 0;
 543 }
 544
 545 /*
 546  * Get from "/proc/dag" all interfaces listed there; if they're
 547  * already in the list of interfaces we have, that won't add another
 548  * instance, but if they're not, that'll add them.
 549  *
 550  * We don't bother getting any addresses for them.
 551  *
 552  * We also don't fail if we couldn't open "/proc/dag"; we just leave
 553  * the list of interfaces as is.
 554  */
 555 int
 556 dag_platform_finddevs(pcap_if_t **devlistp, char *errbuf)
 557 {
 558         FILE *proc_dag_f;
 559         char linebuf[512];
 560         int linenum;
 561         unsigned char *p;
 562         char name[512]; /* XXX - pick a size */
 563         char *q;
 564         int ret = 0;
 565
 566         /* Quick exit if /proc/dag not readable */
 567         proc_dag_f = fopen("/proc/dag", "r");
 568         if (proc_dag_f == NULL)
 569         {
 570                 int i;
 571                 char dev[16] = "dagx";
 572
 573                 for (i = '0'; ret == 0 && i <= '9'; i++) {
 574                         dev[3] = i;
 575                         if (pcap_add_if(devlistp, dev, 0, NULL, errbuf) == -1) {
 576                                 /*
 577                                  * Failure.
 578                                  */
 579                                 ret = -1;
 580                         }
 581                 }
 582
 583                 return (ret);
 584         }
 585
 586         for (linenum = 1; fgets(linebuf, sizeof linebuf, proc_dag_f) != NULL; linenum++) {
 587
 588                 /*
 589                  * Skip the first two lines - they're headers.
 590                  */
 591                 if (linenum <= 2)
 592                         continue;
 593
 594                 p = &linebuf[0];
 595
 596                 if (*p == '\0' || *p == '\n' || *p != 'D')
 597                         continue;  /* not a Dag line */
 598
 599                 /*
 600                  * Get the interface name.
 601                  */
 602                 q = &name[0];
 603                 while (*p != '\0' && *p != ':') {
 604                         if (*p != ' ')
 605                                 *q++ = tolower(*p++);
 606                         else
 607                                 p++;
 608                 }
 609                 *q = '\0';
 610
 611                 /*
 612                  * Add an entry for this interface, with no addresses.
 613                  */
 614                 p[strlen(p) - 1] = '\0'; /* get rid of \n */
 615                 if (pcap_add_if(devlistp, name, 0, strdup(p + 2), errbuf) == -1) {
 616                         /*
 617                          * Failure.
 618                          */
 619                         ret = -1;
 620                         break;
 621                 }
 622         }
 623         if (ret != -1) {
 624                 /*
 625                  * Well, we didn't fail for any other reason; did we
 626                  * fail due to an error reading the file?
 627                  */
 628                 if (ferror(proc_dag_f)) {
 629                         (void)snprintf(errbuf, PCAP_ERRBUF_SIZE,
 630                                   "Error reading /proc/dag: %s",
 631                                   pcap_strerror(errno));
 632                         ret = -1;
 633                 }
 634         }
 635
 636         (void)fclose(proc_dag_f);
 637         return (ret);
 638 }
 639
 640 /*
 641  * Installs the given bpf filter program in the given pcap structure.  There is
 642  * no attempt to store the filter in kernel memory as that is not supported
 643  * with DAG cards.
 644  */
 645 static int
 646 dag_setfilter(pcap_t *p, struct bpf_program *fp)
 647 {
 648         if (!p)
 649                 return -1;
 650         if (!fp) {
 651                 strncpy(p->errbuf, "setfilter: No filter specified",
 652                         sizeof(p->errbuf));
 653                 return -1;
 654         }
 655
 656         /* Make our private copy of the filter */
 657
 658         if (install_bpf_program(p, fp) < 0) {
 659                 snprintf(p->errbuf, sizeof(p->errbuf),
 660                          "malloc: %s", pcap_strerror(errno));
 661                 return -1;
 662         }
 663
 664         p->md.use_bpf = 0;
 665
 666         return (0);
 667 }
 668
 669 static int
 670 dag_set_datalink(pcap_t *p, int dlt)
 671 {
 672         p->linktype = dlt;
 673
 674         return (0);
 675 }
 676
 677 static int
 678 dag_setnonblock(pcap_t *p, int nonblock, char *errbuf)
 679 {
 680         /*
 681          * Set non-blocking mode on the FD.
 682          * XXX - is that necessary?  If not, don't bother calling it,
 683          * and have a "dag_getnonblock()" function that looks at
 684          * "p->md.dag_offset_flags".
 685          */
 686         if (pcap_setnonblock_fd(p, nonblock, errbuf) < 0)
 687                 return (-1);
 688
 689         if (nonblock) {
 690                 p->md.dag_offset_flags |= DAGF_NONBLOCK;
 691         } else {
 692                 p->md.dag_offset_flags &= ~DAGF_NONBLOCK;
 693         }
 694         return (0);
 695 }
 696
 697 static int
 698 dag_get_datalink(pcap_t *p)
 699 {
 700         int daglinktype;
 701
 702         if (p->dlt_list == NULL && (p->dlt_list = malloc(2*sizeof(*(p->dlt_list)))) == NULL) {
 703                 (void)snprintf(p->errbuf, sizeof(p->errbuf), "malloc: %s", pcap_strerror(errno));
 704                 return (-1);
 705         }
 706
 707         /* Check the type through a dagapi call. */
 708         daglinktype = dag_linktype(p->fd);
 709
 710         switch(daglinktype) {
 711
 712         case TYPE_HDLC_POS:
 713                 if (p->dlt_list != NULL) {
 714                         p->dlt_count = 2;
 715                         p->dlt_list[0] = DLT_CHDLC;
 716                         p->dlt_list[1] = DLT_PPP_SERIAL;
 717                 }
 718                 p->linktype = DLT_CHDLC;
 719                 break;
 720
 721         case TYPE_ETH:
 722                 /*
 723                  * This is (presumably) a real Ethernet capture; give it a
 724                  * link-layer-type list with DLT_EN10MB and DLT_DOCSIS, so
 725                  * that an application can let you choose it, in case you're
 726                  * capturing DOCSIS traffic that a Cisco Cable Modem
 727                  * Termination System is putting out onto an Ethernet (it
 728                  * doesn't put an Ethernet header onto the wire, it puts raw
 729                  * DOCSIS frames out on the wire inside the low-level
 730                  * Ethernet framing).
 731                  */
 732                 if (p->dlt_list != NULL) {
 733                         p->dlt_count = 2;
 734                         p->dlt_list[0] = DLT_EN10MB;
 735                         p->dlt_list[1] = DLT_DOCSIS;
 736                 }
 737                 p->linktype = DLT_EN10MB;
 738                 break;
 739
 740         case TYPE_AAL5:
 741         case TYPE_ATM:
 742                 if (p->dlt_list != NULL) {
 743                         p->dlt_count = 2;
 744                         p->dlt_list[0] = DLT_ATM_RFC1483;
 745                         p->dlt_list[1] = DLT_SUNATM;
 746                 }
 747                 p->linktype = DLT_ATM_RFC1483;
 748                 break;
 749
 750
 751         case TYPE_LEGACY:
 752                 p->linktype = DLT_NULL;
 753                 break;
 754
 755         default:
 756                 snprintf(p->errbuf, sizeof(p->errbuf), "unknown DAG linktype %d\n", daglinktype);
 757                 return (-1);
 758
 759         }
 760
 761         return p->linktype;
 762 }