tshark: do not print packet information when using -w without libpcap
[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 #else
1557   if (!output_file_name) {
1558 #endif
1559     /* We're not saving the capture to a file; if "-q" wasn't specified,
1560        we should print packet information */
1561     if (!quiet)
1562       print_packet_info = TRUE;
1563   } else {
1564 #ifdef HAVE_LIBPCAP
1565     const char *save_file = global_capture_opts.save_file;
1566 #else
1567     const char *save_file = output_file_name;
1568 #endif
1569     /* We're saving to a file; if we're writing to the standard output.
1570        and we'll also be writing dissected packets to the standard
1571        output, reject the request.  At best, we could redirect that
1572        to the standard error; we *can't* write both to the standard
1573        output and have either of them be useful. */
1574     if (strcmp(save_file, "-") == 0 && print_packet_info) {
1575       cmdarg_err("You can't write both raw packet data and dissected packets"
1576           " to the standard output.");
1577       exit_status = INVALID_OPTION;
1578       goto clean_exit;
1579     }
1580   }
1581
1582 #ifndef HAVE_LIBPCAP
1583   if (capture_option_specified)
1584     cmdarg_err("This version of TShark was not built with support for capturing packets.");
1585 #endif
1586   if (arg_error) {
1587     print_usage(stderr);
1588     exit_status = INVALID_OPTION;
1589     goto clean_exit;
1590   }
1591
1592   if (print_hex) {
1593     if (output_action != WRITE_TEXT && output_action != WRITE_JSON && output_action != WRITE_JSON_RAW && output_action != WRITE_EK) {
1594       cmdarg_err("Raw packet hex data can only be printed as text, PostScript, JSON, JSONRAW or EK JSON");
1595       exit_status = INVALID_OPTION;
1596       goto clean_exit;
1597     }
1598   }
1599
1600   if (output_only != NULL) {
1601     char *ps;
1602
1603     if (!print_details) {
1604       cmdarg_err("-O requires -V");
1605       exit_status = INVALID_OPTION;
1606       goto clean_exit;
1607     }
1608
1609     output_only_tables = g_hash_table_new (g_str_hash, g_str_equal);
1610     for (ps = strtok (output_only, ","); ps; ps = strtok (NULL, ",")) {
1611       g_hash_table_insert(output_only_tables, (gpointer)ps, (gpointer)ps);
1612     }
1613   }
1614
1615   if (rfilter != NULL && !perform_two_pass_analysis) {
1616     cmdarg_err("-R without -2 is deprecated. For single-pass filtering use -Y.");
1617     exit_status = INVALID_OPTION;
1618     goto clean_exit;
1619   }
1620
1621 #ifdef HAVE_LIBPCAP
1622   if (caps_queries) {
1623     /* We're supposed to list the link-layer/timestamp types for an interface;
1624        did the user also specify a capture file to be read? */
1625     if (cf_name) {
1626       /* Yes - that's bogus. */
1627       cmdarg_err("You can't specify %s and a capture file to be read.",
1628                  caps_queries & CAPS_QUERY_LINK_TYPES ? "-L" : "--list-time-stamp-types");
1629       exit_status = INVALID_OPTION;
1630       goto clean_exit;
1631     }
1632     /* No - did they specify a ring buffer option? */
1633     if (global_capture_opts.multi_files_on) {
1634       cmdarg_err("Ring buffer requested, but a capture isn't being done.");
1635       exit_status = INVALID_OPTION;
1636       goto clean_exit;
1637     }
1638   } else {
1639     if (cf_name) {
1640       /*
1641        * "-r" was specified, so we're reading a capture file.
1642        * Capture options don't apply here.
1643        */
1644
1645       /* We don't support capture filters when reading from a capture file
1646          (the BPF compiler doesn't support all link-layer types that we
1647          support in capture files we read). */
1648       if (global_capture_opts.default_options.cfilter) {
1649         cmdarg_err("Only read filters, not capture filters, "
1650           "can be specified when reading a capture file.");
1651         exit_status = INVALID_OPTION;
1652         goto clean_exit;
1653       }
1654       if (global_capture_opts.multi_files_on) {
1655         cmdarg_err("Multiple capture files requested, but "
1656                    "a capture isn't being done.");
1657         exit_status = INVALID_OPTION;
1658         goto clean_exit;
1659       }
1660       if (global_capture_opts.has_file_duration) {
1661         cmdarg_err("Switching capture files after a time period was specified, but "
1662                    "a capture isn't being done.");
1663         exit_status = INVALID_OPTION;
1664         goto clean_exit;
1665       }
1666       if (global_capture_opts.has_file_interval) {
1667         cmdarg_err("Switching capture files after a time interval was specified, but "
1668                    "a capture isn't being done.");
1669         exit_status = INVALID_OPTION;
1670         goto clean_exit;
1671       }
1672       if (global_capture_opts.has_ring_num_files) {
1673         cmdarg_err("A ring buffer of capture files was specified, but "
1674           "a capture isn't being done.");
1675         exit_status = INVALID_OPTION;
1676         goto clean_exit;
1677       }
1678       if (global_capture_opts.has_autostop_files) {
1679         cmdarg_err("A maximum number of capture files was specified, but "
1680           "a capture isn't being done.");
1681         exit_status = INVALID_OPTION;
1682         goto clean_exit;
1683       }
1684       if (global_capture_opts.capture_comment) {
1685         cmdarg_err("A capture comment was specified, but "
1686           "a capture isn't being done.\nThere's no support for adding "
1687           "a capture comment to an existing capture file.");
1688         exit_status = INVALID_OPTION;
1689         goto clean_exit;
1690       }
1691
1692       /* Note: TShark now allows the restriction of a _read_ file by packet count
1693        * and byte count as well as a write file. Other autostop options remain valid
1694        * only for a write file.
1695        */
1696       if (global_capture_opts.has_autostop_duration) {
1697         cmdarg_err("A maximum capture time was specified, but "
1698           "a capture isn't being done.");
1699         exit_status = INVALID_OPTION;
1700         goto clean_exit;
1701       }
1702     } else {
1703       /*
1704        * "-r" wasn't specified, so we're doing a live capture.
1705        */
1706       if (perform_two_pass_analysis) {
1707         /* Two-pass analysis doesn't work with live capture since it requires us
1708          * to buffer packets until we've read all of them, but a live capture
1709          * has no useful/meaningful definition of "all" */
1710         cmdarg_err("Live captures do not support two-pass analysis.");
1711         exit_status = INVALID_OPTION;
1712         goto clean_exit;
1713       }
1714
1715       if (global_capture_opts.saving_to_file) {
1716         /* They specified a "-w" flag, so we'll be saving to a capture file. */
1717
1718         /* When capturing, we only support writing pcap or pcapng format. */
1719         if (out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAP &&
1720             out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAPNG) {
1721           cmdarg_err("Live captures can only be saved in pcap or pcapng format.");
1722           exit_status = INVALID_OPTION;
1723           goto clean_exit;
1724         }
1725         if (global_capture_opts.capture_comment &&
1726             out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAPNG) {
1727           cmdarg_err("A capture comment can only be written to a pcapng file.");
1728           exit_status = INVALID_OPTION;
1729           goto clean_exit;
1730         }
1731         if (global_capture_opts.multi_files_on) {
1732           /* Multiple-file mode doesn't work under certain conditions:
1733              a) it doesn't work if you're writing to the standard output;
1734              b) it doesn't work if you're writing to a pipe;
1735           */
1736           if (strcmp(global_capture_opts.save_file, "-") == 0) {
1737             cmdarg_err("Multiple capture files requested, but "
1738               "the capture is being written to the standard output.");
1739             exit_status = INVALID_OPTION;
1740             goto clean_exit;
1741           }
1742           if (global_capture_opts.output_to_pipe) {
1743             cmdarg_err("Multiple capture files requested, but "
1744               "the capture file is a pipe.");
1745             exit_status = INVALID_OPTION;
1746             goto clean_exit;
1747           }
1748           if (!global_capture_opts.has_autostop_filesize &&
1749               !global_capture_opts.has_file_duration &&
1750               !global_capture_opts.has_file_interval) {
1751             cmdarg_err("Multiple capture files requested, but "
1752               "no maximum capture file size, duration or interval was specified.");
1753             exit_status = INVALID_OPTION;
1754             goto clean_exit;
1755           }
1756         }
1757         /* Currently, we don't support read or display filters when capturing
1758            and saving the packets. */
1759         if (rfilter != NULL) {
1760           cmdarg_err("Read filters aren't supported when capturing and saving the captured packets.");
1761           exit_status = INVALID_OPTION;
1762           goto clean_exit;
1763         }
1764         if (dfilter != NULL) {
1765           cmdarg_err("Display filters aren't supported when capturing and saving the captured packets.");
1766           exit_status = INVALID_OPTION;
1767           goto clean_exit;
1768         }
1769         global_capture_opts.use_pcapng = (out_file_type == WTAP_FILE_TYPE_SUBTYPE_PCAPNG) ? TRUE : FALSE;
1770       } else {
1771         /* They didn't specify a "-w" flag, so we won't be saving to a
1772            capture file.  Check for options that only make sense if
1773            we're saving to a file. */
1774         if (global_capture_opts.has_autostop_filesize) {
1775           cmdarg_err("Maximum capture file size specified, but "
1776            "capture isn't being saved to a file.");
1777           exit_status = INVALID_OPTION;
1778           goto clean_exit;
1779         }
1780         if (global_capture_opts.multi_files_on) {
1781           cmdarg_err("Multiple capture files requested, but "
1782             "the capture isn't being saved to a file.");
1783           exit_status = INVALID_OPTION;
1784           goto clean_exit;
1785         }
1786         if (global_capture_opts.capture_comment) {
1787           cmdarg_err("A capture comment was specified, but "
1788             "the capture isn't being saved to a file.");
1789           exit_status = INVALID_OPTION;
1790           goto clean_exit;
1791         }
1792       }
1793     }
1794   }
1795 #endif
1796
1797 #ifdef _WIN32
1798   /* Start windows sockets */
1799   result = WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
1800   if (result != 0)
1801   {
1802     exit_status = INIT_FAILED;
1803     goto clean_exit;
1804   }
1805 #endif /* _WIN32 */
1806
1807   /* Notify all registered modules that have had any of their preferences
1808      changed either from one of the preferences file or from the command
1809      line that their preferences have changed. */
1810   prefs_apply_all();
1811
1812   /* We can also enable specified taps for export object */
1813   start_exportobjects();
1814
1815   /* At this point MATE will have registered its field array so we can
1816      check if the fields specified by the user are all good.
1817    */
1818   {
1819     GSList* it = NULL;
1820     GSList *invalid_fields = output_fields_valid(output_fields);
1821     if (invalid_fields != NULL) {
1822
1823       cmdarg_err("Some fields aren't valid:");
1824       for (it=invalid_fields; it != NULL; it = g_slist_next(it)) {
1825         cmdarg_err_cont("\t%s", (gchar *)it->data);
1826       }
1827       g_slist_free(invalid_fields);
1828       exit_status = INVALID_OPTION;
1829       goto clean_exit;
1830     }
1831   }
1832 #ifdef HAVE_LIBPCAP
1833   /* We currently don't support taps, or printing dissected packets,
1834      if we're writing to a pipe. */
1835   if (global_capture_opts.saving_to_file &&
1836       global_capture_opts.output_to_pipe) {
1837     if (tap_listeners_require_dissection()) {
1838       cmdarg_err("Taps aren't supported when saving to a pipe.");
1839       exit_status = INVALID_OPTION;
1840       goto clean_exit;
1841     }
1842     if (print_packet_info) {
1843       cmdarg_err("Printing dissected packets isn't supported when saving to a pipe.");
1844       exit_status = INVALID_OPTION;
1845       goto clean_exit;
1846     }
1847   }
1848 #endif
1849
1850   if (ex_opt_count("read_format") > 0) {
1851     const gchar* name = ex_opt_get_next("read_format");
1852     in_file_type = open_info_name_to_type(name);
1853     if (in_file_type == WTAP_TYPE_AUTO) {
1854       cmdarg_err("\"%s\" isn't a valid read file format type", name? name : "");
1855       list_read_capture_types();
1856       exit_status = INVALID_OPTION;
1857       goto clean_exit;
1858     }
1859   }
1860
1861   timestamp_set_type(global_dissect_options.time_format);
1862
1863   /*
1864    * Enabled and disabled protocols and heuristic dissectors as per
1865    * command-line options.
1866    */
1867   if (!setup_enabled_and_disabled_protocols()) {
1868     exit_status = INVALID_OPTION;
1869     goto clean_exit;
1870   }
1871
1872   /* Build the column format array */
1873   build_column_format_array(&cfile.cinfo, prefs_p->num_cols, TRUE);
1874
1875 #ifdef HAVE_LIBPCAP
1876   capture_opts_trim_snaplen(&global_capture_opts, MIN_PACKET_SIZE);
1877   capture_opts_trim_ring_num_files(&global_capture_opts);
1878 #endif
1879
1880   if (rfilter != NULL) {
1881     tshark_debug("Compiling read filter: '%s'", rfilter);
1882     if (!dfilter_compile(rfilter, &rfcode, &err_msg)) {
1883       cmdarg_err("%s", err_msg);
1884       g_free(err_msg);
1885       epan_cleanup();
1886       extcap_cleanup();
1887 #ifdef HAVE_PCAP_OPEN_DEAD
1888       {
1889         pcap_t *pc;
1890
1891         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1892         if (pc != NULL) {
1893           if (pcap_compile(pc, &fcode, rfilter, 0, 0) != -1) {
1894             cmdarg_err_cont(
1895               "  Note: That read filter code looks like a valid capture filter;\n"
1896               "        maybe you mixed them up?");
1897           }
1898           pcap_close(pc);
1899         }
1900       }
1901 #endif
1902       exit_status = INVALID_INTERFACE;
1903       goto clean_exit;
1904     }
1905   }
1906   cfile.rfcode = rfcode;
1907
1908   if (dfilter != NULL) {
1909     tshark_debug("Compiling display filter: '%s'", dfilter);
1910     if (!dfilter_compile(dfilter, &dfcode, &err_msg)) {
1911       cmdarg_err("%s", err_msg);
1912       g_free(err_msg);
1913       epan_cleanup();
1914       extcap_cleanup();
1915 #ifdef HAVE_PCAP_OPEN_DEAD
1916       {
1917         pcap_t *pc;
1918
1919         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1920         if (pc != NULL) {
1921           if (pcap_compile(pc, &fcode, dfilter, 0, 0) != -1) {
1922             cmdarg_err_cont(
1923               "  Note: That display filter code looks like a valid capture filter;\n"
1924               "        maybe you mixed them up?");
1925           }
1926           pcap_close(pc);
1927         }
1928       }
1929 #endif
1930       exit_status = INVALID_FILTER;
1931       goto clean_exit;
1932     }
1933   }
1934   cfile.dfcode = dfcode;
1935
1936   if (print_packet_info) {
1937     /* If we're printing as text or PostScript, we have
1938        to create a print stream. */
1939     if (output_action == WRITE_TEXT) {
1940       switch (print_format) {
1941
1942       case PR_FMT_TEXT:
1943         print_stream = print_stream_text_stdio_new(stdout);
1944         break;
1945
1946       case PR_FMT_PS:
1947         print_stream = print_stream_ps_stdio_new(stdout);
1948         break;
1949
1950       default:
1951         g_assert_not_reached();
1952       }
1953     }
1954   }
1955
1956   /* PDU export requested. Take the ownership of the '-w' file, apply tap
1957   * filters and start tapping. */
1958   if (pdu_export_arg) {
1959       const char *exp_pdu_tap_name = pdu_export_arg;
1960       const char *exp_pdu_filter = dfilter; /* may be NULL to disable filter */
1961       char       *exp_pdu_error;
1962       int         exp_fd;
1963       char       *comment;
1964
1965       if (!cf_name) {
1966           cmdarg_err("PDUs export requires a capture file (specify with -r).");
1967           exit_status = INVALID_OPTION;
1968           goto clean_exit;
1969       }
1970       /* Take ownership of the '-w' output file. */
1971 #ifdef HAVE_LIBPCAP
1972       exp_pdu_filename = global_capture_opts.save_file;
1973       global_capture_opts.save_file = NULL;
1974 #else
1975       exp_pdu_filename = output_file_name;
1976       output_file_name = NULL;
1977 #endif
1978       if (exp_pdu_filename == NULL) {
1979           cmdarg_err("PDUs export requires an output file (-w).");
1980           exit_status = INVALID_OPTION;
1981           goto clean_exit;
1982       }
1983
1984       exp_pdu_error = exp_pdu_pre_open(exp_pdu_tap_name, exp_pdu_filter,
1985           &exp_pdu_tap_data);
1986       if (exp_pdu_error) {
1987           cmdarg_err("Cannot register tap: %s", exp_pdu_error);
1988           g_free(exp_pdu_error);
1989           exit_status = INVALID_TAP;
1990           goto clean_exit;
1991       }
1992
1993       if (strcmp(exp_pdu_filename, "-") == 0) {
1994         /* Write to the standard output. */
1995         exp_fd = 1;
1996       } else {
1997         exp_fd = ws_open(exp_pdu_filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
1998         if (exp_fd == -1) {
1999           cmdarg_err("%s: %s", exp_pdu_filename, file_open_error_message(errno, TRUE));
2000           exit_status = INVALID_FILE;
2001           goto clean_exit;
2002         }
2003       }
2004
2005       /* Activate the export PDU tap */
2006       comment = g_strdup_printf("Dump of PDUs from %s", cf_name);
2007       err = exp_pdu_open(&exp_pdu_tap_data, exp_fd, comment);
2008       if (err != 0) {
2009           cfile_dump_open_failure_message("TShark", exp_pdu_filename, err,
2010                                           WTAP_FILE_TYPE_SUBTYPE_PCAPNG);
2011           g_free(comment);
2012           exit_status = INVALID_EXPORT;
2013           goto clean_exit;
2014       }
2015   }
2016
2017   tshark_debug("tshark: do_dissection = %s", do_dissection ? "TRUE" : "FALSE");
2018
2019   if (cf_name) {
2020     tshark_debug("tshark: Opening capture file: %s", cf_name);
2021     /*
2022      * We're reading a capture file.
2023      */
2024     if (cf_open(&cfile, cf_name, in_file_type, FALSE, &err) != CF_OK) {
2025       epan_cleanup();
2026       extcap_cleanup();
2027       exit_status = INVALID_FILE;
2028       goto clean_exit;
2029     }
2030
2031     /* Start statistics taps; we do so after successfully opening the
2032        capture file, so we know we have something to compute stats
2033        on, and after registering all dissectors, so that MATE will
2034        have registered its field array so we can have a tap filter
2035        with one of MATE's late-registered fields as part of the
2036        filter. */
2037     start_requested_stats();
2038
2039     /* Do we need to do dissection of packets?  That depends on, among
2040        other things, what taps are listening, so determine that after
2041        starting the statistics taps. */
2042     do_dissection = must_do_dissection(rfcode, dfcode, pdu_export_arg);
2043
2044     /* Process the packets in the file */
2045     tshark_debug("tshark: invoking process_cap_file() to process the packets");
2046     TRY {
2047 #ifdef HAVE_LIBPCAP
2048       success = process_cap_file(&cfile, global_capture_opts.save_file, out_file_type, out_file_name_res,
2049           global_capture_opts.has_autostop_packets ? global_capture_opts.autostop_packets : 0,
2050           global_capture_opts.has_autostop_filesize ? global_capture_opts.autostop_filesize : 0);
2051 #else
2052       success = process_cap_file(&cfile, output_file_name, out_file_type, out_file_name_res, 0, 0);
2053 #endif
2054     }
2055     CATCH(OutOfMemoryError) {
2056       fprintf(stderr,
2057               "Out Of Memory.\n"
2058               "\n"
2059               "Sorry, but TShark has to terminate now.\n"
2060               "\n"
2061               "More information and workarounds can be found at\n"
2062               "https://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2063       success = FALSE;
2064     }
2065     ENDTRY;
2066
2067     if (!success) {
2068       /* We still dump out the results of taps, etc., as we might have
2069          read some packets; however, we exit with an error status. */
2070       exit_status = 2;
2071     }
2072
2073     if (pdu_export_arg) {
2074         err = exp_pdu_close(&exp_pdu_tap_data);
2075         if (err) {
2076             cfile_close_failure_message(exp_pdu_filename, err);
2077             exit_status = 2;
2078         }
2079         g_free(pdu_export_arg);
2080         g_free(exp_pdu_filename);
2081     }
2082   } else {
2083     tshark_debug("tshark: no capture file specified");
2084     /* No capture file specified, so we're supposed to do a live capture
2085        or get a list of link-layer types for a live capture device;
2086        do we have support for live captures? */
2087 #ifdef HAVE_LIBPCAP
2088 #ifdef _WIN32
2089     /* Warn the user if npf.sys isn't loaded. */
2090     if (!npf_sys_is_running()) {
2091       fprintf(stderr, "The NPF driver isn't running.  You may have trouble "
2092           "capturing or\nlisting interfaces.\n");
2093     }
2094 #endif /* _WIN32 */
2095
2096     /* if no interface was specified, pick a default */
2097     exit_status = capture_opts_default_iface_if_necessary(&global_capture_opts,
2098         ((prefs_p->capture_device) && (*prefs_p->capture_device != '\0')) ? get_if_name(prefs_p->capture_device) : NULL);
2099     if (exit_status != 0) {
2100       goto clean_exit;
2101     }
2102
2103     /* if requested, list the link layer types and exit */
2104     if (caps_queries) {
2105         guint i;
2106
2107         /* Get the list of link-layer types for the capture devices. */
2108         for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2109           interface_options *interface_opts;
2110           if_capabilities_t *caps;
2111           char *auth_str = NULL;
2112           int if_caps_queries = caps_queries;
2113
2114           interface_opts = &g_array_index(global_capture_opts.ifaces, interface_options, i);
2115 #ifdef HAVE_PCAP_REMOTE
2116           if (interface_opts->auth_type == CAPTURE_AUTH_PWD) {
2117               auth_str = g_strdup_printf("%s:%s", interface_opts->auth_username, interface_opts->auth_password);
2118           }
2119 #endif
2120           caps = capture_get_if_capabilities(interface_opts->name, interface_opts->monitor_mode, auth_str, &err_str, NULL);
2121           g_free(auth_str);
2122           if (caps == NULL) {
2123             cmdarg_err("%s", err_str);
2124             g_free(err_str);
2125             exit_status = INVALID_CAPABILITY;
2126             goto clean_exit;
2127           }
2128           if ((if_caps_queries & CAPS_QUERY_LINK_TYPES) && caps->data_link_types == NULL) {
2129             cmdarg_err("The capture device \"%s\" has no data link types.", interface_opts->name);
2130             exit_status = INVALID_DATA_LINK;
2131             goto clean_exit;
2132           }
2133           if ((if_caps_queries & CAPS_QUERY_TIMESTAMP_TYPES) && caps->timestamp_types == NULL) {
2134             cmdarg_err("The capture device \"%s\" has no timestamp types.", interface_opts->name);
2135             exit_status = INVALID_TIMESTAMP_TYPE;
2136             goto clean_exit;
2137           }
2138           if (interface_opts->monitor_mode)
2139                 if_caps_queries |= CAPS_MONITOR_MODE;
2140           capture_opts_print_if_capabilities(caps, interface_opts->name, if_caps_queries);
2141           free_if_capabilities(caps);
2142         }
2143         exit_status = EXIT_SUCCESS;
2144         goto clean_exit;
2145     }
2146
2147     /*
2148      * If the standard error isn't a terminal, don't print packet counts,
2149      * as they won't show up on the user's terminal and they'll get in
2150      * the way of error messages in the file (to which we assume the
2151      * standard error was redirected; if it's redirected to the null
2152      * device, there's no point in printing packet counts anyway).
2153      *
2154      * Otherwise, if we're printing packet information and the standard
2155      * output is a terminal (which we assume means the standard output and
2156      * error are going to the same terminal), don't print packet counts,
2157      * as they'll get in the way of the packet information.
2158      *
2159      * Otherwise, if the user specified -q, don't print packet counts.
2160      *
2161      * Otherwise, print packet counts.
2162      *
2163      * XXX - what if the user wants to do a live capture, doesn't want
2164      * to save it to a file, doesn't want information printed for each
2165      * packet, does want some "-z" statistic, and wants packet counts
2166      * so they know whether they're seeing any packets?  -q will
2167      * suppress the information printed for each packet, but it'll
2168      * also suppress the packet counts.
2169      */
2170     if (!ws_isatty(ws_fileno(stderr)))
2171       print_packet_counts = FALSE;
2172     else if (print_packet_info && ws_isatty(ws_fileno(stdout)))
2173       print_packet_counts = FALSE;
2174     else if (quiet)
2175       print_packet_counts = FALSE;
2176     else
2177       print_packet_counts = TRUE;
2178
2179     if (print_packet_info) {
2180       if (!write_preamble(&cfile)) {
2181         show_print_file_io_error(errno);
2182         exit_status = INVALID_FILE;
2183         goto clean_exit;
2184       }
2185     }
2186
2187     tshark_debug("tshark: performing live capture");
2188
2189     /* Start statistics taps; we should only do so after the capture
2190        started successfully, so we know we have something to compute
2191        stats, but we currently don't check for that - see below.
2192
2193        We do so after registering all dissectors, so that MATE will
2194        have registered its field array so we can have a tap filter
2195        with one of MATE's late-registered fields as part of the
2196        filter. */
2197     start_requested_stats();
2198
2199     /* Do we need to do dissection of packets?  That depends on, among
2200        other things, what taps are listening, so determine that after
2201        starting the statistics taps. */
2202     do_dissection = must_do_dissection(rfcode, dfcode, pdu_export_arg);
2203
2204     /*
2205      * XXX - this returns FALSE if an error occurred, but it also
2206      * returns FALSE if the capture stops because a time limit
2207      * was reached (and possibly other limits), so we can't assume
2208      * it means an error.
2209      *
2210      * The capture code is a bit twisty, so it doesn't appear to
2211      * be an easy fix.  We just ignore the return value for now.
2212      * Instead, pass on the exit status from the capture child.
2213      */
2214     capture();
2215     exit_status = global_capture_session.fork_child_status;
2216
2217     if (print_packet_info) {
2218       if (!write_finale()) {
2219         show_print_file_io_error(errno);
2220       }
2221     }
2222 #else
2223     /* No - complain. */
2224     cmdarg_err("This version of TShark was not built with support for capturing packets.");
2225     exit_status = INVALID_CAPTURE;
2226     goto clean_exit;
2227 #endif
2228   }
2229
2230   if (cfile.provider.frames != NULL) {
2231     free_frame_data_sequence(cfile.provider.frames);
2232     cfile.provider.frames = NULL;
2233   }
2234
2235   draw_tap_listeners(TRUE);
2236   /* Memory cleanup */
2237   reset_tap_listeners();
2238   funnel_dump_all_text_windows();
2239   epan_free(cfile.epan);
2240   epan_cleanup();
2241   extcap_cleanup();
2242
2243   output_fields_free(output_fields);
2244   output_fields = NULL;
2245
2246 clean_exit:
2247   g_free(cf_name);
2248   destroy_print_stream(print_stream);
2249 #ifdef HAVE_LIBPCAP
2250   capture_opts_cleanup(&global_capture_opts);
2251 #else
2252   g_free(output_file_name);
2253 #endif
2254   col_cleanup(&cfile.cinfo);
2255   free_filter_lists();
2256   wtap_cleanup();
2257   free_progdirs();
2258   cf_close(&cfile);
2259   dfilter_free(dfcode);
2260   return exit_status;
2261 }
2262
2263 #ifdef _WIN32
2264 int
2265 wmain(int argc, wchar_t *wc_argv[])
2266 {
2267   char **argv;
2268
2269   argv = arg_list_utf_16to8(argc, wc_argv);
2270   return real_main(argc, argv);
2271 }
2272 #else
2273 int
2274 main(int argc, char *argv[])
2275 {
2276   return real_main(argc, argv);
2277 }
2278 #endif
2279
2280 /*#define USE_BROKEN_G_MAIN_LOOP*/
2281
2282 #ifdef USE_BROKEN_G_MAIN_LOOP
2283   GMainLoop *loop;
2284 #else
2285   gboolean loop_running = FALSE;
2286 #endif
2287   guint32 packet_count = 0;
2288
2289
2290 typedef struct pipe_input_tag {
2291   gint             source;
2292   gpointer         user_data;
2293   ws_process_id   *child_process;
2294   pipe_input_cb_t  input_cb;
2295   guint            pipe_input_id;
2296 #ifdef _WIN32
2297   GMutex          *callback_running;
2298 #endif
2299 } pipe_input_t;
2300
2301 static pipe_input_t pipe_input;
2302
2303 #ifdef _WIN32
2304 /* The timer has expired, see if there's stuff to read from the pipe,
2305    if so, do the callback */
2306 static gint
2307 pipe_timer_cb(gpointer data)
2308 {
2309   HANDLE        handle;
2310   DWORD         avail        = 0;
2311   gboolean      result;
2312   DWORD         childstatus;
2313   pipe_input_t *pipe_input_p = data;
2314   gint          iterations   = 0;
2315
2316   g_mutex_lock (pipe_input_p->callback_running);
2317
2318   /* try to read data from the pipe only 5 times, to avoid blocking */
2319   while(iterations < 5) {
2320     /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: new iteration");*/
2321
2322     /* Oddly enough although Named pipes don't work on win9x,
2323        PeekNamedPipe does !!! */
2324     handle = (HANDLE) _get_osfhandle (pipe_input_p->source);
2325     result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
2326
2327     /* Get the child process exit status */
2328     GetExitCodeProcess((HANDLE)*(pipe_input_p->child_process),
2329                        &childstatus);
2330
2331     /* If the Peek returned an error, or there are bytes to be read
2332        or the childwatcher thread has terminated then call the normal
2333        callback */
2334     if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
2335
2336       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: data avail");*/
2337
2338       /* And call the real handler */
2339       if (!pipe_input_p->input_cb(pipe_input_p->source, pipe_input_p->user_data)) {
2340         g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
2341         /* pipe closed, return false so that the timer is stopped */
2342         g_mutex_unlock (pipe_input_p->callback_running);
2343         return FALSE;
2344       }
2345     }
2346     else {
2347       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: no data avail");*/
2348       /* No data, stop now */
2349       break;
2350     }
2351
2352     iterations++;
2353   }
2354
2355   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: finished with iterations: %u, new timer", iterations);*/
2356
2357   g_mutex_unlock (pipe_input_p->callback_running);
2358
2359   /* we didn't stopped the timer, so let it run */
2360   return TRUE;
2361 }
2362 #endif
2363
2364
2365 void
2366 pipe_input_set_handler(gint source, gpointer user_data, ws_process_id *child_process, pipe_input_cb_t input_cb)
2367 {
2368
2369   pipe_input.source         = source;
2370   pipe_input.child_process  = child_process;
2371   pipe_input.user_data      = user_data;
2372   pipe_input.input_cb       = input_cb;
2373
2374 #ifdef _WIN32
2375   pipe_input.callback_running = g_malloc(sizeof(GMutex));
2376   g_mutex_init(pipe_input.callback_running);
2377   /* Tricky to use pipes in win9x, as no concept of wait.  NT can
2378      do this but that doesn't cover all win32 platforms.  GTK can do
2379      this but doesn't seem to work over processes.  Attempt to do
2380      something similar here, start a timer and check for data on every
2381      timeout. */
2382   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
2383   pipe_input.pipe_input_id = g_timeout_add(200, pipe_timer_cb, &pipe_input);
2384 #endif
2385 }
2386
2387 static const nstime_t *
2388 tshark_get_frame_ts(struct packet_provider_data *prov, guint32 frame_num)
2389 {
2390   if (prov->ref && prov->ref->num == frame_num)
2391     return &prov->ref->abs_ts;
2392
2393   if (prov->prev_dis && prov->prev_dis->num == frame_num)
2394     return &prov->prev_dis->abs_ts;
2395
2396   if (prov->prev_cap && prov->prev_cap->num == frame_num)
2397     return &prov->prev_cap->abs_ts;
2398
2399   if (prov->frames) {
2400      frame_data *fd = frame_data_sequence_find(prov->frames, frame_num);
2401
2402      return (fd) ? &fd->abs_ts : NULL;
2403   }
2404
2405   return NULL;
2406 }
2407
2408 static epan_t *
2409 tshark_epan_new(capture_file *cf)
2410 {
2411   static const struct packet_provider_funcs funcs = {
2412     tshark_get_frame_ts,
2413     cap_file_provider_get_interface_name,
2414     cap_file_provider_get_interface_description,
2415     NULL,
2416   };
2417
2418   return epan_new(&cf->provider, &funcs);
2419 }
2420
2421 #ifdef HAVE_LIBPCAP
2422 static gboolean
2423 capture(void)
2424 {
2425   volatile gboolean ret = TRUE;
2426   guint             i;
2427   GString          *str;
2428 #ifdef USE_TSHARK_SELECT
2429   fd_set            readfds;
2430 #endif
2431 #ifndef _WIN32
2432   struct sigaction  action, oldaction;
2433 #endif
2434
2435   /* Create new dissection section. */
2436   epan_free(cfile.epan);
2437   cfile.epan = tshark_epan_new(&cfile);
2438
2439 #ifdef _WIN32
2440   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
2441   SetConsoleCtrlHandler(capture_cleanup, TRUE);
2442 #else /* _WIN32 */
2443   /* Catch SIGINT and SIGTERM and, if we get either of them,
2444      clean up and exit.  If SIGHUP isn't being ignored, catch
2445      it too and, if we get it, clean up and exit.
2446
2447      We restart any read that was in progress, so that it doesn't
2448      disrupt reading from the sync pipe.  The signal handler tells
2449      the capture child to finish; it will report that it finished,
2450      or will exit abnormally, so  we'll stop reading from the sync
2451      pipe, pick up the exit status, and quit. */
2452   memset(&action, 0, sizeof(action));
2453   action.sa_handler = capture_cleanup;
2454   action.sa_flags = SA_RESTART;
2455   sigemptyset(&action.sa_mask);
2456   sigaction(SIGTERM, &action, NULL);
2457   sigaction(SIGINT, &action, NULL);
2458   sigaction(SIGHUP, NULL, &oldaction);
2459   if (oldaction.sa_handler == SIG_DFL)
2460     sigaction(SIGHUP, &action, NULL);
2461
2462 #ifdef SIGINFO
2463   /* Catch SIGINFO and, if we get it and we're capturing to a file in
2464      quiet mode, report the number of packets we've captured.
2465
2466      Again, restart any read that was in progress, so that it doesn't
2467      disrupt reading from the sync pipe. */
2468   action.sa_handler = report_counts_siginfo;
2469   action.sa_flags = SA_RESTART;
2470   sigemptyset(&action.sa_mask);
2471   sigaction(SIGINFO, &action, NULL);
2472 #endif /* SIGINFO */
2473 #endif /* _WIN32 */
2474
2475   global_capture_session.state = CAPTURE_PREPARING;
2476
2477   /* Let the user know which interfaces were chosen. */
2478   for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2479     interface_options *interface_opts;
2480
2481     interface_opts = &g_array_index(global_capture_opts.ifaces, interface_options, i);
2482     interface_opts->descr = get_interface_descriptive_name(interface_opts->name);
2483   }
2484   str = get_iface_list_string(&global_capture_opts, IFLIST_QUOTE_IF_DESCRIPTION);
2485   if (really_quiet == FALSE)
2486     fprintf(stderr, "Capturing on %s\n", str->str);
2487   fflush(stderr);
2488   g_string_free(str, TRUE);
2489
2490   ret = sync_pipe_start(&global_capture_opts, &global_capture_session, &global_info_data, NULL);
2491
2492   if (!ret)
2493     return FALSE;
2494
2495   /*
2496    * Force synchronous resolution of IP addresses; we're doing only
2497    * one pass, so we can't do it in the background and fix up past
2498    * dissections.
2499    */
2500   set_resolution_synchrony(TRUE);
2501
2502   /* the actual capture loop
2503    *
2504    * XXX - glib doesn't seem to provide any event based loop handling.
2505    *
2506    * XXX - for whatever reason,
2507    * calling g_main_loop_new() ends up in 100% cpu load.
2508    *
2509    * But that doesn't matter: in UNIX we can use select() to find an input
2510    * source with something to do.
2511    *
2512    * But that doesn't matter because we're in a CLI (that doesn't need to
2513    * update a GUI or something at the same time) so it's OK if we block
2514    * trying to read from the pipe.
2515    *
2516    * So all the stuff in USE_TSHARK_SELECT could be removed unless I'm
2517    * wrong (but I leave it there in case I am...).
2518    */
2519
2520 #ifdef USE_TSHARK_SELECT
2521   FD_ZERO(&readfds);
2522   FD_SET(pipe_input.source, &readfds);
2523 #endif
2524
2525   loop_running = TRUE;
2526
2527   TRY
2528   {
2529     while (loop_running)
2530     {
2531 #ifdef USE_TSHARK_SELECT
2532       ret = select(pipe_input.source+1, &readfds, NULL, NULL, NULL);
2533
2534       if (ret == -1)
2535       {
2536         fprintf(stderr, "%s: %s\n", "select()", g_strerror(errno));
2537         ret = TRUE;
2538         loop_running = FALSE;
2539       } else if (ret == 1) {
2540 #endif
2541         /* Call the real handler */
2542         if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
2543           g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
2544           ret = FALSE;
2545           loop_running = FALSE;
2546         }
2547 #ifdef USE_TSHARK_SELECT
2548       }
2549 #endif
2550     }
2551   }
2552   CATCH(OutOfMemoryError) {
2553     fprintf(stderr,
2554             "Out Of Memory.\n"
2555             "\n"
2556             "Sorry, but TShark has to terminate now.\n"
2557             "\n"
2558             "More information and workarounds can be found at\n"
2559             "https://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2560     abort();
2561   }
2562   ENDTRY;
2563   return ret;
2564 }
2565
2566 /* capture child detected an error */
2567 void
2568 capture_input_error_message(capture_session *cap_session _U_, char *error_msg, char *secondary_error_msg)
2569 {
2570   cmdarg_err("%s", error_msg);
2571   cmdarg_err_cont("%s", secondary_error_msg);
2572 }
2573
2574
2575 /* capture child detected an capture filter related error */
2576 void
2577 capture_input_cfilter_error_message(capture_session *cap_session, guint i, char *error_message)
2578 {
2579   capture_options *capture_opts = cap_session->capture_opts;
2580   dfilter_t         *rfcode = NULL;
2581   interface_options *interface_opts;
2582
2583   g_assert(i < capture_opts->ifaces->len);
2584   interface_opts = &g_array_index(capture_opts->ifaces, interface_options, i);
2585
2586   if (dfilter_compile(interface_opts->cfilter, &rfcode, NULL) && rfcode != NULL) {
2587     cmdarg_err(
2588       "Invalid capture filter \"%s\" for interface '%s'.\n"
2589       "\n"
2590       "That string looks like a valid display filter; however, it isn't a valid\n"
2591       "capture filter (%s).\n"
2592       "\n"
2593       "Note that display filters and capture filters don't have the same syntax,\n"
2594       "so you can't use most display filter expressions as capture filters.\n"
2595       "\n"
2596       "See the User's Guide for a description of the capture filter syntax.",
2597       interface_opts->cfilter, interface_opts->descr, error_message);
2598     dfilter_free(rfcode);
2599   } else {
2600     cmdarg_err(
2601       "Invalid capture filter \"%s\" for interface '%s'.\n"
2602       "\n"
2603       "That string isn't a valid capture filter (%s).\n"
2604       "See the User's Guide for a description of the capture filter syntax.",
2605       interface_opts->cfilter, interface_opts->descr, error_message);
2606   }
2607 }
2608
2609
2610 /* capture child tells us we have a new (or the first) capture file */
2611 gboolean
2612 capture_input_new_file(capture_session *cap_session, gchar *new_file)
2613 {
2614   capture_options *capture_opts = cap_session->capture_opts;
2615   capture_file *cf = (capture_file *) cap_session->cf;
2616   gboolean is_tempfile;
2617   int      err;
2618
2619   if (cap_session->state == CAPTURE_PREPARING) {
2620     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started.");
2621   }
2622   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
2623
2624   g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
2625
2626   /* free the old filename */
2627   if (capture_opts->save_file != NULL) {
2628
2629     /* we start a new capture file, close the old one (if we had one before) */
2630     if (cf->state != FILE_CLOSED) {
2631       if (cf->provider.wth != NULL) {
2632         wtap_close(cf->provider.wth);
2633         cf->provider.wth = NULL;
2634       }
2635       cf->state = FILE_CLOSED;
2636     }
2637
2638     g_free(capture_opts->save_file);
2639     is_tempfile = FALSE;
2640
2641     epan_free(cf->epan);
2642     cf->epan = tshark_epan_new(cf);
2643   } else {
2644     /* we didn't had a save_file before, must be a tempfile */
2645     is_tempfile = TRUE;
2646   }
2647
2648   /* save the new filename */
2649   capture_opts->save_file = g_strdup(new_file);
2650
2651   /* if we are in real-time mode, open the new file now */
2652   if (do_dissection) {
2653     /* this is probably unecessary, but better safe than sorry */
2654     ((capture_file *)cap_session->cf)->open_type = WTAP_TYPE_AUTO;
2655     /* Attempt to open the capture file and set up to read from it. */
2656     switch(cf_open((capture_file *)cap_session->cf, capture_opts->save_file, WTAP_TYPE_AUTO, is_tempfile, &err)) {
2657     case CF_OK:
2658       break;
2659     case CF_ERROR:
2660       /* Don't unlink (delete) the save file - leave it around,
2661          for debugging purposes. */
2662       g_free(capture_opts->save_file);
2663       capture_opts->save_file = NULL;
2664       return FALSE;
2665     }
2666   }
2667
2668   cap_session->state = CAPTURE_RUNNING;
2669
2670   return TRUE;
2671 }
2672
2673
2674 /* capture child tells us we have new packets to read */
2675 void
2676 capture_input_new_packets(capture_session *cap_session, int to_read)
2677 {
2678   gboolean      ret;
2679   int           err;
2680   gchar        *err_info;
2681   gint64        data_offset;
2682   capture_file *cf = (capture_file *)cap_session->cf;
2683   gboolean      filtering_tap_listeners;
2684   guint         tap_flags;
2685
2686 #ifdef SIGINFO
2687   /*
2688    * Prevent a SIGINFO handler from writing to the standard error while
2689    * we're doing so or writing to the standard output; instead, have it
2690    * just set a flag telling us to print that information when we're done.
2691    */
2692   infodelay = TRUE;
2693 #endif /* SIGINFO */
2694
2695   /* Do we have any tap listeners with filters? */
2696   filtering_tap_listeners = have_filtering_tap_listeners();
2697
2698   /* Get the union of the flags for all tap listeners. */
2699   tap_flags = union_of_tap_listener_flags();
2700
2701   if (do_dissection) {
2702     gboolean create_proto_tree;
2703     epan_dissect_t *edt;
2704
2705     /*
2706      * Determine whether we need to create a protocol tree.
2707      * We do if:
2708      *
2709      *    we're going to apply a read filter;
2710      *
2711      *    we're going to apply a display filter;
2712      *
2713      *    we're going to print the protocol tree;
2714      *
2715      *    one of the tap listeners is going to apply a filter;
2716      *
2717      *    one of the tap listeners requires a protocol tree;
2718      *
2719      *    a postdissector wants field values or protocols
2720      *    on the first pass;
2721      *
2722      *    we have custom columns (which require field values, which
2723      *    currently requires that we build a protocol tree).
2724      */
2725     create_proto_tree =
2726       (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
2727         (tap_flags & TL_REQUIRES_PROTO_TREE) || postdissectors_want_hfids() ||
2728         have_custom_cols(&cf->cinfo) || dissect_color);
2729
2730     /* The protocol tree will be "visible", i.e., printed, only if we're
2731        printing packet details, which is true if we're printing stuff
2732        ("print_packet_info" is true) and we're in verbose mode
2733        ("packet_details" is true). */
2734     edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
2735
2736     while (to_read-- && cf->provider.wth) {
2737       wtap_cleareof(cf->provider.wth);
2738       ret = wtap_read(cf->provider.wth, &err, &err_info, &data_offset);
2739       reset_epan_mem(cf, edt, create_proto_tree, print_packet_info && print_details);
2740       if (ret == FALSE) {
2741         /* read from file failed, tell the capture child to stop */
2742         sync_pipe_stop(cap_session);
2743         wtap_close(cf->provider.wth);
2744         cf->provider.wth = NULL;
2745       } else {
2746         ret = process_packet_single_pass(cf, edt, data_offset,
2747                                          wtap_get_rec(cf->provider.wth),
2748                                          wtap_get_buf_ptr(cf->provider.wth), tap_flags);
2749       }
2750       if (ret != FALSE) {
2751         /* packet successfully read and gone through the "Read Filter" */
2752         packet_count++;
2753       }
2754     }
2755
2756     epan_dissect_free(edt);
2757
2758   } else {
2759     /*
2760      * Dumpcap's doing all the work; we're not doing any dissection.
2761      * Count all the packets it wrote.
2762      */
2763     packet_count += to_read;
2764   }
2765
2766   if (print_packet_counts) {
2767       /* We're printing packet counts. */
2768       if (packet_count != 0) {
2769         fprintf(stderr, "\r%u ", packet_count);
2770         /* stderr could be line buffered */
2771         fflush(stderr);
2772       }
2773   }
2774
2775 #ifdef SIGINFO
2776   /*
2777    * Allow SIGINFO handlers to write.
2778    */
2779   infodelay = FALSE;
2780
2781   /*
2782    * If a SIGINFO handler asked us to write out capture counts, do so.
2783    */
2784   if (infoprint)
2785     report_counts();
2786 #endif /* SIGINFO */
2787 }
2788
2789 static void
2790 report_counts(void)
2791 {
2792   if ((print_packet_counts == FALSE) && (really_quiet == FALSE)) {
2793     /* Report the count only if we aren't printing a packet count
2794        as packets arrive. */
2795       fprintf(stderr, "%u packet%s captured\n", packet_count,
2796             plurality(packet_count, "", "s"));
2797   }
2798 #ifdef SIGINFO
2799   infoprint = FALSE; /* we just reported it */
2800 #endif /* SIGINFO */
2801 }
2802
2803 #ifdef SIGINFO
2804 static void
2805 report_counts_siginfo(int signum _U_)
2806 {
2807   int sav_errno = errno;
2808   /* If we've been told to delay printing, just set a flag asking
2809      that we print counts (if we're supposed to), otherwise print
2810      the count of packets captured (if we're supposed to). */
2811   if (infodelay)
2812     infoprint = TRUE;
2813   else
2814     report_counts();
2815   errno = sav_errno;
2816 }
2817 #endif /* SIGINFO */
2818
2819
2820 /* capture child detected any packet drops? */
2821 void
2822 capture_input_drops(capture_session *cap_session _U_, guint32 dropped)
2823 {
2824   if (print_packet_counts) {
2825     /* We're printing packet counts to stderr.
2826        Send a newline so that we move to the line after the packet count. */
2827     fprintf(stderr, "\n");
2828   }
2829
2830   if (dropped != 0) {
2831     /* We're printing packet counts to stderr.
2832        Send a newline so that we move to the line after the packet count. */
2833     fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2834   }
2835 }
2836
2837
2838 /*
2839  * Capture child closed its side of the pipe, report any error and
2840  * do the required cleanup.
2841  */
2842 void
2843 capture_input_closed(capture_session *cap_session, gchar *msg)
2844 {
2845   capture_file *cf = (capture_file *) cap_session->cf;
2846
2847   if (msg != NULL)
2848     fprintf(stderr, "tshark: %s\n", msg);
2849
2850   report_counts();
2851
2852   if (cf != NULL && cf->provider.wth != NULL) {
2853     wtap_close(cf->provider.wth);
2854     if (cf->is_tempfile) {
2855       ws_unlink(cf->filename);
2856     }
2857   }
2858 #ifdef USE_BROKEN_G_MAIN_LOOP
2859   /*g_main_loop_quit(loop);*/
2860   g_main_loop_quit(loop);
2861 #else
2862   loop_running = FALSE;
2863 #endif
2864 }
2865
2866
2867
2868
2869 #ifdef _WIN32
2870 static BOOL WINAPI
2871 capture_cleanup(DWORD ctrltype _U_)
2872 {
2873   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2874      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2875      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2876      like SIGTERM at least when the machine's shutting down.
2877
2878      For now, we handle them all as indications that we should clean up
2879      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2880      way on UNIX.
2881
2882      We must return TRUE so that no other handler - such as one that would
2883      terminate the process - gets called.
2884
2885      XXX - for some reason, typing ^C to TShark, if you run this in
2886      a Cygwin console window in at least some versions of Cygwin,
2887      causes TShark to terminate immediately; this routine gets
2888      called, but the main loop doesn't get a chance to run and
2889      exit cleanly, at least if this is compiled with Microsoft Visual
2890      C++ (i.e., it's a property of the Cygwin console window or Bash;
2891      it happens if TShark is not built with Cygwin - for all I know,
2892      building it with Cygwin may make the problem go away). */
2893
2894   /* tell the capture child to stop */
2895   sync_pipe_stop(&global_capture_session);
2896
2897   /* don't stop our own loop already here, otherwise status messages and
2898    * cleanup wouldn't be done properly. The child will indicate the stop of
2899    * everything by calling capture_input_closed() later */
2900
2901   return TRUE;
2902 }
2903 #else
2904 static void
2905 capture_cleanup(int signum _U_)
2906 {
2907   /* tell the capture child to stop */
2908   sync_pipe_stop(&global_capture_session);
2909
2910   /* don't stop our own loop already here, otherwise status messages and
2911    * cleanup wouldn't be done properly. The child will indicate the stop of
2912    * everything by calling capture_input_closed() later */
2913 }
2914 #endif /* _WIN32 */
2915 #endif /* HAVE_LIBPCAP */
2916
2917 static gboolean
2918 process_packet_first_pass(capture_file *cf, epan_dissect_t *edt,
2919                           gint64 offset, wtap_rec *rec,
2920                           const guchar *pd)
2921 {
2922   frame_data     fdlocal;
2923   guint32        framenum;
2924   gboolean       passed;
2925
2926   /* The frame number of this packet is one more than the count of
2927      frames in this packet. */
2928   framenum = cf->count + 1;
2929
2930   /* If we're not running a display filter and we're not printing any
2931      packet information, we don't need to do a dissection. This means
2932      that all packets can be marked as 'passed'. */
2933   passed = TRUE;
2934
2935   frame_data_init(&fdlocal, framenum, rec, offset, cum_bytes);
2936
2937   /* If we're going to run a read filter or a display filter, set up to
2938      do a dissection and do so.  (This is the first pass of two passes
2939      over the packets, so we will not be printing any information
2940      from the dissection or running taps on the packet; if we're doing
2941      any of that, we'll do it in the second pass.) */
2942   if (edt) {
2943     /* If we're running a read filter, prime the epan_dissect_t with that
2944        filter. */
2945     if (cf->rfcode)
2946       epan_dissect_prime_with_dfilter(edt, cf->rfcode);
2947
2948     if (cf->dfcode)
2949       epan_dissect_prime_with_dfilter(edt, cf->dfcode);
2950
2951     /* This is the first pass, so prime the epan_dissect_t with the
2952        hfids postdissectors want on the first pass. */
2953     prime_epan_dissect_with_postdissector_wanted_hfids(edt);
2954
2955     frame_data_set_before_dissect(&fdlocal, &cf->elapsed_time,
2956                                   &cf->provider.ref, cf->provider.prev_dis);
2957     if (cf->provider.ref == &fdlocal) {
2958       ref_frame = fdlocal;
2959       cf->provider.ref = &ref_frame;
2960     }
2961
2962     epan_dissect_run(edt, cf->cd_t, rec,
2963                      frame_tvbuff_new(&cf->provider, &fdlocal, pd),
2964                      &fdlocal, NULL);
2965
2966     /* Run the read filter if we have one. */
2967     if (cf->rfcode)
2968       passed = dfilter_apply_edt(cf->rfcode, edt);
2969   }
2970
2971   if (passed) {
2972     frame_data_set_after_dissect(&fdlocal, &cum_bytes);
2973     cf->provider.prev_cap = cf->provider.prev_dis = frame_data_sequence_add(cf->provider.frames, &fdlocal);
2974
2975     /* If we're not doing dissection then there won't be any dependent frames.
2976      * More importantly, edt.pi.dependent_frames won't be initialized because
2977      * epan hasn't been initialized.
2978      * if we *are* doing dissection, then mark the dependent frames, but only
2979      * if a display filter was given and it matches this packet.
2980      */
2981     if (edt && cf->dfcode) {
2982       if (dfilter_apply_edt(cf->dfcode, edt)) {
2983         g_slist_foreach(edt->pi.dependent_frames, find_and_mark_frame_depended_upon, cf->provider.frames);
2984       }
2985     }
2986
2987     cf->count++;
2988   } else {
2989     /* if we don't add it to the frame_data_sequence, clean it up right now
2990      * to avoid leaks */
2991     frame_data_destroy(&fdlocal);
2992   }
2993
2994   if (edt)
2995     epan_dissect_reset(edt);
2996
2997   return passed;
2998 }
2999
3000 static gboolean
3001 process_packet_second_pass(capture_file *cf, epan_dissect_t *edt,
3002                            frame_data *fdata, wtap_rec *rec,
3003                            Buffer *buf, guint tap_flags)
3004 {
3005   column_info    *cinfo;
3006   gboolean        passed;
3007
3008   /* If we're not running a display filter and we're not printing any
3009      packet information, we don't need to do a dissection. This means
3010      that all packets can be marked as 'passed'. */
3011   passed = TRUE;
3012
3013   /* If we're going to print packet information, or we're going to
3014      run a read filter, or we're going to process taps, set up to
3015      do a dissection and do so.  (This is the second pass of two
3016      passes over the packets; that's the pass where we print
3017      packet information or run taps.) */
3018   if (edt) {
3019     /* If we're running a display filter, prime the epan_dissect_t with that
3020        filter. */
3021     if (cf->dfcode)
3022       epan_dissect_prime_with_dfilter(edt, cf->dfcode);
3023
3024     col_custom_prime_edt(edt, &cf->cinfo);
3025
3026     /* We only need the columns if either
3027          1) some tap needs the columns
3028        or
3029          2) we're printing packet info but we're *not* verbose; in verbose
3030             mode, we print the protocol tree, not the protocol summary.
3031      */
3032     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
3033       cinfo = &cf->cinfo;
3034     else
3035       cinfo = NULL;
3036
3037     frame_data_set_before_dissect(fdata, &cf->elapsed_time,
3038                                   &cf->provider.ref, cf->provider.prev_dis);
3039     if (cf->provider.ref == fdata) {
3040       ref_frame = *fdata;
3041       cf->provider.ref = &ref_frame;
3042     }
3043
3044     if (dissect_color) {
3045       color_filters_prime_edt(edt);
3046       fdata->flags.need_colorize = 1;
3047     }
3048
3049     epan_dissect_run_with_taps(edt, cf->cd_t, rec,
3050                                frame_tvbuff_new_buffer(&cf->provider, fdata, buf),
3051                                fdata, cinfo);
3052
3053     /* Run the read/display filter if we have one. */
3054     if (cf->dfcode)
3055       passed = dfilter_apply_edt(cf->dfcode, edt);
3056   }
3057
3058   if (passed) {
3059     frame_data_set_after_dissect(fdata, &cum_bytes);
3060     /* Process this packet. */
3061     if (print_packet_info) {
3062       /* We're printing packet information; print the information for
3063          this packet. */
3064       print_packet(cf, edt);
3065
3066       /* If we're doing "line-buffering", flush the standard output
3067          after every packet.  See the comment above, for the "-l"
3068          option, for an explanation of why we do that. */
3069       if (line_buffered)
3070         fflush(stdout);
3071
3072       if (ferror(stdout)) {
3073         show_print_file_io_error(errno);
3074         exit(2);
3075       }
3076     }
3077     cf->provider.prev_dis = fdata;
3078   }
3079   cf->provider.prev_cap = fdata;
3080
3081   if (edt) {
3082     epan_dissect_reset(edt);
3083   }
3084   return passed || fdata->flags.dependent_of_displayed;
3085 }
3086
3087 static gboolean
3088 process_cap_file(capture_file *cf, char *save_file, int out_file_type,
3089     gboolean out_file_name_res, int max_packet_count, gint64 max_byte_count)
3090 {
3091   gboolean     success = TRUE;
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   wtap_dump_params params = WTAP_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     wtap_dump_params_init(&params, cf->provider.wth);
3110
3111     /* If we don't have an application name add Tshark */
3112     if (wtap_block_get_string_option_value(g_array_index(params.shb_hdrs, wtap_block_t, 0), OPT_SHB_USERAPPL, &shb_user_appl) != WTAP_OPTTYPE_SUCCESS) {
3113         /* this is free'd by wtap_block_free() later */
3114         wtap_block_add_string_option_format(g_array_index(params.shb_hdrs, wtap_block_t, 0), OPT_SHB_USERAPPL, "TShark (Wireshark) %s", get_ws_vcs_version_info());
3115     }
3116
3117     tshark_debug("tshark: writing format type %d, to %s", out_file_type, save_file);
3118     if (strcmp(save_file, "-") == 0) {
3119       /* Write to the standard output. */
3120       pdh = wtap_dump_open_stdout(out_file_type, WTAP_UNCOMPRESSED, &params,
3121                                   &err);
3122     } else {
3123       pdh = wtap_dump_open(save_file, out_file_type, WTAP_UNCOMPRESSED, &params,
3124                            &err);
3125     }
3126
3127     g_free(params.idb_inf);
3128     params.idb_inf = NULL;
3129
3130     if (pdh == NULL) {
3131       /* We couldn't set up to write to the capture file. */
3132       cfile_dump_open_failure_message("TShark", save_file, err, out_file_type);
3133       success = FALSE;
3134       goto out;
3135     }
3136   } else {
3137     /* Set up to print packet information. */
3138     if (print_packet_info) {
3139       if (!write_preamble(cf)) {
3140         show_print_file_io_error(errno);
3141         success = FALSE;
3142         goto out;
3143       }
3144     }
3145     pdh = NULL;
3146   }
3147
3148   /* Do we have any tap listeners with filters? */
3149   filtering_tap_listeners = have_filtering_tap_listeners();
3150
3151   /* Get the union of the flags for all tap listeners. */
3152   tap_flags = union_of_tap_listener_flags();
3153
3154   if (perform_two_pass_analysis) {
3155     frame_data *fdata;
3156
3157     tshark_debug("tshark: perform_two_pass_analysis, do_dissection=%s", do_dissection ? "TRUE" : "FALSE");
3158
3159     /* Allocate a frame_data_sequence for all the frames. */
3160     cf->provider.frames = new_frame_data_sequence();
3161
3162     if (do_dissection) {
3163       gboolean create_proto_tree;
3164
3165       /*
3166        * Determine whether we need to create a protocol tree.
3167        * We do if:
3168        *
3169        *    we're going to apply a read filter;
3170        *
3171        *    we're going to apply a display filter;
3172        *
3173        *    a postdissector wants field values or protocols
3174        *    on the first pass.
3175        */
3176       create_proto_tree =
3177         (cf->rfcode != NULL || cf->dfcode != NULL || postdissectors_want_hfids() || dissect_color);
3178
3179       tshark_debug("tshark: create_proto_tree = %s", create_proto_tree ? "TRUE" : "FALSE");
3180
3181       /* We're not going to display the protocol tree on this pass,
3182          so it's not going to be "visible". */
3183       edt = epan_dissect_new(cf->epan, create_proto_tree, FALSE);
3184     }
3185
3186     tshark_debug("tshark: reading records for first pass");
3187     while (wtap_read(cf->provider.wth, &err, &err_info, &data_offset)) {
3188       if (process_packet_first_pass(cf, edt, data_offset, wtap_get_rec(cf->provider.wth),
3189                                     wtap_get_buf_ptr(cf->provider.wth))) {
3190         /* Stop reading if we have the maximum number of packets;
3191          * When the -c option has not been used, max_packet_count
3192          * starts at 0, which practically means, never stop reading.
3193          * (unless we roll over max_packet_count ?)
3194          */
3195         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3196           tshark_debug("tshark: max_packet_count (%d) or max_byte_count (%" G_GINT64_MODIFIER "d/%" G_GINT64_MODIFIER "d) reached",
3197                         max_packet_count, data_offset, max_byte_count);
3198           err = 0; /* This is not an error */
3199           break;
3200         }
3201       }
3202     }
3203
3204     /*
3205      * If we got a read error on the first pass, remember the error, so
3206      * but do the second pass, so we can at least process the packets we
3207      * read, and then report the first-pass error after the second pass
3208      * (and before we report any second-pass errors), so all the the
3209      * errors show up at the end.
3210      */
3211     if (err != 0) {
3212       err_pass1 = err;
3213       err_info_pass1 = err_info;
3214       err = 0;
3215       err_info = NULL;
3216     }
3217
3218     if (edt) {
3219       epan_dissect_free(edt);
3220       edt = NULL;
3221     }
3222
3223     /* Close the sequential I/O side, to free up memory it requires. */
3224     wtap_sequential_close(cf->provider.wth);
3225
3226     /* Allow the protocol dissectors to free up memory that they
3227      * don't need after the sequential run-through of the packets. */
3228     postseq_cleanup_all_protocols();
3229
3230     cf->provider.prev_dis = NULL;
3231     cf->provider.prev_cap = NULL;
3232     ws_buffer_init(&buf, 1500);
3233
3234     tshark_debug("tshark: done with first pass");
3235
3236     if (do_dissection) {
3237       gboolean create_proto_tree;
3238
3239       /*
3240        * Determine whether we need to create a protocol tree.
3241        * We do if:
3242        *
3243        *    we're going to apply a display filter;
3244        *
3245        *    we're going to print the protocol tree;
3246        *
3247        *    one of the tap listeners requires a protocol tree;
3248        *
3249        *    we have custom columns (which require field values, which
3250        *    currently requires that we build a protocol tree).
3251        */
3252       create_proto_tree =
3253         (cf->dfcode || print_details || filtering_tap_listeners ||
3254          (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo) || dissect_color);
3255
3256       tshark_debug("tshark: create_proto_tree = %s", create_proto_tree ? "TRUE" : "FALSE");
3257
3258       /* The protocol tree will be "visible", i.e., printed, only if we're
3259          printing packet details, which is true if we're printing stuff
3260          ("print_packet_info" is true) and we're in verbose mode
3261          ("packet_details" is true). */
3262       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
3263     }
3264
3265     /*
3266      * Force synchronous resolution of IP addresses; in this pass, we
3267      * can't do it in the background and fix up past dissections.
3268      */
3269     set_resolution_synchrony(TRUE);
3270
3271     for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
3272       fdata = frame_data_sequence_find(cf->provider.frames, framenum);
3273       if (wtap_seek_read(cf->provider.wth, fdata->file_off, &rec, &buf, &err,
3274                          &err_info)) {
3275         tshark_debug("tshark: invoking process_packet_second_pass() for frame #%d", framenum);
3276         if (process_packet_second_pass(cf, edt, fdata, &rec, &buf,
3277                                        tap_flags)) {
3278           /* Either there's no read filtering or this packet passed the
3279              filter, so, if we're writing to a capture file, write
3280              this packet out. */
3281           if (pdh != NULL) {
3282             tshark_debug("tshark: writing packet #%d to outfile", framenum);
3283             if (!wtap_dump(pdh, &rec, ws_buffer_start_ptr(&buf), &err, &err_info)) {
3284               /* Error writing to a capture file */
3285               tshark_debug("tshark: error writing to a capture file (%d)", err);
3286
3287               /* Report the error.
3288                  XXX - framenum is not necessarily the frame number in
3289                  the input file if there was a read filter. */
3290               cfile_write_failure_message("TShark", cf->filename, save_file,
3291                                           err, err_info, framenum,
3292                                           out_file_type);
3293               wtap_dump_close(pdh, &err);
3294               wtap_dump_params_cleanup(&params);
3295               exit(2);
3296             }
3297           }
3298         }
3299       }
3300     }
3301
3302     if (edt) {
3303       epan_dissect_free(edt);
3304       edt = NULL;
3305     }
3306
3307     ws_buffer_free(&buf);
3308
3309     tshark_debug("tshark: done with second pass");
3310   }
3311   else {
3312     /* !perform_two_pass_analysis */
3313     framenum = 0;
3314     gboolean create_proto_tree = FALSE;
3315     tshark_debug("tshark: perform one pass analysis, do_dissection=%s", do_dissection ? "TRUE" : "FALSE");
3316
3317     if (do_dissection) {
3318       /*
3319        * Determine whether we need to create a protocol tree.
3320        * We do if:
3321        *
3322        *    we're going to apply a read filter;
3323        *
3324        *    we're going to apply a display filter;
3325        *
3326        *    we're going to print the protocol tree;
3327        *
3328        *    one of the tap listeners is going to apply a filter;
3329        *
3330        *    one of the tap listeners requires a protocol tree;
3331        *
3332        *    a postdissector wants field values or protocols
3333        *    on the first pass;
3334        *
3335        *    we have custom columns (which require field values, which
3336        *    currently requires that we build a protocol tree).
3337        */
3338       create_proto_tree =
3339         (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
3340           (tap_flags & TL_REQUIRES_PROTO_TREE) || postdissectors_want_hfids() ||
3341           have_custom_cols(&cf->cinfo) || dissect_color);
3342
3343       tshark_debug("tshark: create_proto_tree = %s", create_proto_tree ? "TRUE" : "FALSE");
3344
3345       /* The protocol tree will be "visible", i.e., printed, only if we're
3346          printing packet details, which is true if we're printing stuff
3347          ("print_packet_info" is true) and we're in verbose mode
3348          ("packet_details" is true). */
3349       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
3350     }
3351
3352     /*
3353      * Force synchronous resolution of IP addresses; we're doing only
3354      * one pass, so we can't do it in the background and fix up past
3355      * dissections.
3356      */
3357     set_resolution_synchrony(TRUE);
3358
3359     while (wtap_read(cf->provider.wth, &err, &err_info, &data_offset)) {
3360       framenum++;
3361
3362       tshark_debug("tshark: processing packet #%d", framenum);
3363
3364       reset_epan_mem(cf, edt, create_proto_tree, print_packet_info && print_details);
3365
3366       if (process_packet_single_pass(cf, edt, data_offset, wtap_get_rec(cf->provider.wth),
3367                                      wtap_get_buf_ptr(cf->provider.wth), tap_flags)) {
3368         /* Either there's no read filtering or this packet passed the
3369            filter, so, if we're writing to a capture file, write
3370            this packet out. */
3371         if (pdh != NULL) {
3372           tshark_debug("tshark: writing packet #%d to outfile", framenum);
3373           if (!wtap_dump(pdh, wtap_get_rec(cf->provider.wth), wtap_get_buf_ptr(cf->provider.wth), &err, &err_info)) {
3374             /* Error writing to a capture file */
3375             tshark_debug("tshark: error writing to a capture file (%d)", err);
3376             cfile_write_failure_message("TShark", cf->filename, save_file,
3377                                         err, err_info, framenum, out_file_type);
3378             wtap_dump_close(pdh, &err);
3379             wtap_dump_params_cleanup(&params);
3380             exit(2);
3381           }
3382         }
3383       }
3384       /* Stop reading if we have the maximum number of packets;
3385        * When the -c option has not been used, max_packet_count
3386        * starts at 0, which practically means, never stop reading.
3387        * (unless we roll over max_packet_count ?)
3388        */
3389       if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3390         tshark_debug("tshark: max_packet_count (%d) or max_byte_count (%" G_GINT64_MODIFIER "d/%" G_GINT64_MODIFIER "d) reached",
3391                       max_packet_count, data_offset, max_byte_count);
3392         err = 0; /* This is not an error */
3393         break;
3394       }
3395     }
3396
3397     if (edt) {
3398       epan_dissect_free(edt);
3399       edt = NULL;
3400     }
3401   }
3402
3403   wtap_rec_cleanup(&rec);
3404
3405   if (err != 0 || err_pass1 != 0) {
3406     tshark_debug("tshark: something failed along the line (%d)", err);
3407     /*
3408      * Print a message noting that the read failed somewhere along the line.
3409      *
3410      * If we're printing packet data, and the standard output and error are
3411      * going to the same place, flush the standard output, so everything
3412      * buffered up is written, and then print a newline to the standard error
3413      * before printing the error message, to separate it from the packet
3414      * data.  (Alas, that only works on UN*X; st_dev is meaningless, and
3415      * the _fstat() documentation at Microsoft doesn't indicate whether
3416      * st_ino is even supported.)
3417      */
3418 #ifndef _WIN32
3419     if (print_packet_info) {
3420       ws_statb64 stat_stdout, stat_stderr;
3421
3422       if (ws_fstat64(1, &stat_stdout) == 0 && ws_fstat64(2, &stat_stderr) == 0) {
3423         if (stat_stdout.st_dev == stat_stderr.st_dev &&
3424             stat_stdout.st_ino == stat_stderr.st_ino) {
3425           fflush(stdout);
3426           fprintf(stderr, "\n");
3427         }
3428       }
3429     }
3430 #endif
3431     if (err_pass1 != 0) {
3432       /* Error on pass 1 of two-pass processing. */
3433       cfile_read_failure_message("TShark", cf->filename, err_pass1,
3434                                  err_info_pass1);
3435     }
3436     if (err != 0) {
3437       /* Error on pass 2 of two-pass processing or on the only pass of
3438          one-pass processing. */
3439       cfile_read_failure_message("TShark", cf->filename, err, err_info);
3440     }
3441     success = FALSE;
3442   }
3443   if (save_file != NULL) {
3444     if (pdh && out_file_name_res) {
3445       if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
3446         cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
3447                    wtap_file_type_subtype_short_string(out_file_type));
3448       }
3449     }
3450     /* Now close the capture file. */
3451     if (!wtap_dump_close(pdh, &err)) {
3452       cfile_close_failure_message(save_file, err);
3453       success = FALSE;
3454     }
3455   } else {
3456     if (print_packet_info) {
3457       if (!write_finale()) {
3458         show_print_file_io_error(errno);
3459         success = FALSE;
3460       }
3461     }
3462   }
3463
3464 out:
3465   wtap_close(cf->provider.wth);
3466   cf->provider.wth = NULL;
3467
3468   wtap_dump_params_cleanup(&params);
3469
3470   return success;
3471 }
3472
3473 static gboolean
3474 process_packet_single_pass(capture_file *cf, epan_dissect_t *edt, gint64 offset,
3475                            wtap_rec *rec, const guchar *pd,
3476                            guint tap_flags)
3477 {
3478   frame_data      fdata;
3479   column_info    *cinfo;
3480   gboolean        passed;
3481
3482   /* Count this packet. */
3483   cf->count++;
3484
3485   /* If we're not running a display filter and we're not printing any
3486      packet information, we don't need to do a dissection. This means
3487      that all packets can be marked as 'passed'. */
3488   passed = TRUE;
3489
3490   frame_data_init(&fdata, cf->count, rec, offset, cum_bytes);
3491
3492   /* If we're going to print packet information, or we're going to
3493      run a read filter, or we're going to process taps, set up to
3494      do a dissection and do so.  (This is the one and only pass
3495      over the packets, so, if we'll be printing packet information
3496      or running taps, we'll be doing it here.) */
3497   if (edt) {
3498     /* If we're running a filter, prime the epan_dissect_t with that
3499        filter. */
3500     if (cf->dfcode)
3501       epan_dissect_prime_with_dfilter(edt, cf->dfcode);
3502
3503     /* This is the first and only pass, so prime the epan_dissect_t
3504        with the hfids postdissectors want on the first pass. */
3505     prime_epan_dissect_with_postdissector_wanted_hfids(edt);
3506
3507     col_custom_prime_edt(edt, &cf->cinfo);
3508
3509     /* We only need the columns if either
3510          1) some tap needs the columns
3511        or
3512          2) we're printing packet info but we're *not* verbose; in verbose
3513             mode, we print the protocol tree, not the protocol summary.
3514        or
3515          3) there is a column mapped as an individual field */
3516     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
3517       cinfo = &cf->cinfo;
3518     else
3519       cinfo = NULL;
3520
3521     frame_data_set_before_dissect(&fdata, &cf->elapsed_time,
3522                                   &cf->provider.ref, cf->provider.prev_dis);
3523     if (cf->provider.ref == &fdata) {
3524       ref_frame = fdata;
3525       cf->provider.ref = &ref_frame;
3526     }
3527
3528     if (dissect_color) {
3529       color_filters_prime_edt(edt);
3530       fdata.flags.need_colorize = 1;
3531     }
3532
3533     epan_dissect_run_with_taps(edt, cf->cd_t, rec,
3534                                frame_tvbuff_new(&cf->provider, &fdata, pd),
3535                                &fdata, cinfo);
3536
3537     /* Run the filter if we have it. */
3538     if (cf->dfcode)
3539       passed = dfilter_apply_edt(cf->dfcode, edt);
3540   }
3541
3542   if (passed) {
3543     frame_data_set_after_dissect(&fdata, &cum_bytes);
3544
3545     /* Process this packet. */
3546     if (print_packet_info) {
3547       /* We're printing packet information; print the information for
3548          this packet. */
3549       g_assert(edt);
3550       print_packet(cf, edt);
3551
3552       /* If we're doing "line-buffering", flush the standard output
3553          after every packet.  See the comment above, for the "-l"
3554          option, for an explanation of why we do that. */
3555       if (line_buffered)
3556         fflush(stdout);
3557
3558       if (ferror(stdout)) {
3559         show_print_file_io_error(errno);
3560         exit(2);
3561       }
3562     }
3563
3564     /* this must be set after print_packet() [bug #8160] */
3565     prev_dis_frame = fdata;
3566     cf->provider.prev_dis = &prev_dis_frame;
3567   }
3568
3569   prev_cap_frame = fdata;
3570   cf->provider.prev_cap = &prev_cap_frame;
3571
3572   if (edt) {
3573     epan_dissect_reset(edt);
3574     frame_data_destroy(&fdata);
3575   }
3576   return passed;
3577 }
3578
3579 static gboolean
3580 write_preamble(capture_file *cf)
3581 {
3582   switch (output_action) {
3583
3584   case WRITE_TEXT:
3585     return print_preamble(print_stream, cf->filename, get_ws_vcs_version_info());
3586
3587   case WRITE_XML:
3588     if (print_details)
3589       write_pdml_preamble(stdout, cf->filename);
3590     else
3591       write_psml_preamble(&cf->cinfo, stdout);
3592     return !ferror(stdout);
3593
3594   case WRITE_FIELDS:
3595     write_fields_preamble(output_fields, stdout);
3596     return !ferror(stdout);
3597
3598   case WRITE_JSON:
3599   case WRITE_JSON_RAW:
3600     write_json_preamble(stdout);
3601     return !ferror(stdout);
3602
3603   case WRITE_EK:
3604     return !ferror(stdout);
3605
3606   default:
3607     g_assert_not_reached();
3608     return FALSE;
3609   }
3610 }
3611
3612 static char *
3613 get_line_buf(size_t len)
3614 {
3615   static char   *line_bufp    = NULL;
3616   static size_t  line_buf_len = 256;
3617   size_t         new_line_buf_len;
3618
3619   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
3620        new_line_buf_len *= 2)
3621     ;
3622   if (line_bufp == NULL) {
3623     line_buf_len = new_line_buf_len;
3624     line_bufp = (char *)g_malloc(line_buf_len + 1);
3625   } else {
3626     if (new_line_buf_len > line_buf_len) {
3627       line_buf_len = new_line_buf_len;
3628       line_bufp = (char *)g_realloc(line_bufp, line_buf_len + 1);
3629     }
3630   }
3631   return line_bufp;
3632 }
3633
3634 static inline void
3635 put_string(char *dest, const char *str, size_t str_len)
3636 {
3637   memcpy(dest, str, str_len);
3638   dest[str_len] = '\0';
3639 }
3640
3641 static inline void
3642 put_spaces_string(char *dest, const char *str, size_t str_len, size_t str_with_spaces)
3643 {
3644   size_t i;
3645
3646   for (i = str_len; i < str_with_spaces; i++)
3647     *dest++ = ' ';
3648
3649   put_string(dest, str, str_len);
3650 }
3651
3652 static inline void
3653 put_string_spaces(char *dest, const char *str, size_t str_len, size_t str_with_spaces)
3654 {
3655   size_t i;
3656
3657   memcpy(dest, str, str_len);
3658   for (i = str_len; i < str_with_spaces; i++)
3659     dest[i] = ' ';
3660
3661   dest[str_with_spaces] = '\0';
3662 }
3663
3664 static gboolean
3665 print_columns(capture_file *cf, const epan_dissect_t *edt)
3666 {
3667   char   *line_bufp;
3668   int     i;
3669   size_t  buf_offset;
3670   size_t  column_len;
3671   size_t  col_len;
3672   col_item_t* col_item;
3673   gchar str_format[11];
3674   const color_filter_t *color_filter = NULL;
3675
3676   line_bufp = get_line_buf(256);
3677   buf_offset = 0;
3678   *line_bufp = '\0';
3679
3680   if (dissect_color)
3681     color_filter = edt->pi.fd->color_filter;
3682
3683   for (i = 0; i < cf->cinfo.num_cols; i++) {
3684     col_item = &cf->cinfo.columns[i];
3685     /* Skip columns not marked as visible. */
3686     if (!get_column_visible(i))
3687       continue;
3688     switch (col_item->col_fmt) {
3689     case COL_NUMBER:
3690       column_len = col_len = strlen(col_item->col_data);
3691       if (column_len < 5)
3692         column_len = 5;
3693       line_bufp = get_line_buf(buf_offset + column_len);
3694       put_spaces_string(line_bufp + buf_offset, col_item->col_data, col_len, column_len);
3695       break;
3696
3697     case COL_CLS_TIME:
3698     case COL_REL_TIME:
3699     case COL_ABS_TIME:
3700     case COL_ABS_YMD_TIME:  /* XXX - wider */
3701     case COL_ABS_YDOY_TIME: /* XXX - wider */
3702     case COL_UTC_TIME:
3703     case COL_UTC_YMD_TIME:  /* XXX - wider */
3704     case COL_UTC_YDOY_TIME: /* XXX - wider */
3705       column_len = col_len = strlen(col_item->col_data);
3706       if (column_len < 10)
3707         column_len = 10;
3708       line_bufp = get_line_buf(buf_offset + column_len);
3709       put_spaces_string(line_bufp + buf_offset, col_item->col_data, col_len, column_len);
3710       break;
3711
3712     case COL_DEF_SRC:
3713     case COL_RES_SRC:
3714     case COL_UNRES_SRC:
3715     case COL_DEF_DL_SRC:
3716     case COL_RES_DL_SRC:
3717     case COL_UNRES_DL_SRC:
3718     case COL_DEF_NET_SRC:
3719     case COL_RES_NET_SRC:
3720     case COL_UNRES_NET_SRC:
3721       column_len = col_len = strlen(col_item->col_data);
3722       if (column_len < 12)
3723         column_len = 12;
3724       line_bufp = get_line_buf(buf_offset + column_len);
3725       put_spaces_string(line_bufp + buf_offset, col_item->col_data, col_len, column_len);
3726       break;
3727
3728     case COL_DEF_DST:
3729     case COL_RES_DST:
3730     case COL_UNRES_DST:
3731     case COL_DEF_DL_DST:
3732     case COL_RES_DL_DST:
3733     case COL_UNRES_DL_DST:
3734     case COL_DEF_NET_DST:
3735     case COL_RES_NET_DST:
3736     case COL_UNRES_NET_DST:
3737       column_len = col_len = strlen(col_item->col_data);
3738       if (column_len < 12)
3739         column_len = 12;
3740       line_bufp = get_line_buf(buf_offset + column_len);
3741       put_string_spaces(line_bufp + buf_offset, col_item->col_data, col_len, column_len);
3742       break;
3743
3744     default:
3745       column_len = strlen(col_item->col_data);
3746       line_bufp = get_line_buf(buf_offset + column_len);
3747       put_string(line_bufp + buf_offset, col_item->col_data, column_len);
3748       break;
3749     }
3750     buf_offset += column_len;
3751     if (i != cf->cinfo.num_cols - 1) {
3752       /*
3753        * This isn't the last column, so we need to print a
3754        * separator between this column and the next.
3755        *
3756        * If we printed a network source and are printing a
3757        * network destination of the same type next, separate
3758        * them with a UTF-8 right arrow; if we printed a network
3759        * destination and are printing a network source of the same
3760        * type next, separate them with a UTF-8 left arrow;
3761        * otherwise separate them with a space.
3762        *
3763        * We add enough space to the buffer for " \xe2\x86\x90 "
3764        * or " \xe2\x86\x92 ", even if we're only adding " ".
3765        */
3766       line_bufp = get_line_buf(buf_offset + 5);
3767       switch (col_item->col_fmt) {
3768
3769       case COL_DEF_SRC:
3770       case COL_RES_SRC:
3771       case COL_UNRES_SRC:
3772         switch (cf->cinfo.columns[i+1].col_fmt) {
3773
3774         case COL_DEF_DST:
3775         case COL_RES_DST:
3776         case COL_UNRES_DST:
3777           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_RIGHTWARDS_ARROW, delimiter_char);
3778           put_string(line_bufp + buf_offset, str_format, 5);
3779           buf_offset += 5;
3780           break;
3781
3782         default:
3783           put_string(line_bufp + buf_offset, delimiter_char, 1);
3784           buf_offset += 1;
3785           break;
3786         }
3787         break;
3788
3789       case COL_DEF_DL_SRC:
3790       case COL_RES_DL_SRC:
3791       case COL_UNRES_DL_SRC:
3792         switch (cf->cinfo.columns[i+1].col_fmt) {
3793
3794         case COL_DEF_DL_DST:
3795         case COL_RES_DL_DST:
3796         case COL_UNRES_DL_DST:
3797           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_RIGHTWARDS_ARROW, delimiter_char);
3798           put_string(line_bufp + buf_offset, str_format, 5);
3799           buf_offset += 5;
3800           break;
3801
3802         default:
3803           put_string(line_bufp + buf_offset, delimiter_char, 1);
3804           buf_offset += 1;
3805           break;
3806         }
3807         break;
3808
3809       case COL_DEF_NET_SRC:
3810       case COL_RES_NET_SRC:
3811       case COL_UNRES_NET_SRC:
3812         switch (cf->cinfo.columns[i+1].col_fmt) {
3813
3814         case COL_DEF_NET_DST:
3815         case COL_RES_NET_DST:
3816         case COL_UNRES_NET_DST:
3817           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_RIGHTWARDS_ARROW, delimiter_char);
3818           put_string(line_bufp + buf_offset, str_format, 5);
3819           buf_offset += 5;
3820           break;
3821
3822         default:
3823           put_string(line_bufp + buf_offset, delimiter_char, 1);
3824           buf_offset += 1;
3825           break;
3826         }
3827         break;
3828
3829       case COL_DEF_DST:
3830       case COL_RES_DST:
3831       case COL_UNRES_DST:
3832         switch (cf->cinfo.columns[i+1].col_fmt) {
3833
3834         case COL_DEF_SRC:
3835         case COL_RES_SRC:
3836         case COL_UNRES_SRC:
3837           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_LEFTWARDS_ARROW, delimiter_char);
3838           put_string(line_bufp + buf_offset, str_format, 5);
3839           buf_offset += 5;
3840           break;
3841
3842         default:
3843           put_string(line_bufp + buf_offset, delimiter_char, 1);
3844           buf_offset += 1;
3845           break;
3846         }
3847         break;
3848
3849       case COL_DEF_DL_DST:
3850       case COL_RES_DL_DST:
3851       case COL_UNRES_DL_DST:
3852         switch (cf->cinfo.columns[i+1].col_fmt) {
3853
3854         case COL_DEF_DL_SRC:
3855         case COL_RES_DL_SRC:
3856         case COL_UNRES_DL_SRC:
3857           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_LEFTWARDS_ARROW, delimiter_char);
3858           put_string(line_bufp + buf_offset, str_format, 5);
3859           buf_offset += 5;
3860           break;
3861
3862         default:
3863           put_string(line_bufp + buf_offset, delimiter_char, 1);
3864           buf_offset += 1;
3865           break;
3866         }
3867         break;
3868
3869       case COL_DEF_NET_DST:
3870       case COL_RES_NET_DST:
3871       case COL_UNRES_NET_DST:
3872         switch (cf->cinfo.columns[i+1].col_fmt) {
3873
3874         case COL_DEF_NET_SRC:
3875         case COL_RES_NET_SRC:
3876         case COL_UNRES_NET_SRC:
3877           g_snprintf(str_format, sizeof(str_format), "%s%s%s", delimiter_char, UTF8_LEFTWARDS_ARROW, delimiter_char);
3878           put_string(line_bufp + buf_offset, str_format, 5);
3879           buf_offset += 5;
3880           break;
3881
3882         default:
3883           put_string(line_bufp + buf_offset, delimiter_char, 1);
3884           buf_offset += 1;
3885           break;
3886         }
3887         break;
3888
3889       default:
3890         put_string(line_bufp + buf_offset, delimiter_char, 1);
3891         buf_offset += 1;
3892         break;
3893       }
3894     }
3895   }
3896
3897   if (dissect_color && color_filter != NULL)
3898     return print_line_color(print_stream, 0, line_bufp, &color_filter->fg_color, &color_filter->bg_color);
3899   else
3900     return print_line(print_stream, 0, line_bufp);
3901 }
3902
3903 static gboolean
3904 print_packet(capture_file *cf, epan_dissect_t *edt)
3905 {
3906   if (print_summary || output_fields_has_cols(output_fields))
3907     /* Just fill in the columns. */
3908     epan_dissect_fill_in_columns(edt, FALSE, TRUE);
3909
3910   /* Print summary columns and/or protocol tree */
3911   switch (output_action) {
3912
3913   case WRITE_TEXT:
3914     if (print_summary && !print_columns(cf, edt))
3915         return FALSE;
3916     if (print_details) {
3917       if (!proto_tree_print(print_details ? print_dissections_expanded : print_dissections_none,
3918                             print_hex, edt, output_only_tables, print_stream))
3919         return FALSE;
3920       if (!print_hex) {
3921         if (!print_line(print_stream, 0, separator))
3922           return FALSE;
3923       }
3924     }
3925     break;
3926
3927   case WRITE_XML:
3928     if (print_summary) {
3929       write_psml_columns(edt, stdout, dissect_color);
3930       return !ferror(stdout);
3931     }
3932     if (print_details) {
3933       write_pdml_proto_tree(output_fields, protocolfilter, protocolfilter_flags, edt, &cf->cinfo, stdout, dissect_color);
3934       printf("\n");
3935       return !ferror(stdout);
3936     }
3937     break;
3938
3939   case WRITE_FIELDS:
3940     if (print_summary) {
3941       /*No non-verbose "fields" format */
3942       g_assert_not_reached();
3943     }
3944     if (print_details) {
3945       write_fields_proto_tree(output_fields, edt, &cf->cinfo, stdout);
3946       printf("\n");
3947       return !ferror(stdout);
3948     }
3949     break;
3950
3951   case WRITE_JSON:
3952     if (print_summary)
3953       g_assert_not_reached();
3954     if (print_details) {
3955       write_json_proto_tree(output_fields, print_dissections_expanded,
3956                             print_hex, protocolfilter, protocolfilter_flags,
3957                             edt, &cf->cinfo, node_children_grouper, stdout);
3958       return !ferror(stdout);
3959     }
3960     break;
3961
3962   case WRITE_JSON_RAW:
3963     if (print_summary)
3964       g_assert_not_reached();
3965     if (print_details) {
3966       write_json_proto_tree(output_fields, print_dissections_none, TRUE,
3967                             protocolfilter, protocolfilter_flags,
3968                             edt, &cf->cinfo, node_children_grouper, stdout);
3969       return !ferror(stdout);
3970     }
3971     break;
3972
3973   case WRITE_EK:
3974     write_ek_proto_tree(output_fields, print_summary, print_hex, protocolfilter,
3975                         protocolfilter_flags, edt, &cf->cinfo, stdout);
3976     return !ferror(stdout);
3977   }
3978
3979   if (print_hex) {
3980     if (print_summary || print_details) {
3981       if (!print_line(print_stream, 0, ""))
3982         return FALSE;
3983     }
3984     if (!print_hex_data(print_stream, edt))
3985       return FALSE;
3986     if (!print_line(print_stream, 0, separator))
3987       return FALSE;
3988   }
3989   return TRUE;
3990 }
3991
3992 static gboolean
3993 write_finale(void)
3994 {
3995   switch (output_action) {
3996
3997   case WRITE_TEXT:
3998     return print_finale(print_stream);
3999
4000   case WRITE_XML:
4001     if (print_details)
4002       write_pdml_finale(stdout);
4003     else
4004       write_psml_finale(stdout);
4005     return !ferror(stdout);
4006
4007   case WRITE_FIELDS:
4008     write_fields_finale(output_fields, stdout);
4009     return !ferror(stdout);
4010
4011   case WRITE_JSON:
4012   case WRITE_JSON_RAW:
4013     write_json_finale(stdout);
4014     return !ferror(stdout);
4015
4016   case WRITE_EK:
4017     return !ferror(stdout);
4018
4019   default:
4020     g_assert_not_reached();
4021     return FALSE;
4022   }
4023 }
4024
4025 void
4026 cf_close(capture_file *cf)
4027 {
4028   g_free(cf->filename);
4029 }
4030
4031 cf_status_t
4032 cf_open(capture_file *cf, const char *fname, unsigned int type, gboolean is_tempfile, int *err)
4033 {
4034   wtap  *wth;
4035   gchar *err_info;
4036
4037   wth = wtap_open_offline(fname, type, err, &err_info, perform_two_pass_analysis);
4038   if (wth == NULL)
4039     goto fail;
4040
4041   /* The open succeeded.  Fill in the information for this file. */
4042
4043   cf->provider.wth = wth;
4044   cf->f_datalen = 0; /* not used, but set it anyway */
4045
4046   /* Set the file name because we need it to set the follow stream filter.
4047      XXX - is that still true?  We need it for other reasons, though,
4048      in any case. */
4049   cf->filename = g_strdup(fname);
4050
4051   /* Indicate whether it's a permanent or temporary file. */
4052   cf->is_tempfile = is_tempfile;
4053
4054   /* No user changes yet. */
4055   cf->unsaved_changes = FALSE;
4056
4057   cf->cd_t      = wtap_file_type_subtype(cf->provider.wth);
4058   cf->open_type = type;
4059   cf->count     = 0;
4060   cf->drops_known = FALSE;
4061   cf->drops     = 0;
4062   cf->snap      = wtap_snapshot_length(cf->provider.wth);
4063   nstime_set_zero(&cf->elapsed_time);
4064   cf->provider.ref = NULL;
4065   cf->provider.prev_dis = NULL;
4066   cf->provider.prev_cap = NULL;
4067
4068   /* Create new epan session for dissection. */
4069   epan_free(cf->epan);
4070   cf->epan = tshark_epan_new(cf);
4071
4072   wtap_set_cb_new_ipv4(cf->provider.wth, add_ipv4_name);
4073   wtap_set_cb_new_ipv6(cf->provider.wth, (wtap_new_ipv6_callback_t) add_ipv6_name);
4074
4075   return CF_OK;
4076
4077 fail:
4078   cfile_open_failure_message("TShark", fname, *err, err_info);
4079   return CF_ERROR;
4080 }
4081
4082 static void
4083 show_print_file_io_error(int err)
4084 {
4085   switch (err) {
4086
4087   case ENOSPC:
4088     cmdarg_err("Not all the packets could be printed because there is "
4089 "no space left on the file system.");
4090     break;
4091
4092 #ifdef EDQUOT
4093   case EDQUOT:
4094     cmdarg_err("Not all the packets could be printed because you are "
4095 "too close to, or over your disk quota.");
4096   break;
4097 #endif
4098
4099   default:
4100     cmdarg_err("An error occurred while printing packets: %s.",
4101       g_strerror(err));
4102     break;
4103   }
4104 }
4105
4106 /*
4107  * General errors and warnings are reported with an console message
4108  * in TShark.
4109  */
4110 static void
4111 failure_warning_message(const char *msg_format, va_list ap)
4112 {
4113   fprintf(stderr, "tshark: ");
4114   vfprintf(stderr, msg_format, ap);
4115   fprintf(stderr, "\n");
4116 }
4117
4118 /*
4119  * Open/create errors are reported with an console message in TShark.
4120  */
4121 static void
4122 open_failure_message(const char *filename, int err, gboolean for_writing)
4123 {
4124   fprintf(stderr, "tshark: ");
4125   fprintf(stderr, file_open_error_message(err, for_writing), filename);
4126   fprintf(stderr, "\n");
4127 }
4128
4129 /*
4130  * Read errors are reported with an console message in TShark.
4131  */
4132 static void
4133 read_failure_message(const char *filename, int err)
4134 {
4135   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
4136              filename, g_strerror(err));
4137 }
4138
4139 /*
4140  * Write errors are reported with an console message in TShark.
4141  */
4142 static void
4143 write_failure_message(const char *filename, int err)
4144 {
4145   cmdarg_err("An error occurred while writing to the file \"%s\": %s.",
4146              filename, g_strerror(err));
4147 }
4148
4149 static void reset_epan_mem(capture_file *cf,epan_dissect_t *edt, gboolean tree, gboolean visual)
4150 {
4151   if (!epan_auto_reset || (cf->count < epan_auto_reset_count))
4152     return;
4153
4154   fprintf(stderr, "resetting session.\n");
4155
4156   epan_dissect_cleanup(edt);
4157   epan_free(cf->epan);
4158
4159   cf->epan = tshark_epan_new(cf);
4160   epan_dissect_init(edt, cf->epan, tree, visual);
4161   cf->count = 0;
4162 }
4163
4164 /*
4165  * Report additional information for an error in command-line arguments.
4166  */
4167 static void
4168 failure_message_cont(const char *msg_format, va_list ap)
4169 {
4170   vfprintf(stderr, msg_format, ap);
4171   fprintf(stderr, "\n");
4172 }
4173
4174 /*
4175  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
4176  *
4177  * Local variables:
4178  * c-basic-offset: 2
4179  * tab-width: 8
4180  * indent-tabs-mode: nil
4181  * End:
4182  *
4183  * vi: set shiftwidth=2 tabstop=8 expandtab:
4184  * :indentSize=2:tabSize=8:noTabs=true:
4185  */