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