contrib/libpcap-0.8.3/pcap-linux.c

   1 /*
   2  *  pcap-linux.c: Packet capture interface to the Linux kernel
   3  *
   4  *  Copyright (c) 2000 Torsten Landschoff <torsten@debian.org>
   5  *                     Sebastian Krahmer  <krahmer@cs.uni-potsdam.de>
   6  *
   7  *  License: BSD
   8  *
   9  *  Redistribution and use in source and binary forms, with or without
  10  *  modification, are permitted provided that the following conditions
  11  *  are met:
  12  *
  13  *  1. Redistributions of source code must retain the above copyright
  14  *     notice, this list of conditions and the following disclaimer.
  15  *  2. Redistributions in binary form must reproduce the above copyright
  16  *     notice, this list of conditions and the following disclaimer in
  17  *     the documentation and/or other materials provided with the
  18  *     distribution.
  19  *  3. The names of the authors may not be used to endorse or promote
  20  *     products derived from this software without specific prior
  21  *     written permission.
  22  *
  23  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  24  *  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  25  *  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  26  */
  27
  28 #ifndef lint
  29 static const char rcsid[] _U_ =
  30     "@(#) $Header: /tcpdump/master/libpcap/pcap-linux.c,v 1.98.2.4 2003/11/21 10:20:46 guy Exp $ (LBL)";
  31 #endif
  32
  33 /*
  34  * Known problems with 2.0[.x] kernels:
  35  *
  36  *   - The loopback device gives every packet twice; on 2.2[.x] kernels,
  37  *     if we use PF_PACKET, we can filter out the transmitted version
  38  *     of the packet by using data in the "sockaddr_ll" returned by
  39  *     "recvfrom()", but, on 2.0[.x] kernels, we have to use
  40  *     PF_INET/SOCK_PACKET, which means "recvfrom()" supplies a
  41  *     "sockaddr_pkt" which doesn't give us enough information to let
  42  *     us do that.
  43  *
  44  *   - We have to set the interface's IFF_PROMISC flag ourselves, if
  45  *     we're to run in promiscuous mode, which means we have to turn
  46  *     it off ourselves when we're done; the kernel doesn't keep track
  47  *     of how many sockets are listening promiscuously, which means
  48  *     it won't get turned off automatically when no sockets are
  49  *     listening promiscuously.  We catch "pcap_close()" and, for
  50  *     interfaces we put into promiscuous mode, take them out of
  51  *     promiscuous mode - which isn't necessarily the right thing to
  52  *     do, if another socket also requested promiscuous mode between
  53  *     the time when we opened the socket and the time when we close
  54  *     the socket.
  55  *
  56  *   - MSG_TRUNC isn't supported, so you can't specify that "recvfrom()"
  57  *     return the amount of data that you could have read, rather than
  58  *     the amount that was returned, so we can't just allocate a buffer
  59  *     whose size is the snapshot length and pass the snapshot length
  60  *     as the byte count, and also pass MSG_TRUNC, so that the return
  61  *     value tells us how long the packet was on the wire.
  62  *
  63  *     This means that, if we want to get the actual size of the packet,
  64  *     so we can return it in the "len" field of the packet header,
  65  *     we have to read the entire packet, not just the part that fits
  66  *     within the snapshot length, and thus waste CPU time copying data
  67  *     from the kernel that our caller won't see.
  68  *
  69  *     We have to get the actual size, and supply it in "len", because
  70  *     otherwise, the IP dissector in tcpdump, for example, will complain
  71  *     about "truncated-ip", as the packet will appear to have been
  72  *     shorter, on the wire, than the IP header said it should have been.
  73  */
  74
  75
  76 #ifdef HAVE_CONFIG_H
  77 #include "config.h"
  78 #endif
  79
  80 #include "pcap-int.h"
  81 #include "sll.h"
  82
  83 #ifdef HAVE_DAG_API
  84 #include "pcap-dag.h"
  85 #endif /* HAVE_DAG_API */
  86
  87 #include <errno.h>
  88 #include <stdlib.h>
  89 #include <unistd.h>
  90 #include <fcntl.h>
  91 #include <string.h>
  92 #include <sys/socket.h>
  93 #include <sys/ioctl.h>
  94 #include <sys/utsname.h>
  95 #include <net/if.h>
  96 #include <netinet/in.h>
  97 #include <linux/if_ether.h>
  98 #include <net/if_arp.h>
  99
 100 /*
 101  * If PF_PACKET is defined, we can use {SOCK_RAW,SOCK_DGRAM}/PF_PACKET
 102  * sockets rather than SOCK_PACKET sockets.
 103  *
 104  * To use them, we include <linux/if_packet.h> rather than
 105  * <netpacket/packet.h>; we do so because
 106  *
 107  *      some Linux distributions (e.g., Slackware 4.0) have 2.2 or
 108  *      later kernels and libc5, and don't provide a <netpacket/packet.h>
 109  *      file;
 110  *
 111  *      not all versions of glibc2 have a <netpacket/packet.h> file
 112  *      that defines stuff needed for some of the 2.4-or-later-kernel
 113  *      features, so if the system has a 2.4 or later kernel, we
 114  *      still can't use those features.
 115  *
 116  * We're already including a number of other <linux/XXX.h> headers, and
 117  * this code is Linux-specific (no other OS has PF_PACKET sockets as
 118  * a raw packet capture mechanism), so it's not as if you gain any
 119  * useful portability by using <netpacket/packet.h>
 120  *
 121  * XXX - should we just include <linux/if_packet.h> even if PF_PACKET
 122  * isn't defined?  It only defines one data structure in 2.0.x, so
 123  * it shouldn't cause any problems.
 124  */
 125 #ifdef PF_PACKET
 126 # include <linux/if_packet.h>
 127
 128  /*
 129   * On at least some Linux distributions (for example, Red Hat 5.2),
 130   * there's no <netpacket/packet.h> file, but PF_PACKET is defined if
 131   * you include <sys/socket.h>, but <linux/if_packet.h> doesn't define
 132   * any of the PF_PACKET stuff such as "struct sockaddr_ll" or any of
 133   * the PACKET_xxx stuff.
 134   *
 135   * So we check whether PACKET_HOST is defined, and assume that we have
 136   * PF_PACKET sockets only if it is defined.
 137   */
 138 # ifdef PACKET_HOST
 139 #  define HAVE_PF_PACKET_SOCKETS
 140 # endif /* PACKET_HOST */
 141 #endif /* PF_PACKET */
 142
 143 #ifdef SO_ATTACH_FILTER
 144 #include <linux/types.h>
 145 #include <linux/filter.h>
 146 #endif
 147
 148 #ifndef __GLIBC__
 149 typedef int             socklen_t;
 150 #endif
 151
 152 #ifndef MSG_TRUNC
 153 /*
 154  * This is being compiled on a system that lacks MSG_TRUNC; define it
 155  * with the value it has in the 2.2 and later kernels, so that, on
 156  * those kernels, when we pass it in the flags argument to "recvfrom()"
 157  * we're passing the right value and thus get the MSG_TRUNC behavior
 158  * we want.  (We don't get that behavior on 2.0[.x] kernels, because
 159  * they didn't support MSG_TRUNC.)
 160  */
 161 #define MSG_TRUNC       0x20
 162 #endif
 163
 164 #ifndef SOL_PACKET
 165 /*
 166  * This is being compiled on a system that lacks SOL_PACKET; define it
 167  * with the value it has in the 2.2 and later kernels, so that we can
 168  * set promiscuous mode in the good modern way rather than the old
 169  * 2.0-kernel crappy way.
 170  */
 171 #define SOL_PACKET      263
 172 #endif
 173
 174 #define MAX_LINKHEADER_SIZE     256
 175
 176 /*
 177  * When capturing on all interfaces we use this as the buffer size.
 178  * Should be bigger then all MTUs that occur in real life.
 179  * 64kB should be enough for now.
 180  */
 181 #define BIGGER_THAN_ALL_MTUS    (64*1024)
 182
 183 /*
 184  * Prototypes for internal functions
 185  */
 186 static void map_arphrd_to_dlt(pcap_t *, int, int);
 187 static int live_open_old(pcap_t *, const char *, int, int, char *);
 188 static int live_open_new(pcap_t *, const char *, int, int, char *);
 189 static int pcap_read_linux(pcap_t *, int, pcap_handler, u_char *);
 190 static int pcap_read_packet(pcap_t *, pcap_handler, u_char *);
 191 static int pcap_stats_linux(pcap_t *, struct pcap_stat *);
 192 static int pcap_setfilter_linux(pcap_t *, struct bpf_program *);
 193 static void pcap_close_linux(pcap_t *);
 194
 195 /*
 196  * Wrap some ioctl calls
 197  */
 198 #ifdef HAVE_PF_PACKET_SOCKETS
 199 static int      iface_get_id(int fd, const char *device, char *ebuf);
 200 #endif
 201 static int      iface_get_mtu(int fd, const char *device, char *ebuf);
 202 static int      iface_get_arptype(int fd, const char *device, char *ebuf);
 203 #ifdef HAVE_PF_PACKET_SOCKETS
 204 static int      iface_bind(int fd, int ifindex, char *ebuf);
 205 #endif
 206 static int      iface_bind_old(int fd, const char *device, char *ebuf);
 207
 208 #ifdef SO_ATTACH_FILTER
 209 static int      fix_program(pcap_t *handle, struct sock_fprog *fcode);
 210 static int      fix_offset(struct bpf_insn *p);
 211 static int      set_kernel_filter(pcap_t *handle, struct sock_fprog *fcode);
 212 static int      reset_kernel_filter(pcap_t *handle);
 213
 214 static struct sock_filter       total_insn
 215         = BPF_STMT(BPF_RET | BPF_K, 0);
 216 static struct sock_fprog        total_fcode
 217         = { 1, &total_insn };
 218 #endif
 219
 220 /*
 221  *  Get a handle for a live capture from the given device. You can
 222  *  pass NULL as device to get all packages (without link level
 223  *  information of course). If you pass 1 as promisc the interface
 224  *  will be set to promiscous mode (XXX: I think this usage should
 225  *  be deprecated and functions be added to select that later allow
 226  *  modification of that values -- Torsten).
 227  *
 228  *  See also pcap(3).
 229  */
 230 pcap_t *
 231 pcap_open_live(const char *device, int snaplen, int promisc, int to_ms,
 232     char *ebuf)
 233 {
 234         pcap_t          *handle;
 235         int             mtu;
 236         int             err;
 237         int             live_open_ok = 0;
 238         struct utsname  utsname;
 239
 240 #ifdef HAVE_DAG_API
 241         if (strstr(device, "dag")) {
 242                 return dag_open_live(device, snaplen, promisc, to_ms, ebuf);
 243         }
 244 #endif /* HAVE_DAG_API */
 245
 246         /* Allocate a handle for this session. */
 247
 248         handle = malloc(sizeof(*handle));
 249         if (handle == NULL) {
 250                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "malloc: %s",
 251                          pcap_strerror(errno));
 252                 return NULL;
 253         }
 254
 255         /* Initialize some components of the pcap structure. */
 256
 257         memset(handle, 0, sizeof(*handle));
 258         handle->snapshot        = snaplen;
 259         handle->md.timeout      = to_ms;
 260
 261         /*
 262          * NULL and "any" are special devices which give us the hint to
 263          * monitor all devices.
 264          */
 265         if (!device || strcmp(device, "any") == 0) {
 266                 device                  = NULL;
 267                 handle->md.device       = strdup("any");
 268                 if (promisc) {
 269                         promisc = 0;
 270                         /* Just a warning. */
 271                         snprintf(ebuf, PCAP_ERRBUF_SIZE,
 272                             "Promiscuous mode not supported on the \"any\" device");
 273                 }
 274
 275         } else
 276                 handle->md.device       = strdup(device);
 277
 278         if (handle->md.device == NULL) {
 279                 snprintf(ebuf, PCAP_ERRBUF_SIZE, "strdup: %s",
 280                          pcap_strerror(errno) );
 281                 free(handle);
 282                 return NULL;
 283         }
 284
 285         /*
 286          * Current Linux kernels use the protocol family PF_PACKET to
 287          * allow direct access to all packets on the network while
 288          * older kernels had a special socket type SOCK_PACKET to
 289          * implement this feature.
 290          * While this old implementation is kind of obsolete we need
 291          * to be compatible with older kernels for a while so we are
 292          * trying both methods with the newer method preferred.
 293          */
 294
 295         if ((err = live_open_new(handle, device, promisc, to_ms, ebuf)) == 1)
 296                 live_open_ok = 1;
 297         else if (err == 0) {
 298                 /* Non-fatal error; try old way */
 299                 if (live_open_old(handle, device, promisc, to_ms, ebuf))
 300                         live_open_ok = 1;
 301         }
 302         if (!live_open_ok) {
 303                 /*
 304                  * Both methods to open the packet socket failed. Tidy
 305                  * up and report our failure (ebuf is expected to be
 306                  * set by the functions above).
 307                  */
 308
 309                 if (handle->md.device != NULL)
 310                         free(handle->md.device);
 311                 free(handle);
 312                 return NULL;
 313         }
 314
 315         /*
 316          * Compute the buffer size.
 317          *
 318          * If we're using SOCK_PACKET, this might be a 2.0[.x] kernel,
 319          * and might require special handling - check.
 320          */
 321         if (handle->md.sock_packet && (uname(&utsname) < 0 ||
 322             strncmp(utsname.release, "2.0", 3) == 0)) {
 323                 /*
 324                  * We're using a SOCK_PACKET structure, and either
 325                  * we couldn't find out what kernel release this is,
 326                  * or it's a 2.0[.x] kernel.
 327                  *
 328                  * In the 2.0[.x] kernel, a "recvfrom()" on
 329                  * a SOCK_PACKET socket, with MSG_TRUNC set, will
 330                  * return the number of bytes read, so if we pass
 331                  * a length based on the snapshot length, it'll
 332                  * return the number of bytes from the packet
 333                  * copied to userland, not the actual length
 334                  * of the packet.
 335                  *
 336                  * This means that, for example, the IP dissector
 337                  * in tcpdump will get handed a packet length less
 338                  * than the length in the IP header, and will
 339                  * complain about "truncated-ip".
 340                  *
 341                  * So we don't bother trying to copy from the
 342                  * kernel only the bytes in which we're interested,
 343                  * but instead copy them all, just as the older
 344                  * versions of libpcap for Linux did.
 345                  *
 346                  * The buffer therefore needs to be big enough to
 347                  * hold the largest packet we can get from this
 348                  * device.  Unfortunately, we can't get the MRU
 349                  * of the network; we can only get the MTU.  The
 350                  * MTU may be too small, in which case a packet larger
 351                  * than the buffer size will be truncated *and* we
 352                  * won't get the actual packet size.
 353                  *
 354                  * However, if the snapshot length is larger than
 355                  * the buffer size based on the MTU, we use the
 356                  * snapshot length as the buffer size, instead;
 357                  * this means that with a sufficiently large snapshot
 358                  * length we won't artificially truncate packets
 359                  * to the MTU-based size.
 360                  *
 361                  * This mess just one of many problems with packet
 362                  * capture on 2.0[.x] kernels; you really want a
 363                  * 2.2[.x] or later kernel if you want packet capture
 364                  * to work well.
 365                  */
 366                 mtu = iface_get_mtu(handle->fd, device, ebuf);
 367                 if (mtu == -1) {
 368                         pcap_close_linux(handle);
 369                         free(handle);
 370                         return NULL;
 371                 }
 372                 handle->bufsize = MAX_LINKHEADER_SIZE + mtu;
 373                 if (handle->bufsize < handle->snapshot)
 374                         handle->bufsize = handle->snapshot;
 375         } else {
 376                 /*
 377                  * This is a 2.2[.x] or later kernel (we know that
 378                  * either because we're not using a SOCK_PACKET
 379                  * socket - PF_PACKET is supported only in 2.2
 380                  * and later kernels - or because we checked the
 381                  * kernel version).
 382                  *
 383                  * We can safely pass "recvfrom()" a byte count
 384                  * based on the snapshot length.
 385                  */
 386                 handle->bufsize = handle->snapshot;
 387         }
 388
 389         /* Allocate the buffer */
 390
 391         handle->buffer   = malloc(handle->bufsize + handle->offset);
 392         if (!handle->buffer) {
 393                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
 394                          "malloc: %s", pcap_strerror(errno));
 395                 pcap_close_linux(handle);
 396                 free(handle);
 397                 return NULL;
 398         }
 399
 400         /*
 401          * "handle->fd" is a socket, so "select()" and "poll()"
 402          * should work on it.
 403          */
 404         handle->selectable_fd = handle->fd;
 405
 406         handle->read_op = pcap_read_linux;
 407         handle->setfilter_op = pcap_setfilter_linux;
 408         handle->set_datalink_op = NULL; /* can't change data link type */
 409         handle->getnonblock_op = pcap_getnonblock_fd;
 410         handle->setnonblock_op = pcap_setnonblock_fd;
 411         handle->stats_op = pcap_stats_linux;
 412         handle->close_op = pcap_close_linux;
 413
 414         return handle;
 415 }
 416
 417 /*
 418  *  Read at most max_packets from the capture stream and call the callback
 419  *  for each of them. Returns the number of packets handled or -1 if an
 420  *  error occured.
 421  */
 422 static int
 423 pcap_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user)
 424 {
 425         /*
 426          * Currently, on Linux only one packet is delivered per read,
 427          * so we don't loop.
 428          */
 429         return pcap_read_packet(handle, callback, user);
 430 }
 431
 432 /*
 433  *  Read a packet from the socket calling the handler provided by
 434  *  the user. Returns the number of packets received or -1 if an
 435  *  error occured.
 436  */
 437 static int
 438 pcap_read_packet(pcap_t *handle, pcap_handler callback, u_char *userdata)
 439 {
 440         u_char                  *bp;
 441         int                     offset;
 442 #ifdef HAVE_PF_PACKET_SOCKETS
 443         struct sockaddr_ll      from;
 444         struct sll_header       *hdrp;
 445 #else
 446         struct sockaddr         from;
 447 #endif
 448         socklen_t               fromlen;
 449         int                     packet_len, caplen;
 450         struct pcap_pkthdr      pcap_header;
 451
 452 #ifdef HAVE_PF_PACKET_SOCKETS
 453         /*
 454          * If this is a cooked device, leave extra room for a
 455          * fake packet header.
 456          */
 457         if (handle->md.cooked)
 458                 offset = SLL_HDR_LEN;
 459         else
 460                 offset = 0;
 461 #else
 462         /*
 463          * This system doesn't have PF_PACKET sockets, so it doesn't
 464          * support cooked devices.
 465          */
 466         offset = 0;
 467 #endif
 468
 469         /* Receive a single packet from the kernel */
 470
 471         bp = handle->buffer + handle->offset;
 472         do {
 473                 /*
 474                  * Has "pcap_breakloop()" been called?
 475                  */
 476                 if (handle->break_loop) {
 477                         /*
 478                          * Yes - clear the flag that indicates that it
 479                          * has, and return -2 as an indication that we
 480                          * were told to break out of the loop.
 481                          */
 482                         handle->break_loop = 0;
 483                         return -2;
 484                 }
 485                 fromlen = sizeof(from);
 486                 packet_len = recvfrom(
 487                         handle->fd, bp + offset,
 488                         handle->bufsize - offset, MSG_TRUNC,
 489                         (struct sockaddr *) &from, &fromlen);
 490         } while (packet_len == -1 && errno == EINTR);
 491
 492         /* Check if an error occured */
 493
 494         if (packet_len == -1) {
 495                 if (errno == EAGAIN)
 496                         return 0;       /* no packet there */
 497                 else {
 498                         snprintf(handle->errbuf, sizeof(handle->errbuf),
 499                                  "recvfrom: %s", pcap_strerror(errno));
 500                         return -1;
 501                 }
 502         }
 503
 504 #ifdef HAVE_PF_PACKET_SOCKETS
 505         /*
 506          * If this is from the loopback device, reject outgoing packets;
 507          * we'll see the packet as an incoming packet as well, and
 508          * we don't want to see it twice.
 509          *
 510          * We can only do this if we're using PF_PACKET; the address
 511          * returned for SOCK_PACKET is a "sockaddr_pkt" which lacks
 512          * the relevant packet type information.
 513          */
 514         if (!handle->md.sock_packet &&
 515             from.sll_ifindex == handle->md.lo_ifindex &&
 516             from.sll_pkttype == PACKET_OUTGOING)
 517                 return 0;
 518 #endif
 519
 520 #ifdef HAVE_PF_PACKET_SOCKETS
 521         /*
 522          * If this is a cooked device, fill in the fake packet header.
 523          */
 524         if (handle->md.cooked) {
 525                 /*
 526                  * Add the length of the fake header to the length
 527                  * of packet data we read.
 528                  */
 529                 packet_len += SLL_HDR_LEN;
 530
 531                 hdrp = (struct sll_header *)bp;
 532
 533                 /*
 534                  * Map the PACKET_ value to a LINUX_SLL_ value; we
 535                  * want the same numerical value to be used in
 536                  * the link-layer header even if the numerical values
 537                  * for the PACKET_ #defines change, so that programs
 538                  * that look at the packet type field will always be
 539                  * able to handle DLT_LINUX_SLL captures.
 540                  */
 541                 switch (from.sll_pkttype) {
 542
 543                 case PACKET_HOST:
 544                         hdrp->sll_pkttype = htons(LINUX_SLL_HOST);
 545                         break;
 546
 547                 case PACKET_BROADCAST:
 548                         hdrp->sll_pkttype = htons(LINUX_SLL_BROADCAST);
 549                         break;
 550
 551                 case PACKET_MULTICAST:
 552                         hdrp->sll_pkttype = htons(LINUX_SLL_MULTICAST);
 553                         break;
 554
 555                 case PACKET_OTHERHOST:
 556                         hdrp->sll_pkttype = htons(LINUX_SLL_OTHERHOST);
 557                         break;
 558
 559                 case PACKET_OUTGOING:
 560                         hdrp->sll_pkttype = htons(LINUX_SLL_OUTGOING);
 561                         break;
 562
 563                 default:
 564                         hdrp->sll_pkttype = -1;
 565                         break;
 566                 }
 567
 568                 hdrp->sll_hatype = htons(from.sll_hatype);
 569                 hdrp->sll_halen = htons(from.sll_halen);
 570                 memcpy(hdrp->sll_addr, from.sll_addr,
 571                     (from.sll_halen > SLL_ADDRLEN) ?
 572                       SLL_ADDRLEN :
 573                       from.sll_halen);
 574                 hdrp->sll_protocol = from.sll_protocol;
 575         }
 576 #endif
 577
 578         /*
 579          * XXX: According to the kernel source we should get the real
 580          * packet len if calling recvfrom with MSG_TRUNC set. It does
 581          * not seem to work here :(, but it is supported by this code
 582          * anyway.
 583          * To be honest the code RELIES on that feature so this is really
 584          * broken with 2.2.x kernels.
 585          * I spend a day to figure out what's going on and I found out
 586          * that the following is happening:
 587          *
 588          * The packet comes from a random interface and the packet_rcv
 589          * hook is called with a clone of the packet. That code inserts
 590          * the packet into the receive queue of the packet socket.
 591          * If a filter is attached to that socket that filter is run
 592          * first - and there lies the problem. The default filter always
 593          * cuts the packet at the snaplen:
 594          *
 595          * # tcpdump -d
 596          * (000) ret      #68
 597          *
 598          * So the packet filter cuts down the packet. The recvfrom call
 599          * says "hey, it's only 68 bytes, it fits into the buffer" with
 600          * the result that we don't get the real packet length. This
 601          * is valid at least until kernel 2.2.17pre6.
 602          *
 603          * We currently handle this by making a copy of the filter
 604          * program, fixing all "ret" instructions with non-zero
 605          * operands to have an operand of 65535 so that the filter
 606          * doesn't truncate the packet, and supplying that modified
 607          * filter to the kernel.
 608          */
 609
 610         caplen = packet_len;
 611         if (caplen > handle->snapshot)
 612                 caplen = handle->snapshot;
 613
 614         /* Run the packet filter if not using kernel filter */
 615         if (!handle->md.use_bpf && handle->fcode.bf_insns) {
 616                 if (bpf_filter(handle->fcode.bf_insns, bp,
 617                                 packet_len, caplen) == 0)
 618                 {
 619                         /* rejected by filter */
 620                         return 0;
 621                 }
 622         }
 623
 624         /* Fill in our own header data */
 625
 626         if (ioctl(handle->fd, SIOCGSTAMP, &pcap_header.ts) == -1) {
 627                 snprintf(handle->errbuf, sizeof(handle->errbuf),
 628                          "ioctl: %s", pcap_strerror(errno));
 629                 return -1;
 630         }
 631         pcap_header.caplen      = caplen;
 632         pcap_header.len         = packet_len;
 633
 634         /*
 635          * Count the packet.
 636          *
 637          * Arguably, we should count them before we check the filter,
 638          * as on many other platforms "ps_recv" counts packets
 639          * handed to the filter rather than packets that passed
 640          * the filter, but if filtering is done in the kernel, we
 641          * can't get a count of packets that passed the filter,
 642          * and that would mean the meaning of "ps_recv" wouldn't
 643          * be the same on all Linux systems.
 644          *
 645          * XXX - it's not the same on all systems in any case;
 646          * ideally, we should have a "get the statistics" call
 647          * that supplies more counts and indicates which of them
 648          * it supplies, so that we supply a count of packets
 649          * handed to the filter only on platforms where that
 650          * information is available.
 651          *
 652          * We count them here even if we can get the packet count
 653          * from the kernel, as we can only determine at run time
 654          * whether we'll be able to get it from the kernel (if
 655          * HAVE_TPACKET_STATS isn't defined, we can't get it from
 656          * the kernel, but if it is defined, the library might
 657          * have been built with a 2.4 or later kernel, but we
 658          * might be running on a 2.2[.x] kernel without Alexey
 659          * Kuznetzov's turbopacket patches, and thus the kernel
 660          * might not be able to supply those statistics).  We
 661          * could, I guess, try, when opening the socket, to get
 662          * the statistics, and if we can not increment the count
 663          * here, but it's not clear that always incrementing
 664          * the count is more expensive than always testing a flag
 665          * in memory.
 666          */
 667         handle->md.stat.ps_recv++;
 668
 669         /* Call the user supplied callback function */
 670         callback(userdata, &pcap_header, bp);
 671
 672         return 1;
 673 }
 674
 675 /*
 676  *  Get the statistics for the given packet capture handle.
 677  *  Reports the number of dropped packets iff the kernel supports
 678  *  the PACKET_STATISTICS "getsockopt()" argument (2.4 and later
 679  *  kernels, and 2.2[.x] kernels with Alexey Kuznetzov's turbopacket
 680  *  patches); otherwise, that information isn't available, and we lie
 681  *  and report 0 as the count of dropped packets.
 682  */
 683 static int
 684 pcap_stats_linux(pcap_t *handle, struct pcap_stat *stats)
 685 {
 686 #ifdef HAVE_TPACKET_STATS
 687         struct tpacket_stats kstats;
 688         socklen_t len = sizeof (struct tpacket_stats);
 689 #endif
 690
 691 #ifdef HAVE_TPACKET_STATS
 692         /*
 693          * Try to get the packet counts from the kernel.
 694          */
 695         if (getsockopt(handle->fd, SOL_PACKET, PACKET_STATISTICS,
 696                         &kstats, &len) > -1) {
 697                 /*
 698                  * In "linux/net/packet/af_packet.c", at least in the
 699                  * 2.4.9 kernel, "tp_packets" is incremented for every
 700                  * packet that passes the packet filter *and* is
 701                  * successfully queued on the socket; "tp_drops" is
 702                  * incremented for every packet dropped because there's
 703                  * not enough free space in the socket buffer.
 704                  *
 705                  * When the statistics are returned for a PACKET_STATISTICS
 706                  * "getsockopt()" call, "tp_drops" is added to "tp_packets",
 707                  * so that "tp_packets" counts all packets handed to
 708                  * the PF_PACKET socket, including packets dropped because
 709                  * there wasn't room on the socket buffer - but not
 710                  * including packets that didn't pass the filter.
 711                  *
 712                  * In the BSD BPF, the count of received packets is
 713                  * incremented for every packet handed to BPF, regardless
 714                  * of whether it passed the filter.
 715                  *
 716                  * We can't make "pcap_stats()" work the same on both
 717                  * platforms, but the best approximation is to return
 718                  * "tp_packets" as the count of packets and "tp_drops"
 719                  * as the count of drops.
 720                  */
 721                 handle->md.stat.ps_recv = kstats.tp_packets;
 722                 handle->md.stat.ps_drop = kstats.tp_drops;
 723         }
 724         else
 725         {
 726                 /*
 727                  * If the error was EOPNOTSUPP, fall through, so that
 728                  * if you build the library on a system with
 729                  * "struct tpacket_stats" and run it on a system
 730                  * that doesn't, it works as it does if the library
 731                  * is built on a system without "struct tpacket_stats".
 732                  */
 733                 if (errno != EOPNOTSUPP) {
 734                         snprintf(handle->errbuf, PCAP_ERRBUF_SIZE,
 735                             "pcap_stats: %s", pcap_strerror(errno));
 736                         return -1;
 737                 }
 738         }
 739 #endif
 740         /*
 741          * On systems where the PACKET_STATISTICS "getsockopt()" argument
 742          * is supported on PF_PACKET sockets:
 743          *
 744          *      "ps_recv" counts only packets that *passed* the filter,
 745          *      not packets that didn't pass the filter.  This includes
 746          *      packets later dropped because we ran out of buffer space.
 747          *
 748          *      "ps_drop" counts packets dropped because we ran out of
 749          *      buffer space.  It doesn't count packets dropped by the
 750          *      interface driver.  It counts only packets that passed
 751          *      the filter.
 752          *
 753          *      Both statistics include packets not yet read from the
 754          *      kernel by libpcap, and thus not yet seen by the application.
 755          *
 756          * On systems where the PACKET_STATISTICS "getsockopt()" argument
 757          * is not supported on PF_PACKET sockets:
 758          *
 759          *      "ps_recv" counts only packets that *passed* the filter,
 760          *      not packets that didn't pass the filter.  It does not
 761          *      count packets dropped because we ran out of buffer
 762          *      space.
 763          *
 764          *      "ps_drop" is not supported.
 765          *
 766          *      "ps_recv" doesn't include packets not yet read from
 767          *      the kernel by libpcap.
 768          */
 769         *stats = handle->md.stat;
 770         return 0;
 771 }
 772
 773 /*
 774  * Description string for the "any" device.
 775  */
 776 static const char any_descr[] = "Pseudo-device that captures on all interfaces";
 777
 778 int
 779 pcap_platform_finddevs(pcap_if_t **alldevsp, char *errbuf)
 780 {
 781         if (pcap_add_if(alldevsp, "any", 0, any_descr, errbuf) < 0)
 782                 return (-1);
 783
 784 #ifdef HAVE_DAG_API
 785         if (dag_platform_finddevs(alldevsp, errbuf) < 0)
 786                 return (-1);
 787 #endif /* HAVE_DAG_API */
 788
 789         return (0);
 790 }
 791
 792 /*
 793  *  Attach the given BPF code to the packet capture device.
 794  */
 795 static int
 796 pcap_setfilter_linux(pcap_t *handle, struct bpf_program *filter)
 797 {
 798 #ifdef SO_ATTACH_FILTER
 799         struct sock_fprog       fcode;
 800         int                     can_filter_in_kernel;
 801         int                     err = 0;
 802 #endif
 803
 804         if (!handle)
 805                 return -1;
 806         if (!filter) {
 807                 strncpy(handle->errbuf, "setfilter: No filter specified",
 808                         sizeof(handle->errbuf));
 809                 return -1;
 810         }
 811
 812         /* Make our private copy of the filter */
 813
 814         if (install_bpf_program(handle, filter) < 0)
 815                 /* install_bpf_program() filled in errbuf */
 816                 return -1;
 817
 818         /*
 819          * Run user level packet filter by default. Will be overriden if
 820          * installing a kernel filter succeeds.
 821          */
 822         handle->md.use_bpf = 0;
 823
 824         /* Install kernel level filter if possible */
 825
 826 #ifdef SO_ATTACH_FILTER
 827 #ifdef USHRT_MAX
 828         if (handle->fcode.bf_len > USHRT_MAX) {
 829                 /*
 830                  * fcode.len is an unsigned short for current kernel.
 831                  * I have yet to see BPF-Code with that much
 832                  * instructions but still it is possible. So for the
 833                  * sake of correctness I added this check.
 834                  */
 835                 fprintf(stderr, "Warning: Filter too complex for kernel\n");
 836                 fcode.filter = NULL;
 837                 can_filter_in_kernel = 0;
 838         } else
 839 #endif /* USHRT_MAX */
 840         {
 841                 /*
 842                  * Oh joy, the Linux kernel uses struct sock_fprog instead
 843                  * of struct bpf_program and of course the length field is
 844                  * of different size. Pointed out by Sebastian
 845                  *
 846                  * Oh, and we also need to fix it up so that all "ret"
 847                  * instructions with non-zero operands have 65535 as the
 848                  * operand, and so that, if we're in cooked mode, all
 849                  * memory-reference instructions use special magic offsets
 850                  * in references to the link-layer header and assume that
 851                  * the link-layer payload begins at 0; "fix_program()"
 852                  * will do that.
 853                  */
 854                 switch (fix_program(handle, &fcode)) {
 855
 856                 case -1:
 857                 default:
 858                         /*
 859                          * Fatal error; just quit.
 860                          * (The "default" case shouldn't happen; we
 861                          * return -1 for that reason.)
 862                          */
 863                         return -1;
 864
 865                 case 0:
 866                         /*
 867                          * The program performed checks that we can't make
 868                          * work in the kernel.
 869                          */
 870                         can_filter_in_kernel = 0;
 871                         break;
 872
 873                 case 1:
 874                         /*
 875                          * We have a filter that'll work in the kernel.
 876                          */
 877                         can_filter_in_kernel = 1;
 878                         break;
 879                 }
 880         }
 881
 882         if (can_filter_in_kernel) {
 883                 if ((err = set_kernel_filter(handle, &fcode)) == 0)
 884                 {
 885                         /* Installation succeded - using kernel filter. */
 886                         handle->md.use_bpf = 1;
 887                 }
 888                 else if (err == -1)     /* Non-fatal error */
 889                 {
 890                         /*
 891                          * Print a warning if we weren't able to install
 892                          * the filter for a reason other than "this kernel
 893                          * isn't configured to support socket filters.
 894                          */
 895                         if (errno != ENOPROTOOPT && errno != EOPNOTSUPP) {
 896                                 fprintf(stderr,
 897                                     "Warning: Kernel filter failed: %s\n",
 898                                         pcap_strerror(errno));
 899                         }
 900                 }
 901         }
 902
 903         /*
 904          * If we're not using the kernel filter, get rid of any kernel
 905          * filter that might've been there before, e.g. because the
 906          * previous filter could work in the kernel, or because some other
 907          * code attached a filter to the socket by some means other than
 908          * calling "pcap_setfilter()".  Otherwise, the kernel filter may
 909          * filter out packets that would pass the new userland filter.
 910          */
 911         if (!handle->md.use_bpf)
 912                 reset_kernel_filter(handle);
 913
 914         /*
 915          * Free up the copy of the filter that was made by "fix_program()".
 916          */
 917         if (fcode.filter != NULL)
 918                 free(fcode.filter);
 919
 920         if (err == -2)
 921                 /* Fatal error */
 922                 return -1;
 923 #endif /* SO_ATTACH_FILTER */
 924
 925         return 0;
 926 }
 927
 928 /*
 929  *  Linux uses the ARP hardware type to identify the type of an
 930  *  interface. pcap uses the DLT_xxx constants for this. This
 931  *  function takes a pointer to a "pcap_t", and an ARPHRD_xxx
 932  *  constant, as arguments, and sets "handle->linktype" to the
 933  *  appropriate DLT_XXX constant and sets "handle->offset" to
 934  *  the appropriate value (to make "handle->offset" plus link-layer
 935  *  header length be a multiple of 4, so that the link-layer payload
 936  *  will be aligned on a 4-byte boundary when capturing packets).
 937  *  (If the offset isn't set here, it'll be 0; add code as appropriate
 938  *  for cases where it shouldn't be 0.)
 939  *
 940  *  If "cooked_ok" is non-zero, we can use DLT_LINUX_SLL and capture
 941  *  in cooked mode; otherwise, we can't use cooked mode, so we have
 942  *  to pick some type that works in raw mode, or fail.
 943  *
 944  *  Sets the link type to -1 if unable to map the type.
 945  */
 946 static void map_arphrd_to_dlt(pcap_t *handle, int arptype, int cooked_ok)
 947 {
 948         switch (arptype) {
 949
 950         case ARPHRD_ETHER:
 951         case ARPHRD_METRICOM:
 952         case ARPHRD_LOOPBACK:
 953                 handle->linktype = DLT_EN10MB;
 954                 handle->offset = 2;
 955                 break;
 956
 957         case ARPHRD_EETHER:
 958                 handle->linktype = DLT_EN3MB;
 959                 break;
 960
 961         case ARPHRD_AX25:
 962                 handle->linktype = DLT_AX25;
 963                 break;
 964
 965         case ARPHRD_PRONET:
 966                 handle->linktype = DLT_PRONET;
 967                 break;
 968
 969         case ARPHRD_CHAOS:
 970                 handle->linktype = DLT_CHAOS;
 971                 break;
 972
 973 #ifndef ARPHRD_IEEE802_TR
 974 #define ARPHRD_IEEE802_TR 800   /* From Linux 2.4 */
 975 #endif
 976         case ARPHRD_IEEE802_TR:
 977         case ARPHRD_IEEE802:
 978                 handle->linktype = DLT_IEEE802;
 979                 handle->offset = 2;
 980                 break;
 981
 982         case ARPHRD_ARCNET:
 983                 handle->linktype = DLT_ARCNET_LINUX;
 984                 break;
 985
 986 #ifndef ARPHRD_FDDI     /* From Linux 2.2.13 */
 987 #define ARPHRD_FDDI     774
 988 #endif
 989         case ARPHRD_FDDI:
 990                 handle->linktype = DLT_FDDI;
 991                 handle->offset = 3;
 992                 break;
 993
 994 #ifndef ARPHRD_ATM  /* FIXME: How to #include this? */
 995 #define ARPHRD_ATM 19
 996 #endif
 997         case ARPHRD_ATM:
 998                 /*
 999                  * The Classical IP implementation in ATM for Linux
1000                  * supports both what RFC 1483 calls "LLC Encapsulation",
1001                  * in which each packet has an LLC header, possibly
1002                  * with a SNAP header as well, prepended to it, and
1003                  * what RFC 1483 calls "VC Based Multiplexing", in which
1004                  * different virtual circuits carry different network
1005                  * layer protocols, and no header is prepended to packets.
1006                  *
1007                  * They both have an ARPHRD_ type of ARPHRD_ATM, so
1008                  * you can't use the ARPHRD_ type to find out whether
1009                  * captured packets will have an LLC header, and,
1010                  * while there's a socket ioctl to *set* the encapsulation
1011                  * type, there's no ioctl to *get* the encapsulation type.
1012                  *
1013                  * This means that
1014                  *
1015                  *      programs that dissect Linux Classical IP frames
1016                  *      would have to check for an LLC header and,
1017                  *      depending on whether they see one or not, dissect
1018                  *      the frame as LLC-encapsulated or as raw IP (I
1019                  *      don't know whether there's any traffic other than
1020                  *      IP that would show up on the socket, or whether
1021                  *      there's any support for IPv6 in the Linux
1022                  *      Classical IP code);
1023                  *
1024                  *      filter expressions would have to compile into
1025                  *      code that checks for an LLC header and does
1026                  *      the right thing.
1027                  *
1028                  * Both of those are a nuisance - and, at least on systems
1029                  * that support PF_PACKET sockets, we don't have to put
1030                  * up with those nuisances; instead, we can just capture
1031                  * in cooked mode.  That's what we'll do, if we can.
1032                  * Otherwise, we'll just fail.
1033                  */
1034                 if (cooked_ok)
1035                         handle->linktype = DLT_LINUX_SLL;
1036                 else
1037                         handle->linktype = -1;
1038                 break;
1039
1040 #ifndef ARPHRD_IEEE80211  /* From Linux 2.4.6 */
1041 #define ARPHRD_IEEE80211 801
1042 #endif
1043         case ARPHRD_IEEE80211:
1044                 handle->linktype = DLT_IEEE802_11;
1045                 break;
1046
1047 #ifndef ARPHRD_IEEE80211_PRISM  /* From Linux 2.4.18 */
1048 #define ARPHRD_IEEE80211_PRISM 802
1049 #endif
1050         case ARPHRD_IEEE80211_PRISM:
1051                 handle->linktype = DLT_PRISM_HEADER;
1052                 break;
1053
1054         case ARPHRD_PPP:
1055                 /*
1056                  * Some PPP code in the kernel supplies no link-layer
1057                  * header whatsoever to PF_PACKET sockets; other PPP
1058                  * code supplies PPP link-layer headers ("syncppp.c");
1059                  * some PPP code might supply random link-layer
1060                  * headers (PPP over ISDN - there's code in Ethereal,
1061                  * for example, to cope with PPP-over-ISDN captures
1062                  * with which the Ethereal developers have had to cope,
1063                  * heuristically trying to determine which of the
1064                  * oddball link-layer headers particular packets have).
1065                  *
1066                  * As such, we just punt, and run all PPP interfaces
1067                  * in cooked mode, if we can; otherwise, we just treat
1068                  * it as DLT_RAW, for now - if somebody needs to capture,
1069                  * on a 2.0[.x] kernel, on PPP devices that supply a
1070                  * link-layer header, they'll have to add code here to
1071                  * map to the appropriate DLT_ type (possibly adding a
1072                  * new DLT_ type, if necessary).
1073                  */
1074                 if (cooked_ok)
1075                         handle->linktype = DLT_LINUX_SLL;
1076                 else {
1077                         /*
1078                          * XXX - handle ISDN types here?  We can't fall
1079                          * back on cooked sockets, so we'd have to
1080                          * figure out from the device name what type of
1081                          * link-layer encapsulation it's using, and map
1082                          * that to an appropriate DLT_ value, meaning
1083                          * we'd map "isdnN" devices to DLT_RAW (they
1084                          * supply raw IP packets with no link-layer
1085                          * header) and "isdY" devices to a new DLT_I4L_IP
1086                          * type that has only an Ethernet packet type as
1087                          * a link-layer header.
1088                          *
1089                          * But sometimes we seem to get random crap
1090                          * in the link-layer header when capturing on
1091                          * ISDN devices....
1092                          */
1093                         handle->linktype = DLT_RAW;
1094                 }
1095                 break;
1096
1097 #ifndef ARPHRD_CISCO
1098 #define ARPHRD_CISCO 513 /* previously ARPHRD_HDLC */
1099 #endif
1100         case ARPHRD_CISCO:
1101                 handle->linktype = DLT_C_HDLC;
1102                 break;
1103
1104         /* Not sure if this is correct for all tunnels, but it
1105          * works for CIPE */
1106         case ARPHRD_TUNNEL:
1107 #ifndef ARPHRD_SIT
1108 #define ARPHRD_SIT 776  /* From Linux 2.2.13 */
1109 #endif
1110         case ARPHRD_SIT:
1111         case ARPHRD_CSLIP:
1112         case ARPHRD_SLIP6:
1113         case ARPHRD_CSLIP6:
1114         case ARPHRD_ADAPT:
1115         case ARPHRD_SLIP:
1116 #ifndef ARPHRD_RAWHDLC
1117 #define ARPHRD_RAWHDLC 518
1118 #endif
1119         case ARPHRD_RAWHDLC:
1120 #ifndef ARPHRD_DLCI
1121 #define ARPHRD_DLCI 15
1122 #endif
1123         case ARPHRD_DLCI:
1124                 /*
1125                  * XXX - should some of those be mapped to DLT_LINUX_SLL
1126                  * instead?  Should we just map all of them to DLT_LINUX_SLL?
1127                  */
1128                 handle->linktype = DLT_RAW;
1129                 break;
1130
1131 #ifndef ARPHRD_FRAD
1132 #define ARPHRD_FRAD 770
1133 #endif
1134         case ARPHRD_FRAD:
1135                 handle->linktype = DLT_FRELAY;
1136                 break;
1137
1138         case ARPHRD_LOCALTLK:
1139                 handle->linktype = DLT_LTALK;
1140                 break;
1141
1142 #ifndef ARPHRD_FCPP
1143 #define ARPHRD_FCPP     784
1144 #endif
1145         case ARPHRD_FCPP:
1146 #ifndef ARPHRD_FCAL
1147 #define ARPHRD_FCAL     785
1148 #endif
1149         case ARPHRD_FCAL:
1150 #ifndef ARPHRD_FCPL
1151 #define ARPHRD_FCPL     786
1152 #endif
1153         case ARPHRD_FCPL:
1154 #ifndef ARPHRD_FCFABRIC
1155 #define ARPHRD_FCFABRIC 787
1156 #endif
1157         case ARPHRD_FCFABRIC:
1158                 /*
1159                  * We assume that those all mean RFC 2625 IP-over-
1160                  * Fibre Channel, with the RFC 2625 header at
1161                  * the beginning of the packet.
1162                  */
1163                 handle->linktype = DLT_IP_OVER_FC;
1164                 break;
1165
1166         case ARPHRD_IRDA:
1167                 /* Don't expect IP packet out of this interfaces... */
1168                 handle->linktype = DLT_LINUX_IRDA;
1169                 /* We need to save packet direction for IrDA decoding,
1170                  * so let's use "Linux-cooked" mode. Jean II */
1171                 //handle->md.cooked = 1;
1172                 break;
1173
1174         default:
1175                 handle->linktype = -1;
1176                 break;
1177         }
1178 }
1179
1180 /* ===== Functions to interface to the newer kernels ================== */
1181
1182 /*
1183  *  Try to open a packet socket using the new kernel interface.
1184  *  Returns 0 on failure.
1185  *  FIXME: 0 uses to mean success (Sebastian)
1186  */
1187 static int
1188 live_open_new(pcap_t *handle, const char *device, int promisc,
1189               int to_ms, char *ebuf)
1190 {
1191 #ifdef HAVE_PF_PACKET_SOCKETS
1192         int                     sock_fd = -1, device_id, arptype;
1193         int                     err;
1194         int                     fatal_err = 0;
1195         struct packet_mreq      mr;
1196
1197         /* One shot loop used for error handling - bail out with break */
1198
1199         do {
1200                 /*
1201                  * Open a socket with protocol family packet. If a device is
1202                  * given we try to open it in raw mode otherwise we use
1203                  * the cooked interface.
1204                  */
1205                 sock_fd = device ?
1206                         socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL))
1207                       : socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL));
1208
1209                 if (sock_fd == -1) {
1210                         snprintf(ebuf, PCAP_ERRBUF_SIZE, "socket: %s",
1211                                  pcap_strerror(errno) );
1212                         break;
1213                 }
1214
1215                 /* It seems the kernel supports the new interface. */
1216                 handle->md.sock_packet = 0;
1217
1218                 /*
1219                  * Get the interface index of the loopback device.
1220                  * If the attempt fails, don't fail, just set the
1221                  * "md.lo_ifindex" to -1.
1222                  *
1223                  * XXX - can there be more than one device that loops
1224                  * packets back, i.e. devices other than "lo"?  If so,
1225                  * we'd need to find them all, and have an array of
1226                  * indices for them, and check all of them in
1227                  * "pcap_read_packet()".
1228                  */
1229                 handle->md.lo_ifindex = iface_get_id(sock_fd, "lo", ebuf);
1230
1231                 /*
1232                  * Default value for offset to align link-layer payload
1233                  * on a 4-byte boundary.
1234                  */
1235                 handle->offset   = 0;
1236
1237                 /*
1238                  * What kind of frames do we have to deal with? Fall back
1239                  * to cooked mode if we have an unknown interface type.
1240                  */
1241
1242                 if (device) {
1243                         /* Assume for now we don't need cooked mode. */
1244                         handle->md.cooked = 0;
1245
1246                         arptype = iface_get_arptype(sock_fd, device, ebuf);
1247                         if (arptype == -1) {
1248                                 fatal_err = 1;
1249                                 break;
1250                         }
1251                         map_arphrd_to_dlt(handle, arptype, 1);
1252                         if (handle->linktype == -1 ||
1253                             handle->linktype == DLT_LINUX_SLL ||
1254                             handle->linktype == DLT_LINUX_IRDA ||
1255                             (handle->linktype == DLT_EN10MB &&
1256                              (strncmp("isdn", device, 4) == 0 ||
1257                               strncmp("isdY", device, 4) == 0))) {
1258                                 /*
1259                                  * Unknown interface type (-1), or a
1260                                  * device we explicitly chose to run
1261                                  * in cooked mode (e.g., PPP devices),
1262                                  * or an ISDN device (whose link-layer
1263                                  * type we can only determine by using
1264                                  * APIs that may be different on different
1265                                  * kernels) - reopen in cooked mode.
1266                                  */
1267                                 if (close(sock_fd) == -1) {
1268                                         snprintf(ebuf, PCAP_ERRBUF_SIZE,
1269                                                  "close: %s", pcap_strerror(errno));
1270                                         break;
1271                                 }
1272                                 sock_fd = socket(PF_PACKET, SOCK_DGRAM,
1273                                                  htons(ETH_P_ALL));
1274                                 if (sock_fd == -1) {
1275                                         snprintf(ebuf, PCAP_ERRBUF_SIZE,
1276                                                  "socket: %s", pcap_strerror(errno));
1277                                         break;
1278                                 }
1279                                 handle->md.cooked = 1;
1280
1281                                 if (handle->linktype == -1) {
1282                                         /*
1283                                          * Warn that we're falling back on
1284                                          * cooked mode; we may want to
1285                                          * update "map_arphrd_to_dlt()"
1286                                          * to handle the new type.
1287                                          */
1288                                         snprintf(ebuf, PCAP_ERRBUF_SIZE,
1289                                                 "arptype %d not "
1290                                                 "supported by libpcap - "
1291                                                 "falling back to cooked "
1292                                                 "socket",
1293                                                 arptype);
1294                                 }
1295                                 /* IrDA capture is not a real "cooked" capture,
1296                                  * it's IrLAP frames, not IP packets. */
1297                                 if(handle->linktype != DLT_LINUX_IRDA)
1298                                         handle->linktype = DLT_LINUX_SLL;
1299                         }
1300
1301                         device_id = iface_get_id(sock_fd, device, ebuf);
1302                         if (device_id == -1)
1303                                 break;
1304
1305                         if ((err = iface_bind(sock_fd, device_id, ebuf)) < 0) {
1306                                 if (err == -2)
1307                                         fatal_err = 1;
1308                                 break;
1309                         }
1310                 } else {
1311                         /*
1312                          * This is cooked mode.
1313                          */
1314                         handle->md.cooked = 1;
1315                         handle->linktype = DLT_LINUX_SLL;
1316
1317                         /*
1318                          * XXX - squelch GCC complaints about
1319                          * uninitialized variables; if we can't
1320                          * select promiscuous mode on all interfaces,
1321                          * we should move the code below into the
1322                          * "if (device)" branch of the "if" and
1323                          * get rid of the next statement.
1324                          */
1325                         device_id = -1;
1326                 }
1327
1328                 /*
1329                  * Select promiscuous mode on if "promisc" is set.
1330                  *
1331                  * Do not turn allmulti mode on if we don't select
1332                  * promiscuous mode - on some devices (e.g., Orinoco
1333                  * wireless interfaces), allmulti mode isn't supported
1334                  * and the driver implements it by turning promiscuous
1335                  * mode on, and that screws up the operation of the
1336                  * card as a normal networking interface, and on no
1337                  * other platform I know of does starting a non-
1338                  * promiscuous capture affect which multicast packets
1339                  * are received by the interface.
1340                  */
1341
1342                 /*
1343                  * Hmm, how can we set promiscuous mode on all interfaces?
1344                  * I am not sure if that is possible at all.
1345                  */
1346
1347                 if (device && promisc) {
1348                         memset(&mr, 0, sizeof(mr));
1349                         mr.mr_ifindex = device_id;
1350                         mr.mr_type    = PACKET_MR_PROMISC;
1351                         if (setsockopt(sock_fd, SOL_PACKET,
1352                                 PACKET_ADD_MEMBERSHIP, &mr, sizeof(mr)) == -1)
1353                         {
1354                                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
1355                                         "setsockopt: %s", pcap_strerror(errno));
1356                                 break;
1357                         }
1358                 }
1359
1360                 /* Save the socket FD in the pcap structure */
1361
1362                 handle->fd       = sock_fd;
1363
1364                 return 1;
1365
1366         } while(0);
1367
1368         if (sock_fd != -1)
1369                 close(sock_fd);
1370
1371         if (fatal_err)
1372                 return -2;
1373         else
1374                 return 0;
1375 #else
1376         strncpy(ebuf,
1377                 "New packet capturing interface not supported by build "
1378                 "environment", PCAP_ERRBUF_SIZE);
1379         return 0;
1380 #endif
1381 }
1382
1383 #ifdef HAVE_PF_PACKET_SOCKETS
1384 /*
1385  *  Return the index of the given device name. Fill ebuf and return
1386  *  -1 on failure.
1387  */
1388 static int
1389 iface_get_id(int fd, const char *device, char *ebuf)
1390 {
1391         struct ifreq    ifr;
1392
1393         memset(&ifr, 0, sizeof(ifr));
1394         strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
1395
1396         if (ioctl(fd, SIOCGIFINDEX, &ifr) == -1) {
1397                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
1398                          "ioctl: %s", pcap_strerror(errno));
1399                 return -1;
1400         }
1401
1402         return ifr.ifr_ifindex;
1403 }
1404
1405 /*
1406  *  Bind the socket associated with FD to the given device.
1407  */
1408 static int
1409 iface_bind(int fd, int ifindex, char *ebuf)
1410 {
1411         struct sockaddr_ll      sll;
1412         int                     err;
1413         socklen_t               errlen = sizeof(err);
1414
1415         memset(&sll, 0, sizeof(sll));
1416         sll.sll_family          = AF_PACKET;
1417         sll.sll_ifindex         = ifindex;
1418         sll.sll_protocol        = htons(ETH_P_ALL);
1419
1420         if (bind(fd, (struct sockaddr *) &sll, sizeof(sll)) == -1) {
1421                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
1422                          "bind: %s", pcap_strerror(errno));
1423                 return -1;
1424         }
1425
1426         /* Any pending errors, e.g., network is down? */
1427
1428         if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {
1429                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
1430                         "getsockopt: %s", pcap_strerror(errno));
1431                 return -2;
1432         }
1433
1434         if (err > 0) {
1435                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
1436                         "bind: %s", pcap_strerror(err));
1437                 return -2;
1438         }
1439
1440         return 0;
1441 }
1442
1443 #endif
1444
1445
1446 /* ===== Functions to interface to the older kernels ================== */
1447
1448 /*
1449  * With older kernels promiscuous mode is kind of interesting because we
1450  * have to reset the interface before exiting. The problem can't really
1451  * be solved without some daemon taking care of managing usage counts.
1452  * If we put the interface into promiscuous mode, we set a flag indicating
1453  * that we must take it out of that mode when the interface is closed,
1454  * and, when closing the interface, if that flag is set we take it out
1455  * of promiscuous mode.
1456  */
1457
1458 /*
1459  * List of pcaps for which we turned promiscuous mode on by hand.
1460  * If there are any such pcaps, we arrange to call "pcap_close_all()"
1461  * when we exit, and have it close all of them to turn promiscuous mode
1462  * off.
1463  */
1464 static struct pcap *pcaps_to_close;
1465
1466 /*
1467  * TRUE if we've already called "atexit()" to cause "pcap_close_all()" to
1468  * be called on exit.
1469  */
1470 static int did_atexit;
1471
1472 static void     pcap_close_all(void)
1473 {
1474         struct pcap *handle;
1475
1476         while ((handle = pcaps_to_close) != NULL)
1477                 pcap_close(handle);
1478 }
1479
1480 static void     pcap_close_linux( pcap_t *handle )
1481 {
1482         struct pcap     *p, *prevp;
1483         struct ifreq    ifr;
1484
1485         if (handle->md.clear_promisc) {
1486                 /*
1487                  * We put the interface into promiscuous mode; take
1488                  * it out of promiscuous mode.
1489                  *
1490                  * XXX - if somebody else wants it in promiscuous mode,
1491                  * this code cannot know that, so it'll take it out
1492                  * of promiscuous mode.  That's not fixable in 2.0[.x]
1493                  * kernels.
1494                  */
1495                 memset(&ifr, 0, sizeof(ifr));
1496                 strncpy(ifr.ifr_name, handle->md.device, sizeof(ifr.ifr_name));
1497                 if (ioctl(handle->fd, SIOCGIFFLAGS, &ifr) == -1) {
1498                         fprintf(stderr,
1499                             "Can't restore interface flags (SIOCGIFFLAGS failed: %s).\n"
1500                             "Please adjust manually.\n"
1501                             "Hint: This can't happen with Linux >= 2.2.0.\n",
1502                             strerror(errno));
1503                 } else {
1504                         if (ifr.ifr_flags & IFF_PROMISC) {
1505                                 /*
1506                                  * Promiscuous mode is currently on; turn it
1507                                  * off.
1508                                  */
1509                                 ifr.ifr_flags &= ~IFF_PROMISC;
1510                                 if (ioctl(handle->fd, SIOCSIFFLAGS, &ifr) == -1) {
1511                                         fprintf(stderr,
1512                                             "Can't restore interface flags (SIOCSIFFLAGS failed: %s).\n"
1513                                             "Please adjust manually.\n"
1514                                             "Hint: This can't happen with Linux >= 2.2.0.\n",
1515                                             strerror(errno));
1516                                 }
1517                         }
1518                 }
1519
1520                 /*
1521                  * Take this pcap out of the list of pcaps for which we
1522                  * have to take the interface out of promiscuous mode.
1523                  */
1524                 for (p = pcaps_to_close, prevp = NULL; p != NULL;
1525                     prevp = p, p = p->md.next) {
1526                         if (p == handle) {
1527                                 /*
1528                                  * Found it.  Remove it from the list.
1529                                  */
1530                                 if (prevp == NULL) {
1531                                         /*
1532                                          * It was at the head of the list.
1533                                          */
1534                                         pcaps_to_close = p->md.next;
1535                                 } else {
1536                                         /*
1537                                          * It was in the middle of the list.
1538                                          */
1539                                         prevp->md.next = p->md.next;
1540                                 }
1541                                 break;
1542                         }
1543                 }
1544         }
1545
1546         if (handle->md.device != NULL)
1547                 free(handle->md.device);
1548         handle->md.device = NULL;
1549         if (handle->buffer != NULL)
1550                 free(handle->buffer);
1551         if (handle->fd >= 0)
1552                 close(handle->fd);
1553 }
1554
1555 /*
1556  *  Try to open a packet socket using the old kernel interface.
1557  *  Returns 0 on failure.
1558  *  FIXME: 0 uses to mean success (Sebastian)
1559  */
1560 static int
1561 live_open_old(pcap_t *handle, const char *device, int promisc,
1562               int to_ms, char *ebuf)
1563 {
1564         int             arptype;
1565         struct ifreq    ifr;
1566
1567         do {
1568                 /* Open the socket */
1569
1570                 handle->fd = socket(PF_INET, SOCK_PACKET, htons(ETH_P_ALL));
1571                 if (handle->fd == -1) {
1572                         snprintf(ebuf, PCAP_ERRBUF_SIZE,
1573                                  "socket: %s", pcap_strerror(errno));
1574                         break;
1575                 }
1576
1577                 /* It worked - we are using the old interface */
1578                 handle->md.sock_packet = 1;
1579
1580                 /* ...which means we get the link-layer header. */
1581                 handle->md.cooked = 0;
1582
1583                 /* Bind to the given device */
1584
1585                 if (!device) {
1586                         strncpy(ebuf, "pcap_open_live: The \"any\" device isn't supported on 2.0[.x]-kernel systems",
1587                                 PCAP_ERRBUF_SIZE);
1588                         break;
1589                 }
1590                 if (iface_bind_old(handle->fd, device, ebuf) == -1)
1591                         break;
1592
1593                 /*
1594                  * Try to get the link-layer type.
1595                  */
1596                 arptype = iface_get_arptype(handle->fd, device, ebuf);
1597                 if (arptype == -1)
1598                         break;
1599
1600                 /*
1601                  * Try to find the DLT_ type corresponding to that
1602                  * link-layer type.
1603                  */
1604                 map_arphrd_to_dlt(handle, arptype, 0);
1605                 if (handle->linktype == -1) {
1606                         snprintf(ebuf, PCAP_ERRBUF_SIZE,
1607                                  "unknown arptype %d", arptype);
1608                         break;
1609                 }
1610
1611                 /* Go to promisc mode if requested */
1612
1613                 if (promisc) {
1614                         memset(&ifr, 0, sizeof(ifr));
1615                         strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
1616                         if (ioctl(handle->fd, SIOCGIFFLAGS, &ifr) == -1) {
1617                                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
1618                                          "ioctl: %s", pcap_strerror(errno));
1619                                 break;
1620                         }
1621                         if ((ifr.ifr_flags & IFF_PROMISC) == 0) {
1622                                 /*
1623                                  * Promiscuous mode isn't currently on,
1624                                  * so turn it on, and remember that
1625                                  * we should turn it off when the
1626                                  * pcap_t is closed.
1627                                  */
1628
1629                                 /*
1630                                  * If we haven't already done so, arrange
1631                                  * to have "pcap_close_all()" called when
1632                                  * we exit.
1633                                  */
1634                                 if (!did_atexit) {
1635                                         if (atexit(pcap_close_all) == -1) {
1636                                                 /*
1637                                                  * "atexit()" failed; don't
1638                                                  * put the interface in
1639                                                  * promiscuous mode, just
1640                                                  * give up.
1641                                                  */
1642                                                 strncpy(ebuf, "atexit failed",
1643                                                         PCAP_ERRBUF_SIZE);
1644                                                 break;
1645                                         }
1646                                         did_atexit = 1;
1647                                 }
1648
1649                                 ifr.ifr_flags |= IFF_PROMISC;
1650                                 if (ioctl(handle->fd, SIOCSIFFLAGS, &ifr) == -1) {
1651                                         snprintf(ebuf, PCAP_ERRBUF_SIZE,
1652                                                  "ioctl: %s",
1653                                                  pcap_strerror(errno));
1654                                         break;
1655                                 }
1656                                 handle->md.clear_promisc = 1;
1657
1658                                 /*
1659                                  * Add this to the list of pcaps
1660                                  * to close when we exit.
1661                                  */
1662                                 handle->md.next = pcaps_to_close;
1663                                 pcaps_to_close = handle;
1664                         }
1665                 }
1666
1667                 /*
1668                  * Default value for offset to align link-layer payload
1669                  * on a 4-byte boundary.
1670                  */
1671                 handle->offset   = 0;
1672
1673                 return 1;
1674
1675         } while (0);
1676
1677         pcap_close_linux(handle);
1678         return 0;
1679 }
1680
1681 /*
1682  *  Bind the socket associated with FD to the given device using the
1683  *  interface of the old kernels.
1684  */
1685 static int
1686 iface_bind_old(int fd, const char *device, char *ebuf)
1687 {
1688         struct sockaddr saddr;
1689         int             err;
1690         socklen_t       errlen = sizeof(err);
1691
1692         memset(&saddr, 0, sizeof(saddr));
1693         strncpy(saddr.sa_data, device, sizeof(saddr.sa_data));
1694         if (bind(fd, &saddr, sizeof(saddr)) == -1) {
1695                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
1696                          "bind: %s", pcap_strerror(errno));
1697                 return -1;
1698         }
1699
1700         /* Any pending errors, e.g., network is down? */
1701
1702         if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &errlen) == -1) {
1703                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
1704                         "getsockopt: %s", pcap_strerror(errno));
1705                 return -1;
1706         }
1707
1708         if (err > 0) {
1709                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
1710                         "bind: %s", pcap_strerror(err));
1711                 return -1;
1712         }
1713
1714         return 0;
1715 }
1716
1717
1718 /* ===== System calls available on all supported kernels ============== */
1719
1720 /*
1721  *  Query the kernel for the MTU of the given interface.
1722  */
1723 static int
1724 iface_get_mtu(int fd, const char *device, char *ebuf)
1725 {
1726         struct ifreq    ifr;
1727
1728         if (!device)
1729                 return BIGGER_THAN_ALL_MTUS;
1730
1731         memset(&ifr, 0, sizeof(ifr));
1732         strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
1733
1734         if (ioctl(fd, SIOCGIFMTU, &ifr) == -1) {
1735                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
1736                          "ioctl: %s", pcap_strerror(errno));
1737                 return -1;
1738         }
1739
1740         return ifr.ifr_mtu;
1741 }
1742
1743 /*
1744  *  Get the hardware type of the given interface as ARPHRD_xxx constant.
1745  */
1746 static int
1747 iface_get_arptype(int fd, const char *device, char *ebuf)
1748 {
1749         struct ifreq    ifr;
1750
1751         memset(&ifr, 0, sizeof(ifr));
1752         strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
1753
1754         if (ioctl(fd, SIOCGIFHWADDR, &ifr) == -1) {
1755                 snprintf(ebuf, PCAP_ERRBUF_SIZE,
1756                          "ioctl: %s", pcap_strerror(errno));
1757                 return -1;
1758         }
1759
1760         return ifr.ifr_hwaddr.sa_family;
1761 }
1762
1763 #ifdef SO_ATTACH_FILTER
1764 static int
1765 fix_program(pcap_t *handle, struct sock_fprog *fcode)
1766 {
1767         size_t prog_size;
1768         register int i;
1769         register struct bpf_insn *p;
1770         struct bpf_insn *f;
1771         int len;
1772
1773         /*
1774          * Make a copy of the filter, and modify that copy if
1775          * necessary.
1776          */
1777         prog_size = sizeof(*handle->fcode.bf_insns) * handle->fcode.bf_len;
1778         len = handle->fcode.bf_len;
1779         f = (struct bpf_insn *)malloc(prog_size);
1780         if (f == NULL) {
1781                 snprintf(handle->errbuf, sizeof(handle->errbuf),
1782                          "malloc: %s", pcap_strerror(errno));
1783                 return -1;
1784         }
1785         memcpy(f, handle->fcode.bf_insns, prog_size);
1786         fcode->len = len;
1787         fcode->filter = (struct sock_filter *) f;
1788
1789         for (i = 0; i < len; ++i) {
1790                 p = &f[i];
1791                 /*
1792                  * What type of instruction is this?
1793                  */
1794                 switch (BPF_CLASS(p->code)) {
1795
1796                 case BPF_RET:
1797                         /*
1798                          * It's a return instruction; is the snapshot
1799                          * length a constant, rather than the contents
1800                          * of the accumulator?
1801                          */
1802                         if (BPF_MODE(p->code) == BPF_K) {
1803                                 /*
1804                                  * Yes - if the value to be returned,
1805                                  * i.e. the snapshot length, is anything
1806                                  * other than 0, make it 65535, so that
1807                                  * the packet is truncated by "recvfrom()",
1808                                  * not by the filter.
1809                                  *
1810                                  * XXX - there's nothing we can easily do
1811                                  * if it's getting the value from the
1812                                  * accumulator; we'd have to insert
1813                                  * code to force non-zero values to be
1814                                  * 65535.
1815                                  */
1816                                 if (p->k != 0)
1817                                         p->k = 65535;
1818                         }
1819                         break;
1820
1821                 case BPF_LD:
1822                 case BPF_LDX:
1823                         /*
1824                          * It's a load instruction; is it loading
1825                          * from the packet?
1826                          */
1827                         switch (BPF_MODE(p->code)) {
1828
1829                         case BPF_ABS:
1830                         case BPF_IND:
1831                         case BPF_MSH:
1832                                 /*
1833                                  * Yes; are we in cooked mode?
1834                                  */
1835                                 if (handle->md.cooked) {
1836                                         /*
1837                                          * Yes, so we need to fix this
1838                                          * instruction.
1839                                          */
1840                                         if (fix_offset(p) < 0) {
1841                                                 /*
1842                                                  * We failed to do so.
1843                                                  * Return 0, so our caller
1844                                                  * knows to punt to userland.
1845                                                  */
1846                                                 return 0;
1847                                         }
1848                                 }
1849                                 break;
1850                         }
1851                         break;
1852                 }
1853         }
1854         return 1;       /* we succeeded */
1855 }
1856
1857 static int
1858 fix_offset(struct bpf_insn *p)
1859 {
1860         /*
1861          * What's the offset?
1862          */
1863         if (p->k >= SLL_HDR_LEN) {
1864                 /*
1865                  * It's within the link-layer payload; that starts at an
1866                  * offset of 0, as far as the kernel packet filter is
1867                  * concerned, so subtract the length of the link-layer
1868                  * header.
1869                  */
1870                 p->k -= SLL_HDR_LEN;
1871         } else if (p->k == 14) {
1872                 /*
1873                  * It's the protocol field; map it to the special magic
1874                  * kernel offset for that field.
1875                  */
1876                 p->k = SKF_AD_OFF + SKF_AD_PROTOCOL;
1877         } else {
1878                 /*
1879                  * It's within the header, but it's not one of those
1880                  * fields; we can't do that in the kernel, so punt
1881                  * to userland.
1882                  */
1883                 return -1;
1884         }
1885         return 0;
1886 }
1887
1888 static int
1889 set_kernel_filter(pcap_t *handle, struct sock_fprog *fcode)
1890 {
1891         int total_filter_on = 0;
1892         int save_mode;
1893         int ret;
1894         int save_errno;
1895
1896         /*
1897          * The socket filter code doesn't discard all packets queued
1898          * up on the socket when the filter is changed; this means
1899          * that packets that don't match the new filter may show up
1900          * after the new filter is put onto the socket, if those
1901          * packets haven't yet been read.
1902          *
1903          * This means, for example, that if you do a tcpdump capture
1904          * with a filter, the first few packets in the capture might
1905          * be packets that wouldn't have passed the filter.
1906          *
1907          * We therefore discard all packets queued up on the socket
1908          * when setting a kernel filter.  (This isn't an issue for
1909          * userland filters, as the userland filtering is done after
1910          * packets are queued up.)
1911          *
1912          * To flush those packets, we put the socket in read-only mode,
1913          * and read packets from the socket until there are no more to
1914          * read.
1915          *
1916          * In order to keep that from being an infinite loop - i.e.,
1917          * to keep more packets from arriving while we're draining
1918          * the queue - we put the "total filter", which is a filter
1919          * that rejects all packets, onto the socket before draining
1920          * the queue.
1921          *
1922          * This code deliberately ignores any errors, so that you may
1923          * get bogus packets if an error occurs, rather than having
1924          * the filtering done in userland even if it could have been
1925          * done in the kernel.
1926          */
1927         if (setsockopt(handle->fd, SOL_SOCKET, SO_ATTACH_FILTER,
1928                        &total_fcode, sizeof(total_fcode)) == 0) {
1929                 char drain[1];
1930
1931                 /*
1932                  * Note that we've put the total filter onto the socket.
1933                  */
1934                 total_filter_on = 1;
1935
1936                 /*
1937                  * Save the socket's current mode, and put it in
1938                  * non-blocking mode; we drain it by reading packets
1939                  * until we get an error (which is normally a
1940                  * "nothing more to be read" error).
1941                  */
1942                 save_mode = fcntl(handle->fd, F_GETFL, 0);
1943                 if (save_mode != -1 &&
1944                     fcntl(handle->fd, F_SETFL, save_mode | O_NONBLOCK) >= 0) {
1945                         while (recv(handle->fd, &drain, sizeof drain,
1946                                MSG_TRUNC) >= 0)
1947                                 ;
1948                         save_errno = errno;
1949                         fcntl(handle->fd, F_SETFL, save_mode);
1950                         if (save_errno != EAGAIN) {
1951                                 /* Fatal error */
1952                                 reset_kernel_filter(handle);
1953                                 snprintf(handle->errbuf, sizeof(handle->errbuf),
1954                                  "recv: %s", pcap_strerror(save_errno));
1955                                 return -2;
1956                         }
1957                 }
1958         }
1959
1960         /*
1961          * Now attach the new filter.
1962          */
1963         ret = setsockopt(handle->fd, SOL_SOCKET, SO_ATTACH_FILTER,
1964                          fcode, sizeof(*fcode));
1965         if (ret == -1 && total_filter_on) {
1966                 /*
1967                  * Well, we couldn't set that filter on the socket,
1968                  * but we could set the total filter on the socket.
1969                  *
1970                  * This could, for example, mean that the filter was
1971                  * too big to put into the kernel, so we'll have to
1972                  * filter in userland; in any case, we'll be doing
1973                  * filtering in userland, so we need to remove the
1974                  * total filter so we see packets.
1975                  */
1976                 save_errno = errno;
1977
1978                 /*
1979                  * XXX - if this fails, we're really screwed;
1980                  * we have the total filter on the socket,
1981                  * and it won't come off.  What do we do then?
1982                  */
1983                 reset_kernel_filter(handle);
1984
1985                 errno = save_errno;
1986         }
1987         return ret;
1988 }
1989
1990 static int
1991 reset_kernel_filter(pcap_t *handle)
1992 {
1993         /* setsockopt() barfs unless it get a dummy parameter */
1994         int dummy;
1995
1996         return setsockopt(handle->fd, SOL_SOCKET, SO_DETACH_FILTER,
1997                                    &dummy, sizeof(dummy));
1998 }
1999 #endif