document SIGUSR1 in manual page

[tcpdump] / tcpdump.c

diff --git a/tcpdump.c b/tcpdump.c
index 85ceafb21c7ea5a1a77e6d4732d97c265183c995..8e07d8f2e1572dc307aafe86e7c40c200f4d3e99 100644 (file)
--- a/tcpdump.c
+++ b/tcpdump.c
@@ -43,6 +43,17 @@ The Regents of the University of California.  All rights reserved.\n";
 #include "config.h"
 #endif
 
 #include "config.h"
 #endif
 

+/*
+ * Mac OS X may ship pcap.h from libpcap 0.6 with a libpcap based on
+ * 0.8.  That means it has pcap_findalldevs() but the header doesn't
+ * define pcap_if_t, meaning that we can't actually *use* pcap_findalldevs().
+ */
+#ifdef HAVE_PCAP_FINDALLDEVS
+#ifndef HAVE_PCAP_IF_T
+#undef HAVE_PCAP_FINDALLDEVS
+#endif
+#endif
+

 #include <tcpdump-stdinc.h>
 
 #ifdef WIN32
 #include <tcpdump-stdinc.h>
 
 #ifdef WIN32


@@ -53,15 +64,30 @@ extern int SIZE_BUF;
 #define uint UINT
 #endif /* WIN32 */
 
 #define uint UINT
 #endif /* WIN32 */
 

-#ifdef HAVE_SMI_H
+#ifdef USE_LIBSMI

 #include <smi.h>
 #endif
 
 #include <smi.h>
 #endif
 

+#ifdef HAVE_LIBCRYPTO
+#include <openssl/crypto.h>
+#endif
+

 #ifdef HAVE_GETOPT_LONG
 #include <getopt.h>
 #else
 #include "getopt_long.h"
 #endif
 #ifdef HAVE_GETOPT_LONG
 #include <getopt.h>
 #else
 #include "getopt_long.h"
 #endif

+/* Capsicum-specific code requires macros from <net/bpf.h>, which will fail
+ * to compile if <pcap.h> has already been included; including the headers
+ * in the opposite order works fine.
+ */
+#ifdef HAVE_CAPSICUM
+#include <sys/capability.h>
+#include <sys/ioccom.h>
+#include <net/bpf.h>
+#include <fcntl.h>
+#include <libgen.h>
+#endif /* HAVE_CAPSICUM */

 #include <pcap.h>
 #include <signal.h>
 #include <stdio.h>
 #include <pcap.h>
 #include <signal.h>
 #include <stdio.h>


@@ -73,13 +99,20 @@ extern int SIZE_BUF;
 #include <sys/resource.h>
 #include <pwd.h>
 #include <grp.h>
 #include <sys/resource.h>
 #include <pwd.h>
 #include <grp.h>

-#include <errno.h>

 #endif /* WIN32 */
 
 #endif /* WIN32 */
 

-/* capabilities convinience library */
+/* capabilities convenience library */
+/* If a code depends on HAVE_LIBCAP_NG, it depends also on HAVE_CAP_NG_H.
+ * If HAVE_CAP_NG_H is not defined, undefine HAVE_LIBCAP_NG.
+ * Thus, the later tests are done only on HAVE_LIBCAP_NG.
+ */
+#ifdef HAVE_LIBCAP_NG

 #ifdef HAVE_CAP_NG_H
 #include <cap-ng.h>
 #ifdef HAVE_CAP_NG_H
 #include <cap-ng.h>

+#else
+#undef HAVE_LIBCAP_NG

 #endif /* HAVE_CAP_NG_H */
 #endif /* HAVE_CAP_NG_H */

+#endif /* HAVE_LIBCAP_NG */

 
 #include "netdissect.h"
 #include "interface.h"
 
 #include "netdissect.h"
 #include "interface.h"


@@ -123,7 +156,8 @@ int32_t thiszone;           /* seconds offset from gmt to local time */
 /* Forwards */
 static RETSIGTYPE cleanup(int);
 static RETSIGTYPE child_cleanup(int);
 /* Forwards */
 static RETSIGTYPE cleanup(int);
 static RETSIGTYPE child_cleanup(int);

-static void usage(void) __attribute__((noreturn));
+static void print_version(void);
+static void print_usage(void);

 static void show_dlts_and_exit(const char *device, pcap_t *pd) __attribute__((noreturn));
 
 static void print_packet(u_char *, const struct pcap_pkthdr *, const u_char *);
 static void show_dlts_and_exit(const char *device, pcap_t *pd) __attribute__((noreturn));
 
 static void print_packet(u_char *, const struct pcap_pkthdr *, const u_char *);


@@ -437,6 +471,9 @@ struct dump_info {
        char    *CurrentFileName;
        pcap_t  *pd;
        pcap_dumper_t *p;
        char    *CurrentFileName;
        pcap_t  *pd;
        pcap_dumper_t *p;

+#ifdef HAVE_CAPSICUM
+       int     dirfd;
+#endif

 };
 
 #ifdef HAVE_PCAP_SET_TSTAMP_TYPE
 };
 
 #ifdef HAVE_PCAP_SET_TSTAMP_TYPE


@@ -551,6 +588,27 @@ show_devices_and_exit (void)
 }
 #endif /* HAVE_PCAP_FINDALLDEVS */
 
 }
 #endif /* HAVE_PCAP_FINDALLDEVS */
 

+/*
+ * Short options.
+ *
+ * Note that there we use all letters for short options except for g, k,
+ * o, and P, and those are used by other versions of tcpdump, and we should
+ * only use them for the same purposes that the other versions of tcpdump
+ * use them:
+ *
+ * OS X tcpdump uses -g to force non--v output for IP to be on one
+ * line, making it more "g"repable;
+ *
+ * OS X tcpdump uses -k tospecify that packet comments in pcap-ng files
+ * should be printed;
+ *
+ * OpenBSD tcpdump uses -o to indicate that OS fingerprinting should be done
+ * for hosts sending TCP SYN packets;
+ *
+ * OS X tcpdump uses -P to indicate that -w should write pcap-ng rather
+ * than pcap files.
+ */
+

 /*
  * Set up flags that might or might not be supported depending on the
  * version of libpcap we're using.
 /*
  * Set up flags that might or might not be supported depending on the
  * version of libpcap we're using.


@@ -579,12 +637,6 @@ show_devices_and_exit (void)
 #define J_FLAG
 #endif /* PCAP_ERROR_TSTAMP_TYPE_NOTSUP */
 
 #define J_FLAG
 #endif /* PCAP_ERROR_TSTAMP_TYPE_NOTSUP */
 

