/builds/wireshark/wireshark/capinfos.c

Bug Summary

File:	builds/wireshark/wireshark/capinfos.c
Warning:	line 1081, column 33 Read function called when stream is in EOF state. Function has no effect
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name capinfos.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -ffloat16-excess-precision=fast -fbfloat16-excess-precision=fast -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/builds/wireshark/wireshark/build -fcoverage-compilation-dir=/builds/wireshark/wireshark/build -resource-dir /usr/lib/llvm-22/lib/clang/22 -isystem /usr/include/glib-2.0 -isystem /usr/lib/x86_64-linux-gnu/glib-2.0/include -D CARES_NO_DEPRECATED -D G_DISABLE_DEPRECATED -D G_DISABLE_SINGLE_INCLUDES -D WS_DEBUG -D WS_DEBUG_UTF_8 -I /builds/wireshark/wireshark/build -I /builds/wireshark/wireshark -I /builds/wireshark/wireshark/include -I /builds/wireshark/wireshark/wiretap -D _GLIBCXX_ASSERTIONS -internal-isystem /usr/lib/llvm-22/lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/builds/wireshark/wireshark/= -fmacro-prefix-map=/builds/wireshark/wireshark/build/= -fmacro-prefix-map=../= -Wno-format-nonliteral -std=gnu17 -ferror-limit 19 -fvisibility=hidden -fwrapv -fwrapv-pointer -fstrict-flex-arrays=3 -stack-protector 2 -fstack-clash-protection -fcf-protection=full -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fexceptions -fcolor-diagnostics -analyzer-output=html -faddrsig -fdwarf2-cfi-asm -o /builds/wireshark/wireshark/sbout/2026-08-16-100800-3660-1 -x c /builds/wireshark/wireshark/capinfos.c
1/* capinfos.c
* Reports capture file information including # of packets, duration, others
*
* Copyright 2004 Ian Schorr
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <[email protected]>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/

13/*
* 2009-09-19: jyoung
*
* New capinfos features
*
* Continue processing additional files after
* a wiretap open failure.  The new -C option
* reverts to capinfos' original behavior which
* is to cancel any further file processing at
* first file open failure.
*
* Change the behavior of how the default display
* of all infos is initiated.  This gets rid of a
* special post getopt() argument count test.
*
* Add new table output format (with related options)
* This feature allows outputting the various infos
* into a tab delimited text file, or to a comma
* separated variables file (*.csv) instead of the
* original "long" format.
*
* 2011-04-05: wmeier
* behaviour changed: Upon exit capinfos will return
*  an error status if an error occurred at any
*  point during "continuous" file processing.
*  (Previously a success status was always
*   returned if the -C option was not used).
*
*/


44#include <config.h>
45#define WS_LOG_DOMAIN"Main"  LOG_DOMAIN_MAIN"Main"

47#include <stdio.h>
48#include <stdlib.h>
49#include <string.h>
50#include <stdarg.h>
51#include <locale.h>

53#include <ws_exit_codes.h>
54#include <wsutil/clopts_common.h>
55#include <wsutil/ws_getopt.h>

57#include <glib.h>

59#include <wiretap/wtap.h>

61#include <wsutil/cmdarg_err.h>
62#include <wsutil/filesystem.h>
63#include <app/application_flavor.h>
64#include <wsutil/file_compressed.h>
65#include <wsutil/privileges.h>
66#include <wsutil/version_info.h>
67#include <wsutil/report_message.h>
68#include <wiretap/wtap_opttypes.h>

70#ifdef HAVE_PLUGINS1
71#include <wsutil/plugins.h>
72#endif

74#include <wsutil/str_util.h>
75#include <wsutil/to_str.h>
76#include <wsutil/file_util.h>
77#include <wsutil/ws_assert.h>
78#include <wsutil/wslog.h>

80#include <gcrypt.h>

82#include "ui/failure_message.h"

84/*
* By default capinfos now continues processing
* the next filename if and when wiretap detects
* a problem opening or reading a file.
* Use the '-C' option to revert back to original
* capinfos behavior which is to abort any
* additional file processing at the first file
* open or read failure.
*/

94static bool_Bool stop_after_failure;

96/*
* table report variables
*/

100static bool_Bool long_report               = true1;  /* By default generate long report       */
101static bool_Bool table_report_header       = true1;  /* Generate column header by default     */
102static char field_separator           = '\t';  /* Use TAB as field separator by default */
103static char quote_char                = '\0';  /* Do NOT quote fields by default        */
104static bool_Bool machine_readable; /* Display machine-readable numbers      */

106/*
* capinfos has the ability to report on a number of
* various characteristics ("infos") for each input file.
*
* By default reporting of all info fields is enabled.
*
* Optionally the reporting of any specific info field
* or combination of info fields can be enabled with
* individual options.
*/

117static bool_Bool report_all_infos   = true1;  /* Report all infos           */

119static bool_Bool cap_file_type      = true1;  /* Report capture type        */
120static bool_Bool cap_file_encap     = true1;  /* Report encapsulation       */
121static bool_Bool cap_snaplen        = true1;  /* Packet size limit (snaplen)*/
122static bool_Bool cap_packet_count   = true1;  /* Report packet count        */
123static bool_Bool cap_file_size      = true1;  /* Report file size           */
124static bool_Bool cap_comment        = true1;  /* Display the capture comment */
125static bool_Bool cap_file_more_info = true1;  /* Report more file info      */
126static bool_Bool cap_file_idb       = true1;  /* Report Interface info      */
127static bool_Bool cap_file_nrb       = true1;  /* Report Name Resolution Block info      */
128static bool_Bool cap_file_dsb       = true1;  /* Report Decryption Secrets Block info      */

130static bool_Bool cap_data_size      = true1;  /* Report packet byte size    */
131static bool_Bool cap_duration       = true1;  /* Report capture duration    */
132static bool_Bool cap_earliest_packet_time = true1;  /* Report timestamp of earliest packet */
133static bool_Bool cap_latest_packet_time = true1;  /* Report timestamp of latest packet */
134static bool_Bool time_as_secs; /* Report time values as raw seconds */

136static bool_Bool cap_data_rate_byte = true1;  /* Report data rate bytes/sec */
137static bool_Bool cap_data_rate_bit  = true1;  /* Report data rate bites/sec */
138static bool_Bool cap_packet_size    = true1;  /* Report average packet size */
139static bool_Bool cap_packet_rate    = true1;  /* Report average packet rate */
140static bool_Bool cap_order          = true1;  /* Report if packets are in chronological order (True/False) */
141static bool_Bool pkt_comments       = true1;  /* Report individual packet comments */

143static bool_Bool cap_file_hashes    = true1;  /* Calculate file hashes */

145// Strongest to weakest
146#define HASH_SIZE_SHA25632 32
147#define HASH_SIZE_SHA120   20

149#define HASH_STR_SIZE(65) (65) /* Max hash size * 2 + '\0' */
150#define HASH_BUF_SIZE(1024 * 1024) (1024 * 1024)


153static char file_sha256[HASH_STR_SIZE(65)];
154static char file_sha1[HASH_STR_SIZE(65)];

156static char  *hash_buf;
157static gcry_md_hd_t hd;

159static unsigned int num_ipv4_addresses;
160static unsigned int num_ipv6_addresses;
161static unsigned int num_decryption_secrets;

163/*
* If we have at least two packets with time stamps, and they're not in
* order - i.e., the later packet has a time stamp older than the earlier
* packet - the time stamps are known not to be in order.
*
* If every packet has a time stamp, and they're all in order, the time
* stamp is known to be in order.
*
* Otherwise, we have no idea.
*/
173typedef enum {
  IN_ORDER,
  NOT_IN_ORDER,
  ORDER_UNKNOWN
177} order_t;

179typedef struct _pkt_cmt {
  uint32_t recno;
  char *cmt;
  struct _pkt_cmt *next;
183} pkt_cmt;

185typedef struct _capture_info {
  const char           *filename;
  uint16_t              file_type;
  ws_compression_type   compression_type;
  int                   file_encap;
  int                   file_tsprec;
  wtap                 *wth;
  int64_t               filesize;
  uint64_t              packet_bytes;
  bool_Bool                  times_known;
  nstime_t              earliest_packet_time;
  int                   earliest_packet_time_tsprec;
  nstime_t              latest_packet_time;
  int                   latest_packet_time_tsprec;
  uint32_t              packet_count;
  bool_Bool                  snap_set;                 /* If set in capture file header      */
  uint32_t              snaplen;                  /* value from the capture file header */
  uint32_t              snaplen_min_inferred;     /* If caplen < len for 1 or more rcds */
  uint32_t              snaplen_max_inferred;     /*  ...                               */
  bool_Bool                  drops_known;
  uint32_t              drop_count;

  nstime_t              duration;
  int                   duration_tsprec;
  double                packet_rate;
  double                packet_size;
  double                data_rate;                /* in bytes/s */
  bool_Bool                  know_order;
  order_t               order;

  int                  *encap_counts;             /* array of per_packet encap counts; array has one entry per wtap_encap type */
  pkt_cmt              *pkt_cmts;                 /* list of packet comments */

  unsigned int                 num_interfaces;           /* number of IDBs, and thus size of interface_packet_counts array */
  GArray               *interface_packet_counts;  /* array of per_packet interface_id counts; one entry per file IDB */
  uint32_t              pkt_interface_id_unknown; /* counts if packet interface_id didn't match a known one */
  GArray               *idb_info_strings;         /* array of IDB info strings */
222} capture_info;

