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