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