224static char *decimal_point;

226static void
227enable_all_infos(void)
228{
  report_all_infos   = true1;

  cap_file_type      = true1;
  cap_file_encap     = true1;
  cap_snaplen        = true1;
  cap_packet_count   = true1;
  cap_file_size      = true1;
  cap_comment        = true1;
  pkt_comments       = true1;
  cap_file_more_info = true1;
  cap_file_idb       = true1;
  cap_file_nrb       = true1;
  cap_file_dsb       = true1;

  cap_data_size      = true1;
  cap_duration       = true1;
  cap_earliest_packet_time = true1;
  cap_latest_packet_time = true1;
  cap_order          = true1;

  cap_data_rate_byte = true1;
  cap_data_rate_bit  = true1;
  cap_packet_size    = true1;
  cap_packet_rate    = true1;

  cap_file_hashes    = true1;
255}

257static void
258disable_all_infos(void)
259{
  report_all_infos   = false0;

  cap_file_type      = false0;
  cap_file_encap     = false0;
  cap_snaplen        = false0;
  cap_packet_count   = false0;
  cap_file_size      = false0;
  cap_comment        = false0;
  pkt_comments       = false0;
  cap_file_more_info = false0;
  cap_file_idb       = false0;
  cap_file_nrb       = false0;
  cap_file_dsb       = false0;

  cap_data_size      = false0;
  cap_duration       = false0;
  cap_earliest_packet_time = false0;
  cap_latest_packet_time = false0;
  cap_order          = false0;

  cap_data_rate_byte = false0;
  cap_data_rate_bit  = false0;
  cap_packet_size    = false0;
  cap_packet_rate    = false0;

  cap_file_hashes    = false0;
286}

288static const char *
289order_string(order_t order)
290{
  switch (order) {

      case IN_ORDER:
          return "True";

      case NOT_IN_ORDER:
          return "False";

      case ORDER_UNKNOWN:
          return "Unknown";

      default:
          return "???";  /* "cannot happen" (the next step is "Profit!") */
  }
305}

307static char *
308absolute_time_string(nstime_t *timer, int tsprecision, capture_info *cf_info)
309{
  /*
   *    https://web.archive.org/web/20120513133703/http://www.idrbt.ac.in/publications/workingpapers/Working%20Paper%20No.%209.pdf
   *
   * says:
   *
   *    A 64-bit Unix time would be safe for the indefinite future, as
   *    this variable would not overflow until 2**63 or
   *    9,223,372,036,854,775,808 (over nine quintillion) seconds
   *    after the beginning of the Unix epoch - corresponding to
   *    GMT 15:30:08, Sunday, 4th December, 292,277,026,596.
   *
   * So, if we're displaying the time as YYYY-MM-DD HH:MM:SS.SSSSSSSSS,
   * we'll have the buffer be large enough for a date of the format
   * 292277026596-MM-DD HH:MM:SS.SSSSSSSSS, which is the biggest value
   * you'll get with a 64-bit time_t and a nanosecond-resolution
   * fraction-of-a-second.
   *
   * That's 12+1+2+1+2+1+2+1+2+2+2+1+9+1, including the terminating
   * \0, or 39.
   *
   * If we're displaying the time as epoch time, and the time is
   * unsigned, 2^64-1 is 18446744073709551615, so the buffer has
   * to be big enough for 18446744073709551615.999999999.  That's
   * 20+1+9+1, including the terminating '\0', or 31.  If it's
   * signed, 2^63 is 9223372036854775808, so the buffer has to
   * be big enough for -9223372036854775808.999999999, which is
   * again 20+1+9+1, or 31.
   *
   * So we go with 39.
   */
  static char time_string_buf[39];

  if (cf_info->times_known && cf_info->packet_count > 0) {
      if (time_as_secs) {
          display_epoch_time(time_string_buf, sizeof time_string_buf, timer, tsprecision);
      } else {
          format_nstime_as_iso8601(time_string_buf, sizeof time_string_buf, timer, decimal_point, true1, tsprecision);
      }
  } else {
      snprintf(time_string_buf, sizeof time_string_buf, "n/a");
  }
  return time_string_buf;
352}

354static char *
355relative_time_string(nstime_t *timer, int tsprecision, capture_info *cf_info, bool_Bool want_seconds)
356{
  const char  *second = want_seconds ? " second" : "";
  const char  *plural = want_seconds ? "s" : "";
  /*
   * If we're displaying the time as epoch time, and the time is
   * unsigned, 2^64-1 is 18446744073709551615, so the buffer has
   * to be big enough for "18446744073709551615.999999999 seconds".
   * That's 20+1+9+1+7+1, including the terminating '\0', or 39.
   * If it's signed, 2^63 is 9223372036854775808, so the buffer has to
   * be big enough for "-9223372036854775808.999999999 seconds",
   * which is again 20+1+9+1+7+1, or 39.
   */
  static char  time_string_buf[39];

  if (cf_info->times_known && cf_info->packet_count > 0) {
      char *ptr;
      size_t remaining;
      int num_bytes;

      ptr = time_string_buf;
      remaining = sizeof time_string_buf;
      num_bytes = snprintf(ptr, remaining,
                           "%"PRId64"l" "d",
                           (int64_t)timer->secs);
      if (num_bytes < 0) {
          /*
           * That got an error.
           * Not much else we can do.
           */
          snprintf(ptr, remaining, "snprintf() failed");
          return time_string_buf;
      }
      if ((unsigned int)num_bytes >= remaining) {
          /*
           * That filled up or would have overflowed the buffer.
           * Nothing more we can do.
           */
          return time_string_buf;
      }
      ptr += num_bytes;
      remaining -= num_bytes;

      if (tsprecision != 0) {
          /*
           * Append the fractional part.
           */
          num_bytes = format_fractional_part_nsecs(ptr, remaining, timer->nsecs, decimal_point, tsprecision);
          if ((unsigned int)num_bytes >= remaining) {
              /*
               * That filled up or would have overflowed the buffer.
               * Nothing more we can do.
               */
              return time_string_buf;
          }
          ptr += num_bytes;
          remaining -= num_bytes;
      }

      /*
       * Append the units.
       */
      snprintf(ptr, remaining, "%s%s",
               second,
               timer->secs == 1 ? "" : plural);

      return time_string_buf;
  }

  snprintf(time_string_buf, sizeof time_string_buf, "n/a");
  return time_string_buf;
426}

428static void print_value(const char *text_p1, int width, const char *text_p2, double value)
429{
  if (value > 0.0)
      printf("%s%.*f%s\n", text_p1, width, value, text_p2);
  else
      printf("%sn/a\n", text_p1);
434}

436/* multi-line comments would conflict with the formatting that capinfos uses
 we replace linefeeds with spaces */
438static void
439string_replace_newlines(char *str)
440{
  char *p;

  if (str) {
      p = str;
      while (*p != '\0') {
          if (*p == '\n')
              *p = ' ';
          if (*p == '\r')
              *p = ' ';
          p++;
      }
  }
453}

455static void
456show_option_string(const char *prefix, const char *option_str)
457{
  char *str;

  if (option_str != NULL((void*)0) && option_str[0] != '\0') {
      str = g_strdup(option_str)g_strdup_inline (option_str);
      string_replace_newlines(str);
      printf("%s%s\n", prefix, str);
      g_free(str)(__builtin_object_size ((str), 0) != ((size_t) - 1)) ? g_free_sized
 (str, __builtin_object_size ((str), 0)) : (g_free) (str);
  }
466}

