diff --git a/acinclude.m4 b/acinclude.m4

index f962022..719bdbe 100644

--- a/acinclude.m4

+++ b/acinclude.m4

@@ -615,7 +615,7 @@ install a newer version of the header file.])

 	  AC_CHECK_FUNCS(pcap_datalink_val_to_description)

 	  AC_CHECK_FUNCS(pcap_list_datalinks pcap_set_datalink pcap_lib_version)

 	  AC_CHECK_FUNCS(pcap_get_selectable_fd pcap_free_datalinks)

-	  AC_CHECK_FUNCS(pcap_create bpf_image)

+	  AC_CHECK_FUNCS(pcap_create bpf_image pcap_set_tstamp_precision)

 	fi

 	LIBS="$ac_save_LIBS"

 ])

diff --git a/cmake/modules/FindPCAP.cmake b/cmake/modules/FindPCAP.cmake

index 1d3c1b6..bde07d7 100644

--- a/cmake/modules/FindPCAP.cmake

+++ b/cmake/modules/FindPCAP.cmake

@@ -121,6 +121,7 @@ CHECK_FUNCTION_EXISTS("pcap_get_selectable_fd" HAVE_PCAP_GET_SELECTABLE_FD)

 CHECK_FUNCTION_EXISTS("pcap_lib_version" HAVE_PCAP_LIB_VERSION)

 CHECK_FUNCTION_EXISTS("pcap_list_datalinks" HAVE_PCAP_LIST_DATALINKS)

 CHECK_FUNCTION_EXISTS("pcap_set_datalink" HAVE_PCAP_SET_DATALINK)

+CHECK_FUNCTION_EXISTS("pcap_set_tstamp_precision" HAVE_PCAP_SET_TSTAMP_PRECISION)

 # Remote pcap checks

 CHECK_FUNCTION_EXISTS("pcap_open" H_PCAP_OPEN)

 CHECK_FUNCTION_EXISTS("pcap_findalldevs_ex" H_FINDALLDEVS_EX)

diff --git a/cmakeconfig.h.in b/cmakeconfig.h.in

index 2ef36d1..fee55c5 100644

--- a/cmakeconfig.h.in

+++ b/cmakeconfig.h.in

@@ -252,6 +252,9 @@

 #cmakedefine HAVE_PCAP_REMOTE 1

 #cmakedefine HAVE_REMOTE 1

+/* Define to 1 if you have the `pcap_set_tstamp_precision' function. */

+#cmakedefine HAVE_PCAP_SET_TSTAMP_PRECISION 1

+

 /* Define to 1 if you have the <portaudio.h> header file. */

 #cmakedefine HAVE_PORTAUDIO_H 1

diff --git a/dumpcap.c b/dumpcap.c

index adba93d..bae3fbf 100644

--- a/dumpcap.c

+++ b/dumpcap.c

@@ -641,7 +641,12 @@ relinquish_all_capabilities(void)

 #endif

 static pcap_t *

