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