468static void
469print_stats(const char *filename, capture_info *cf_info)
470{
  const char           *file_type_string, *file_encap_string;
  char                 *size_string;
  pkt_cmt              *p, *prev;

  /* Build printable strings for various stats */
  if (machine_readable) {
      file_type_string = wtap_file_type_subtype_name(cf_info->file_type);
      file_encap_string = wtap_encap_name(cf_info->file_encap);
  }
  else {
      file_type_string = wtap_file_type_subtype_description(cf_info->file_type);
      file_encap_string = wtap_encap_description(cf_info->file_encap);
  }

  if (filename)           printf     ("File name:           %s\n", filename);
  if (cap_file_type) {
      const char *compression_type_description;
      compression_type_description = ws_compression_type_description(cf_info->compression_type);
      if (compression_type_description == NULL((void*)0))
          printf     ("File type:           %s\n",
                  file_type_string);
      else
          printf     ("File type:           %s (%s)\n",
                  file_type_string, compression_type_description);
  }
  if (cap_file_encap) {
      printf      ("File encapsulation:  %s\n", file_encap_string);
      if (cf_info->file_encap == WTAP_ENCAP_PER_PACKET-1) {
          int i;
          printf    ("Encapsulation in use by packets (# of pkts):\n");
          for (i=0; i<WTAP_NUM_ENCAP_TYPESwtap_get_num_encap_types(); i++) {
              if (cf_info->encap_counts[i] > 0)
                  printf("                     %s (%d)\n",
                          wtap_encap_description(i), cf_info->encap_counts[i]);
          }
      }
  }
  if (cap_file_more_info) {
      printf      ("File timestamp precision:  %s (%d)\n",
              wtap_tsprec_string(cf_info->file_tsprec), cf_info->file_tsprec);
  }

  if (cap_snaplen && cf_info->snap_set)
      printf     ("Packet size limit:   file hdr: %u bytes\n", cf_info->snaplen);
  else if (cap_snaplen && !cf_info->snap_set)
      printf     ("Packet size limit:   file hdr: (not set)\n");
  if (cf_info->snaplen_max_inferred > 0) {
      if (cf_info->snaplen_min_inferred == cf_info->snaplen_max_inferred)
          printf     ("Packet size limit:   inferred: %u bytes\n", cf_info->snaplen_min_inferred);
      else
          printf     ("Packet size limit:   inferred: %u bytes - %u bytes (range)\n",
                  cf_info->snaplen_min_inferred, cf_info->snaplen_max_inferred);
  }
  if (cap_packet_count) {
      printf     ("Number of packets:   ");
      if (machine_readable) {
          printf ("%u\n", cf_info->packet_count);
      } else {
          size_string = format_size(cf_info->packet_count, FORMAT_SIZE_UNIT_NONE, 0)format_size_wmem(((void*)0), cf_info->packet_count, FORMAT_SIZE_UNIT_NONE
, 0);
          printf ("%s\n", size_string);
          g_free(size_string)(__builtin_object_size ((size_string), 0) != ((size_t) - 1)) ?
 g_free_sized (size_string, __builtin_object_size ((size_string
), 0)) : (g_free) (size_string);
      }
  }
  if (cap_file_size) {
      printf     ("File size:           ");
      if (machine_readable) {
          printf     ("%" PRId64"l" "d" " bytes\n", cf_info->filesize);
      } else {
          size_string = format_size(cf_info->filesize, FORMAT_SIZE_UNIT_BYTES, 0)format_size_wmem(((void*)0), cf_info->filesize, FORMAT_SIZE_UNIT_BYTES
, 0);
          printf ("%s\n", size_string);
          g_free(size_string)(__builtin_object_size ((size_string), 0) != ((size_t) - 1)) ?
 g_free_sized (size_string, __builtin_object_size ((size_string
), 0)) : (g_free) (size_string);
      }
  }
  if (cap_data_size) {
      printf     ("Data size:           ");
      if (machine_readable) {
          printf     ("%" PRIu64"l" "u" " bytes\n", cf_info->packet_bytes);
      } else {
          size_string = format_size(cf_info->packet_bytes, FORMAT_SIZE_UNIT_BYTES, 0)format_size_wmem(((void*)0), cf_info->packet_bytes, FORMAT_SIZE_UNIT_BYTES
, 0);
          printf ("%s\n", size_string);
          g_free(size_string)(__builtin_object_size ((size_string), 0) != ((size_t) - 1)) ?
 g_free_sized (size_string, __builtin_object_size ((size_string
), 0)) : (g_free) (size_string);
      }
  }
  if (cf_info->times_known) {
      if (cap_duration) /* XXX - shorten to hh:mm:ss */
          printf("Capture duration:    %s\n", relative_time_string(&cf_info->duration, cf_info->duration_tsprec, cf_info, true1));
      if (cap_earliest_packet_time)
          printf("Earliest packet time: %s\n", absolute_time_string(&cf_info->earliest_packet_time, cf_info->earliest_packet_time_tsprec, cf_info));
      if (cap_latest_packet_time)
          printf("Latest packet time:   %s\n", absolute_time_string(&cf_info->latest_packet_time, cf_info->latest_packet_time_tsprec, cf_info));
      if (cap_data_rate_byte) {
          printf("Data byte rate:      ");
          if (machine_readable) {
              print_value("", 2, " bytes/sec",   cf_info->data_rate);
          } else {
              size_string = format_size((int64_t)cf_info->data_rate, FORMAT_SIZE_UNIT_BYTES_S, 0)format_size_wmem(((void*)0), (int64_t)cf_info->data_rate, FORMAT_SIZE_UNIT_BYTES_S
, 0);
              printf ("%s\n", size_string);
              g_free(size_string)(__builtin_object_size ((size_string), 0) != ((size_t) - 1)) ?
 g_free_sized (size_string, __builtin_object_size ((size_string
), 0)) : (g_free) (size_string);
          }
      }
      if (cap_data_rate_bit) {
          printf("Data bit rate:       ");
          if (machine_readable) {
              print_value("", 2, " bits/sec",    cf_info->data_rate*8);
          } else {
              size_string = format_size((int64_t)(cf_info->data_rate*8), FORMAT_SIZE_UNIT_BITS_S, 0)format_size_wmem(((void*)0), (int64_t)(cf_info->data_rate*
8), FORMAT_SIZE_UNIT_BITS_S, 0);
              printf ("%s\n", size_string);
              g_free(size_string)(__builtin_object_size ((size_string), 0) != ((size_t) - 1)) ?
 g_free_sized (size_string, __builtin_object_size ((size_string
), 0)) : (g_free) (size_string);
          }
      }
  }
  if (cap_packet_size)    printf("Average packet size: %.2f bytes\n",        cf_info->packet_size);
  if (cf_info->times_known) {
      if (cap_packet_rate) {
          printf("Average packet rate: ");
          if (machine_readable) {
              print_value("", 2, " packets/sec", cf_info->packet_rate);
          } else {
              size_string = format_size((int64_t)cf_info->packet_rate, FORMAT_SIZE_UNIT_PACKETS_S, 0)format_size_wmem(((void*)0), (int64_t)cf_info->packet_rate
, FORMAT_SIZE_UNIT_PACKETS_S, 0);
              printf ("%s\n", size_string);
              g_free(size_string)(__builtin_object_size ((size_string), 0) != ((size_t) - 1)) ?
 g_free_sized (size_string, __builtin_object_size ((size_string
), 0)) : (g_free) (size_string);
          }
      }
  }
  if (cap_file_hashes) {
      printf     ("SHA256:              %s\n", file_sha256);
      printf     ("SHA1:                %s\n", file_sha1);
  }
  if (cap_order)          printf     ("Strict time order:   %s\n", order_string(cf_info->order));

  bool_Bool has_multiple_sections = (wtap_file_get_num_shbs(cf_info->wth) > 1);

  for (unsigned int section_number = 0;
          section_number < wtap_file_get_num_shbs(cf_info->wth);
          section_number++) {
      wtap_block_t shb;

      // If we have more than one section, add headers for each section.
      if (has_multiple_sections)
          printf("Section %u:\n\n", section_number);

      shb = wtap_file_get_shb(cf_info->wth, section_number);
      if (shb != NULL((void*)0)) {
          if (cap_file_more_info) {
              char *str;

              if (wtap_block_get_string_option_value(shb, OPT_SHB_HARDWARE2, &str) == WTAP_OPTTYPE_SUCCESS)
                  show_option_string("Capture hardware:    ", str);
              if (wtap_block_get_string_option_value(shb, OPT_SHB_OS3, &str) == WTAP_OPTTYPE_SUCCESS)
                  show_option_string("Capture oper-sys:    ", str);
              if (wtap_block_get_string_option_value(shb, OPT_SHB_USERAPPL4, &str) == WTAP_OPTTYPE_SUCCESS)
                  show_option_string("Capture application: ", str);
          }
          if (cap_comment) {
              unsigned int i;
              char *str;

              for (i = 0; wtap_block_get_nth_string_option_value(shb, OPT_COMMENT1, i, &str) == WTAP_OPTTYPE_SUCCESS; i++) {
                  show_option_string("Capture comment:     ", str);
              }
          }
      }
  }

  if (pkt_comments && cf_info->pkt_cmts != NULL((void*)0)) {
      for (p = cf_info->pkt_cmts; p != NULL((void*)0); prev = p, p = p->next, g_free(prev)(__builtin_object_size ((prev), 0) != ((size_t) - 1)) ? g_free_sized
 (prev, __builtin_object_size ((prev), 0)) : (g_free) (prev)) {
          if (machine_readable){
              char *escaped_cmt = g_strescape(p->cmt, NULL((void*)0));
              printf("Packet %u Comment:    %s\n", p->recno, escaped_cmt);
              g_free(escaped_cmt)(__builtin_object_size ((escaped_cmt), 0) != ((size_t) - 1)) ?
 g_free_sized (escaped_cmt, __builtin_object_size ((escaped_cmt
), 0)) : (g_free) (escaped_cmt);
          } else {
              printf("Packet %u Comment:    %s\n", p->recno, p->cmt);
          }
          g_free(p->cmt)(__builtin_object_size ((p->cmt), 0) != ((size_t) - 1)) ? g_free_sized
 (p->cmt, __builtin_object_size ((p->cmt), 0)) : (g_free
) (p->cmt);
      }
      cf_info->pkt_cmts = NULL((void*)0);
  }

  if (cap_file_idb && cf_info->num_interfaces != 0) {
      unsigned int i;
      ws_assert(cf_info->num_interfaces == cf_info->idb_info_strings->len)do { if ((1) && !(cf_info->num_interfaces == cf_info
->idb_info_strings->len)) ws_log_fatal_full("Main", LOG_LEVEL_ERROR
, "capinfos.c", 651, __func__, "assertion failed: %s", "cf_info->num_interfaces == cf_info->idb_info_strings->len"
); } while (0);
      printf     ("Number of interfaces in file: %u\n", cf_info->num_interfaces);
      for (i = 0; i < cf_info->idb_info_strings->len; i++) {
          char *s = g_array_index(cf_info->idb_info_strings, char*, i)(((char**) (void *) (cf_info->idb_info_strings)->data) [
(i)]);
          uint32_t packet_count = 0;
          if (i < cf_info->interface_packet_counts->len)
              packet_count = g_array_index(cf_info->interface_packet_counts, uint32_t, i)(((uint32_t*) (void *) (cf_info->interface_packet_counts)->
data) [(i)]);
          printf   ("Interface #%u info:\n", i);
          printf   ("%s", s);
          printf   ("                     Number of packets = %u\n", packet_count);
      }
  }

  if (cap_file_nrb) {
      if (num_ipv4_addresses != 0)
          printf   ("Number of resolved IPv4 addresses in file: %u\n", num_ipv4_addresses);
      if (num_ipv6_addresses != 0)
          printf   ("Number of resolved IPv6 addresses in file: %u\n", num_ipv6_addresses);
  }
  if (cap_file_dsb) {
      if (num_decryption_secrets != 0)
          printf   ("Number of decryption secrets in file: %u\n", num_decryption_secrets);
  }
674}

