tshark.c

   1 /* tshark.c
   2  *
   3  * Text-mode variant of Wireshark, along the lines of tcpdump and snoop,
   4  * by Gilbert Ramirez <gram@alumni.rice.edu> and Guy Harris <guy@alum.mit.edu>.
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * SPDX-License-Identifier: GPL-2.0+
  11  */
  12
  13 #include <config.h>
  14
  15 #include <stdlib.h>
  16 #include <stdio.h>
  17 #include <string.h>
  18 #include <locale.h>
  19 #include <limits.h>
  20
  21 #ifdef HAVE_GETOPT_H
  22 #include <getopt.h>
  23 #endif
  24
  25 #include <errno.h>
  26
  27 #ifdef _WIN32
  28 # include <winsock2.h>
  29 #endif
  30
  31 #ifndef _WIN32
  32 #include <signal.h>
  33 #endif
  34
  35 #ifdef HAVE_LIBCAP
  36 # include <sys/capability.h>
  37 #endif
  38
  39 #ifndef HAVE_GETOPT_LONG
  40 #include "wsutil/wsgetopt.h"
  41 #endif
  42
  43 #include <glib.h>
  44
  45 #include <epan/exceptions.h>
  46 #include <epan/epan.h>
  47
  48 #include <wsutil/clopts_common.h>
  49 #include <wsutil/cmdarg_err.h>
  50 #include <wsutil/crash_info.h>
  51 #include <wsutil/filesystem.h>
  52 #include <wsutil/file_util.h>
  53 #include <wsutil/privileges.h>
  54 #include <wsutil/report_message.h>
  55 #include <version_info.h>
  56 #include <wiretap/wtap_opttypes.h>
  57 #include <wiretap/pcapng.h>
  58
  59 #include "globals.h"
  60 #include <epan/timestamp.h>
  61 #include <epan/packet.h>
  62 #ifdef HAVE_LUA
  63 #include <epan/wslua/init_wslua.h>
  64 #endif
  65 #include "frame_tvbuff.h"
  66 #include <epan/disabled_protos.h>
  67 #include <epan/prefs.h>
  68 #include <epan/column.h>
  69 #include <epan/decode_as.h>
  70 #include <epan/print.h>
  71 #include <epan/addr_resolv.h>
  72 #ifdef HAVE_LIBPCAP
  73 #include "ui/capture_ui_utils.h"
  74 #endif
  75 #include "ui/util.h"
  76 #include "ui/ws_ui_util.h"
  77 #include "ui/decode_as_utils.h"
  78 #include "ui/filter_files.h"
  79 #include "ui/cli/tshark-tap.h"
  80 #include "ui/cli/tap-exportobject.h"
  81 #include "ui/tap_export_pdu.h"
  82 #include "ui/dissect_opts.h"
  83 #include "ui/failure_message.h"
  84 #if defined(HAVE_LIBSMI)
  85 #include "epan/oids.h"
  86 #endif
  87 #if defined(HAVE_GEOIP)
  88 #include "epan/geoip_db.h"
  89 #endif
  90 #include "epan/register.h"
  91 #include <epan/epan_dissect.h>
  92 #include <epan/tap.h>
  93 #include <epan/stat_tap_ui.h>
  94 #include <epan/conversation_table.h>
  95 #include <epan/srt_table.h>
  96 #include <epan/rtd_table.h>
  97 #include <epan/ex-opt.h>
  98 #include <epan/exported_pdu.h>
  99
 100 #include "capture_opts.h"
 101
 102 #include "caputils/capture-pcap-util.h"
 103
 104 #ifdef HAVE_LIBPCAP
 105 #include "caputils/capture_ifinfo.h"
 106 #ifdef _WIN32
 107 #include "caputils/capture-wpcap.h"
 108 #include <wsutil/os_version_info.h>
 109 #include <wsutil/unicode-utils.h>
 110 #endif /* _WIN32 */
 111 #include <capchild/capture_session.h>
 112 #include <capchild/capture_sync.h>
 113 #include <capture_info.h>
 114 #endif /* HAVE_LIBPCAP */
 115 #include "log.h"
 116 #include <epan/funnel.h>
 117
 118 #include <wsutil/str_util.h>
 119 #include <wsutil/utf8_entities.h>
 120
 121 #ifdef HAVE_EXTCAP
 122 #include "extcap.h"
 123 #endif
 124
 125 #ifdef HAVE_PLUGINS
 126 #include <wsutil/plugins.h>
 127 #endif
 128
 129 /* Exit codes */
 130 #define INVALID_OPTION 1
 131 #define INVALID_INTERFACE 2
 132 #define INVALID_FILE 2
 133 #define INVALID_FILTER 2
 134 #define INVALID_EXPORT 2
 135 #define INVALID_CAPABILITY 2
 136 #define INVALID_TAP 2
 137 #define INVALID_DATA_LINK 2
 138 #define INVALID_TIMESTAMP_TYPE 2
 139 #define INVALID_CAPTURE 2
 140 #define INIT_FAILED 2
 141
 142 /*
 143  * values 128..65535 are capture+dissect options, 65536 is used by
 144  * ui/commandline.c, so start tshark-specific options 1000 after this
 145  */
 146 #define LONGOPT_COLOR (65536+1000)
 147 #define LONGOPT_NO_DUPLICATE_KEYS (65536+1001)
 148
 149 #if 0
 150 #define tshark_debug(...) g_warning(__VA_ARGS__)
 151 #else
 152 #define tshark_debug(...)
 153 #endif
 154
 155 capture_file cfile;
 156
 157 static guint32 cum_bytes;
 158 static frame_data ref_frame;
 159 static frame_data prev_dis_frame;
 160 static frame_data prev_cap_frame;
 161
 162 static gboolean perform_two_pass_analysis;
 163 static guint32 epan_auto_reset_count = 0;
 164 static gboolean epan_auto_reset = FALSE;
 165
 166 /*
 167  * The way the packet decode is to be written.
 168  */
 169 typedef enum {
 170   WRITE_TEXT,   /* summary or detail text */
 171   WRITE_XML,    /* PDML or PSML */
 172   WRITE_FIELDS, /* User defined list of fields */
 173   WRITE_JSON,   /* JSON */
 174   WRITE_JSON_RAW,   /* JSON only raw hex */
 175   WRITE_EK      /* JSON bulk insert to Elasticsearch */
 176   /* Add CSV and the like here */
 177 } output_action_e;
 178
 179 static output_action_e output_action;
 180 static gboolean do_dissection;     /* TRUE if we have to dissect each packet */
 181 static gboolean print_packet_info; /* TRUE if we're to print packet information */
 182 static gboolean print_summary;     /* TRUE if we're to print packet summary information */
 183 static gboolean print_details;     /* TRUE if we're to print packet details information */
 184 static gboolean print_hex;         /* TRUE if we're to print hex/ascci information */
 185 static gboolean line_buffered;
 186 static gboolean really_quiet = FALSE;
 187 static gchar* delimiter_char = " ";
 188 static gboolean dissect_color = FALSE;
 189
 190 static print_format_e print_format = PR_FMT_TEXT;
 191 static print_stream_t *print_stream = NULL;
 192
 193 static output_fields_t* output_fields  = NULL;
 194 static gchar **protocolfilter = NULL;
 195 static pf_flags protocolfilter_flags = PF_NONE;
 196
 197 static gboolean no_duplicate_keys = FALSE;
 198 static proto_node_children_grouper_func node_children_grouper = proto_node_group_children_by_unique;
 199
 200 /* The line separator used between packets, changeable via the -S option */
 201 static const char *separator = "";
 202
 203 static gboolean prefs_loaded = FALSE;
 204
 205 #ifdef HAVE_LIBPCAP
 206 /*
 207  * TRUE if we're to print packet counts to keep track of captured packets.
 208  */
 209 static gboolean print_packet_counts;
 210
 211 static capture_options global_capture_opts;
 212 static capture_session global_capture_session;
 213 static info_data_t global_info_data;
 214
 215 #ifdef SIGINFO
 216 static gboolean infodelay;      /* if TRUE, don't print capture info in SIGINFO handler */
 217 static gboolean infoprint;      /* if TRUE, print capture info after clearing infodelay */
 218 #endif /* SIGINFO */
 219
 220 static gboolean capture(void);
 221 static void report_counts(void);
 222 #ifdef _WIN32
 223 static BOOL WINAPI capture_cleanup(DWORD);
 224 #else /* _WIN32 */
 225 static void capture_cleanup(int);
 226 #ifdef SIGINFO
 227 static void report_counts_siginfo(int);
 228 #endif /* SIGINFO */
 229 #endif /* _WIN32 */
 230
 231 #else /* HAVE_LIBPCAP */
 232
 233 static char *output_file_name;
 234
 235 #endif /* HAVE_LIBPCAP */
 236
 237 static void reset_epan_mem(capture_file *cf, epan_dissect_t *edt, gboolean tree, gboolean visual);
 238 static gboolean process_cap_file(capture_file *, char *, int, gboolean, int, gint64);
 239 static gboolean process_packet_single_pass(capture_file *cf,
 240     epan_dissect_t *edt, gint64 offset, struct wtap_pkthdr *whdr,
 241     const guchar *pd, guint tap_flags);
 242 static void show_print_file_io_error(int err);
 243 static gboolean write_preamble(capture_file *cf);
 244 static gboolean print_packet(capture_file *cf, epan_dissect_t *edt);
 245 static gboolean write_finale(void);
 246
 247 static void failure_warning_message(const char *msg_format, va_list ap);
 248 static void open_failure_message(const char *filename, int err,
 249     gboolean for_writing);
 250 static void read_failure_message(const char *filename, int err);
 251 static void write_failure_message(const char *filename, int err);
 252 static void failure_message_cont(const char *msg_format, va_list ap);
 253
 254 static GHashTable *output_only_tables = NULL;
 255
 256 struct string_elem {
 257   const char *sstr;   /* The short string */
 258   const char *lstr;   /* The long string */
 259 };
 260
 261 static gint
 262 string_compare(gconstpointer a, gconstpointer b)
 263 {
 264   return strcmp(((const struct string_elem *)a)->sstr,
 265                 ((const struct string_elem *)b)->sstr);
 266 }
 267
 268 static void
 269 string_elem_print(gpointer data, gpointer not_used _U_)
 270 {
 271   fprintf(stderr, "    %s - %s\n",
 272           ((struct string_elem *)data)->sstr,
 273           ((struct string_elem *)data)->lstr);
 274 }
 275
 276 static void
 277 list_capture_types(void) {
 278   int                 i;
 279   struct string_elem *captypes;
 280   GSList             *list = NULL;
 281
 282   captypes = g_new(struct string_elem, WTAP_NUM_FILE_TYPES_SUBTYPES);
 283
 284   fprintf(stderr, "tshark: The available capture file types for the \"-F\" flag are:\n");
 285   for (i = 0; i < WTAP_NUM_FILE_TYPES_SUBTYPES; i++) {
 286     if (wtap_dump_can_open(i)) {
 287       captypes[i].sstr = wtap_file_type_subtype_short_string(i);
 288       captypes[i].lstr = wtap_file_type_subtype_string(i);
 289       list = g_slist_insert_sorted(list, &captypes[i], string_compare);
 290     }
 291   }
 292   g_slist_foreach(list, string_elem_print, NULL);
 293   g_slist_free(list);
 294   g_free(captypes);
 295 }
 296
 297 static void
 298 list_read_capture_types(void) {
 299   int                 i;
 300   struct string_elem *captypes;
 301   GSList             *list = NULL;
 302   const char *magic = "Magic-value-based";
 303   const char *heuristic = "Heuristics-based";
 304
 305   /* this is a hack, but WTAP_NUM_FILE_TYPES_SUBTYPES is always >= number of open routines so we're safe */
 306   captypes = g_new(struct string_elem, WTAP_NUM_FILE_TYPES_SUBTYPES);
 307
 308   fprintf(stderr, "tshark: The available read file types for the \"-X read_format:\" option are:\n");
 309   for (i = 0; open_routines[i].name != NULL; i++) {
 310     captypes[i].sstr = open_routines[i].name;
 311     captypes[i].lstr = (open_routines[i].type == OPEN_INFO_MAGIC) ? magic : heuristic;
 312     list = g_slist_insert_sorted(list, &captypes[i], string_compare);
 313   }
 314   g_slist_foreach(list, string_elem_print, NULL);
 315   g_slist_free(list);
 316   g_free(captypes);
 317 }
 318
 319 static void
 320 print_usage(FILE *output)
 321 {
 322   fprintf(output, "\n");
 323   fprintf(output, "Usage: tshark [options] ...\n");
 324   fprintf(output, "\n");
 325
 326 #ifdef HAVE_LIBPCAP
 327   fprintf(output, "Capture interface:\n");
 328   fprintf(output, "  -i <interface>           name or idx of interface (def: first non-loopback)\n");
 329   fprintf(output, "  -f <capture filter>      packet filter in libpcap filter syntax\n");
 330 #ifdef HAVE_PCAP_CREATE
 331   fprintf(output, "  -s <snaplen>             packet snapshot length (def: appropriate maximum)\n");
 332 #else
 333   fprintf(output, "  -s <snaplen>             packet snapshot length (def: %u)\n", WTAP_MAX_PACKET_SIZE_STANDARD);
 334 #endif
 335   fprintf(output, "  -p                       don't capture in promiscuous mode\n");
 336 #ifdef HAVE_PCAP_CREATE
 337   fprintf(output, "  -I                       capture in monitor mode, if available\n");
 338 #endif
 339 #ifdef CAN_SET_CAPTURE_BUFFER_SIZE
 340   fprintf(output, "  -B <buffer size>         size of kernel buffer (def: %dMB)\n", DEFAULT_CAPTURE_BUFFER_SIZE);
 341 #endif
 342   fprintf(output, "  -y <link type>           link layer type (def: first appropriate)\n");
 343   fprintf(output, "  --time-stamp-type <type> timestamp method for interface\n");
 344   fprintf(output, "  -D                       print list of interfaces and exit\n");
 345   fprintf(output, "  -L                       print list of link-layer types of iface and exit\n");
 346   fprintf(output, "  --list-time-stamp-types  print list of timestamp types for iface and exit\n");
 347   fprintf(output, "\n");
 348   fprintf(output, "Capture stop conditions:\n");
 349   fprintf(output, "  -c <packet count>        stop after n packets (def: infinite)\n");
 350   fprintf(output, "  -a <autostop cond.> ...  duration:NUM - stop after NUM seconds\n");
 351   fprintf(output, "                           filesize:NUM - stop this file after NUM KB\n");
 352   fprintf(output, "                              files:NUM - stop after NUM files\n");
 353   /*fprintf(output, "\n");*/
 354   fprintf(output, "Capture output:\n");
 355   fprintf(output, "  -b <ringbuffer opt.> ... duration:NUM - switch to next file after NUM secs\n");
 356   fprintf(output, "                           interval:NUM - create time intervals of NUM secs\n");
 357   fprintf(output, "                           filesize:NUM - switch to next file after NUM KB\n");
 358   fprintf(output, "                              files:NUM - ringbuffer: replace after NUM files\n");
 359 #endif  /* HAVE_LIBPCAP */
 360 #ifdef HAVE_PCAP_REMOTE
 361   fprintf(output, "RPCAP options:\n");
 362   fprintf(output, "  -A <user>:<password>     use RPCAP password authentication\n");
 363 #endif
 364   /*fprintf(output, "\n");*/
 365   fprintf(output, "Input file:\n");
 366   fprintf(output, "  -r <infile>              set the filename to read from (- to read from stdin)\n");
 367
 368   fprintf(output, "\n");
 369   fprintf(output, "Processing:\n");
 370   fprintf(output, "  -2                       perform a two-pass analysis\n");
 371   fprintf(output, "  -M <packet count>        perform session auto reset\n");
 372   fprintf(output, "  -R <read filter>         packet Read filter in Wireshark display filter syntax\n");
 373   fprintf(output, "                           (requires -2)\n");
 374   fprintf(output, "  -Y <display filter>      packet displaY filter in Wireshark display filter\n");
 375   fprintf(output, "                           syntax\n");
 376   fprintf(output, "  -n                       disable all name resolutions (def: all enabled)\n");
 377   fprintf(output, "  -N <name resolve flags>  enable specific name resolution(s): \"mnNtCd\"\n");
 378   fprintf(output, "  -d %s ...\n", DECODE_AS_ARG_TEMPLATE);
 379   fprintf(output, "                           \"Decode As\", see the man page for details\n");
 380   fprintf(output, "                           Example: tcp.port==8888,http\n");
 381   fprintf(output, "  -H <hosts file>          read a list of entries from a hosts file, which will\n");
 382   fprintf(output, "                           then be written to a capture file. (Implies -W n)\n");
 383   fprintf(output, "  --enable-protocol <proto_name>\n");
 384   fprintf(output, "                           enable dissection of proto_name\n");
 385   fprintf(output, "  --disable-protocol <proto_name>\n");
 386   fprintf(output, "                           disable dissection of proto_name\n");
 387   fprintf(output, "  --enable-heuristic <short_name>\n");
 388   fprintf(output, "                           enable dissection of heuristic protocol\n");
 389   fprintf(output, "  --disable-heuristic <short_name>\n");
 390   fprintf(output, "                           disable dissection of heuristic protocol\n");
 391
 392   /*fprintf(output, "\n");*/
 393   fprintf(output, "Output:\n");
 394   fprintf(output, "  -w <outfile|->           write packets to a pcap-format file named \"outfile\"\n");
 395   fprintf(output, "                           (or to the standard output for \"-\")\n");
 396   fprintf(output, "  -C <config profile>      start with specified configuration profile\n");
 397   fprintf(output, "  -F <output file type>    set the output file type, default is pcapng\n");
 398   fprintf(output, "                           an empty \"-F\" option will list the file types\n");
 399   fprintf(output, "  -V                       add output of packet tree        (Packet Details)\n");
 400   fprintf(output, "  -O <protocols>           Only show packet details of these protocols, comma\n");
 401   fprintf(output, "                           separated\n");
 402   fprintf(output, "  -P                       print packet summary even when writing to a file\n");
 403   fprintf(output, "  -S <separator>           the line separator to print between packets\n");
 404   fprintf(output, "  -x                       add output of hex and ASCII dump (Packet Bytes)\n");
 405   fprintf(output, "  -T pdml|ps|psml|json|jsonraw|ek|tabs|text|fields|?\n");
 406   fprintf(output, "                           format of text output (def: text)\n");
 407   fprintf(output, "  -j <protocolfilter>      protocols layers filter if -T ek|pdml|json selected\n");
 408   fprintf(output, "                           (e.g. \"ip ip.flags text\", filter does not expand child\n");
 409   fprintf(output, "                           nodes, unless child is specified also in the filter)\n");
 410   fprintf(output, "  -J <protocolfilter>      top level protocol filter if -T ek|pdml|json selected\n");
 411   fprintf(output, "                           (e.g. \"http tcp\", filter which expands all child nodes)\n");
 412   fprintf(output, "  -e <field>               field to print if -Tfields selected (e.g. tcp.port,\n");
 413   fprintf(output, "                           _ws.col.Info)\n");
 414   fprintf(output, "                           this option can be repeated to print multiple fields\n");
 415   fprintf(output, "  -E<fieldsoption>=<value> set options for output when -Tfields selected:\n");
 416   fprintf(output, "     bom=y|n               print a UTF-8 BOM\n");
 417   fprintf(output, "     header=y|n            switch headers on and off\n");
 418   fprintf(output, "     separator=/t|/s|<char> select tab, space, printable character as separator\n");
 419   fprintf(output, "     occurrence=f|l|a      print first, last or all occurrences of each field\n");
 420   fprintf(output, "     aggregator=,|/s|<char> select comma, space, printable character as\n");
 421   fprintf(output, "                           aggregator\n");
 422   fprintf(output, "     quote=d|s|n           select double, single, no quotes for values\n");
 423   fprintf(output, "  -t a|ad|d|dd|e|r|u|ud|?  output format of time stamps (def: r: rel. to first)\n");
 424   fprintf(output, "  -u s|hms                 output format of seconds (def: s: seconds)\n");
 425   fprintf(output, "  -l                       flush standard output after each packet\n");
 426   fprintf(output, "  -q                       be more quiet on stdout (e.g. when using statistics)\n");
 427   fprintf(output, "  -Q                       only log true errors to stderr (quieter than -q)\n");
 428   fprintf(output, "  -g                       enable group read access on the output file(s)\n");
 429   fprintf(output, "  -W n                     Save extra information in the file, if supported.\n");
 430   fprintf(output, "                           n = write network address resolution information\n");
 431   fprintf(output, "  -X <key>:<value>         eXtension options, see the man page for details\n");
 432   fprintf(output, "  -U tap_name              PDUs export mode, see the man page for details\n");
 433   fprintf(output, "  -z <statistics>          various statistics, see the man page for details\n");
 434   fprintf(output, "  --capture-comment <comment>\n");
 435   fprintf(output, "                           add a capture comment to the newly created\n");
 436   fprintf(output, "                           output file (only for pcapng)\n");
 437   fprintf(output, "  --export-objects <protocol>,<destdir> save exported objects for a protocol to\n");
 438   fprintf(output, "                           a directory named \"destdir\"\n");
 439   fprintf(output, "  --color                  color output text similarly to the Wireshark GUI,\n");
 440   fprintf(output, "                           requires a terminal with 24-bit color support\n");
 441   fprintf(output, "                           Also supplies color attributes to pdml and psml formats\n");
 442   fprintf(output, "                           (Note that attributes are nonstandard)\n");
 443   fprintf(output, "  --no-duplicate-keys      If -T json is specified, merge duplicate keys in an object\n");
 444   fprintf(output, "                           into a single key with as value a json array containing all\n");
 445   fprintf(output, "                           values");
 446
 447   fprintf(output, "\n");
 448   fprintf(output, "Miscellaneous:\n");
 449   fprintf(output, "  -h                       display this help and exit\n");
 450   fprintf(output, "  -v                       display version info and exit\n");
 451   fprintf(output, "  -o <name>:<value> ...    override preference setting\n");
 452   fprintf(output, "  -K <keytab>              keytab file to use for kerberos decryption\n");
 453   fprintf(output, "  -G [report]              dump one of several available reports and exit\n");
 454   fprintf(output, "                           default report=\"fields\"\n");
 455   fprintf(output, "                           use \"-G help\" for more help\n");
 456 #ifdef __linux__
 457   fprintf(output, "\n");
 458   fprintf(output, "WARNING: dumpcap will enable kernel BPF JIT compiler if available.\n");
 459   fprintf(output, "You might want to reset it\n");
 460   fprintf(output, "By doing \"echo 0 > /proc/sys/net/core/bpf_jit_enable\"\n");
 461 #endif
 462
 463 }
 464
 465 static void
 466 glossary_option_help(void)
 467 {
 468   FILE *output;
 469
 470   output = stdout;
 471
 472   fprintf(output, "TShark (Wireshark) %s\n", get_ws_vcs_version_info());
 473
 474   fprintf(output, "\n");
 475   fprintf(output, "Usage: tshark -G [report]\n");
 476   fprintf(output, "\n");
 477   fprintf(output, "Glossary table reports:\n");
 478   fprintf(output, "  -G column-formats        dump column format codes and exit\n");
 479   fprintf(output, "  -G decodes               dump \"layer type\"/\"decode as\" associations and exit\n");
 480   fprintf(output, "  -G dissector-tables      dump dissector table names, types, and properties\n");
 481   fprintf(output, "  -G fieldcount            dump count of header fields and exit\n");
 482   fprintf(output, "  -G fields                dump fields glossary and exit\n");
 483   fprintf(output, "  -G ftypes                dump field type basic and descriptive names\n");
 484   fprintf(output, "  -G heuristic-decodes     dump heuristic dissector tables\n");
 485   fprintf(output, "  -G plugins               dump installed plugins and exit\n");
 486   fprintf(output, "  -G protocols             dump protocols in registration database and exit\n");
 487   fprintf(output, "  -G values                dump value, range, true/false strings and exit\n");
 488   fprintf(output, "\n");
 489   fprintf(output, "Preference reports:\n");
 490   fprintf(output, "  -G currentprefs          dump current preferences and exit\n");
 491   fprintf(output, "  -G defaultprefs          dump default preferences and exit\n");
 492   fprintf(output, "  -G folders               dump about:folders\n");
 493   fprintf(output, "\n");
 494 }
 495
 496 static void
 497 tshark_log_handler (const gchar *log_domain, GLogLevelFlags log_level,
 498     const gchar *message, gpointer user_data)
 499 {
 500   /* ignore log message, if log_level isn't interesting based
 501      upon the console log preferences.
 502      If the preferences haven't been loaded yet, display the
 503      message anyway.
 504
 505      The default console_log_level preference value is such that only
 506        ERROR, CRITICAL and WARNING level messages are processed;
 507        MESSAGE, INFO and DEBUG level messages are ignored.
 508
 509      XXX: Aug 07, 2009: Prior tshark g_log code was hardwired to process only
 510            ERROR and CRITICAL level messages so the current code is a behavioral
 511            change.  The current behavior is the same as in Wireshark.
 512   */
 513   if (prefs_loaded && (log_level & G_LOG_LEVEL_MASK & prefs.console_log_level) == 0) {
 514     return;
 515   }
 516
 517   g_log_default_handler(log_domain, log_level, message, user_data);
 518
 519 }
 520
 521 static void
 522 print_current_user(void) {
 523   gchar *cur_user, *cur_group;
 524
 525   if (started_with_special_privs()) {
 526     cur_user = get_cur_username();
 527     cur_group = get_cur_groupname();
 528     fprintf(stderr, "Running as user \"%s\" and group \"%s\".",
 529       cur_user, cur_group);
 530     g_free(cur_user);
 531     g_free(cur_group);
 532     if (running_with_special_privs()) {
 533       fprintf(stderr, " This could be dangerous.");
 534     }
 535     fprintf(stderr, "\n");
 536   }
 537 }
 538
 539 static void
 540 get_tshark_compiled_version_info(GString *str)
 541 {
 542   /* Capture libraries */
 543   get_compiled_caplibs_version(str);
 544 }
 545
 546 static void
 547 get_tshark_runtime_version_info(GString *str)
 548 {
 549 #ifdef HAVE_LIBPCAP
 550     /* Capture libraries */
 551     g_string_append(str, ", ");
 552     get_runtime_caplibs_version(str);
 553 #endif
 554
 555     /* stuff used by libwireshark */
 556     epan_get_runtime_version_info(str);
 557 }
 558
 559 static void
 560 about_folders(void)
 561 {
 562   const char           *constpath;
 563   char                 *path;
 564 #if defined(HAVE_LIBSMI) || defined(HAVE_GEOIP) || defined(HAVE_EXTCAP)
 565   gint                  i;
 566   gchar               **resultArray;
 567 #endif
 568
 569   /* "file open" */
 570
 571   /*
 572    * Fetching the "File" dialogs folder not implemented.
 573    * This is arguably just a pwd for a ui/cli .
 574    */
 575
 576   /* temp */
 577   printf("%-21s\t%s\n", "Temp:", g_get_tmp_dir());
 578
 579   /* pers conf */
 580   path = get_persconffile_path("", FALSE);
 581   printf("%-21s\t%s\n", "Personal configuration:", path);
 582   g_free(path);
 583
 584   /* global conf */
 585   constpath = get_datafile_dir();
 586   if (constpath != NULL) {
 587     printf("%-21s\t%s\n", "Global configuration:", constpath);
 588   }
 589
 590   /* system */
 591   constpath = get_systemfile_dir();
 592   printf("%-21s\t%s\n", "System:", constpath);
 593
 594   /* program */
 595   constpath = get_progfile_dir();
 596   printf("%-21s\t%s\n", "Program:", constpath);
 597
 598 #ifdef HAVE_PLUGINS
 599   /* pers plugins */
 600   printf("%-21s\t%s\n", "Personal Plugins:", get_plugins_pers_dir_with_version());
 601
 602   /* global plugins */
 603   printf("%-21s\t%s\n", "Global Plugins:", get_plugins_dir_with_version());
 604 #endif
 605
 606 #ifdef HAVE_LUA
 607   /* pers lua plugins */
 608   printf("%-21s\t%s\n", "Personal Lua Plugins:", get_plugins_pers_dir());
 609
 610   /* global lua plugins */
 611   printf("%-21s\t%s\n", "Global Lua Plugins:", get_plugins_dir());
 612 #endif
 613
 614 #ifdef HAVE_EXTCAP
 615   /* Extcap */
 616   constpath = get_extcap_dir();
 617
 618   resultArray = g_strsplit(constpath, G_SEARCHPATH_SEPARATOR_S, 10);
 619   for(i = 0; resultArray[i]; i++)
 620     printf("%-21s\t%s\n", "Extcap path:", g_strstrip(resultArray[i]));
 621
 622   g_strfreev(resultArray);
 623 #endif
 624
 625 #ifdef HAVE_GEOIP
 626   /* GeoIP */
 627   path = geoip_db_get_paths();
 628
 629   resultArray = g_strsplit(path, G_SEARCHPATH_SEPARATOR_S, 10);
 630
 631   for(i = 0; resultArray[i]; i++)
 632     printf("%-21s\t%s\n", "GeoIP path:", g_strstrip(resultArray[i]));
 633
 634   g_strfreev(resultArray);
 635   g_free(path);
 636 #endif
 637
 638 #ifdef HAVE_LIBSMI
 639   /* SMI MIBs/PIBs */
 640   path = oid_get_default_mib_path();
 641   resultArray = g_strsplit(path, G_SEARCHPATH_SEPARATOR_S, 10);
 642
 643   for(i = 0; resultArray[i]; i++)
 644     printf("%-21s\t%s\n", "MIB/PIB path:", g_strstrip(resultArray[i]));
 645
 646   g_strfreev(resultArray);
 647   g_free(path);
 648 #endif
 649
 650 }
 651
 652 int
 653 main(int argc, char *argv[])
 654 {
 655   GString             *comp_info_str;
 656   GString             *runtime_info_str;
 657   char                *init_progfile_dir_error;
 658   int                  opt;
 659   static const struct option long_options[] = {
 660     {"help", no_argument, NULL, 'h'},
 661     {"version", no_argument, NULL, 'v'},
 662     LONGOPT_CAPTURE_COMMON
 663     LONGOPT_DISSECT_COMMON
 664     {"print", no_argument, NULL, 'P'},
 665     {"export-objects", required_argument, NULL, LONGOPT_EXPORT_OBJECTS},
 666     {"color", no_argument, NULL, LONGOPT_COLOR},
 667     {"no-duplicate-keys", no_argument, NULL, LONGOPT_NO_DUPLICATE_KEYS},
 668     {0, 0, 0, 0 }
 669   };
 670   gboolean             arg_error = FALSE;
 671
 672 #ifdef _WIN32
 673   int                  result;
 674   WSADATA              wsaData;
 675 #endif  /* _WIN32 */
 676
 677   int                  err;
 678   volatile gboolean    success;
 679   volatile int         exit_status = EXIT_SUCCESS;
 680 #ifdef HAVE_LIBPCAP
 681   int                  caps_queries = 0;
 682   gboolean             start_capture = FALSE;
 683   GList               *if_list;
 684   gchar               *err_str;
 685 #else
 686   gboolean             capture_option_specified = FALSE;
 687 #endif
 688   gboolean             quiet = FALSE;
 689 #ifdef PCAP_NG_DEFAULT
 690   volatile int         out_file_type = WTAP_FILE_TYPE_SUBTYPE_PCAPNG;
 691 #else
 692   volatile int         out_file_type = WTAP_FILE_TYPE_SUBTYPE_PCAP;
 693 #endif
 694   volatile gboolean    out_file_name_res = FALSE;
 695   volatile int         in_file_type = WTAP_TYPE_AUTO;
 696   gchar               *volatile cf_name = NULL;
 697   gchar               *rfilter = NULL;
 698   gchar               *dfilter = NULL;
 699 #ifdef HAVE_PCAP_OPEN_DEAD
 700   struct bpf_program   fcode;
 701 #endif
 702   dfilter_t           *rfcode = NULL;
 703   dfilter_t           *dfcode = NULL;
 704   gchar               *err_msg;
 705   e_prefs             *prefs_p;
 706   int                  log_flags;
 707   gchar               *output_only = NULL;
 708   gchar               *volatile pdu_export_arg = NULL;
 709   const char          *volatile exp_pdu_filename = NULL;
 710   exp_pdu_t            exp_pdu_tap_data;
 711
 712 /*
 713  * The leading + ensures that getopt_long() does not permute the argv[]
 714  * entries.
 715  *
 716  * We have to make sure that the first getopt_long() preserves the content
 717  * of argv[] for the subsequent getopt_long() call.
 718  *
 719  * We use getopt_long() in both cases to ensure that we're using a routine
 720  * whose permutation behavior we can control in the same fashion on all
 721  * platforms, and so that, if we ever need to process a long argument before
 722  * doing further initialization, we can do so.
 723  *
 724  * Glibc and Solaris libc document that a leading + disables permutation
 725  * of options, regardless of whether POSIXLY_CORRECT is set or not; *BSD
 726  * and macOS don't document it, but do so anyway.
 727  *
 728  * We do *not* use a leading - because the behavior of a leading - is
 729  * platform-dependent.
 730  */
 731 #define OPTSTRING "+2" OPTSTRING_CAPTURE_COMMON OPTSTRING_DISSECT_COMMON "M:C:e:E:F:gG:hH:j:J:lo:O:PqQr:R:S:T:U:vVw:W:xX:Y:z:"
 732
 733   static const char    optstring[] = OPTSTRING;
 734
 735   tshark_debug("tshark started with %d args", argc);
 736
 737   /* Set the C-language locale to the native environment. */
 738   setlocale(LC_ALL, "");
 739
 740   cmdarg_err_init(failure_warning_message, failure_message_cont);
 741
 742 #ifdef _WIN32
 743   arg_list_utf_16to8(argc, argv);
 744   create_app_running_mutex();
 745 #if !GLIB_CHECK_VERSION(2,31,0)
 746   g_thread_init(NULL);
 747 #endif
 748 #endif /* _WIN32 */
 749
 750   /*
 751    * Get credential information for later use, and drop privileges
 752    * before doing anything else.
 753    * Let the user know if anything happened.
 754    */
 755   init_process_policies();
 756   relinquish_special_privs_perm();
 757   print_current_user();
 758
 759   /*
 760    * Attempt to get the pathname of the directory containing the
 761    * executable file.
 762    */
 763   init_progfile_dir_error = init_progfile_dir(argv[0], main);
 764   if (init_progfile_dir_error != NULL) {
 765     fprintf(stderr,
 766             "tshark: Can't get pathname of directory containing the tshark program: %s.\n"
 767             "It won't be possible to capture traffic.\n"
 768             "Report this to the Wireshark developers.",
 769             init_progfile_dir_error);
 770     g_free(init_progfile_dir_error);
 771   }
 772
 773   initialize_funnel_ops();
 774
 775 #ifdef _WIN32
 776   ws_init_dll_search_path();
 777 #ifdef HAVE_LIBPCAP
 778   /* Load wpcap if possible. Do this before collecting the run-time version information */
 779   load_wpcap();
 780
 781   /* Warn the user if npf.sys isn't loaded. */
 782   if (!npf_sys_is_running() && get_windows_major_version() >= 6) {
 783     fprintf(stderr, "The NPF driver isn't running.  You may have trouble "
 784       "capturing or\nlisting interfaces.\n");
 785   }
 786 #endif /* HAVE_LIBPCAP */
 787 #endif /* _WIN32 */
 788
 789   /* Get the compile-time version information string */
 790   comp_info_str = get_compiled_version_info(get_tshark_compiled_version_info,
 791                                             epan_get_compiled_version_info);
 792
 793   /* Get the run-time version information string */
 794   runtime_info_str = get_runtime_version_info(get_tshark_runtime_version_info);
 795
 796   /* Add it to the information to be reported on a crash. */
 797   ws_add_crash_info("TShark (Wireshark) %s\n"
 798          "\n"
 799          "%s"
 800          "\n"
 801          "%s",
 802       get_ws_vcs_version_info(), comp_info_str->str, runtime_info_str->str);
 803   g_string_free(comp_info_str, TRUE);
 804   g_string_free(runtime_info_str, TRUE);
 805
 806   /* Fail sometimes. Useful for testing fuzz scripts. */
 807   /* if (g_random_int_range(0, 100) < 5) abort(); */
 808
 809   /*
 810    * In order to have the -X opts assigned before the wslua machine starts
 811    * we need to call getopt_long before epan_init() gets called.
 812    *
 813    * In order to handle, for example, -o options, we also need to call it
 814    * *after* epan_init() gets called, so that the dissectors have had a
 815    * chance to register their preferences.
 816    *
 817    * XXX - can we do this all with one getopt_long() call, saving the
 818    * arguments we can't handle until after initializing libwireshark,
 819    * and then process them after initializing libwireshark?
 820    */
 821   opterr = 0;
 822
 823   while ((opt = getopt_long(argc, argv, optstring, long_options, NULL)) != -1) {
 824     switch (opt) {
 825     case 'C':        /* Configuration Profile */
 826       if (profile_exists (optarg, FALSE)) {
 827         set_profile_name (optarg);
 828       } else {
 829         cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
 830         exit_status = INVALID_OPTION;
 831         goto clean_exit;
 832       }
 833       break;
 834     case 'P':        /* Print packet summary info even when writing to a file */
 835       print_packet_info = TRUE;
 836       print_summary = TRUE;
 837       break;
 838     case 'O':        /* Only output these protocols */
 839       output_only = g_strdup(optarg);
 840       /* FALLTHROUGH */
 841     case 'V':        /* Verbose */
 842       print_details = TRUE;
 843       print_packet_info = TRUE;
 844       break;
 845     case 'x':        /* Print packet data in hex (and ASCII) */
 846       print_hex = TRUE;
 847       /*  The user asked for hex output, so let's ensure they get it,
 848        *  even if they're writing to a file.
 849        */
 850       print_packet_info = TRUE;
 851       break;
 852     case 'X':
 853       ex_opt_add(optarg);
 854       break;
 855     default:
 856       break;
 857     }
 858   }
 859
 860 /** Send All g_log messages to our own handler **/
 861
 862   log_flags =
 863                     G_LOG_LEVEL_ERROR|
 864                     G_LOG_LEVEL_CRITICAL|
 865                     G_LOG_LEVEL_WARNING|
 866                     G_LOG_LEVEL_MESSAGE|
 867                     G_LOG_LEVEL_INFO|
 868                     G_LOG_LEVEL_DEBUG|
 869                     G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
 870
 871   g_log_set_handler(NULL,
 872                     (GLogLevelFlags)log_flags,
 873                     tshark_log_handler, NULL /* user_data */);
 874   g_log_set_handler(LOG_DOMAIN_MAIN,
 875                     (GLogLevelFlags)log_flags,
 876                     tshark_log_handler, NULL /* user_data */);
 877
 878 #ifdef HAVE_LIBPCAP
 879   g_log_set_handler(LOG_DOMAIN_CAPTURE,
 880                     (GLogLevelFlags)log_flags,
 881                     tshark_log_handler, NULL /* user_data */);
 882   g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
 883                     (GLogLevelFlags)log_flags,
 884                     tshark_log_handler, NULL /* user_data */);
 885 #endif
 886
 887   init_report_message(failure_warning_message, failure_warning_message,
 888                       open_failure_message, read_failure_message,
 889                       write_failure_message);
 890
 891 #ifdef HAVE_LIBPCAP
 892   capture_opts_init(&global_capture_opts);
 893   capture_session_init(&global_capture_session, &cfile);
 894 #endif
 895
 896   timestamp_set_type(TS_RELATIVE);
 897   timestamp_set_precision(TS_PREC_AUTO);
 898   timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
 899
 900   wtap_init();
 901
 902 #ifdef HAVE_PLUGINS
 903   /* Register all the plugin types we have. */
 904   epan_register_plugin_types(); /* Types known to libwireshark */
 905
 906   /* Scan for plugins.  This does *not* call their registration routines;
 907      that's done later. */
 908   scan_plugins(REPORT_LOAD_FAILURE);
 909
 910   /* Register all libwiretap plugin modules. */
 911   register_all_wiretap_modules();
 912 #endif
 913
 914   /* Register all dissectors; we must do this before checking for the
 915      "-G" flag, as the "-G" flag dumps information registered by the
 916      dissectors, and we must do it before we read the preferences, in
 917      case any dissectors register preferences. */
 918   if (!epan_init(register_all_protocols, register_all_protocol_handoffs, NULL,
 919                  NULL)) {
 920     exit_status = INIT_FAILED;
 921     goto clean_exit;
 922   }
 923
 924   /* Register all tap listeners; we do this before we parse the arguments,
 925      as the "-z" argument can specify a registered tap. */
 926
 927   /* we register the plugin taps before the other taps because
 928      stats_tree taps plugins will be registered as tap listeners
 929      by stats_tree_stat.c and need to registered before that */
 930 #ifdef HAVE_PLUGINS
 931   register_all_plugin_tap_listeners();
 932 #endif
 933 #ifdef HAVE_EXTCAP
 934   extcap_register_preferences();
 935 #endif
 936   register_all_tap_listeners();
 937   conversation_table_set_gui_info(init_iousers);
 938   hostlist_table_set_gui_info(init_hostlists);
 939   srt_table_iterate_tables(register_srt_tables, NULL);
 940   rtd_table_iterate_tables(register_rtd_tables, NULL);
 941   new_stat_tap_iterate_tables(register_simple_stat_tables, NULL);
 942
 943   /* If invoked with the "-G" flag, we dump out information based on
 944      the argument to the "-G" flag; if no argument is specified,
 945      for backwards compatibility we dump out a glossary of display
 946      filter symbols.
 947
 948      XXX - we do this here, for now, to support "-G" with no arguments.
 949      If none of our build or other processes uses "-G" with no arguments,
 950      we can just process it with the other arguments. */
 951   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
 952     proto_initialize_all_prefixes();
 953
 954     if (argc == 2)
 955       proto_registrar_dump_fields();
 956     else {
 957       if (strcmp(argv[2], "column-formats") == 0)
 958         column_dump_column_formats();
 959       else if (strcmp(argv[2], "currentprefs") == 0) {
 960         epan_load_settings();
 961         write_prefs(NULL);
 962       }
 963       else if (strcmp(argv[2], "decodes") == 0)
 964         dissector_dump_decodes();
 965       else if (strcmp(argv[2], "defaultprefs") == 0)
 966         write_prefs(NULL);
 967       else if (strcmp(argv[2], "dissector-tables") == 0)
 968         dissector_dump_dissector_tables();
 969       else if (strcmp(argv[2], "fieldcount") == 0) {
 970         /* return value for the test suite */
 971         exit_status = proto_registrar_dump_fieldcount();
 972         goto clean_exit;
 973       } else if (strcmp(argv[2], "fields") == 0)
 974         proto_registrar_dump_fields();
 975       else if (strcmp(argv[2], "folders") == 0)
 976         about_folders();
 977       else if (strcmp(argv[2], "ftypes") == 0)
 978         proto_registrar_dump_ftypes();
 979       else if (strcmp(argv[2], "heuristic-decodes") == 0)
 980         dissector_dump_heur_decodes();
 981       else if (strcmp(argv[2], "plugins") == 0) {
 982 #ifdef HAVE_PLUGINS
 983         plugins_dump_all();
 984 #endif
 985 #ifdef HAVE_LUA
 986         wslua_plugins_dump_all();
 987 #endif
 988       }
 989       else if (strcmp(argv[2], "protocols") == 0)
 990         proto_registrar_dump_protocols();
 991       else if (strcmp(argv[2], "values") == 0)
 992         proto_registrar_dump_values();
 993       else if (strcmp(argv[2], "help") == 0)
 994         glossary_option_help();
 995       /* These are supported only for backwards compatibility and may or may not work
 996        * for a given user in a given directory on a given operating system with a given
 997        * command-line interpreter.
 998        */
 999       else if (strcmp(argv[2], "?") == 0)
1000         glossary_option_help();
1001       else if (strcmp(argv[2], "-?") == 0)
1002         glossary_option_help();
1003       else {
1004         cmdarg_err("Invalid \"%s\" option for -G flag, enter -G help for more help.", argv[2]);
1005         exit_status = INVALID_OPTION;
1006         goto clean_exit;
1007       }
1008     }
1009     exit_status = EXIT_SUCCESS;
1010     goto clean_exit;
1011   }
1012
1013   tshark_debug("tshark reading settings");
1014
1015   /* Load libwireshark settings from the current profile. */
1016   prefs_p = epan_load_settings();
1017   prefs_loaded = TRUE;
1018
1019   read_filter_list(CFILTER_LIST);
1020
1021   cap_file_init(&cfile);
1022
1023   /* Print format defaults to this. */
1024   print_format = PR_FMT_TEXT;
1025   delimiter_char = " ";
1026
1027   output_fields = output_fields_new();
1028
1029   /*
1030    * To reset the options parser, set optreset to 1 on platforms that
1031    * have optreset (documented in *BSD and macOS, apparently present but
1032    * not documented in Solaris - the Illumos repository seems to
1033    * suggest that the first Solaris getopt_long(), at least as of 2004,
1034    * was based on the NetBSD one, it had optreset) and set optind to 1,
1035    * and set optind to 0 otherwise (documented as working in the GNU
1036    * getopt_long().  Setting optind to 0 didn't originally work in the
1037    * NetBSD one, but that was added later - we don't want to depend on
1038    * it if we have optreset).
1039    *
1040    * Also reset opterr to 1, so that error messages are printed by
1041    * getopt_long().
1042    */
1043 #ifdef HAVE_OPTRESET
1044   optreset = 1;
1045   optind = 1;
1046 #else
1047   optind = 0;
1048 #endif
1049   opterr = 1;
1050
1051   /* Now get our args */
1052   while ((opt = getopt_long(argc, argv, optstring, long_options, NULL)) != -1) {
1053     switch (opt) {
1054     case '2':        /* Perform two pass analysis */
1055       if(epan_auto_reset){
1056         cmdarg_err("-2 does not support auto session reset.");
1057         arg_error=TRUE;
1058       }
1059       perform_two_pass_analysis = TRUE;
1060       break;
1061     case 'M':
1062       if(perform_two_pass_analysis){
1063         cmdarg_err("-M does not support two pass analysis.");
1064         arg_error=TRUE;
1065       }
1066       epan_auto_reset_count = get_positive_int(optarg, "epan reset count");
1067       epan_auto_reset = TRUE;
1068       break;
1069     case 'a':        /* autostop criteria */
1070     case 'b':        /* Ringbuffer option */
1071     case 'c':        /* Capture x packets */
1072     case 'f':        /* capture filter */
1073     case 'g':        /* enable group read access on file(s) */
1074     case 'i':        /* Use interface x */
1075     case LONGOPT_SET_TSTAMP_TYPE: /* Set capture timestamp type */
1076     case 'p':        /* Don't capture in promiscuous mode */
1077 #ifdef HAVE_PCAP_REMOTE
1078     case 'A':        /* Authentication */
1079 #endif
1080 #ifdef HAVE_PCAP_CREATE
1081     case 'I':        /* Capture in monitor mode, if available */
1082 #endif
1083     case 's':        /* Set the snapshot (capture) length */
1084     case 'w':        /* Write to capture file x */
1085     case 'y':        /* Set the pcap data link type */
1086     case  LONGOPT_NUM_CAP_COMMENT: /* add a capture comment */
1087 #ifdef CAN_SET_CAPTURE_BUFFER_SIZE
1088     case 'B':        /* Buffer size */
1089 #endif
1090 #ifdef HAVE_LIBPCAP
1091       exit_status = capture_opts_add_opt(&global_capture_opts, opt, optarg, &start_capture);
1092       if (exit_status != 0) {
1093         goto clean_exit;
1094       }
1095 #else
1096       if (opt == 'w') {
1097         /*
1098          * Output file name, if we're reading a file and writing to another
1099          * file.
1100          */
1101         output_file_name = optarg;
1102       } else {
1103         capture_option_specified = TRUE;
1104         arg_error = TRUE;
1105       }
1106 #endif
1107       break;
1108     case 'C':
1109       /* already processed; just ignore it now */
1110       break;
1111     case 'D':        /* Print a list of capture devices and exit */
1112 #ifdef HAVE_LIBPCAP
1113       if_list = capture_interface_list(&err, &err_str,NULL);
1114       if (if_list == NULL) {
1115         if (err == 0)
1116           cmdarg_err("There are no interfaces on which a capture can be done");
1117         else {
1118           cmdarg_err("%s", err_str);
1119           g_free(err_str);
1120         }
1121         exit_status = INVALID_INTERFACE;
1122         goto clean_exit;
1123       }
1124       capture_opts_print_interfaces(if_list);
1125       free_interface_list(if_list);
1126       exit_status = EXIT_SUCCESS;
1127       goto clean_exit;
1128 #else
1129       capture_option_specified = TRUE;
1130       arg_error = TRUE;
1131 #endif
1132       break;
1133     case 'e':
1134       /* Field entry */
1135       output_fields_add(output_fields, optarg);
1136       break;
1137     case 'E':
1138       /* Field option */
1139       if (!output_fields_set_option(output_fields, optarg)) {
1140         cmdarg_err("\"%s\" is not a valid field output option=value pair.", optarg);
1141         output_fields_list_options(stderr);
1142         exit_status = INVALID_OPTION;
1143         goto clean_exit;
1144       }
1145       break;
1146     case 'F':
1147       out_file_type = wtap_short_string_to_file_type_subtype(optarg);
1148       if (out_file_type < 0) {
1149         cmdarg_err("\"%s\" isn't a valid capture file type", optarg);
1150         list_capture_types();
1151         exit_status = INVALID_OPTION;
1152         goto clean_exit;
1153       }
1154       break;
1155     case 'j':
1156       protocolfilter = wmem_strsplit(wmem_epan_scope(), optarg, " ", -1);
1157       break;
1158     case 'J':
1159       protocolfilter_flags = PF_INCLUDE_CHILDREN;
1160       protocolfilter = wmem_strsplit(wmem_epan_scope(), optarg, " ", -1);
1161       break;
1162     case 'W':        /* Select extra information to save in our capture file */
1163       /* This is patterned after the -N flag which may not be the best idea. */
1164       if (strchr(optarg, 'n')) {
1165         out_file_name_res = TRUE;
1166       } else {
1167         cmdarg_err("Invalid -W argument \"%s\"; it must be one of:", optarg);
1168         cmdarg_err_cont("\t'n' write network address resolution information (pcapng only)");
1169         exit_status = INVALID_OPTION;
1170         goto clean_exit;
1171       }
1172       break;
1173     case 'H':        /* Read address to name mappings from a hosts file */
1174       if (! add_hosts_file(optarg))
1175       {
1176         cmdarg_err("Can't read host entries from \"%s\"", optarg);
1177         exit_status = INVALID_OPTION;
1178         goto clean_exit;
1179       }
1180       out_file_name_res = TRUE;
1181       break;
1182
1183     case 'h':        /* Print help and exit */
1184       printf("TShark (Wireshark) %s\n"
1185              "Dump and analyze network traffic.\n"
1186              "See https://www.wireshark.org for more information.\n",
1187              get_ws_vcs_version_info());
1188       print_usage(stdout);
1189       exit_status = EXIT_SUCCESS;
1190       goto clean_exit;
1191       break;
1192     case 'l':        /* "Line-buffer" standard output */
1193       /* The ANSI C standard does not appear to *require* that a line-buffered
1194          stream be flushed to the host environment whenever a newline is
1195          written, it just says that, on such a stream, characters "are
1196          intended to be transmitted to or from the host environment as a
1197          block when a new-line character is encountered".
1198
1199          The Visual C++ 6.0 C implementation doesn't do what is intended;
1200          even if you set a stream to be line-buffered, it still doesn't
1201          flush the buffer at the end of every line.
1202
1203          The whole reason for the "-l" flag in either tcpdump or TShark
1204          is to allow the output of a live capture to be piped to a program
1205          or script and to have that script see the information for the
1206          packet as soon as it's printed, rather than having to wait until
1207          a standard I/O buffer fills up.
1208
1209          So, if the "-l" flag is specified, we flush the standard output
1210          at the end of a packet.  This will do the right thing if we're
1211          printing packet summary lines, and, as we print the entire protocol
1212          tree for a single packet without waiting for anything to happen,
1213          it should be as good as line-buffered mode if we're printing
1214          protocol trees - arguably even better, as it may do fewer
1215          writes. */
1216       line_buffered = TRUE;
1217       break;
1218     case 'L':        /* Print list of link-layer types and exit */
1219 #ifdef HAVE_LIBPCAP
1220       caps_queries |= CAPS_QUERY_LINK_TYPES;
1221 #else
1222       capture_option_specified = TRUE;
1223       arg_error = TRUE;
1224 #endif
1225       break;
1226     case LONGOPT_LIST_TSTAMP_TYPES: /* List possible timestamp types */
1227 #ifdef HAVE_LIBPCAP
1228       caps_queries |= CAPS_QUERY_TIMESTAMP_TYPES;
1229 #else
1230       capture_option_specified = TRUE;
1231       arg_error = TRUE;
1232 #endif
1233       break;
1234     case 'o':        /* Override preference from command line */
1235     {
1236       char *errmsg = NULL;
1237
1238       switch (prefs_set_pref(optarg, &errmsg)) {
1239
1240       case PREFS_SET_OK:
1241         break;
1242
1243       case PREFS_SET_SYNTAX_ERR:
1244         cmdarg_err("Invalid -o flag \"%s\"%s%s", optarg,
1245             errmsg ? ": " : "", errmsg ? errmsg : "");
1246         g_free(errmsg);
1247         exit_status = INVALID_OPTION;
1248         goto clean_exit;
1249         break;
1250
1251       case PREFS_SET_NO_SUCH_PREF:
1252       case PREFS_SET_OBSOLETE:
1253         cmdarg_err("-o flag \"%s\" specifies unknown preference", optarg);
1254         exit_status = INVALID_OPTION;
1255         goto clean_exit;
1256         break;
1257       }
1258       break;
1259     }
1260     case 'q':        /* Quiet */
1261       quiet = TRUE;
1262       break;
1263     case 'Q':        /* Really quiet */
1264       quiet = TRUE;
1265       really_quiet = TRUE;
1266       break;
1267     case 'r':        /* Read capture file x */
1268       cf_name = g_strdup(optarg);
1269       break;
1270     case 'R':        /* Read file filter */
1271       rfilter = optarg;
1272       break;
1273     case 'P':
1274         /* already processed; just ignore it now */
1275         break;
1276     case 'S':        /* Set the line Separator to be printed between packets */
1277       separator = optarg;
1278       break;
1279     case 'T':        /* printing Type */
1280       print_packet_info = TRUE;
1281       if (strcmp(optarg, "text") == 0) {
1282         output_action = WRITE_TEXT;
1283         print_format = PR_FMT_TEXT;
1284       } else if (strcmp(optarg, "tabs") == 0) {
1285         output_action = WRITE_TEXT;
1286         print_format = PR_FMT_TEXT;
1287         delimiter_char = "\t";
1288       } else if (strcmp(optarg, "ps") == 0) {
1289         output_action = WRITE_TEXT;
1290         print_format = PR_FMT_PS;
1291       } else if (strcmp(optarg, "pdml") == 0) {
1292         output_action = WRITE_XML;
1293         print_details = TRUE;   /* Need details */
1294         print_summary = FALSE;  /* Don't allow summary */
1295       } else if (strcmp(optarg, "psml") == 0) {
1296         output_action = WRITE_XML;
1297         print_details = FALSE;  /* Don't allow details */
1298         print_summary = TRUE;   /* Need summary */
1299       } else if (strcmp(optarg, "fields") == 0) {
1300         output_action = WRITE_FIELDS;
1301         print_details = TRUE;   /* Need full tree info */
1302         print_summary = FALSE;  /* Don't allow summary */
1303       } else if (strcmp(optarg, "json") == 0) {
1304         output_action = WRITE_JSON;
1305         print_details = TRUE;   /* Need details */
1306         print_summary = FALSE;  /* Don't allow summary */
1307       } else if (strcmp(optarg, "ek") == 0) {
1308         output_action = WRITE_EK;
1309         if (!print_summary)
1310           print_details = TRUE;
1311       } else if (strcmp(optarg, "jsonraw") == 0) {
1312         output_action = WRITE_JSON_RAW;
1313         print_details = TRUE;   /* Need details */
1314         print_summary = FALSE;  /* Don't allow summary */
1315       }
1316       else {
1317         cmdarg_err("Invalid -T parameter \"%s\"; it must be one of:", optarg);                   /* x */
1318         cmdarg_err_cont("\t\"fields\"  The values of fields specified with the -e option, in a form\n"
1319                         "\t          specified by the -E option.\n"
1320                         "\t\"pdml\"    Packet Details Markup Language, an XML-based format for the\n"
1321                         "\t          details of a decoded packet. This information is equivalent to\n"
1322                         "\t          the packet details printed with the -V flag.\n"
1323                         "\t\"ps\"      PostScript for a human-readable one-line summary of each of\n"
1324                         "\t          the packets, or a multi-line view of the details of each of\n"
1325                         "\t          the packets, depending on whether the -V flag was specified.\n"
1326                         "\t\"psml\"    Packet Summary Markup Language, an XML-based format for the\n"
1327                         "\t          summary information of a decoded packet. This information is\n"
1328                         "\t          equivalent to the information shown in the one-line summary\n"
1329                         "\t          printed by default.\n"
1330                         "\t\"json\"    Packet Summary, an JSON-based format for the details\n"
1331                         "\t          summary information of a decoded packet. This information is \n"
1332                         "\t          equivalent to the packet details printed with the -V flag.\n"
1333                         "\t\"jsonraw\" Packet Details, a JSON-based format for machine parsing\n"
1334                         "\t          including only raw hex decoded fields (same as -T json -x but\n"
1335                         "\t          without text decoding, only raw fields included). \n"
1336                         "\t\"ek\"      Packet Details, an EK JSON-based format for the bulk insert \n"
1337                         "\t          into elastic search cluster. This information is \n"
1338                         "\t          equivalent to the packet details printed with the -V flag.\n"
1339                         "\t\"text\"    Text of a human-readable one-line summary of each of the\n"
1340                         "\t          packets, or a multi-line view of the details of each of the\n"
1341                         "\t          packets, depending on whether the -V flag was specified.\n"
1342                         "\t          This is the default.\n"
1343                         "\t\"tabs\"    Similar to the text report except that each column of the\n"
1344                         "\t          human-readable one-line summary is delimited with an ASCII\n"
1345                         "\t          horizontal tab character.");
1346         exit_status = INVALID_OPTION;
1347         goto clean_exit;
1348       }
1349       break;
1350     case 'U':        /* Export PDUs to file */
1351     {
1352         GSList *export_pdu_tap_name_list = NULL;
1353
1354         if (!*optarg) {
1355             cmdarg_err("A tap name is required. Valid names are:");
1356             for (export_pdu_tap_name_list = get_export_pdu_tap_list(); export_pdu_tap_name_list; export_pdu_tap_name_list = g_slist_next(export_pdu_tap_name_list)) {
1357                 cmdarg_err("%s\n", (const char*)(export_pdu_tap_name_list->data));
1358             }
1359             exit_status = INVALID_OPTION;
1360             goto clean_exit;
1361         }
1362         pdu_export_arg = g_strdup(optarg);
1363         break;
1364     }
1365     case 'v':         /* Show version and exit */
1366       comp_info_str = get_compiled_version_info(get_tshark_compiled_version_info,
1367                                                 epan_get_compiled_version_info);
1368       runtime_info_str = get_runtime_version_info(get_tshark_runtime_version_info);
1369       show_version("TShark (Wireshark)", comp_info_str, runtime_info_str);
1370       g_string_free(comp_info_str, TRUE);
1371       g_string_free(runtime_info_str, TRUE);
1372       /* We don't really have to cleanup here, but it's a convenient way to test
1373        * start-up and shut-down of the epan library without any UI-specific
1374        * cruft getting in the way. Makes the results of running
1375        * $ ./tools/valgrind-wireshark -n
1376        * much more useful. */
1377       epan_cleanup();
1378 #ifdef HAVE_EXTCAP
1379       extcap_cleanup();
1380 #endif
1381       exit_status = EXIT_SUCCESS;
1382       goto clean_exit;
1383     case 'O':        /* Only output these protocols */
1384       /* already processed; just ignore it now */
1385       break;
1386     case 'V':        /* Verbose */
1387       /* already processed; just ignore it now */
1388       break;
1389     case 'x':        /* Print packet data in hex (and ASCII) */
1390       /* already processed; just ignore it now */
1391       break;
1392     case 'X':
1393       /* already processed; just ignore it now */
1394       break;
1395     case 'Y':
1396       dfilter = optarg;
1397       break;
1398     case 'z':
1399       /* We won't call the init function for the stat this soon
1400          as it would disallow MATE's fields (which are registered
1401          by the preferences set callback) from being used as
1402          part of a tap filter.  Instead, we just add the argument
1403          to a list of stat arguments. */
1404       if (strcmp("help", optarg) == 0) {
1405         fprintf(stderr, "tshark: The available statistics for the \"-z\" option are:\n");
1406         list_stat_cmd_args();
1407         exit_status = EXIT_SUCCESS;
1408         goto clean_exit;
1409       }
1410       if (!process_stat_cmd_arg(optarg)) {
1411         cmdarg_err("Invalid -z argument \"%s\"; it must be one of:", optarg);
1412         list_stat_cmd_args();
1413         exit_status = INVALID_OPTION;
1414         goto clean_exit;
1415       }
1416       break;
1417     case 'd':        /* Decode as rule */
1418     case 'K':        /* Kerberos keytab file */
1419     case 'n':        /* No name resolution */
1420     case 'N':        /* Select what types of addresses/port #s to resolve */
1421     case 't':        /* Time stamp type */
1422     case 'u':        /* Seconds type */
1423     case LONGOPT_DISABLE_PROTOCOL: /* disable dissection of protocol */
1424     case LONGOPT_ENABLE_HEURISTIC: /* enable heuristic dissection of protocol */
1425     case LONGOPT_DISABLE_HEURISTIC: /* disable heuristic dissection of protocol */
1426     case LONGOPT_ENABLE_PROTOCOL: /* enable dissection of protocol (that is disabled by default) */
1427       if (!dissect_opts_handle_opt(opt, optarg)) {
1428         exit_status = INVALID_OPTION;
1429         goto clean_exit;
1430       }
1431       break;
1432     case LONGOPT_EXPORT_OBJECTS:   /* --export-objects */
1433       if (strcmp("help", optarg) == 0) {
1434         fprintf(stderr, "tshark: The available export object types for the \"--export-objects\" option are:\n");
1435         eo_list_object_types();
1436         exit_status = EXIT_SUCCESS;
1437         goto clean_exit;
1438       }
1439       if (!eo_tap_opt_add(optarg)) {
1440         exit_status = INVALID_OPTION;
1441         goto clean_exit;
1442       }
1443       break;
1444     case LONGOPT_COLOR: /* print in color where appropriate */
1445       dissect_color = TRUE;
1446       break;
1447     case LONGOPT_NO_DUPLICATE_KEYS:
1448       no_duplicate_keys = TRUE;
1449       node_children_grouper = proto_node_group_children_by_json_key;
1450       break;
1451     default:
1452     case '?':        /* Bad flag - print usage message */
1453       switch(optopt) {
1454       case 'F':
1455         list_capture_types();
1456         break;
1457       default:
1458         print_usage(stderr);
1459       }
1460       exit_status = INVALID_OPTION;
1461       goto clean_exit;
1462       break;
1463     }
1464   }
1465
1466   /*
1467    * Print packet summary information is the default if neither -V or -x
1468    * were specified. Note that this is new behavior, which allows for the
1469    * possibility of printing only hex/ascii output without necessarily
1470    * requiring that either the summary or details be printed too.
1471    */
1472   if (!print_summary && !print_details && !print_hex)
1473     print_summary = TRUE;
1474
1475   if (no_duplicate_keys && output_action != WRITE_JSON && output_action != WRITE_JSON_RAW) {
1476     cmdarg_err("--no-duplicate-keys can only be used with \"-T json\" and \"-T jsonraw\"");
1477     exit_status = INVALID_OPTION;
1478     goto clean_exit;
1479   }
1480
1481   /* If we specified output fields, but not the output field type... */
1482   if ((WRITE_FIELDS != output_action && WRITE_XML != output_action && WRITE_JSON != output_action && WRITE_EK != output_action) && 0 != output_fields_num_fields(output_fields)) {
1483         cmdarg_err("Output fields were specified with \"-e\", "
1484             "but \"-Tek, -Tfields, -Tjson or -Tpdml\" was not specified.");
1485         exit_status = INVALID_OPTION;
1486         goto clean_exit;
1487   } else if (WRITE_FIELDS == output_action && 0 == output_fields_num_fields(output_fields)) {
1488         cmdarg_err("\"-Tfields\" was specified, but no fields were "
1489                     "specified with \"-e\".");
1490
1491         exit_status = INVALID_OPTION;
1492         goto clean_exit;
1493   }
1494
1495   if (dissect_color) {
1496     if (!color_filters_init(&err_msg, NULL)) {
1497       fprintf(stderr, "%s\n", err_msg);
1498       g_free(err_msg);
1499     }
1500   }
1501
1502   /* If no capture filter or display filter has been specified, and there are
1503      still command-line arguments, treat them as the tokens of a capture
1504      filter (if no "-r" flag was specified) or a display filter (if a "-r"
1505      flag was specified. */
1506   if (optind < argc) {
1507     if (cf_name != NULL) {
1508       if (dfilter != NULL) {
1509         cmdarg_err("Display filters were specified both with \"-d\" "
1510             "and with additional command-line arguments.");
1511         exit_status = INVALID_OPTION;
1512         goto clean_exit;
1513       }
1514       dfilter = get_args_as_string(argc, argv, optind);
1515     } else {
1516 #ifdef HAVE_LIBPCAP
1517       guint i;
1518
1519       if (global_capture_opts.default_options.cfilter) {
1520         cmdarg_err("A default capture filter was specified both with \"-f\""
1521             " and with additional command-line arguments.");
1522         exit_status = INVALID_OPTION;
1523         goto clean_exit;
1524       }
1525       for (i = 0; i < global_capture_opts.ifaces->len; i++) {
1526         interface_options *interface_opts;
1527         interface_opts = &g_array_index(global_capture_opts.ifaces, interface_options, i);
1528         if (interface_opts->cfilter == NULL) {
1529           interface_opts->cfilter = get_args_as_string(argc, argv, optind);
1530         } else {
1531           cmdarg_err("A capture filter was specified both with \"-f\""
1532               " and with additional command-line arguments.");
1533           exit_status = INVALID_OPTION;
1534           goto clean_exit;
1535         }
1536       }
1537       global_capture_opts.default_options.cfilter = get_args_as_string(argc, argv, optind);
1538 #else
1539       capture_option_specified = TRUE;
1540 #endif
1541     }
1542   }
1543
1544 #ifdef HAVE_LIBPCAP
1545   if (!global_capture_opts.saving_to_file) {
1546     /* We're not saving the capture to a file; if "-q" wasn't specified,
1547        we should print packet information */
1548     if (!quiet)
1549       print_packet_info = TRUE;
1550   } else {
1551     /* We're saving to a file; if we're writing to the standard output.
1552        and we'll also be writing dissected packets to the standard
1553        output, reject the request.  At best, we could redirect that
1554        to the standard error; we *can't* write both to the standard
1555        output and have either of them be useful. */
1556     if (strcmp(global_capture_opts.save_file, "-") == 0 && print_packet_info) {
1557       cmdarg_err("You can't write both raw packet data and dissected packets"
1558           " to the standard output.");
1559       exit_status = INVALID_OPTION;
1560       goto clean_exit;
1561     }
1562   }
1563 #else
1564   /* We're not saving the capture to a file; if "-q" wasn't specified,
1565      we should print packet information */
1566   if (!quiet)
1567     print_packet_info = TRUE;
1568 #endif
1569
1570 #ifndef HAVE_LIBPCAP
1571   if (capture_option_specified)
1572     cmdarg_err("This version of TShark was not built with support for capturing packets.");
1573 #endif
1574   if (arg_error) {
1575     print_usage(stderr);
1576     exit_status = INVALID_OPTION;
1577     goto clean_exit;
1578   }
1579
1580   if (print_hex) {
1581     if (output_action != WRITE_TEXT && output_action != WRITE_JSON && output_action != WRITE_JSON_RAW && output_action != WRITE_EK) {
1582       cmdarg_err("Raw packet hex data can only be printed as text, PostScript, JSON, JSONRAW or EK JSON");
1583       exit_status = INVALID_OPTION;
1584       goto clean_exit;
1585     }
1586   }
1587
1588   if (output_only != NULL) {
1589     char *ps;
1590
1591     if (!print_details) {
1592       cmdarg_err("-O requires -V");
1593       exit_status = INVALID_OPTION;
1594       goto clean_exit;
1595     }
1596
1597     output_only_tables = g_hash_table_new (g_str_hash, g_str_equal);
1598     for (ps = strtok (output_only, ","); ps; ps = strtok (NULL, ",")) {
1599       g_hash_table_insert(output_only_tables, (gpointer)ps, (gpointer)ps);
1600     }
1601   }
1602
1603   if (rfilter != NULL && !perform_two_pass_analysis) {
1604     cmdarg_err("-R without -2 is deprecated. For single-pass filtering use -Y.");
1605     exit_status = INVALID_OPTION;
1606     goto clean_exit;
1607   }
1608
1609 #ifdef HAVE_LIBPCAP
1610   if (caps_queries) {
1611     /* We're supposed to list the link-layer/timestamp types for an interface;
1612        did the user also specify a capture file to be read? */
1613     if (cf_name) {
1614       /* Yes - that's bogus. */
1615       cmdarg_err("You can't specify %s and a capture file to be read.",
1616                  caps_queries & CAPS_QUERY_LINK_TYPES ? "-L" : "--list-time-stamp-types");
1617       exit_status = INVALID_OPTION;
1618       goto clean_exit;
1619     }
1620     /* No - did they specify a ring buffer option? */
1621     if (global_capture_opts.multi_files_on) {
1622       cmdarg_err("Ring buffer requested, but a capture isn't being done.");
1623       exit_status = INVALID_OPTION;
1624       goto clean_exit;
1625     }
1626   } else {
1627     if (cf_name) {
1628       /*
1629        * "-r" was specified, so we're reading a capture file.
1630        * Capture options don't apply here.
1631        */
1632
1633       /* We don't support capture filters when reading from a capture file
1634          (the BPF compiler doesn't support all link-layer types that we
1635          support in capture files we read). */
1636       if (global_capture_opts.default_options.cfilter) {
1637         cmdarg_err("Only read filters, not capture filters, "
1638           "can be specified when reading a capture file.");
1639         exit_status = INVALID_OPTION;
1640         goto clean_exit;
1641       }
1642       if (global_capture_opts.multi_files_on) {
1643         cmdarg_err("Multiple capture files requested, but "
1644                    "a capture isn't being done.");
1645         exit_status = INVALID_OPTION;
1646         goto clean_exit;
1647       }
1648       if (global_capture_opts.has_file_duration) {
1649         cmdarg_err("Switching capture files after a time period was specified, but "
1650                    "a capture isn't being done.");
1651         exit_status = INVALID_OPTION;
1652         goto clean_exit;
1653       }
1654       if (global_capture_opts.has_file_interval) {
1655         cmdarg_err("Switching capture files after a time interval was specified, but "
1656                    "a capture isn't being done.");
1657         exit_status = INVALID_OPTION;
1658         goto clean_exit;
1659       }
1660       if (global_capture_opts.has_ring_num_files) {
1661         cmdarg_err("A ring buffer of capture files was specified, but "
1662           "a capture isn't being done.");
1663         exit_status = INVALID_OPTION;
1664         goto clean_exit;
1665       }
1666       if (global_capture_opts.has_autostop_files) {
1667         cmdarg_err("A maximum number of capture files was specified, but "
1668           "a capture isn't being done.");
1669         exit_status = INVALID_OPTION;
1670         goto clean_exit;
1671       }
1672       if (global_capture_opts.capture_comment) {
1673         cmdarg_err("A capture comment was specified, but "
1674           "a capture isn't being done.\nThere's no support for adding "
1675           "a capture comment to an existing capture file.");
1676         exit_status = INVALID_OPTION;
1677         goto clean_exit;
1678       }
1679
1680       /* Note: TShark now allows the restriction of a _read_ file by packet count
1681        * and byte count as well as a write file. Other autostop options remain valid
1682        * only for a write file.
1683        */
1684       if (global_capture_opts.has_autostop_duration) {
1685         cmdarg_err("A maximum capture time was specified, but "
1686           "a capture isn't being done.");
1687         exit_status = INVALID_OPTION;
1688         goto clean_exit;
1689       }
1690     } else {
1691       /*
1692        * "-r" wasn't specified, so we're doing a live capture.
1693        */
1694       if (perform_two_pass_analysis) {
1695         /* Two-pass analysis doesn't work with live capture since it requires us
1696          * to buffer packets until we've read all of them, but a live capture
1697          * has no useful/meaningful definition of "all" */
1698         cmdarg_err("Live captures do not support two-pass analysis.");
1699         exit_status = INVALID_OPTION;
1700         goto clean_exit;
1701       }
1702
1703       if (global_capture_opts.saving_to_file) {
1704         /* They specified a "-w" flag, so we'll be saving to a capture file. */
1705
1706         /* When capturing, we only support writing pcap or pcap-ng format. */
1707         if (out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAP &&
1708             out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAPNG) {
1709           cmdarg_err("Live captures can only be saved in pcap or pcapng format.");
1710           exit_status = INVALID_OPTION;
1711           goto clean_exit;
1712         }
1713         if (global_capture_opts.capture_comment &&
1714             out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAPNG) {
1715           cmdarg_err("A capture comment can only be written to a pcapng file.");
1716           exit_status = INVALID_OPTION;
1717           goto clean_exit;
1718         }
1719         if (global_capture_opts.multi_files_on) {
1720           /* Multiple-file mode doesn't work under certain conditions:
1721              a) it doesn't work if you're writing to the standard output;
1722              b) it doesn't work if you're writing to a pipe;
1723           */
1724           if (strcmp(global_capture_opts.save_file, "-") == 0) {
1725             cmdarg_err("Multiple capture files requested, but "
1726               "the capture is being written to the standard output.");
1727             exit_status = INVALID_OPTION;
1728             goto clean_exit;
1729           }
1730           if (global_capture_opts.output_to_pipe) {
1731             cmdarg_err("Multiple capture files requested, but "
1732               "the capture file is a pipe.");
1733             exit_status = INVALID_OPTION;
1734             goto clean_exit;
1735           }
1736           if (!global_capture_opts.has_autostop_filesize &&
1737               !global_capture_opts.has_file_duration &&
1738               !global_capture_opts.has_file_interval) {
1739             cmdarg_err("Multiple capture files requested, but "
1740               "no maximum capture file size, duration or interval was specified.");
1741             exit_status = INVALID_OPTION;
1742             goto clean_exit;
1743           }
1744         }
1745         /* Currently, we don't support read or display filters when capturing
1746            and saving the packets. */
1747         if (rfilter != NULL) {
1748           cmdarg_err("Read filters aren't supported when capturing and saving the captured packets.");
1749           exit_status = INVALID_OPTION;
1750           goto clean_exit;
1751         }
1752         if (dfilter != NULL) {
1753           cmdarg_err("Display filters aren't supported when capturing and saving the captured packets.");
1754           exit_status = INVALID_OPTION;
1755           goto clean_exit;
1756         }
1757         global_capture_opts.use_pcapng = (out_file_type == WTAP_FILE_TYPE_SUBTYPE_PCAPNG) ? TRUE : FALSE;
1758       } else {
1759         /* They didn't specify a "-w" flag, so we won't be saving to a
1760            capture file.  Check for options that only make sense if
1761            we're saving to a file. */
1762         if (global_capture_opts.has_autostop_filesize) {
1763           cmdarg_err("Maximum capture file size specified, but "
1764            "capture isn't being saved to a file.");
1765           exit_status = INVALID_OPTION;
1766           goto clean_exit;
1767         }
1768         if (global_capture_opts.multi_files_on) {
1769           cmdarg_err("Multiple capture files requested, but "
1770             "the capture isn't being saved to a file.");
1771           exit_status = INVALID_OPTION;
1772           goto clean_exit;
1773         }
1774         if (global_capture_opts.capture_comment) {
1775           cmdarg_err("A capture comment was specified, but "
1776             "the capture isn't being saved to a file.");
1777           exit_status = INVALID_OPTION;
1778           goto clean_exit;
1779         }
1780       }
1781     }
1782   }
1783 #endif
1784
1785 #ifdef _WIN32
1786   /* Start windows sockets */
1787   result = WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
1788   if (result != 0)
1789   {
1790     exit_status = INIT_FAILED;
1791     goto clean_exit;
1792   }
1793 #endif /* _WIN32 */
1794
1795   /* Notify all registered modules that have had any of their preferences
1796      changed either from one of the preferences file or from the command
1797      line that their preferences have changed. */
1798   prefs_apply_all();
1799
1800   /* At this point MATE will have registered its field array so we can
1801      have a tap filter with one of MATE's late-registered fields as part
1802      of the filter.  We can now process all the "-z" arguments. */
1803   start_requested_stats();
1804
1805   /* We can also enable specified taps for export object */
1806   start_exportobjects();
1807
1808   /* At this point MATE will have registered its field array so we can
1809      check if the fields specified by the user are all good.
1810    */
1811   {
1812     GSList* it = NULL;
1813     GSList *invalid_fields = output_fields_valid(output_fields);
1814     if (invalid_fields != NULL) {
1815
1816       cmdarg_err("Some fields aren't valid:");
1817       for (it=invalid_fields; it != NULL; it = g_slist_next(it)) {
1818         cmdarg_err_cont("\t%s", (gchar *)it->data);
1819       }
1820       g_slist_free(invalid_fields);
1821       exit_status = INVALID_OPTION;
1822       goto clean_exit;
1823     }
1824   }
1825 #ifdef HAVE_LIBPCAP
1826   /* We currently don't support taps, or printing dissected packets,
1827      if we're writing to a pipe. */
1828   if (global_capture_opts.saving_to_file &&
1829       global_capture_opts.output_to_pipe) {
1830     if (tap_listeners_require_dissection()) {
1831       cmdarg_err("Taps aren't supported when saving to a pipe.");
1832       exit_status = INVALID_OPTION;
1833       goto clean_exit;
1834     }
1835     if (print_packet_info) {
1836       cmdarg_err("Printing dissected packets isn't supported when saving to a pipe.");
1837       exit_status = INVALID_OPTION;
1838       goto clean_exit;
1839     }
1840   }
1841 #endif
1842
1843   if (ex_opt_count("read_format") > 0) {
1844     const gchar* name = ex_opt_get_next("read_format");
1845     in_file_type = open_info_name_to_type(name);
1846     if (in_file_type == WTAP_TYPE_AUTO) {
1847       cmdarg_err("\"%s\" isn't a valid read file format type", name? name : "");
1848       list_read_capture_types();
1849       exit_status = INVALID_OPTION;
1850       goto clean_exit;
1851     }
1852   }
1853
1854   timestamp_set_type(global_dissect_options.time_format);
1855
1856   /*
1857    * Enabled and disabled protocols and heuristic dissectors as per
1858    * command-line options.
1859    */
1860   if (!setup_enabled_and_disabled_protocols()) {
1861     exit_status = INVALID_OPTION;
1862     goto clean_exit;
1863   }
1864
1865   /* Build the column format array */
1866   build_column_format_array(&cfile.cinfo, prefs_p->num_cols, TRUE);
1867
1868 #ifdef HAVE_LIBPCAP
1869   capture_opts_trim_snaplen(&global_capture_opts, MIN_PACKET_SIZE);
1870   capture_opts_trim_ring_num_files(&global_capture_opts);
1871 #endif
1872
1873   if (rfilter != NULL) {
1874     tshark_debug("Compiling read filter: '%s'", rfilter);
1875     if (!dfilter_compile(rfilter, &rfcode, &err_msg)) {
1876       cmdarg_err("%s", err_msg);
1877       g_free(err_msg);
1878       epan_cleanup();
1879 #ifdef HAVE_EXTCAP
1880       extcap_cleanup();
1881 #endif
1882 #ifdef HAVE_PCAP_OPEN_DEAD
1883       {
1884         pcap_t *pc;
1885
1886         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1887         if (pc != NULL) {
1888           if (pcap_compile(pc, &fcode, rfilter, 0, 0) != -1) {
1889             cmdarg_err_cont(
1890               "  Note: That read filter code looks like a valid capture filter;\n"
1891               "        maybe you mixed them up?");
1892           }
1893           pcap_close(pc);
1894         }
1895       }
1896 #endif
1897       exit_status = INVALID_INTERFACE;
1898       goto clean_exit;
1899     }
1900   }
1901   cfile.rfcode = rfcode;
1902
1903   if (dfilter != NULL) {
1904     tshark_debug("Compiling display filter: '%s'", dfilter);
1905     if (!dfilter_compile(dfilter, &dfcode, &err_msg)) {
1906       cmdarg_err("%s", err_msg);
1907       g_free(err_msg);
1908       epan_cleanup();
1909 #ifdef HAVE_EXTCAP
1910       extcap_cleanup();
1911 #endif
1912 #ifdef HAVE_PCAP_OPEN_DEAD
1913       {
1914         pcap_t *pc;
1915
1916         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1917         if (pc != NULL) {
1918           if (pcap_compile(pc, &fcode, dfilter, 0, 0) != -1) {
1919             cmdarg_err_cont(
1920               "  Note: That display filter code looks like a valid capture filter;\n"
1921               "        maybe you mixed them up?");
1922           }
1923           pcap_close(pc);
1924         }
1925       }
1926 #endif
1927       exit_status = INVALID_FILTER;
1928       goto clean_exit;
1929     }
1930   }
1931   cfile.dfcode = dfcode;
1932
1933   if (print_packet_info) {
1934     /* If we're printing as text or PostScript, we have
1935        to create a print stream. */
1936     if (output_action == WRITE_TEXT) {
1937       switch (print_format) {
1938
1939       case PR_FMT_TEXT:
1940         print_stream = print_stream_text_stdio_new(stdout);
1941         break;
1942
1943       case PR_FMT_PS:
1944         print_stream = print_stream_ps_stdio_new(stdout);
1945         break;
1946
1947       default:
1948         g_assert_not_reached();
1949       }
1950     }
1951   }
1952
1953   /* PDU export requested. Take the ownership of the '-w' file, apply tap
1954   * filters and start tapping. */
1955   if (pdu_export_arg) {
1956       const char *exp_pdu_tap_name = pdu_export_arg;
1957       const char *exp_pdu_filter = dfilter; /* may be NULL to disable filter */
1958       char       *exp_pdu_error;
1959       int         exp_fd;
1960       char       *comment;
1961
1962       if (!cf_name) {
1963           cmdarg_err("PDUs export requires a capture file (specify with -r).");
1964           exit_status = INVALID_OPTION;
1965           goto clean_exit;
1966       }
1967       /* Take ownership of the '-w' output file. */
1968 #ifdef HAVE_LIBPCAP
1969       exp_pdu_filename = global_capture_opts.save_file;
1970       global_capture_opts.save_file = NULL;
1971 #else
1972       exp_pdu_filename = output_file_name;
1973       output_file_name = NULL;
1974 #endif
1975       if (exp_pdu_filename == NULL) {
1976           cmdarg_err("PDUs export requires an output file (-w).");
1977           exit_status = INVALID_OPTION;
1978           goto clean_exit;
1979       }
1980
1981       exp_pdu_error = exp_pdu_pre_open(exp_pdu_tap_name, exp_pdu_filter,
1982           &exp_pdu_tap_data);
1983       if (exp_pdu_error) {
1984           cmdarg_err("Cannot register tap: %s", exp_pdu_error);
1985           g_free(exp_pdu_error);
1986           exit_status = INVALID_TAP;
1987           goto clean_exit;
1988       }
1989
1990       exp_fd = ws_open(exp_pdu_filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
1991       if (exp_fd == -1) {
1992           cmdarg_err("%s: %s", exp_pdu_filename, file_open_error_message(errno, TRUE));
1993           exit_status = INVALID_FILE;
1994           goto clean_exit;
1995       }
1996
1997       /* Activate the export PDU tap */
1998       comment = g_strdup_printf("Dump of PDUs from %s", cf_name);
1999       err = exp_pdu_open(&exp_pdu_tap_data, exp_fd, comment);
2000       if (err != 0) {
2001           cfile_dump_open_failure_message("TShark", exp_pdu_filename, err,
2002                                           WTAP_FILE_TYPE_SUBTYPE_PCAPNG);
2003           g_free(comment);
2004           exit_status = INVALID_EXPORT;
2005           goto clean_exit;
2006       }
2007   }
2008
2009   /* We have to dissect each packet if:
2010
2011         we're printing information about each packet;
2012
2013         we're using a read filter on the packets;
2014
2015         we're using a display filter on the packets;
2016
2017         we're exporting PDUs;
2018
2019         we're using any taps that need dissection. */
2020   do_dissection = print_packet_info || rfcode || dfcode || pdu_export_arg ||
2021       tap_listeners_require_dissection() || dissect_color;
2022   tshark_debug("tshark: do_dissection = %s", do_dissection ? "TRUE" : "FALSE");
2023
2024   if (cf_name) {
2025     tshark_debug("tshark: Opening capture file: %s", cf_name);
2026     /*
2027      * We're reading a capture file.
2028      */
2029     if (cf_open(&cfile, cf_name, in_file_type, FALSE, &err) != CF_OK) {
2030       epan_cleanup();
2031 #ifdef HAVE_EXTCAP
2032       extcap_cleanup();
2033 #endif
2034       exit_status = INVALID_FILE;
2035       goto clean_exit;
2036     }
2037
2038     /* Process the packets in the file */
2039     tshark_debug("tshark: invoking process_cap_file() to process the packets");
2040     TRY {
2041 #ifdef HAVE_LIBPCAP
2042       success = process_cap_file(&cfile, global_capture_opts.save_file, out_file_type, out_file_name_res,
2043           global_capture_opts.has_autostop_packets ? global_capture_opts.autostop_packets : 0,
2044           global_capture_opts.has_autostop_filesize ? global_capture_opts.autostop_filesize : 0);
2045 #else
2046       success = process_cap_file(&cfile, output_file_name, out_file_type, out_file_name_res, 0, 0);
2047 #endif
2048     }
2049     CATCH(OutOfMemoryError) {
2050       fprintf(stderr,
2051               "Out Of Memory.\n"
2052               "\n"
2053               "Sorry, but TShark has to terminate now.\n"
2054               "\n"
2055               "More information and workarounds can be found at\n"
2056               "https://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2057       success = FALSE;
2058     }
2059     ENDTRY;
2060
2061     if (!success) {
2062       /* We still dump out the results of taps, etc., as we might have
2063          read some packets; however, we exit with an error status. */
2064       exit_status = 2;
2065     }
2066
2067     if (pdu_export_arg) {
2068         err = exp_pdu_close(&exp_pdu_tap_data);
2069         if (err) {
2070             cfile_close_failure_message(exp_pdu_filename, err);
2071             exit_status = 2;
2072         }
2073         g_free(pdu_export_arg);
2074     }
2075   } else {
2076     tshark_debug("tshark: no capture file specified");
2077     /* No capture file specified, so we're supposed to do a live capture
2078        or get a list of link-layer types for a live capture device;
2079        do we have support for live captures? */
2080 #ifdef HAVE_LIBPCAP
2081     /* if no interface was specified, pick a default */
2082     exit_status = capture_opts_default_iface_if_necessary(&global_capture_opts,
2083         ((prefs_p->capture_device) && (*prefs_p->capture_device != '\0')) ? get_if_name(prefs_p->capture_device) : NULL);
2084     if (exit_status != 0) {
2085       goto clean_exit;
2086     }
2087
2088     /* if requested, list the link layer types and exit */
2089     if (caps_queries) {
2090         guint i;
2091
2092         /* Get the list of link-layer types for the capture devices. */
2093         for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2094           interface_options *interface_opts;
2095           if_capabilities_t *caps;
2096           char *auth_str = NULL;
2097           int if_caps_queries = caps_queries;
2098
2099           interface_opts = &g_array_index(global_capture_opts.ifaces, interface_options, i);
2100 #ifdef HAVE_PCAP_REMOTE
2101           if (interface_opts->auth_type == CAPTURE_AUTH_PWD) {
2102               auth_str = g_strdup_printf("%s:%s", interface_opts->auth_username, interface_opts->auth_password);
2103           }
2104 #endif
2105           caps = capture_get_if_capabilities(interface_opts->name, interface_opts->monitor_mode, auth_str, &err_str, NULL);
2106           g_free(auth_str);
2107           if (caps == NULL) {
2108             cmdarg_err("%s", err_str);
2109             g_free(err_str);
2110             exit_status = INVALID_CAPABILITY;
2111             goto clean_exit;
2112           }
2113           if ((if_caps_queries & CAPS_QUERY_LINK_TYPES) && caps->data_link_types == NULL) {
2114             cmdarg_err("The capture device \"%s\" has no data link types.", interface_opts->name);
2115             exit_status = INVALID_DATA_LINK;
2116             goto clean_exit;
2117           }
2118           if ((if_caps_queries & CAPS_QUERY_TIMESTAMP_TYPES) && caps->timestamp_types == NULL) {
2119             cmdarg_err("The capture device \"%s\" has no timestamp types.", interface_opts->name);
2120             exit_status = INVALID_TIMESTAMP_TYPE;
2121             goto clean_exit;
2122           }
2123           if (interface_opts->monitor_mode)
2124                 if_caps_queries |= CAPS_MONITOR_MODE;
2125           capture_opts_print_if_capabilities(caps, interface_opts->name, if_caps_queries);
2126           free_if_capabilities(caps);
2127         }
2128         exit_status = EXIT_SUCCESS;
2129         goto clean_exit;
2130     }
2131
2132     /*
2133      * If the standard error isn't a terminal, don't print packet counts,
2134      * as they won't show up on the user's terminal and they'll get in
2135      * the way of error messages in the file (to which we assume the
2136      * standard error was redirected; if it's redirected to the null
2137      * device, there's no point in printing packet counts anyway).
2138      *
2139      * Otherwise, if we're printing packet information and the standard
2140      * output is a terminal (which we assume means the standard output and
2141      * error are going to the same terminal), don't print packet counts,
2142      * as they'll get in the way of the packet information.
2143      *
2144      * Otherwise, if the user specified -q, don't print packet counts.
2145      *
2146      * Otherwise, print packet counts.
2147      *
2148      * XXX - what if the user wants to do a live capture, doesn't want
2149      * to save it to a file, doesn't want information printed for each
2150      * packet, does want some "-z" statistic, and wants packet counts
2151      * so they know whether they're seeing any packets?  -q will
2152      * suppress the information printed for each packet, but it'll
2153      * also suppress the packet counts.
2154      */
2155     if (!ws_isatty(ws_fileno(stderr)))
2156       print_packet_counts = FALSE;
2157     else if (print_packet_info && ws_isatty(ws_fileno(stdout)))
2158       print_packet_counts = FALSE;
2159     else if (quiet)
2160       print_packet_counts = FALSE;
2161     else
2162       print_packet_counts = TRUE;
2163
2164     if (print_packet_info) {
2165       if (!write_preamble(&cfile)) {
2166         show_print_file_io_error(errno);
2167         exit_status = INVALID_FILE;
2168         goto clean_exit;
2169       }
2170     }
2171
2172     tshark_debug("tshark: performing live capture");
2173     /*
2174      * XXX - this returns FALSE if an error occurred, but it also
2175      * returns FALSE if the capture stops because a time limit
2176      * was reached (and possibly other limits), so we can't assume
2177      * it means an error.
2178      *
2179      * The capture code is a bit twisty, so it doesn't appear to
2180      * be an easy fix.  We just ignore the return value for now.
2181      * Instead, pass on the exit status from the capture child.
2182      */
2183     capture();
2184     exit_status = global_capture_session.fork_child_status;
2185
2186     if (print_packet_info) {
2187       if (!write_finale()) {
2188         show_print_file_io_error(errno);
2189       }
2190     }
2191 #else
2192     /* No - complain. */
2193     cmdarg_err("This version of TShark was not built with support for capturing packets.");
2194     exit_status = INVALID_CAPTURE;
2195     goto clean_exit;
2196 #endif
2197   }
2198
2199   g_free(cf_name);
2200
2201   if (cfile.provider.frames != NULL) {
2202     free_frame_data_sequence(cfile.provider.frames);
2203     cfile.provider.frames = NULL;
2204   }
2205
2206   draw_tap_listeners(TRUE);
2207   funnel_dump_all_text_windows();
2208   epan_free(cfile.epan);
2209   epan_cleanup();
2210 #ifdef HAVE_EXTCAP
2211   extcap_cleanup();
2212 #endif
2213
2214   output_fields_free(output_fields);
2215   output_fields = NULL;
2216
2217 clean_exit:
2218   destroy_print_stream(print_stream);
2219 #ifdef HAVE_LIBPCAP
2220   capture_opts_cleanup(&global_capture_opts);
2221 #endif
2222   col_cleanup(&cfile.cinfo);
2223   free_filter_lists();
2224   wtap_cleanup();
2225   free_progdirs();
2226 #ifdef HAVE_PLUGINS
2227   plugins_cleanup();
2228 #endif
2229   cf_close(&cfile);
2230   return exit_status;
2231 }
2232
2233 /*#define USE_BROKEN_G_MAIN_LOOP*/
2234
2235 #ifdef USE_BROKEN_G_MAIN_LOOP
2236   GMainLoop *loop;
2237 #else
2238   gboolean loop_running = FALSE;
2239 #endif
2240   guint32 packet_count = 0;
2241
2242
2243 typedef struct pipe_input_tag {
2244   gint             source;
2245   gpointer         user_data;
2246   ws_process_id   *child_process;
2247   pipe_input_cb_t  input_cb;
2248   guint            pipe_input_id;
2249 #ifdef _WIN32
2250   GMutex          *callback_running;
2251 #endif
2252 } pipe_input_t;
2253
2254 static pipe_input_t pipe_input;
2255
2256 #ifdef _WIN32
2257 /* The timer has expired, see if there's stuff to read from the pipe,
2258    if so, do the callback */
2259 static gint
2260 pipe_timer_cb(gpointer data)
2261 {
2262   HANDLE        handle;
2263   DWORD         avail        = 0;
2264   gboolean      result;
2265   DWORD         childstatus;
2266   pipe_input_t *pipe_input_p = data;
2267   gint          iterations   = 0;
2268
2269   g_mutex_lock (pipe_input_p->callback_running);
2270
2271   /* try to read data from the pipe only 5 times, to avoid blocking */
2272   while(iterations < 5) {
2273     /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: new iteration");*/
2274
2275     /* Oddly enough although Named pipes don't work on win9x,
2276        PeekNamedPipe does !!! */
2277     handle = (HANDLE) _get_osfhandle (pipe_input_p->source);
2278     result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
2279
2280     /* Get the child process exit status */
2281     GetExitCodeProcess((HANDLE)*(pipe_input_p->child_process),
2282                        &childstatus);
2283
2284     /* If the Peek returned an error, or there are bytes to be read
2285        or the childwatcher thread has terminated then call the normal
2286        callback */
2287     if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
2288
2289       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: data avail");*/
2290
2291       /* And call the real handler */
2292       if (!pipe_input_p->input_cb(pipe_input_p->source, pipe_input_p->user_data)) {
2293         g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
2294         /* pipe closed, return false so that the timer is stopped */
2295         g_mutex_unlock (pipe_input_p->callback_running);
2296         return FALSE;
2297       }
2298     }
2299     else {
2300       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: no data avail");*/
2301       /* No data, stop now */
2302       break;
2303     }
2304
2305     iterations++;
2306   }
2307
2308   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: finished with iterations: %u, new timer", iterations);*/
2309
2310   g_mutex_unlock (pipe_input_p->callback_running);
2311
2312   /* we didn't stopped the timer, so let it run */
2313   return TRUE;
2314 }
2315 #endif
2316
2317
2318 void
2319 pipe_input_set_handler(gint source, gpointer user_data, ws_process_id *child_process, pipe_input_cb_t input_cb)
2320 {
2321
2322   pipe_input.source         = source;
2323   pipe_input.child_process  = child_process;
2324   pipe_input.user_data      = user_data;
2325   pipe_input.input_cb       = input_cb;
2326
2327 #ifdef _WIN32
2328 #if GLIB_CHECK_VERSION(2,31,0)
2329   pipe_input.callback_running = g_malloc(sizeof(GMutex));
2330   g_mutex_init(pipe_input.callback_running);
2331 #else
2332   pipe_input.callback_running = g_mutex_new();
2333 #endif
2334   /* Tricky to use pipes in win9x, as no concept of wait.  NT can
2335      do this but that doesn't cover all win32 platforms.  GTK can do
2336      this but doesn't seem to work over processes.  Attempt to do
2337      something similar here, start a timer and check for data on every
2338      timeout. */
2339   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
2340   pipe_input.pipe_input_id = g_timeout_add(200, pipe_timer_cb, &pipe_input);
2341 #endif
2342 }
2343
2344 static const nstime_t *
2345 tshark_get_frame_ts(struct packet_provider_data *prov, guint32 frame_num)
2346 {
2347   if (prov->ref && prov->ref->num == frame_num)
2348     return &prov->ref->abs_ts;
2349
2350   if (prov->prev_dis && prov->prev_dis->num == frame_num)
2351     return &prov->prev_dis->abs_ts;
2352
2353   if (prov->prev_cap && prov->prev_cap->num == frame_num)
2354     return &prov->prev_cap->abs_ts;
2355
2356   if (prov->frames) {
2357      frame_data *fd = frame_data_sequence_find(prov->frames, frame_num);
2358
2359      return (fd) ? &fd->abs_ts : NULL;
2360   }
2361
2362   return NULL;
2363 }
2364
2365 static epan_t *
2366 tshark_epan_new(capture_file *cf)
2367 {
2368   static const struct packet_provider_funcs funcs = {
2369     tshark_get_frame_ts,
2370     cap_file_provider_get_interface_name,
2371     cap_file_provider_get_interface_description,
2372     NULL,
2373   };
2374
2375   return epan_new(&cf->provider, &funcs);
2376 }
2377
2378 #ifdef HAVE_LIBPCAP
2379 static gboolean
2380 capture(void)
2381 {
2382   gboolean          ret;
2383   guint             i;
2384   GString          *str;
2385 #ifdef USE_TSHARK_SELECT
2386   fd_set            readfds;
2387 #endif
2388 #ifndef _WIN32
2389   struct sigaction  action, oldaction;
2390 #endif
2391
2392   /* Create new dissection section. */
2393   epan_free(cfile.epan);
2394   cfile.epan = tshark_epan_new(&cfile);
2395
2396 #ifdef _WIN32
2397   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
2398   SetConsoleCtrlHandler(capture_cleanup, TRUE);
2399 #else /* _WIN32 */
2400   /* Catch SIGINT and SIGTERM and, if we get either of them,
2401      clean up and exit.  If SIGHUP isn't being ignored, catch
2402      it too and, if we get it, clean up and exit.
2403
2404      We restart any read that was in progress, so that it doesn't
2405      disrupt reading from the sync pipe.  The signal handler tells
2406      the capture child to finish; it will report that it finished,
2407      or will exit abnormally, so  we'll stop reading from the sync
2408      pipe, pick up the exit status, and quit. */
2409   memset(&action, 0, sizeof(action));
2410   action.sa_handler = capture_cleanup;
2411   action.sa_flags = SA_RESTART;
2412   sigemptyset(&action.sa_mask);
2413   sigaction(SIGTERM, &action, NULL);
2414   sigaction(SIGINT, &action, NULL);
2415   sigaction(SIGHUP, NULL, &oldaction);
2416   if (oldaction.sa_handler == SIG_DFL)
2417     sigaction(SIGHUP, &action, NULL);
2418
2419 #ifdef SIGINFO
2420   /* Catch SIGINFO and, if we get it and we're capturing to a file in
2421      quiet mode, report the number of packets we've captured.
2422
2423      Again, restart any read that was in progress, so that it doesn't
2424      disrupt reading from the sync pipe. */
2425   action.sa_handler = report_counts_siginfo;
2426   action.sa_flags = SA_RESTART;
2427   sigemptyset(&action.sa_mask);
2428   sigaction(SIGINFO, &action, NULL);
2429 #endif /* SIGINFO */
2430 #endif /* _WIN32 */
2431
2432   global_capture_session.state = CAPTURE_PREPARING;
2433
2434   /* Let the user know which interfaces were chosen. */
2435   for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2436     interface_options *interface_opts;
2437
2438     interface_opts = &g_array_index(global_capture_opts.ifaces, interface_options, i);
2439     interface_opts->descr = get_interface_descriptive_name(interface_opts->name);
2440   }
2441   str = get_iface_list_string(&global_capture_opts, IFLIST_QUOTE_IF_DESCRIPTION);
2442   if (really_quiet == FALSE)
2443     fprintf(stderr, "Capturing on %s\n", str->str);
2444   fflush(stderr);
2445   g_string_free(str, TRUE);
2446
2447   ret = sync_pipe_start(&global_capture_opts, &global_capture_session, &global_info_data, NULL);
2448
2449   if (!ret)
2450     return FALSE;
2451
2452   /* the actual capture loop
2453    *
2454    * XXX - glib doesn't seem to provide any event based loop handling.
2455    *
2456    * XXX - for whatever reason,
2457    * calling g_main_loop_new() ends up in 100% cpu load.
2458    *
2459    * But that doesn't matter: in UNIX we can use select() to find an input
2460    * source with something to do.
2461    *
2462    * But that doesn't matter because we're in a CLI (that doesn't need to
2463    * update a GUI or something at the same time) so it's OK if we block
2464    * trying to read from the pipe.
2465    *
2466    * So all the stuff in USE_TSHARK_SELECT could be removed unless I'm
2467    * wrong (but I leave it there in case I am...).
2468    */
2469
2470 #ifdef USE_TSHARK_SELECT
2471   FD_ZERO(&readfds);
2472   FD_SET(pipe_input.source, &readfds);
2473 #endif
2474
2475   loop_running = TRUE;
2476
2477   TRY
2478   {
2479     while (loop_running)
2480     {
2481 #ifdef USE_TSHARK_SELECT
2482       ret = select(pipe_input.source+1, &readfds, NULL, NULL, NULL);
2483
2484       if (ret == -1)
2485       {
2486         fprintf(stderr, "%s: %s\n", "select()", g_strerror(errno));
2487         return TRUE;
2488       } else if (ret == 1) {
2489 #endif
2490         /* Call the real handler */
2491         if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
2492           g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
2493           return FALSE;
2494         }
2495 #ifdef USE_TSHARK_SELECT
2496       }
2497 #endif
2498     }
2499   }
2500   CATCH(OutOfMemoryError) {
2501     fprintf(stderr,
2502             "Out Of Memory.\n"
2503             "\n"
2504             "Sorry, but TShark has to terminate now.\n"
2505             "\n"
2506             "More information and workarounds can be found at\n"
2507             "https://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2508     exit(1);
2509   }
2510   ENDTRY;
2511   return TRUE;
2512 }
2513
2514 /* capture child detected an error */
2515 void
2516 capture_input_error_message(capture_session *cap_session _U_, char *error_msg, char *secondary_error_msg)
2517 {
2518   cmdarg_err("%s", error_msg);
2519   cmdarg_err_cont("%s", secondary_error_msg);
2520 }
2521
2522
2523 /* capture child detected an capture filter related error */
2524 void
2525 capture_input_cfilter_error_message(capture_session *cap_session, guint i, char *error_message)
2526 {
2527   capture_options *capture_opts = cap_session->capture_opts;
2528   dfilter_t         *rfcode = NULL;
2529   interface_options *interface_opts;
2530
2531   g_assert(i < capture_opts->ifaces->len);
2532   interface_opts = &g_array_index(capture_opts->ifaces, interface_options, i);
2533
2534   if (dfilter_compile(interface_opts->cfilter, &rfcode, NULL) && rfcode != NULL) {
2535     cmdarg_err(
2536       "Invalid capture filter \"%s\" for interface '%s'.\n"
2537       "\n"
2538       "That string looks like a valid display filter; however, it isn't a valid\n"
2539       "capture filter (%s).\n"
2540       "\n"
2541       "Note that display filters and capture filters don't have the same syntax,\n"
2542       "so you can't use most display filter expressions as capture filters.\n"
2543       "\n"
2544       "See the User's Guide for a description of the capture filter syntax.",
2545       interface_opts->cfilter, interface_opts->descr, error_message);
2546     dfilter_free(rfcode);
2547   } else {
2548     cmdarg_err(
2549       "Invalid capture filter \"%s\" for interface '%s'.\n"
2550       "\n"
2551       "That string isn't a valid capture filter (%s).\n"
2552       "See the User's Guide for a description of the capture filter syntax.",
2553       interface_opts->cfilter, interface_opts->descr, error_message);
2554   }
2555 }
2556
2557
2558 /* capture child tells us we have a new (or the first) capture file */
2559 gboolean
2560 capture_input_new_file(capture_session *cap_session, gchar *new_file)
2561 {
2562   capture_options *capture_opts = cap_session->capture_opts;
2563   capture_file *cf = (capture_file *) cap_session->cf;
2564   gboolean is_tempfile;
2565   int      err;
2566
2567   if (cap_session->state == CAPTURE_PREPARING) {
2568     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started.");
2569   }
2570   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
2571
2572   g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
2573
2574   /* free the old filename */
2575   if (capture_opts->save_file != NULL) {
2576
2577     /* we start a new capture file, close the old one (if we had one before) */
2578     if (cf->state != FILE_CLOSED) {
2579       if (cf->provider.wth != NULL) {
2580         wtap_close(cf->provider.wth);
2581         cf->provider.wth = NULL;
2582       }
2583       cf->state = FILE_CLOSED;
2584     }
2585
2586     g_free(capture_opts->save_file);
2587     is_tempfile = FALSE;
2588
2589     epan_free(cf->epan);
2590     cf->epan = tshark_epan_new(cf);
2591   } else {
2592     /* we didn't had a save_file before, must be a tempfile */
2593     is_tempfile = TRUE;
2594   }
2595
2596   /* save the new filename */
2597   capture_opts->save_file = g_strdup(new_file);
2598
2599   /* if we are in real-time mode, open the new file now */
2600   if (do_dissection) {
2601     /* this is probably unecessary, but better safe than sorry */
2602     ((capture_file *)cap_session->cf)->open_type = WTAP_TYPE_AUTO;
2603     /* Attempt to open the capture file and set up to read from it. */
2604     switch(cf_open((capture_file *)cap_session->cf, capture_opts->save_file, WTAP_TYPE_AUTO, is_tempfile, &err)) {
2605     case CF_OK:
2606       break;
2607     case CF_ERROR:
2608       /* Don't unlink (delete) the save file - leave it around,
2609          for debugging purposes. */
2610       g_free(capture_opts->save_file);
2611       capture_opts->save_file = NULL;
2612       return FALSE;
2613     }
2614   }
2615
2616   cap_session->state = CAPTURE_RUNNING;
2617
2618   return TRUE;
2619 }
2620
2621
2622 /* capture child tells us we have new packets to read */
2623 void
2624 capture_input_new_packets(capture_session *cap_session, int to_read)
2625 {
2626   gboolean      ret;
2627   int           err;
2628   gchar        *err_info;
2629   gint64        data_offset;
2630   capture_file *cf = (capture_file *)cap_session->cf;
2631   gboolean      filtering_tap_listeners;
2632   guint         tap_flags;
2633
2634 #ifdef SIGINFO
2635   /*
2636    * Prevent a SIGINFO handler from writing to the standard error while
2637    * we're doing so or writing to the standard output; instead, have it
2638    * just set a flag telling us to print that information when we're done.
2639    */
2640   infodelay = TRUE;
2641 #endif /* SIGINFO */
2642
2643   /* Do we have any tap listeners with filters? */
2644   filtering_tap_listeners = have_filtering_tap_listeners();
2645
2646   /* Get the union of the flags for all tap listeners. */
2647   tap_flags = union_of_tap_listener_flags();
2648
2649   if (do_dissection) {
2650     gboolean create_proto_tree;
2651     epan_dissect_t *edt;
2652
2653     /*
2654      * Determine whether we need to create a protocol tree.
2655      * We do if:
2656      *
2657      *    we're going to apply a read filter;
2658      *
2659      *    we're going to apply a display filter;
2660      *
2661      *    we're going to print the protocol tree;
2662      *
2663      *    one of the tap listeners is going to apply a filter;
2664      *
2665      *    one of the tap listeners requires a protocol tree;
2666      *
2667      *    a postdissector wants field values or protocols
2668      *    on the first pass;
2669      *
2670      *    we have custom columns (which require field values, which
2671      *    currently requires that we build a protocol tree).
2672      */
2673     create_proto_tree =
2674       (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
2675         (tap_flags & TL_REQUIRES_PROTO_TREE) || postdissectors_want_hfids() ||
2676         have_custom_cols(&cf->cinfo) || dissect_color);
2677
2678     /* The protocol tree will be "visible", i.e., printed, only if we're
2679        printing packet details, which is true if we're printing stuff
2680        ("print_packet_info" is true) and we're in verbose mode
2681        ("packet_details" is true). */
2682     edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
2683
2684     while (to_read-- && cf->provider.wth) {
2685       wtap_cleareof(cf->provider.wth);
2686       ret = wtap_read(cf->provider.wth, &err, &err_info, &data_offset);
2687       reset_epan_mem(cf, edt, create_proto_tree, print_packet_info && print_details);
2688       if (ret == FALSE) {
2689         /* read from file failed, tell the capture child to stop */
2690         sync_pipe_stop(cap_session);
2691         wtap_close(cf->provider.wth);
2692         cf->provider.wth = NULL;
2693       } else {
2694         ret = process_packet_single_pass(cf, edt, data_offset,
2695                                          wtap_phdr(cf->provider.wth),
2696                                          wtap_buf_ptr(cf->provider.wth), tap_flags);
2697       }
2698       if (ret != FALSE) {
2699         /* packet successfully read and gone through the "Read Filter" */
2700         packet_count++;
2701       }
2702     }
2703
2704     epan_dissect_free(edt);
2705
2706   } else {
2707     /*
2708      * Dumpcap's doing all the work; we're not doing any dissection.
2709      * Count all the packets it wrote.
2710      */
2711     packet_count += to_read;
2712   }
2713
2714   if (print_packet_counts) {
2715       /* We're printing packet counts. */
2716       if (packet_count != 0) {
2717         fprintf(stderr, "\r%u ", packet_count);
2718         /* stderr could be line buffered */
2719         fflush(stderr);
2720       }
2721   }
2722
2723 #ifdef SIGINFO
2724   /*
2725    * Allow SIGINFO handlers to write.
2726    */
2727   infodelay = FALSE;
2728
2729   /*
2730    * If a SIGINFO handler asked us to write out capture counts, do so.
2731    */
2732   if (infoprint)
2733     report_counts();
2734 #endif /* SIGINFO */
2735 }
2736
2737 static void
2738 report_counts(void)
2739 {
2740   if ((print_packet_counts == FALSE) && (really_quiet == FALSE)) {
2741     /* Report the count only if we aren't printing a packet count
2742        as packets arrive. */
2743       fprintf(stderr, "%u packet%s captured\n", packet_count,
2744             plurality(packet_count, "", "s"));
2745   }
2746 #ifdef SIGINFO
2747   infoprint = FALSE; /* we just reported it */
2748 #endif /* SIGINFO */
2749 }
2750
2751 #ifdef SIGINFO
2752 static void
2753 report_counts_siginfo(int signum _U_)
2754 {
2755   int sav_errno = errno;
2756   /* If we've been told to delay printing, just set a flag asking
2757      that we print counts (if we're supposed to), otherwise print
2758      the count of packets captured (if we're supposed to). */
2759   if (infodelay)
2760     infoprint = TRUE;
2761   else
2762     report_counts();
2763   errno = sav_errno;
2764 }
2765 #endif /* SIGINFO */
2766
2767
2768 /* capture child detected any packet drops? */
2769 void
2770 capture_input_drops(capture_session *cap_session _U_, guint32 dropped)
2771 {
2772   if (print_packet_counts) {
2773     /* We're printing packet counts to stderr.
2774        Send a newline so that we move to the line after the packet count. */
2775     fprintf(stderr, "\n");
2776   }
2777
2778   if (dropped != 0) {
2779     /* We're printing packet counts to stderr.
2780        Send a newline so that we move to the line after the packet count. */
2781     fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2782   }
2783 }
2784
2785
2786 /*
2787  * Capture child closed its side of the pipe, report any error and
2788  * do the required cleanup.
2789  */
2790 void
2791 capture_input_closed(capture_session *cap_session, gchar *msg)
2792 {
2793   capture_file *cf = (capture_file *) cap_session->cf;
2794
2795   if (msg != NULL)
2796     fprintf(stderr, "tshark: %s\n", msg);
2797
2798   report_counts();
2799
2800   if (cf != NULL && cf->provider.wth != NULL) {
2801     wtap_close(cf->provider.wth);
2802     if (cf->is_tempfile) {
2803       ws_unlink(cf->filename);
2804     }
2805   }
2806 #ifdef USE_BROKEN_G_MAIN_LOOP
2807   /*g_main_loop_quit(loop);*/
2808   g_main_loop_quit(loop);
2809 #else
2810   loop_running = FALSE;
2811 #endif
2812 }
2813
2814
2815
2816
2817 #ifdef _WIN32
2818 static BOOL WINAPI
2819 capture_cleanup(DWORD ctrltype _U_)
2820 {
2821   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2822      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2823      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2824      like SIGTERM at least when the machine's shutting down.
2825
2826      For now, we handle them all as indications that we should clean up
2827      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2828      way on UNIX.
2829
2830      We must return TRUE so that no other handler - such as one that would
2831      terminate the process - gets called.
2832
2833      XXX - for some reason, typing ^C to TShark, if you run this in
2834      a Cygwin console window in at least some versions of Cygwin,
2835      causes TShark to terminate immediately; this routine gets
2836      called, but the main loop doesn't get a chance to run and
2837      exit cleanly, at least if this is compiled with Microsoft Visual
2838      C++ (i.e., it's a property of the Cygwin console window or Bash;
2839      it happens if TShark is not built with Cygwin - for all I know,
2840      building it with Cygwin may make the problem go away). */
2841
2842   /* tell the capture child to stop */
2843   sync_pipe_stop(&global_capture_session);
2844
2845   /* don't stop our own loop already here, otherwise status messages and
2846    * cleanup wouldn't be done properly. The child will indicate the stop of
2847    * everything by calling capture_input_closed() later */
2848
2849   return TRUE;
2850 }
2851 #else
2852 static void
2853 capture_cleanup(int signum _U_)
2854 {
2855   /* tell the capture child to stop */
2856   sync_pipe_stop(&global_capture_session);
2857
2858   /* don't stop our own loop already here, otherwise status messages and
2859    * cleanup wouldn't be done properly. The child will indicate the stop of
2860    * everything by calling capture_input_closed() later */
2861 }
2862 #endif /* _WIN32 */
2863 #endif /* HAVE_LIBPCAP */
2864
2865 static gboolean
2866 process_packet_first_pass(capture_file *cf, epan_dissect_t *edt,
2867                           gint64 offset, struct wtap_pkthdr *whdr,
2868                           const guchar *pd)
2869 {
2870   frame_data     fdlocal;
2871   guint32        framenum;
2872   gboolean       passed;
2873
2874   /* The frame number of this packet is one more than the count of
2875      frames in this packet. */
2876   framenum = cf->count + 1;
2877
2878   /* If we're not running a display filter and we're not printing any
2879      packet information, we don't need to do a dissection. This means
2880      that all packets can be marked as 'passed'. */
2881   passed = TRUE;
2882
2883   frame_data_init(&fdlocal, framenum, whdr, offset, cum_bytes);
2884
2885   /* If we're going to run a read filter or a display filter, set up to
2886      do a dissection and do so.  (This is the first pass of two passes
2887      over the packets, so we will not be printing any information
2888      from the dissection or running taps on the packet; if we're doing
2889      any of that, we'll do it in the second pass.) */
2890   if (edt) {
2891     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2892         gbl_resolv_flags.transport_name)
2893       /* Grab any resolved addresses */
2894       host_name_lookup_process();
2895
2896     /* If we're running a read filter, prime the epan_dissect_t with that
2897        filter. */
2898     if (cf->rfcode)
2899       epan_dissect_prime_with_dfilter(edt, cf->rfcode);
2900
2901     if (cf->dfcode)
2902       epan_dissect_prime_with_dfilter(edt, cf->dfcode);
2903
2904     /* This is the first pass, so prime the epan_dissect_t with the
2905        hfids postdissectors want on the first pass. */
2906     prime_epan_dissect_with_postdissector_wanted_hfids(edt);
2907
2908     frame_data_set_before_dissect(&fdlocal, &cf->elapsed_time,
2909                                   &cf->provider.ref, cf->provider.prev_dis);
2910     if (cf->provider.ref == &fdlocal) {
2911       ref_frame = fdlocal;
2912       cf->provider.ref = &ref_frame;
2913     }
2914
2915     epan_dissect_run(edt, cf->cd_t, whdr, frame_tvbuff_new(&fdlocal, pd), &fdlocal, NULL);
2916
2917     /* Run the read filter if we have one. */
2918     if (cf->rfcode)
2919       passed = dfilter_apply_edt(cf->rfcode, edt);
2920   }
2921
2922   if (passed) {
2923     frame_data_set_after_dissect(&fdlocal, &cum_bytes);
2924     cf->provider.prev_cap = cf->provider.prev_dis = frame_data_sequence_add(cf->provider.frames, &fdlocal);
2925
2926     /* If we're not doing dissection then there won't be any dependent frames.
2927      * More importantly, edt.pi.dependent_frames won't be initialized because
2928      * epan hasn't been initialized.
2929      * if we *are* doing dissection, then mark the dependent frames, but only
2930      * if a display filter was given and it matches this packet.
2931      */
2932     if (edt && cf->dfcode) {
2933       if (dfilter_apply_edt(cf->dfcode, edt)) {
2934         g_slist_foreach(edt->pi.dependent_frames, find_and_mark_frame_depended_upon, cf->provider.frames);
2935       }
2936     }
2937
2938     cf->count++;
2939   } else {
2940     /* if we don't add it to the frame_data_sequence, clean it up right now
2941      * to avoid leaks */
2942     frame_data_destroy(&fdlocal);
2943   }
2944
2945   if (edt)
2946     epan_dissect_reset(edt);
2947
2948   return passed;
2949 }
2950
2951 static gboolean
2952 process_packet_second_pass(capture_file *cf, epan_dissect_t *edt,
2953                            frame_data *fdata, struct wtap_pkthdr *phdr,
2954                            Buffer *buf, guint tap_flags)
2955 {
2956   column_info    *cinfo;
2957   gboolean        passed;
2958
2959   /* If we're not running a display filter and we're not printing any
2960      packet information, we don't need to do a dissection. This means
2961      that all packets can be marked as 'passed'. */
2962   passed = TRUE;
2963
2964   /* If we're going to print packet information, or we're going to
2965      run a read filter, or we're going to process taps, set up to
2966      do a dissection and do so.  (This is the second pass of two
2967      passes over the packets; that's the pass where we print
2968      packet information or run taps.) */
2969   if (edt) {
2970     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2971         gbl_resolv_flags.transport_name)
2972       /* Grab any resolved addresses */
2973       host_name_lookup_process();
2974
2975     /* If we're running a display filter, prime the epan_dissect_t with that
2976        filter. */
2977     if (cf->dfcode)
2978       epan_dissect_prime_with_dfilter(edt, cf->dfcode);
2979
2980     col_custom_prime_edt(edt, &cf->cinfo);
2981
2982     /* We only need the columns if either
2983          1) some tap needs the columns
2984        or
2985          2) we're printing packet info but we're *not* verbose; in verbose
2986             mode, we print the protocol tree, not the protocol summary.
2987      */
2988     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
2989       cinfo = &cf->cinfo;
2990     else
2991       cinfo = NULL;
2992
2993     frame_data_set_before_dissect(fdata, &cf->elapsed_time,
2994                                   &cf->provider.ref, cf->provider.prev_dis);
2995     if (cf->provider.ref == fdata) {
2996       ref_frame = *fdata;
2997       cf->provider.ref = &ref_frame;
2998     }
2999
3000     if (dissect_color) {
3001       color_filters_prime_edt(edt);
3002       fdata->flags.need_colorize = 1;
3003     }
3004
3005     epan_dissect_run_with_taps(edt, cf->cd_t, phdr, frame_tvbuff_new_buffer(fdata, buf), fdata, cinfo);
3006
3007     /* Run the read/display filter if we have one. */
3008     if (cf->dfcode)
3009       passed = dfilter_apply_edt(cf->dfcode, edt);
3010   }
3011
3012   if (passed) {
3013     frame_data_set_after_dissect(fdata, &cum_bytes);
3014     /* Process this packet. */
3015     if (print_packet_info) {
3016       /* We're printing packet information; print the information for
3017          this packet. */
3018       print_packet(cf, edt);
3019
3020       /* If we're doing "line-buffering", flush the standard output
3021          after every packet.  See the comment above, for the "-l"
3022          option, for an explanation of why we do that. */
3023       if (line_buffered)
3024         fflush(stdout);
3025
3026       if (ferror(stdout)) {
3027         show_print_file_io_error(errno);
3028         exit(2);
3029       }
3030     }
3031     cf->provider.prev_dis = fdata;
3032   }
3033   cf->provider.prev_cap = fdata;
3034
3035   if (edt) {
3036     epan_dissect_reset(edt);
3037   }
3038   return passed || fdata->flags.dependent_of_displayed;
3039 }
3040
3041 static gboolean
3042 process_cap_file(capture_file *cf, char *save_file, int out_file_type,
3043     gboolean out_file_name_res, int max_packet_count, gint64 max_byte_count)
3044 {
3045   gboolean     success = TRUE;
3046   gint         linktype;
3047   int          snapshot_length;
3048   wtap_dumper *pdh;
3049   guint32      framenum;
3050   int          err = 0, err_pass1 = 0;
3051   gchar       *err_info = NULL, *err_info_pass1 = NULL;
3052   gint64       data_offset;
3053   gboolean     filtering_tap_listeners;
3054   guint        tap_flags;
3055   GArray                      *shb_hdrs = NULL;
3056   wtapng_iface_descriptions_t *idb_inf = NULL;
3057   GArray                      *nrb_hdrs = NULL;
3058   struct wtap_pkthdr phdr;
3059   Buffer       buf;
3060   epan_dissect_t *edt = NULL;
3061   char                        *shb_user_appl;
3062
3063   wtap_phdr_init(&phdr);
3064
3065   idb_inf = wtap_file_get_idb_info(cf->provider.wth);
3066 #ifdef PCAP_NG_DEFAULT
3067   if (idb_inf->interface_data->len > 1) {
3068     linktype = WTAP_ENCAP_PER_PACKET;
3069   } else {
3070     linktype = wtap_file_encap(cf->provider.wth);
3071   }
3072 #else
3073   linktype = wtap_file_encap(cf->provider.wth);
3074 #endif
3075   if (save_file != NULL) {
3076     /* Set up to write to the capture file. */
3077     snapshot_length = wtap_snapshot_length(cf->provider.wth);
3078     if (snapshot_length == 0) {
3079       /* Snapshot length of input file not known. */
3080       snapshot_length = WTAP_MAX_PACKET_SIZE_STANDARD;
3081     }
3082     tshark_debug("tshark: snapshot_length = %d", snapshot_length);
3083
3084     shb_hdrs = wtap_file_get_shb_for_new_file(cf->provider.wth);
3085     nrb_hdrs = wtap_file_get_nrb_for_new_file(cf->provider.wth);
3086
3087     /* If we don't have an application name add Tshark */
3088     if (wtap_block_get_string_option_value(g_array_index(shb_hdrs, wtap_block_t, 0), OPT_SHB_USERAPPL, &shb_user_appl) != WTAP_OPTTYPE_SUCCESS) {
3089         /* this is free'd by wtap_block_free() later */
3090         wtap_block_add_string_option_format(g_array_index(shb_hdrs, wtap_block_t, 0), OPT_SHB_USERAPPL, "TShark (Wireshark) %s", get_ws_vcs_version_info());
3091     }
3092
3093     if (linktype != WTAP_ENCAP_PER_PACKET &&
3094         out_file_type == WTAP_FILE_TYPE_SUBTYPE_PCAP) {
3095         tshark_debug("tshark: writing PCAP format to %s", save_file);
3096         if (strcmp(save_file, "-") == 0) {
3097           /* Write to the standard output. */
3098           pdh = wtap_dump_open_stdout(out_file_type, linktype,
3099               snapshot_length, FALSE /* compressed */, &err);
3100         } else {
3101           pdh = wtap_dump_open(save_file, out_file_type, linktype,
3102               snapshot_length, FALSE /* compressed */, &err);
3103         }
3104     }
3105     else {
3106         tshark_debug("tshark: writing format type %d, to %s", out_file_type, save_file);
3107         if (strcmp(save_file, "-") == 0) {
3108           /* Write to the standard output. */
3109           pdh = wtap_dump_open_stdout_ng(out_file_type, linktype,
3110               snapshot_length, FALSE /* compressed */, shb_hdrs, idb_inf, nrb_hdrs, &err);
3111         } else {
3112           pdh = wtap_dump_open_ng(save_file, out_file_type, linktype,
3113               snapshot_length, FALSE /* compressed */, shb_hdrs, idb_inf, nrb_hdrs, &err);
3114         }
3115     }
3116
3117     g_free(idb_inf);
3118     idb_inf = NULL;
3119
3120     if (pdh == NULL) {
3121       /* We couldn't set up to write to the capture file. */
3122       cfile_dump_open_failure_message("TShark", save_file, err, out_file_type);
3123       success = FALSE;
3124       goto out;
3125     }
3126   } else {
3127     /* Set up to print packet information. */
3128     if (print_packet_info) {
3129       if (!write_preamble(cf)) {
3130         show_print_file_io_error(errno);
3131         success = FALSE;
3132         goto out;
3133       }
3134     }
3135     g_free(idb_inf);
3136     idb_inf = NULL;
3137     pdh = NULL;
3138   }
3139
3140   /* Do we have any tap listeners with filters? */
3141   filtering_tap_listeners = have_filtering_tap_listeners();
3142
3143   /* Get the union of the flags for all tap listeners. */
3144   tap_flags = union_of_tap_listener_flags();
3145
3146   if (perform_two_pass_analysis) {
3147     frame_data *fdata;
3148
3149     tshark_debug("tshark: perform_two_pass_analysis, do_dissection=%s", do_dissection ? "TRUE" : "FALSE");
3150
3151     /* Allocate a frame_data_sequence for all the frames. */
3152     cf->provider.frames = new_frame_data_sequence();
3153
3154     if (do_dissection) {
3155       gboolean create_proto_tree;
3156
3157       /*
3158        * Determine whether we need to create a protocol tree.
3159        * We do if:
3160        *
3161        *    we're going to apply a read filter;
3162        *
3163        *    we're going to apply a display filter;
3164        *
3165        *    a postdissector wants field values or protocols
3166        *    on the first pass.
3167        */
3168       create_proto_tree =
3169         (cf->rfcode != NULL || cf->dfcode != NULL || postdissectors_want_hfids() || dissect_color);
3170
3171       tshark_debug("tshark: create_proto_tree = %s", create_proto_tree ? "TRUE" : "FALSE");
3172
3173       /* We're not going to display the protocol tree on this pass,
3174          so it's not going to be "visible". */
3175       edt = epan_dissect_new(cf->epan, create_proto_tree, FALSE);
3176     }
3177
3178     tshark_debug("tshark: reading records for first pass");
3179     while (wtap_read(cf->provider.wth, &err, &err_info, &data_offset)) {
3180       if (process_packet_first_pass(cf, edt, data_offset, wtap_phdr(cf->provider.wth),
3181                                     wtap_buf_ptr(cf->provider.wth))) {
3182         /* Stop reading if we have the maximum number of packets;
3183          * When the -c option has not been used, max_packet_count
3184          * starts at 0, which practically means, never stop reading.
3185          * (unless we roll over max_packet_count ?)
3186          */
3187         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3188           tshark_debug("tshark: max_packet_count (%d) or max_byte_count (%" G_GINT64_MODIFIER "d/%" G_GINT64_MODIFIER "d) reached",
3189                         max_packet_count, data_offset, max_byte_count);
3190           err = 0; /* This is not an error */
3191           break;
3192         }
3193       }
3194     }
3195
3196     /*
3197      * If we got a read error on the first pass, remember the error, so
3198      * but do the second pass, so we can at least process the packets we
3199      * read, and then report the first-pass error after the second pass
3200      * (and before we report any second-pass errors), so all the the
3201      * errors show up at the end.
3202      */
3203     if (err != 0) {
3204       err_pass1 = err;
3205       err_info_pass1 = err_info;
3206       err = 0;
3207       err_info = NULL;
3208     }
3209
3210     if (edt) {
3211       epan_dissect_free(edt);
3212       edt = NULL;
3213     }
3214
3215     /* Close the sequential I/O side, to free up memory it requires. */
3216     wtap_sequential_close(cf->provider.wth);
3217
3218     /* Allow the protocol dissectors to free up memory that they
3219      * don't need after the sequential run-through of the packets. */
3220     postseq_cleanup_all_protocols();
3221
3222     cf->provider.prev_dis = NULL;
3223     cf->provider.prev_cap = NULL;
3224     ws_buffer_init(&buf, 1500);
3225
3226     tshark_debug("tshark: done with first pass");
3227
3228     if (do_dissection) {
3229       gboolean create_proto_tree;
3230
3231       /*
3232        * Determine whether we need to create a protocol tree.
3233        * We do if:
3234        *
3235        *    we're going to apply a display filter;
3236        *
3237        *    we're going to print the protocol tree;
3238        *
3239        *    one of the tap listeners requires a protocol tree;
3240        *
3241        *    we have custom columns (which require field values, which
3242        *    currently requires that we build a protocol tree).
3243        */
3244       create_proto_tree =
3245         (cf->dfcode || print_details || filtering_tap_listeners ||
3246          (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo) || dissect_color);
3247
3248       tshark_debug("tshark: create_proto_tree = %s", create_proto_tree ? "TRUE" : "FALSE");
3249
3250       /* The protocol tree will be "visible", i.e., printed, only if we're
3251          printing packet details, which is true if we're printing stuff
3252          ("print_packet_info" is true) and we're in verbose mode
3253          ("packet_details" is true). */
3254       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
3255     }
3256
3257     for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
3258       fdata = frame_data_sequence_find(cf->provider.frames, framenum);
3259       if (wtap_seek_read(cf->provider.wth, fdata->file_off, &phdr, &buf, &err,
3260                          &err_info)) {
3261         tshark_debug("tshark: invoking process_packet_second_pass() for frame #%d", framenum);
3262         if (process_packet_second_pass(cf, edt, fdata, &phdr, &buf,
3263                                        tap_flags)) {
3264           /* Either there's no read filtering or this packet passed the
3265              filter, so, if we're writing to a capture file, write
3266              this packet out. */
3267           if (pdh != NULL) {
3268             tshark_debug("tshark: writing packet #%d to outfile", framenum);
3269             if (!wtap_dump(pdh, &phdr, ws_buffer_start_ptr(&buf), &err, &err_info)) {
3270               /* Error writing to a capture file */
3271               tshark_debug("tshark: error writing to a capture file (%d)", err);
3272
3273               /* Report the error.
3274                  XXX - framenum is not necessarily the frame number in
3275                  the input file if there was a read filter. */
3276               cfile_write_failure_message("TShark", cf->filename, save_file,
3277                                           err, err_info, framenum,
3278                                           out_file_type);
3279               wtap_dump_close(pdh, &err);
3280               wtap_block_array_free(shb_hdrs);
3281               wtap_block_array_free(nrb_hdrs);
3282               exit(2);
3283             }
3284           }
3285         }
3286       }
3287     }
3288
3289     if (edt) {
3290       epan_dissect_free(edt);
3291       edt = NULL;
3292     }
3293
3294     ws_buffer_free(&buf);
3295
3296     tshark_debug("tshark: done with second pass");
3297   }
3298   else {
3299     /* !perform_two_pass_analysis */
3300     framenum = 0;
3301     gboolean create_proto_tree = FALSE;
3302     tshark_debug("tshark: perform one pass analysis, do_dissection=%s", do_dissection ? "TRUE" : "FALSE");
3303
3304     if (do_dissection) {
3305       /*
3306        * Determine whether we need to create a protocol tree.
3307        * We do if:
3308        *
3309        *    we're going to apply a read filter;
3310        *
3311        *    we're going to apply a display filter;
3312        *
3313        *    we're going to print the protocol tree;
3314        *
3315        *    one of the tap listeners is going to apply a filter;
3316        *
3317        *    one of the tap listeners requires a protocol tree;
3318        *
3319        *    a postdissector wants field values or protocols
3320        *    on the first pass;
3321        *
3322        *    we have custom columns (which require field values, which
3323        *    currently requires that we build a protocol tree).
3324        */
3325       create_proto_tree =
3326         (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
3327           (tap_flags & TL_REQUIRES_PROTO_TREE) || postdissectors_want_hfids() ||
3328           have_custom_cols(&cf->cinfo) || dissect_color);
3329
3330       tshark_debug("tshark: create_proto_tree = %s", create_proto_tree ? "TRUE" : "FALSE");
3331
3332       /* The protocol tree will be "visible", i.e., printed, only if we're
3333          printing packet details, which is true if we're printing stuff
3334          ("print_packet_info" is true) and we're in verbose mode
3335          ("packet_details" is true). */
3336       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
3337     }
3338
3339     while (wtap_read(cf->provider.wth, &err, &err_info, &data_offset)) {
3340       framenum++;
3341
3342       tshark_debug("tshark: processing packet #%d", framenum);
3343
3344       reset_epan_mem(cf, edt, create_proto_tree, print_packet_info && print_details);
3345
3346       if (process_packet_single_pass(cf, edt, data_offset, wtap_phdr(cf->provider.wth),
3347                                      wtap_buf_ptr(cf->provider.wth), tap_flags)) {
3348         /* Either there's no read filtering or this packet passed the
3349            filter, so, if we're writing to a capture file, write
3350            this packet out. */
3351         if (pdh != NULL) {
3352           tshark_debug("tshark: writing packet #%d to outfile", framenum);
3353           if (!wtap_dump(pdh, wtap_phdr(cf->provider.wth), wtap_buf_ptr(cf->provider.wth), &err, &err_info)) {
3354             /* Error writing to a capture file */
3355             tshark_debug("tshark: error writing to a capture file (%d)", err);
3356             cfile_write_failure_message("TShark", cf->filename, save_file,
3357                                         err, err_info, framenum, out_file_type);
3358             wtap_dump_close(pdh, &err);
3359             wtap_block_array_free(shb_hdrs);
3360             wtap_block_array_free(nrb_hdrs);
3361             exit(2);
3362           }
3363         }
3364       }
3365       /* Stop reading if we have the maximum number of packets;
3366        * When the -c option has not been used, max_packet_count
3367        * starts at 0, which practically means, never stop reading.
3368        * (unless we roll over max_packet_count ?)
3369        */
3370       if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3371         tshark_debug("tshark: max_packet_count (%d) or max_byte_count (%" G_GINT64_MODIFIER "d/%" G_GINT64_MODIFIER "d) reached",
3372                       max_packet_count, data_offset, max_byte_count);
3373         err = 0; /* This is not an error */
3374         break;
3375       }
3376     }
3377
3378     if (edt) {
3379       epan_dissect_free(edt);
3380       edt = NULL;
3381     }
3382   }
3383
3384   wtap_phdr_cleanup(&phdr);
3385
3386   if (err != 0 || err_pass1 != 0) {
3387     tshark_debug("tshark: something failed along the line (%d)", err);
3388     /*
3389      * Print a message noting that the read failed somewhere along the line.
3390      *
3391      * If we're printing packet data, and the standard output and error are
3392      * going to the same place, flush the standard output, so everything
3393      * buffered up is written, and then print a newline to the standard error
3394      * before printing the error message, to separate it from the packet
3395      * data.  (Alas, that only works on UN*X; st_dev is meaningless, and
3396      * the _fstat() documentation at Microsoft doesn't indicate whether
3397      * st_ino is even supported.)
3398      */
3399 #ifndef _WIN32
3400     if (print_packet_info) {
3401       ws_statb64 stat_stdout, stat_stderr;
3402
3403       if (ws_fstat64(1, &stat_stdout) == 0 && ws_fstat64(2, &stat_stderr) == 0) {
3404         if (stat_stdout.st_dev == stat_stderr.st_dev &&
3405             stat_stdout.st_ino == stat_stderr.st_ino) {
3406           fflush(stdout);
3407           fprintf(stderr, "\n");
3408         }
3409       }
3410     }
3411 #endif
3412     if (err_pass1 != 0) {
3413       /* Error on pass 1 of two-pass processing. */
3414       cfile_read_failure_message("TShark", cf->filename, err_pass1,
3415                                  err_info_pass1);
3416     }
3417     if (err != 0) {
3418       /* Error on pass 2 of two-pass processing or on the only pass of
3419          one-pass processing. */
3420       cfile_read_failure_message("TShark", cf->filename, err, err_info);
3421     }
3422     success = FALSE;
3423   }
3424   if (save_file != NULL) {
3425     if (pdh && out_file_name_res) {
3426       if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
3427         cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
3428                    wtap_file_type_subtype_short_string(out_file_type));
3429       }
3430     }
3431     /* Now close the capture file. */
3432     if (!wtap_dump_close(pdh, &err)) {
3433       cfile_close_failure_message(save_file, err);
3434       success = FALSE;
3435     }
3436   } else {
3437     if (print_packet_info) {
3438       if (!write_finale()) {
3439         show_print_file_io_error(errno);
3440         success = FALSE;
3441       }
3442     }
3443   }
3444
3445 out:
3446   wtap_close(cf->provider.wth);
3447   cf->provider.wth = NULL;
3448
3449   wtap_block_array_free(shb_hdrs);
3450   wtap_block_array_free(nrb_hdrs);
3451
3452   return success;
3453 }
3454
3455 static gboolean
3456 process_packet_single_pass(capture_file *cf, epan_dissect_t *edt, gint64 offset,
3457                            struct wtap_pkthdr *whdr, const guchar *pd,
3458                            guint tap_flags)
3459 {
3460   frame_data      fdata;
3461   column_info    *cinfo;
3462   gboolean        passed;
3463
3464   /* Count this packet. */
3465   cf->count++;
3466
3467   /* If we're not running a display filter and we're not printing any
3468      packet information, we don't need to do a dissection. This means
3469      that all packets can be marked as 'passed'. */
3470   passed = TRUE;
3471
3472   frame_data_init(&fdata, cf->count, whdr, offset, cum_bytes);
3473
3474   /* If we're going to print packet information, or we're going to
3475      run a read filter, or we're going to process taps, set up to
3476      do a dissection and do so.  (This is the one and only pass
3477      over the packets, so, if we'll be printing packet information
3478      or running taps, we'll be doing it here.) */
3479   if (edt) {
3480     if (print_packet_info && (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
3481         gbl_resolv_flags.transport_name))
3482       /* Grab any resolved addresses */
3483       host_name_lookup_process();
3484
3485     /* If we're running a filter, prime the epan_dissect_t with that
3486        filter. */
3487     if (cf->dfcode)
3488       epan_dissect_prime_with_dfilter(edt, cf->dfcode);
3489
3490     /* This is the first and only pass, so prime the epan_dissect_t
3491        with the hfids postdissectors want on the first pass. */
3492     prime_epan_dissect_with_postdissector_wanted_hfids(edt);
3493
3494     col_custom_prime_edt(edt, &cf->cinfo);
3495
3496     /* We only need the columns if either
3497          1) some tap needs the columns
3498        or
3499          2) we're printing packet info but we're *not* verbose; in verbose
3500             mode, we print the protocol tree, not the protocol summary.
3501        or
3502          3) there is a column mapped as an individual field */
3503     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
3504       cinfo = &cf->cinfo;
3505     else
3506       cinfo = NULL;
3507
3508     frame_data_set_before_dissect(&fdata, &cf->elapsed_time,
3509                                   &cf->provider.ref, cf->provider.prev_dis);
3510     if (cf->provider.ref == &fdata) {
3511       ref_frame = fdata;
3512       cf->provider.ref = &ref_frame;
3513     }
3514
3515     if (dissect_color) {
3516       color_filters_prime_edt(edt);
3517       fdata.flags.need_colorize = 1;
3518     }
3519
3520     epan_dissect_run_with_taps(edt, cf->cd_t, whdr, frame_tvbuff_new(&fdata, pd), &fdata, cinfo);
3521
3522     /* Run the filter if we have it. */
3523     if (cf->dfcode)
3524       passed = dfilter_apply_edt(cf->dfcode, edt);
3525   }
3526
3527   if (passed) {
3528     frame_data_set_after_dissect(&fdata, &cum_bytes);
3529
3530     /* Process this packet. */
3531     if (print_packet_info) {
3532       /* We're printing packet information; print the information for
3533          this packet. */
3534       g_assert(edt);
3535       print_packet(cf, edt);
3536
3537       /* If we're doing "line-buffering", flush the standard output
3538          after every packet.  See the comment above, for the "-l"
3539          option, for an explanation of why we do that. */
3540       if (line_buffered)
3541         fflush(stdout);
3542
3543       if (ferror(stdout)) {
3544         show_print_file_io_error(errno);
3545         exit(2);
3546       }
3547     }
3548
3549     /* this must be set after print_packet() [bug #8160] */
3550     prev_dis_frame = fdata;
3551     cf->provider.prev_dis = &prev_dis_frame;
3552   }
3553
3554   prev_cap_frame = fdata;
3555   cf->provider.prev_cap = &prev_cap_frame;
3556
3557   if (edt) {
3558     epan_dissect_reset(edt);
3559     frame_data_destroy(&fdata);
3560   }
3561   return passed;
3562 }
3563
3564 static gboolean
3565 write_preamble(capture_file *cf)
3566 {
3567   switch (output_action) {
3568
3569   case WRITE_TEXT:
3570     return print_preamble(print_stream, cf->filename, get_ws_vcs_version_info());
3571
3572   case WRITE_XML:
3573     if (print_details)
3574       write_pdml_preamble(stdout, cf->filename);
3575     else
3576       write_psml_preamble(&cf->cinfo, stdout);
3577     return !ferror(stdout);
3578
3579   case WRITE_FIELDS:
3580     write_fields_preamble(output_fields, stdout);
3581     return !ferror(stdout);
3582
3583   case WRITE_JSON:
3584   case WRITE_JSON_RAW:
3585     write_json_preamble(stdout);
3586     return !ferror(stdout);
3587
3588   case WRITE_EK:
3589     return !ferror(stdout);
3590
3591   default:
3592     g_assert_not_reached();
3593     return FALSE;
3594   }
3595 }
3596
3597 static char *
3598 get_line_buf(size_t len)
3599 {
3600   static char   *line_bufp    = NULL;
3601   static size_t  line_buf_len = 256;
3602   size_t         new_line_buf_len;
3603
3604   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
3605        new_line_buf_len *= 2)
3606     ;
3607   if (line_bufp == NULL) {
3608     line_buf_len = new_line_buf_len;
3609     line_bufp = (char *)g_malloc(line_buf_len + 1);
3610   } else {
3611     if (new_line_buf_len > line_buf_len) {
3612       line_buf_len = new_line_buf_len;
3613       line_bufp = (char *)g_realloc(line_bufp, line_buf_len + 1);
3614     }
3615   }
3616   return line_bufp;
3617 }
3618
3619 static inline void
3620 put_string(char *dest, const char *str, size_t str_len)
3621 {
3622   memcpy(dest, str, str_len);
3623   dest[str_len] = '\0';
3624 }
3625
3626 static inline void
3627 put_spaces_string(char *dest, const char *str, size_t str_len, size_t str_with_spaces)
3628 {
3629   size_t i;
3630
3631   for (i = str_len; i < str_with_spaces; i++)
3632     *dest++ = ' ';
3633
3634   put_string(dest, str, str_len);
3635 }
3636
3637 static inline void
3638 put_string_spaces(char *dest, const char *str, size_t str_len, size_t str_with_spaces)
3639 {
3640   size_t i;
3641
3642   memcpy(dest, str, str_len);
3643   for (i = str_len; i < str_with_spaces; i++)
3644     dest[i] = ' ';
3645
3646   dest[str_with_spaces] = '\0';
3647 }
3648
3649 static gboolean
3650 print_columns(capture_file *cf, const epan_dissect_t *edt)
3651 {
3652   char   *line_bufp;
3653   int     i;
3654   size_t  buf_offset;
3655   size_t  column_len;
3656   size_t  col_len;
3657   col_item_t* col_item;
3658   gchar str_format[11];
3659   const color_filter_t *color_filter = NULL;
3660
3661   line_bufp = get_line_buf(256);
3662   buf_offset = 0;
3663   *line_bufp = '\0';
3664
3665   if (dissect_color)
3666     color_filter = edt->pi.fd->color_filter;
3667
3668   for (i = 0; i < cf->cinfo.num_cols; i++) {
3669     col_item = &cf->cinfo.columns[i];
3670     /* Skip columns not marked as visible. */
3671     if (!get_column_visible(i))
3672       continue;
3673     switch (col_item->col_fmt) {
3674     case COL_NUMBER:
3675       column_len = col_len = strlen(col_item->col_data);
3676       if (column_len < 5)
3677         column_len = 5;
3678       line_bufp = get_line_buf(buf_offset + column_len);
3679       put_spaces_string(line_bufp + buf_offset, col_item->col_data, col_len, column_len);
3680       break;
3681
3682     case COL_CLS_TIME:
3683     case COL_REL_TIME:
3684     case COL_ABS_TIME:
3685     case COL_ABS_YMD_TIME:  /* XXX - wider */
3686     case COL_ABS_YDOY_TIME: /* XXX - wider */
3687     case COL_UTC_TIME:
3688     case COL_UTC_YMD_TIME:  /* XXX - wider */
3689     case COL_UTC_YDOY_TIME: /* XXX - wider */
3690       column_len = col_len = strlen(col_item->col_data);
3691       if (column_len < 10)
3692         column_len = 10;
3693       line_bufp = get_line_buf(buf_offset + column_len);
3694       put_spaces_string(line_bufp + buf_offset, col_item->col_data, col_len, column_len);
3695       break;
3696
3697     case COL_DEF_SRC:
3698     case COL_RES_SRC:
3699     case COL_UNRES_SRC:
3700     case COL_DEF_DL_SRC:
3701     case COL_RES_DL_SRC:
3702     case COL_UNRES_DL_SRC:
3703     case COL_DEF_NET_SRC:
3704     case COL_RES_NET_SRC:
3705     case COL_UNRES_NET_SRC:
3706       column_len = col_len = strlen(col_item->col_data);
3707       if (column_len < 12)
3708         column_len = 12;
3709       line_bufp = get_line_buf(buf_offset + column_len);
3710       put_spaces_string(line_bufp + buf_offset, col_item->col_data, col_len, column_len);
3711       break;
3712
3713     case COL_DEF_DST:
3714     case COL_RES_DST:
3715     case COL_UNRES_DST:
3716     case COL_DEF_DL_DST:
3717     case COL_RES_DL_DST:
3718     case COL_UNRES_DL_DST:
3719     case COL_DEF_NET_DST:
3720     case COL_RES_NET_DST:
3721     case COL_UNRES_NET_DST:
3722       column_len = col_len = strlen(col_item->col_data);
3723       if (column_len < 12)
3724         column_len = 12;
3725       line_bufp = get_line_buf(buf_offset + column_len);
3726       put_string_spaces(line_bufp + buf_offset, col_item->col_data, col_len, column_len);
3727       break;
3728
3729     default:
3730       column_len = strlen(col_item->col_data);
3731       line_bufp = get_line_buf(buf_offset + column_len);
3732       put_string(line_bufp + buf_offset, col_item->col_data, column_len);
3733       break;
3734     }
3735     buf_offset += column_len;
3736     if (i != cf->cinfo.num_cols - 1) {
3737       /*
3738        * This isn't the last column, so we need to print a
3739        * separator between this column and the next.
3740        *
3741        * If we printed a network source and are printing a
3742        * network destination of the same type next, separate
3743        * them with a UTF-8 right arrow; if we printed a network
3744        * destination and are printing a network source of the same
3745        * type next, separate them with a UTF-8 left arrow;
3746        * otherwise separate them with a space.
3747        *
3748        * We add enough space to the buffer for " \xe2\x86\x90 "
3749        * or " \xe2\x86\x92 ", even if we're only adding " ".
3750        */
3751       line_bufp = get_line_buf(buf_offset + 5);
3752       switch (col_item->col_fmt) {
3753
3754       case COL_DEF_SRC:
3755       case COL_RES_SRC:
3756       case COL_UNRES_SRC:
3757         switch (cf->cinfo.columns[i+1].col_fmt) {
3758
3759         case COL_DEF_DST:
3760         case COL_RES_DST:
3761         case COL_UNRES_DST:
3762           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_RIGHTWARDS_ARROW, delimiter_char);
3763           put_string(line_bufp + buf_offset, str_format, 5);
3764           buf_offset += 5;
3765           break;
3766
3767         default:
3768           put_string(line_bufp + buf_offset, delimiter_char, 1);
3769           buf_offset += 1;
3770           break;
3771         }
3772         break;
3773
3774       case COL_DEF_DL_SRC:
3775       case COL_RES_DL_SRC:
3776       case COL_UNRES_DL_SRC:
3777         switch (cf->cinfo.columns[i+1].col_fmt) {
3778
3779         case COL_DEF_DL_DST:
3780         case COL_RES_DL_DST:
3781         case COL_UNRES_DL_DST:
3782           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_RIGHTWARDS_ARROW, delimiter_char);
3783           put_string(line_bufp + buf_offset, str_format, 5);
3784           buf_offset += 5;
3785           break;
3786
3787         default:
3788           put_string(line_bufp + buf_offset, delimiter_char, 1);
3789           buf_offset += 1;
3790           break;
3791         }
3792         break;
3793
3794       case COL_DEF_NET_SRC:
3795       case COL_RES_NET_SRC:
3796       case COL_UNRES_NET_SRC:
3797         switch (cf->cinfo.columns[i+1].col_fmt) {
3798
3799         case COL_DEF_NET_DST:
3800         case COL_RES_NET_DST:
3801         case COL_UNRES_NET_DST:
3802           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_RIGHTWARDS_ARROW, delimiter_char);
3803           put_string(line_bufp + buf_offset, str_format, 5);
3804           buf_offset += 5;
3805           break;
3806
3807         default:
3808           put_string(line_bufp + buf_offset, delimiter_char, 1);
3809           buf_offset += 1;
3810           break;
3811         }
3812         break;
3813
3814       case COL_DEF_DST:
3815       case COL_RES_DST:
3816       case COL_UNRES_DST:
3817         switch (cf->cinfo.columns[i+1].col_fmt) {
3818
3819         case COL_DEF_SRC:
3820         case COL_RES_SRC:
3821         case COL_UNRES_SRC:
3822           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_LEFTWARDS_ARROW, delimiter_char);
3823           put_string(line_bufp + buf_offset, str_format, 5);
3824           buf_offset += 5;
3825           break;
3826
3827         default:
3828           put_string(line_bufp + buf_offset, delimiter_char, 1);
3829           buf_offset += 1;
3830           break;
3831         }
3832         break;
3833
3834       case COL_DEF_DL_DST:
3835       case COL_RES_DL_DST:
3836       case COL_UNRES_DL_DST:
3837         switch (cf->cinfo.columns[i+1].col_fmt) {
3838
3839         case COL_DEF_DL_SRC:
3840         case COL_RES_DL_SRC:
3841         case COL_UNRES_DL_SRC:
3842           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_LEFTWARDS_ARROW, delimiter_char);
3843           put_string(line_bufp + buf_offset, str_format, 5);
3844           buf_offset += 5;
3845           break;
3846
3847         default:
3848           put_string(line_bufp + buf_offset, delimiter_char, 1);
3849           buf_offset += 1;
3850           break;
3851         }
3852         break;
3853
3854       case COL_DEF_NET_DST:
3855       case COL_RES_NET_DST:
3856       case COL_UNRES_NET_DST:
3857         switch (cf->cinfo.columns[i+1].col_fmt) {
3858
3859         case COL_DEF_NET_SRC:
3860         case COL_RES_NET_SRC:
3861         case COL_UNRES_NET_SRC:
3862           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_LEFTWARDS_ARROW, delimiter_char);
3863           put_string(line_bufp + buf_offset, str_format, 5);
3864           buf_offset += 5;
3865           break;
3866
3867         default:
3868           put_string(line_bufp + buf_offset, delimiter_char, 1);
3869           buf_offset += 1;
3870           break;
3871         }
3872         break;
3873
3874       default:
3875         put_string(line_bufp + buf_offset, delimiter_char, 1);
3876         buf_offset += 1;
3877         break;
3878       }
3879     }
3880   }
3881
3882   if (dissect_color && color_filter != NULL)
3883     return print_line_color(print_stream, 0, line_bufp, &color_filter->fg_color, &color_filter->bg_color);
3884   else
3885     return print_line(print_stream, 0, line_bufp);
3886 }
3887
3888 static gboolean
3889 print_packet(capture_file *cf, epan_dissect_t *edt)
3890 {
3891   if (print_summary || output_fields_has_cols(output_fields))
3892     /* Just fill in the columns. */
3893     epan_dissect_fill_in_columns(edt, FALSE, TRUE);
3894
3895   /* Print summary columns and/or protocol tree */
3896   switch (output_action) {
3897
3898   case WRITE_TEXT:
3899     if (print_summary && !print_columns(cf, edt))
3900         return FALSE;
3901     if (print_details) {
3902       if (!proto_tree_print(print_details ? print_dissections_expanded : print_dissections_none,
3903                             print_hex, edt, output_only_tables, print_stream))
3904         return FALSE;
3905       if (!print_hex) {
3906         if (!print_line(print_stream, 0, separator))
3907           return FALSE;
3908       }
3909     }
3910     break;
3911
3912   case WRITE_XML:
3913     if (print_summary) {
3914       write_psml_columns(edt, stdout, dissect_color);
3915       return !ferror(stdout);
3916     }
3917     if (print_details) {
3918       write_pdml_proto_tree(output_fields, protocolfilter, protocolfilter_flags, edt, stdout, dissect_color);
3919       printf("\n");
3920       return !ferror(stdout);
3921     }
3922     break;
3923
3924   case WRITE_FIELDS:
3925     if (print_summary) {
3926       /*No non-verbose "fields" format */
3927       g_assert_not_reached();
3928     }
3929     if (print_details) {
3930       write_fields_proto_tree(output_fields, edt, &cf->cinfo, stdout);
3931       printf("\n");
3932       return !ferror(stdout);
3933     }
3934     break;
3935
3936   case WRITE_JSON:
3937     if (print_summary)
3938       g_assert_not_reached();
3939     if (print_details) {
3940       write_json_proto_tree(output_fields, print_dissections_expanded,
3941                             print_hex, protocolfilter, protocolfilter_flags,
3942                             edt, node_children_grouper, stdout);
3943       return !ferror(stdout);
3944     }
3945     break;
3946
3947   case WRITE_JSON_RAW:
3948     if (print_summary)
3949       g_assert_not_reached();
3950     if (print_details) {
3951       write_json_proto_tree(output_fields, print_dissections_none, TRUE,
3952                             protocolfilter, protocolfilter_flags,
3953                             edt, node_children_grouper, stdout);
3954       return !ferror(stdout);
3955     }
3956     break;
3957
3958   case WRITE_EK:
3959     write_ek_proto_tree(output_fields, print_summary, print_hex, protocolfilter,
3960                         protocolfilter_flags, edt, stdout);
3961     return !ferror(stdout);
3962   }
3963
3964   if (print_hex) {
3965     if (print_summary || print_details) {
3966       if (!print_line(print_stream, 0, ""))
3967         return FALSE;
3968     }
3969     if (!print_hex_data(print_stream, edt))
3970       return FALSE;
3971     if (!print_line(print_stream, 0, separator))
3972       return FALSE;
3973   }
3974   return TRUE;
3975 }
3976
3977 static gboolean
3978 write_finale(void)
3979 {
3980   switch (output_action) {
3981
3982   case WRITE_TEXT:
3983     return print_finale(print_stream);
3984
3985   case WRITE_XML:
3986     if (print_details)
3987       write_pdml_finale(stdout);
3988     else
3989       write_psml_finale(stdout);
3990     return !ferror(stdout);
3991
3992   case WRITE_FIELDS:
3993     write_fields_finale(output_fields, stdout);
3994     return !ferror(stdout);
3995
3996   case WRITE_JSON:
3997   case WRITE_JSON_RAW:
3998     write_json_finale(stdout);
3999     return !ferror(stdout);
4000
4001   case WRITE_EK:
4002     return !ferror(stdout);
4003
4004   default:
4005     g_assert_not_reached();
4006     return FALSE;
4007   }
4008 }
4009
4010 void
4011 cf_close(capture_file *cf)
4012 {
4013   g_free(cf->filename);
4014 }
4015
4016 cf_status_t
4017 cf_open(capture_file *cf, const char *fname, unsigned int type, gboolean is_tempfile, int *err)
4018 {
4019   wtap  *wth;
4020   gchar *err_info;
4021
4022   wth = wtap_open_offline(fname, type, err, &err_info, perform_two_pass_analysis);
4023   if (wth == NULL)
4024     goto fail;
4025
4026   /* The open succeeded.  Fill in the information for this file. */
4027
4028   /* Create new epan session for dissection. */
4029   epan_free(cf->epan);
4030   cf->epan = tshark_epan_new(cf);
4031
4032   cf->provider.wth = wth;
4033   cf->f_datalen = 0; /* not used, but set it anyway */
4034
4035   /* Set the file name because we need it to set the follow stream filter.
4036      XXX - is that still true?  We need it for other reasons, though,
4037      in any case. */
4038   cf->filename = g_strdup(fname);
4039
4040   /* Indicate whether it's a permanent or temporary file. */
4041   cf->is_tempfile = is_tempfile;
4042
4043   /* No user changes yet. */
4044   cf->unsaved_changes = FALSE;
4045
4046   cf->cd_t      = wtap_file_type_subtype(cf->provider.wth);
4047   cf->open_type = type;
4048   cf->count     = 0;
4049   cf->drops_known = FALSE;
4050   cf->drops     = 0;
4051   cf->snap      = wtap_snapshot_length(cf->provider.wth);
4052   nstime_set_zero(&cf->elapsed_time);
4053   cf->provider.ref = NULL;
4054   cf->provider.prev_dis = NULL;
4055   cf->provider.prev_cap = NULL;
4056
4057   cf->state = FILE_READ_IN_PROGRESS;
4058
4059   wtap_set_cb_new_ipv4(cf->provider.wth, add_ipv4_name);
4060   wtap_set_cb_new_ipv6(cf->provider.wth, (wtap_new_ipv6_callback_t) add_ipv6_name);
4061
4062   return CF_OK;
4063
4064 fail:
4065   cfile_open_failure_message("TShark", fname, *err, err_info);
4066   return CF_ERROR;
4067 }
4068
4069 static void
4070 show_print_file_io_error(int err)
4071 {
4072   switch (err) {
4073
4074   case ENOSPC:
4075     cmdarg_err("Not all the packets could be printed because there is "
4076 "no space left on the file system.");
4077     break;
4078
4079 #ifdef EDQUOT
4080   case EDQUOT:
4081     cmdarg_err("Not all the packets could be printed because you are "
4082 "too close to, or over your disk quota.");
4083   break;
4084 #endif
4085
4086   default:
4087     cmdarg_err("An error occurred while printing packets: %s.",
4088       g_strerror(err));
4089     break;
4090   }
4091 }
4092
4093 /*
4094  * General errors and warnings are reported with an console message
4095  * in TShark.
4096  */
4097 static void
4098 failure_warning_message(const char *msg_format, va_list ap)
4099 {
4100   fprintf(stderr, "tshark: ");
4101   vfprintf(stderr, msg_format, ap);
4102   fprintf(stderr, "\n");
4103 }
4104
4105 /*
4106  * Open/create errors are reported with an console message in TShark.
4107  */
4108 static void
4109 open_failure_message(const char *filename, int err, gboolean for_writing)
4110 {
4111   fprintf(stderr, "tshark: ");
4112   fprintf(stderr, file_open_error_message(err, for_writing), filename);
4113   fprintf(stderr, "\n");
4114 }
4115
4116 /*
4117  * Read errors are reported with an console message in TShark.
4118  */
4119 static void
4120 read_failure_message(const char *filename, int err)
4121 {
4122   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
4123              filename, g_strerror(err));
4124 }
4125
4126 /*
4127  * Write errors are reported with an console message in TShark.
4128  */
4129 static void
4130 write_failure_message(const char *filename, int err)
4131 {
4132   cmdarg_err("An error occurred while writing to the file \"%s\": %s.",
4133              filename, g_strerror(err));
4134 }
4135
4136 static void reset_epan_mem(capture_file *cf,epan_dissect_t *edt, gboolean tree, gboolean visual)
4137 {
4138   if (!epan_auto_reset || (cf->count < epan_auto_reset_count))
4139     return;
4140
4141   fprintf(stderr, "resetting session.\n");
4142
4143   epan_dissect_cleanup(edt);
4144   epan_free(cf->epan);
4145
4146   cf->epan = tshark_epan_new(cf);
4147   epan_dissect_init(edt, cf->epan, tree, visual);
4148   cf->count = 0;
4149 }
4150
4151 /*
4152  * Report additional information for an error in command-line arguments.
4153  */
4154 static void
4155 failure_message_cont(const char *msg_format, va_list ap)
4156 {
4157   vfprintf(stderr, msg_format, ap);
4158   fprintf(stderr, "\n");
4159 }
4160
4161 /*
4162  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
4163  *
4164  * Local variables:
4165  * c-basic-offset: 2
4166  * tab-width: 8
4167  * indent-tabs-mode: nil
4168  * End:
4169  *
4170  * vi: set shiftwidth=2 tabstop=8 expandtab:
4171  * :indentSize=2:tabSize=8:noTabs=true:
4172  */