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