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