--- tcpdump-3.8.1/tcpdump.c.orig        2003-12-18 01:22:57.000000000 +0000
+++ tcpdump-3.8.1/tcpdump.c     2004-03-16 00:30:15.000000000 +0000
@@ -61,6 +61,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <errno.h>
 
 #include "interface.h"
 #include "addrtoname.h"
@@ -107,7 +108,7 @@
 /* Forwards */
 static RETSIGTYPE cleanup(int);
 static void usage(void) __attribute__((noreturn));
-static void show_dlts_and_exit(pcap_t *pd) __attribute__((noreturn));
+static void show_dlts_and_exit(char **devnames) __attribute__((noreturn));
 
 static void print_packet(u_char *, const struct pcap_pkthdr *, const u_char *);
 static void dump_packet_and_trunc(u_char *, const struct pcap_pkthdr *, const u_char *);
@@ -222,7 +223,8 @@
        /* NOTREACHED */
 }
 
-static pcap_t *pd;
+static pcap_t **pd;
+static int    nrdev;
 
 extern int optind;
 extern int opterr;
@@ -239,38 +241,41 @@
 };
 
 static void
-show_dlts_and_exit(pcap_t *pd)
+show_dlts_and_exit(char **devnames)
 {
        int n_dlts;
        int *dlts = 0;
        const char *dlt_name;
-
-       n_dlts = pcap_list_datalinks(pd, &dlts);
-       if (n_dlts < 0)
-               error("%s", pcap_geterr(pd));
-       else if (n_dlts == 0 || !dlts)
-               error("No data link types.");
-
-       (void) fprintf(stderr, "Data link types (use option -y to set):\n");
-
-       while (--n_dlts >= 0) {
-               dlt_name = pcap_datalink_val_to_name(dlts[n_dlts]);
-               if (dlt_name != NULL) {
-                       (void) fprintf(stderr, "  %s (%s)", dlt_name,
-                           pcap_datalink_val_to_description(dlts[n_dlts]));
-
-                       /*
-                        * OK, does tcpdump handle that type?
-                        */
-                       if (lookup_printer(dlts[n_dlts]) == NULL)
-                               (void) fprintf(stderr, " (not supported)");
-                       putchar('\n');
-               } else {
-                       (void) fprintf(stderr, "  DLT %d (not supported)\n",
-                           dlts[n_dlts]);
+       int i;
+       
+       for(i=0; i<nrdev; i++) {
+               n_dlts = pcap_list_datalinks(pd[i], &dlts);
+               if (n_dlts < 0)
+                       error("%s: %s", devnames[i], pcap_geterr(pd[i]));
+               else if (n_dlts == 0 || !dlts)
+                       error("%s: No data link types.", devnames[i]);
+
+               (void) fprintf(stderr, "%s: Data link types (use option -y to set):\n", devnames[i]);
+
+               while (--n_dlts >= 0) {
+                       dlt_name = pcap_datalink_val_to_name(dlts[n_dlts]);
+                       if (dlt_name != NULL) {
+                               (void) fprintf(stderr, "\t%s (%s)", dlt_name,
+                                   pcap_datalink_val_to_description(dlts[n_dlts]));
+
+                               /*
+                                * OK, does tcpdump handle that type?
+                                */
+                               if (lookup_printer(dlts[n_dlts]) == NULL)
+                                       (void) fprintf(stderr, " (not supported)");
+                               putchar('\n');
+                       } else {
+                               (void) fprintf(stderr, "  DLT %d (not supported)\n",
+                                   dlts[n_dlts]);
+                       }
                }
+               free(dlts);
        }
-       free(dlts);
        exit(0);
 }
 
@@ -301,9 +306,10 @@
 int
 main(int argc, char **argv)
 {
-       register int cnt, op, i;
+       register int cnt, op, i, j;
        bpf_u_int32 localnet, netmask;
-       register char *cp, *infile, *cmdbuf, *device, *RFileName, *WFileName;
+       register char *cp, *infile, *cmdbuf, *RFileName, *WFileName;
+       char **devices;
        pcap_handler callback;
        int type;
        struct bpf_program fcode;
@@ -318,14 +324,14 @@
        pcap_if_t *devpointer;
        int devnum;
 #endif
-       int status;
+       int status, errdev;
 #ifdef WIN32
        u_int UserBufferSize = 1000000;
        if(wsockinit() != 0) return 1;
 #endif /* WIN32 */
 
        cnt = -1;
-       device = NULL;
+       devices = NULL;
        infile = NULL;
        RFileName = NULL;
        WFileName = NULL;
@@ -423,6 +429,7 @@
                        if (optarg[0] == '0' && optarg[1] == 0)
                                error("Invalid adapter index");
                        
+                       devices = realloc(devices, sizeof(char*)*(nrdev+1));
 #ifdef HAVE_PCAP_FINDALLDEVS
                        /*
                         * If the argument is a number, treat it as
@@ -447,11 +454,11 @@
                                                        error("Invalid adapter index");
                                        }
                                }
-                               device = devpointer->name;
+                               devices[nrdev++] = devpointer->name;
                                break;
                        }
 #endif /* HAVE_PCAP_FINDALLDEVS */
-                       device = optarg;
+                       devices[nrdev++] = optarg;
                        break;
 
                case 'l':
@@ -614,6 +621,13 @@
        if (tflag > 0)
                thiszone = gmt2local(0);
 
+
+       if (RFileName != NULL || nrdev < 1)
+               nrdev = 1;
+       pd = calloc(nrdev, sizeof(pcap_t*));
+       if (pd == NULL)
+               error("no memory");
+       
        if (RFileName != NULL) {
                int dlt;
                const char *dlt_name;
@@ -630,10 +644,10 @@
                 */
                setuid(getuid());
 #endif /* WIN32 */
-               pd = pcap_open_offline(RFileName, ebuf);
-               if (pd == NULL)
+               pd[0] = pcap_open_offline(RFileName, ebuf);
+               if (pd[0] == NULL)
                        error("%s", ebuf);
-               dlt = pcap_datalink(pd);
+               dlt = pcap_datalink(pd[0]);
                dlt_name = pcap_datalink_val_to_name(dlt);
                if (dlt_name == NULL) {
                        fprintf(stderr, "reading from file %s, link-type %u\n",
@@ -649,73 +663,84 @@
                if (fflag != 0)
                        error("-f and -r options are incompatible");
        } else {
-               if (device == NULL) {
-                       device = pcap_lookupdev(ebuf);
-                       if (device == NULL)
+               if (devices == NULL) {
+                       devices    = malloc(sizeof(char*));
+                       devices[0] = pcap_lookupdev(ebuf);
+                       if (devices[0] == NULL)
                                error("%s", ebuf);
                }
+
+               for(i=0; i<nrdev; i++) {
 #ifdef WIN32
-               if(IsTextUnicode(device,  
-                       wcslen((short*)device),                // Device always ends with a double \0, so this way to determine its 
-                                                                                                       // length should be always valid
-                       NULL))
-               {
-                       fprintf(stderr, "%s: listening on %ws\n", program_name, device);
-               }
-               else
-               {
-                       fprintf(stderr, "%s: listening on %s\n", program_name, device);
-               }
+                       if(IsTextUnicode(devices[i],  
+                               wcslen((short*)devices[i]),             // Device always ends with a double \0, so this way to determine its 
+                                                                                                               // length should be always valid
+                               NULL))
+                       {
+                               fprintf(stderr, "%s: listening on %ws\n", program_name, device);
+                       }
+                       else
+                       {
+                               fprintf(stderr, "%s: listening on %s\n", program_name, device);
+                       }
 
-               fflush(stderr); 
+                       fflush(stderr); 
 #endif /* WIN32 */
-               *ebuf = '\0';
-               pd = pcap_open_live(device, snaplen, !pflag, 1000, ebuf);
-               if (pd == NULL)
-                       error("%s", ebuf);
-               else if (*ebuf)
-                       warning("%s", ebuf);
+
+                       *ebuf = '\0';
+                       pd[i] = pcap_open_live(devices[i], snaplen, !pflag, 1000, ebuf);
+                       if (pd[i] == NULL)
+                               error("%s", ebuf);
+                       else if (*ebuf)
+                               warning("%s", ebuf);
 #ifdef WIN32
-               if(UserBufferSize != 1000000)
-                       if(pcap_setbuff(pd, UserBufferSize)==-1){
-                               error("%s", pcap_geterr(pd));
-                       }
+                       if(UserBufferSize != 1000000)
+                               if(pcap_setbuff(pd[i], UserBufferSize)==-1){
+                                       error("%s", pcap_geterr(pd[i]));
+                               }
 #endif /* WIN32 */
-               if (Lflag)
-                       show_dlts_and_exit(pd);
-               if (dlt >= 0) {
+                       if (Lflag)
+                               continue;
+
+                       if (dlt >= 0) {
 #ifdef HAVE_PCAP_SET_DATALINK
-                       if (pcap_set_datalink(pd, dlt) < 0)
-                               error("%s", pcap_geterr(pd));
+                               if (pcap_set_datalink(pd[i], dlt) < 0)
+                                       error("%s: %s", devices[i], pcap_geterr(pd[i]));
 #else
-                       /*
-                        * We don't actually support changing the
-                        * data link type, so we only let them
-                        * set it to what it already is.
-                        */
-                       if (dlt != pcap_datalink(pd)) {
-                               error("%s is not one of the DLTs supported by this device\n",
-                                   dlt_name);
-                       }
+                               /*
+                                * We don't actually support changing the
+                                * data link type, so we only let them
+                                * set it to what it already is.
+                                */
+                               if (dlt != pcap_datalink(pd[i])) {
+                                       error("%s: %s is not one of the DLTs supported by this device\n",
+                                           devices[i], dlt_name);
+                               }
 #endif
-                       (void)fprintf(stderr, "%s: data link type %s\n",
-                                     program_name, dlt_name);
-                       (void)fflush(stderr);
-               }
-               i = pcap_snapshot(pd);
-               if (snaplen < i) {
-                       warning("snaplen raised from %d to %d", snaplen, i);
-                       snaplen = i;
-               }
-               if (pcap_lookupnet(device, &localnet, &netmask, ebuf) < 0) {
-                       localnet = 0;
-                       netmask = 0;
-                       warning("%s", ebuf);
+                               (void)fprintf(stderr, "%s: %s: data link type %s\n",
+                                     program_name, devices[i], dlt_name);
+                               (void)fflush(stderr);
+                       }
+                       j = pcap_snapshot(pd[i]);
+                       if (snaplen < j) {
+                               warning("snaplen raised from %d to %d", snaplen, j);
+                               snaplen = j;
+                       }
+                       if (i > 0 && pcap_datalink(pd[i]) != pcap_datalink(pd[0]))
+                               error("%s: Differing link types not supported", devices[i]);
+                       if (pcap_lookupnet(devices[i], &localnet, &netmask, ebuf) < 0) {
+                               localnet = 0;
+                               netmask = 0;
+                               warning("%s", ebuf);
+                       }
                }
+
+               if(Lflag)
+                       show_dlts_and_exit(devices);
+#ifndef WIN32
                /*
                 * Let user own process after socket has been opened.
                 */
-#ifndef WIN32
                setuid(getuid());
 #endif /* WIN32 */
        }
@@ -724,11 +749,12 @@
        else
                cmdbuf = copy_argv(&argv[optind]);
 
-       if (pcap_compile(pd, &fcode, cmdbuf, Oflag, netmask) < 0)
-               error("%s", pcap_geterr(pd));
+       if (pcap_compile(pd[0], &fcode, cmdbuf, Oflag, netmask) < 0)
+               error("%s", pcap_geterr(pd[0]));
        if (dflag) {
                bpf_dump(&fcode, dflag);
-               pcap_close(pd);
+               for(i=0; i<nrdev; i++)
+                       pcap_close(pd[i]);
                exit(0);
        }
        init_addrtoname(localnet, netmask);
@@ -744,16 +770,18 @@
                (void)setsignal(SIGHUP, oldhandler);
 #endif /* WIN32 */
 
-       if (pcap_setfilter(pd, &fcode) < 0)
-               error("%s", pcap_geterr(pd));
+       for(i=0; i<nrdev; i++) {
+               if (pcap_setfilter(pd[i], &fcode) < 0)
+                       error("%s", pcap_geterr(pd[i]));
+       }
        if (WFileName) {
-               pcap_dumper_t *p = pcap_dump_open(pd, WFileName);
+               pcap_dumper_t *p = pcap_dump_open(pd[0], WFileName);
                if (p == NULL)
-                       error("%s", pcap_geterr(pd));
+                       error("%s", pcap_geterr(pd[0]));
                if (Cflag != 0) {
                        callback = dump_packet_and_trunc;
                        dumpinfo.WFileName = WFileName;
-                       dumpinfo.pd = pd;
+                       dumpinfo.pd = pd[0];
                        dumpinfo.p = p;
                        pcap_userdata = (u_char *)&dumpinfo;
                } else {
@@ -761,7 +789,7 @@
                        pcap_userdata = (u_char *)p;
                }
        } else {
-               type = pcap_datalink(pd);
+               type = pcap_datalink(pd[0]);
                printinfo.printer = lookup_printer(type);
                if (printinfo.printer == NULL) {
                        dlt_name = pcap_datalink_val_to_name(type);
@@ -785,22 +813,71 @@
                        (void)fprintf(stderr,
                            "%s: verbose output suppressed, use -v or -vv for full protocol decode\n",
                            program_name);
-               } else
-                       (void)fprintf(stderr, "%s: ", program_name);
-               dlt = pcap_datalink(pd);
+               }
+               dlt = pcap_datalink(pd[0]);
                dlt_name = pcap_datalink_val_to_name(dlt);
-               if (dlt_name == NULL) {
-                       (void)fprintf(stderr, "listening on %s, link-type %u, capture size %u bytes\n",
-                           device, dlt, snaplen);
-               } else {
-                       (void)fprintf(stderr, "listening on %s, link-type %s (%s), capture size %u bytes\n",
-                           device, dlt_name,
-                           pcap_datalink_val_to_description(dlt), snaplen);
+               for(i=0; i<nrdev; i++) {
+                       fprintf(stderr, "%s: ", program_name);
+                       if (dlt_name == NULL) {
+                               (void)fprintf(stderr, "listening on %s, link-type %u, capture size %u bytes\n",
+                                   devices[i], dlt, snaplen);
+                       } else {
+                               (void)fprintf(stderr, "listening on %s, link-type %s (%s), capture size %u bytes\n",
+                                   devices[i], dlt_name,
+                                   pcap_datalink_val_to_description(dlt), snaplen);
+                       }
                }
                (void)fflush(stderr);
        }
 #endif /* WIN32 */
-       status = pcap_loop(pd, cnt, callback, pcap_userdata);
+
+       if (nrdev == 1) {
+               /* old mechanism, incase platforms select() on raw sockets is buggy */
+               status = pcap_loop(pd[0], cnt, callback, pcap_userdata);
+               errdev = 0;
+       } else {
+               /* select() mechanism */
+               fd_set  fds;
+               int     n, err = 0;
+               
+               status = 0;
+               FD_ZERO(&fds);
+               for(i=0; i<nrdev; i++) {
+                       if (pcap_setnonblock(pd[i], 1, ebuf) < 0)
+                               error("pcap_setnonblock: %s: %s", devices[i], ebuf);
+               }
+               
+               while(cnt != 0 && status >= 0) {
+                       for(i=0; i<nrdev; i++)
+                               FD_SET(pcap_fileno(pd[i]), &fds);
+
+                       err = select(FD_SETSIZE, &fds, NULL, NULL, NULL);
+                       if (err < 0) {
+                               if (errno == EINTR)
+                                       break;
+                               error("select: %s", strerror(errno));
+                       }
+
+                       /* Attempts to fairly balance between all devices with outstanding packets */
+                       while(cnt != 0 && status >= 0) {
+                               for(i=0, n=0; i<nrdev; i++) {
+                                       status = pcap_dispatch(pd[i], (cnt > 0 && cnt < 10 ? cnt : 10), callback, pcap_userdata);
+                                       if (status < 0) {
+                                               errdev = i;
+                                               break;
+                                       }
+                                       if (status > 0) {
+                                               n++;
+                                               if (cnt > 0)
+                                                       cnt -= status;
+                                       }
+                               }
+                               if (n == 0)
+                                       break;
+                       }
+               }
+       }
+
        if (WFileName == NULL) {
                /*
                 * We're printing packets.  Flush the printed output,
@@ -820,8 +897,8 @@
                /*
                 * Error.  Report it.
                 */
-               (void)fprintf(stderr, "%s: pcap_loop: %s\n",
-                   program_name, pcap_geterr(pd));
+               (void)fprintf(stderr, "%s: %s: pcap_loop: %s\n",
+                   program_name, devices[errdev], pcap_geterr(pd[errdev]));
        }
        if (RFileName == NULL) {
                /*
@@ -830,7 +907,8 @@
                 */
                info(1);
        }
-       pcap_close(pd);
+       for(i=0; i<nrdev; i++)
+               pcap_close(pd[i]);
        exit(status == -1 ? 1 : 0);
 }
 
@@ -839,13 +917,16 @@
 cleanup(int signo _U_)
 {
 #ifdef HAVE_PCAP_BREAKLOOP
+       int i;
+       
        /*
         * We have "pcap_breakloop()"; use it, so that we do as little
         * as possible in the signal handler (it's probably not safe
         * to do anything with standard I/O streams in a signal handler -
         * the ANSI C standard doesn't say it is).
         */
-       pcap_breakloop(pd);
+       for(i=0; i<nrdev; i++)
+               pcap_breakloop(pd[i]);
 #else
        /*
         * We don't have "pcap_breakloop()"; this isn't safe, but
@@ -853,7 +934,7 @@
         * not reading from a savefile - i.e., if we're doing a
         * live capture - and exit.
         */
-       if (pd != NULL && pcap_file(pd) == NULL) {
+       if (pd != NULL && pcap_file(pd[0]) == NULL) {
                /*
                 * We got interrupted, so perhaps we didn't
                 * manage to finish a line we were printing.
@@ -871,10 +952,18 @@
 info(register int verbose)
 {
        struct pcap_stat stat;
-
-       if (pcap_stats(pd, &stat) < 0) {
-               (void)fprintf(stderr, "pcap_stats: %s\n", pcap_geterr(pd));
-               return;
+       struct pcap_stat tot;
+       int i;
+       
+       tot.ps_recv = tot.ps_drop = 0;
+
+       for(i=0; i<nrdev; i++) {
+               if (pcap_stats(pd[i], &stat) < 0) {
+                       (void)fprintf(stderr, "pcap_stats: %s\n", pcap_geterr(pd[i]));
+                       return;
+               }
+               tot.ps_recv += stat.ps_recv;
+               tot.ps_drop += stat.ps_drop;
        }
 
        if (!verbose)
@@ -885,12 +974,12 @@
                fputs(", ", stderr);
        else
                putc('\n', stderr);
-       (void)fprintf(stderr, "%d packets received by filter", stat.ps_recv);
+       (void)fprintf(stderr, "%d packets received by filter", tot.ps_recv);
        if (!verbose)
                fputs(", ", stderr);
        else
                putc('\n', stderr);
-       (void)fprintf(stderr, "%d packets dropped by kernel\n", stat.ps_drop);
+       (void)fprintf(stderr, "%d packets dropped by kernel\n", tot.ps_drop);
        infoprint = 0;
 }
 
@@ -950,7 +1039,7 @@
                dump_info->p = pcap_dump_open(dump_info->pd, name);
                free(name);
                if (dump_info->p == NULL)
-                       error("%s", pcap_geterr(pd));
+                       error("%s", pcap_geterr(dump_info->pd));
        }
 
        pcap_dump((u_char *)dump_info->p, h, sp);