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