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