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