contrib/libpcap/pcap-dag.c

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