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