676static void
677putsep(void)
678{
  if (field_separator) putchar(field_separator);
680}

682static void
683putquote(void)
684{
  if (quote_char) putchar(quote_char);
686}

688static void G_GNUC_PRINTF(1, 2)__attribute__((__format__ (__printf__, 1, 2)))
689print_stats_table_header_label(const char *fmt, ...)
690{
  va_list ap;

  putsep();
  putquote();
  va_start(ap, fmt)__builtin_va_start(ap, fmt);
  vprintf(fmt, ap);
  va_end(ap)__builtin_va_end(ap);
  putquote();
699}

701static void
702print_stats_table_header(capture_info *cf_info)
703{
  pkt_cmt *p;

  putquote();
  printf("File name");
  putquote();

  if (cap_file_type)      print_stats_table_header_label("File type");
  if (cap_file_encap)     print_stats_table_header_label("File encapsulation");
  if (cap_file_more_info) print_stats_table_header_label("File time precision");
  if (cap_snaplen) {
      print_stats_table_header_label("Packet size limit");
      print_stats_table_header_label("Packet size limit min (inferred)");
      print_stats_table_header_label("Packet size limit max (inferred)");
  }
  if (cap_packet_count)   print_stats_table_header_label("Number of packets");
  if (cap_file_size)      print_stats_table_header_label("File size (bytes)");
  if (cap_data_size)      print_stats_table_header_label("Data size (bytes)");
  if (cap_duration)       print_stats_table_header_label("Capture duration (seconds)");
  if (cap_earliest_packet_time) print_stats_table_header_label("Start time");
  if (cap_latest_packet_time) print_stats_table_header_label("End time");
  if (cap_data_rate_byte) print_stats_table_header_label("Data byte rate (bytes/sec)");
  if (cap_data_rate_bit)  print_stats_table_header_label("Data bit rate (bits/sec)");
  if (cap_packet_size)    print_stats_table_header_label("Average packet size (bytes)");
  if (cap_packet_rate)    print_stats_table_header_label("Average packet rate (packets/sec)");
  if (cap_file_hashes) {
      print_stats_table_header_label("SHA256");
      print_stats_table_header_label("SHA1");
  }
  if (cap_order)          print_stats_table_header_label("Strict time order");
  if (cap_file_more_info) {
      print_stats_table_header_label("Capture hardware");
      print_stats_table_header_label("Capture oper-sys");
      print_stats_table_header_label("Capture application");
  }
  if (cap_comment)        print_stats_table_header_label("Capture comment");

  if (pkt_comments && cf_info->pkt_cmts != NULL((void*)0)) {
      for (p = cf_info->pkt_cmts; p != NULL((void*)0); p = p->next) {
          print_stats_table_header_label("Packet %u Comment", p->recno);
      }
  }

  printf("\n");
747}

749static void
750print_stats_table(const char *filename, capture_info *cf_info)
751{
  const char           *file_type_string, *file_encap_string;
  pkt_cmt               *p, *prev;

  /* Build printable strings for various stats */
  file_type_string = wtap_file_type_subtype_name(cf_info->file_type);
  file_encap_string = wtap_encap_name(cf_info->file_encap);

  if (filename) {
      putquote();
      printf("%s", filename);
      putquote();
  }

  if (cap_file_type) {
      putsep();
      putquote();
      printf("%s", file_type_string);
      putquote();
  }

  /* ToDo: If WTAP_ENCAP_PER_PACKET, show the list of encapsulations encountered;
   *       Output a line for each different encap with all fields repeated except
   *        the encapsulation field which has "Per Packet: ..." for each
   *        encapsulation type seen ?
   */
  if (cap_file_encap) {
      putsep();
      putquote();
      printf("%s", file_encap_string);
      putquote();
  }

  if (cap_file_more_info) {
      putsep();
      putquote();
      printf("%s", wtap_tsprec_string(cf_info->file_tsprec));
      putquote();
  }

  if (cap_snaplen) {
      putsep();
      putquote();
      if (cf_info->snap_set)
          printf("%u", cf_info->snaplen);
      else
          printf("(not set)");
      putquote();
      if (cf_info->snaplen_max_inferred > 0) {
          putsep();
          putquote();
          printf("%u", cf_info->snaplen_min_inferred);
          putquote();
          putsep();
          putquote();
          printf("%u", cf_info->snaplen_max_inferred);
          putquote();
      }
      else {
          putsep();
          putquote();
          printf("n/a");
          putquote();
          putsep();
          putquote();
          printf("n/a");
          putquote();
      }
  }

  if (cap_packet_count) {
      putsep();
      putquote();
      printf("%u", cf_info->packet_count);
      putquote();
  }

  if (cap_file_size) {
      putsep();
      putquote();
      printf("%" PRId64"l" "d", cf_info->filesize);
      putquote();
  }

  if (cap_data_size) {
      putsep();
      putquote();
      printf("%" PRIu64"l" "u", cf_info->packet_bytes);
      putquote();
  }

  if (cap_duration) {
      putsep();
      putquote();
      printf("%s", relative_time_string(&cf_info->duration, cf_info->duration_tsprec, cf_info, false0));
      putquote();
  }

  if (cap_earliest_packet_time) {
      putsep();
      putquote();
      printf("%s", absolute_time_string(&cf_info->earliest_packet_time, cf_info->earliest_packet_time_tsprec, cf_info));
      putquote();
  }

  if (cap_latest_packet_time) {
      putsep();
      putquote();
      printf("%s", absolute_time_string(&cf_info->latest_packet_time, cf_info->latest_packet_time_tsprec, cf_info));
      putquote();
  }

  if (cap_data_rate_byte) {
      putsep();
      putquote();
      if (cf_info->times_known)
          printf("%.2f", cf_info->data_rate);
      else
          printf("n/a");
      putquote();
  }

  if (cap_data_rate_bit) {
      putsep();
      putquote();
      if (cf_info->times_known)
          printf("%.2f", cf_info->data_rate*8);
      else
          printf("n/a");
      putquote();
  }

  if (cap_packet_size) {
      putsep();
      putquote();
      printf("%.2f", cf_info->packet_size);
      putquote();
  }

  if (cap_packet_rate) {
      putsep();
      putquote();
      if (cf_info->times_known)
          printf("%.2f", cf_info->packet_rate);
      else
          printf("n/a");
      putquote();
  }

  if (cap_file_hashes) {
      putsep();
      putquote();
      printf("%s", file_sha256);
      putquote();

      putsep();
      putquote();
      printf("%s", file_sha1);
      putquote();
  }

  if (cap_order) {
      putsep();
      putquote();
      printf("%s", order_string(cf_info->order));
      putquote();
  }

  for (unsigned section_number = 0;
          section_number < wtap_file_get_num_shbs(cf_info->wth);
          section_number++) {
      wtap_block_t shb;

      shb = wtap_file_get_shb(cf_info->wth, section_number);
      if (cap_file_more_info) {
          char *str;

          putsep();
          putquote();
          if (wtap_block_get_string_option_value(shb, OPT_SHB_HARDWARE2, &str) == WTAP_OPTTYPE_SUCCESS) {
              printf("%s", str);
          }
          putquote();

          putsep();
          putquote();
          if (wtap_block_get_string_option_value(shb, OPT_SHB_OS3, &str) == WTAP_OPTTYPE_SUCCESS) {
              printf("%s", str);
          }
          putquote();

          putsep();
          putquote();
          if (wtap_block_get_string_option_value(shb, OPT_SHB_USERAPPL4, &str) == WTAP_OPTTYPE_SUCCESS) {
              printf("%s", str);
          }
          putquote();
      }

      /*
       * One might argue that the following is silly to put into a table format,
       * but oh well note that there may be *more than one* of each of these types
       * of options.  To mitigate some of the potential silliness the if(cap_comment)
       * block is moved AFTER the if(cap_file_more_info) block.  This will make any
       * comments the last item(s) in each row.  We now have a new -K option to
       * disable cap_comment to more easily manage the potential silliness.
       * Potential silliness includes multiple comments (therefore resulting in
       * more than one additional column and/or comments with embedded newlines
       * and/or possible delimiters).
       *
       * To mitigate embedded newlines and other special characters, use -M
       */
      if (cap_comment) {
          unsigned int i;
          char *opt_comment;
          bool_Bool have_cap = false0;

          for (i = 0; wtap_block_get_nth_string_option_value(shb, OPT_COMMENT1, i, &opt_comment) == WTAP_OPTTYPE_SUCCESS; i++) {
              have_cap = true1;
              putsep();
              putquote();
              if (machine_readable){
                  opt_comment = g_strescape(opt_comment, NULL((void*)0));
                  printf("%s", opt_comment);
                  g_free(opt_comment)(__builtin_object_size ((opt_comment), 0) != ((size_t) - 1)) ?
 g_free_sized (opt_comment, __builtin_object_size ((opt_comment
), 0)) : (g_free) (opt_comment);
              } else {
                  printf("%s", opt_comment);
              }
              putquote();
          }
          if(!have_cap) {
              /* Maintain column alignment when we have no OPT_COMMENT */
              putsep();
              putquote();
              putquote();
          }
      }

  }

  if (pkt_comments && cf_info->pkt_cmts != NULL((void*)0)) {
      for(p = cf_info->pkt_cmts; p != NULL((void*)0); prev = p, p = p->next, g_free(prev)(__builtin_object_size ((prev), 0) != ((size_t) - 1)) ? g_free_sized
 (prev, __builtin_object_size ((prev), 0)) : (g_free) (prev)) {
          putsep();
          putquote();
          if (machine_readable) {
              char *escaped_cmt = g_strescape(p->cmt, NULL((void*)0));
              printf("%s", escaped_cmt);
              g_free(escaped_cmt)(__builtin_object_size ((escaped_cmt), 0) != ((size_t) - 1)) ?
 g_free_sized (escaped_cmt, __builtin_object_size ((escaped_cmt
), 0)) : (g_free) (escaped_cmt);
          } else {
              printf("%s", p->cmt);
          }
          g_free(p->cmt)(__builtin_object_size ((p->cmt), 0) != ((size_t) - 1)) ? g_free_sized
 (p->cmt, __builtin_object_size ((p->cmt), 0)) : (g_free
) (p->cmt);
          putquote();
      }
      cf_info->pkt_cmts = NULL((void*)0);
  }

  printf("\n");
1009}