-open_capture_device(interface_options *interface_opts,

+open_capture_device(capture_options *capture_opts

+#ifndef HAVE_PCAP_SET_TSTAMP_PRECISION

+                    _U_

+#endif

+                    ,

+                    interface_options *interface_opts,

                     char (*open_err_str)[PCAP_ERRBUF_SIZE])

 {

     pcap_t *pcap_h;

@@ -714,6 +719,31 @@ open_capture_device(interface_options *interface_opts,

             pcap_set_promisc(pcap_h, interface_opts->promisc_mode);

             pcap_set_timeout(pcap_h, CAP_READ_TIMEOUT);

+#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION

+            /*

+             * If we're writing pcap-ng files, try to enable

+             * nanosecond-resolution capture; any code that

+             * can read pcap-ng files must be able to handle

+             * nanosecond-resolution time stamps.

+             *

+             * If we're writing pcap files, don't try to enable

+             * nanosecond-resolution capture, as not all code

+             * that reads pcap files recognizes the nanosecond-

+             * resolution pcap file magic number.

+             */

+            if (capture_opts->use_pcapng) {

+                /*

+                 * The only errors this is documenting as returning

+                 * are PCAP_ERROR_TSTAMP_PRECISION_NOTSUP, which jus

+                 * means we can't do nanosecond precision on this adapter,

+                 * in which case we just live with whatever resolution

+                 * we get by default, and PCAP_ERROR_ACTIVATED, which

+                 * can't happen as we haven't activated the pcap_t yet.

+                 */

+                pcap_set_tstamp_precision(pcap_h, PCAP_TSTAMP_PRECISION_NANO);

+            }

+#endif

+

             g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,

                   "buffersize %d.", interface_opts->buffer_size);

             if (interface_opts->buffer_size != 0) {

@@ -913,7 +943,7 @@ show_filter_code(capture_options *capture_opts)

     for (j = 0; j < capture_opts->ifaces->len; j++) {

         interface_opts = g_array_index(capture_opts->ifaces, interface_options, j);

-        pcap_h = open_capture_device(&interface_opts, &open_err_str);

+        pcap_h = open_capture_device(capture_opts, &interface_opts, &open_err_str);

         if (pcap_h == NULL) {

             /* Open failed; get messages */

             get_capture_device_open_failure_messages(open_err_str,

@@ -2680,10 +2710,16 @@ capture_loop_open_input(capture_options *capture_opts, loop_data *ld,

         g_array_append_val(ld->pcaps, pcap_opts);

         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_open_input : %s", interface_opts.name);

-        pcap_opts->pcap_h = open_capture_device(&interface_opts, &open_err_str);

+        pcap_opts->pcap_h = open_capture_device(capture_opts, &interface_opts, &open_err_str);

         if (pcap_opts->pcap_h != NULL) {

             /* we've opened "iface" as a network device */

+

+#ifdef HAVE_PCAP_SET_TSTAMP_PRECISION

+        /* Find out if we're getting nanosecond-precision time stamps */

+        pcap_opts->ts_nsec = pcap_get_tstamp_precision(pcap_opts->pcap_h) == PCAP_TSTAMP_PRECISION_NANO;

+#endif

+

 #ifdef _WIN32

             /* try to set the capture buffer size */

             if (interface_opts.buffer_size > 1 &&

diff --git a/editcap.c b/editcap.c

index 9ba8245..8caa1bf 100644

--- a/editcap.c

+++ b/editcap.c

@@ -125,7 +125,6 @@ fd_hash_t fd_hash[MAX_DUP_DEPTH];

 int dup_window = DEFAULT_DUP_DEPTH;

 int cur_dup_entry = 0;

-#define ONE_MILLION 1000000

 #define ONE_BILLION 1000000000

 /* Weights of different errors we can introduce */

@@ -143,7 +142,7 @@ int cur_dup_entry = 0;

 struct time_adjustment {

-  struct timeval tv;

+  nstime_t tv;

   int is_negative;

 };

@@ -368,18 +367,18 @@ set_time_adjustment(char *optarg_str_p)

           exit(1);

       }

   }

-  time_adj.tv.tv_sec = val;

+  time_adj.tv.secs = val;

   /* now collect the partial seconds, if any */

   if (*frac != '\0') {             /* chars left, so get fractional part */

     val = strtol(&(frac[1]), &end, 10);

-    /* if more than 6 fractional digits truncate to 6 */

-    if((end - &(frac[1])) > 6) {

-        frac[7] = 't'; /* 't' for truncate */

+    /* if more than 9 fractional digits truncate to 9 */

+    if((end - &(frac[1])) > 9) {

+        frac[10] = 't'; /* 't' for truncate */

         val = strtol(&(frac[1]), &end, 10);

     }

     if (*frac != '.' || end == NULL || end == frac

-        || val < 0 || val > ONE_MILLION || val == LONG_MIN || val == LONG_MAX) {

+        || val < 0 || val > ONE_BILLION || val == LONG_MIN || val == LONG_MAX) {

       fprintf(stderr, "editcap: \"%s\" isn't a valid time adjustment\n",

               optarg_str_p);

       exit(1);

@@ -390,15 +389,15 @@ set_time_adjustment(char *optarg_str_p)

   }

   /* adjust fractional portion from fractional to numerator

-   * e.g., in "1.5" from 5 to 500000 since .5*10^6 = 500000 */

+   * e.g., in "1.5" from 5 to 500000000 since .5*10^9 = 500000000 */

   if (frac && end) {            /* both are valid */

     frac_digits = end - frac - 1;   /* fractional digit count (remember '.') */

-    while(frac_digits < 6) {    /* this is frac of 10^6 */

+    while(frac_digits < 9) {    /* this is frac of 10^9 */

       val *= 10;

       frac_digits++;

     }

   }

-  time_adj.tv.tv_usec = (int)val;

+  time_adj.tv.nsecs = (int) val;

 }

 static void

@@ -443,18 +442,18 @@ set_strict_time_adj(char *optarg_str_p)

           exit(1);

       }

   }

-  strict_time_adj.tv.tv_sec = val;

+  strict_time_adj.tv.secs = val;

   /* now collect the partial seconds, if any */

   if (*frac != '\0') {             /* chars left, so get fractional part */

     val = strtol(&(frac[1]), &end, 10);

-    /* if more than 6 fractional digits truncate to 6 */

-    if((end - &(frac[1])) > 6) {

-        frac[7] = 't'; /* 't' for truncate */

+    /* if more than 9 fractional digits truncate to 9 */

+    if((end - &(frac[1])) > 9) {

+        frac[10] = 't'; /* 't' for truncate */

         val = strtol(&(frac[1]), &end, 10);

     }

     if (*frac != '.' || end == NULL || end == frac

-        || val < 0 || val > ONE_MILLION || val == LONG_MIN || val == LONG_MAX) {

+        || val < 0 || val > ONE_BILLION || val == LONG_MIN || val == LONG_MAX) {

       fprintf(stderr, "editcap: \"%s\" isn't a valid time adjustment\n",

               optarg_str_p);

       exit(1);

@@ -465,15 +464,15 @@ set_strict_time_adj(char *optarg_str_p)

   }

   /* adjust fractional portion from fractional to numerator

-   * e.g., in "1.5" from 5 to 500000 since .5*10^6 = 500000 */

+   * e.g., in "1.5" from 5 to 500000000 since .5*10^9 = 500000000 */

   if (frac && end) {            /* both are valid */

     frac_digits = end - frac - 1;   /* fractional digit count (remember '.') */

-    while(frac_digits < 6) {    /* this is frac of 10^6 */

+    while(frac_digits < 9) {    /* this is frac of 10^9 */

       val *= 10;

       frac_digits++;

     }

   }

-  strict_time_adj.tv.tv_usec = (int)val;

+  strict_time_adj.tv.nsecs = (int) val;

 }

 static void

@@ -1319,14 +1318,14 @@ main(int argc, char *argv[])

                  */

                 /* printf("++out of order, need to adjust this packet!\n"); */

                 snap_phdr = *phdr;

-                snap_phdr.ts.secs = previous_time.secs + strict_time_adj.tv.tv_sec;

+                snap_phdr.ts.secs = previous_time.secs + strict_time_adj.tv.secs;

                 snap_phdr.ts.nsecs = previous_time.nsecs;

-                if (snap_phdr.ts.nsecs + strict_time_adj.tv.tv_usec * 1000 > ONE_MILLION * 1000) {

+                if (snap_phdr.ts.nsecs + strict_time_adj.tv.nsecs > ONE_BILLION) {

                   /* carry */

                   snap_phdr.ts.secs++;

-                  snap_phdr.ts.nsecs += (strict_time_adj.tv.tv_usec - ONE_MILLION) * 1000;

+                  snap_phdr.ts.nsecs += strict_time_adj.tv.nsecs - ONE_BILLION;

                 } else {

-                  snap_phdr.ts.nsecs += strict_time_adj.tv.tv_usec * 1000;

+                  snap_phdr.ts.nsecs += strict_time_adj.tv.nsecs;

                 }

                 phdr = &snap_phdr;

               }

@@ -1337,14 +1336,14 @@ main(int argc, char *argv[])

                * packet's timestamp plus delta.

                */

               snap_phdr = *phdr;

-              snap_phdr.ts.secs = previous_time.secs + strict_time_adj.tv.tv_sec;

+              snap_phdr.ts.secs = previous_time.secs + strict_time_adj.tv.secs;

               snap_phdr.ts.nsecs = previous_time.nsecs;

-              if (snap_phdr.ts.nsecs + strict_time_adj.tv.tv_usec * 1000 > ONE_MILLION * 1000) {

+              if (snap_phdr.ts.nsecs + strict_time_adj.tv.nsecs > ONE_BILLION) {

                 /* carry */

                 snap_phdr.ts.secs++;

-                snap_phdr.ts.nsecs += (strict_time_adj.tv.tv_usec - ONE_MILLION) * 1000;

+                snap_phdr.ts.nsecs += strict_time_adj.tv.nsecs - ONE_BILLION;

               } else {

-                snap_phdr.ts.nsecs += strict_time_adj.tv.tv_usec * 1000;

+                snap_phdr.ts.nsecs += strict_time_adj.tv.nsecs;

               }

               phdr = &snap_phdr;

             }

@@ -1355,32 +1354,32 @@ main(int argc, char *argv[])

         /* assume that if the frame's tv_sec is 0, then

          * the timestamp isn't supported */

-        if (phdr->ts.secs > 0 && time_adj.tv.tv_sec != 0) {

+        if (phdr->ts.secs > 0 && time_adj.tv.secs != 0) {

           snap_phdr = *phdr;

           if (time_adj.is_negative)

-            snap_phdr.ts.secs -= time_adj.tv.tv_sec;

+            snap_phdr.ts.secs -= time_adj.tv.secs;

           else

-            snap_phdr.ts.secs += time_adj.tv.tv_sec;

+            snap_phdr.ts.secs += time_adj.tv.secs;

           phdr = &snap_phdr;

         }

         /* assume that if the frame's tv_sec is 0, then

          * the timestamp isn't supported */

-        if (phdr->ts.secs > 0 && time_adj.tv.tv_usec != 0) {

+        if (phdr->ts.secs > 0 && time_adj.tv.nsecs != 0) {

           snap_phdr = *phdr;

           if (time_adj.is_negative) { /* subtract */

-            if (snap_phdr.ts.nsecs/1000 < time_adj.tv.tv_usec) { /* borrow */

+            if (snap_phdr.ts.nsecs < time_adj.tv.nsecs) { /* borrow */

               snap_phdr.ts.secs--;

-              snap_phdr.ts.nsecs += ONE_MILLION * 1000;

+              snap_phdr.ts.nsecs += ONE_BILLION;

             }

-            snap_phdr.ts.nsecs -= time_adj.tv.tv_usec * 1000;

+            snap_phdr.ts.nsecs -= time_adj.tv.nsecs;

           } else {                  /* add */

-            if (snap_phdr.ts.nsecs + time_adj.tv.tv_usec * 1000 > ONE_MILLION * 1000) {

+            if (snap_phdr.ts.nsecs + time_adj.tv.nsecs > ONE_BILLION) {

               /* carry */

               snap_phdr.ts.secs++;

-              snap_phdr.ts.nsecs += (time_adj.tv.tv_usec - ONE_MILLION) * 1000;

+              snap_phdr.ts.nsecs += time_adj.tv.nsecs - ONE_BILLION;

             } else {

-              snap_phdr.ts.nsecs += time_adj.tv.tv_usec * 1000;

+              snap_phdr.ts.nsecs += time_adj.tv.nsecs;

             }

           }

           phdr = &snap_phdr;

diff --git a/epan/column-utils.c b/epan/column-utils.c

index 6ed9f85..8e89409 100644

--- a/epan/column-utils.c

+++ b/epan/column-utils.c

@@ -675,6 +675,7 @@ set_abs_date_time(const frame_data *fd, gchar *buf, gboolean local)

 {

   struct tm *tmp;

   time_t then;

+  int tsprecision;

   if (fd->flags.has_ts) {

     then = fd->abs_ts.secs;

@@ -685,9 +686,33 @@ set_abs_date_time(const frame_data *fd, gchar *buf, gboolean local)

   } else

     tmp = NULL;

   if (tmp != NULL) {

-      switch(timestamp_get_precision()) {

-      case TS_PREC_FIXED_SEC:

-      case TS_PREC_AUTO_SEC:

+      switch (timestamp_get_precision()) {

+        case TS_PREC_FIXED_SEC:

+            tsprecision = WTAP_TSPREC_SEC;

+            break;

+        case TS_PREC_FIXED_DSEC:

+            tsprecision = WTAP_TSPREC_DSEC;

+            break;

+        case TS_PREC_FIXED_CSEC:

+            tsprecision = WTAP_TSPREC_CSEC;

+            break;

+        case TS_PREC_FIXED_MSEC:

+            tsprecision = WTAP_TSPREC_MSEC;

+            break;

+        case TS_PREC_FIXED_USEC:

+            tsprecision = WTAP_TSPREC_USEC;

+            break;

+        case TS_PREC_FIXED_NSEC:

+            tsprecision = WTAP_TSPREC_NSEC;

+            break;

+        case TS_PREC_AUTO:

+            tsprecision = fd->tsprec;

+            break;

+        default:

+            g_assert_not_reached();

+      }

+      switch(tsprecision) {

+      case WTAP_TSPREC_SEC:

           g_snprintf(buf, COL_MAX_LEN,"%04d-%02d-%02d %02d:%02d:%02d",

              tmp->tm_year + 1900,

              tmp->tm_mon + 1,

@@ -696,8 +721,7 @@ set_abs_date_time(const frame_data *fd, gchar *buf, gboolean local)

              tmp->tm_min,

              tmp->tm_sec);

           break;

-      case TS_PREC_FIXED_DSEC:

-      case TS_PREC_AUTO_DSEC:

+      case WTAP_TSPREC_DSEC:

           g_snprintf(buf, COL_MAX_LEN,"%04d-%02d-%02d %02d:%02d:%02d.%01d",

              tmp->tm_year + 1900,

              tmp->tm_mon + 1,

@@ -707,8 +731,7 @@ set_abs_date_time(const frame_data *fd, gchar *buf, gboolean local)

              tmp->tm_sec,

              fd->abs_ts.nsecs / 100000000);

           break;

-      case TS_PREC_FIXED_CSEC:

-      case TS_PREC_AUTO_CSEC:

+      case WTAP_TSPREC_CSEC:

           g_snprintf(buf, COL_MAX_LEN,"%04d-%02d-%02d %02d:%02d:%02d.%02d",

              tmp->tm_year + 1900,

              tmp->tm_mon + 1,

@@ -718,8 +741,7 @@ set_abs_date_time(const frame_data *fd, gchar *buf, gboolean local)

              tmp->tm_sec,

              fd->abs_ts.nsecs / 10000000);

           break;

-      case TS_PREC_FIXED_MSEC:

-      case TS_PREC_AUTO_MSEC:

+      case WTAP_TSPREC_MSEC:

           g_snprintf(buf, COL_MAX_LEN, "%04d-%02d-%02d %02d:%02d:%02d.%03d",

              tmp->tm_year + 1900,

              tmp->tm_mon + 1,

@@ -729,8 +751,7 @@ set_abs_date_time(const frame_data *fd, gchar *buf, gboolean local)

              tmp->tm_sec,

              fd->abs_ts.nsecs / 1000000);

           break;

-      case TS_PREC_FIXED_USEC:

-      case TS_PREC_AUTO_USEC:

+      case WTAP_TSPREC_USEC:

           g_snprintf(buf, COL_MAX_LEN, "%04d-%02d-%02d %02d:%02d:%02d.%06d",

              tmp->tm_year + 1900,

              tmp->tm_mon + 1,

@@ -740,8 +761,7 @@ set_abs_date_time(const frame_data *fd, gchar *buf, gboolean local)

              tmp->tm_sec,

              fd->abs_ts.nsecs / 1000);

           break;

-      case TS_PREC_FIXED_NSEC:

-      case TS_PREC_AUTO_NSEC:

+      case WTAP_TSPREC_NSEC:

           g_snprintf(buf, COL_MAX_LEN, "%04d-%02d-%02d %02d:%02d:%02d.%09d",

              tmp->tm_year + 1900,

              tmp->tm_mon + 1,

@@ -780,36 +800,57 @@ col_set_utc_date_time(const frame_data *fd, column_info *cinfo, const int col)

 }

 static void

-set_time_seconds(const nstime_t *ts, gchar *buf)

+set_time_seconds(const frame_data *fd, const nstime_t *ts, gchar *buf)

 {

-  switch(timestamp_get_precision()) {

-      case TS_PREC_FIXED_SEC:

-      case TS_PREC_AUTO_SEC:

+  int tsprecision;

+

+  switch (timestamp_get_precision()) {

+  case TS_PREC_FIXED_SEC:

+      tsprecision = WTAP_TSPREC_SEC;

+      break;

+  case TS_PREC_FIXED_DSEC:

+      tsprecision = WTAP_TSPREC_DSEC;

+      break;

+  case TS_PREC_FIXED_CSEC:

+      tsprecision = WTAP_TSPREC_CSEC;

+      break;

+  case TS_PREC_FIXED_MSEC:

+      tsprecision = WTAP_TSPREC_MSEC;

+      break;

+  case TS_PREC_FIXED_USEC:

+      tsprecision = WTAP_TSPREC_USEC;

+      break;

+  case TS_PREC_FIXED_NSEC:

+      tsprecision = WTAP_TSPREC_NSEC;

+      break;

+  case TS_PREC_AUTO:

+      tsprecision = fd->tsprec;

+      break;

+  default:

+      g_assert_not_reached();

+  }

+  switch(tsprecision) {

+      case WTAP_TSPREC_SEC:

           display_signed_time(buf, COL_MAX_LEN,

             (gint32) ts->secs, ts->nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);

           break;

-      case TS_PREC_FIXED_DSEC:

-      case TS_PREC_AUTO_DSEC:

+      case WTAP_TSPREC_DSEC:

           display_signed_time(buf, COL_MAX_LEN,

             (gint32) ts->secs, ts->nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);

           break;

-      case TS_PREC_FIXED_CSEC:

-      case TS_PREC_AUTO_CSEC:

+      case WTAP_TSPREC_CSEC:

           display_signed_time(buf, COL_MAX_LEN,

             (gint32) ts->secs, ts->nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);

           break;

-      case TS_PREC_FIXED_MSEC:

-      case TS_PREC_AUTO_MSEC:

+      case WTAP_TSPREC_MSEC:

           display_signed_time(buf, COL_MAX_LEN,

             (gint32) ts->secs, ts->nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);

           break;

-      case TS_PREC_FIXED_USEC:

-      case TS_PREC_AUTO_USEC:

+      case WTAP_TSPREC_USEC:

           display_signed_time(buf, COL_MAX_LEN,

             (gint32) ts->secs, ts->nsecs / 1000, TO_STR_TIME_RES_T_USECS);

           break;

-      case TS_PREC_FIXED_NSEC:

-      case TS_PREC_AUTO_NSEC:

+      case WTAP_TSPREC_NSEC:

           display_signed_time(buf, COL_MAX_LEN,

             (gint32) ts->secs, ts->nsecs, TO_STR_TIME_RES_T_NSECS);

           break;

@@ -819,11 +860,12 @@ set_time_seconds(const nstime_t *ts, gchar *buf)

 }

 static void

-set_time_hour_min_sec(const nstime_t *ts, gchar *buf)

+set_time_hour_min_sec(const frame_data *fd, const nstime_t *ts, gchar *buf)

 {

   time_t secs = ts->secs;

   long nsecs = (long) ts->nsecs;

   gboolean negative = FALSE;

+  int tsprecision;

   if (secs < 0) {

     secs = -secs;

@@ -834,9 +876,33 @@ set_time_hour_min_sec(const nstime_t *ts, gchar *buf)

     negative = TRUE;

   }

-  switch(timestamp_get_precision()) {

+  switch (timestamp_get_precision()) {

   case TS_PREC_FIXED_SEC:

-  case TS_PREC_AUTO_SEC:

+      tsprecision = WTAP_TSPREC_SEC;

+      break;

+  case TS_PREC_FIXED_DSEC:

+      tsprecision = WTAP_TSPREC_DSEC;

+      break;

+  case TS_PREC_FIXED_CSEC:

+      tsprecision = WTAP_TSPREC_CSEC;

+      break;

+  case TS_PREC_FIXED_MSEC:

+      tsprecision = WTAP_TSPREC_MSEC;

+      break;

+  case TS_PREC_FIXED_USEC:

+      tsprecision = WTAP_TSPREC_USEC;

+      break;

+  case TS_PREC_FIXED_NSEC:

+      tsprecision = WTAP_TSPREC_NSEC;

+      break;

+  case TS_PREC_AUTO:

+      tsprecision = fd->tsprec;

+      break;

+  default:

+      g_assert_not_reached();

+  }

+  switch(tsprecision) {

+  case WTAP_TSPREC_SEC:

     if (secs >= (60*60)) {

       g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2ds",

 		 negative ? "- " : "",

@@ -854,8 +920,7 @@ set_time_hour_min_sec(const nstime_t *ts, gchar *buf)

 		 (gint32) secs);

     }

     break;

-  case TS_PREC_FIXED_DSEC:

-  case TS_PREC_AUTO_DSEC:

+  case WTAP_TSPREC_DSEC:

     if (secs >= (60*60)) {

       g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%01lds",

 		 negative ? "- " : "",

@@ -876,8 +941,7 @@ set_time_hour_min_sec(const nstime_t *ts, gchar *buf)

 		 nsecs / 100000000);

     }

     break;

-  case TS_PREC_FIXED_CSEC:

-  case TS_PREC_AUTO_CSEC:

+  case WTAP_TSPREC_CSEC:

     if (secs >= (60*60)) {

       g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%02lds",

 		 negative ? "- " : "",

@@ -898,8 +962,7 @@ set_time_hour_min_sec(const nstime_t *ts, gchar *buf)

 		 nsecs / 10000000);

     }

     break;

-  case TS_PREC_FIXED_MSEC:

-  case TS_PREC_AUTO_MSEC:

+  case WTAP_TSPREC_MSEC:

     if (secs >= (60*60)) {

       g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%03lds",

 		 negative ? "- " : "",

@@ -920,8 +983,7 @@ set_time_hour_min_sec(const nstime_t *ts, gchar *buf)

 		 nsecs / 1000000);

     }

     break;

-  case TS_PREC_FIXED_USEC:

-  case TS_PREC_AUTO_USEC:

+  case WTAP_TSPREC_USEC:

     if (secs >= (60*60)) {

       g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%06lds",

 		 negative ? "- " : "",

@@ -942,8 +1004,7 @@ set_time_hour_min_sec(const nstime_t *ts, gchar *buf)

 		 nsecs / 1000);

     }

     break;

-  case TS_PREC_FIXED_NSEC:

-  case TS_PREC_AUTO_NSEC:

+  case WTAP_TSPREC_NSEC:

     if (secs >= (60*60)) {

       g_snprintf(buf, COL_MAX_LEN, "%s%dh %2dm %2d.%09lds",

 		 negative ? "- " : "",

@@ -978,14 +1039,14 @@ col_set_rel_time(const frame_data *fd, column_info *cinfo, const int col)

   }

   switch (timestamp_get_seconds_type()) {

   case TS_SECONDS_DEFAULT:

-    set_time_seconds(&fd->rel_ts, cinfo->col_buf[col]);

+    set_time_seconds(fd, &fd->rel_ts, cinfo->col_buf[col]);

     cinfo->col_expr.col_expr[col] = "frame.time_relative";

     g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);

     break;

   case TS_SECONDS_HOUR_MIN_SEC:

-    set_time_hour_min_sec(&fd->rel_ts, cinfo->col_buf[col]);

+    set_time_hour_min_sec(fd, &fd->rel_ts, cinfo->col_buf[col]);

     cinfo->col_expr.col_expr[col] = "frame.time_relative";

-    set_time_seconds(&fd->rel_ts, cinfo->col_expr.col_expr_val[col]);

+    set_time_seconds(fd, &fd->rel_ts, cinfo->col_expr.col_expr_val[col]);

     break;

   default:

     g_assert_not_reached();

@@ -1002,14 +1063,14 @@ col_set_delta_time(const frame_data *fd, column_info *cinfo, const int col)

   switch (timestamp_get_seconds_type()) {

   case TS_SECONDS_DEFAULT:

-    set_time_seconds(&del_cap_ts, cinfo->col_buf[col]);

+    set_time_seconds(fd, &del_cap_ts, cinfo->col_buf[col]);

     cinfo->col_expr.col_expr[col] = "frame.time_delta";

     g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);

     break;

   case TS_SECONDS_HOUR_MIN_SEC:

-    set_time_hour_min_sec(&del_cap_ts, cinfo->col_buf[col]);

+    set_time_hour_min_sec(fd, &del_cap_ts, cinfo->col_buf[col]);

     cinfo->col_expr.col_expr[col] = "frame.time_delta";

-    set_time_seconds(&del_cap_ts, cinfo->col_expr.col_expr_val[col]);

+    set_time_seconds(fd, &del_cap_ts, cinfo->col_expr.col_expr_val[col]);

     break;

   default:

     g_assert_not_reached();

@@ -1032,14 +1093,14 @@ col_set_delta_time_dis(const frame_data *fd, column_info *cinfo, const int col)

   switch (timestamp_get_seconds_type()) {

   case TS_SECONDS_DEFAULT:

-    set_time_seconds(&del_dis_ts, cinfo->col_buf[col]);

+    set_time_seconds(fd, &del_dis_ts, cinfo->col_buf[col]);

     cinfo->col_expr.col_expr[col] = "frame.time_delta_displayed";

     g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);

     break;

   case TS_SECONDS_HOUR_MIN_SEC:

-    set_time_hour_min_sec(&del_dis_ts, cinfo->col_buf[col]);

+    set_time_hour_min_sec(fd, &del_dis_ts, cinfo->col_buf[col]);

     cinfo->col_expr.col_expr[col] = "frame.time_delta_displayed";

-    set_time_seconds(&del_dis_ts, cinfo->col_expr.col_expr_val[col]);

+    set_time_seconds(fd, &del_dis_ts, cinfo->col_expr.col_expr_val[col]);

     break;

   default:

     g_assert_not_reached();

@@ -1053,6 +1114,7 @@ set_abs_time(const frame_data *fd, gchar *buf, gboolean local)

 {

   struct tm *tmp;

   time_t then;

+  int tsprecision;

   if (fd->flags.has_ts) {

     then = fd->abs_ts.secs;

@@ -1063,48 +1125,67 @@ set_abs_time(const frame_data *fd, gchar *buf, gboolean local)

   } else

     tmp = NULL;

   if (tmp != NULL) {

-      switch(timestamp_get_precision()) {

+      switch (timestamp_get_precision()) {

       case TS_PREC_FIXED_SEC:

-      case TS_PREC_AUTO_SEC:

+          tsprecision = WTAP_TSPREC_SEC;

+          break;

+      case TS_PREC_FIXED_DSEC:

+          tsprecision = WTAP_TSPREC_DSEC;

+          break;

+      case TS_PREC_FIXED_CSEC:

+          tsprecision = WTAP_TSPREC_CSEC;

+          break;

+      case TS_PREC_FIXED_MSEC:

+          tsprecision = WTAP_TSPREC_MSEC;

+          break;

+      case TS_PREC_FIXED_USEC:

+          tsprecision = WTAP_TSPREC_USEC;

+          break;

+      case TS_PREC_FIXED_NSEC:

+          tsprecision = WTAP_TSPREC_NSEC;

+          break;

+      case TS_PREC_AUTO:

+          tsprecision = fd->tsprec;

+          break;

+      default:

+          g_assert_not_reached();

+      }

+      switch(tsprecision) {

+      case WTAP_TSPREC_SEC:

           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d",

              tmp->tm_hour,

              tmp->tm_min,

              tmp->tm_sec);

           break;

-      case TS_PREC_FIXED_DSEC:

-      case TS_PREC_AUTO_DSEC:

+      case WTAP_TSPREC_DSEC:

           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%01d",

              tmp->tm_hour,

              tmp->tm_min,

              tmp->tm_sec,

              fd->abs_ts.nsecs / 100000000);

           break;

-      case TS_PREC_FIXED_CSEC:

-      case TS_PREC_AUTO_CSEC:

+      case WTAP_TSPREC_CSEC:

           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%02d",

              tmp->tm_hour,

              tmp->tm_min,

              tmp->tm_sec,

              fd->abs_ts.nsecs / 10000000);

           break;

-      case TS_PREC_FIXED_MSEC:

-      case TS_PREC_AUTO_MSEC:

+      case WTAP_TSPREC_MSEC:

           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%03d",

              tmp->tm_hour,

              tmp->tm_min,

              tmp->tm_sec,

              fd->abs_ts.nsecs / 1000000);

           break;

-      case TS_PREC_FIXED_USEC:

-      case TS_PREC_AUTO_USEC:

+      case WTAP_TSPREC_USEC:

           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%06d",

              tmp->tm_hour,

              tmp->tm_min,

              tmp->tm_sec,

              fd->abs_ts.nsecs / 1000);

           break;

-      case TS_PREC_FIXED_NSEC:

-      case TS_PREC_AUTO_NSEC:

+      case WTAP_TSPREC_NSEC:

           g_snprintf(buf, COL_MAX_LEN, "%02d:%02d:%02d.%09d",

              tmp->tm_hour,

              tmp->tm_min,

@@ -1143,38 +1224,59 @@ col_set_utc_time(const frame_data *fd, column_info *cinfo, const int col)

 static gboolean