contrib/libpcap-0.9/pcap-bpf.c

   1 /*
   2  * Copyright (c) 1993, 1994, 1995, 1996, 1998
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the University of California,
  13  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  */
  21 #ifndef lint
  22 static const char rcsid[] _U_ =
  23     "@(#) $Header: /tcpdump/master/libpcap/pcap-bpf.c,v 1.86.2.9 2006/01/22 05:28:34 guy Exp $ (LBL)";
  24 #endif
  25
  26 #ifdef HAVE_CONFIG_H
  27 #include "config.h"
  28 #endif
  29
  30 #include <sys/param.h>                  /* optionally get BSD define */
  31 #include <sys/time.h>
  32 #include <sys/timeb.h>
  33 #include <sys/socket.h>
  34 #include <sys/file.h>
  35 #include <sys/ioctl.h>
  36 #include <sys/utsname.h>
  37
  38 #include <net/if.h>
  39
  40 #ifdef _AIX
  41
  42 /*
  43  * Make "pcap.h" not include "pcap-bpf.h"; we are going to include the
  44  * native OS version, as we need "struct bpf_config" from it.
  45  */
  46 #define PCAP_DONT_INCLUDE_PCAP_BPF_H
  47
  48 #include <sys/types.h>
  49
  50 /*
  51  * Prevent bpf.h from redefining the DLT_ values to their
  52  * IFT_ values, as we're going to return the standard libpcap
  53  * values, not IBM's non-standard IFT_ values.
  54  */
  55 #undef _AIX
  56 #include <net/bpf.h>
  57 #define _AIX
  58
  59 #include <net/if_types.h>               /* for IFT_ values */
  60 #include <sys/sysconfig.h>
  61 #include <sys/device.h>
  62 #include <sys/cfgodm.h>
  63 #include <cf.h>
  64
  65 #ifdef __64BIT__
  66 #define domakedev makedev64
  67 #define getmajor major64
  68 #define bpf_hdr bpf_hdr32
  69 #else /* __64BIT__ */
  70 #define domakedev makedev
  71 #define getmajor major
  72 #endif /* __64BIT__ */
  73
  74 #define BPF_NAME "bpf"
  75 #define BPF_MINORS 4
  76 #define DRIVER_PATH "/usr/lib/drivers"
  77 #define BPF_NODE "/dev/bpf"
  78 static int bpfloadedflag = 0;
  79 static int odmlockid = 0;
  80
  81 #else /* _AIX */
  82
  83 #include <net/bpf.h>
  84
  85 #endif /* _AIX */
  86
  87 #include <ctype.h>
  88 #include <errno.h>
  89 #include <netdb.h>
  90 #include <stdio.h>
  91 #include <stdlib.h>
  92 #include <string.h>
  93 #include <unistd.h>
  94
  95 #include "pcap-int.h"
  96
  97 #ifdef HAVE_DAG_API
  98 #include "pcap-dag.h"
  99 #endif /* HAVE_DAG_API */
 100
 101 #ifdef HAVE_OS_PROTO_H
 102 #include "os-proto.h"
 103 #endif
 104
 105 #include "gencode.h"    /* for "no_optimize" */
 106
 107 static int pcap_setfilter_bpf(pcap_t *p, struct bpf_program *fp);
 108 static int pcap_setdirection_bpf(pcap_t *, pcap_direction_t);
 109 static int pcap_set_datalink_bpf(pcap_t *p, int dlt);
 110
 111 static int
 112 pcap_stats_bpf(pcap_t *p, struct pcap_stat *ps)
 113 {
 114         struct bpf_stat s;
 115
 116         /*
 117          * "ps_recv" counts packets handed to the filter, not packets
 118          * that passed the filter.  This includes packets later dropped
 119          * because we ran out of buffer space.
 120          *
 121          * "ps_drop" counts packets dropped inside the BPF device
 122          * because we ran out of buffer space.  It doesn't count
 123          * packets dropped by the interface driver.  It counts
 124          * only packets that passed the filter.
 125          *
 126          * Both statistics include packets not yet read from the kernel
 127          * by libpcap, and thus not yet seen by the application.
 128          */
 129         if (ioctl(p->fd, BIOCGSTATS, (caddr_t)&s) < 0) {
 130                 snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCGSTATS: %s",
 131                     pcap_strerror(errno));
 132                 return (-1);
 133         }
 134
 135         ps->ps_recv = s.bs_recv;
 136         ps->ps_drop = s.bs_drop;
 137         return (0);
 138 }
 139
 140 static int
 141 pcap_read_bpf(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
 142 {
 143         int cc;
 144         int n = 0;
 145         register u_char *bp, *ep;
 146         u_char *datap;
 147         struct bpf_insn *fcode;
 148 #ifdef PCAP_FDDIPAD
 149         register int pad;
 150 #endif
 151
 152         fcode = p->md.use_bpf ? NULL : p->fcode.bf_insns;
 153  again:
 154         /*
 155          * Has "pcap_breakloop()" been called?
 156          */
 157         if (p->break_loop) {
 158                 /*
 159                  * Yes - clear the flag that indicates that it
 160                  * has, and return -2 to indicate that we were
 161                  * told to break out of the loop.
 162                  */
 163                 p->break_loop = 0;
 164                 return (-2);
 165         }
 166         cc = p->cc;
 167         if (p->cc == 0) {
 168                 cc = read(p->fd, (char *)p->buffer, p->bufsize);
 169                 if (cc < 0) {
 170                         /* Don't choke when we get ptraced */
 171                         switch (errno) {
 172
 173                         case EINTR:
 174                                 goto again;
 175
 176 #ifdef _AIX
 177                         case EFAULT:
 178                                 /*
 179                                  * Sigh.  More AIX wonderfulness.
 180                                  *
 181                                  * For some unknown reason the uiomove()
 182                                  * operation in the bpf kernel extension
 183                                  * used to copy the buffer into user
 184                                  * space sometimes returns EFAULT. I have
 185                                  * no idea why this is the case given that
 186                                  * a kernel debugger shows the user buffer
 187                                  * is correct. This problem appears to
 188                                  * be mostly mitigated by the memset of
 189                                  * the buffer before it is first used.
 190                                  * Very strange.... Shaun Clowes
 191                                  *
 192                                  * In any case this means that we shouldn't
 193                                  * treat EFAULT as a fatal error; as we
 194                                  * don't have an API for returning
 195                                  * a "some packets were dropped since
 196                                  * the last packet you saw" indication,
 197                                  * we just ignore EFAULT and keep reading.
 198                                  */
 199                                 goto again;
 200 #endif
 201
 202                         case EWOULDBLOCK:
 203                                 return (0);
 204 #if defined(sun) && !defined(BSD)
 205                         /*
 206                          * Due to a SunOS bug, after 2^31 bytes, the kernel
 207                          * file offset overflows and read fails with EINVAL.
 208                          * The lseek() to 0 will fix things.
 209                          */
 210                         case EINVAL:
 211                                 if (lseek(p->fd, 0L, SEEK_CUR) +
 212                                     p->bufsize < 0) {
 213                                         (void)lseek(p->fd, 0L, SEEK_SET);
 214                                         goto again;
 215                                 }
 216                                 /* fall through */
 217 #endif
 218                         }
 219                         snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "read: %s",
 220                             pcap_strerror(errno));
 221                         return (-1);
 222                 }
 223                 bp = p->buffer;
 224         } else
 225                 bp = p->bp;
 226
 227         /*
 228          * Loop through each packet.
 229          */
 230 #define bhp ((struct bpf_hdr *)bp)
 231         ep = bp + cc;
 232 #ifdef PCAP_FDDIPAD
 233         pad = p->fddipad;
 234 #endif
 235         while (bp < ep) {
 236                 register int caplen, hdrlen;
 237
 238                 /*
 239                  * Has "pcap_breakloop()" been called?
 240                  * If so, return immediately - if we haven't read any
 241                  * packets, clear the flag and return -2 to indicate
 242                  * that we were told to break out of the loop, otherwise
 243                  * leave the flag set, so that the *next* call will break
 244                  * out of the loop without having read any packets, and
 245                  * return the number of packets we've processed so far.
 246                  */
 247                 if (p->break_loop) {
 248                         if (n == 0) {
 249                                 p->break_loop = 0;
 250                                 return (-2);
 251                         } else {
 252                                 p->bp = bp;
 253                                 p->cc = ep - bp;
 254                                 return (n);
 255                         }
 256                 }
 257
 258                 caplen = bhp->bh_caplen;
 259                 hdrlen = bhp->bh_hdrlen;
 260                 datap = bp + hdrlen;
 261                 /*
 262                  * Short-circuit evaluation: if using BPF filter
 263                  * in kernel, no need to do it now.
 264                  *
 265 #ifdef PCAP_FDDIPAD
 266                  * Note: the filter code was generated assuming
 267                  * that p->fddipad was the amount of padding
 268                  * before the header, as that's what's required
 269                  * in the kernel, so we run the filter before
 270                  * skipping that padding.
 271 #endif
 272                  */
 273                 if (fcode == NULL ||
 274                     bpf_filter(fcode, datap, bhp->bh_datalen, caplen)) {
 275                         struct pcap_pkthdr pkthdr;
 276
 277                         pkthdr.ts.tv_sec = bhp->bh_tstamp.tv_sec;
 278 #ifdef _AIX
 279                         /*
 280                          * AIX's BPF returns seconds/nanoseconds time
 281                          * stamps, not seconds/microseconds time stamps.
 282                          */
 283                         pkthdr.ts.tv_usec = bhp->bh_tstamp.tv_usec/1000;
 284 #else
 285                         pkthdr.ts.tv_usec = bhp->bh_tstamp.tv_usec;
 286 #endif
 287 #ifdef PCAP_FDDIPAD
 288                         if (caplen > pad)
 289                                 pkthdr.caplen = caplen - pad;
 290                         else
 291                                 pkthdr.caplen = 0;
 292                         if (bhp->bh_datalen > pad)
 293                                 pkthdr.len = bhp->bh_datalen - pad;
 294                         else
 295                                 pkthdr.len = 0;
 296                         datap += pad;
 297 #else
 298                         pkthdr.caplen = caplen;
 299                         pkthdr.len = bhp->bh_datalen;
 300 #endif
 301                         (*callback)(user, &pkthdr, datap);
 302                         bp += BPF_WORDALIGN(caplen + hdrlen);
 303                         if (++n >= cnt && cnt > 0) {
 304                                 p->bp = bp;
 305                                 p->cc = ep - bp;
 306                                 return (n);
 307                         }
 308                 } else {
 309                         /*
 310                          * Skip this packet.
 311                          */
 312                         bp += BPF_WORDALIGN(caplen + hdrlen);
 313                 }
 314         }
 315 #undef bhp
 316         p->cc = 0;
 317         return (n);
 318 }
 319
 320 static int
 321 pcap_inject_bpf(pcap_t *p, const void *buf, size_t size)
 322 {
 323         int ret;
 324
 325         ret = write(p->fd, buf, size);
 326 #ifdef __APPLE__
 327         if (ret == -1 && errno == EAFNOSUPPORT) {
 328                 /*
 329                  * In Mac OS X, there's a bug wherein setting the
 330                  * BIOCSHDRCMPLT flag causes writes to fail; see,
 331                  * for example:
 332                  *
 333                  *      http://cerberus.sourcefire.com/~jeff/archives/patches/macosx/BIOCSHDRCMPLT-10.3.3.patch
 334                  *
 335                  * So, if, on OS X, we get EAFNOSUPPORT from the write, we
 336                  * assume it's due to that bug, and turn off that flag
 337                  * and try again.  If we succeed, it either means that
 338                  * somebody applied the fix from that URL, or other patches
 339                  * for that bug from
 340                  *
 341                  *      http://cerberus.sourcefire.com/~jeff/archives/patches/macosx/
 342                  *
 343                  * and are running a Darwin kernel with those fixes, or
 344                  * that Apple fixed the problem in some OS X release.
 345                  */
 346                 u_int spoof_eth_src = 0;
 347
 348                 if (ioctl(p->fd, BIOCSHDRCMPLT, &spoof_eth_src) == -1) {
 349                         (void)snprintf(p->errbuf, PCAP_ERRBUF_SIZE,
 350                             "send: can't turn off BIOCSHDRCMPLT: %s",
 351                             pcap_strerror(errno));
 352                         return (-1);
 353                 }
 354
 355                 /*
 356                  * Now try the write again.
 357                  */
 358                 ret = write(p->fd, buf, size);
 359         }
 360 #endif /* __APPLE__ */
 361         if (ret == -1) {
 362                 snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "send: %s",
 363                     pcap_strerror(errno));
 364                 return (-1);
 365         }
 366         return (ret);
 367 }
 368
 369 #ifdef _AIX
 370 static int
 371 bpf_odminit(char *errbuf)
 372 {
 373         char *errstr;
 374
 375         if (odm_initialize() == -1) {
 376                 if (odm_err_msg(odmerrno, &errstr) == -1)
 377                         errstr = "Unknown error";
 378                 snprintf(errbuf, PCAP_ERRBUF_SIZE,
 379                     "bpf_load: odm_initialize failed: %s",
 380                     errstr);
 381                 return (-1);
 382         }
 383
 384         if ((odmlockid = odm_lock("/etc/objrepos/config_lock", ODM_WAIT)) == -1) {
 385                 if (odm_err_msg(odmerrno, &errstr) == -1)
 386                         errstr = "Unknown error";
 387                 snprintf(errbuf, PCAP_ERRBUF_SIZE,
 388                     "bpf_load: odm_lock of /etc/objrepos/config_lock failed: %s",
 389                     errstr);
 390                 return (-1);
 391         }
 392
 393         return (0);
 394 }
 395
 396 static int
 397 bpf_odmcleanup(char *errbuf)
 398 {
 399         char *errstr;
 400
 401         if (odm_unlock(odmlockid) == -1) {
 402                 if (odm_err_msg(odmerrno, &errstr) == -1)
 403                         errstr = "Unknown error";
 404                 snprintf(errbuf, PCAP_ERRBUF_SIZE,
 405                     "bpf_load: odm_unlock failed: %s",
 406                     errstr);
 407                 return (-1);
 408         }
 409
 410         if (odm_terminate() == -1) {
 411                 if (odm_err_msg(odmerrno, &errstr) == -1)
 412                         errstr = "Unknown error";
 413                 snprintf(errbuf, PCAP_ERRBUF_SIZE,
 414                     "bpf_load: odm_terminate failed: %s",
 415                     errstr);
 416                 return (-1);
 417         }
 418
 419         return (0);
 420 }
 421
 422 static int
 423 bpf_load(char *errbuf)
 424 {
 425         long major;
 426         int *minors;
 427         int numminors, i, rc;
 428         char buf[1024];
 429         struct stat sbuf;
 430         struct bpf_config cfg_bpf;
 431         struct cfg_load cfg_ld;
 432         struct cfg_kmod cfg_km;
 433
 434         /*
 435          * This is very very close to what happens in the real implementation
 436          * but I've fixed some (unlikely) bug situations.
 437          */
 438         if (bpfloadedflag)
 439                 return (0);
 440
 441         if (bpf_odminit(errbuf) != 0)
 442                 return (-1);
 443
 444         major = genmajor(BPF_NAME);
 445         if (major == -1) {
 446                 snprintf(errbuf, PCAP_ERRBUF_SIZE,
 447                     "bpf_load: genmajor failed: %s", pcap_strerror(errno));
 448                 return (-1);
 449         }
 450
 451         minors = getminor(major, &numminors, BPF_NAME);
 452         if (!minors) {
 453                 minors = genminor("bpf", major, 0, BPF_MINORS, 1, 1);
 454                 if (!minors) {
 455                         snprintf(errbuf, PCAP_ERRBUF_SIZE,
 456                             "bpf_load: genminor failed: %s",
 457                             pcap_strerror(errno));
 458                         return (-1);
 459                 }
 460         }
 461
 462         if (bpf_odmcleanup(errbuf))
 463                 return (-1);
 464
 465         rc = stat(BPF_NODE "0", &sbuf);
 466         if (rc == -1 && errno != ENOENT) {
 467                 snprintf(errbuf, PCAP_ERRBUF_SIZE,
 468                     "bpf_load: can't stat %s: %s",
 469                     BPF_NODE "0", pcap_strerror(errno));
 470                 return (-1);
 471         }
 472
 473         if (rc == -1 || getmajor(sbuf.st_rdev) != major) {
 474                 for (i = 0; i < BPF_MINORS; i++) {
 475                         sprintf(buf, "%s%d", BPF_NODE, i);
 476                         unlink(buf);
 477                         if (mknod(buf, S_IRUSR | S_IFCHR, domakedev(major, i)) == -1) {
 478                                 snprintf(errbuf, PCAP_ERRBUF_SIZE,
 479                                     "bpf_load: can't mknod %s: %s",
 480                                     buf, pcap_strerror(errno));
 481                                 return (-1);
 482                         }
 483                 }
 484         }
 485
 486         /* Check if the driver is loaded */
 487         memset(&cfg_ld, 0x0, sizeof(cfg_ld));
 488         cfg_ld.path = buf;
 489         sprintf(cfg_ld.path, "%s/%s", DRIVER_PATH, BPF_NAME);
 490         if ((sysconfig(SYS_QUERYLOAD, (void *)&cfg_ld, sizeof(cfg_ld)) == -1) ||
 491             (cfg_ld.kmid == 0)) {
 492                 /* Driver isn't loaded, load it now */
 493                 if (sysconfig(SYS_SINGLELOAD, (void *)&cfg_ld, sizeof(cfg_ld)) == -1) {
 494                         snprintf(errbuf, PCAP_ERRBUF_SIZE,
 495                             "bpf_load: could not load driver: %s",
 496                             strerror(errno));
 497                         return (-1);
 498                 }
 499         }
 500
 501         /* Configure the driver */
 502         cfg_km.cmd = CFG_INIT;
 503         cfg_km.kmid = cfg_ld.kmid;
 504         cfg_km.mdilen = sizeof(cfg_bpf);
 505         cfg_km.mdiptr = (void *)&cfg_bpf;
 506         for (i = 0; i < BPF_MINORS; i++) {
 507                 cfg_bpf.devno = domakedev(major, i);
 508                 if (sysconfig(SYS_CFGKMOD, (void *)&cfg_km, sizeof(cfg_km)) == -1) {
 509                         snprintf(errbuf, PCAP_ERRBUF_SIZE,
 510                             "bpf_load: could not configure driver: %s",
 511                             strerror(errno));
 512                         return (-1);
 513                 }
 514         }
 515
 516         bpfloadedflag = 1;
 517
 518         return (0);
 519 }
 520 #endif
 521
 522 static inline int
 523 bpf_open(pcap_t *p, char *errbuf)
 524 {
 525         int fd;
 526         int n = 0;
 527         char device[sizeof "/dev/bpf0000000000"];
 528
 529 #ifdef _AIX
 530         /*
 531          * Load the bpf driver, if it isn't already loaded,
 532          * and create the BPF device entries, if they don't
 533          * already exist.
 534          */
 535         if (bpf_load(errbuf) == -1)
 536                 return (-1);
 537 #endif
 538
 539         /*
 540          * Go through all the minors and find one that isn't in use.
 541          */
 542         do {
 543                 (void)snprintf(device, sizeof(device), "/dev/bpf%d", n++);
 544                 /*
 545                  * Initially try a read/write open (to allow the inject
 546                  * method to work).  If that fails due to permission
 547                  * issues, fall back to read-only.  This allows a
 548                  * non-root user to be granted specific access to pcap
 549                  * capabilities via file permissions.
 550                  *
 551                  * XXX - we should have an API that has a flag that
 552                  * controls whether to open read-only or read-write,
 553                  * so that denial of permission to send (or inability
 554                  * to send, if sending packets isn't supported on
 555                  * the device in question) can be indicated at open
 556                  * time.
 557                  */
 558                 fd = open(device, O_RDWR);
 559                 if (fd == -1 && errno == EACCES)
 560                         fd = open(device, O_RDONLY);
 561         } while (fd < 0 && errno == EBUSY);
 562
 563         /*
 564          * XXX better message for all minors used
 565          */
 566         if (fd < 0)
 567                 snprintf(errbuf, PCAP_ERRBUF_SIZE, "(no devices found) %s: %s",
 568                     device, pcap_strerror(errno));
 569
 570         return (fd);
 571 }
 572
 573 /*
 574  * We include the OS's <net/bpf.h>, not our "pcap-bpf.h", so we probably
 575  * don't get DLT_DOCSIS defined.
 576  */
 577 #ifndef DLT_DOCSIS
 578 #define DLT_DOCSIS      143
 579 #endif
 580
 581 pcap_t *
 582 pcap_open_live(const char *device, int snaplen, int promisc, int to_ms,
 583     char *ebuf)
 584 {
 585         int fd;
 586         struct ifreq ifr;
 587         struct bpf_version bv;
 588 #ifdef BIOCGDLTLIST
 589         struct bpf_dltlist bdl;
 590 #endif
 591 #if defined(BIOCGHDRCMPLT) && defined(BIOCSHDRCMPLT)
 592         u_int spoof_eth_src = 1;
 593 #endif
 594         u_int v;
 595         pcap_t *p;
 596         struct bpf_insn total_insn;
 597         struct bpf_program total_prog;
 598         struct utsname osinfo;
 599
 600 #ifdef HAVE_DAG_API
 601         if (strstr(device, "dag")) {
 602                 return dag_open_live(device, snaplen, promisc, to_ms, ebuf);
 603         }
 604 #endif /* HAVE_DAG_API */
 605
 606 #ifdef BIOCGDLTLIST
 607         memset(&bdl, 0, sizeof(bdl));
 608 #endif
 609
 610         p = (pcap_t *)malloc(sizeof(*p));
 611         if (p == NULL) {
 612                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
 613                     pcap_strerror(errno));
 614                 return (NULL);
 615         }
 616         memset(p, 0, sizeof(*p));
 617         fd = bpf_open(p, ebuf);
 618         if (fd < 0)
 619                 goto bad;
 620
 621         p->fd = fd;
 622         p->snapshot = snaplen;
 623
 624         if (ioctl(fd, BIOCVERSION, (caddr_t)&bv) < 0) {
 625                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "BIOCVERSION: %s",
 626                     pcap_strerror(errno));
 627                 goto bad;
 628         }
 629         if (bv.bv_major != BPF_MAJOR_VERSION ||
 630             bv.bv_minor < BPF_MINOR_VERSION) {
 631                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
 632                     "kernel bpf filter out of date");
 633                 goto bad;
 634         }
 635
 636         /*
 637          * Try finding a good size for the buffer; 32768 may be too
 638          * big, so keep cutting it in half until we find a size
 639          * that works, or run out of sizes to try.  If the default
 640          * is larger, don't make it smaller.
 641          *
 642          * XXX - there should be a user-accessible hook to set the
 643          * initial buffer size.
 644          */
 645         if ((ioctl(fd, BIOCGBLEN, (caddr_t)&v) < 0) || v < 32768)
 646                 v = 32768;
 647         for ( ; v != 0; v >>= 1) {
 648                 /* Ignore the return value - this is because the call fails
 649                  * on BPF systems that don't have kernel malloc.  And if
 650                  * the call fails, it's no big deal, we just continue to
 651                  * use the standard buffer size.
 652                  */
 653                 (void) ioctl(fd, BIOCSBLEN, (caddr_t)&v);
 654
 655                 (void)strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
 656                 if (ioctl(fd, BIOCSETIF, (caddr_t)&ifr) >= 0)
 657                         break;  /* that size worked; we're done */
 658
 659                 if (errno != ENOBUFS) {
 660                         snprintf(ebuf, PCAP_ERRBUF_SIZE, "BIOCSETIF: %s: %s",
 661                             device, pcap_strerror(errno));
 662                         goto bad;
 663                 }
 664         }
 665
 666         if (v == 0) {
 667                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
 668                          "BIOCSBLEN: %s: No buffer size worked", device);
 669                 goto bad;
 670         }
 671
 672         /* Get the data link layer type. */
 673         if (ioctl(fd, BIOCGDLT, (caddr_t)&v) < 0) {
 674                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "BIOCGDLT: %s",
 675                     pcap_strerror(errno));
 676                 goto bad;
 677         }
 678 #ifdef _AIX
 679         /*
 680          * AIX's BPF returns IFF_ types, not DLT_ types, in BIOCGDLT.
 681          */
 682         switch (v) {
 683
 684         case IFT_ETHER:
 685         case IFT_ISO88023:
 686                 v = DLT_EN10MB;
 687                 break;
 688
 689         case IFT_FDDI:
 690                 v = DLT_FDDI;
 691                 break;
 692
 693         case IFT_ISO88025:
 694                 v = DLT_IEEE802;
 695                 break;
 696
 697         case IFT_LOOP:
 698                 v = DLT_NULL;
 699                 break;
 700
 701         default:
 702                 /*
 703                  * We don't know what to map this to yet.
 704                  */
 705                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "unknown interface type %u",
 706                     v);
 707                 goto bad;
 708         }
 709 #endif
 710 #if _BSDI_VERSION - 0 >= 199510
 711         /* The SLIP and PPP link layer header changed in BSD/OS 2.1 */
 712         switch (v) {
 713
 714         case DLT_SLIP:
 715                 v = DLT_SLIP_BSDOS;
 716                 break;
 717
 718         case DLT_PPP:
 719                 v = DLT_PPP_BSDOS;
 720                 break;
 721
 722         case 11:        /*DLT_FR*/
 723                 v = DLT_FRELAY;
 724                 break;
 725
 726         case 12:        /*DLT_C_HDLC*/
 727                 v = DLT_CHDLC;
 728                 break;
 729         }
 730 #endif
 731 #ifdef PCAP_FDDIPAD
 732         if (v == DLT_FDDI)
 733                 p->fddipad = PCAP_FDDIPAD;
 734         else
 735                 p->fddipad = 0;
 736 #endif
 737         p->linktype = v;
 738
 739 #ifdef BIOCGDLTLIST
 740         /*
 741          * We know the default link type -- now determine all the DLTs
 742          * this interface supports.  If this fails with EINVAL, it's
 743          * not fatal; we just don't get to use the feature later.
 744          */
 745         if (ioctl(fd, BIOCGDLTLIST, (caddr_t)&bdl) == 0) {
 746                 u_int i;
 747                 int is_ethernet;
 748
 749                 bdl.bfl_list = (u_int *) malloc(sizeof(u_int) * (bdl.bfl_len + 1));
 750                 if (bdl.bfl_list == NULL) {
 751                         (void)snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
 752                             pcap_strerror(errno));
 753                         goto bad;
 754                 }
 755
 756                 if (ioctl(fd, BIOCGDLTLIST, (caddr_t)&bdl) < 0) {
 757                         (void)snprintf(ebuf, PCAP_ERRBUF_SIZE,
 758                             "BIOCGDLTLIST: %s", pcap_strerror(errno));
 759                         free(bdl.bfl_list);
 760                         goto bad;
 761                 }
 762
 763                 /*
 764                  * OK, for real Ethernet devices, add DLT_DOCSIS to the
 765                  * list, so that an application can let you choose it,
 766                  * in case you're capturing DOCSIS traffic that a Cisco
 767                  * Cable Modem Termination System is putting out onto
 768                  * an Ethernet (it doesn't put an Ethernet header onto
 769                  * the wire, it puts raw DOCSIS frames out on the wire
 770                  * inside the low-level Ethernet framing).
 771                  *
 772                  * A "real Ethernet device" is defined here as a device
 773                  * that has a link-layer type of DLT_EN10MB and that has
 774                  * no alternate link-layer types; that's done to exclude
 775                  * 802.11 interfaces (which might or might not be the
 776                  * right thing to do, but I suspect it is - Ethernet <->
 777                  * 802.11 bridges would probably badly mishandle frames
 778                  * that don't have Ethernet headers).
 779                  */
 780                 if (p->linktype == DLT_EN10MB) {
 781                         is_ethernet = 1;
 782                         for (i = 0; i < bdl.bfl_len; i++) {
 783                                 if (bdl.bfl_list[i] != DLT_EN10MB) {
 784                                         is_ethernet = 0;
 785                                         break;
 786                                 }
 787                         }
 788                         if (is_ethernet) {
 789                                 /*
 790                                  * We reserved one more slot at the end of
 791                                  * the list.
 792                                  */
 793                                 bdl.bfl_list[bdl.bfl_len] = DLT_DOCSIS;
 794                                 bdl.bfl_len++;
 795                         }
 796                 }
 797                 p->dlt_count = bdl.bfl_len;
 798                 p->dlt_list = bdl.bfl_list;
 799         } else {
 800                 if (errno != EINVAL) {
 801                         (void)snprintf(ebuf, PCAP_ERRBUF_SIZE,
 802                             "BIOCGDLTLIST: %s", pcap_strerror(errno));
 803                         goto bad;
 804                 }
 805         }
 806 #endif
 807
 808         /*
 809          * If this is an Ethernet device, and we don't have a DLT_ list,
 810          * give it a list with DLT_EN10MB and DLT_DOCSIS.  (That'd give
 811          * 802.11 interfaces DLT_DOCSIS, which isn't the right thing to
 812          * do, but there's not much we can do about that without finding
 813          * some other way of determining whether it's an Ethernet or 802.11
 814          * device.)
 815          */
 816         if (p->linktype == DLT_EN10MB && p->dlt_count == 0) {
 817                 p->dlt_list = (u_int *) malloc(sizeof(u_int) * 2);
 818                 /*
 819                  * If that fails, just leave the list empty.
 820                  */
 821                 if (p->dlt_list != NULL) {
 822                         p->dlt_list[0] = DLT_EN10MB;
 823                         p->dlt_list[1] = DLT_DOCSIS;
 824                         p->dlt_count = 2;
 825                 }
 826         }
 827
 828 #if defined(BIOCGHDRCMPLT) && defined(BIOCSHDRCMPLT)
 829         /*
 830          * Do a BIOCSHDRCMPLT, if defined, to turn that flag on, so
 831          * the link-layer source address isn't forcibly overwritten.
 832          * (Should we ignore errors?  Should we do this only if
 833          * we're open for writing?)
 834          *
 835          * XXX - I seem to remember some packet-sending bug in some
 836          * BSDs - check CVS log for "bpf.c"?
 837          */
 838         if (ioctl(fd, BIOCSHDRCMPLT, &spoof_eth_src) == -1) {
 839                 (void)snprintf(ebuf, PCAP_ERRBUF_SIZE,
 840                     "BIOCSHDRCMPLT: %s", pcap_strerror(errno));
 841                 goto bad;
 842         }
 843 #endif
 844         /* set timeout */
 845         if (to_ms != 0) {
 846                 /*
 847                  * XXX - is this seconds/nanoseconds in AIX?
 848                  * (Treating it as such doesn't fix the timeout
 849                  * problem described below.)
 850                  */
 851                 struct timeval to;
 852                 to.tv_sec = to_ms / 1000;
 853                 to.tv_usec = (to_ms * 1000) % 1000000;
 854                 if (ioctl(p->fd, BIOCSRTIMEOUT, (caddr_t)&to) < 0) {
 855                         snprintf(ebuf, PCAP_ERRBUF_SIZE, "BIOCSRTIMEOUT: %s",
 856                             pcap_strerror(errno));
 857                         goto bad;
 858                 }
 859         }
 860
 861 #ifdef _AIX
 862 #ifdef  BIOCIMMEDIATE
 863         /*
 864          * Darren Reed notes that
 865          *
 866          *      On AIX (4.2 at least), if BIOCIMMEDIATE is not set, the
 867          *      timeout appears to be ignored and it waits until the buffer
 868          *      is filled before returning.  The result of not having it
 869          *      set is almost worse than useless if your BPF filter
 870          *      is reducing things to only a few packets (i.e. one every
 871          *      second or so).
 872          *
 873          * so we turn BIOCIMMEDIATE mode on if this is AIX.
 874          *
 875          * We don't turn it on for other platforms, as that means we
 876          * get woken up for every packet, which may not be what we want;
 877          * in the Winter 1993 USENIX paper on BPF, they say:
 878          *
 879          *      Since a process might want to look at every packet on a
 880          *      network and the time between packets can be only a few
 881          *      microseconds, it is not possible to do a read system call
 882          *      per packet and BPF must collect the data from several
 883          *      packets and return it as a unit when the monitoring
 884          *      application does a read.
 885          *
 886          * which I infer is the reason for the timeout - it means we
 887          * wait that amount of time, in the hopes that more packets
 888          * will arrive and we'll get them all with one read.
 889          *
 890          * Setting BIOCIMMEDIATE mode on FreeBSD (and probably other
 891          * BSDs) causes the timeout to be ignored.
 892          *
 893          * On the other hand, some platforms (e.g., Linux) don't support
 894          * timeouts, they just hand stuff to you as soon as it arrives;
 895          * if that doesn't cause a problem on those platforms, it may
 896          * be OK to have BIOCIMMEDIATE mode on BSD as well.
 897          *
 898          * (Note, though, that applications may depend on the read
 899          * completing, even if no packets have arrived, when the timeout
 900          * expires, e.g. GUI applications that have to check for input
 901          * while waiting for packets to arrive; a non-zero timeout
 902          * prevents "select()" from working right on FreeBSD and
 903          * possibly other BSDs, as the timer doesn't start until a
 904          * "read()" is done, so the timer isn't in effect if the
 905          * application is blocked on a "select()", and the "select()"
 906          * doesn't get woken up for a BPF device until the buffer
 907          * fills up.)
 908          */
 909         v = 1;
 910         if (ioctl(p->fd, BIOCIMMEDIATE, &v) < 0) {
 911                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "BIOCIMMEDIATE: %s",
 912                     pcap_strerror(errno));
 913                 goto bad;
 914         }
 915 #endif  /* BIOCIMMEDIATE */
 916 #endif  /* _AIX */
 917
 918         if (promisc) {
 919                 /* set promiscuous mode, okay if it fails */
 920                 if (ioctl(p->fd, BIOCPROMISC, NULL) < 0) {
 921                         snprintf(ebuf, PCAP_ERRBUF_SIZE, "BIOCPROMISC: %s",
 922                             pcap_strerror(errno));
 923                 }
 924         }
 925
 926         if (ioctl(fd, BIOCGBLEN, (caddr_t)&v) < 0) {
 927                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "BIOCGBLEN: %s",
 928                     pcap_strerror(errno));
 929                 goto bad;
 930         }
 931         p->bufsize = v;
 932         p->buffer = (u_char *)malloc(p->bufsize);
 933         if (p->buffer == NULL) {
 934                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
 935                     pcap_strerror(errno));
 936                 goto bad;
 937         }
 938 #ifdef _AIX
 939         /* For some strange reason this seems to prevent the EFAULT
 940          * problems we have experienced from AIX BPF. */
 941         memset(p->buffer, 0x0, p->bufsize);
 942 #endif
 943
 944         /*
 945          * If there's no filter program installed, there's
 946          * no indication to the kernel of what the snapshot
 947          * length should be, so no snapshotting is done.
 948          *
 949          * Therefore, when we open the device, we install
 950          * an "accept everything" filter with the specified
 951          * snapshot length.
 952          */
 953         total_insn.code = (u_short)(BPF_RET | BPF_K);
 954         total_insn.jt = 0;
 955         total_insn.jf = 0;
 956         total_insn.k = snaplen;
 957
 958         total_prog.bf_len = 1;
 959         total_prog.bf_insns = &total_insn;
 960         if (ioctl(p->fd, BIOCSETF, (caddr_t)&total_prog) < 0) {
 961                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "BIOCSETF: %s",
 962                     pcap_strerror(errno));
 963                 goto bad;
 964         }
 965
 966         /*
 967          * On most BPF platforms, either you can do a "select()" or
 968          * "poll()" on a BPF file descriptor and it works correctly,
 969          * or you can do it and it will return "readable" if the
 970          * hold buffer is full but not if the timeout expires *and*
 971          * a non-blocking read will, if the hold buffer is empty
 972          * but the store buffer isn't empty, rotate the buffers
 973          * and return what packets are available.
 974          *
 975          * In the latter case, the fact that a non-blocking read
 976          * will give you the available packets means you can work
 977          * around the failure of "select()" and "poll()" to wake up
 978          * and return "readable" when the timeout expires by using
 979          * the timeout as the "select()" or "poll()" timeout, putting
 980          * the BPF descriptor into non-blocking mode, and read from
 981          * it regardless of whether "select()" reports it as readable
 982          * or not.
 983          *
 984          * However, in FreeBSD 4.3 and 4.4, "select()" and "poll()"
 985          * won't wake up and return "readable" if the timer expires
 986          * and non-blocking reads return EWOULDBLOCK if the hold
 987          * buffer is empty, even if the store buffer is non-empty.
 988          *
 989          * This means the workaround in question won't work.
 990          *
 991          * Therefore, on FreeBSD 4.3 and 4.4, we set "p->selectable_fd"
 992          * to -1, which means "sorry, you can't use 'select()' or 'poll()'
 993          * here".  On all other BPF platforms, we set it to the FD for
 994          * the BPF device; in NetBSD, OpenBSD, and Darwin, a non-blocking
 995          * read will, if the hold buffer is empty and the store buffer
 996          * isn't empty, rotate the buffers and return what packets are
 997          * there (and in sufficiently recent versions of OpenBSD
 998          * "select()" and "poll()" should work correctly).
 999          *
1000          * XXX - what about AIX?
1001          */
1002         p->selectable_fd = p->fd;       /* assume select() works until we know otherwise */
1003         if (uname(&osinfo) == 0) {
1004                 /*
1005                  * We can check what OS this is.
1006                  */
1007                 if (strcmp(osinfo.sysname, "FreeBSD") == 0) {
1008                         if (strncmp(osinfo.release, "4.3-", 4) == 0 ||
1009                              strncmp(osinfo.release, "4.4-", 4) == 0)
1010                                 p->selectable_fd = -1;
1011                 }
1012         }
1013
1014         p->read_op = pcap_read_bpf;
1015         p->inject_op = pcap_inject_bpf;
1016         p->setfilter_op = pcap_setfilter_bpf;
1017         p->setdirection_op = pcap_setdirection_bpf;
1018         p->set_datalink_op = pcap_set_datalink_bpf;
1019         p->getnonblock_op = pcap_getnonblock_fd;
1020         p->setnonblock_op = pcap_setnonblock_fd;
1021         p->stats_op = pcap_stats_bpf;
1022         p->close_op = pcap_close_common;
1023
1024         return (p);
1025  bad:
1026         (void)close(fd);
1027         if (p->dlt_list != NULL)
1028                 free(p->dlt_list);
1029         free(p);
1030         return (NULL);
1031 }
1032
1033 int
1034 pcap_platform_finddevs(pcap_if_t **alldevsp, char *errbuf)
1035 {
1036 #ifdef HAVE_DAG_API
1037         if (dag_platform_finddevs(alldevsp, errbuf) < 0)
1038                 return (-1);
1039 #endif /* HAVE_DAG_API */
1040
1041         return (0);
1042 }
1043
1044 static int
1045 pcap_setfilter_bpf(pcap_t *p, struct bpf_program *fp)
1046 {
1047         /*
1048          * It looks that BPF code generated by gen_protochain() is not
1049          * compatible with some of kernel BPF code (for example BSD/OS 3.1).
1050          * Take a safer side for now.
1051          */
1052         if (no_optimize) {
1053                 /*
1054                  * XXX - what if we already have a filter in the kernel?
1055                  */
1056                 if (install_bpf_program(p, fp) < 0)
1057                         return (-1);
1058                 p->md.use_bpf = 0;      /* filtering in userland */
1059                 return (0);
1060         }
1061
1062         /*
1063          * Free any user-mode filter we might happen to have installed.
1064          */
1065         pcap_freecode(&p->fcode);
1066
1067         /*
1068          * Try to install the kernel filter.
1069          */
1070         if (ioctl(p->fd, BIOCSETF, (caddr_t)fp) < 0) {
1071                 snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "BIOCSETF: %s",
1072                     pcap_strerror(errno));
1073                 return (-1);
1074         }
1075         p->md.use_bpf = 1;      /* filtering in the kernel */
1076
1077         /*
1078          * Discard any previously-received packets, as they might have
1079          * passed whatever filter was formerly in effect, but might
1080          * not pass this filter (BIOCSETF discards packets buffered
1081          * in the kernel, so you can lose packets in any case).
1082          */
1083         p->cc = 0;
1084         return (0);
1085 }
1086
1087 /*
1088  * Set direction flag: Which packets do we accept on a forwarding
1089  * single device? IN, OUT or both?
1090  */
1091 static int
1092 pcap_setdirection_bpf(pcap_t *p, pcap_direction_t d)
1093 {
1094 #ifdef BIOCSSEESENT
1095         u_int seesent;
1096 #endif
1097
1098         /*
1099          * We don't support PCAP_D_OUT.
1100          */
1101         if (d == PCAP_D_OUT) {
1102                 snprintf(p->errbuf, sizeof(p->errbuf),
1103                     "Setting direction to PCAP_D_OUT is not supported on BPF");
1104                 return -1;
1105         }
1106 #ifdef BIOCSSEESENT
1107         seesent = (d == PCAP_D_INOUT);
1108         if (ioctl(p->fd, BIOCSSEESENT, &seesent) == -1) {
1109                 (void) snprintf(p->errbuf, sizeof(p->errbuf),
1110                     "Cannot set direction to %s: %s",
1111                         (d == PCAP_D_INOUT) ? "PCAP_D_INOUT" : "PCAP_D_IN",
1112                         strerror(errno));
1113                 return (-1);
1114         }
1115         return (0);
1116 #else
1117         (void) snprintf(p->errbuf, sizeof(p->errbuf),
1118             "This system doesn't support BIOCSSEESENT, so the direction can't be set");
1119         return (-1);
1120 #endif
1121 }
1122
1123 static int
1124 pcap_set_datalink_bpf(pcap_t *p, int dlt)
1125 {
1126 #ifdef BIOCSDLT
1127         if (ioctl(p->fd, BIOCSDLT, &dlt) == -1) {
1128                 (void) snprintf(p->errbuf, sizeof(p->errbuf),
1129                     "Cannot set DLT %d: %s", dlt, strerror(errno));
1130                 return (-1);
1131         }
1132 #endif
1133         return (0);
1134 }