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