-#ifdef HAVE_PCAP_FINDALLDEVS
-#ifndef HAVE_PCAP_IF_T
-#undef HAVE_PCAP_FINDALLDEVS
-#endif
-#endif
-

 #ifdef HAVE_PCAP_FINDALLDEVS
 #define D_FLAG "D"
 #else
 #ifdef HAVE_PCAP_FINDALLDEVS
 #define D_FLAG "D"
 #else


@@ -603,85 +655,69 @@ show_devices_and_exit (void)
 #define Q_FLAG
 #endif
 
 #define Q_FLAG
 #endif
 

-static struct option longopts[] = {
-       { NULL, no_argument, NULL, 'a' },
-       { NULL, no_argument, NULL, 'A' },
-       { NULL, no_argument, NULL, 'b' },
+/*
+ * Long options.
+ *
+ * We do not currently have long options corresponding to all short
+ * options; we should probably pick appropriate option names for them.
+ *
+ * However, the short options where the number of times the option is
+ * specified matters, such as -v and -d and -t, should probably not
+ * just map to a long option, as saying
+ *
+ *  tcpdump --verbose --verbose
+ *
+ * doesn't make sense; it should be --verbosity={N} or something such
+ * as that.
+ *
+ * For long options with no corresponding short options, we define values
+ * outside the range of ASCII graphic characters, make that the last
+ * component of the entry for the long option, and have a case for that
+ * option in the switch statement.
+ */
+#define OPTION_VERSION         128
+#define OPTION_TSTAMP_PRECISION        129
+#define OPTION_IMMEDIATE_MODE  130
+
+static const struct option longopts[] = {

 #if defined(HAVE_PCAP_CREATE) || defined(WIN32)
 #if defined(HAVE_PCAP_CREATE) || defined(WIN32)

-       { NULL, required_argument, NULL, 'B' },
-#endif
-       { NULL, required_argument, NULL, 'c' },
-       { NULL, required_argument, NULL, 'C' },
-       { NULL, no_argument, NULL, 'd' },
-       { NULL, no_argument, NULL, 'D' },
-       { NULL, no_argument, NULL, 'e' },
-       { NULL, required_argument, NULL, 'E' },
-       { NULL, no_argument, NULL, 'f' },
-       { NULL, required_argument, NULL, 'F' },
-       /*
-        * NOTE: OS X tcpdump uses -g; we shouldn't use it except for
-        * the same purpose (forcing non--v output for IP to be on one
-        * line, making it more "g"repable).
-        */
-       { NULL, required_argument, NULL, 'G' },
-       { NULL, no_argument, NULL, 'h' },
-       { NULL, no_argument, NULL, 'H' },
-       { NULL, required_argument, NULL, 'i' },
+       { "buffer-size", required_argument, NULL, 'B' },
+#endif
+       { "list-interfaces", no_argument, NULL, 'D' },
+       { "help", no_argument, NULL, 'h' },
+       { "interface", required_argument, NULL, 'i' },

 #ifdef HAVE_PCAP_CREATE
 #ifdef HAVE_PCAP_CREATE

-       { NULL, no_argument, NULL, 'I' },
+       { "monitor-mode", no_argument, NULL, 'I' },

 #endif
 #ifdef HAVE_PCAP_SET_TSTAMP_TYPE
 #endif
 #ifdef HAVE_PCAP_SET_TSTAMP_TYPE

-       { NULL, required_argument, NULL, 'j' },
-       { NULL, no_argument, NULL, 'J' },
+       { "time-stamp-type", required_argument, NULL, 'j' },
+       { "list-time-stamp-types", no_argument, NULL, 'J' },

 #endif
 #endif

-       /*
-        * NOTE: OS X tcpdump uses -k; we shouldn't use it except for
-        * the same purpose (printing packet comments in pcap-ng files).
-        */
-       { NULL, no_argument, NULL, 'K' },
-       { NULL, no_argument, NULL, 'l' },
-       { NULL, no_argument, NULL, 'L' },
-       { NULL, required_argument, NULL, 'm' },
-       { NULL, required_argument, NULL, 'M' },
-       { NULL, no_argument, NULL, 'n' },
-       { NULL, no_argument, NULL, 'N' },
-       /*
-        * NOTE: OpenBSD tcpdump uses -o; we shouldn't use it except for 
-        * the same purpose (trying to do OS fingerprinting for
-        * hosts sending TCP SYN packets).
-        */
-       { NULL, no_argument, NULL, 'O' },
-       { NULL, no_argument, NULL, 'p' },
-       /*
-        * NOTE: OS X tcpdump uses -P; we shouldn't use it except for
-        * the same purpose (writing pcap-ng rather than pcap files).
-        */
-       { NULL, no_argument, NULL, 'q' },
+#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION
+       { "time-stamp-precision", required_argument, NULL, OPTION_TSTAMP_PRECISION},
+#endif
+       { "dont-verify-checksums", no_argument, NULL, 'K' },
+       { "list-data-link-types", no_argument, NULL, 'L' },
+       { "no-optimize", no_argument, NULL, 'O' },
+       { "no-promiscuous-mode", no_argument, NULL, 'p' },

 #ifdef HAVE_PCAP_SETDIRECTION
 #ifdef HAVE_PCAP_SETDIRECTION

-       { NULL, required_argument, NULL, 'Q' },
-#endif
-       { NULL, required_argument, NULL, 'r' },
-       { NULL, no_argument, NULL, 'R' },
-       { NULL, required_argument, NULL, 's' },
-       { NULL, no_argument, NULL, 'S' },
-       { NULL, no_argument, NULL, 't' },
-       { NULL, required_argument, NULL, 'T' },
-       { NULL, no_argument, NULL, 'u' },
+       { "direction", required_argument, NULL, 'Q' },
+#endif
+       { "snapshot-length", required_argument, NULL, 's' },
+       { "absolute-tcp-sequence-numbers", no_argument, NULL, 'S' },

 #ifdef HAVE_PCAP_DUMP_FLUSH
 #ifdef HAVE_PCAP_DUMP_FLUSH

-       { NULL, no_argument, NULL, 'U' },
-#endif
-       { NULL, no_argument, NULL, 'v' },
-       { NULL, required_argument, NULL, 'V' },
-       { NULL, required_argument, NULL, 'w' },
-       { NULL, required_argument, NULL, 'W' },
-       { NULL, no_argument, NULL, 'x' },
-       { NULL, no_argument, NULL, 'X' },
-       { NULL, required_argument, NULL, 'y' },
+       { "packet-buffered", no_argument, NULL, 'U' },
+#endif
+       { "linktype", required_argument, NULL, 'y' },
+#ifdef HAVE_PCAP_SET_IMMEDIATE_MODE
+       { "immediate-mode", no_argument, NULL, OPTION_IMMEDIATE_MODE },
+#endif

 #if defined(HAVE_PCAP_DEBUG) || defined(HAVE_YYDEBUG)
 #if defined(HAVE_PCAP_DEBUG) || defined(HAVE_YYDEBUG)

-       { NULL, no_argument, NULL, 'Y' },
+       { "debug-filter-parser", no_argument, NULL, 'Y' },

 #endif
 #endif

-       { NULL, required_argument, NULL, 'z' },
-       { NULL, required_argument, NULL, 'Z' },
+       { "relinquish-privileges", required_argument, NULL, 'Z' },
+       { "number", no_argument, NULL, '#' },
+       { "version", no_argument, NULL, OPTION_VERSION },

        { NULL, 0, NULL, 0 }
 };
 
        { NULL, 0, NULL, 0 }
 };
 


