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