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