1011static void
1012cleanup_capture_info(capture_info *cf_info)
1013{
  pkt_cmt *p, *prev;
  unsigned int i;
  ws_assert(cf_info != NULL)do { if ((1) && !(cf_info != ((void*)0))) ws_log_fatal_full
("Main", LOG_LEVEL_ERROR, "capinfos.c", 1016, __func__, "assertion failed: %s"
, "cf_info != ((void*)0)"); } while (0);

  g_free(cf_info->encap_counts)(__builtin_object_size ((cf_info->encap_counts), 0) != ((size_t
) - 1)) ? g_free_sized (cf_info->encap_counts, __builtin_object_size
 ((cf_info->encap_counts), 0)) : (g_free) (cf_info->encap_counts
);
  cf_info->encap_counts = NULL((void*)0);

  g_array_free(cf_info->interface_packet_counts, true1);
  cf_info->interface_packet_counts = NULL((void*)0);

  if (cf_info->idb_info_strings) {
      for (i = 0; i < cf_info->idb_info_strings->len; i++) {
          char *s = g_array_index(cf_info->idb_info_strings, char*, i)(((char**) (void *) (cf_info->idb_info_strings)->data) [
(i)]);
          g_free(s)(__builtin_object_size ((s), 0) != ((size_t) - 1)) ? g_free_sized
 (s, __builtin_object_size ((s), 0)) : (g_free) (s);
      }
      g_array_free(cf_info->idb_info_strings, true1);
  }
  cf_info->idb_info_strings = NULL((void*)0);

  for(p = cf_info->pkt_cmts; p != NULL((void*)0); prev = p, p = p->next, g_free(prev)(__builtin_object_size ((prev), 0) != ((size_t) - 1)) ? g_free_sized
 (prev, __builtin_object_size ((prev), 0)) : (g_free) (prev)) {
      g_free(p->cmt)(__builtin_object_size ((p->cmt), 0) != ((size_t) - 1)) ? g_free_sized
 (p->cmt, __builtin_object_size ((p->cmt), 0)) : (g_free
) (p->cmt);
  }
  cf_info->pkt_cmts = NULL((void*)0);
1037}

1039static void
1040count_ipv4_address(const unsigned int addr _U___attribute__((unused)), const char *name _U___attribute__((unused)), const bool_Bool static_entry _U___attribute__((unused)))
1041{
  num_ipv4_addresses++;
1043}

1045static void
1046count_ipv6_address(const ws_in6_addr *addrp _U___attribute__((unused)), const char *name _U___attribute__((unused)), const bool_Bool static_entry _U___attribute__((unused)))
1047{
  num_ipv6_addresses++;
1049}

1051static void
1052count_decryption_secret(uint32_t secrets_type _U___attribute__((unused)), const void *secrets _U___attribute__((unused)), unsigned int size _U___attribute__((unused)))
1053{
  /* XXX - count them based on the secrets type (which is an opaque code,
     not a small integer)? */
  num_decryption_secrets++;
1057}

1059static void
1060hash_to_str(const unsigned char *hash, size_t length, char *str)
1061{
  int i;

  for (i = 0; i < (int) length; i++) {
      snprintf(str+(i*2), 3, "%02x", hash[i]);
  }
1067}

1069static void
1070calculate_hashes(const char *filename)
1071{
  FILE  *fh;
  size_t hash_bytes;

  (void) g_strlcpy(file_sha256, "<unknown>", HASH_STR_SIZE(65));
  (void) g_strlcpy(file_sha1, "<unknown>", HASH_STR_SIZE(65));

  if (cap_file_hashes) {
18
←
Assuming 'cap_file_hashes' is true→
19
←
Taking true branch→
      fh = ws_fopenfopen(filename, "rb");
      if (fh19.1
'fh' is non-null
 && hd) {
20
←
Assuming 'hd' is non-null→
21
←
Taking true branch→
          while((hash_bytes = fread(hash_buf, 1, HASH_BUF_SIZE(1024 * 1024), fh)) > 0) {
22
←
Assuming stream reaches end-of-file here→
23
←
Assuming the condition is true→
24
←
Loop condition is true.  Entering loop body→
25
←
Read function called when stream is in EOF state. Function has no effect
              gcry_md_write(hd, hash_buf, hash_bytes);
          }
          gcry_md_final(hd)gcry_md_ctl ((hd), GCRYCTL_FINALIZE, ((void*)0), 0);
          hash_to_str(gcry_md_read(hd, GCRY_MD_SHA256), HASH_SIZE_SHA25632, file_sha256);
          hash_to_str(gcry_md_read(hd, GCRY_MD_SHA1), HASH_SIZE_SHA120, file_sha1);
      }
      if (fh) fclose(fh);
      if (hd) gcry_md_reset(hd);
  }
1091}

