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