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