1093static int
1094process_cap_file(const char *filename, bool_Bool need_separator)
1095{
  int                   status = 0;
  int                   err;
  char                 *err_info;
  int64_t               size;
  int64_t               data_offset;

  uint32_t              packet = 0;
  int64_t               bytes  = 0;
  uint32_t              snaplen_min_inferred = 0xffffffff;
  uint32_t              snaplen_max_inferred =          0;
  wtap_rec              rec;
  capture_info          cf_info;
  bool_Bool                  have_times = true1;
  nstime_t              earliest_packet_time;
  int                   earliest_packet_time_tsprec;
  nstime_t              latest_packet_time;
  int                   latest_packet_time_tsprec;
  nstime_t              cur_time;
  nstime_t              prev_time;
  bool_Bool                  know_order = false0;
  order_t               order = IN_ORDER;
  unsigned int                 i;
  wtapng_iface_descriptions_t *idb_info;

  pkt_cmt *pc = NULL((void*)0), *prev = NULL((void*)0);

  cf_info.wth = wtap_open_offline(filename, WTAP_TYPE_AUTO0, &err, &err_info, false0, application_configuration_environment_prefix());
  if (!cf_info.wth) {
15
←
Assuming field 'wth' is non-null→
16
←
Taking false branch→
      report_cfile_open_failure(filename, err, err_info);
      return 2;
  }

  /*
   * Calculate the checksums. Do this after wtap_open_offline, so we don't
   * bother calculating them for files that are not known capture types
   * where we wouldn't print them anyway.
   */
  calculate_hashes(filename);
17
←
Calling 'calculate_hashes'→

  if (need_separator && long_report) {
      printf("\n");
  }

  nstime_set_zero(&earliest_packet_time);
  earliest_packet_time_tsprec = WTAP_TSPREC_UNKNOWN-2;
  nstime_set_zero(&latest_packet_time);
  latest_packet_time_tsprec = WTAP_TSPREC_UNKNOWN-2;
  nstime_set_zero(&cur_time);
  nstime_set_zero(&prev_time);

  cf_info.encap_counts = g_new0(int,WTAP_NUM_ENCAP_TYPES)((int *) g_malloc0_n ((wtap_get_num_encap_types()), sizeof (int
)));

  idb_info = wtap_file_get_idb_info(cf_info.wth);

  ws_assert(idb_info->interface_data != NULL)do { if ((1) && !(idb_info->interface_data != ((void
*)0))) ws_log_fatal_full("Main", LOG_LEVEL_ERROR, "capinfos.c"
, 1150, __func__, "assertion failed: %s", "idb_info->interface_data != ((void*)0)"
); } while (0);

  cf_info.pkt_cmts = NULL((void*)0);
  cf_info.num_interfaces = idb_info->interface_data->len;
  cf_info.interface_packet_counts  = g_array_sized_new(false0, true1, sizeof(uint32_t), cf_info.num_interfaces);
  g_array_set_size(cf_info.interface_packet_counts, cf_info.num_interfaces);
  cf_info.pkt_interface_id_unknown = 0;

  g_free(idb_info)(__builtin_object_size ((idb_info), 0) != ((size_t) - 1)) ? g_free_sized
 (idb_info, __builtin_object_size ((idb_info), 0)) : (g_free)
 (idb_info);
  idb_info = NULL((void*)0);

  /* Zero out the counters for the callbacks. */
  num_ipv4_addresses = 0;
  num_ipv6_addresses = 0;
  num_decryption_secrets = 0;

  /* Register callbacks for new name<->address maps from the file and
     decryption secrets from the file. */
  wtap_set_cb_new_ipv4(cf_info.wth, count_ipv4_address);
  wtap_set_cb_new_ipv6(cf_info.wth, count_ipv6_address);
  wtap_set_cb_new_secrets(cf_info.wth, count_decryption_secret);

  /* Tally up data that we need to parse through the file to find */
  wtap_rec_init(&rec, DEFAULT_INIT_BUFFER_SIZE_2048(2 * 1024));
  while (wtap_read(cf_info.wth, &rec, &err, &err_info, &data_offset))  {
      if (rec.presence_flags & WTAP_HAS_TS0x00000001) {
          prev_time = cur_time;
          cur_time = rec.ts;
          if (packet == 0) {
              earliest_packet_time = rec.ts;
              earliest_packet_time_tsprec = rec.tsprec;
              latest_packet_time  = rec.ts;
              latest_packet_time_tsprec = rec.tsprec;
              prev_time  = rec.ts;
          }
          if (nstime_cmp(&cur_time, &prev_time) < 0) {
              order = NOT_IN_ORDER;
          }
          if (nstime_cmp(&cur_time, &earliest_packet_time) < 0) {
              earliest_packet_time = cur_time;
              earliest_packet_time_tsprec = rec.tsprec;
          }
          if (nstime_cmp(&cur_time, &latest_packet_time) > 0) {
              latest_packet_time = cur_time;
              latest_packet_time_tsprec = rec.tsprec;
          }
      } else {
          have_times = false0; /* at least one packet has no time stamp */
          if (order != NOT_IN_ORDER)
              order = ORDER_UNKNOWN;
      }

      if (rec.rec_type == REC_TYPE_PACKET0) {
          bytes += rec.rec_header.packet_header.len;
          packet++;
          /* packet comments */
          if (pkt_comments && wtap_block_count_option(rec.block, OPT_COMMENT1) > 0) {
              char *cmt_buff;
              for (i = 0; wtap_block_get_nth_string_option_value(rec.block, OPT_COMMENT1, i, &cmt_buff) == WTAP_OPTTYPE_SUCCESS; i++) {
                  pc = g_new0(pkt_cmt, 1)((pkt_cmt *) g_malloc0_n ((1), sizeof (pkt_cmt)));

                  pc->recno = packet;
                  pc->cmt = g_strdup(cmt_buff)g_strdup_inline (cmt_buff);
                  pc->next = NULL((void*)0);

                  if (prev == NULL((void*)0))
                      cf_info.pkt_cmts = pc;
                  else
                      prev->next = pc;

                  prev = pc;
              }
          }

          /* If caplen < len for a rcd, then presumably           */
          /* 'Limit packet capture length' was done for this rcd. */
          /* Keep track as to the min/max actual snapshot lengths */
          /*  seen for this file.                                 */
          if (rec.rec_header.packet_header.caplen < rec.rec_header.packet_header.len) {
              if (rec.rec_header.packet_header.caplen < snaplen_min_inferred)
                  snaplen_min_inferred = rec.rec_header.packet_header.caplen;
              if (rec.rec_header.packet_header.caplen > snaplen_max_inferred)
                  snaplen_max_inferred = rec.rec_header.packet_header.caplen;
          }

          if ((rec.rec_header.packet_header.pkt_encap > 0) &&
                  (rec.rec_header.packet_header.pkt_encap < WTAP_NUM_ENCAP_TYPESwtap_get_num_encap_types())) {
              cf_info.encap_counts[rec.rec_header.packet_header.pkt_encap] += 1;
          } else {
              fprintf(stderrstderr, "capinfos: Unknown packet encapsulation %d in frame %u of file \"%s\"\n",
                      rec.rec_header.packet_header.pkt_encap, packet, filename);
          }

          /* Packet interface_id info */
          if (rec.presence_flags & WTAP_HAS_INTERFACE_ID0x00000004) {
              /* cf_info.num_interfaces is size, not index, so it's one more than max index */
              if (rec.rec_header.packet_header.interface_id >= cf_info.num_interfaces) {
                  /*
                   * OK, re-fetch the number of interfaces, as there might have
                   * been an interface that was in the middle of packets, and
                   * grow the array to be big enough for the new number of
                   * interfaces.
                   */
                  idb_info = wtap_file_get_idb_info(cf_info.wth);

                  cf_info.num_interfaces = idb_info->interface_data->len;
                  g_array_set_size(cf_info.interface_packet_counts, cf_info.num_interfaces);

                  g_free(idb_info)(__builtin_object_size ((idb_info), 0) != ((size_t) - 1)) ? g_free_sized
 (idb_info, __builtin_object_size ((idb_info), 0)) : (g_free)
 (idb_info);
                  idb_info = NULL((void*)0);
              }
              if (rec.rec_header.packet_header.interface_id < cf_info.num_interfaces) {
                  g_array_index(cf_info.interface_packet_counts, uint32_t,(((uint32_t*) (void *) (cf_info.interface_packet_counts)->
data) [(rec.rec_header.packet_header.interface_id)])
                          rec.rec_header.packet_header.interface_id)(((uint32_t*) (void *) (cf_info.interface_packet_counts)->
data) [(rec.rec_header.packet_header.interface_id)]) += 1;
              }
              else {
                  cf_info.pkt_interface_id_unknown += 1;
              }
          }
          else {
              /* it's for interface_id 0 */
              if (cf_info.num_interfaces != 0) {
                  g_array_index(cf_info.interface_packet_counts, uint32_t, 0)(((uint32_t*) (void *) (cf_info.interface_packet_counts)->
data) [(0)]) += 1;
              }
              else {
                  cf_info.pkt_interface_id_unknown += 1;
              }
          }
      }

      wtap_rec_reset(&rec);
  } /* while */
  wtap_rec_cleanup(&rec);

  /*
   * Get IDB info strings.
   * We do this at the end, so we can get information for all IDBs in
   * the file, even those that come after packet records, and so that
   * we get, for example, a count of the number of statistics entries
   * for each interface as of the *end* of the file.
   */
  idb_info = wtap_file_get_idb_info(cf_info.wth);

  cf_info.idb_info_strings = g_array_sized_new(false0, false0, sizeof(char*), cf_info.num_interfaces);
  cf_info.num_interfaces = idb_info->interface_data->len;
  for (i = 0; i < cf_info.num_interfaces; i++) {
      const wtap_block_t if_descr = g_array_index(idb_info->interface_data, wtap_block_t, i)(((wtap_block_t*) (void *) (idb_info->interface_data)->
data) [(i)]);
      char *s = wtap_get_debug_if_descr(if_descr, 21, "\n");
      g_array_append_val(cf_info.idb_info_strings, s)g_array_append_vals (cf_info.idb_info_strings, &(s), 1);
  }

  g_free(idb_info)(__builtin_object_size ((idb_info), 0) != ((size_t) - 1)) ? g_free_sized
 (idb_info, __builtin_object_size ((idb_info), 0)) : (g_free)
 (idb_info);
  idb_info = NULL((void*)0);

  if (err != 0) {
      fprintf(stderrstderr,
              "capinfos: An error occurred after reading %u packets from \"%s\".\n",
              packet, filename);
      report_cfile_read_failure(filename, err, err_info);
      if (err == WTAP_ERR_SHORT_READ-12) {
          /* Don't give up completely with this one. */
          status = 1;
          fprintf(stderrstderr,
                  "  (will continue anyway, checksums might be incorrect)\n");
      } else {
          cleanup_capture_info(&cf_info);
          wtap_close(cf_info.wth);
          return 2;
      }
  }

  /* File size */
  size = wtap_file_size(cf_info.wth, &err);
  if (size == -1) {
      fprintf(stderrstderr,
              "capinfos: Can't get size of \"%s\": %s.\n",
              filename, g_strerror(err));
      cleanup_capture_info(&cf_info);
      wtap_close(cf_info.wth);
      return 2;
  }

  cf_info.filesize = size;

  /* File Type */
  cf_info.file_type = wtap_file_type_subtype(cf_info.wth);
  cf_info.compression_type = wtap_get_compression_type(cf_info.wth);

  /* File Encapsulation */
  cf_info.file_encap = wtap_file_encap(cf_info.wth);

  cf_info.file_tsprec = wtap_file_tsprec(cf_info.wth);

  /* Packet size limit (snaplen) */
  cf_info.snaplen = wtap_snapshot_length(cf_info.wth);
  if (cf_info.snaplen > 0)
      cf_info.snap_set = true1;
  else
      cf_info.snap_set = false0;

  cf_info.snaplen_min_inferred = snaplen_min_inferred;
  cf_info.snaplen_max_inferred = snaplen_max_inferred;

  /* # of packets */
  cf_info.packet_count = packet;

  /* File Times */
  cf_info.times_known = have_times;
  cf_info.earliest_packet_time = earliest_packet_time;
  cf_info.earliest_packet_time_tsprec = earliest_packet_time_tsprec;
  cf_info.latest_packet_time = latest_packet_time;
  cf_info.latest_packet_time_tsprec = latest_packet_time_tsprec;
  nstime_delta(&cf_info.duration, &latest_packet_time, &earliest_packet_time);
  /* Duration precision is the higher of the earliest and latest packet timestamp precisions. */
  if (cf_info.latest_packet_time_tsprec > cf_info.earliest_packet_time_tsprec)
      cf_info.duration_tsprec = cf_info.latest_packet_time_tsprec;
  else
      cf_info.duration_tsprec = cf_info.earliest_packet_time_tsprec;
  cf_info.know_order = know_order;
  cf_info.order = order;

  /* Number of packet bytes */
  cf_info.packet_bytes = bytes;

  cf_info.data_rate   = 0.0;
  cf_info.packet_rate = 0.0;
  cf_info.packet_size = 0.0;

  if (packet > 0) {
      double delta_time = nstime_to_sec(&latest_packet_time) - nstime_to_sec(&earliest_packet_time);
      if (delta_time > 0.0) {
          cf_info.data_rate   = (double)bytes  / delta_time; /* Data rate per second */
          cf_info.packet_rate = (double)packet / delta_time; /* packet rate per second */
      }
      cf_info.packet_size = (double)bytes / packet;                  /* Avg packet size      */
  }

  if (!long_report && table_report_header) {
    print_stats_table_header(&cf_info);
  }

  if (long_report) {
      print_stats(filename, &cf_info);
  } else {
      print_stats_table(filename, &cf_info);
  }

  cleanup_capture_info(&cf_info);
  wtap_close(cf_info.wth);

  return status;
1401}