@@ -706,18 +742,14 @@ droproot(const char *username, const char *chroot_dir)
                                exit(1);
                        }
                }
                                exit(1);
                        }
                }

-#ifdef HAVE_CAP_NG_H
+#ifdef HAVE_LIBCAP_NG

                int ret = capng_change_id(pw->pw_uid, pw->pw_gid, CAPNG_NO_FLAG);
                if (ret < 0) {
                int ret = capng_change_id(pw->pw_uid, pw->pw_gid, CAPNG_NO_FLAG);
                if (ret < 0) {

-                       printf("error : ret %d\n", ret);
+                       fprintf(stderr, "error : ret %d\n", ret);
+               }
+               else {
+                       fprintf(stderr, "dropped privs to %s\n", username);

                }
                }

-               /* We don't need CAP_SETUID and CAP_SETGID */
-               capng_update(CAPNG_DROP, CAPNG_EFFECTIVE, CAP_SETUID);
-               capng_update(CAPNG_DROP, CAPNG_EFFECTIVE, CAP_SETUID);
-               capng_update(CAPNG_DROP, CAPNG_PERMITTED, CAP_SETUID);
-               capng_update(CAPNG_DROP, CAPNG_PERMITTED, CAP_SETUID);
-               capng_apply(CAPNG_SELECT_BOTH);
-

 #else
                if (initgroups(pw->pw_name, pw->pw_gid) != 0 ||
                    setgid(pw->pw_gid) != 0 || setuid(pw->pw_uid) != 0) {
 #else
                if (initgroups(pw->pw_name, pw->pw_gid) != 0 ||
                    setgid(pw->pw_gid) != 0 || setuid(pw->pw_uid) != 0) {


@@ -728,13 +760,27 @@ droproot(const char *username, const char *chroot_dir)
                            pcap_strerror(errno));
                        exit(1);
                }
                            pcap_strerror(errno));
                        exit(1);
                }

-#endif /* HAVE_CAP_NG_H */
+               else {
+                       fprintf(stderr, "dropped privs to %s\n", username);
+               }
+#endif /* HAVE_LIBCAP_NG */

        }
        else {
                fprintf(stderr, "tcpdump: Couldn't find user '%.32s'\n",
                    username);
                exit(1);
        }
        }
        else {
                fprintf(stderr, "tcpdump: Couldn't find user '%.32s'\n",
                    username);
                exit(1);
        }

+#ifdef HAVE_LIBCAP_NG
+       /* We don't need CAP_SETUID and CAP_SETGID any more. */
+       capng_updatev(
+               CAPNG_DROP,
+               CAPNG_EFFECTIVE | CAPNG_PERMITTED,
+               CAP_SETUID,
+               CAP_SETGID,
+               -1);
+       capng_apply(CAPNG_SELECT_BOTH);
+#endif /* HAVE_LIBCAP_NG */
+

 }
 #endif /* WIN32 */
 
 }
 #endif /* WIN32 */
 


@@ -838,6 +884,36 @@ get_next_file(FILE *VFile, char *ptr)
        return ret;
 }
 
        return ret;
 }
 

