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