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