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