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