+#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION
+static int
+tstamp_precision_from_string(const char *precision)
+{
+       if (strncmp(precision, "nano", strlen("nano")) == 0)
+               return PCAP_TSTAMP_PRECISION_NANO;
+
+       if (strncmp(precision, "micro", strlen("micro")) == 0)
+               return PCAP_TSTAMP_PRECISION_MICRO;
+
+       return -EINVAL;
+}
+
+static const char *
+tstamp_precision_to_string(int precision)
+{
+       switch (precision) {
+
+       case PCAP_TSTAMP_PRECISION_MICRO:
+               return "micro";
+
+       case PCAP_TSTAMP_PRECISION_NANO:
+               return "nano";
+
+       default:
+               return "unknown";
+       }
+}
+#endif
+

 int
 main(int argc, char **argv)
 {
 int
 main(int argc, char **argv)
 {


@@ -868,6 +944,11 @@ main(int argc, char **argv)
 #endif
        int status;
        FILE *VFile;
 #endif
        int status;
        FILE *VFile;

+#ifdef HAVE_CAPSICUM
+       cap_rights_t rights;
+       int cansandbox;
+#endif /* HAVE_CAPSICUM */
+

 #ifdef WIN32
        if(wsockinit() != 0) return 1;
 #endif /* WIN32 */
 #ifdef WIN32
        if(wsockinit() != 0) return 1;
 #endif /* WIN32 */


@@ -881,6 +962,7 @@ main(int argc, char **argv)
        gndo->ndo_error=ndo_error;
        gndo->ndo_warning=ndo_warning;
        gndo->ndo_snaplen = DEFAULT_SNAPLEN;
        gndo->ndo_error=ndo_error;
        gndo->ndo_warning=ndo_warning;
        gndo->ndo_snaplen = DEFAULT_SNAPLEN;

+       gndo->ndo_immediate = 0;

 
        cnt = -1;
        device = NULL;
 
        cnt = -1;
        device = NULL;


@@ -895,15 +977,22 @@ main(int argc, char **argv)
        else
                program_name = argv[0];
 
        else
                program_name = argv[0];
 

+       /*
+        * On platforms where the CPU doesn't support unaligned loads,
+        * force unaligned accesses to abort with SIGBUS, rather than
+        * being fixed up (slowly) by the OS kernel; on those platforms,
+        * misaligned accesses are bugs, and we want tcpdump to crash so
+        * that the bugs are reported.
+        */

        if (abort_on_misalignment(ebuf, sizeof(ebuf)) < 0)
                error("%s", ebuf);
 
        if (abort_on_misalignment(ebuf, sizeof(ebuf)) < 0)
                error("%s", ebuf);
 

-#ifdef LIBSMI
+#ifdef USE_LIBSMI

        smiInit("tcpdump");
 #endif
 
        while (
        smiInit("tcpdump");
 #endif
 
        while (

-           (op = getopt_long(argc, argv, "aAb" B_FLAG "c:C:d" D_FLAG "eE:fF:G:hHi:" I_FLAG j_FLAG J_FLAG "KlLm:M:nNOpq" Q_FLAG "r:Rs:StT:u" U_FLAG "vV:w:W:xXy:Yz:Z:", longopts, NULL)) != -1)
+           (op = getopt_long(argc, argv, "aAb" B_FLAG "c:C:d" D_FLAG "eE:fF:G:hHi:" I_FLAG j_FLAG J_FLAG "KlLm:M:nNOpq" Q_FLAG "r:Rs:StT:u" U_FLAG "vV:w:W:xXy:Yz:Z:#", longopts, NULL)) != -1)

                switch (op) {
 
                case 'a':
                switch (op) {
 
                case 'a':


@@ -985,7 +1074,8 @@ main(int argc, char **argv)
                        break;
 
                case 'h':
                        break;
 
                case 'h':

-                       usage();
+                       print_usage();
+                       exit(0);

                        break;
 
                case 'H':
                        break;
 
                case 'H':


@@ -1078,7 +1168,7 @@ main(int argc, char **argv)
                        break;
 
                case 'm':
                        break;
 
                case 'm':

-#ifdef LIBSMI
+#ifdef USE_LIBSMI

                        if (smiLoadModule(optarg) == 0) {
                                error("could not load MIB module %s", optarg);
                        }
                        if (smiLoadModule(optarg) == 0) {
                                error("could not load MIB module %s", optarg);
                        }


@@ -1263,8 +1353,32 @@ main(int argc, char **argv)
                        username = strdup(optarg);
                        break;
 
                        username = strdup(optarg);
                        break;
 

+               case '#':
+                       gndo->ndo_packet_number = 1;
+                       break;
+
+               case OPTION_VERSION:
+                       print_version();
+                       exit(0);
+                       break;
+
+#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION
+               case OPTION_TSTAMP_PRECISION:
+                       gndo->ndo_tstamp_precision = tstamp_precision_from_string(optarg);
+                       if (gndo->ndo_tstamp_precision < 0)
+                               error("unsupported time stamp precision");
+                       break;
+#endif
+
+#ifdef HAVE_PCAP_SET_IMMEDIATE_MODE
+               case OPTION_IMMEDIATE_MODE:
+                       gndo->ndo_immediate = 1;
+                       break;
+#endif
+

                default:
                default:

-                       usage();
+                       print_usage();
+                       exit(1);

                        /* NOTREACHED */
                }
 
                        /* NOTREACHED */
                }
 


@@ -1297,6 +1411,17 @@ main(int argc, char **argv)
        if (VFileName != NULL && RFileName != NULL)
                error("-V and -r are mutually exclusive.");
 
        if (VFileName != NULL && RFileName != NULL)
                error("-V and -r are mutually exclusive.");
 

+#ifdef HAVE_PCAP_SET_IMMEDIATE_MODE
+       /*
+        * If we're printing dissected packets to the standard output
+        * rather than saving raw packets to a file, and the standard
+        * output is a terminal, use immediate mode, as the user's
+        * probably expecting to see packets pop up immediately.
+        */
+       if (WFileName == NULL && isatty(1))
+               gndo->ndo_immediate = 1;
+#endif
+

 #ifdef WITH_CHROOT
        /* if run as root, prepare for chrooting */
        if (getuid() == 0 || geteuid() == 0) {
 #ifdef WITH_CHROOT
        /* if run as root, prepare for chrooting */
        if (getuid() == 0 || geteuid() == 0) {


@@ -1353,9 +1478,22 @@ main(int argc, char **argv)
                        RFileName = VFileLine;
                }
 
                        RFileName = VFileLine;
                }
 

+#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION
+               pd = pcap_open_offline_with_tstamp_precision(RFileName,
+                   gndo->ndo_tstamp_precision, ebuf);
+#else

                pd = pcap_open_offline(RFileName, ebuf);
                pd = pcap_open_offline(RFileName, ebuf);

+#endif
+

                if (pd == NULL)
                        error("%s", ebuf);
                if (pd == NULL)
                        error("%s", ebuf);

+#ifdef HAVE_CAPSICUM
+               cap_rights_init(&rights, CAP_READ);
+               if (cap_rights_limit(fileno(pcap_file(pd)), &rights) < 0 &&
+                   errno != ENOSYS) {
+                       error("unable to limit pcap descriptor");
+               }
+#endif

                dlt = pcap_datalink(pd);
                dlt_name = pcap_datalink_val_to_name(dlt);
                if (dlt_name == NULL) {
                dlt = pcap_datalink(pd);
                dlt_name = pcap_datalink_val_to_name(dlt);
                if (dlt_name == NULL) {


@@ -1399,6 +1537,24 @@ main(int argc, char **argv)
 #ifdef HAVE_PCAP_SET_TSTAMP_TYPE
                if (Jflag)
                        show_tstamp_types_and_exit(device, pd);
 #ifdef HAVE_PCAP_SET_TSTAMP_TYPE
                if (Jflag)
                        show_tstamp_types_and_exit(device, pd);

+#endif
+#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION
+               status = pcap_set_tstamp_precision(pd, gndo->ndo_tstamp_precision);
+               if (status != 0)
+                       error("%s: Can't set %ssecond time stamp precision: %s",
+                               device,
+                               tstamp_precision_to_string(gndo->ndo_tstamp_precision),
+                               pcap_statustostr(status));
+#endif
+
+#ifdef HAVE_PCAP_SET_IMMEDIATE_MODE
+               if (gndo->ndo_immediate) {
+                       status = pcap_set_immediate_mode(pd, 1);
+                       if (status != 0)
+                               error("%s: Can't set immediate mode: %s",
+                               device,
+                               pcap_statustostr(status));
+               }

 #endif
                /*
                 * Is this an interface that supports monitor mode?
 #endif
                /*
                 * Is this an interface that supports monitor mode?


@@ -1436,7 +1592,7 @@ main(int argc, char **argv)
                        status = pcap_set_tstamp_type(pd, jflag);
                        if (status < 0)
                                error("%s: Can't set time stamp type: %s",
                        status = pcap_set_tstamp_type(pd, jflag);
                        if (status < 0)
                                error("%s: Can't set time stamp type: %s",

-                                   device, pcap_statustostr(status));
+                                     device, pcap_statustostr(status));

                }
 #endif
                status = pcap_activate(pd);
                }
 #endif
                status = pcap_activate(pd);


@@ -1582,27 +1738,28 @@ main(int argc, char **argv)
         * savefile doesn't handle the general case.
         */
 
         * savefile doesn't handle the general case.
         */
 

-#ifdef HAVE_CAP_NG_H
-       /* We are running as root and we will be writing to savefile */
-       if ((getuid() == 0 || geteuid() == 0) && WFileName) {
+       if (getuid() == 0 || geteuid() == 0) {
+#ifdef HAVE_LIBCAP_NG
+               /* Initialize capng */
+               capng_clear(CAPNG_SELECT_BOTH);

                if (username) {
                if (username) {

-                       /* Drop all capabilities from effective set */
-                       capng_clear(CAPNG_EFFECTIVE);
-                       /* Add capabilities we will need*/
-                       capng_update(CAPNG_ADD, CAPNG_PERMITTED, CAP_SETUID);
-                       capng_update(CAPNG_ADD, CAPNG_PERMITTED, CAP_SETGID);
-                       capng_update(CAPNG_ADD, CAPNG_PERMITTED, CAP_DAC_OVERRIDE);
-
-                       capng_update(CAPNG_ADD, CAPNG_EFFECTIVE, CAP_SETUID);
-                       capng_update(CAPNG_ADD, CAPNG_EFFECTIVE, CAP_SETGID);
-                       capng_update(CAPNG_ADD, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
-
-                       capng_apply(CAPNG_SELECT_BOTH);
+                       capng_updatev(
+                               CAPNG_ADD,
+                               CAPNG_PERMITTED | CAPNG_EFFECTIVE,
+                               CAP_SETUID,
+                               CAP_SETGID,
+                               -1);

                }
                }

-       }
-#endif /* HAVE_CAP_NG_H */

 
 

-       if (getuid() == 0 || geteuid() == 0) {
+               if (WFileName) {
+                       capng_update(
+                               CAPNG_ADD,
+                               CAPNG_PERMITTED | CAPNG_EFFECTIVE,
+                               CAP_DAC_OVERRIDE
+                               );
+               }
+               capng_apply(CAPNG_SELECT_BOTH);
+#endif /* HAVE_LIBCAP_NG */

                if (username || chroot_dir)
                        droproot(username, chroot_dir);
 
                if (username || chroot_dir)
                        droproot(username, chroot_dir);
 


@@ -1611,6 +1768,21 @@ main(int argc, char **argv)
 
        if (pcap_setfilter(pd, &fcode) < 0)
                error("%s", pcap_geterr(pd));
 
        if (pcap_setfilter(pd, &fcode) < 0)
                error("%s", pcap_geterr(pd));

+#ifdef HAVE_CAPSICUM
+       if (RFileName == NULL && VFileName == NULL) {
+               static const unsigned long cmds[] = { BIOCGSTATS };
+
+               cap_rights_init(&rights, CAP_IOCTL, CAP_READ);
+               if (cap_rights_limit(pcap_fileno(pd), &rights) < 0 &&
+                   errno != ENOSYS) {
+                       error("unable to limit pcap descriptor");
+               }
+               if (cap_ioctls_limit(pcap_fileno(pd), cmds,
+                   sizeof(cmds) / sizeof(cmds[0])) < 0 && errno != ENOSYS) {
+                       error("unable to limit ioctls on pcap descriptor");
+               }
+       }
+#endif

        if (WFileName) {
                pcap_dumper_t *p;
                /* Do not exceed the default PATH_MAX for files. */
        if (WFileName) {
                pcap_dumper_t *p;
                /* Do not exceed the default PATH_MAX for files. */


@@ -1626,15 +1798,47 @@ main(int argc, char **argv)
                  MakeFilename(dumpinfo.CurrentFileName, WFileName, 0, 0);
 
                p = pcap_dump_open(pd, dumpinfo.CurrentFileName);
                  MakeFilename(dumpinfo.CurrentFileName, WFileName, 0, 0);
 
                p = pcap_dump_open(pd, dumpinfo.CurrentFileName);

-#ifdef HAVE_CAP_NG_H
-        /* Give up capabilities, clear Effective set */
-        capng_clear(CAPNG_EFFECTIVE);
-#endif
+#ifdef HAVE_LIBCAP_NG
+               /* Give up CAP_DAC_OVERRIDE capability.
+                * Only allow it to be restored if the -C or -G flag have been
+                * set since we may need to create more files later on.
+                */
+               capng_update(
+                       CAPNG_DROP,
+                       (Cflag || Gflag ? 0 : CAPNG_PERMITTED)
+                               | CAPNG_EFFECTIVE,
+                       CAP_DAC_OVERRIDE
+                       );
+               capng_apply(CAPNG_SELECT_BOTH);
+#endif /* HAVE_LIBCAP_NG */

                if (p == NULL)
                        error("%s", pcap_geterr(pd));
                if (p == NULL)
                        error("%s", pcap_geterr(pd));

+#ifdef HAVE_CAPSICUM
+               cap_rights_init(&rights, CAP_SEEK, CAP_WRITE);
+               if (cap_rights_limit(fileno(pcap_dump_file(p)), &rights) < 0 &&
+                   errno != ENOSYS) {
+                       error("unable to limit dump descriptor");
+               }
+#endif

                if (Cflag != 0 || Gflag != 0) {
                if (Cflag != 0 || Gflag != 0) {

-                       callback = dump_packet_and_trunc;
+#ifdef HAVE_CAPSICUM
+                       dumpinfo.WFileName = strdup(basename(WFileName));
+                       dumpinfo.dirfd = open(dirname(WFileName),
+                           O_DIRECTORY | O_RDONLY);
+                       if (dumpinfo.dirfd < 0) {
+                               error("unable to open directory %s",
+                                   dirname(WFileName));
+                       }
+                       cap_rights_init(&rights, CAP_CREATE, CAP_FCNTL,
+                           CAP_FTRUNCATE, CAP_LOOKUP, CAP_SEEK, CAP_WRITE);
+                       if (cap_rights_limit(dumpinfo.dirfd, &rights) < 0 &&
+                           errno != ENOSYS) {
+                               error("unable to limit directory rights");
+                       }
+#else  /* !HAVE_CAPSICUM */

                        dumpinfo.WFileName = WFileName;
                        dumpinfo.WFileName = WFileName;

+#endif
+                       callback = dump_packet_and_trunc;

                        dumpinfo.pd = pd;
                        dumpinfo.p = p;
                        pcap_userdata = (u_char *)&dumpinfo;
                        dumpinfo.pd = pd;
                        dumpinfo.p = p;
                        pcap_userdata = (u_char *)&dumpinfo;


@@ -1704,6 +1908,15 @@ main(int argc, char **argv)
                (void)fflush(stderr);
        }
 #endif /* WIN32 */
                (void)fflush(stderr);
        }
 #endif /* WIN32 */

+
+#ifdef HAVE_CAPSICUM
+       cansandbox = (nflag && VFileName == NULL && zflag == NULL);
+       if (cansandbox && cap_enter() < 0 && errno != ENOSYS)
+               error("unable to enter the capability mode");
+       if (cap_sandboxed())
+               fprintf(stderr, "capability mode sandbox enabled\n");
+#endif /* HAVE_CAPSICUM */
+

        do {
                status = pcap_loop(pd, cnt, callback, pcap_userdata);
                if (WFileName == NULL) {
        do {
                status = pcap_loop(pd, cnt, callback, pcap_userdata);
                if (WFileName == NULL) {


@@ -1751,6 +1964,13 @@ main(int argc, char **argv)
                                pd = pcap_open_offline(RFileName, ebuf);
                                if (pd == NULL)
                                        error("%s", ebuf);
                                pd = pcap_open_offline(RFileName, ebuf);
                                if (pd == NULL)
                                        error("%s", ebuf);

+#ifdef HAVE_CAPSICUM
+                               cap_rights_init(&rights, CAP_READ);
+                               if (cap_rights_limit(fileno(pcap_file(pd)),
+                                   &rights) < 0 && errno != ENOSYS) {
+                                       error("unable to limit pcap descriptor");
+                               }
+#endif

                                new_dlt = pcap_datalink(pd);
                                if (WFileName && new_dlt != dlt)
                                        error("%s: new dlt does not match original", RFileName);
                                new_dlt = pcap_datalink(pd);
                                if (WFileName && new_dlt != dlt)
                                        error("%s: new dlt does not match original", RFileName);


@@ -1919,6 +2139,9 @@ static void
 dump_packet_and_trunc(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
 {
        struct dump_info *dump_info;
 dump_packet_and_trunc(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
 {
        struct dump_info *dump_info;

+#ifdef HAVE_CAPSICUM
+       cap_rights_t rights;
+#endif

 
        ++packets_captured;
 
 
        ++packets_captured;
 


@@ -1947,6 +2170,11 @@ dump_packet_and_trunc(u_char *user, const struct pcap_pkthdr *h, const u_char *s
 
                /* If the time is greater than the specified window, rotate */
                if (t - Gflag_time >= Gflag) {
 
                /* If the time is greater than the specified window, rotate */
                if (t - Gflag_time >= Gflag) {

+#ifdef HAVE_CAPSICUM
+                       FILE *fp;
+                       int fd;
+#endif
+

                        /* Update the Gflag_time */
                        Gflag_time = t;
                        /* Update Gflag_count */
                        /* Update the Gflag_time */
                        Gflag_time = t;
                        /* Update Gflag_count */


@@ -1996,17 +2224,40 @@ dump_packet_and_trunc(u_char *user, const struct pcap_pkthdr *h, const u_char *s
                        else
                                MakeFilename(dump_info->CurrentFileName, dump_info->WFileName, 0, 0);
 
                        else
                                MakeFilename(dump_info->CurrentFileName, dump_info->WFileName, 0, 0);
 

-#ifdef HAVE_CAP_NG_H
+#ifdef HAVE_LIBCAP_NG

                        capng_update(CAPNG_ADD, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
                        capng_update(CAPNG_ADD, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);

-                       capng_apply(CAPNG_EFFECTIVE);
-#endif /* HAVE_CAP_NG_H */
+                       capng_apply(CAPNG_SELECT_BOTH);
+#endif /* HAVE_LIBCAP_NG */
+#ifdef HAVE_CAPSICUM
+                       fd = openat(dump_info->dirfd,
+                           dump_info->CurrentFileName,
+                           O_CREAT | O_WRONLY | O_TRUNC, 0644);
+                       if (fd < 0) {
+                               error("unable to open file %s",
+                                   dump_info->CurrentFileName);
+                       }
+                       fp = fdopen(fd, "w");
+                       if (fp == NULL) {
+                               error("unable to fdopen file %s",
+                                   dump_info->CurrentFileName);
+                       }
+                       dump_info->p = pcap_dump_fopen(dump_info->pd, fp);
+#else  /* !HAVE_CAPSICUM */

                        dump_info->p = pcap_dump_open(dump_info->pd, dump_info->CurrentFileName);
                        dump_info->p = pcap_dump_open(dump_info->pd, dump_info->CurrentFileName);

-#ifdef HAVE_CAP_NG_H
+#endif
+#ifdef HAVE_LIBCAP_NG

                        capng_update(CAPNG_DROP, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
                        capng_update(CAPNG_DROP, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);

-                       capng_apply(CAPNG_EFFECTIVE);
-#endif /* HAVE_CAP_NG_H */
+                       capng_apply(CAPNG_SELECT_BOTH);
+#endif /* HAVE_LIBCAP_NG */

                        if (dump_info->p == NULL)
                                error("%s", pcap_geterr(pd));
                        if (dump_info->p == NULL)
                                error("%s", pcap_geterr(pd));

+#ifdef HAVE_CAPSICUM
+                       cap_rights_init(&rights, CAP_SEEK, CAP_WRITE);
+                       if (cap_rights_limit(fileno(pcap_dump_file(dump_info->p)),
+                           &rights) < 0 && errno != ENOSYS) {
+                               error("unable to limit dump descriptor");
+                       }
+#endif

                }
        }
 
                }
        }
 


@@ -2015,32 +2266,74 @@ dump_packet_and_trunc(u_char *user, const struct pcap_pkthdr *h, const u_char *s
         * larger than Cflag - the last packet written to the
         * file could put it over Cflag.
         */
         * larger than Cflag - the last packet written to the
         * file could put it over Cflag.
         */

-       if (Cflag != 0 && pcap_dump_ftell(dump_info->p) > Cflag) {
-               /*
-                * Close the current file and open a new one.
-                */
-               pcap_dump_close(dump_info->p);
+       if (Cflag != 0) {
+               long size = pcap_dump_ftell(dump_info->p);

 
 

-               /*
-                * Compress the file we just closed, if the user asked for it
-                */
-               if (zflag != NULL)
-                       compress_savefile(dump_info->CurrentFileName);
+               if (size == -1)
+                       error("ftell fails on output file");
+               if (size > Cflag) {
+#ifdef HAVE_CAPSICUM
+                       FILE *fp;
+                       int fd;
+#endif
+
+                       /*
+                        * Close the current file and open a new one.
+                        */
+                       pcap_dump_close(dump_info->p);
+
+                       /*
+                        * Compress the file we just closed, if the user
+                        * asked for it.
+                        */
+                       if (zflag != NULL)
+                               compress_savefile(dump_info->CurrentFileName);

 
 

-               Cflag_count++;
-               if (Wflag > 0) {
-                       if (Cflag_count >= Wflag)
-                               Cflag_count = 0;
+                       Cflag_count++;
+                       if (Wflag > 0) {
+                               if (Cflag_count >= Wflag)
+                                       Cflag_count = 0;
+                       }
+                       if (dump_info->CurrentFileName != NULL)
+                               free(dump_info->CurrentFileName);
+                       dump_info->CurrentFileName = (char *)malloc(PATH_MAX + 1);
+                       if (dump_info->CurrentFileName == NULL)
+                               error("dump_packet_and_trunc: malloc");
+                       MakeFilename(dump_info->CurrentFileName, dump_info->WFileName, Cflag_count, WflagChars);
+#ifdef HAVE_LIBCAP_NG
+                       capng_update(CAPNG_ADD, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
+                       capng_apply(CAPNG_SELECT_BOTH);
+#endif /* HAVE_LIBCAP_NG */
+#ifdef HAVE_CAPSICUM
+                       fd = openat(dump_info->dirfd, dump_info->CurrentFileName,
+                           O_CREAT | O_WRONLY | O_TRUNC, 0644);
+                       if (fd < 0) {
+                               error("unable to open file %s",
+                                   dump_info->CurrentFileName);
+                       }
+                       fp = fdopen(fd, "w");
+                       if (fp == NULL) {
+                               error("unable to fdopen file %s",
+                                   dump_info->CurrentFileName);
+                       }
+                       dump_info->p = pcap_dump_fopen(dump_info->pd, fp);
+#else  /* !HAVE_CAPSICUM */
+                       dump_info->p = pcap_dump_open(dump_info->pd, dump_info->CurrentFileName);
+#endif
+#ifdef HAVE_LIBCAP_NG
+                       capng_update(CAPNG_DROP, CAPNG_EFFECTIVE, CAP_DAC_OVERRIDE);
+                       capng_apply(CAPNG_SELECT_BOTH);
+#endif /* HAVE_LIBCAP_NG */
+                       if (dump_info->p == NULL)
+                               error("%s", pcap_geterr(pd));
+#ifdef HAVE_CAPSICUM
+                       cap_rights_init(&rights, CAP_SEEK, CAP_WRITE);
+                       if (cap_rights_limit(fileno(pcap_dump_file(dump_info->p)),
+                           &rights) < 0 && errno != ENOSYS) {
+                               error("unable to limit dump descriptor");
+                       }
+#endif

                }
                }

-               if (dump_info->CurrentFileName != NULL)
-                       free(dump_info->CurrentFileName);
-               dump_info->CurrentFileName = (char *)malloc(PATH_MAX + 1);
-               if (dump_info->CurrentFileName == NULL)
-                       error("dump_packet_and_trunc: malloc");
-               MakeFilename(dump_info->CurrentFileName, dump_info->WFileName, Cflag_count, WflagChars);
-               dump_info->p = pcap_dump_open(dump_info->pd, dump_info->CurrentFileName);
-               if (dump_info->p == NULL)
-                       error("%s", pcap_geterr(pd));

        }
 
        pcap_dump((u_char *)dump_info->p, h, sp);
        }
 
        pcap_dump((u_char *)dump_info->p, h, sp);


@@ -2085,12 +2378,17 @@ print_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
 
        print_info = (struct print_info *)user;
         ndo = print_info->ndo;
 
        print_info = (struct print_info *)user;
         ndo = print_info->ndo;

+
+       if(ndo->ndo_packet_number)
+               ND_PRINT((ndo, "%5u  ", packets_captured));
+

        ts_print(ndo, &h->ts);
 
        /*
         * Some printers want to check that they're not walking off the
         * end of the packet.
        ts_print(ndo, &h->ts);
 
        /*
         * Some printers want to check that they're not walking off the
         * end of the packet.

-        * Rather than pass it all the way down, we set this global.
+        * Rather than pass it all the way down, we set this member
+        * of the netdissect_options structure.

         */
        ndo->ndo_snapend = sp + h->caplen;
 
         */
        ndo->ndo_snapend = sp + h->caplen;
 


@@ -2100,6 +2398,11 @@ print_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
                 hdrlen = (*print_info->p.printer)(h, sp);
         }
 
                 hdrlen = (*print_info->p.printer)(h, sp);
         }
 

+       /*
+        * Restore the original snapend, as a printer might have
+        * changed it.
+        */
+       ndo->ndo_snapend = sp + h->caplen;

        if (ndo->ndo_Xflag) {
                /*
                 * Print the raw packet data in hex and ASCII.
        if (ndo->ndo_Xflag) {
                /*
                 * Print the raw packet data in hex and ASCII.


@@ -2198,7 +2501,7 @@ print_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *sp)
 static void
 ndo_default_print(netdissect_options *ndo, const u_char *bp, u_int length)
 {
 static void
 ndo_default_print(netdissect_options *ndo, const u_char *bp, u_int length)
 {

-       hex_and_ascii_print(ndo, "\n\t", bp, length); /* pass on lf and identation string */
+       hex_and_ascii_print(ndo, "\n\t", bp, length); /* pass on lf and indentation string */

 }
 
 void
 }
 
 void


@@ -2240,8 +2543,9 @@ static void verbose_stats_dump(int sig _U_)
 }
 #endif
 
 }
 #endif
 

+USES_APPLE_DEPRECATED_API

 static void
 static void

-usage(void)
+print_version(void)

 {
        extern char version[];
 #ifndef HAVE_PCAP_LIB_VERSION
 {
        extern char version[];
 #ifndef HAVE_PCAP_LIB_VERSION


@@ -2268,23 +2572,46 @@ usage(void)
        (void)fprintf(stderr, "libpcap version %s\n", pcap_version);
 #endif /* WIN32 */
 #endif /* HAVE_PCAP_LIB_VERSION */
        (void)fprintf(stderr, "libpcap version %s\n", pcap_version);
 #endif /* WIN32 */
 #endif /* HAVE_PCAP_LIB_VERSION */

+
+#if defined(HAVE_LIBCRYPTO) && defined(SSLEAY_VERSION)
+       (void)fprintf (stderr, "%s\n", SSLeay_version(SSLEAY_VERSION));
+#endif
+
+#ifdef USE_LIBSMI
+       (void)fprintf (stderr, "SMI-library: %s\n", smi_version_string);
+#endif
+}
+USES_APPLE_RST
+
+static void
+print_usage(void)
+{
+       print_version();

        (void)fprintf(stderr,
        (void)fprintf(stderr,

-"Usage: %s [-aAbd" D_FLAG "efhH" I_FLAG J_FLAG "KlLnNOpqRStu" U_FLAG "vxX]" B_FLAG_USAGE " [ -c count ]\n", program_name);
+"Usage: %s [-aAbd" D_FLAG "efhH" I_FLAG J_FLAG "KlLnNOpqRStu" U_FLAG "vxX#]" B_FLAG_USAGE " [ -c count ]\n", program_name);

        (void)fprintf(stderr,
 "\t\t[ -C file_size ] [ -E algo:secret ] [ -F file ] [ -G seconds ]\n");
        (void)fprintf(stderr,
        (void)fprintf(stderr,
 "\t\t[ -C file_size ] [ -E algo:secret ] [ -F file ] [ -G seconds ]\n");
        (void)fprintf(stderr,

-"\t\t[ -i interface ]" j_FLAG_USAGE " [ -M secret ]\n");
+"\t\t[ -i interface ]" j_FLAG_USAGE " [ -M secret ] [ --number ]\n");

 #ifdef HAVE_PCAP_SETDIRECTION
        (void)fprintf(stderr,
 "\t\t[ -Q in|out|inout ]\n");
 #endif
        (void)fprintf(stderr,
 #ifdef HAVE_PCAP_SETDIRECTION
        (void)fprintf(stderr,
 "\t\t[ -Q in|out|inout ]\n");
 #endif
        (void)fprintf(stderr,

-"\t\t[ -r file ] [ -s snaplen ] [ -T type ] [ -V file ] [ -w file ]\n");
+"\t\t[ -r file ] [ -s snaplen ] ");
+#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION
+       (void)fprintf(stderr, "[ --time-stamp-precision precision ]\n");
+       (void)fprintf(stderr,
+"\t\t");
+#endif
+#ifdef HAVE_PCAP_SET_IMMEDIATE_MODE
+       (void)fprintf(stderr, "[ --immediate-mode ] ");
+#endif
+       (void)fprintf(stderr, "[ -T type ] [ --version ] [ -V file ]\n");

        (void)fprintf(stderr,
        (void)fprintf(stderr,

-"\t\t[ -W filecount ] [ -y datalinktype ] [ -z command ]\n");
+"\t\t[ -w file ] [ -W filecount ] [ -y datalinktype ] [ -z command ]\n");

        (void)fprintf(stderr,
 "\t\t[ -Z user ] [ expression ]\n");
        (void)fprintf(stderr,
 "\t\t[ -Z user ] [ expression ]\n");

-       exit(1);

 }
 
 
 }