tshark: Add delimiter to both sides of packetlist arrows
[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  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23  */
24
25 #include <config.h>
26
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <string.h>
30 #include <locale.h>
31 #include <limits.h>
32
33 #ifdef HAVE_GETOPT_H
34 #include <getopt.h>
35 #endif
36
37 #include <errno.h>
38
39 #ifdef HAVE_WINSOCK2_H
40 # include <winsock2.h>
41 #endif
42
43 #ifndef _WIN32
44 #include <signal.h>
45 #endif
46
47 #ifdef HAVE_LIBCAP
48 # include <sys/capability.h>
49 #endif
50
51 #ifndef HAVE_GETOPT_LONG
52 #include "wsutil/wsgetopt.h"
53 #endif
54
55 #include <glib.h>
56
57 #include <epan/exceptions.h>
58 #include <epan/epan-int.h>
59 #include <epan/epan.h>
60
61 #include <wsutil/clopts_common.h>
62 #include <wsutil/cmdarg_err.h>
63 #include <wsutil/crash_info.h>
64 #include <wsutil/filesystem.h>
65 #include <wsutil/file_util.h>
66 #include <wsutil/privileges.h>
67 #include <wsutil/report_message.h>
68 #include <ws_version_info.h>
69 #include <wiretap/wtap_opttypes.h>
70 #include <wiretap/pcapng.h>
71
72 #include "globals.h"
73 #include <epan/timestamp.h>
74 #include <epan/packet.h>
75 #ifdef HAVE_LUA
76 #include <epan/wslua/init_wslua.h>
77 #endif
78 #include "frame_tvbuff.h"
79 #include <epan/disabled_protos.h>
80 #include <epan/prefs.h>
81 #include <epan/column.h>
82 #include <epan/decode_as.h>
83 #include <epan/print.h>
84 #include <epan/addr_resolv.h>
85 #ifdef HAVE_LIBPCAP
86 #include "ui/capture_ui_utils.h"
87 #endif
88 #include "ui/util.h"
89 #include "ui/ui_util.h"
90 #include "ui/decode_as_utils.h"
91 #include "ui/filter_files.h"
92 #include "ui/cli/tshark-tap.h"
93 #include "ui/cli/tap-exportobject.h"
94 #include "ui/tap_export_pdu.h"
95 #include "ui/dissect_opts.h"
96 #include "ui/failure_message.h"
97 #if defined(HAVE_LIBSMI)
98 #include "epan/oids.h"
99 #endif
100 #if defined(HAVE_GEOIP)
101 #include "epan/geoip_db.h"
102 #endif
103 #include "register.h"
104 #include <epan/epan_dissect.h>
105 #include <epan/tap.h>
106 #include <epan/stat_tap_ui.h>
107 #include <epan/conversation_table.h>
108 #include <epan/srt_table.h>
109 #include <epan/rtd_table.h>
110 #include <epan/ex-opt.h>
111 #include <epan/exported_pdu.h>
112
113 #include "capture_opts.h"
114
115 #include "caputils/capture-pcap-util.h"
116
117 #ifdef HAVE_LIBPCAP
118 #include "caputils/capture_ifinfo.h"
119 #ifdef _WIN32
120 #include "caputils/capture-wpcap.h"
121 #include <wsutil/os_version_info.h>
122 #include <wsutil/unicode-utils.h>
123 #endif /* _WIN32 */
124 #include <capchild/capture_session.h>
125 #include <capchild/capture_sync.h>
126 #include <capture_info.h>
127 #endif /* HAVE_LIBPCAP */
128 #include "log.h"
129 #include <epan/funnel.h>
130
131 #include <wsutil/str_util.h>
132 #include <wsutil/utf8_entities.h>
133
134 #ifdef HAVE_EXTCAP
135 #include "extcap.h"
136 #endif
137
138 #ifdef HAVE_PLUGINS
139 #include <wsutil/plugins.h>
140 #endif
141
142 /* Exit codes */
143 #define INVALID_OPTION 1
144 #define INVALID_INTERFACE 2
145 #define INVALID_FILE 2
146 #define INVALID_FILTER 2
147 #define INVALID_EXPORT 2
148 #define INVALID_CAPABILITY 2
149 #define INVALID_TAP 2
150 #define INVALID_DATA_LINK 2
151 #define INVALID_TIMESTAMP_TYPE 2
152 #define INVALID_CAPTURE 2
153 #define INIT_FAILED 2
154
155 /*
156  * values 128..65535 are capture+dissect options, 65536 is used by
157  * ui/commandline.c, so start tshark-specific options 1000 after this
158  */
159 #define LONGOPT_COLOR (65536+1000)
160 #define LONGOPT_NO_DUPLICATE_KEYS (65536+1001)
161
162 #if 0
163 #define tshark_debug(...) g_warning(__VA_ARGS__)
164 #else
165 #define tshark_debug(...)
166 #endif
167
168 static guint32 cum_bytes;
169 static const frame_data *ref;
170 static frame_data ref_frame;
171 static frame_data *prev_dis;
172 static frame_data prev_dis_frame;
173 static frame_data *prev_cap;
174 static frame_data prev_cap_frame;
175
176 static gboolean perform_two_pass_analysis;
177 static guint32 epan_auto_reset_count = 0;
178 static gboolean epan_auto_reset = FALSE;
179
180 /*
181  * The way the packet decode is to be written.
182  */
183 typedef enum {
184   WRITE_TEXT,   /* summary or detail text */
185   WRITE_XML,    /* PDML or PSML */
186   WRITE_FIELDS, /* User defined list of fields */
187   WRITE_JSON,   /* JSON */
188   WRITE_JSON_RAW,   /* JSON only raw hex */
189   WRITE_EK      /* JSON bulk insert to Elasticsearch */
190   /* Add CSV and the like here */
191 } output_action_e;
192
193 static output_action_e output_action;
194 static gboolean do_dissection;     /* TRUE if we have to dissect each packet */
195 static gboolean print_packet_info; /* TRUE if we're to print packet information */
196 static gint print_summary = -1;    /* TRUE if we're to print packet summary information */
197 static gboolean print_details;     /* TRUE if we're to print packet details information */
198 static gboolean print_hex;         /* TRUE if we're to print hex/ascci information */
199 static gboolean line_buffered;
200 static gboolean really_quiet = FALSE;
201 static gchar* delimiter_char = " ";
202 static gboolean dissect_color = FALSE;
203
204 static print_format_e print_format = PR_FMT_TEXT;
205 static print_stream_t *print_stream = NULL;
206
207 static output_fields_t* output_fields  = NULL;
208 static gchar **protocolfilter = NULL;
209 static pf_flags protocolfilter_flags = PF_NONE;
210
211 static gboolean no_duplicate_keys = FALSE;
212 static proto_node_children_grouper_func node_children_grouper = proto_node_group_children_by_unique;
213
214 /* The line separator used between packets, changeable via the -S option */
215 static const char *separator = "";
216
217 #ifdef HAVE_LIBPCAP
218 /*
219  * TRUE if we're to print packet counts to keep track of captured packets.
220  */
221 static gboolean print_packet_counts;
222
223 static capture_options global_capture_opts;
224 static capture_session global_capture_session;
225 static info_data_t global_info_data;
226
227 #ifdef SIGINFO
228 static gboolean infodelay;      /* if TRUE, don't print capture info in SIGINFO handler */
229 static gboolean infoprint;      /* if TRUE, print capture info after clearing infodelay */
230 #endif /* SIGINFO */
231
232 static gboolean capture(void);
233 static void report_counts(void);
234 #ifdef _WIN32
235 static BOOL WINAPI capture_cleanup(DWORD);
236 #else /* _WIN32 */
237 static void capture_cleanup(int);
238 #ifdef SIGINFO
239 static void report_counts_siginfo(int);
240 #endif /* SIGINFO */
241 #endif /* _WIN32 */
242
243 #else /* HAVE_LIBPCAP */
244
245 static char *output_file_name;
246
247 #endif /* HAVE_LIBPCAP */
248
249 static void reset_epan_mem(capture_file *cf, epan_dissect_t *edt, gboolean tree, gboolean visual);
250 static gboolean process_cap_file(capture_file *, char *, int, gboolean, int, gint64);
251 static gboolean process_packet_single_pass(capture_file *cf,
252     epan_dissect_t *edt, gint64 offset, struct wtap_pkthdr *whdr,
253     const guchar *pd, guint tap_flags);
254 static void show_print_file_io_error(int err);
255 static gboolean write_preamble(capture_file *cf);
256 static gboolean print_packet(capture_file *cf, epan_dissect_t *edt);
257 static gboolean write_finale(void);
258
259 static void failure_warning_message(const char *msg_format, va_list ap);
260 static void open_failure_message(const char *filename, int err,
261     gboolean for_writing);
262 static void read_failure_message(const char *filename, int err);
263 static void write_failure_message(const char *filename, int err);
264 static void failure_message_cont(const char *msg_format, va_list ap);
265
266 capture_file cfile;
267
268 static GHashTable *output_only_tables = NULL;
269
270 struct string_elem {
271   const char *sstr;   /* The short string */
272   const char *lstr;   /* The long string */
273 };
274
275 static gint
276 string_compare(gconstpointer a, gconstpointer b)
277 {
278   return strcmp(((const struct string_elem *)a)->sstr,
279                 ((const struct string_elem *)b)->sstr);
280 }
281
282 static void
283 string_elem_print(gpointer data, gpointer not_used _U_)
284 {
285   fprintf(stderr, "    %s - %s\n",
286           ((struct string_elem *)data)->sstr,
287           ((struct string_elem *)data)->lstr);
288 }
289
290 static void
291 list_capture_types(void) {
292   int                 i;
293   struct string_elem *captypes;
294   GSList             *list = NULL;
295
296   captypes = g_new(struct string_elem, WTAP_NUM_FILE_TYPES_SUBTYPES);
297
298   fprintf(stderr, "tshark: The available capture file types for the \"-F\" flag are:\n");
299   for (i = 0; i < WTAP_NUM_FILE_TYPES_SUBTYPES; i++) {
300     if (wtap_dump_can_open(i)) {
301       captypes[i].sstr = wtap_file_type_subtype_short_string(i);
302       captypes[i].lstr = wtap_file_type_subtype_string(i);
303       list = g_slist_insert_sorted(list, &captypes[i], string_compare);
304     }
305   }
306   g_slist_foreach(list, string_elem_print, NULL);
307   g_slist_free(list);
308   g_free(captypes);
309 }
310
311 static void
312 list_read_capture_types(void) {
313   int                 i;
314   struct string_elem *captypes;
315   GSList             *list = NULL;
316   const char *magic = "Magic-value-based";
317   const char *heuristic = "Heuristics-based";
318
319   /* this is a hack, but WTAP_NUM_FILE_TYPES_SUBTYPES is always >= number of open routines so we're safe */
320   captypes = g_new(struct string_elem, WTAP_NUM_FILE_TYPES_SUBTYPES);
321
322   fprintf(stderr, "tshark: The available read file types for the \"-X read_format:\" option are:\n");
323   for (i = 0; open_routines[i].name != NULL; i++) {
324     captypes[i].sstr = open_routines[i].name;
325     captypes[i].lstr = (open_routines[i].type == OPEN_INFO_MAGIC) ? magic : heuristic;
326     list = g_slist_insert_sorted(list, &captypes[i], string_compare);
327   }
328   g_slist_foreach(list, string_elem_print, NULL);
329   g_slist_free(list);
330   g_free(captypes);
331 }
332
333 static void
334 print_usage(FILE *output)
335 {
336   fprintf(output, "\n");
337   fprintf(output, "Usage: tshark [options] ...\n");
338   fprintf(output, "\n");
339
340 #ifdef HAVE_LIBPCAP
341   fprintf(output, "Capture interface:\n");
342   fprintf(output, "  -i <interface>           name or idx of interface (def: first non-loopback)\n");
343   fprintf(output, "  -f <capture filter>      packet filter in libpcap filter syntax\n");
344 #ifdef HAVE_PCAP_CREATE
345   fprintf(output, "  -s <snaplen>             packet snapshot length (def: appropriate maximum)\n");
346 #else
347   fprintf(output, "  -s <snaplen>             packet snapshot length (def: %u)\n", WTAP_MAX_PACKET_SIZE_STANDARD);
348 #endif
349   fprintf(output, "  -p                       don't capture in promiscuous mode\n");
350 #ifdef HAVE_PCAP_CREATE
351   fprintf(output, "  -I                       capture in monitor mode, if available\n");
352 #endif
353 #ifdef CAN_SET_CAPTURE_BUFFER_SIZE
354   fprintf(output, "  -B <buffer size>         size of kernel buffer (def: %dMB)\n", DEFAULT_CAPTURE_BUFFER_SIZE);
355 #endif
356   fprintf(output, "  -y <link type>           link layer type (def: first appropriate)\n");
357   fprintf(output, "  --time-stamp-type <type> timestamp method for interface\n");
358   fprintf(output, "  -D                       print list of interfaces and exit\n");
359   fprintf(output, "  -L                       print list of link-layer types of iface and exit\n");
360   fprintf(output, "  --list-time-stamp-types  print list of timestamp types for iface and exit\n");
361   fprintf(output, "\n");
362   fprintf(output, "Capture stop conditions:\n");
363   fprintf(output, "  -c <packet count>        stop after n packets (def: infinite)\n");
364   fprintf(output, "  -a <autostop cond.> ...  duration:NUM - stop after NUM seconds\n");
365   fprintf(output, "                           filesize:NUM - stop this file after NUM KB\n");
366   fprintf(output, "                              files:NUM - stop after NUM files\n");
367   /*fprintf(output, "\n");*/
368   fprintf(output, "Capture output:\n");
369   fprintf(output, "  -b <ringbuffer opt.> ... duration:NUM - switch to next file after NUM secs\n");
370   fprintf(output, "                           interval:NUM - create time intervals of NUM secs\n");
371   fprintf(output, "                           filesize:NUM - switch to next file after NUM KB\n");
372   fprintf(output, "                              files:NUM - ringbuffer: replace after NUM files\n");
373 #endif  /* HAVE_LIBPCAP */
374 #ifdef HAVE_PCAP_REMOTE
375   fprintf(output, "RPCAP options:\n");
376   fprintf(output, "  -A <user>:<password>     use RPCAP password authentication\n");
377 #endif
378   /*fprintf(output, "\n");*/
379   fprintf(output, "Input file:\n");
380   fprintf(output, "  -r <infile>              set the filename to read from (- to read from stdin)\n");
381
382   fprintf(output, "\n");
383   fprintf(output, "Processing:\n");
384   fprintf(output, "  -2                       perform a two-pass analysis\n");
385   fprintf(output, "  -M <packet count>        perform session auto reset\n");
386   fprintf(output, "  -R <read filter>         packet Read filter in Wireshark display filter syntax\n");
387   fprintf(output, "                           (requires -2)\n");
388   fprintf(output, "  -Y <display filter>      packet displaY filter in Wireshark display filter\n");
389   fprintf(output, "                           syntax\n");
390   fprintf(output, "  -n                       disable all name resolutions (def: all enabled)\n");
391   fprintf(output, "  -N <name resolve flags>  enable specific name resolution(s): \"mnNtCd\"\n");
392   fprintf(output, "  -d %s ...\n", DECODE_AS_ARG_TEMPLATE);
393   fprintf(output, "                           \"Decode As\", see the man page for details\n");
394   fprintf(output, "                           Example: tcp.port==8888,http\n");
395   fprintf(output, "  -H <hosts file>          read a list of entries from a hosts file, which will\n");
396   fprintf(output, "                           then be written to a capture file. (Implies -W n)\n");
397   fprintf(output, "  --enable-protocol <proto_name>\n");
398   fprintf(output, "                           enable dissection of proto_name\n");
399   fprintf(output, "  --disable-protocol <proto_name>\n");
400   fprintf(output, "                           disable dissection of proto_name\n");
401   fprintf(output, "  --enable-heuristic <short_name>\n");
402   fprintf(output, "                           enable dissection of heuristic protocol\n");
403   fprintf(output, "  --disable-heuristic <short_name>\n");
404   fprintf(output, "                           disable dissection of heuristic protocol\n");
405
406   /*fprintf(output, "\n");*/
407   fprintf(output, "Output:\n");
408   fprintf(output, "  -w <outfile|->           write packets to a pcap-format file named \"outfile\"\n");
409   fprintf(output, "                           (or to the standard output for \"-\")\n");
410   fprintf(output, "  -C <config profile>      start with specified configuration profile\n");
411   fprintf(output, "  -F <output file type>    set the output file type, default is pcapng\n");
412   fprintf(output, "                           an empty \"-F\" option will list the file types\n");
413   fprintf(output, "  -V                       add output of packet tree        (Packet Details)\n");
414   fprintf(output, "  -O <protocols>           Only show packet details of these protocols, comma\n");
415   fprintf(output, "                           separated\n");
416   fprintf(output, "  -P                       print packet summary even when writing to a file\n");
417   fprintf(output, "  -S <separator>           the line separator to print between packets\n");
418   fprintf(output, "  -x                       add output of hex and ASCII dump (Packet Bytes)\n");
419   fprintf(output, "  -T pdml|ps|psml|json|jsonraw|ek|tabs|text|fields|?\n");
420   fprintf(output, "                           format of text output (def: text)\n");
421   fprintf(output, "  -j <protocolfilter>      protocols layers filter if -T ek|pdml|json selected\n");
422   fprintf(output, "                           (e.g. \"ip ip.flags text\", filter does not expand child\n");
423   fprintf(output, "                           nodes, unless child is specified also in the filter)\n");
424   fprintf(output, "  -J <protocolfilter>      top level protocol filter if -T ek|pdml|json selected\n");
425   fprintf(output, "                           (e.g. \"http tcp\", filter which expands all child nodes)\n");
426   fprintf(output, "  -e <field>               field to print if -Tfields selected (e.g. tcp.port,\n");
427   fprintf(output, "                           _ws.col.Info)\n");
428   fprintf(output, "                           this option can be repeated to print multiple fields\n");
429   fprintf(output, "  -E<fieldsoption>=<value> set options for output when -Tfields selected:\n");
430   fprintf(output, "     bom=y|n               print a UTF-8 BOM\n");
431   fprintf(output, "     header=y|n            switch headers on and off\n");
432   fprintf(output, "     separator=/t|/s|<char> select tab, space, printable character as separator\n");
433   fprintf(output, "     occurrence=f|l|a      print first, last or all occurrences of each field\n");
434   fprintf(output, "     aggregator=,|/s|<char> select comma, space, printable character as\n");
435   fprintf(output, "                           aggregator\n");
436   fprintf(output, "     quote=d|s|n           select double, single, no quotes for values\n");
437   fprintf(output, "  -t a|ad|d|dd|e|r|u|ud|?  output format of time stamps (def: r: rel. to first)\n");
438   fprintf(output, "  -u s|hms                 output format of seconds (def: s: seconds)\n");
439   fprintf(output, "  -l                       flush standard output after each packet\n");
440   fprintf(output, "  -q                       be more quiet on stdout (e.g. when using statistics)\n");
441   fprintf(output, "  -Q                       only log true errors to stderr (quieter than -q)\n");
442   fprintf(output, "  -g                       enable group read access on the output file(s)\n");
443   fprintf(output, "  -W n                     Save extra information in the file, if supported.\n");
444   fprintf(output, "                           n = write network address resolution information\n");
445   fprintf(output, "  -X <key>:<value>         eXtension options, see the man page for details\n");
446   fprintf(output, "  -U tap_name              PDUs export mode, see the man page for details\n");
447   fprintf(output, "  -z <statistics>          various statistics, see the man page for details\n");
448   fprintf(output, "  --capture-comment <comment>\n");
449   fprintf(output, "                           add a capture comment to the newly created\n");
450   fprintf(output, "                           output file (only for pcapng)\n");
451   fprintf(output, "  --export-objects <protocol>,<destdir> save exported objects for a protocol to\n");
452   fprintf(output, "                           a directory named \"destdir\"\n");
453   fprintf(output, "  --color                  color output text similarly to the Wireshark GUI,\n");
454   fprintf(output, "                           requires a terminal with 24-bit color support\n");
455   fprintf(output, "                           Also supplies color attributes to pdml and psml formats\n");
456   fprintf(output, "                           (Note that attributes are nonstandard)\n");
457   fprintf(output, "  --no-duplicate-keys      If -T json is specified, merge duplicate keys in an object\n");
458   fprintf(output, "                           into a single key with as value a json array containing all\n");
459   fprintf(output, "                           values");
460
461   fprintf(output, "\n");
462   fprintf(output, "Miscellaneous:\n");
463   fprintf(output, "  -h                       display this help and exit\n");
464   fprintf(output, "  -v                       display version info and exit\n");
465   fprintf(output, "  -o <name>:<value> ...    override preference setting\n");
466   fprintf(output, "  -K <keytab>              keytab file to use for kerberos decryption\n");
467   fprintf(output, "  -G [report]              dump one of several available reports and exit\n");
468   fprintf(output, "                           default report=\"fields\"\n");
469   fprintf(output, "                           use \"-G ?\" for more help\n");
470 #ifdef __linux__
471   fprintf(output, "\n");
472   fprintf(output, "WARNING: dumpcap will enable kernel BPF JIT compiler if available.\n");
473   fprintf(output, "You might want to reset it\n");
474   fprintf(output, "By doing \"echo 0 > /proc/sys/net/core/bpf_jit_enable\"\n");
475   fprintf(output, "\n");
476 #endif
477
478 }
479
480 static void
481 glossary_option_help(void)
482 {
483   FILE *output;
484
485   output = stdout;
486
487   fprintf(output, "TShark (Wireshark) %s\n", get_ws_vcs_version_info());
488
489   fprintf(output, "\n");
490   fprintf(output, "Usage: tshark -G [report]\n");
491   fprintf(output, "\n");
492   fprintf(output, "Glossary table reports:\n");
493   fprintf(output, "  -G column-formats        dump column format codes and exit\n");
494   fprintf(output, "  -G decodes               dump \"layer type\"/\"decode as\" associations and exit\n");
495   fprintf(output, "  -G dissector-tables      dump dissector table names, types, and properties\n");
496   fprintf(output, "  -G fieldcount            dump count of header fields and exit\n");
497   fprintf(output, "  -G fields                dump fields glossary and exit\n");
498   fprintf(output, "  -G ftypes                dump field type basic and descriptive names\n");
499   fprintf(output, "  -G heuristic-decodes     dump heuristic dissector tables\n");
500   fprintf(output, "  -G plugins               dump installed plugins and exit\n");
501   fprintf(output, "  -G protocols             dump protocols in registration database and exit\n");
502   fprintf(output, "  -G values                dump value, range, true/false strings and exit\n");
503   fprintf(output, "\n");
504   fprintf(output, "Preference reports:\n");
505   fprintf(output, "  -G currentprefs          dump current preferences and exit\n");
506   fprintf(output, "  -G defaultprefs          dump default preferences and exit\n");
507   fprintf(output, "  -G folders               dump about:folders\n");
508   fprintf(output, "\n");
509 }
510
511 static void
512 tshark_log_handler (const gchar *log_domain, GLogLevelFlags log_level,
513     const gchar *message, gpointer user_data)
514 {
515   /* ignore log message, if log_level isn't interesting based
516      upon the console log preferences.
517      If the preferences haven't been loaded loaded yet, display the
518      message anyway.
519
520      The default console_log_level preference value is such that only
521        ERROR, CRITICAL and WARNING level messages are processed;
522        MESSAGE, INFO and DEBUG level messages are ignored.
523
524      XXX: Aug 07, 2009: Prior tshark g_log code was hardwired to process only
525            ERROR and CRITICAL level messages so the current code is a behavioral
526            change.  The current behavior is the same as in Wireshark.
527   */
528   if ((log_level & G_LOG_LEVEL_MASK & prefs.console_log_level) == 0 &&
529      prefs.console_log_level != 0) {
530     return;
531   }
532
533   g_log_default_handler(log_domain, log_level, message, user_data);
534
535 }
536
537 static void
538 print_current_user(void) {
539   gchar *cur_user, *cur_group;
540
541   if (started_with_special_privs()) {
542     cur_user = get_cur_username();
543     cur_group = get_cur_groupname();
544     fprintf(stderr, "Running as user \"%s\" and group \"%s\".",
545       cur_user, cur_group);
546     g_free(cur_user);
547     g_free(cur_group);
548     if (running_with_special_privs()) {
549       fprintf(stderr, " This could be dangerous.");
550     }
551     fprintf(stderr, "\n");
552   }
553 }
554
555 static void
556 get_tshark_compiled_version_info(GString *str)
557 {
558   /* Capture libraries */
559   get_compiled_caplibs_version(str);
560 }
561
562 static void
563 get_tshark_runtime_version_info(GString *str)
564 {
565 #ifdef HAVE_LIBPCAP
566     /* Capture libraries */
567     g_string_append(str, ", ");
568     get_runtime_caplibs_version(str);
569 #endif
570
571     /* stuff used by libwireshark */
572     epan_get_runtime_version_info(str);
573 }
574
575 static void
576 about_folders(void)
577 {
578   const char           *constpath;
579   char                 *path;
580 #if defined(HAVE_LIBSMI) || defined(HAVE_GEOIP) || defined(HAVE_EXTCAP)
581   gint                  i;
582   gchar               **resultArray;
583 #endif
584
585   /* "file open" */
586
587   /*
588    * Fetching the "File" dialogs folder not implemented.
589    * This is arguably just a pwd for a ui/cli .
590    */
591
592   /* temp */
593   printf("%-21s\t%s\n", "Temp:", g_get_tmp_dir());
594
595   /* pers conf */
596   path = get_persconffile_path("", FALSE);
597   printf("%-21s\t%s\n", "Personal configuration:", path);
598   g_free(path);
599
600   /* global conf */
601   constpath = get_datafile_dir();
602   if (constpath != NULL) {
603     printf("%-21s\t%s\n", "Global configuration:", constpath);
604   }
605
606   /* system */
607   constpath = get_systemfile_dir();
608   printf("%-21s\t%s\n", "System:", constpath);
609
610   /* program */
611   constpath = get_progfile_dir();
612   printf("%-21s\t%s\n", "Program:", constpath);
613
614 #if defined(HAVE_PLUGINS) || defined(HAVE_LUA)
615   /* pers plugins */
616   path = get_plugins_pers_dir();
617
618   printf("%-21s\t%s\n", "Personal Plugins:", path);
619
620   g_free(path);
621
622   /* global plugins */
623   printf("%-21s\t%s\n", "Global Plugins:", get_plugin_dir());
624 #endif
625
626 #ifdef HAVE_GEOIP
627   /* GeoIP */
628   path = geoip_db_get_paths();
629
630   resultArray = g_strsplit(path, G_SEARCHPATH_SEPARATOR_S, 10);
631
632   for(i = 0; resultArray[i]; i++)
633     printf("%-21s\t%s\n", "GeoIP path:", g_strstrip(resultArray[i]));
634
635   g_strfreev(resultArray);
636   g_free(path);
637 #endif
638
639 #ifdef HAVE_LIBSMI
640   /* SMI MIBs/PIBs */
641   path = oid_get_default_mib_path();
642   resultArray = g_strsplit(path, G_SEARCHPATH_SEPARATOR_S, 10);
643
644   for(i = 0; resultArray[i]; i++)
645     printf("%-21s\t%s\n", "MIB/PIB path:", g_strstrip(resultArray[i]));
646
647   g_strfreev(resultArray);
648   g_free(path);
649 #endif
650
651 #ifdef HAVE_EXTCAP
652   /* Extcap */
653   constpath = get_extcap_dir();
654
655   resultArray = g_strsplit(constpath, G_SEARCHPATH_SEPARATOR_S, 10);
656   for(i = 0; resultArray[i]; i++)
657     printf("%-21s\t%s\n", "Extcap path:", g_strstrip(resultArray[i]));
658
659   g_strfreev(resultArray);
660 #endif
661
662 }
663
664 int
665 main(int argc, char *argv[])
666 {
667   GString             *comp_info_str;
668   GString             *runtime_info_str;
669   char                *init_progfile_dir_error;
670   int                  opt;
671   static const struct option long_options[] = {
672     {"help", no_argument, NULL, 'h'},
673     {"version", no_argument, NULL, 'v'},
674     LONGOPT_CAPTURE_COMMON
675     LONGOPT_DISSECT_COMMON
676     {"export-objects", required_argument, NULL, LONGOPT_EXPORT_OBJECTS},
677     {"color", no_argument, NULL, LONGOPT_COLOR},
678     {"no-duplicate-keys", no_argument, NULL, LONGOPT_NO_DUPLICATE_KEYS},
679     {0, 0, 0, 0 }
680   };
681   gboolean             arg_error = FALSE;
682
683 #ifdef _WIN32
684   int                  result;
685   WSADATA              wsaData;
686 #endif  /* _WIN32 */
687
688   int                  err;
689   volatile gboolean    success;
690   volatile int         exit_status = EXIT_SUCCESS;
691 #ifdef HAVE_LIBPCAP
692   int                  caps_queries = 0;
693   gboolean             start_capture = FALSE;
694   GList               *if_list;
695   gchar               *err_str;
696 #else
697   gboolean             capture_option_specified = FALSE;
698 #endif
699   gboolean             quiet = FALSE;
700 #ifdef PCAP_NG_DEFAULT
701   volatile int         out_file_type = WTAP_FILE_TYPE_SUBTYPE_PCAPNG;
702 #else
703   volatile int         out_file_type = WTAP_FILE_TYPE_SUBTYPE_PCAP;
704 #endif
705   volatile gboolean    out_file_name_res = FALSE;
706   volatile int         in_file_type = WTAP_TYPE_AUTO;
707   gchar               *volatile cf_name = NULL;
708   gchar               *rfilter = NULL;
709   gchar               *dfilter = NULL;
710 #ifdef HAVE_PCAP_OPEN_DEAD
711   struct bpf_program   fcode;
712 #endif
713   dfilter_t           *rfcode = NULL;
714   dfilter_t           *dfcode = NULL;
715   gchar               *err_msg;
716   e_prefs             *prefs_p;
717   int                  log_flags;
718   gchar               *output_only = NULL;
719   gchar               *volatile pdu_export_arg = NULL;
720   const char          *volatile exp_pdu_filename = NULL;
721   exp_pdu_t            exp_pdu_tap_data;
722
723 /*
724  * The leading + ensures that getopt_long() does not permute the argv[]
725  * entries.
726  *
727  * We have to make sure that the first getopt_long() preserves the content
728  * of argv[] for the subsequent getopt_long() call.
729  *
730  * We use getopt_long() in both cases to ensure that we're using a routine
731  * whose permutation behavior we can control in the same fashion on all
732  * platforms, and so that, if we ever need to process a long argument before
733  * doing further initialization, we can do so.
734  *
735  * Glibc and Solaris libc document that a leading + disables permutation
736  * of options, regardless of whether POSIXLY_CORRECT is set or not; *BSD
737  * and macOS don't document it, but do so anyway.
738  *
739  * We do *not* use a leading - because the behavior of a leading - is
740  * platform-dependent.
741  */
742 #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:"
743
744   static const char    optstring[] = OPTSTRING;
745
746   tshark_debug("tshark started with %d args", argc);
747
748   /* Set the C-language locale to the native environment. */
749   setlocale(LC_ALL, "");
750
751   cmdarg_err_init(failure_warning_message, failure_message_cont);
752
753 #ifdef _WIN32
754   arg_list_utf_16to8(argc, argv);
755   create_app_running_mutex();
756 #if !GLIB_CHECK_VERSION(2,31,0)
757   g_thread_init(NULL);
758 #endif
759 #endif /* _WIN32 */
760
761   /*
762    * Get credential information for later use, and drop privileges
763    * before doing anything else.
764    * Let the user know if anything happened.
765    */
766   init_process_policies();
767   relinquish_special_privs_perm();
768   print_current_user();
769
770   /*
771    * Attempt to get the pathname of the directory containing the
772    * executable file.
773    */
774   init_progfile_dir_error = init_progfile_dir(argv[0], main);
775   if (init_progfile_dir_error != NULL) {
776     fprintf(stderr,
777             "tshark: Can't get pathname of directory containing the tshark program: %s.\n"
778             "It won't be possible to capture traffic.\n"
779             "Report this to the Wireshark developers.",
780             init_progfile_dir_error);
781     g_free(init_progfile_dir_error);
782   }
783
784   initialize_funnel_ops();
785
786 #ifdef _WIN32
787   ws_init_dll_search_path();
788 #ifdef HAVE_LIBPCAP
789   /* Load wpcap if possible. Do this before collecting the run-time version information */
790   load_wpcap();
791
792   /* Warn the user if npf.sys isn't loaded. */
793   if (!npf_sys_is_running() && get_windows_major_version() >= 6) {
794     fprintf(stderr, "The NPF driver isn't running.  You may have trouble "
795       "capturing or\nlisting interfaces.\n");
796   }
797 #endif /* HAVE_LIBPCAP */
798 #endif /* _WIN32 */
799
800   /* Get the compile-time version information string */
801   comp_info_str = get_compiled_version_info(get_tshark_compiled_version_info,
802                                             epan_get_compiled_version_info);
803
804   /* Get the run-time version information string */
805   runtime_info_str = get_runtime_version_info(get_tshark_runtime_version_info);
806
807   /* Add it to the information to be reported on a crash. */
808   ws_add_crash_info("TShark (Wireshark) %s\n"
809          "\n"
810          "%s"
811          "\n"
812          "%s",
813       get_ws_vcs_version_info(), comp_info_str->str, runtime_info_str->str);
814   g_string_free(comp_info_str, TRUE);
815   g_string_free(runtime_info_str, TRUE);
816
817   /* Fail sometimes. Useful for testing fuzz scripts. */
818   /* if (g_random_int_range(0, 100) < 5) abort(); */
819
820   /*
821    * In order to have the -X opts assigned before the wslua machine starts
822    * we need to call getopt_long before epan_init() gets called.
823    *
824    * In order to handle, for example, -o options, we also need to call it
825    * *after* epan_init() gets called, so that the dissectors have had a
826    * chance to register their preferences.
827    *
828    * XXX - can we do this all with one getopt_long() call, saving the
829    * arguments we can't handle until after initializing libwireshark,
830    * and then process them after initializing libwireshark?
831    */
832   opterr = 0;
833
834   while ((opt = getopt_long(argc, argv, optstring, long_options, NULL)) != -1) {
835     switch (opt) {
836     case 'C':        /* Configuration Profile */
837       if (profile_exists (optarg, FALSE)) {
838         set_profile_name (optarg);
839       } else {
840         cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
841         exit_status = INVALID_OPTION;
842         goto clean_exit;
843       }
844       break;
845     case 'P':        /* Print packet summary info even when writing to a file */
846       print_packet_info = TRUE;
847       print_summary = TRUE;
848       break;
849     case 'O':        /* Only output these protocols */
850       output_only = g_strdup(optarg);
851       /* FALLTHROUGH */
852     case 'V':        /* Verbose */
853       print_details = TRUE;
854       print_packet_info = TRUE;
855       break;
856     case 'x':        /* Print packet data in hex (and ASCII) */
857       print_hex = TRUE;
858       /*  The user asked for hex output, so let's ensure they get it,
859        *  even if they're writing to a file.
860        */
861       print_packet_info = TRUE;
862       break;
863     case 'X':
864       ex_opt_add(optarg);
865       break;
866     default:
867       break;
868     }
869   }
870
871   /*
872    * Print packet summary information is the default, unless either -V or -x
873    * were specified and -P was not.  Note that this is new behavior, which
874    * allows for the possibility of printing only hex/ascii output without
875    * necessarily requiring that either the summary or details be printed too.
876    */
877   if (print_summary == -1)
878     print_summary = (print_details || print_hex) ? FALSE : TRUE;
879
880 /** Send All g_log messages to our own handler **/
881
882   log_flags =
883                     G_LOG_LEVEL_ERROR|
884                     G_LOG_LEVEL_CRITICAL|
885                     G_LOG_LEVEL_WARNING|
886                     G_LOG_LEVEL_MESSAGE|
887                     G_LOG_LEVEL_INFO|
888                     G_LOG_LEVEL_DEBUG|
889                     G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
890
891   g_log_set_handler(NULL,
892                     (GLogLevelFlags)log_flags,
893                     tshark_log_handler, NULL /* user_data */);
894   g_log_set_handler(LOG_DOMAIN_MAIN,
895                     (GLogLevelFlags)log_flags,
896                     tshark_log_handler, NULL /* user_data */);
897
898 #ifdef HAVE_LIBPCAP
899   g_log_set_handler(LOG_DOMAIN_CAPTURE,
900                     (GLogLevelFlags)log_flags,
901                     tshark_log_handler, NULL /* user_data */);
902   g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
903                     (GLogLevelFlags)log_flags,
904                     tshark_log_handler, NULL /* user_data */);
905 #endif
906
907   init_report_message(failure_warning_message, failure_warning_message,
908                       open_failure_message, read_failure_message,
909                       write_failure_message);
910
911 #ifdef HAVE_LIBPCAP
912   capture_opts_init(&global_capture_opts);
913   capture_session_init(&global_capture_session, &cfile);
914 #endif
915
916   timestamp_set_type(TS_RELATIVE);
917   timestamp_set_precision(TS_PREC_AUTO);
918   timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
919
920   wtap_init();
921
922 #ifdef HAVE_PLUGINS
923   /* Register all the plugin types we have. */
924   epan_register_plugin_types(); /* Types known to libwireshark */
925
926   /* Scan for plugins.  This does *not* call their registration routines;
927      that's done later. */
928   scan_plugins(REPORT_LOAD_FAILURE);
929
930   /* Register all libwiretap plugin modules. */
931   register_all_wiretap_modules();
932 #endif
933
934   /* Register all dissectors; we must do this before checking for the
935      "-G" flag, as the "-G" flag dumps information registered by the
936      dissectors, and we must do it before we read the preferences, in
937      case any dissectors register preferences. */
938   if (!epan_init(register_all_protocols, register_all_protocol_handoffs, NULL,
939                  NULL)) {
940     exit_status = INIT_FAILED;
941     goto clean_exit;
942   }
943
944   /* Register all tap listeners; we do this before we parse the arguments,
945      as the "-z" argument can specify a registered tap. */
946
947   /* we register the plugin taps before the other taps because
948      stats_tree taps plugins will be registered as tap listeners
949      by stats_tree_stat.c and need to registered before that */
950 #ifdef HAVE_PLUGINS
951   register_all_plugin_tap_listeners();
952 #endif
953 #ifdef HAVE_EXTCAP
954   extcap_register_preferences();
955 #endif
956   register_all_tap_listeners();
957   conversation_table_set_gui_info(init_iousers);
958   hostlist_table_set_gui_info(init_hostlists);
959   srt_table_iterate_tables(register_srt_tables, NULL);
960   rtd_table_iterate_tables(register_rtd_tables, NULL);
961   new_stat_tap_iterate_tables(register_simple_stat_tables, NULL);
962
963   /* If invoked with the "-G" flag, we dump out information based on
964      the argument to the "-G" flag; if no argument is specified,
965      for backwards compatibility we dump out a glossary of display
966      filter symbols.
967
968      XXX - we do this here, for now, to support "-G" with no arguments.
969      If none of our build or other processes uses "-G" with no arguments,
970      we can just process it with the other arguments. */
971   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
972     proto_initialize_all_prefixes();
973
974     if (argc == 2)
975       proto_registrar_dump_fields();
976     else {
977       if (strcmp(argv[2], "column-formats") == 0)
978         column_dump_column_formats();
979       else if (strcmp(argv[2], "currentprefs") == 0) {
980         epan_load_settings();
981         write_prefs(NULL);
982       }
983       else if (strcmp(argv[2], "decodes") == 0)
984         dissector_dump_decodes();
985       else if (strcmp(argv[2], "defaultprefs") == 0)
986         write_prefs(NULL);
987       else if (strcmp(argv[2], "dissector-tables") == 0)
988         dissector_dump_dissector_tables();
989       else if (strcmp(argv[2], "fieldcount") == 0) {
990         /* return value for the test suite */
991         exit_status = proto_registrar_dump_fieldcount();
992         goto clean_exit;
993       } else if (strcmp(argv[2], "fields") == 0)
994         proto_registrar_dump_fields();
995       else if (strcmp(argv[2], "folders") == 0)
996         about_folders();
997       else if (strcmp(argv[2], "ftypes") == 0)
998         proto_registrar_dump_ftypes();
999       else if (strcmp(argv[2], "heuristic-decodes") == 0)
1000         dissector_dump_heur_decodes();
1001       else if (strcmp(argv[2], "plugins") == 0) {
1002 #ifdef HAVE_PLUGINS
1003         plugins_dump_all();
1004 #endif
1005 #ifdef HAVE_LUA
1006         wslua_plugins_dump_all();
1007 #endif
1008       }
1009       else if (strcmp(argv[2], "protocols") == 0)
1010         proto_registrar_dump_protocols();
1011       else if (strcmp(argv[2], "values") == 0)
1012         proto_registrar_dump_values();
1013       else if (strcmp(argv[2], "?") == 0)
1014         glossary_option_help();
1015       else if (strcmp(argv[2], "-?") == 0)
1016         glossary_option_help();
1017       else {
1018         cmdarg_err("Invalid \"%s\" option for -G flag, enter -G ? for more help.", argv[2]);
1019         exit_status = INVALID_OPTION;
1020         goto clean_exit;
1021       }
1022     }
1023     exit_status = EXIT_SUCCESS;
1024     goto clean_exit;
1025   }
1026
1027   tshark_debug("tshark reading settings");
1028
1029   /* Load libwireshark settings from the current profile. */
1030   prefs_p = epan_load_settings();
1031
1032   read_filter_list(CFILTER_LIST);
1033
1034   cap_file_init(&cfile);
1035
1036   /* Print format defaults to this. */
1037   print_format = PR_FMT_TEXT;
1038   delimiter_char = " ";
1039
1040   output_fields = output_fields_new();
1041
1042   /*
1043    * To reset the options parser, set optreset to 1 on platforms that
1044    * have optreset (documented in *BSD and macOS, apparently present but
1045    * not documented in Solaris - the Illumos repository seems to
1046    * suggest that the first Solaris getopt_long(), at least as of 2004,
1047    * was based on the NetBSD one, it had optreset) and set optind to 1,
1048    * and set optind to 0 otherwise (documented as working in the GNU
1049    * getopt_long().  Setting optind to 0 didn't originally work in the
1050    * NetBSD one, but that was added later - we don't want to depend on
1051    * it if we have optreset).
1052    *
1053    * Also reset opterr to 1, so that error messages are printed by
1054    * getopt_long().
1055    */
1056 #ifdef HAVE_OPTRESET
1057   optreset = 1;
1058   optind = 1;
1059 #else
1060   optind = 0;
1061 #endif
1062   opterr = 1;
1063
1064   /* Now get our args */
1065   while ((opt = getopt_long(argc, argv, optstring, long_options, NULL)) != -1) {
1066     switch (opt) {
1067     case '2':        /* Perform two pass analysis */
1068       if(epan_auto_reset){
1069         cmdarg_err("-2 does not support auto session reset.");
1070         arg_error=TRUE;
1071       }
1072       perform_two_pass_analysis = TRUE;
1073       break;
1074     case 'M':
1075       if(perform_two_pass_analysis){
1076         cmdarg_err("-M does not support two pass analysis.");
1077         arg_error=TRUE;
1078       }
1079       epan_auto_reset_count = get_positive_int(optarg, "epan reset count");
1080       epan_auto_reset = TRUE;
1081       break;
1082     case 'a':        /* autostop criteria */
1083     case 'b':        /* Ringbuffer option */
1084     case 'c':        /* Capture x packets */
1085     case 'f':        /* capture filter */
1086     case 'g':        /* enable group read access on file(s) */
1087     case 'i':        /* Use interface x */
1088     case LONGOPT_SET_TSTAMP_TYPE: /* Set capture timestamp type */
1089     case 'p':        /* Don't capture in promiscuous mode */
1090 #ifdef HAVE_PCAP_REMOTE
1091     case 'A':        /* Authentication */
1092 #endif
1093 #ifdef HAVE_PCAP_CREATE
1094     case 'I':        /* Capture in monitor mode, if available */
1095 #endif
1096     case 's':        /* Set the snapshot (capture) length */
1097     case 'w':        /* Write to capture file x */
1098     case 'y':        /* Set the pcap data link type */
1099     case  LONGOPT_NUM_CAP_COMMENT: /* add a capture comment */
1100 #ifdef CAN_SET_CAPTURE_BUFFER_SIZE
1101     case 'B':        /* Buffer size */
1102 #endif
1103 #ifdef HAVE_LIBPCAP
1104       exit_status = capture_opts_add_opt(&global_capture_opts, opt, optarg, &start_capture);
1105       if (exit_status != 0) {
1106         goto clean_exit;
1107       }
1108 #else
1109       if (opt == 'w') {
1110         /*
1111          * Output file name, if we're reading a file and writing to another
1112          * file.
1113          */
1114         output_file_name = optarg;
1115       } else {
1116         capture_option_specified = TRUE;
1117         arg_error = TRUE;
1118       }
1119 #endif
1120       break;
1121     case 'C':
1122       /* already processed; just ignore it now */
1123       break;
1124     case 'D':        /* Print a list of capture devices and exit */
1125 #ifdef HAVE_LIBPCAP
1126       if_list = capture_interface_list(&err, &err_str,NULL);
1127       if (if_list == NULL) {
1128         if (err == 0)
1129           cmdarg_err("There are no interfaces on which a capture can be done");
1130         else {
1131           cmdarg_err("%s", err_str);
1132           g_free(err_str);
1133         }
1134         exit_status = INVALID_INTERFACE;
1135         goto clean_exit;
1136       }
1137       capture_opts_print_interfaces(if_list);
1138       free_interface_list(if_list);
1139       exit_status = EXIT_SUCCESS;
1140       goto clean_exit;
1141 #else
1142       capture_option_specified = TRUE;
1143       arg_error = TRUE;
1144 #endif
1145       break;
1146     case 'e':
1147       /* Field entry */
1148       output_fields_add(output_fields, optarg);
1149       break;
1150     case 'E':
1151       /* Field option */
1152       if (!output_fields_set_option(output_fields, optarg)) {
1153         cmdarg_err("\"%s\" is not a valid field output option=value pair.", optarg);
1154         output_fields_list_options(stderr);
1155         exit_status = INVALID_OPTION;
1156         goto clean_exit;
1157       }
1158       break;
1159     case 'F':
1160       out_file_type = wtap_short_string_to_file_type_subtype(optarg);
1161       if (out_file_type < 0) {
1162         cmdarg_err("\"%s\" isn't a valid capture file type", optarg);
1163         list_capture_types();
1164         exit_status = INVALID_OPTION;
1165         goto clean_exit;
1166       }
1167       break;
1168     case 'j':
1169       protocolfilter = wmem_strsplit(wmem_epan_scope(), optarg, " ", -1);
1170       break;
1171     case 'J':
1172       protocolfilter_flags = PF_INCLUDE_CHILDREN;
1173       protocolfilter = wmem_strsplit(wmem_epan_scope(), optarg, " ", -1);
1174       break;
1175     case 'W':        /* Select extra information to save in our capture file */
1176       /* This is patterned after the -N flag which may not be the best idea. */
1177       if (strchr(optarg, 'n')) {
1178         out_file_name_res = TRUE;
1179       } else {
1180         cmdarg_err("Invalid -W argument \"%s\"; it must be one of:", optarg);
1181         cmdarg_err_cont("\t'n' write network address resolution information (pcapng only)");
1182         exit_status = INVALID_OPTION;
1183         goto clean_exit;
1184       }
1185       break;
1186     case 'H':        /* Read address to name mappings from a hosts file */
1187       if (! add_hosts_file(optarg))
1188       {
1189         cmdarg_err("Can't read host entries from \"%s\"", optarg);
1190         exit_status = INVALID_OPTION;
1191         goto clean_exit;
1192       }
1193       out_file_name_res = TRUE;
1194       break;
1195
1196     case 'h':        /* Print help and exit */
1197       printf("TShark (Wireshark) %s\n"
1198              "Dump and analyze network traffic.\n"
1199              "See https://www.wireshark.org for more information.\n",
1200              get_ws_vcs_version_info());
1201       print_usage(stdout);
1202       exit_status = EXIT_SUCCESS;
1203       goto clean_exit;
1204       break;
1205     case 'l':        /* "Line-buffer" standard output */
1206       /* The ANSI C standard does not appear to *require* that a line-buffered
1207          stream be flushed to the host environment whenever a newline is
1208          written, it just says that, on such a stream, characters "are
1209          intended to be transmitted to or from the host environment as a
1210          block when a new-line character is encountered".
1211
1212          The Visual C++ 6.0 C implementation doesn't do what is intended;
1213          even if you set a stream to be line-buffered, it still doesn't
1214          flush the buffer at the end of every line.
1215
1216          The whole reason for the "-l" flag in either tcpdump or TShark
1217          is to allow the output of a live capture to be piped to a program
1218          or script and to have that script see the information for the
1219          packet as soon as it's printed, rather than having to wait until
1220          a standard I/O buffer fills up.
1221
1222          So, if the "-l" flag is specified, we flush the standard output
1223          at the end of a packet.  This will do the right thing if we're
1224          printing packet summary lines, and, as we print the entire protocol
1225          tree for a single packet without waiting for anything to happen,
1226          it should be as good as line-buffered mode if we're printing
1227          protocol trees - arguably even better, as it may do fewer
1228          writes. */
1229       line_buffered = TRUE;
1230       break;
1231     case 'L':        /* Print list of link-layer types and exit */
1232 #ifdef HAVE_LIBPCAP
1233       caps_queries |= CAPS_QUERY_LINK_TYPES;
1234 #else
1235       capture_option_specified = TRUE;
1236       arg_error = TRUE;
1237 #endif
1238       break;
1239     case LONGOPT_LIST_TSTAMP_TYPES: /* List possible timestamp types */
1240 #ifdef HAVE_LIBPCAP
1241       caps_queries |= CAPS_QUERY_TIMESTAMP_TYPES;
1242 #else
1243       capture_option_specified = TRUE;
1244       arg_error = TRUE;
1245 #endif
1246       break;
1247     case 'o':        /* Override preference from command line */
1248     {
1249       char *errmsg = NULL;
1250
1251       switch (prefs_set_pref(optarg, &errmsg)) {
1252
1253       case PREFS_SET_OK:
1254         break;
1255
1256       case PREFS_SET_SYNTAX_ERR:
1257         cmdarg_err("Invalid -o flag \"%s\"%s%s", optarg,
1258             errmsg ? ": " : "", errmsg ? errmsg : "");
1259         g_free(errmsg);
1260         exit_status = INVALID_OPTION;
1261         goto clean_exit;
1262         break;
1263
1264       case PREFS_SET_NO_SUCH_PREF:
1265       case PREFS_SET_OBSOLETE:
1266         cmdarg_err("-o flag \"%s\" specifies unknown preference", optarg);
1267         exit_status = INVALID_OPTION;
1268         goto clean_exit;
1269         break;
1270       }
1271       break;
1272     }
1273     case 'q':        /* Quiet */
1274       quiet = TRUE;
1275       break;
1276     case 'Q':        /* Really quiet */
1277       quiet = TRUE;
1278       really_quiet = TRUE;
1279       break;
1280     case 'r':        /* Read capture file x */
1281       cf_name = g_strdup(optarg);
1282       break;
1283     case 'R':        /* Read file filter */
1284       rfilter = optarg;
1285       break;
1286     case 'P':
1287         /* already processed; just ignore it now */
1288         break;
1289     case 'S':        /* Set the line Separator to be printed between packets */
1290       separator = optarg;
1291       break;
1292     case 'T':        /* printing Type */
1293       print_packet_info = TRUE;
1294       if (strcmp(optarg, "text") == 0) {
1295         output_action = WRITE_TEXT;
1296         print_format = PR_FMT_TEXT;
1297       } else if (strcmp(optarg, "tabs") == 0) {
1298         output_action = WRITE_TEXT;
1299         print_format = PR_FMT_TEXT;
1300         delimiter_char = "\t";
1301       } else if (strcmp(optarg, "ps") == 0) {
1302         output_action = WRITE_TEXT;
1303         print_format = PR_FMT_PS;
1304       } else if (strcmp(optarg, "pdml") == 0) {
1305         output_action = WRITE_XML;
1306         print_details = TRUE;   /* Need details */
1307         print_summary = FALSE;  /* Don't allow summary */
1308       } else if (strcmp(optarg, "psml") == 0) {
1309         output_action = WRITE_XML;
1310         print_details = FALSE;  /* Don't allow details */
1311         print_summary = TRUE;   /* Need summary */
1312       } else if (strcmp(optarg, "fields") == 0) {
1313         output_action = WRITE_FIELDS;
1314         print_details = TRUE;   /* Need full tree info */
1315         print_summary = FALSE;  /* Don't allow summary */
1316       } else if (strcmp(optarg, "json") == 0) {
1317         output_action = WRITE_JSON;
1318         print_details = TRUE;   /* Need details */
1319         print_summary = FALSE;  /* Don't allow summary */
1320       } else if (strcmp(optarg, "ek") == 0) {
1321         output_action = WRITE_EK;
1322         print_details = TRUE;   /* Need details */
1323         print_summary = FALSE;  /* Don't allow summary */
1324       } else if (strcmp(optarg, "jsonraw") == 0) {
1325         output_action = WRITE_JSON_RAW;
1326         print_details = TRUE;   /* Need details */
1327         print_summary = FALSE;  /* Don't allow summary */
1328       }
1329       else {
1330         cmdarg_err("Invalid -T parameter \"%s\"; it must be one of:", optarg);                   /* x */
1331         cmdarg_err_cont("\t\"fields\"  The values of fields specified with the -e option, in a form\n"
1332                         "\t          specified by the -E option.\n"
1333                         "\t\"pdml\"    Packet Details Markup Language, an XML-based format for the\n"
1334                         "\t          details of a decoded packet. This information is equivalent to\n"
1335                         "\t          the packet details printed with the -V flag.\n"
1336                         "\t\"ps\"      PostScript for a human-readable one-line summary of each of\n"
1337                         "\t          the packets, or a multi-line view of the details of each of\n"
1338                         "\t          the packets, depending on whether the -V flag was specified.\n"
1339                         "\t\"psml\"    Packet Summary Markup Language, an XML-based format for the\n"
1340                         "\t          summary information of a decoded packet. This information is\n"
1341                         "\t          equivalent to the information shown in the one-line summary\n"
1342                         "\t          printed by default.\n"
1343                         "\t\"json\"    Packet Summary, an JSON-based format for the details\n"
1344                         "\t          summary information of a decoded packet. This information is \n"
1345                         "\t          equivalent to the packet details printed with the -V flag.\n"
1346                         "\t\"jsonraw\" Packet Details, a JSON-based format for machine parsing\n"
1347                         "\t          including only raw hex decoded fields (same as -T json -x but\n"
1348                         "\t          without text decoding, only raw fields included). \n"
1349                         "\t\"ek\"      Packet Details, an EK JSON-based format for the bulk insert \n"
1350                         "\t          into elastic search cluster. This information is \n"
1351                         "\t          equivalent to the packet details printed with the -V flag.\n"
1352                         "\t\"text\"    Text of a human-readable one-line summary of each of the\n"
1353                         "\t          packets, or a multi-line view of the details of each of the\n"
1354                         "\t          packets, depending on whether the -V flag was specified.\n"
1355                         "\t          This is the default.\n"
1356                         "\t\"tabs\"    Similar to the text report except that each column of the\n"
1357                         "\t          human-readable one-line summary is delimited with an ASCII\n"
1358                         "\t          horizontal tab character.");
1359         exit_status = INVALID_OPTION;
1360         goto clean_exit;
1361       }
1362       break;
1363     case 'U':        /* Export PDUs to file */
1364     {
1365         GSList *export_pdu_tap_name_list = NULL;
1366
1367         if (!*optarg) {
1368             cmdarg_err("A tap name is required. Valid names are:");
1369             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)) {
1370                 cmdarg_err("%s\n", (const char*)(export_pdu_tap_name_list->data));
1371             }
1372             exit_status = INVALID_OPTION;
1373             goto clean_exit;
1374         }
1375         pdu_export_arg = g_strdup(optarg);
1376         break;
1377     }
1378     case 'v':         /* Show version and exit */
1379       comp_info_str = get_compiled_version_info(get_tshark_compiled_version_info,
1380                                                 epan_get_compiled_version_info);
1381       runtime_info_str = get_runtime_version_info(get_tshark_runtime_version_info);
1382       show_version("TShark (Wireshark)", comp_info_str, runtime_info_str);
1383       g_string_free(comp_info_str, TRUE);
1384       g_string_free(runtime_info_str, TRUE);
1385       /* We don't really have to cleanup here, but it's a convenient way to test
1386        * start-up and shut-down of the epan library without any UI-specific
1387        * cruft getting in the way. Makes the results of running
1388        * $ ./tools/valgrind-wireshark -n
1389        * much more useful. */
1390       epan_cleanup();
1391 #ifdef HAVE_EXTCAP
1392       extcap_cleanup();
1393 #endif
1394       exit_status = EXIT_SUCCESS;
1395       goto clean_exit;
1396     case 'O':        /* Only output these protocols */
1397       /* already processed; just ignore it now */
1398       break;
1399     case 'V':        /* Verbose */
1400       /* already processed; just ignore it now */
1401       break;
1402     case 'x':        /* Print packet data in hex (and ASCII) */
1403       /* already processed; just ignore it now */
1404       break;
1405     case 'X':
1406       /* already processed; just ignore it now */
1407       break;
1408     case 'Y':
1409       dfilter = optarg;
1410       break;
1411     case 'z':
1412       /* We won't call the init function for the stat this soon
1413          as it would disallow MATE's fields (which are registered
1414          by the preferences set callback) from being used as
1415          part of a tap filter.  Instead, we just add the argument
1416          to a list of stat arguments. */
1417       if (strcmp("help", optarg) == 0) {
1418         fprintf(stderr, "tshark: The available statistics for the \"-z\" option are:\n");
1419         list_stat_cmd_args();
1420         exit_status = EXIT_SUCCESS;
1421         goto clean_exit;
1422       }
1423       if (!process_stat_cmd_arg(optarg)) {
1424         cmdarg_err("Invalid -z argument \"%s\"; it must be one of:", optarg);
1425         list_stat_cmd_args();
1426         exit_status = INVALID_OPTION;
1427         goto clean_exit;
1428       }
1429       break;
1430     case 'd':        /* Decode as rule */
1431     case 'K':        /* Kerberos keytab file */
1432     case 'n':        /* No name resolution */
1433     case 'N':        /* Select what types of addresses/port #s to resolve */
1434     case 't':        /* Time stamp type */
1435     case 'u':        /* Seconds type */
1436     case LONGOPT_DISABLE_PROTOCOL: /* disable dissection of protocol */
1437     case LONGOPT_ENABLE_HEURISTIC: /* enable heuristic dissection of protocol */
1438     case LONGOPT_DISABLE_HEURISTIC: /* disable heuristic dissection of protocol */
1439     case LONGOPT_ENABLE_PROTOCOL: /* enable dissection of protocol (that is disabled by default) */
1440       if (!dissect_opts_handle_opt(opt, optarg)) {
1441         exit_status = INVALID_OPTION;
1442         goto clean_exit;
1443       }
1444       break;
1445     case LONGOPT_EXPORT_OBJECTS:   /* --export-objects */
1446       if (strcmp("help", optarg) == 0) {
1447         fprintf(stderr, "tshark: The available export object types for the \"--export-objects\" option are:\n");
1448         eo_list_object_types();
1449         exit_status = EXIT_SUCCESS;
1450         goto clean_exit;
1451       }
1452       if (!eo_tap_opt_add(optarg)) {
1453         exit_status = INVALID_OPTION;
1454         goto clean_exit;
1455       }
1456       break;
1457     case LONGOPT_COLOR: /* print in color where appropriate */
1458       dissect_color = TRUE;
1459       break;
1460     case LONGOPT_NO_DUPLICATE_KEYS:
1461       no_duplicate_keys = TRUE;
1462       node_children_grouper = proto_node_group_children_by_json_key;
1463       break;
1464     default:
1465     case '?':        /* Bad flag - print usage message */
1466       switch(optopt) {
1467       case 'F':
1468         list_capture_types();
1469         break;
1470       default:
1471         print_usage(stderr);
1472       }
1473       exit_status = INVALID_OPTION;
1474       goto clean_exit;
1475       break;
1476     }
1477   }
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(void *data, guint32 frame_num)
2350 {
2351   capture_file *cf = (capture_file *) data;
2352
2353   if (ref && ref->num == frame_num)
2354     return &ref->abs_ts;
2355
2356   if (prev_dis && prev_dis->num == frame_num)
2357     return &prev_dis->abs_ts;
2358
2359   if (prev_cap && prev_cap->num == frame_num)
2360     return &prev_cap->abs_ts;
2361
2362   if (cf->frames) {
2363      frame_data *fd = frame_data_sequence_find(cf->frames, frame_num);
2364
2365      return (fd) ? &fd->abs_ts : NULL;
2366   }
2367
2368   return NULL;
2369 }
2370
2371 static epan_t *
2372 tshark_epan_new(capture_file *cf)
2373 {
2374   epan_t *epan = epan_new();
2375
2376   epan->data = cf;
2377   epan->get_frame_ts = tshark_get_frame_ts;
2378   epan->get_interface_name = cap_file_get_interface_name;
2379   epan->get_interface_description = cap_file_get_interface_description;
2380   epan->get_user_comment = NULL;
2381
2382   return epan;
2383 }
2384
2385 #ifdef HAVE_LIBPCAP
2386 static gboolean
2387 capture(void)
2388 {
2389   gboolean          ret;
2390   guint             i;
2391   GString          *str;
2392 #ifdef USE_TSHARK_SELECT
2393   fd_set            readfds;
2394 #endif
2395 #ifndef _WIN32
2396   struct sigaction  action, oldaction;
2397 #endif
2398
2399   /* Create new dissection section. */
2400   epan_free(cfile.epan);
2401   cfile.epan = tshark_epan_new(&cfile);
2402
2403 #ifdef _WIN32
2404   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
2405   SetConsoleCtrlHandler(capture_cleanup, TRUE);
2406 #else /* _WIN32 */
2407   /* Catch SIGINT and SIGTERM and, if we get either of them,
2408      clean up and exit.  If SIGHUP isn't being ignored, catch
2409      it too and, if we get it, clean up and exit.
2410
2411      We restart any read that was in progress, so that it doesn't
2412      disrupt reading from the sync pipe.  The signal handler tells
2413      the capture child to finish; it will report that it finished,
2414      or will exit abnormally, so  we'll stop reading from the sync
2415      pipe, pick up the exit status, and quit. */
2416   memset(&action, 0, sizeof(action));
2417   action.sa_handler = capture_cleanup;
2418   action.sa_flags = SA_RESTART;
2419   sigemptyset(&action.sa_mask);
2420   sigaction(SIGTERM, &action, NULL);
2421   sigaction(SIGINT, &action, NULL);
2422   sigaction(SIGHUP, NULL, &oldaction);
2423   if (oldaction.sa_handler == SIG_DFL)
2424     sigaction(SIGHUP, &action, NULL);
2425
2426 #ifdef SIGINFO
2427   /* Catch SIGINFO and, if we get it and we're capturing to a file in
2428      quiet mode, report the number of packets we've captured.
2429
2430      Again, restart any read that was in progress, so that it doesn't
2431      disrupt reading from the sync pipe. */
2432   action.sa_handler = report_counts_siginfo;
2433   action.sa_flags = SA_RESTART;
2434   sigemptyset(&action.sa_mask);
2435   sigaction(SIGINFO, &action, NULL);
2436 #endif /* SIGINFO */
2437 #endif /* _WIN32 */
2438
2439   global_capture_session.state = CAPTURE_PREPARING;
2440
2441   /* Let the user know which interfaces were chosen. */
2442   for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2443     interface_options *interface_opts;
2444
2445     interface_opts = &g_array_index(global_capture_opts.ifaces, interface_options, i);
2446     interface_opts->descr = get_interface_descriptive_name(interface_opts->name);
2447   }
2448   str = get_iface_list_string(&global_capture_opts, IFLIST_QUOTE_IF_DESCRIPTION);
2449   if (really_quiet == FALSE)
2450     fprintf(stderr, "Capturing on %s\n", str->str);
2451   fflush(stderr);
2452   g_string_free(str, TRUE);
2453
2454   ret = sync_pipe_start(&global_capture_opts, &global_capture_session, &global_info_data, NULL);
2455
2456   if (!ret)
2457     return FALSE;
2458
2459   /* the actual capture loop
2460    *
2461    * XXX - glib doesn't seem to provide any event based loop handling.
2462    *
2463    * XXX - for whatever reason,
2464    * calling g_main_loop_new() ends up in 100% cpu load.
2465    *
2466    * But that doesn't matter: in UNIX we can use select() to find an input
2467    * source with something to do.
2468    *
2469    * But that doesn't matter because we're in a CLI (that doesn't need to
2470    * update a GUI or something at the same time) so it's OK if we block
2471    * trying to read from the pipe.
2472    *
2473    * So all the stuff in USE_TSHARK_SELECT could be removed unless I'm
2474    * wrong (but I leave it there in case I am...).
2475    */
2476
2477 #ifdef USE_TSHARK_SELECT
2478   FD_ZERO(&readfds);
2479   FD_SET(pipe_input.source, &readfds);
2480 #endif
2481
2482   loop_running = TRUE;
2483
2484   TRY
2485   {
2486     while (loop_running)
2487     {
2488 #ifdef USE_TSHARK_SELECT
2489       ret = select(pipe_input.source+1, &readfds, NULL, NULL, NULL);
2490
2491       if (ret == -1)
2492       {
2493         fprintf(stderr, "%s: %s\n", "select()", g_strerror(errno));
2494         return TRUE;
2495       } else if (ret == 1) {
2496 #endif
2497         /* Call the real handler */
2498         if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
2499           g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
2500           return FALSE;
2501         }
2502 #ifdef USE_TSHARK_SELECT
2503       }
2504 #endif
2505     }
2506   }
2507   CATCH(OutOfMemoryError) {
2508     fprintf(stderr,
2509             "Out Of Memory.\n"
2510             "\n"
2511             "Sorry, but TShark has to terminate now.\n"
2512             "\n"
2513             "More information and workarounds can be found at\n"
2514             "https://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2515     exit(1);
2516   }
2517   ENDTRY;
2518   return TRUE;
2519 }
2520
2521 /* capture child detected an error */
2522 void
2523 capture_input_error_message(capture_session *cap_session _U_, char *error_msg, char *secondary_error_msg)
2524 {
2525   cmdarg_err("%s", error_msg);
2526   cmdarg_err_cont("%s", secondary_error_msg);
2527 }
2528
2529
2530 /* capture child detected an capture filter related error */
2531 void
2532 capture_input_cfilter_error_message(capture_session *cap_session, guint i, char *error_message)
2533 {
2534   capture_options *capture_opts = cap_session->capture_opts;
2535   dfilter_t         *rfcode = NULL;
2536   interface_options *interface_opts;
2537
2538   g_assert(i < capture_opts->ifaces->len);
2539   interface_opts = &g_array_index(capture_opts->ifaces, interface_options, i);
2540
2541   if (dfilter_compile(interface_opts->cfilter, &rfcode, NULL) && rfcode != NULL) {
2542     cmdarg_err(
2543       "Invalid capture filter \"%s\" for interface '%s'.\n"
2544       "\n"
2545       "That string looks like a valid display filter; however, it isn't a valid\n"
2546       "capture filter (%s).\n"
2547       "\n"
2548       "Note that display filters and capture filters don't have the same syntax,\n"
2549       "so you can't use most display filter expressions as capture filters.\n"
2550       "\n"
2551       "See the User's Guide for a description of the capture filter syntax.",
2552       interface_opts->cfilter, interface_opts->descr, error_message);
2553     dfilter_free(rfcode);
2554   } else {
2555     cmdarg_err(
2556       "Invalid capture filter \"%s\" for interface '%s'.\n"
2557       "\n"
2558       "That string isn't a valid capture filter (%s).\n"
2559       "See the User's Guide for a description of the capture filter syntax.",
2560       interface_opts->cfilter, interface_opts->descr, error_message);
2561   }
2562 }
2563
2564
2565 /* capture child tells us we have a new (or the first) capture file */
2566 gboolean
2567 capture_input_new_file(capture_session *cap_session, gchar *new_file)
2568 {
2569   capture_options *capture_opts = cap_session->capture_opts;
2570   capture_file *cf = (capture_file *) cap_session->cf;
2571   gboolean is_tempfile;
2572   int      err;
2573
2574   if (cap_session->state == CAPTURE_PREPARING) {
2575     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started.");
2576   }
2577   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
2578
2579   g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
2580
2581   /* free the old filename */
2582   if (capture_opts->save_file != NULL) {
2583
2584     /* we start a new capture file, close the old one (if we had one before) */
2585     if (cf->state != FILE_CLOSED) {
2586       if (cf->wth != NULL) {
2587         wtap_close(cf->wth);
2588         cf->wth = NULL;
2589       }
2590       cf->state = FILE_CLOSED;
2591     }
2592
2593     g_free(capture_opts->save_file);
2594     is_tempfile = FALSE;
2595
2596     epan_free(cf->epan);
2597     cf->epan = tshark_epan_new(cf);
2598   } else {
2599     /* we didn't had a save_file before, must be a tempfile */
2600     is_tempfile = TRUE;
2601   }
2602
2603   /* save the new filename */
2604   capture_opts->save_file = g_strdup(new_file);
2605
2606   /* if we are in real-time mode, open the new file now */
2607   if (do_dissection) {
2608     /* this is probably unecessary, but better safe than sorry */
2609     ((capture_file *)cap_session->cf)->open_type = WTAP_TYPE_AUTO;
2610     /* Attempt to open the capture file and set up to read from it. */
2611     switch(cf_open((capture_file *)cap_session->cf, capture_opts->save_file, WTAP_TYPE_AUTO, is_tempfile, &err)) {
2612     case CF_OK:
2613       break;
2614     case CF_ERROR:
2615       /* Don't unlink (delete) the save file - leave it around,
2616          for debugging purposes. */
2617       g_free(capture_opts->save_file);
2618       capture_opts->save_file = NULL;
2619       return FALSE;
2620     }
2621   }
2622
2623   cap_session->state = CAPTURE_RUNNING;
2624
2625   return TRUE;
2626 }
2627
2628
2629 /* capture child tells us we have new packets to read */
2630 void
2631 capture_input_new_packets(capture_session *cap_session, int to_read)
2632 {
2633   gboolean      ret;
2634   int           err;
2635   gchar        *err_info;
2636   gint64        data_offset;
2637   capture_file *cf = (capture_file *)cap_session->cf;
2638   gboolean      filtering_tap_listeners;
2639   guint         tap_flags;
2640
2641 #ifdef SIGINFO
2642   /*
2643    * Prevent a SIGINFO handler from writing to the standard error while
2644    * we're doing so or writing to the standard output; instead, have it
2645    * just set a flag telling us to print that information when we're done.
2646    */
2647   infodelay = TRUE;
2648 #endif /* SIGINFO */
2649
2650   /* Do we have any tap listeners with filters? */
2651   filtering_tap_listeners = have_filtering_tap_listeners();
2652
2653   /* Get the union of the flags for all tap listeners. */
2654   tap_flags = union_of_tap_listener_flags();
2655
2656   if (do_dissection) {
2657     gboolean create_proto_tree;
2658     epan_dissect_t *edt;
2659
2660     /*
2661      * Determine whether we need to create a protocol tree.
2662      * We do if:
2663      *
2664      *    we're going to apply a read filter;
2665      *
2666      *    we're going to apply a display filter;
2667      *
2668      *    we're going to print the protocol tree;
2669      *
2670      *    one of the tap listeners is going to apply a filter;
2671      *
2672      *    one of the tap listeners requires a protocol tree;
2673      *
2674      *    a postdissector wants field values or protocols
2675      *    on the first pass;
2676      *
2677      *    we have custom columns (which require field values, which
2678      *    currently requires that we build a protocol tree).
2679      */
2680     create_proto_tree =
2681       (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
2682         (tap_flags & TL_REQUIRES_PROTO_TREE) || postdissectors_want_hfids() ||
2683         have_custom_cols(&cf->cinfo) || dissect_color);
2684
2685     /* The protocol tree will be "visible", i.e., printed, only if we're
2686        printing packet details, which is true if we're printing stuff
2687        ("print_packet_info" is true) and we're in verbose mode
2688        ("packet_details" is true). */
2689     edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
2690
2691     while (to_read-- && cf->wth) {
2692       wtap_cleareof(cf->wth);
2693       ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
2694       reset_epan_mem(cf, edt, create_proto_tree, print_packet_info && print_details);
2695       if (ret == FALSE) {
2696         /* read from file failed, tell the capture child to stop */
2697         sync_pipe_stop(cap_session);
2698         wtap_close(cf->wth);
2699         cf->wth = NULL;
2700       } else {
2701         ret = process_packet_single_pass(cf, edt, data_offset,
2702                                          wtap_phdr(cf->wth),
2703                                          wtap_buf_ptr(cf->wth), tap_flags);
2704       }
2705       if (ret != FALSE) {
2706         /* packet successfully read and gone through the "Read Filter" */
2707         packet_count++;
2708       }
2709     }
2710
2711     epan_dissect_free(edt);
2712
2713   } else {
2714     /*
2715      * Dumpcap's doing all the work; we're not doing any dissection.
2716      * Count all the packets it wrote.
2717      */
2718     packet_count += to_read;
2719   }
2720
2721   if (print_packet_counts) {
2722       /* We're printing packet counts. */
2723       if (packet_count != 0) {
2724         fprintf(stderr, "\r%u ", packet_count);
2725         /* stderr could be line buffered */
2726         fflush(stderr);
2727       }
2728   }
2729
2730 #ifdef SIGINFO
2731   /*
2732    * Allow SIGINFO handlers to write.
2733    */
2734   infodelay = FALSE;
2735
2736   /*
2737    * If a SIGINFO handler asked us to write out capture counts, do so.
2738    */
2739   if (infoprint)
2740     report_counts();
2741 #endif /* SIGINFO */
2742 }
2743
2744 static void
2745 report_counts(void)
2746 {
2747   if ((print_packet_counts == FALSE) && (really_quiet == FALSE)) {
2748     /* Report the count only if we aren't printing a packet count
2749        as packets arrive. */
2750       fprintf(stderr, "%u packet%s captured\n", packet_count,
2751             plurality(packet_count, "", "s"));
2752   }
2753 #ifdef SIGINFO
2754   infoprint = FALSE; /* we just reported it */
2755 #endif /* SIGINFO */
2756 }
2757
2758 #ifdef SIGINFO
2759 static void
2760 report_counts_siginfo(int signum _U_)
2761 {
2762   int sav_errno = errno;
2763   /* If we've been told to delay printing, just set a flag asking
2764      that we print counts (if we're supposed to), otherwise print
2765      the count of packets captured (if we're supposed to). */
2766   if (infodelay)
2767     infoprint = TRUE;
2768   else
2769     report_counts();
2770   errno = sav_errno;
2771 }
2772 #endif /* SIGINFO */
2773
2774
2775 /* capture child detected any packet drops? */
2776 void
2777 capture_input_drops(capture_session *cap_session _U_, guint32 dropped)
2778 {
2779   if (print_packet_counts) {
2780     /* We're printing packet counts to stderr.
2781        Send a newline so that we move to the line after the packet count. */
2782     fprintf(stderr, "\n");
2783   }
2784
2785   if (dropped != 0) {
2786     /* We're printing packet counts to stderr.
2787        Send a newline so that we move to the line after the packet count. */
2788     fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2789   }
2790 }
2791
2792
2793 /*
2794  * Capture child closed its side of the pipe, report any error and
2795  * do the required cleanup.
2796  */
2797 void
2798 capture_input_closed(capture_session *cap_session, gchar *msg)
2799 {
2800   capture_file *cf = (capture_file *) cap_session->cf;
2801
2802   if (msg != NULL)
2803     fprintf(stderr, "tshark: %s\n", msg);
2804
2805   report_counts();
2806
2807   if (cf != NULL && cf->wth != NULL) {
2808     wtap_close(cf->wth);
2809     if (cf->is_tempfile) {
2810       ws_unlink(cf->filename);
2811     }
2812   }
2813 #ifdef USE_BROKEN_G_MAIN_LOOP
2814   /*g_main_loop_quit(loop);*/
2815   g_main_loop_quit(loop);
2816 #else
2817   loop_running = FALSE;
2818 #endif
2819 }
2820
2821
2822
2823
2824 #ifdef _WIN32
2825 static BOOL WINAPI
2826 capture_cleanup(DWORD ctrltype _U_)
2827 {
2828   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2829      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2830      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2831      like SIGTERM at least when the machine's shutting down.
2832
2833      For now, we handle them all as indications that we should clean up
2834      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2835      way on UNIX.
2836
2837      We must return TRUE so that no other handler - such as one that would
2838      terminate the process - gets called.
2839
2840      XXX - for some reason, typing ^C to TShark, if you run this in
2841      a Cygwin console window in at least some versions of Cygwin,
2842      causes TShark to terminate immediately; this routine gets
2843      called, but the main loop doesn't get a chance to run and
2844      exit cleanly, at least if this is compiled with Microsoft Visual
2845      C++ (i.e., it's a property of the Cygwin console window or Bash;
2846      it happens if TShark is not built with Cygwin - for all I know,
2847      building it with Cygwin may make the problem go away). */
2848
2849   /* tell the capture child to stop */
2850   sync_pipe_stop(&global_capture_session);
2851
2852   /* don't stop our own loop already here, otherwise status messages and
2853    * cleanup wouldn't be done properly. The child will indicate the stop of
2854    * everything by calling capture_input_closed() later */
2855
2856   return TRUE;
2857 }
2858 #else
2859 static void
2860 capture_cleanup(int signum _U_)
2861 {
2862   /* tell the capture child to stop */
2863   sync_pipe_stop(&global_capture_session);
2864
2865   /* don't stop our own loop already here, otherwise status messages and
2866    * cleanup wouldn't be done properly. The child will indicate the stop of
2867    * everything by calling capture_input_closed() later */
2868 }
2869 #endif /* _WIN32 */
2870 #endif /* HAVE_LIBPCAP */
2871
2872 static gboolean
2873 process_packet_first_pass(capture_file *cf, epan_dissect_t *edt,
2874                           gint64 offset, struct wtap_pkthdr *whdr,
2875                           const guchar *pd)
2876 {
2877   frame_data     fdlocal;
2878   guint32        framenum;
2879   gboolean       passed;
2880
2881   /* The frame number of this packet is one more than the count of
2882      frames in this packet. */
2883   framenum = cf->count + 1;
2884
2885   /* If we're not running a display filter and we're not printing any
2886      packet information, we don't need to do a dissection. This means
2887      that all packets can be marked as 'passed'. */
2888   passed = TRUE;
2889
2890   frame_data_init(&fdlocal, framenum, whdr, offset, cum_bytes);
2891
2892   /* If we're going to run a read filter or a display filter, set up to
2893      do a dissection and do so.  (This is the first pass of two passes
2894      over the packets, so we will not be printing any information
2895      from the dissection or running taps on the packet; if we're doing
2896      any of that, we'll do it in the second pass.) */
2897   if (edt) {
2898     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2899         gbl_resolv_flags.transport_name)
2900       /* Grab any resolved addresses */
2901       host_name_lookup_process();
2902
2903     /* If we're running a read filter, prime the epan_dissect_t with that
2904        filter. */
2905     if (cf->rfcode)
2906       epan_dissect_prime_with_dfilter(edt, cf->rfcode);
2907
2908     if (cf->dfcode)
2909       epan_dissect_prime_with_dfilter(edt, cf->dfcode);
2910
2911     /* This is the first pass, so prime the epan_dissect_t with the
2912        hfids postdissectors want on the first pass. */
2913     prime_epan_dissect_with_postdissector_wanted_hfids(edt);
2914
2915     frame_data_set_before_dissect(&fdlocal, &cf->elapsed_time,
2916                                   &ref, prev_dis);
2917     if (ref == &fdlocal) {
2918       ref_frame = fdlocal;
2919       ref = &ref_frame;
2920     }
2921
2922     epan_dissect_run(edt, cf->cd_t, whdr, frame_tvbuff_new(&fdlocal, pd), &fdlocal, NULL);
2923
2924     /* Run the read filter if we have one. */
2925     if (cf->rfcode)
2926       passed = dfilter_apply_edt(cf->rfcode, edt);
2927   }
2928
2929   if (passed) {
2930     frame_data_set_after_dissect(&fdlocal, &cum_bytes);
2931     prev_cap = prev_dis = frame_data_sequence_add(cf->frames, &fdlocal);
2932
2933     /* If we're not doing dissection then there won't be any dependent frames.
2934      * More importantly, edt.pi.dependent_frames won't be initialized because
2935      * epan hasn't been initialized.
2936      * if we *are* doing dissection, then mark the dependent frames, but only
2937      * if a display filter was given and it matches this packet.
2938      */
2939     if (edt && cf->dfcode) {
2940       if (dfilter_apply_edt(cf->dfcode, edt)) {
2941         g_slist_foreach(edt->pi.dependent_frames, find_and_mark_frame_depended_upon, cf->frames);
2942       }
2943     }
2944
2945     cf->count++;
2946   } else {
2947     /* if we don't add it to the frame_data_sequence, clean it up right now
2948      * to avoid leaks */
2949     frame_data_destroy(&fdlocal);
2950   }
2951
2952   if (edt)
2953     epan_dissect_reset(edt);
2954
2955   return passed;
2956 }
2957
2958 static gboolean
2959 process_packet_second_pass(capture_file *cf, epan_dissect_t *edt,
2960                            frame_data *fdata, struct wtap_pkthdr *phdr,
2961                            Buffer *buf, guint tap_flags)
2962 {
2963   column_info    *cinfo;
2964   gboolean        passed;
2965
2966   /* If we're not running a display filter and we're not printing any
2967      packet information, we don't need to do a dissection. This means
2968      that all packets can be marked as 'passed'. */
2969   passed = TRUE;
2970
2971   /* If we're going to print packet information, or we're going to
2972      run a read filter, or we're going to process taps, set up to
2973      do a dissection and do so.  (This is the second pass of two
2974      passes over the packets; that's the pass where we print
2975      packet information or run taps.) */
2976   if (edt) {
2977     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2978         gbl_resolv_flags.transport_name)
2979       /* Grab any resolved addresses */
2980       host_name_lookup_process();
2981
2982     /* If we're running a display filter, prime the epan_dissect_t with that
2983        filter. */
2984     if (cf->dfcode)
2985       epan_dissect_prime_with_dfilter(edt, cf->dfcode);
2986
2987     col_custom_prime_edt(edt, &cf->cinfo);
2988
2989     /* We only need the columns if either
2990          1) some tap needs the columns
2991        or
2992          2) we're printing packet info but we're *not* verbose; in verbose
2993             mode, we print the protocol tree, not the protocol summary.
2994      */
2995     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
2996       cinfo = &cf->cinfo;
2997     else
2998       cinfo = NULL;
2999
3000     frame_data_set_before_dissect(fdata, &cf->elapsed_time,
3001                                   &ref, prev_dis);
3002     if (ref == fdata) {
3003       ref_frame = *fdata;
3004       ref = &ref_frame;
3005     }
3006
3007     if (dissect_color) {
3008       color_filters_prime_edt(edt);
3009       fdata->flags.need_colorize = 1;
3010     }
3011
3012     epan_dissect_run_with_taps(edt, cf->cd_t, phdr, frame_tvbuff_new_buffer(fdata, buf), fdata, cinfo);
3013
3014     /* Run the read/display filter if we have one. */
3015     if (cf->dfcode)
3016       passed = dfilter_apply_edt(cf->dfcode, edt);
3017   }
3018
3019   if (passed) {
3020     frame_data_set_after_dissect(fdata, &cum_bytes);
3021     /* Process this packet. */
3022     if (print_packet_info) {
3023       /* We're printing packet information; print the information for
3024          this packet. */
3025       print_packet(cf, edt);
3026
3027       /* If we're doing "line-buffering", flush the standard output
3028          after every packet.  See the comment above, for the "-l"
3029          option, for an explanation of why we do that. */
3030       if (line_buffered)
3031         fflush(stdout);
3032
3033       if (ferror(stdout)) {
3034         show_print_file_io_error(errno);
3035         exit(2);
3036       }
3037     }
3038     prev_dis = fdata;
3039   }
3040   prev_cap = fdata;
3041
3042   if (edt) {
3043     epan_dissect_reset(edt);
3044   }
3045   return passed || fdata->flags.dependent_of_displayed;
3046 }
3047
3048 static gboolean
3049 process_cap_file(capture_file *cf, char *save_file, int out_file_type,
3050     gboolean out_file_name_res, int max_packet_count, gint64 max_byte_count)
3051 {
3052   gboolean     success = TRUE;
3053   gint         linktype;
3054   int          snapshot_length;
3055   wtap_dumper *pdh;
3056   guint32      framenum;
3057   int          err = 0, err_pass1 = 0;
3058   gchar       *err_info = NULL, *err_info_pass1 = NULL;
3059   gint64       data_offset;
3060   gboolean     filtering_tap_listeners;
3061   guint        tap_flags;
3062   GArray                      *shb_hdrs = NULL;
3063   wtapng_iface_descriptions_t *idb_inf = NULL;
3064   GArray                      *nrb_hdrs = NULL;
3065   struct wtap_pkthdr phdr;
3066   Buffer       buf;
3067   epan_dissect_t *edt = NULL;
3068   char                        *shb_user_appl;
3069
3070   wtap_phdr_init(&phdr);
3071
3072   idb_inf = wtap_file_get_idb_info(cf->wth);
3073 #ifdef PCAP_NG_DEFAULT
3074   if (idb_inf->interface_data->len > 1) {
3075     linktype = WTAP_ENCAP_PER_PACKET;
3076   } else {
3077     linktype = wtap_file_encap(cf->wth);
3078   }
3079 #else
3080   linktype = wtap_file_encap(cf->wth);
3081 #endif
3082   if (save_file != NULL) {
3083     /* Set up to write to the capture file. */
3084     snapshot_length = wtap_snapshot_length(cf->wth);
3085     if (snapshot_length == 0) {
3086       /* Snapshot length of input file not known. */
3087       snapshot_length = WTAP_MAX_PACKET_SIZE_STANDARD;
3088     }
3089     tshark_debug("tshark: snapshot_length = %d", snapshot_length);
3090
3091     shb_hdrs = wtap_file_get_shb_for_new_file(cf->wth);
3092     nrb_hdrs = wtap_file_get_nrb_for_new_file(cf->wth);
3093
3094     /* If we don't have an application name add Tshark */
3095     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) {
3096         /* this is free'd by wtap_block_free() later */
3097         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());
3098     }
3099
3100     if (linktype != WTAP_ENCAP_PER_PACKET &&
3101         out_file_type == WTAP_FILE_TYPE_SUBTYPE_PCAP) {
3102         tshark_debug("tshark: writing PCAP format to %s", save_file);
3103         if (strcmp(save_file, "-") == 0) {
3104           /* Write to the standard output. */
3105           pdh = wtap_dump_open_stdout(out_file_type, linktype,
3106               snapshot_length, FALSE /* compressed */, &err);
3107         } else {
3108           pdh = wtap_dump_open(save_file, out_file_type, linktype,
3109               snapshot_length, FALSE /* compressed */, &err);
3110         }
3111     }
3112     else {
3113         tshark_debug("tshark: writing format type %d, to %s", out_file_type, save_file);
3114         if (strcmp(save_file, "-") == 0) {
3115           /* Write to the standard output. */
3116           pdh = wtap_dump_open_stdout_ng(out_file_type, linktype,
3117               snapshot_length, FALSE /* compressed */, shb_hdrs, idb_inf, nrb_hdrs, &err);
3118         } else {
3119           pdh = wtap_dump_open_ng(save_file, out_file_type, linktype,
3120               snapshot_length, FALSE /* compressed */, shb_hdrs, idb_inf, nrb_hdrs, &err);
3121         }
3122     }
3123
3124     g_free(idb_inf);
3125     idb_inf = NULL;
3126
3127     if (pdh == NULL) {
3128       /* We couldn't set up to write to the capture file. */
3129       cfile_dump_open_failure_message("TShark", save_file, err, out_file_type);
3130       success = FALSE;
3131       goto out;
3132     }
3133   } else {
3134     /* Set up to print packet information. */
3135     if (print_packet_info) {
3136       if (!write_preamble(cf)) {
3137         show_print_file_io_error(errno);
3138         success = FALSE;
3139         goto out;
3140       }
3141     }
3142     g_free(idb_inf);
3143     idb_inf = NULL;
3144     pdh = NULL;
3145   }
3146
3147   /* Do we have any tap listeners with filters? */
3148   filtering_tap_listeners = have_filtering_tap_listeners();
3149
3150   /* Get the union of the flags for all tap listeners. */
3151   tap_flags = union_of_tap_listener_flags();
3152
3153   if (perform_two_pass_analysis) {
3154     frame_data *fdata;
3155
3156     tshark_debug("tshark: perform_two_pass_analysis, do_dissection=%s", do_dissection ? "TRUE" : "FALSE");
3157
3158     /* Allocate a frame_data_sequence for all the frames. */
3159     cf->frames = new_frame_data_sequence();
3160
3161     if (do_dissection) {
3162       gboolean create_proto_tree;
3163
3164       /*
3165        * Determine whether we need to create a protocol tree.
3166        * We do if:
3167        *
3168        *    we're going to apply a read filter;
3169        *
3170        *    we're going to apply a display filter;
3171        *
3172        *    a postdissector wants field values or protocols
3173        *    on the first pass.
3174        */
3175       create_proto_tree =
3176         (cf->rfcode != NULL || cf->dfcode != NULL || postdissectors_want_hfids() || dissect_color);
3177
3178       tshark_debug("tshark: create_proto_tree = %s", create_proto_tree ? "TRUE" : "FALSE");
3179
3180       /* We're not going to display the protocol tree on this pass,
3181          so it's not going to be "visible". */
3182       edt = epan_dissect_new(cf->epan, create_proto_tree, FALSE);
3183     }
3184
3185     tshark_debug("tshark: reading records for first pass");
3186     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
3187       if (process_packet_first_pass(cf, edt, data_offset, wtap_phdr(cf->wth),
3188                                     wtap_buf_ptr(cf->wth))) {
3189         /* Stop reading if we have the maximum number of packets;
3190          * When the -c option has not been used, max_packet_count
3191          * starts at 0, which practically means, never stop reading.
3192          * (unless we roll over max_packet_count ?)
3193          */
3194         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3195           tshark_debug("tshark: max_packet_count (%d) or max_byte_count (%" G_GINT64_MODIFIER "d/%" G_GINT64_MODIFIER "d) reached",
3196                         max_packet_count, data_offset, max_byte_count);
3197           err = 0; /* This is not an error */
3198           break;
3199         }
3200       }
3201     }
3202
3203     /*
3204      * If we got a read error on the first pass, remember the error, so
3205      * but do the second pass, so we can at least process the packets we
3206      * read, and then report the first-pass error after the second pass
3207      * (and before we report any second-pass errors), so all the the
3208      * errors show up at the end.
3209      */
3210     if (err != 0) {
3211       err_pass1 = err;
3212       err_info_pass1 = err_info;
3213       err = 0;
3214       err_info = NULL;
3215     }
3216
3217     if (edt) {
3218       epan_dissect_free(edt);
3219       edt = NULL;
3220     }
3221
3222     /* Close the sequential I/O side, to free up memory it requires. */
3223     wtap_sequential_close(cf->wth);
3224
3225     /* Allow the protocol dissectors to free up memory that they
3226      * don't need after the sequential run-through of the packets. */
3227     postseq_cleanup_all_protocols();
3228
3229     prev_dis = NULL;
3230     prev_cap = NULL;
3231     ws_buffer_init(&buf, 1500);
3232
3233     tshark_debug("tshark: done with first pass");
3234
3235     if (do_dissection) {
3236       gboolean create_proto_tree;
3237
3238       /*
3239        * Determine whether we need to create a protocol tree.
3240        * We do if:
3241        *
3242        *    we're going to apply a display filter;
3243        *
3244        *    we're going to print the protocol tree;
3245        *
3246        *    one of the tap listeners requires a protocol tree;
3247        *
3248        *    we have custom columns (which require field values, which
3249        *    currently requires that we build a protocol tree).
3250        */
3251       create_proto_tree =
3252         (cf->dfcode || print_details || filtering_tap_listeners ||
3253          (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo) || dissect_color);
3254
3255       tshark_debug("tshark: create_proto_tree = %s", create_proto_tree ? "TRUE" : "FALSE");
3256
3257       /* The protocol tree will be "visible", i.e., printed, only if we're
3258          printing packet details, which is true if we're printing stuff
3259          ("print_packet_info" is true) and we're in verbose mode
3260          ("packet_details" is true). */
3261       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
3262     }
3263
3264     for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
3265       fdata = frame_data_sequence_find(cf->frames, framenum);
3266       if (wtap_seek_read(cf->wth, fdata->file_off, &phdr, &buf, &err,
3267                          &err_info)) {
3268         tshark_debug("tshark: invoking process_packet_second_pass() for frame #%d", framenum);
3269         if (process_packet_second_pass(cf, edt, fdata, &phdr, &buf,
3270                                        tap_flags)) {
3271           /* Either there's no read filtering or this packet passed the
3272              filter, so, if we're writing to a capture file, write
3273              this packet out. */
3274           if (pdh != NULL) {
3275             tshark_debug("tshark: writing packet #%d to outfile", framenum);
3276             if (!wtap_dump(pdh, &phdr, ws_buffer_start_ptr(&buf), &err, &err_info)) {
3277               /* Error writing to a capture file */
3278               tshark_debug("tshark: error writing to a capture file (%d)", err);
3279
3280               /* Report the error.
3281                  XXX - framenum is not necessarily the frame number in
3282                  the input file if there was a read filter. */
3283               cfile_write_failure_message("TShark", cf->filename, save_file,
3284                                           err, err_info, framenum,
3285                                           out_file_type);
3286               wtap_dump_close(pdh, &err);
3287               wtap_block_array_free(shb_hdrs);
3288               wtap_block_array_free(nrb_hdrs);
3289               exit(2);
3290             }
3291           }
3292         }
3293       }
3294     }
3295
3296     if (edt) {
3297       epan_dissect_free(edt);
3298       edt = NULL;
3299     }
3300
3301     ws_buffer_free(&buf);
3302
3303     tshark_debug("tshark: done with second pass");
3304   }
3305   else {
3306     /* !perform_two_pass_analysis */
3307     framenum = 0;
3308     gboolean create_proto_tree = FALSE;
3309     tshark_debug("tshark: perform one pass analysis, do_dissection=%s", do_dissection ? "TRUE" : "FALSE");
3310
3311     if (do_dissection) {
3312       /*
3313        * Determine whether we need to create a protocol tree.
3314        * We do if:
3315        *
3316        *    we're going to apply a read filter;
3317        *
3318        *    we're going to apply a display filter;
3319        *
3320        *    we're going to print the protocol tree;
3321        *
3322        *    one of the tap listeners is going to apply a filter;
3323        *
3324        *    one of the tap listeners requires a protocol tree;
3325        *
3326        *    a postdissector wants field values or protocols
3327        *    on the first pass;
3328        *
3329        *    we have custom columns (which require field values, which
3330        *    currently requires that we build a protocol tree).
3331        */
3332       create_proto_tree =
3333         (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
3334           (tap_flags & TL_REQUIRES_PROTO_TREE) || postdissectors_want_hfids() ||
3335           have_custom_cols(&cf->cinfo) || dissect_color);
3336
3337       tshark_debug("tshark: create_proto_tree = %s", create_proto_tree ? "TRUE" : "FALSE");
3338
3339       /* The protocol tree will be "visible", i.e., printed, only if we're
3340          printing packet details, which is true if we're printing stuff
3341          ("print_packet_info" is true) and we're in verbose mode
3342          ("packet_details" is true). */
3343       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
3344     }
3345
3346     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
3347       framenum++;
3348
3349       tshark_debug("tshark: processing packet #%d", framenum);
3350
3351       reset_epan_mem(cf, edt, create_proto_tree, print_packet_info && print_details);
3352
3353       if (process_packet_single_pass(cf, edt, data_offset, wtap_phdr(cf->wth),
3354                                      wtap_buf_ptr(cf->wth), tap_flags)) {
3355         /* Either there's no read filtering or this packet passed the
3356            filter, so, if we're writing to a capture file, write
3357            this packet out. */
3358         if (pdh != NULL) {
3359           tshark_debug("tshark: writing packet #%d to outfile", framenum);
3360           if (!wtap_dump(pdh, wtap_phdr(cf->wth), wtap_buf_ptr(cf->wth), &err, &err_info)) {
3361             /* Error writing to a capture file */
3362             tshark_debug("tshark: error writing to a capture file (%d)", err);
3363             cfile_write_failure_message("TShark", cf->filename, save_file,
3364                                         err, err_info, framenum, out_file_type);
3365             wtap_dump_close(pdh, &err);
3366             wtap_block_array_free(shb_hdrs);
3367             wtap_block_array_free(nrb_hdrs);
3368             exit(2);
3369           }
3370         }
3371       }
3372       /* Stop reading if we have the maximum number of packets;
3373        * When the -c option has not been used, max_packet_count
3374        * starts at 0, which practically means, never stop reading.
3375        * (unless we roll over max_packet_count ?)
3376        */
3377       if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3378         tshark_debug("tshark: max_packet_count (%d) or max_byte_count (%" G_GINT64_MODIFIER "d/%" G_GINT64_MODIFIER "d) reached",
3379                       max_packet_count, data_offset, max_byte_count);
3380         err = 0; /* This is not an error */
3381         break;
3382       }
3383     }
3384
3385     if (edt) {
3386       epan_dissect_free(edt);
3387       edt = NULL;
3388     }
3389   }
3390
3391   wtap_phdr_cleanup(&phdr);
3392
3393   if (err != 0 || err_pass1 != 0) {
3394     tshark_debug("tshark: something failed along the line (%d)", err);
3395     /*
3396      * Print a message noting that the read failed somewhere along the line.
3397      *
3398      * If we're printing packet data, and the standard output and error are
3399      * going to the same place, flush the standard output, so everything
3400      * buffered up is written, and then print a newline to the standard error
3401      * before printing the error message, to separate it from the packet
3402      * data.  (Alas, that only works on UN*X; st_dev is meaningless, and
3403      * the _fstat() documentation at Microsoft doesn't indicate whether
3404      * st_ino is even supported.)
3405      */
3406 #ifndef _WIN32
3407     if (print_packet_info) {
3408       ws_statb64 stat_stdout, stat_stderr;
3409
3410       if (ws_fstat64(1, &stat_stdout) == 0 && ws_fstat64(2, &stat_stderr) == 0) {
3411         if (stat_stdout.st_dev == stat_stderr.st_dev &&
3412             stat_stdout.st_ino == stat_stderr.st_ino) {
3413           fflush(stdout);
3414           fprintf(stderr, "\n");
3415         }
3416       }
3417     }
3418 #endif
3419     if (err_pass1 != 0) {
3420       /* Error on pass 1 of two-pass processing. */
3421       cfile_read_failure_message("TShark", cf->filename, err_pass1,
3422                                  err_info_pass1);
3423     }
3424     if (err != 0) {
3425       /* Error on pass 2 of two-pass processing or on the only pass of
3426          one-pass processing. */
3427       cfile_read_failure_message("TShark", cf->filename, err, err_info);
3428     }
3429     success = FALSE;
3430   }
3431   if (save_file != NULL) {
3432     if (pdh && out_file_name_res) {
3433       if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
3434         cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
3435                    wtap_file_type_subtype_short_string(out_file_type));
3436       }
3437     }
3438     /* Now close the capture file. */
3439     if (!wtap_dump_close(pdh, &err)) {
3440       cfile_close_failure_message(save_file, err);
3441       success = FALSE;
3442     }
3443   } else {
3444     if (print_packet_info) {
3445       if (!write_finale()) {
3446         show_print_file_io_error(errno);
3447         success = FALSE;
3448       }
3449     }
3450   }
3451
3452 out:
3453   wtap_close(cf->wth);
3454   cf->wth = NULL;
3455
3456   wtap_block_array_free(shb_hdrs);
3457   wtap_block_array_free(nrb_hdrs);
3458
3459   return success;
3460 }
3461
3462 static gboolean
3463 process_packet_single_pass(capture_file *cf, epan_dissect_t *edt, gint64 offset,
3464                            struct wtap_pkthdr *whdr, const guchar *pd,
3465                            guint tap_flags)
3466 {
3467   frame_data      fdata;
3468   column_info    *cinfo;
3469   gboolean        passed;
3470
3471   /* Count this packet. */
3472   cf->count++;
3473
3474   /* If we're not running a display filter and we're not printing any
3475      packet information, we don't need to do a dissection. This means
3476      that all packets can be marked as 'passed'. */
3477   passed = TRUE;
3478
3479   frame_data_init(&fdata, cf->count, whdr, offset, cum_bytes);
3480
3481   /* If we're going to print packet information, or we're going to
3482      run a read filter, or we're going to process taps, set up to
3483      do a dissection and do so.  (This is the one and only pass
3484      over the packets, so, if we'll be printing packet information
3485      or running taps, we'll be doing it here.) */
3486   if (edt) {
3487     if (print_packet_info && (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
3488         gbl_resolv_flags.transport_name))
3489       /* Grab any resolved addresses */
3490       host_name_lookup_process();
3491
3492     /* If we're running a filter, prime the epan_dissect_t with that
3493        filter. */
3494     if (cf->dfcode)
3495       epan_dissect_prime_with_dfilter(edt, cf->dfcode);
3496
3497     /* This is the first and only pass, so prime the epan_dissect_t
3498        with the hfids postdissectors want on the first pass. */
3499     prime_epan_dissect_with_postdissector_wanted_hfids(edt);
3500
3501     col_custom_prime_edt(edt, &cf->cinfo);
3502
3503     /* We only need the columns if either
3504          1) some tap needs the columns
3505        or
3506          2) we're printing packet info but we're *not* verbose; in verbose
3507             mode, we print the protocol tree, not the protocol summary.
3508        or
3509          3) there is a column mapped as an individual field */
3510     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
3511       cinfo = &cf->cinfo;
3512     else
3513       cinfo = NULL;
3514
3515     frame_data_set_before_dissect(&fdata, &cf->elapsed_time,
3516                                   &ref, prev_dis);
3517     if (ref == &fdata) {
3518       ref_frame = fdata;
3519       ref = &ref_frame;
3520     }
3521
3522     if (dissect_color) {
3523       color_filters_prime_edt(edt);
3524       fdata.flags.need_colorize = 1;
3525     }
3526
3527     epan_dissect_run_with_taps(edt, cf->cd_t, whdr, frame_tvbuff_new(&fdata, pd), &fdata, cinfo);
3528
3529     /* Run the filter if we have it. */
3530     if (cf->dfcode)
3531       passed = dfilter_apply_edt(cf->dfcode, edt);
3532   }
3533
3534   if (passed) {
3535     frame_data_set_after_dissect(&fdata, &cum_bytes);
3536
3537     /* Process this packet. */
3538     if (print_packet_info) {
3539       /* We're printing packet information; print the information for
3540          this packet. */
3541       g_assert(edt);
3542       print_packet(cf, edt);
3543
3544       /* If we're doing "line-buffering", flush the standard output
3545          after every packet.  See the comment above, for the "-l"
3546          option, for an explanation of why we do that. */
3547       if (line_buffered)
3548         fflush(stdout);
3549
3550       if (ferror(stdout)) {
3551         show_print_file_io_error(errno);
3552         exit(2);
3553       }
3554     }
3555
3556     /* this must be set after print_packet() [bug #8160] */
3557     prev_dis_frame = fdata;
3558     prev_dis = &prev_dis_frame;
3559   }
3560
3561   prev_cap_frame = fdata;
3562   prev_cap = &prev_cap_frame;
3563
3564   if (edt) {
3565     epan_dissect_reset(edt);
3566     frame_data_destroy(&fdata);
3567   }
3568   return passed;
3569 }
3570
3571 static gboolean
3572 write_preamble(capture_file *cf)
3573 {
3574   switch (output_action) {
3575
3576   case WRITE_TEXT:
3577     return print_preamble(print_stream, cf->filename, get_ws_vcs_version_info());
3578
3579   case WRITE_XML:
3580     if (print_details)
3581       write_pdml_preamble(stdout, cf->filename);
3582     else
3583       write_psml_preamble(&cf->cinfo, stdout);
3584     return !ferror(stdout);
3585
3586   case WRITE_FIELDS:
3587     write_fields_preamble(output_fields, stdout);
3588     return !ferror(stdout);
3589
3590   case WRITE_JSON:
3591   case WRITE_JSON_RAW:
3592     write_json_preamble(stdout);
3593     return !ferror(stdout);
3594
3595   case WRITE_EK:
3596     return !ferror(stdout);
3597
3598   default:
3599     g_assert_not_reached();
3600     return FALSE;
3601   }
3602 }
3603
3604 static char *
3605 get_line_buf(size_t len)
3606 {
3607   static char   *line_bufp    = NULL;
3608   static size_t  line_buf_len = 256;
3609   size_t         new_line_buf_len;
3610
3611   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
3612        new_line_buf_len *= 2)
3613     ;
3614   if (line_bufp == NULL) {
3615     line_buf_len = new_line_buf_len;
3616     line_bufp = (char *)g_malloc(line_buf_len + 1);
3617   } else {
3618     if (new_line_buf_len > line_buf_len) {
3619       line_buf_len = new_line_buf_len;
3620       line_bufp = (char *)g_realloc(line_bufp, line_buf_len + 1);
3621     }
3622   }
3623   return line_bufp;
3624 }
3625
3626 static inline void
3627 put_string(char *dest, const char *str, size_t str_len)
3628 {
3629   memcpy(dest, str, str_len);
3630   dest[str_len] = '\0';
3631 }
3632
3633 static inline void
3634 put_spaces_string(char *dest, const char *str, size_t str_len, size_t str_with_spaces)
3635 {
3636   size_t i;
3637
3638   for (i = str_len; i < str_with_spaces; i++)
3639     *dest++ = ' ';
3640
3641   put_string(dest, str, str_len);
3642 }
3643
3644 static inline void
3645 put_string_spaces(char *dest, const char *str, size_t str_len, size_t str_with_spaces)
3646 {
3647   size_t i;
3648
3649   memcpy(dest, str, str_len);
3650   for (i = str_len; i < str_with_spaces; i++)
3651     dest[i] = ' ';
3652
3653   dest[str_with_spaces] = '\0';
3654 }
3655
3656 static gboolean
3657 print_columns(capture_file *cf, const epan_dissect_t *edt)
3658 {
3659   char   *line_bufp;
3660   int     i;
3661   size_t  buf_offset;
3662   size_t  column_len;
3663   size_t  col_len;
3664   col_item_t* col_item;
3665   gchar str_format[11];
3666   const color_filter_t *color_filter = NULL;
3667
3668   line_bufp = get_line_buf(256);
3669   buf_offset = 0;
3670   *line_bufp = '\0';
3671
3672   if (dissect_color)
3673     color_filter = edt->pi.fd->color_filter;
3674
3675   for (i = 0; i < cf->cinfo.num_cols; i++) {
3676     col_item = &cf->cinfo.columns[i];
3677     /* Skip columns not marked as visible. */
3678     if (!get_column_visible(i))
3679       continue;
3680     switch (col_item->col_fmt) {
3681     case COL_NUMBER:
3682       column_len = col_len = strlen(col_item->col_data);
3683       if (column_len < 5)
3684         column_len = 5;
3685       line_bufp = get_line_buf(buf_offset + column_len);
3686       put_spaces_string(line_bufp + buf_offset, col_item->col_data, col_len, column_len);
3687       break;
3688
3689     case COL_CLS_TIME:
3690     case COL_REL_TIME:
3691     case COL_ABS_TIME:
3692     case COL_ABS_YMD_TIME:  /* XXX - wider */
3693     case COL_ABS_YDOY_TIME: /* XXX - wider */
3694     case COL_UTC_TIME:
3695     case COL_UTC_YMD_TIME:  /* XXX - wider */
3696     case COL_UTC_YDOY_TIME: /* XXX - wider */
3697       column_len = col_len = strlen(col_item->col_data);
3698       if (column_len < 10)
3699         column_len = 10;
3700       line_bufp = get_line_buf(buf_offset + column_len);
3701       put_spaces_string(line_bufp + buf_offset, col_item->col_data, col_len, column_len);
3702       break;
3703
3704     case COL_DEF_SRC:
3705     case COL_RES_SRC:
3706     case COL_UNRES_SRC:
3707     case COL_DEF_DL_SRC:
3708     case COL_RES_DL_SRC:
3709     case COL_UNRES_DL_SRC:
3710     case COL_DEF_NET_SRC:
3711     case COL_RES_NET_SRC:
3712     case COL_UNRES_NET_SRC:
3713       column_len = col_len = strlen(col_item->col_data);
3714       if (column_len < 12)
3715         column_len = 12;
3716       line_bufp = get_line_buf(buf_offset + column_len);
3717       put_spaces_string(line_bufp + buf_offset, col_item->col_data, col_len, column_len);
3718       break;
3719
3720     case COL_DEF_DST:
3721     case COL_RES_DST:
3722     case COL_UNRES_DST:
3723     case COL_DEF_DL_DST:
3724     case COL_RES_DL_DST:
3725     case COL_UNRES_DL_DST:
3726     case COL_DEF_NET_DST:
3727     case COL_RES_NET_DST:
3728     case COL_UNRES_NET_DST:
3729       column_len = col_len = strlen(col_item->col_data);
3730       if (column_len < 12)
3731         column_len = 12;
3732       line_bufp = get_line_buf(buf_offset + column_len);
3733       put_string_spaces(line_bufp + buf_offset, col_item->col_data, col_len, column_len);
3734       break;
3735
3736     default:
3737       column_len = strlen(col_item->col_data);
3738       line_bufp = get_line_buf(buf_offset + column_len);
3739       put_string(line_bufp + buf_offset, col_item->col_data, column_len);
3740       break;
3741     }
3742     buf_offset += column_len;
3743     if (i != cf->cinfo.num_cols - 1) {
3744       /*
3745        * This isn't the last column, so we need to print a
3746        * separator between this column and the next.
3747        *
3748        * If we printed a network source and are printing a
3749        * network destination of the same type next, separate
3750        * them with a UTF-8 right arrow; if we printed a network
3751        * destination and are printing a network source of the same
3752        * type next, separate them with a UTF-8 left arrow;
3753        * otherwise separate them with a space.
3754        *
3755        * We add enough space to the buffer for " \xe2\x86\x90 "
3756        * or " \xe2\x86\x92 ", even if we're only adding " ".
3757        */
3758       line_bufp = get_line_buf(buf_offset + 5);
3759       switch (col_item->col_fmt) {
3760
3761       case COL_DEF_SRC:
3762       case COL_RES_SRC:
3763       case COL_UNRES_SRC:
3764         switch (cf->cinfo.columns[i+1].col_fmt) {
3765
3766         case COL_DEF_DST:
3767         case COL_RES_DST:
3768         case COL_UNRES_DST:
3769           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_RIGHTWARDS_ARROW, delimiter_char);
3770           put_string(line_bufp + buf_offset, str_format, 5);
3771           buf_offset += 5;
3772           break;
3773
3774         default:
3775           put_string(line_bufp + buf_offset, delimiter_char, 1);
3776           buf_offset += 1;
3777           break;
3778         }
3779         break;
3780
3781       case COL_DEF_DL_SRC:
3782       case COL_RES_DL_SRC:
3783       case COL_UNRES_DL_SRC:
3784         switch (cf->cinfo.columns[i+1].col_fmt) {
3785
3786         case COL_DEF_DL_DST:
3787         case COL_RES_DL_DST:
3788         case COL_UNRES_DL_DST:
3789           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_RIGHTWARDS_ARROW, delimiter_char);
3790           put_string(line_bufp + buf_offset, str_format, 5);
3791           buf_offset += 5;
3792           break;
3793
3794         default:
3795           put_string(line_bufp + buf_offset, delimiter_char, 1);
3796           buf_offset += 1;
3797           break;
3798         }
3799         break;
3800
3801       case COL_DEF_NET_SRC:
3802       case COL_RES_NET_SRC:
3803       case COL_UNRES_NET_SRC:
3804         switch (cf->cinfo.columns[i+1].col_fmt) {
3805
3806         case COL_DEF_NET_DST:
3807         case COL_RES_NET_DST:
3808         case COL_UNRES_NET_DST:
3809           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_RIGHTWARDS_ARROW, delimiter_char);
3810           put_string(line_bufp + buf_offset, str_format, 5);
3811           buf_offset += 5;
3812           break;
3813
3814         default:
3815           put_string(line_bufp + buf_offset, delimiter_char, 1);
3816           buf_offset += 1;
3817           break;
3818         }
3819         break;
3820
3821       case COL_DEF_DST:
3822       case COL_RES_DST:
3823       case COL_UNRES_DST:
3824         switch (cf->cinfo.columns[i+1].col_fmt) {
3825
3826         case COL_DEF_SRC:
3827         case COL_RES_SRC:
3828         case COL_UNRES_SRC:
3829           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_LEFTWARDS_ARROW, delimiter_char);
3830           put_string(line_bufp + buf_offset, str_format, 5);
3831           buf_offset += 5;
3832           break;
3833
3834         default:
3835           put_string(line_bufp + buf_offset, delimiter_char, 1);
3836           buf_offset += 1;
3837           break;
3838         }
3839         break;
3840
3841       case COL_DEF_DL_DST:
3842       case COL_RES_DL_DST:
3843       case COL_UNRES_DL_DST:
3844         switch (cf->cinfo.columns[i+1].col_fmt) {
3845
3846         case COL_DEF_DL_SRC:
3847         case COL_RES_DL_SRC:
3848         case COL_UNRES_DL_SRC:
3849           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_LEFTWARDS_ARROW, delimiter_char);
3850           put_string(line_bufp + buf_offset, str_format, 5);
3851           buf_offset += 5;
3852           break;
3853
3854         default:
3855           put_string(line_bufp + buf_offset, delimiter_char, 1);
3856           buf_offset += 1;
3857           break;
3858         }
3859         break;
3860
3861       case COL_DEF_NET_DST:
3862       case COL_RES_NET_DST:
3863       case COL_UNRES_NET_DST:
3864         switch (cf->cinfo.columns[i+1].col_fmt) {
3865
3866         case COL_DEF_NET_SRC:
3867         case COL_RES_NET_SRC:
3868         case COL_UNRES_NET_SRC:
3869           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_LEFTWARDS_ARROW, delimiter_char);
3870           put_string(line_bufp + buf_offset, str_format, 5);
3871           buf_offset += 5;
3872           break;
3873
3874         default:
3875           put_string(line_bufp + buf_offset, delimiter_char, 1);
3876           buf_offset += 1;
3877           break;
3878         }
3879         break;
3880
3881       default:
3882         put_string(line_bufp + buf_offset, delimiter_char, 1);
3883         buf_offset += 1;
3884         break;
3885       }
3886     }
3887   }
3888
3889   if (dissect_color && color_filter != NULL)
3890     return print_line_color(print_stream, 0, line_bufp, &color_filter->fg_color, &color_filter->bg_color);
3891   else
3892     return print_line(print_stream, 0, line_bufp);
3893 }
3894
3895 static gboolean
3896 print_packet(capture_file *cf, epan_dissect_t *edt)
3897 {
3898   if (print_summary || output_fields_has_cols(output_fields)) {
3899     /* Just fill in the columns. */
3900     epan_dissect_fill_in_columns(edt, FALSE, TRUE);
3901
3902     if (print_summary) {
3903       /* Now print them. */
3904       switch (output_action) {
3905
3906       case WRITE_TEXT:
3907         if (!print_columns(cf, edt))
3908           return FALSE;
3909         break;
3910
3911       case WRITE_XML:
3912         write_psml_columns(edt, stdout, dissect_color);
3913         return !ferror(stdout);
3914       case WRITE_FIELDS: /*No non-verbose "fields" format */
3915       case WRITE_JSON:
3916       case WRITE_EK:
3917       case WRITE_JSON_RAW:
3918         g_assert_not_reached();
3919         break;
3920       }
3921     }
3922   }
3923   if (print_details) {
3924     /* Print the information in the protocol tree. */
3925     switch (output_action) {
3926
3927     case WRITE_TEXT:
3928       if (!proto_tree_print(print_details ? print_dissections_expanded : print_dissections_none,
3929                             print_hex, edt, output_only_tables, print_stream))
3930         return FALSE;
3931       if (!print_hex) {
3932         if (!print_line(print_stream, 0, separator))
3933           return FALSE;
3934       }
3935       break;
3936
3937     case WRITE_XML:
3938       write_pdml_proto_tree(output_fields, protocolfilter, protocolfilter_flags, edt, stdout, dissect_color);
3939       printf("\n");
3940       return !ferror(stdout);
3941     case WRITE_FIELDS:
3942       write_fields_proto_tree(output_fields, edt, &cf->cinfo, stdout);
3943       printf("\n");
3944       return !ferror(stdout);
3945     case WRITE_JSON:
3946       write_json_proto_tree(output_fields, print_dissections_expanded,
3947                             print_hex, protocolfilter, protocolfilter_flags,
3948                             edt, node_children_grouper, stdout);
3949       return !ferror(stdout);
3950     case WRITE_JSON_RAW:
3951       write_json_proto_tree(output_fields, print_dissections_none, TRUE,
3952                             protocolfilter, protocolfilter_flags,
3953                             edt, node_children_grouper, stdout);
3954       return !ferror(stdout);
3955     case WRITE_EK:
3956       write_ek_proto_tree(output_fields, print_hex, protocolfilter,
3957                           protocolfilter_flags, edt, stdout);
3958       return !ferror(stdout);
3959     }
3960   }
3961   if (print_hex) {
3962     if (print_summary || print_details) {
3963       if (!print_line(print_stream, 0, ""))
3964         return FALSE;
3965     }
3966     if (!print_hex_data(print_stream, edt))
3967       return FALSE;
3968     if (!print_line(print_stream, 0, separator))
3969       return FALSE;
3970   }
3971   return TRUE;
3972 }
3973
3974 static gboolean
3975 write_finale(void)
3976 {
3977   switch (output_action) {
3978
3979   case WRITE_TEXT:
3980     return print_finale(print_stream);
3981
3982   case WRITE_XML:
3983     if (print_details)
3984       write_pdml_finale(stdout);
3985     else
3986       write_psml_finale(stdout);
3987     return !ferror(stdout);
3988
3989   case WRITE_FIELDS:
3990     write_fields_finale(output_fields, stdout);
3991     return !ferror(stdout);
3992
3993   case WRITE_JSON:
3994   case WRITE_JSON_RAW:
3995     write_json_finale(stdout);
3996     return !ferror(stdout);
3997
3998   case WRITE_EK:
3999     return !ferror(stdout);
4000
4001   default:
4002     g_assert_not_reached();
4003     return FALSE;
4004   }
4005 }
4006
4007 void
4008 cf_close(capture_file *cf)
4009 {
4010   g_free(cf->filename);
4011 }
4012
4013 cf_status_t
4014 cf_open(capture_file *cf, const char *fname, unsigned int type, gboolean is_tempfile, int *err)
4015 {
4016   wtap  *wth;
4017   gchar *err_info;
4018
4019   wth = wtap_open_offline(fname, type, err, &err_info, perform_two_pass_analysis);
4020   if (wth == NULL)
4021     goto fail;
4022
4023   /* The open succeeded.  Fill in the information for this file. */
4024
4025   /* Create new epan session for dissection. */
4026   epan_free(cf->epan);
4027   cf->epan = tshark_epan_new(cf);
4028
4029   cf->wth = wth;
4030   cf->f_datalen = 0; /* not used, but set it anyway */
4031
4032   /* Set the file name because we need it to set the follow stream filter.
4033      XXX - is that still true?  We need it for other reasons, though,
4034      in any case. */
4035   cf->filename = g_strdup(fname);
4036
4037   /* Indicate whether it's a permanent or temporary file. */
4038   cf->is_tempfile = is_tempfile;
4039
4040   /* No user changes yet. */
4041   cf->unsaved_changes = FALSE;
4042
4043   cf->cd_t      = wtap_file_type_subtype(cf->wth);
4044   cf->open_type = type;
4045   cf->count     = 0;
4046   cf->drops_known = FALSE;
4047   cf->drops     = 0;
4048   cf->snap      = wtap_snapshot_length(cf->wth);
4049   nstime_set_zero(&cf->elapsed_time);
4050   ref = NULL;
4051   prev_dis = NULL;
4052   prev_cap = NULL;
4053
4054   cf->state = FILE_READ_IN_PROGRESS;
4055
4056   wtap_set_cb_new_ipv4(cf->wth, add_ipv4_name);
4057   wtap_set_cb_new_ipv6(cf->wth, (wtap_new_ipv6_callback_t) add_ipv6_name);
4058
4059   return CF_OK;
4060
4061 fail:
4062   cfile_open_failure_message("TShark", fname, *err, err_info);
4063   return CF_ERROR;
4064 }
4065
4066 static void
4067 show_print_file_io_error(int err)
4068 {
4069   switch (err) {
4070
4071   case ENOSPC:
4072     cmdarg_err("Not all the packets could be printed because there is "
4073 "no space left on the file system.");
4074     break;
4075
4076 #ifdef EDQUOT
4077   case EDQUOT:
4078     cmdarg_err("Not all the packets could be printed because you are "
4079 "too close to, or over your disk quota.");
4080   break;
4081 #endif
4082
4083   default:
4084     cmdarg_err("An error occurred while printing packets: %s.",
4085       g_strerror(err));
4086     break;
4087   }
4088 }
4089
4090 /*
4091  * General errors and warnings are reported with an console message
4092  * in TShark.
4093  */
4094 static void
4095 failure_warning_message(const char *msg_format, va_list ap)
4096 {
4097   fprintf(stderr, "tshark: ");
4098   vfprintf(stderr, msg_format, ap);
4099   fprintf(stderr, "\n");
4100 }
4101
4102 /*
4103  * Open/create errors are reported with an console message in TShark.
4104  */
4105 static void
4106 open_failure_message(const char *filename, int err, gboolean for_writing)
4107 {
4108   fprintf(stderr, "tshark: ");
4109   fprintf(stderr, file_open_error_message(err, for_writing), filename);
4110   fprintf(stderr, "\n");
4111 }
4112
4113 /*
4114  * Read errors are reported with an console message in TShark.
4115  */
4116 static void
4117 read_failure_message(const char *filename, int err)
4118 {
4119   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
4120              filename, g_strerror(err));
4121 }
4122
4123 /*
4124  * Write errors are reported with an console message in TShark.
4125  */
4126 static void
4127 write_failure_message(const char *filename, int err)
4128 {
4129   cmdarg_err("An error occurred while writing to the file \"%s\": %s.",
4130              filename, g_strerror(err));
4131 }
4132
4133 static void reset_epan_mem(capture_file *cf,epan_dissect_t *edt, gboolean tree, gboolean visual)
4134 {
4135   if (!epan_auto_reset || (cf->count < epan_auto_reset_count))
4136     return;
4137
4138   fprintf(stderr, "resetting session.\n");
4139
4140   epan_dissect_cleanup(edt);
4141   epan_free(cf->epan);
4142
4143   cf->epan = tshark_epan_new(cf);
4144   epan_dissect_init(edt, cf->epan, tree, visual);
4145   cf->count = 0;
4146 }
4147
4148 /*
4149  * Report additional information for an error in command-line arguments.
4150  */
4151 static void
4152 failure_message_cont(const char *msg_format, va_list ap)
4153 {
4154   vfprintf(stderr, msg_format, ap);
4155   fprintf(stderr, "\n");
4156 }
4157
4158 /*
4159  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
4160  *
4161  * Local variables:
4162  * c-basic-offset: 2
4163  * tab-width: 8
4164  * indent-tabs-mode: nil
4165  * End:
4166  *
4167  * vi: set shiftwidth=2 tabstop=8 expandtab:
4168  * :indentSize=2:tabSize=8:noTabs=true:
4169  */