1403static void
1404print_usage(FILE *output)
1405{
  fprintf(output, "\n");
  fprintf(output, "Usage: capinfos [options] <infile> ...\n");
  fprintf(output, "\n");
  fprintf(output, "General infos:\n");
  fprintf(output, "  -t display the capture file type\n");
  fprintf(output, "  -E display the capture file encapsulation\n");
  fprintf(output, "  -I display the capture file interface information\n");
  fprintf(output, "  -F display additional capture file information\n");
  fprintf(output, "  -H display the SHA256 and SHA1 hashes of the file\n");
  fprintf(output, "  -k display the capture comment\n");
  fprintf(output, "  -p display individual packet comments\n");
  fprintf(output, "\n");
  fprintf(output, "Size infos:\n");
  fprintf(output, "  -c display the number of packets\n");
  fprintf(output, "  -s display the size of the file (in bytes)\n");
  fprintf(output, "  -d display the total length of all packets (in bytes)\n");
  fprintf(output, "  -l display the packet size limit (snapshot length)\n");
  fprintf(output, "\n");
  fprintf(output, "Time infos:\n");
  fprintf(output, "  -u display the capture duration (in seconds)\n");
  fprintf(output, "  -a display the timestamp of the earliest packet\n");
  fprintf(output, "  -e display the timestamp of the latest packet\n");
  fprintf(output, "  -o display the capture file chronological status (True/False)\n");
  fprintf(output, "  -S display earliest and latest packet timestamps as seconds\n");
  fprintf(output, "\n");
  fprintf(output, "Statistic infos:\n");
  fprintf(output, "  -y display average data rate (in bytes/sec)\n");
  fprintf(output, "  -i display average data rate (in bits/sec)\n");
  fprintf(output, "  -z display average packet size (in bytes)\n");
  fprintf(output, "  -x display average packet rate (in packets/sec)\n");
  fprintf(output, "\n");
  fprintf(output, "Metadata infos:\n");
  fprintf(output, "  -n display number of resolved IPv4 and IPv6 addresses\n");
  fprintf(output, "  -D display number of decryption secrets\n");
  fprintf(output, "\n");
  fprintf(output, "Output format:\n");
  fprintf(output, "  -L generate long report (default)\n");
  fprintf(output, "  -T generate table report\n");
  fprintf(output, "  -M display machine-readable values in long reports\n");
  fprintf(output, "\n");
  fprintf(output, "Table report options:\n");
  fprintf(output, "  -R generate header record (default)\n");
  fprintf(output, "  -r do not generate header record\n");
  fprintf(output, "\n");
  fprintf(output, "  -B separate infos with TAB character (default)\n");
  fprintf(output, "  -m separate infos with comma (,) character\n");
  fprintf(output, "  -b separate infos with SPACE character\n");
  fprintf(output, "\n");
  fprintf(output, "  -N do not quote infos (default)\n");
  fprintf(output, "  -q quote infos with single quotes (')\n");
  fprintf(output, "  -Q quote infos with double quotes (\")\n");
  fprintf(output, "\n");
  fprintf(output, "Miscellaneous:\n");
  fprintf(output, "  -h, --help               display this help and exit\n");
  fprintf(output, "  -v, --version            display version info and exit\n");
  fprintf(output, "  -C cancel processing if file open fails (default is to continue)\n");
  fprintf(output, "  -A generate all infos (default)\n");
  fprintf(output, "  -K disable displaying the capture comment\n");
  fprintf(output, "  -P disable displaying individual packet comments\n");
  fprintf(output, "\n");
  fprintf(output, "Options are processed from left to right order with later options superseding\n");
  fprintf(output, "or adding to earlier options.\n");
  fprintf(output, "\n");
  fprintf(output, "If no options are given the default is to display all infos in long report\n");
  fprintf(output, "output format.\n");
1471}

1473int
1474main(int argc, char *argv[])
1475{
  char  *configuration_init_error;
  bool_Bool need_separator = false0;
  int    opt;
  int    overall_error_status = EXIT_SUCCESS0;
  static const struct ws_option long_options[] = {
      {"help", ws_no_argument0, NULL((void*)0), 'h'},
      {"version", ws_no_argument0, NULL((void*)0), 'v'},
      LONGOPT_WSLOG{"log-level", 1, ((void*)0), 5000 +1}, {"log-domain", 1, ((void
*)0), 5000 +2}, {"log-domains", 1, ((void*)0), 5000 +2}, {"log-file"
, 1, ((void*)0), 5000 +3}, {"log-fatal", 1, ((void*)0), 5000 +
4}, {"log-fatal-count", 1, ((void*)0), 5000 +5}, {"log-fatal-domain"
, 1, ((void*)0), 5000 +6}, {"log-fatal-domains", 1, ((void*)0
), 5000 +6}, {"log-debug", 1, ((void*)0), 5000 +7}, {"log-noisy"
, 1, ((void*)0), 5000 +8},
      {0, 0, 0, 0 }
  };
  const struct file_extension_info* file_extensions;
  unsigned num_extensions;

1489#define OPTSTRING"abcdehiklmnopqrstuvxyzABCDEFHIKLMNPQRST" "abcdehiklmnopqrstuvxyzABCDEFHIKLMNPQRST"
  static const char optstring[] = OPTSTRING"abcdehiklmnopqrstuvxyzABCDEFHIKLMNPQRST";

  int status = 0;

  /* Set the program name. */
  g_set_prgname("capinfos");

  /*
   * Set the C-language locale to the native environment and set the
   * code page to UTF-8 on Windows.
   */
1501#ifdef _WIN32
  setlocale(LC_ALL6, ".UTF-8");
1503#else
  setlocale(LC_ALL6, "");
1505#endif

  cmdarg_err_init(stderr_cmdarg_err, stderr_cmdarg_err_cont);

  /* Initialize log handler early so we can have proper logging during startup. */
  ws_log_init(vcmdarg_err, "Capinfos Debug Console");

  /* Early logging command-line initialization. */
  ws_log_parse_args(&argc, argv, optstring, long_options, vcmdarg_err, WS_EXIT_INVALID_OPTION1);

  ws_noisy("Finished log init and parsing command line log arguments")do { if (1) { ws_log_full("Main", LOG_LEVEL_NOISY, "capinfos.c"
, 1515, __func__, "Finished log init and parsing command line log arguments"
); } } while (0);
1
Taking true branch→
2
←
Loop condition is false.  Exiting loop→

  /* Get the decimal point. */
  decimal_point = g_strdup(localeconv()->decimal_point)g_strdup_inline (localeconv()->decimal_point);

1520#ifdef _WIN32
  create_app_running_mutex();
1522#endif /* _WIN32 */

  /*
   * Get credential information for later use.
   */
  init_process_policies();

  /*
   * Attempt to get the pathname of the directory containing the
   * executable file.
   */
  configuration_init_error = configuration_init(argv[0], "wireshark");
  if (configuration_init_error != NULL((void*)0)) {
3
←
Assuming 'configuration_init_error' is equal to NULL→
4
←
Taking false branch→
      fprintf(stderrstderr,
              "capinfos: Can't get pathname of directory containing the capinfos program: %s.\n",
              configuration_init_error);
      g_free(configuration_init_error)(__builtin_object_size ((configuration_init_error), 0) != ((size_t
) - 1)) ? g_free_sized (configuration_init_error, __builtin_object_size
 ((configuration_init_error), 0)) : (g_free) (configuration_init_error
);
  }

  /* Initialize the version information. */
  ws_init_version_info("Capinfos", NULL((void*)0), application_get_vcs_version_info, NULL((void*)0), NULL((void*)0));

  init_report_failure_message("capinfos");

  application_file_extensions(&file_extensions, &num_extensions);
  wtap_init(true1, application_configuration_environment_prefix(), file_extensions, num_extensions);

  /* Process the options */
  while ((opt = ws_getopt_long(argc, argv, optstring, long_options, NULL((void*)0))) !=-1) {
5
←
Assuming the condition is false→
6
←
Loop condition is false. Execution continues on line 1742→

      switch (opt) {

          case 't':
              if (report_all_infos) disable_all_infos();
              cap_file_type = true1;
              break;

          case 'E':
              if (report_all_infos) disable_all_infos();
              cap_file_encap = true1;
              break;

          case 'l':
              if (report_all_infos) disable_all_infos();
              cap_snaplen = true1;
              break;

          case 'c':
              if (report_all_infos) disable_all_infos();
              cap_packet_count = true1;
              break;

          case 's':
              if (report_all_infos) disable_all_infos();
              cap_file_size = true1;
              break;

          case 'd':
              if (report_all_infos) disable_all_infos();
              cap_data_size = true1;
              break;

          case 'u':
              if (report_all_infos) disable_all_infos();
              cap_duration = true1;
              break;

          case 'a':
              if (report_all_infos) disable_all_infos();
              cap_earliest_packet_time = true1;
              break;

          case 'e':
              if (report_all_infos) disable_all_infos();
              cap_latest_packet_time = true1;
              break;

          case 'S':
              time_as_secs = true1;
              break;

          case 'y':
              if (report_all_infos) disable_all_infos();
              cap_data_rate_byte = true1;
              break;

          case 'i':
              if (report_all_infos) disable_all_infos();
              cap_data_rate_bit = true1;
              break;

          case 'z':
              if (report_all_infos) disable_all_infos();
              cap_packet_size = true1;
              break;

          case 'x':
              if (report_all_infos) disable_all_infos();
              cap_packet_rate = true1;
              break;

          case 'H':
              if (report_all_infos) disable_all_infos();
              cap_file_hashes = true1;
              break;

          case 'o':
              if (report_all_infos) disable_all_infos();
              cap_order = true1;
              break;

          case 'k':
              if (report_all_infos) disable_all_infos();
              cap_comment = true1;
              break;

          case 'p':
              if (report_all_infos) disable_all_infos();
              pkt_comments = true1;
              break;

          case 'K':
              cap_comment = false0;
              break;

          case 'P':
              pkt_comments = false0;
              break;

          case 'F':
              if (report_all_infos) disable_all_infos();
              cap_file_more_info = true1;
              break;

          case 'I':
              if (report_all_infos) disable_all_infos();
              cap_file_idb = true1;
              break;

          case 'n':
              if (report_all_infos) disable_all_infos();
              cap_file_nrb = true1;
              break;

          case 'D':
              if (report_all_infos) disable_all_infos();
              cap_file_dsb = true1;
              break;

          case 'C':
              stop_after_failure = true1;
              break;

          case 'A':
              enable_all_infos();
              break;

          case 'L':
              long_report = true1;
              break;

          case 'T':
              long_report = false0;
              break;

          case 'M':
              machine_readable = true1;
              break;

          case 'R':
              table_report_header = true1;
              break;

          case 'r':
              table_report_header = false0;
              break;

          case 'N':
              quote_char = '\0';
              break;

          case 'q':
              quote_char = '\'';
              break;

          case 'Q':
              quote_char = '"';
              break;

          case 'B':
              field_separator = '\t';
              break;

          case 'm':
              field_separator = ',';
              break;

          case 'b':
              field_separator = ' ';
              break;

          case 'h':
              show_help_header("Print various information (infos) about capture files.");
              print_usage(stdoutstdout);
              goto exit;
              break;

          case 'v':
              show_version();
              goto exit;
              break;

          case '?':              /* Bad flag - print usage message */
              print_usage(stderrstderr);
              overall_error_status = WS_EXIT_INVALID_OPTION1;
              goto exit;
              break;
      }
  }

  if ((argc - ws_optind) < 1) {
7
←
Assuming the condition is false→
8
←
Taking false branch→
      print_usage(stderrstderr);
      overall_error_status = WS_EXIT_INVALID_OPTION1;
      goto exit;
  }

  if (cap_file_hashes8.1
'cap_file_hashes' is true
) {
9
←
Taking true branch→
      gcry_check_version(NULL((void*)0));
      gcry_md_open(&hd, GCRY_MD_SHA256, 0);
      if (hd)
10
←
Assuming 'hd' is null→
11
←
Taking false branch→
          gcry_md_enable(hd, GCRY_MD_SHA1);

      hash_buf = (char *)g_malloc(HASH_BUF_SIZE(1024 * 1024));
  }

  overall_error_status = 0;

  for (opt = ws_optind; opt < argc; opt++) {
12
←
Assuming 'opt' is < 'argc'→
13
←
Loop condition is true.  Entering loop body→

      status = process_cap_file(argv[opt], need_separator);
14
←
Calling 'process_cap_file'→
      if (status) {
          /* Something failed.  It's been reported; remember that processing
             one file failed and, if -C was specified, stop. */
          overall_error_status = status;
          if (stop_after_failure)
              goto exit;
      }
      if (status != 2) {
          /* Either it succeeded or it got a "short read" but printed
             information anyway.  Note that we need a blank line before
             the next file's information, to separate it from the
             previous file. */
          need_separator = true1;
      }
  }

1778exit:
  g_free(hash_buf)(__builtin_object_size ((hash_buf), 0) != ((size_t) - 1)) ? g_free_sized
 (hash_buf, __builtin_object_size ((hash_buf), 0)) : (g_free)
 (hash_buf);
  gcry_md_close(hd);
  wtap_cleanup();
  free_progdirs();
  return overall_error_status;
1784}