tshark: endpoints statistics are not supported for now, do not list them in -z
[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   /* Assemble the compile-time version information string */
1059   comp_info_str = g_string_new("Compiled ");
1060   get_compiled_version_info(comp_info_str, get_tshark_compiled_version_info,
1061                             epan_get_compiled_version_info);
1062
1063   /* Assemble the run-time version information string */
1064   runtime_info_str = g_string_new("Running ");
1065   get_runtime_version_info(runtime_info_str, get_tshark_runtime_version_info);
1066
1067   /* Add it to the information to be reported on a crash. */
1068   ws_add_crash_info("TShark (Wireshark) %s\n"
1069          "\n"
1070          "%s"
1071          "\n"
1072          "%s",
1073       get_ws_vcs_version_info(), comp_info_str->str, runtime_info_str->str);
1074
1075   /*
1076    * In order to have the -X opts assigned before the wslua machine starts
1077    * we need to call getopt_long before epan_init() gets called.
1078    *
1079    * In order to handle, for example, -o options, we also need to call it
1080    * *after* epan_init() gets called, so that the dissectors have had a
1081    * chance to register their preferences.
1082    *
1083    * XXX - can we do this all with one getopt_long() call, saving the
1084    * arguments we can't handle until after initializing libwireshark,
1085    * and then process them after initializing libwireshark?
1086    */
1087   opterr = 0;
1088
1089   while ((opt = getopt_long(argc, argv, optstring, long_options, NULL)) != -1) {
1090     switch (opt) {
1091     case 'C':        /* Configuration Profile */
1092       if (profile_exists (optarg, FALSE)) {
1093         set_profile_name (optarg);
1094       } else {
1095         cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
1096         return 1;
1097       }
1098       break;
1099     case 'P':        /* Print packet summary info even when writing to a file */
1100       print_packet_info = TRUE;
1101       print_summary = TRUE;
1102       break;
1103     case 'O':        /* Only output these protocols */
1104       output_only = g_strdup(optarg);
1105       /* FALLTHROUGH */
1106     case 'V':        /* Verbose */
1107       print_details = TRUE;
1108       print_packet_info = TRUE;
1109       break;
1110     case 'x':        /* Print packet data in hex (and ASCII) */
1111       print_hex = TRUE;
1112       /*  The user asked for hex output, so let's ensure they get it,
1113        *  even if they're writing to a file.
1114        */
1115       print_packet_info = TRUE;
1116       break;
1117     case 'X':
1118       ex_opt_add(optarg);
1119       break;
1120     default:
1121       break;
1122     }
1123   }
1124
1125   /*
1126    * Print packet summary information is the default, unless either -V or -x
1127    * were specified and -P was not.  Note that this is new behavior, which
1128    * allows for the possibility of printing only hex/ascii output without
1129    * necessarily requiring that either the summary or details be printed too.
1130    */
1131   if (print_summary == -1)
1132     print_summary = (print_details || print_hex) ? FALSE : TRUE;
1133
1134 /** Send All g_log messages to our own handler **/
1135
1136   log_flags =
1137                     G_LOG_LEVEL_ERROR|
1138                     G_LOG_LEVEL_CRITICAL|
1139                     G_LOG_LEVEL_WARNING|
1140                     G_LOG_LEVEL_MESSAGE|
1141                     G_LOG_LEVEL_INFO|
1142                     G_LOG_LEVEL_DEBUG|
1143                     G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
1144
1145   g_log_set_handler(NULL,
1146                     (GLogLevelFlags)log_flags,
1147                     tshark_log_handler, NULL /* user_data */);
1148   g_log_set_handler(LOG_DOMAIN_MAIN,
1149                     (GLogLevelFlags)log_flags,
1150                     tshark_log_handler, NULL /* user_data */);
1151
1152 #ifdef HAVE_LIBPCAP
1153   g_log_set_handler(LOG_DOMAIN_CAPTURE,
1154                     (GLogLevelFlags)log_flags,
1155                     tshark_log_handler, NULL /* user_data */);
1156   g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
1157                     (GLogLevelFlags)log_flags,
1158                     tshark_log_handler, NULL /* user_data */);
1159 #endif
1160
1161   init_report_err(failure_message, open_failure_message, read_failure_message,
1162                   write_failure_message);
1163
1164 #ifdef HAVE_LIBPCAP
1165   capture_opts_init(&global_capture_opts);
1166   capture_session_init(&global_capture_session, &cfile);
1167 #endif
1168
1169   timestamp_set_type(TS_RELATIVE);
1170   timestamp_set_precision(TS_PREC_AUTO);
1171   timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
1172
1173   init_open_routines();
1174
1175 #ifdef HAVE_PLUGINS
1176   /* Register all the plugin types we have. */
1177   epan_register_plugin_types(); /* Types known to libwireshark */
1178   wtap_register_plugin_types(); /* Types known to libwiretap */
1179
1180   /* Scan for plugins.  This does *not* call their registration routines;
1181      that's done later. */
1182   scan_plugins();
1183
1184   /* Register all libwiretap plugin modules. */
1185   register_all_wiretap_modules();
1186 #endif
1187
1188   /* Register all dissectors; we must do this before checking for the
1189      "-G" flag, as the "-G" flag dumps information registered by the
1190      dissectors, and we must do it before we read the preferences, in
1191      case any dissectors register preferences. */
1192   epan_init(register_all_protocols, register_all_protocol_handoffs, NULL, NULL);
1193
1194   /* Register all tap listeners; we do this before we parse the arguments,
1195      as the "-z" argument can specify a registered tap. */
1196
1197   /* we register the plugin taps before the other taps because
1198      stats_tree taps plugins will be registered as tap listeners
1199      by stats_tree_stat.c and need to registered before that */
1200 #ifdef HAVE_PLUGINS
1201   register_all_plugin_tap_listeners();
1202 #endif
1203   register_all_tap_listeners();
1204   conversation_table_set_gui_info(init_iousers);
1205   /* hostlist_table_set_gui_info(NULL); XXX - TODO: Provide "GUI" function for TShark */
1206
1207   /* If invoked with the "-G" flag, we dump out information based on
1208      the argument to the "-G" flag; if no argument is specified,
1209      for backwards compatibility we dump out a glossary of display
1210      filter symbols.
1211
1212      XXX - we do this here, for now, to support "-G" with no arguments.
1213      If none of our build or other processes uses "-G" with no arguments,
1214      we can just process it with the other arguments. */
1215   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
1216     proto_initialize_all_prefixes();
1217
1218     if (argc == 2)
1219       proto_registrar_dump_fields();
1220     else {
1221       if (strcmp(argv[2], "column-formats") == 0)
1222         column_dump_column_formats();
1223       else if (strcmp(argv[2], "currentprefs") == 0) {
1224         read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
1225             &pf_open_errno, &pf_read_errno, &pf_path);
1226         write_prefs(NULL);
1227       }
1228       else if (strcmp(argv[2], "decodes") == 0)
1229         dissector_dump_decodes();
1230       else if (strcmp(argv[2], "defaultprefs") == 0)
1231         write_prefs(NULL);
1232       else if (strcmp(argv[2], "dissector-tables") == 0)
1233         dissector_dump_dissector_tables();
1234       else if (strcmp(argv[2], "fields") == 0)
1235         proto_registrar_dump_fields();
1236       else if (strcmp(argv[2], "ftypes") == 0)
1237         proto_registrar_dump_ftypes();
1238       else if (strcmp(argv[2], "heuristic-decodes") == 0)
1239         dissector_dump_heur_decodes();
1240       else if (strcmp(argv[2], "plugins") == 0) {
1241 #ifdef HAVE_PLUGINS
1242         plugins_dump_all();
1243 #endif
1244 #ifdef HAVE_LUA
1245         wslua_plugins_dump_all();
1246 #endif
1247       }
1248       else if (strcmp(argv[2], "protocols") == 0)
1249         proto_registrar_dump_protocols();
1250       else if (strcmp(argv[2], "values") == 0)
1251         proto_registrar_dump_values();
1252       else if (strcmp(argv[2], "?") == 0)
1253         glossary_option_help();
1254       else if (strcmp(argv[2], "-?") == 0)
1255         glossary_option_help();
1256       else {
1257         cmdarg_err("Invalid \"%s\" option for -G flag, enter -G ? for more help.", argv[2]);
1258         return 1;
1259       }
1260     }
1261     return 0;
1262   }
1263
1264   /* Set the C-language locale to the native environment. */
1265   setlocale(LC_ALL, "");
1266
1267   prefs_p = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
1268                      &pf_open_errno, &pf_read_errno, &pf_path);
1269   if (gpf_path != NULL) {
1270     if (gpf_open_errno != 0) {
1271       cmdarg_err("Can't open global preferences file \"%s\": %s.",
1272               pf_path, g_strerror(gpf_open_errno));
1273     }
1274     if (gpf_read_errno != 0) {
1275       cmdarg_err("I/O error reading global preferences file \"%s\": %s.",
1276               pf_path, g_strerror(gpf_read_errno));
1277     }
1278   }
1279   if (pf_path != NULL) {
1280     if (pf_open_errno != 0) {
1281       cmdarg_err("Can't open your preferences file \"%s\": %s.", pf_path,
1282               g_strerror(pf_open_errno));
1283     }
1284     if (pf_read_errno != 0) {
1285       cmdarg_err("I/O error reading your preferences file \"%s\": %s.",
1286               pf_path, g_strerror(pf_read_errno));
1287     }
1288     g_free(pf_path);
1289     pf_path = NULL;
1290   }
1291
1292   /* Read the disabled protocols file. */
1293   read_disabled_protos_list(&gdp_path, &gdp_open_errno, &gdp_read_errno,
1294                             &dp_path, &dp_open_errno, &dp_read_errno);
1295   if (gdp_path != NULL) {
1296     if (gdp_open_errno != 0) {
1297       cmdarg_err("Could not open global disabled protocols file\n\"%s\": %s.",
1298                  gdp_path, g_strerror(gdp_open_errno));
1299     }
1300     if (gdp_read_errno != 0) {
1301       cmdarg_err("I/O error reading global disabled protocols file\n\"%s\": %s.",
1302                  gdp_path, g_strerror(gdp_read_errno));
1303     }
1304     g_free(gdp_path);
1305   }
1306   if (dp_path != NULL) {
1307     if (dp_open_errno != 0) {
1308       cmdarg_err(
1309         "Could not open your disabled protocols file\n\"%s\": %s.", dp_path,
1310         g_strerror(dp_open_errno));
1311     }
1312     if (dp_read_errno != 0) {
1313       cmdarg_err(
1314         "I/O error reading your disabled protocols file\n\"%s\": %s.", dp_path,
1315         g_strerror(dp_read_errno));
1316     }
1317     g_free(dp_path);
1318   }
1319
1320   cap_file_init(&cfile);
1321
1322   /* Print format defaults to this. */
1323   print_format = PR_FMT_TEXT;
1324
1325   output_fields = output_fields_new();
1326
1327   /*
1328    * To reset the options parser, set optreset to 1 on platforms that
1329    * have optreset (documented in *BSD and OS X, apparently present but
1330    * not documented in Solaris - the Illumos repository seems to
1331    * suggest that the first Solaris getopt_long(), at least as of 2004,
1332    * was based on the NetBSD one, it had optreset) and set optind to 1,
1333    * and set optind to 0 otherwise (documented as working in the GNU
1334    * getopt_long().  Setting optind to 0 didn't originally work in the
1335    * NetBSD one, but that was added later - we don't want to depend on
1336    * it if we have optreset).
1337    *
1338    * Also reset opterr to 1, so that error messages are printed by
1339    * getopt_long().
1340    */
1341 #ifdef HAVE_OPTRESET
1342   optreset = 1;
1343   optind = 1;
1344 #else
1345   optind = 0;
1346 #endif
1347   opterr = 1;
1348
1349   /* Now get our args */
1350   while ((opt = getopt_long(argc, argv, optstring, long_options, NULL)) != -1) {
1351     switch (opt) {
1352     case '2':        /* Perform two pass analysis */
1353       perform_two_pass_analysis = TRUE;
1354       break;
1355     case 'a':        /* autostop criteria */
1356     case 'b':        /* Ringbuffer option */
1357     case 'c':        /* Capture x packets */
1358     case 'f':        /* capture filter */
1359     case 'g':        /* enable group read access on file(s) */
1360     case 'i':        /* Use interface x */
1361     case 'p':        /* Don't capture in promiscuous mode */
1362 #ifdef HAVE_PCAP_REMOTE
1363     case 'A':        /* Authentication */
1364 #endif
1365 #ifdef HAVE_PCAP_CREATE
1366     case 'I':        /* Capture in monitor mode, if available */
1367 #endif
1368     case 's':        /* Set the snapshot (capture) length */
1369     case 'w':        /* Write to capture file x */
1370     case 'y':        /* Set the pcap data link type */
1371     case  LONGOPT_NUM_CAP_COMMENT: /* add a capture comment */
1372 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
1373     case 'B':        /* Buffer size */
1374 #endif /* _WIN32 or HAVE_PCAP_CREATE */
1375 #ifdef HAVE_LIBPCAP
1376       status = capture_opts_add_opt(&global_capture_opts, opt, optarg, &start_capture);
1377       if (status != 0) {
1378         return status;
1379       }
1380 #else
1381       if (opt == 'w') {
1382         /*
1383          * Output file name, if we're reading a file and writing to another
1384          * file.
1385          */
1386         output_file_name = optarg;
1387       } else {
1388         capture_option_specified = TRUE;
1389         arg_error = TRUE;
1390       }
1391 #endif
1392       break;
1393     case 'C':
1394       /* already processed; just ignore it now */
1395       break;
1396     case 'd':        /* Decode as rule */
1397       if (!add_decode_as(optarg))
1398         return 1;
1399       break;
1400 #if defined(HAVE_HEIMDAL_KERBEROS) || defined(HAVE_MIT_KERBEROS)
1401     case 'K':        /* Kerberos keytab file */
1402       read_keytab_file(optarg);
1403       break;
1404 #endif
1405     case 'D':        /* Print a list of capture devices and exit */
1406 #ifdef HAVE_LIBPCAP
1407       if_list = capture_interface_list(&err, &err_str,NULL);
1408       if (if_list == NULL) {
1409         if (err == 0)
1410           cmdarg_err("There are no interfaces on which a capture can be done");
1411         else {
1412           cmdarg_err("%s", err_str);
1413           g_free(err_str);
1414         }
1415         return 2;
1416       }
1417       capture_opts_print_interfaces(if_list);
1418       free_interface_list(if_list);
1419       return 0;
1420 #else
1421       capture_option_specified = TRUE;
1422       arg_error = TRUE;
1423 #endif
1424       break;
1425     case 'e':
1426       /* Field entry */
1427       output_fields_add(output_fields, optarg);
1428       break;
1429     case 'E':
1430       /* Field option */
1431       if (!output_fields_set_option(output_fields, optarg)) {
1432         cmdarg_err("\"%s\" is not a valid field output option=value pair.", optarg);
1433         output_fields_list_options(stderr);
1434         return 1;
1435       }
1436       break;
1437     case 'F':
1438       out_file_type = wtap_short_string_to_file_type_subtype(optarg);
1439       if (out_file_type < 0) {
1440         cmdarg_err("\"%s\" isn't a valid capture file type", optarg);
1441         list_capture_types();
1442         return 1;
1443       }
1444       break;
1445     case 'W':        /* Select extra information to save in our capture file */
1446       /* This is patterned after the -N flag which may not be the best idea. */
1447       if (strchr(optarg, 'n')) {
1448         out_file_name_res = TRUE;
1449       } else {
1450         cmdarg_err("Invalid -W argument \"%s\"; it must be one of:", optarg);
1451         cmdarg_err_cont("\t'n' write network address resolution information (pcapng only)");
1452         return 1;
1453       }
1454       break;
1455     case 'H':        /* Read address to name mappings from a hosts file */
1456       if (! add_hosts_file(optarg))
1457       {
1458         cmdarg_err("Can't read host entries from \"%s\"", optarg);
1459         return 1;
1460       }
1461       out_file_name_res = TRUE;
1462       break;
1463
1464     case 'h':        /* Print help and exit */
1465       printf("TShark (Wireshark) %s\n"
1466              "Dump and analyze network traffic.\n"
1467              "See http://www.wireshark.org for more information.\n",
1468              get_ws_vcs_version_info());
1469       print_usage(stdout);
1470       return 0;
1471       break;
1472     case 'l':        /* "Line-buffer" standard output */
1473       /* This isn't line-buffering, strictly speaking, it's just
1474          flushing the standard output after the information for
1475          each packet is printed; however, that should be good
1476          enough for all the purposes to which "-l" is put (and
1477          is probably actually better for "-V", as it does fewer
1478          writes).
1479
1480          See the comment in "process_packet()" for an explanation of
1481          why we do that, and why we don't just use "setvbuf()" to
1482          make the standard output line-buffered (short version: in
1483          Windows, "line-buffered" is the same as "fully-buffered",
1484          and the output buffer is only flushed when it fills up). */
1485       line_buffered = TRUE;
1486       break;
1487     case 'L':        /* Print list of link-layer types and exit */
1488 #ifdef HAVE_LIBPCAP
1489       list_link_layer_types = TRUE;
1490 #else
1491       capture_option_specified = TRUE;
1492       arg_error = TRUE;
1493 #endif
1494       break;
1495     case 'n':        /* No name resolution */
1496       gbl_resolv_flags.mac_name = FALSE;
1497       gbl_resolv_flags.network_name = FALSE;
1498       gbl_resolv_flags.transport_name = FALSE;
1499       gbl_resolv_flags.concurrent_dns = FALSE;
1500       break;
1501     case 'N':        /* Select what types of addresses/port #s to resolve */
1502       badopt = string_to_name_resolve(optarg, &gbl_resolv_flags);
1503       if (badopt != '\0') {
1504         cmdarg_err("-N specifies unknown resolving option '%c'; valid options are:",
1505                    badopt);
1506         cmdarg_err_cont("\t'C' to enable concurrent (asynchronous) DNS lookups\n"
1507                         "\t'm' to enable MAC address resolution\n"
1508                         "\t'n' to enable network address resolution\n"
1509                         "\t'N' to enable using external resolvers (e.g., DNS)\n"
1510                         "\t    for network address resolution\n"
1511                         "\t't' to enable transport-layer port number resolution");
1512         return 1;
1513       }
1514       break;
1515     case 'o':        /* Override preference from command line */
1516       switch (prefs_set_pref(optarg)) {
1517
1518       case PREFS_SET_OK:
1519         break;
1520
1521       case PREFS_SET_SYNTAX_ERR:
1522         cmdarg_err("Invalid -o flag \"%s\"", optarg);
1523         return 1;
1524         break;
1525
1526       case PREFS_SET_NO_SUCH_PREF:
1527       case PREFS_SET_OBSOLETE:
1528         cmdarg_err("-o flag \"%s\" specifies unknown preference", optarg);
1529         return 1;
1530         break;
1531       }
1532       break;
1533     case 'q':        /* Quiet */
1534       quiet = TRUE;
1535       break;
1536     case 'Q':        /* Really quiet */
1537       quiet = TRUE;
1538       really_quiet = TRUE;
1539       break;
1540     case 'r':        /* Read capture file x */
1541       cf_name = g_strdup(optarg);
1542       break;
1543     case 'R':        /* Read file filter */
1544       rfilter = optarg;
1545       break;
1546     case 'P':
1547         /* already processed; just ignore it now */
1548         break;
1549     case 'S':        /* Set the line Separator to be printed between packets */
1550       separator = optarg;
1551       break;
1552     case 't':        /* Time stamp type */
1553       if (strcmp(optarg, "r") == 0)
1554         timestamp_set_type(TS_RELATIVE);
1555       else if (strcmp(optarg, "a") == 0)
1556         timestamp_set_type(TS_ABSOLUTE);
1557       else if (strcmp(optarg, "ad") == 0)
1558         timestamp_set_type(TS_ABSOLUTE_WITH_YMD);
1559       else if (strcmp(optarg, "adoy") == 0)
1560         timestamp_set_type(TS_ABSOLUTE_WITH_YDOY);
1561       else if (strcmp(optarg, "d") == 0)
1562         timestamp_set_type(TS_DELTA);
1563       else if (strcmp(optarg, "dd") == 0)
1564         timestamp_set_type(TS_DELTA_DIS);
1565       else if (strcmp(optarg, "e") == 0)
1566         timestamp_set_type(TS_EPOCH);
1567       else if (strcmp(optarg, "u") == 0)
1568         timestamp_set_type(TS_UTC);
1569       else if (strcmp(optarg, "ud") == 0)
1570         timestamp_set_type(TS_UTC_WITH_YMD);
1571       else if (strcmp(optarg, "udoy") == 0)
1572         timestamp_set_type(TS_UTC_WITH_YDOY);
1573       else {
1574         cmdarg_err("Invalid time stamp type \"%s\"; it must be one of:", optarg);
1575         cmdarg_err_cont("\t\"a\"    for absolute\n"
1576                         "\t\"ad\"   for absolute with YYYY-MM-DD date\n"
1577                         "\t\"adoy\" for absolute with YYYY/DOY date\n"
1578                         "\t\"d\"    for delta\n"
1579                         "\t\"dd\"   for delta displayed\n"
1580                         "\t\"e\"    for epoch\n"
1581                         "\t\"r\"    for relative\n"
1582                         "\t\"u\"    for absolute UTC\n"
1583                         "\t\"ud\"   for absolute UTC with YYYY-MM-DD date\n"
1584                         "\t\"udoy\" for absolute UTC with YYYY/DOY date");
1585         return 1;
1586       }
1587       break;
1588     case 'T':        /* printing Type */
1589       print_packet_info = TRUE;
1590       if (strcmp(optarg, "text") == 0) {
1591         output_action = WRITE_TEXT;
1592         print_format = PR_FMT_TEXT;
1593       } else if (strcmp(optarg, "ps") == 0) {
1594         output_action = WRITE_TEXT;
1595         print_format = PR_FMT_PS;
1596       } else if (strcmp(optarg, "pdml") == 0) {
1597         output_action = WRITE_XML;
1598         print_details = TRUE;   /* Need details */
1599         print_summary = FALSE;  /* Don't allow summary */
1600       } else if (strcmp(optarg, "psml") == 0) {
1601         output_action = WRITE_XML;
1602         print_details = FALSE;  /* Don't allow details */
1603         print_summary = TRUE;   /* Need summary */
1604       } else if (strcmp(optarg, "fields") == 0) {
1605         output_action = WRITE_FIELDS;
1606         print_details = TRUE;   /* Need full tree info */
1607         print_summary = FALSE;  /* Don't allow summary */
1608       } else {
1609         cmdarg_err("Invalid -T parameter \"%s\"; it must be one of:", optarg);                   /* x */
1610         cmdarg_err_cont("\t\"fields\" The values of fields specified with the -e option, in a form\n"
1611                         "\t         specified by the -E option.\n"
1612                         "\t\"pdml\"   Packet Details Markup Language, an XML-based format for the\n"
1613                         "\t         details of a decoded packet. This information is equivalent to\n"
1614                         "\t         the packet details printed with the -V flag.\n"
1615                         "\t\"ps\"     PostScript for a human-readable one-line summary of each of\n"
1616                         "\t         the packets, or a multi-line view of the details of each of\n"
1617                         "\t         the packets, depending on whether the -V flag was specified.\n"
1618                         "\t\"psml\"   Packet Summary Markup Language, an XML-based format for the\n"
1619                         "\t         summary information of a decoded packet. This information is\n"
1620                         "\t         equivalent to the information shown in the one-line summary\n"
1621                         "\t         printed by default.\n"
1622                         "\t\"text\"   Text of a human-readable one-line summary of each of the\n"
1623                         "\t         packets, or a multi-line view of the details of each of the\n"
1624                         "\t         packets, depending on whether the -V flag was specified.\n"
1625                         "\t         This is the default.");
1626         return 1;
1627       }
1628       break;
1629     case 'u':        /* Seconds type */
1630       if (strcmp(optarg, "s") == 0)
1631         timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
1632       else if (strcmp(optarg, "hms") == 0)
1633         timestamp_set_seconds_type(TS_SECONDS_HOUR_MIN_SEC);
1634       else {
1635         cmdarg_err("Invalid seconds type \"%s\"; it must be one of:", optarg);
1636         cmdarg_err_cont("\t\"s\"   for seconds\n"
1637                         "\t\"hms\" for hours, minutes and seconds");
1638         return 1;
1639       }
1640       break;
1641     case 'v':         /* Show version and exit */
1642     {
1643       show_version("TShark (Wireshark)", comp_info_str, runtime_info_str);
1644       g_string_free(comp_info_str, TRUE);
1645       g_string_free(runtime_info_str, TRUE);
1646       /* We don't really have to cleanup here, but it's a convenient way to test
1647        * start-up and shut-down of the epan library without any UI-specific
1648        * cruft getting in the way. Makes the results of running
1649        * $ ./tools/valgrind-wireshark -n
1650        * much more useful. */
1651       epan_cleanup();
1652       return 0;
1653     }
1654     case 'O':        /* Only output these protocols */
1655       /* already processed; just ignore it now */
1656       break;
1657     case 'V':        /* Verbose */
1658       /* already processed; just ignore it now */
1659       break;
1660     case 'x':        /* Print packet data in hex (and ASCII) */
1661       /* already processed; just ignore it now */
1662       break;
1663     case 'X':
1664       /* already processed; just ignore it now */
1665       break;
1666     case 'Y':
1667       dfilter = optarg;
1668       break;
1669     case 'z':
1670       /* We won't call the init function for the stat this soon
1671          as it would disallow MATE's fields (which are registered
1672          by the preferences set callback) from being used as
1673          part of a tap filter.  Instead, we just add the argument
1674          to a list of stat arguments. */
1675       if (strcmp("help", optarg) == 0) {
1676         fprintf(stderr, "tshark: The available statistics for the \"-z\" option are:\n");
1677         list_stat_cmd_args();
1678         return 0;
1679       }
1680       if (!process_stat_cmd_arg(optarg)) {
1681         cmdarg_err("Invalid -z argument \"%s\"; it must be one of:", optarg);
1682         list_stat_cmd_args();
1683         return 1;
1684       }
1685       break;
1686     default:
1687     case '?':        /* Bad flag - print usage message */
1688       switch(optopt) {
1689       case 'F':
1690         list_capture_types();
1691         break;
1692       default:
1693         print_usage(stderr);
1694       }
1695       return 1;
1696       break;
1697     }
1698   }
1699
1700   /* If we specified output fields, but not the output field type... */
1701   if (WRITE_FIELDS != output_action && 0 != output_fields_num_fields(output_fields)) {
1702         cmdarg_err("Output fields were specified with \"-e\", "
1703             "but \"-Tfields\" was not specified.");
1704         return 1;
1705   } else if (WRITE_FIELDS == output_action && 0 == output_fields_num_fields(output_fields)) {
1706         cmdarg_err("\"-Tfields\" was specified, but no fields were "
1707                     "specified with \"-e\".");
1708
1709         return 1;
1710   }
1711
1712   /* If no capture filter or display filter has been specified, and there are
1713      still command-line arguments, treat them as the tokens of a capture
1714      filter (if no "-r" flag was specified) or a display filter (if a "-r"
1715      flag was specified. */
1716   if (optind < argc) {
1717     if (cf_name != NULL) {
1718       if (dfilter != NULL) {
1719         cmdarg_err("Display filters were specified both with \"-d\" "
1720             "and with additional command-line arguments.");
1721         return 1;
1722       }
1723       dfilter = get_args_as_string(argc, argv, optind);
1724     } else {
1725 #ifdef HAVE_LIBPCAP
1726       guint i;
1727
1728       if (global_capture_opts.default_options.cfilter) {
1729         cmdarg_err("A default capture filter was specified both with \"-f\""
1730             " and with additional command-line arguments.");
1731         return 1;
1732       }
1733       for (i = 0; i < global_capture_opts.ifaces->len; i++) {
1734         interface_options interface_opts;
1735         interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
1736         if (interface_opts.cfilter == NULL) {
1737           interface_opts.cfilter = get_args_as_string(argc, argv, optind);
1738           global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
1739           g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
1740         } else {
1741           cmdarg_err("A capture filter was specified both with \"-f\""
1742               " and with additional command-line arguments.");
1743           return 1;
1744         }
1745       }
1746       global_capture_opts.default_options.cfilter = get_args_as_string(argc, argv, optind);
1747 #else
1748       capture_option_specified = TRUE;
1749 #endif
1750     }
1751   }
1752
1753 #ifdef HAVE_LIBPCAP
1754   if (!global_capture_opts.saving_to_file) {
1755     /* We're not saving the capture to a file; if "-q" wasn't specified,
1756        we should print packet information */
1757     if (!quiet)
1758       print_packet_info = TRUE;
1759   } else {
1760     /* We're saving to a file; if we're writing to the standard output.
1761        and we'll also be writing dissected packets to the standard
1762        output, reject the request.  At best, we could redirect that
1763        to the standard error; we *can't* write both to the standard
1764        output and have either of them be useful. */
1765     if (strcmp(global_capture_opts.save_file, "-") == 0 && print_packet_info) {
1766       cmdarg_err("You can't write both raw packet data and dissected packets"
1767           " to the standard output.");
1768       return 1;
1769     }
1770   }
1771 #else
1772   /* We're not saving the capture to a file; if "-q" wasn't specified,
1773      we should print packet information */
1774   if (!quiet)
1775     print_packet_info = TRUE;
1776 #endif
1777
1778 #ifndef HAVE_LIBPCAP
1779   if (capture_option_specified)
1780     cmdarg_err("This version of TShark was not built with support for capturing packets.");
1781 #endif
1782   if (arg_error) {
1783     print_usage(stderr);
1784     return 1;
1785   }
1786
1787   if (print_hex) {
1788     if (output_action != WRITE_TEXT) {
1789       cmdarg_err("Raw packet hex data can only be printed as text or PostScript");
1790       return 1;
1791     }
1792   }
1793
1794   if (output_only != NULL) {
1795     char *ps;
1796
1797     if (!print_details) {
1798       cmdarg_err("-O requires -V");
1799       return 1;
1800     }
1801
1802     output_only_tables = g_hash_table_new (g_str_hash, g_str_equal);
1803     for (ps = strtok (output_only, ","); ps; ps = strtok (NULL, ",")) {
1804       g_hash_table_insert(output_only_tables, (gpointer)ps, (gpointer)ps);
1805     }
1806   }
1807
1808   if (rfilter != NULL && !perform_two_pass_analysis) {
1809     cmdarg_err("-R without -2 is deprecated. For single-pass filtering use -Y.");
1810     return 1;
1811   }
1812
1813 #ifdef HAVE_LIBPCAP
1814   if (list_link_layer_types) {
1815     /* We're supposed to list the link-layer types for an interface;
1816        did the user also specify a capture file to be read? */
1817     if (cf_name) {
1818       /* Yes - that's bogus. */
1819       cmdarg_err("You can't specify -L and a capture file to be read.");
1820       return 1;
1821     }
1822     /* No - did they specify a ring buffer option? */
1823     if (global_capture_opts.multi_files_on) {
1824       cmdarg_err("Ring buffer requested, but a capture isn't being done.");
1825       return 1;
1826     }
1827   } else {
1828     if (cf_name) {
1829       /*
1830        * "-r" was specified, so we're reading a capture file.
1831        * Capture options don't apply here.
1832        */
1833
1834       /* We don't support capture filters when reading from a capture file
1835          (the BPF compiler doesn't support all link-layer types that we
1836          support in capture files we read). */
1837       if (global_capture_opts.default_options.cfilter) {
1838         cmdarg_err("Only read filters, not capture filters, "
1839           "can be specified when reading a capture file.");
1840         return 1;
1841       }
1842       if (global_capture_opts.multi_files_on) {
1843         cmdarg_err("Multiple capture files requested, but "
1844                    "a capture isn't being done.");
1845         return 1;
1846       }
1847       if (global_capture_opts.has_file_duration) {
1848         cmdarg_err("Switching capture files after a time interval was specified, but "
1849                    "a capture isn't being done.");
1850         return 1;
1851       }
1852       if (global_capture_opts.has_ring_num_files) {
1853         cmdarg_err("A ring buffer of capture files was specified, but "
1854           "a capture isn't being done.");
1855         return 1;
1856       }
1857       if (global_capture_opts.has_autostop_files) {
1858         cmdarg_err("A maximum number of capture files was specified, but "
1859           "a capture isn't being done.");
1860         return 1;
1861       }
1862       if (global_capture_opts.capture_comment) {
1863         cmdarg_err("A capture comment was specified, but "
1864           "a capture isn't being done.\nThere's no support for adding "
1865           "a capture comment to an existing capture file.");
1866         return 1;
1867       }
1868
1869       /* Note: TShark now allows the restriction of a _read_ file by packet count
1870        * and byte count as well as a write file. Other autostop options remain valid
1871        * only for a write file.
1872        */
1873       if (global_capture_opts.has_autostop_duration) {
1874         cmdarg_err("A maximum capture time was specified, but "
1875           "a capture isn't being done.");
1876         return 1;
1877       }
1878     } else {
1879       /*
1880        * "-r" wasn't specified, so we're doing a live capture.
1881        */
1882       if (perform_two_pass_analysis) {
1883         /* Two-pass analysis doesn't work with live capture since it requires us
1884          * to buffer packets until we've read all of them, but a live capture
1885          * has no useful/meaningful definition of "all" */
1886         cmdarg_err("Live captures do not support two-pass analysis.");
1887         return 1;
1888       }
1889
1890       if (global_capture_opts.saving_to_file) {
1891         /* They specified a "-w" flag, so we'll be saving to a capture file. */
1892
1893         /* When capturing, we only support writing pcap or pcap-ng format. */
1894         if (out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAP &&
1895             out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAPNG) {
1896           cmdarg_err("Live captures can only be saved in pcap or pcapng format.");
1897           return 1;
1898         }
1899         if (global_capture_opts.capture_comment &&
1900             out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAPNG) {
1901           cmdarg_err("A capture comment can only be written to a pcapng file.");
1902           return 1;
1903         }
1904         if (global_capture_opts.multi_files_on) {
1905           /* Multiple-file mode doesn't work under certain conditions:
1906              a) it doesn't work if you're writing to the standard output;
1907              b) it doesn't work if you're writing to a pipe;
1908           */
1909           if (strcmp(global_capture_opts.save_file, "-") == 0) {
1910             cmdarg_err("Multiple capture files requested, but "
1911               "the capture is being written to the standard output.");
1912             return 1;
1913           }
1914           if (global_capture_opts.output_to_pipe) {
1915             cmdarg_err("Multiple capture files requested, but "
1916               "the capture file is a pipe.");
1917             return 1;
1918           }
1919           if (!global_capture_opts.has_autostop_filesize &&
1920               !global_capture_opts.has_file_duration) {
1921             cmdarg_err("Multiple capture files requested, but "
1922               "no maximum capture file size or duration was specified.");
1923             return 1;
1924           }
1925         }
1926         /* Currently, we don't support read or display filters when capturing
1927            and saving the packets. */
1928         if (rfilter != NULL) {
1929           cmdarg_err("Read filters aren't supported when capturing and saving the captured packets.");
1930           return 1;
1931         }
1932         if (dfilter != NULL) {
1933           cmdarg_err("Display filters aren't supported when capturing and saving the captured packets.");
1934           return 1;
1935         }
1936         global_capture_opts.use_pcapng = (out_file_type == WTAP_FILE_TYPE_SUBTYPE_PCAPNG) ? TRUE : FALSE;
1937       } else {
1938         /* They didn't specify a "-w" flag, so we won't be saving to a
1939            capture file.  Check for options that only make sense if
1940            we're saving to a file. */
1941         if (global_capture_opts.has_autostop_filesize) {
1942           cmdarg_err("Maximum capture file size specified, but "
1943            "capture isn't being saved to a file.");
1944           return 1;
1945         }
1946         if (global_capture_opts.multi_files_on) {
1947           cmdarg_err("Multiple capture files requested, but "
1948             "the capture isn't being saved to a file.");
1949           return 1;
1950         }
1951         if (global_capture_opts.capture_comment) {
1952           cmdarg_err("A capture comment was specified, but "
1953             "the capture isn't being saved to a file.");
1954           return 1;
1955         }
1956       }
1957     }
1958   }
1959 #endif
1960
1961 #ifdef _WIN32
1962   /* Start windows sockets */
1963   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
1964 #endif /* _WIN32 */
1965
1966   /* Notify all registered modules that have had any of their preferences
1967      changed either from one of the preferences file or from the command
1968      line that their preferences have changed. */
1969   prefs_apply_all();
1970
1971   /* At this point MATE will have registered its field array so we can
1972      have a tap filter with one of MATE's late-registered fields as part
1973      of the filter.  We can now process all the "-z" arguments. */
1974   start_requested_stats();
1975
1976   /* At this point MATE will have registered its field array so we can
1977      check if the fields specified by the user are all good.
1978    */
1979   if (!output_fields_valid(output_fields)) {
1980     cmdarg_err("Some fields aren't valid");
1981     return 1;
1982   }
1983
1984 #ifdef HAVE_LIBPCAP
1985   /* We currently don't support taps, or printing dissected packets,
1986      if we're writing to a pipe. */
1987   if (global_capture_opts.saving_to_file &&
1988       global_capture_opts.output_to_pipe) {
1989     if (tap_listeners_require_dissection()) {
1990       cmdarg_err("Taps aren't supported when saving to a pipe.");
1991       return 1;
1992     }
1993     if (print_packet_info) {
1994       cmdarg_err("Printing dissected packets isn't supported when saving to a pipe.");
1995       return 1;
1996     }
1997   }
1998 #endif
1999
2000   if (ex_opt_count("read_format") > 0) {
2001     const gchar* name = ex_opt_get_next("read_format");
2002     in_file_type = open_info_name_to_type(name);
2003     if (in_file_type == WTAP_TYPE_AUTO) {
2004       cmdarg_err("\"%s\" isn't a valid read file format type", name? name : "");
2005       list_read_capture_types();
2006       return 1;
2007     }
2008   }
2009
2010   /* disabled protocols as per configuration file */
2011   if (gdp_path == NULL && dp_path == NULL) {
2012     set_disabled_protos_list();
2013   }
2014
2015   /* Build the column format array */
2016   build_column_format_array(&cfile.cinfo, prefs_p->num_cols, TRUE);
2017
2018 #ifdef HAVE_LIBPCAP
2019   capture_opts_trim_snaplen(&global_capture_opts, MIN_PACKET_SIZE);
2020   capture_opts_trim_ring_num_files(&global_capture_opts);
2021 #endif
2022
2023   if (rfilter != NULL) {
2024     if (!dfilter_compile(rfilter, &rfcode)) {
2025       cmdarg_err("%s", dfilter_error_msg);
2026       epan_cleanup();
2027 #ifdef HAVE_PCAP_OPEN_DEAD
2028       {
2029         pcap_t *pc;
2030
2031         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
2032         if (pc != NULL) {
2033           if (pcap_compile(pc, &fcode, rfilter, 0, 0) != -1) {
2034             cmdarg_err_cont(
2035               "  Note: That read filter code looks like a valid capture filter;\n"
2036               "        maybe you mixed them up?");
2037           }
2038           pcap_close(pc);
2039         }
2040       }
2041 #endif
2042       return 2;
2043     }
2044   }
2045   cfile.rfcode = rfcode;
2046
2047   if (dfilter != NULL) {
2048     if (!dfilter_compile(dfilter, &dfcode)) {
2049       cmdarg_err("%s", dfilter_error_msg);
2050       epan_cleanup();
2051 #ifdef HAVE_PCAP_OPEN_DEAD
2052       {
2053         pcap_t *pc;
2054
2055         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
2056         if (pc != NULL) {
2057           if (pcap_compile(pc, &fcode, dfilter, 0, 0) != -1) {
2058             cmdarg_err_cont(
2059               "  Note: That display filter code looks like a valid capture filter;\n"
2060               "        maybe you mixed them up?");
2061           }
2062           pcap_close(pc);
2063         }
2064       }
2065 #endif
2066       return 2;
2067     }
2068   }
2069   cfile.dfcode = dfcode;
2070
2071   if (print_packet_info) {
2072     /* If we're printing as text or PostScript, we have
2073        to create a print stream. */
2074     if (output_action == WRITE_TEXT) {
2075       switch (print_format) {
2076
2077       case PR_FMT_TEXT:
2078         print_stream = print_stream_text_stdio_new(stdout);
2079         break;
2080
2081       case PR_FMT_PS:
2082         print_stream = print_stream_ps_stdio_new(stdout);
2083         break;
2084
2085       default:
2086         g_assert_not_reached();
2087       }
2088     }
2089   }
2090
2091   /* We have to dissect each packet if:
2092
2093         we're printing information about each packet;
2094
2095         we're using a read filter on the packets;
2096
2097         we're using a display filter on the packets;
2098
2099         we're using any taps that need dissection. */
2100   do_dissection = print_packet_info || rfcode || dfcode || tap_listeners_require_dissection();
2101
2102   if (cf_name) {
2103     /*
2104      * We're reading a capture file.
2105      */
2106     if (cf_open(&cfile, cf_name, in_file_type, FALSE, &err) != CF_OK) {
2107       epan_cleanup();
2108       return 2;
2109     }
2110
2111     /* Process the packets in the file */
2112     TRY {
2113 #ifdef HAVE_LIBPCAP
2114       err = load_cap_file(&cfile, global_capture_opts.save_file, out_file_type, out_file_name_res,
2115           global_capture_opts.has_autostop_packets ? global_capture_opts.autostop_packets : 0,
2116           global_capture_opts.has_autostop_filesize ? global_capture_opts.autostop_filesize : 0);
2117 #else
2118       err = load_cap_file(&cfile, output_file_name, out_file_type, out_file_name_res, 0, 0);
2119 #endif
2120     }
2121     CATCH(OutOfMemoryError) {
2122       fprintf(stderr,
2123               "Out Of Memory.\n"
2124               "\n"
2125               "Sorry, but TShark has to terminate now.\n"
2126               "\n"
2127               "More information and workarounds can be found at\n"
2128               "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2129       err = ENOMEM;
2130     }
2131     ENDTRY;
2132     if (err != 0) {
2133       /* We still dump out the results of taps, etc., as we might have
2134          read some packets; however, we exit with an error status. */
2135       exit_status = 2;
2136     }
2137   } else {
2138     /* No capture file specified, so we're supposed to do a live capture
2139        or get a list of link-layer types for a live capture device;
2140        do we have support for live captures? */
2141 #ifdef HAVE_LIBPCAP
2142     /* if no interface was specified, pick a default */
2143     exit_status = capture_opts_default_iface_if_necessary(&global_capture_opts,
2144         ((prefs_p->capture_device) && (*prefs_p->capture_device != '\0')) ? get_if_name(prefs_p->capture_device) : NULL);
2145     if (exit_status != 0)
2146         return exit_status;
2147
2148     /* if requested, list the link layer types and exit */
2149     if (list_link_layer_types) {
2150         guint i;
2151
2152         /* Get the list of link-layer types for the capture devices. */
2153         for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2154           interface_options  interface_opts;
2155           if_capabilities_t *caps;
2156
2157           interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2158           caps = capture_get_if_capabilities(interface_opts.name, interface_opts.monitor_mode, &err_str, NULL);
2159           if (caps == NULL) {
2160             cmdarg_err("%s", err_str);
2161             g_free(err_str);
2162             return 2;
2163           }
2164           if (caps->data_link_types == NULL) {
2165             cmdarg_err("The capture device \"%s\" has no data link types.", interface_opts.name);
2166             return 2;
2167           }
2168           capture_opts_print_if_capabilities(caps, interface_opts.name, interface_opts.monitor_mode);
2169           free_if_capabilities(caps);
2170         }
2171         return 0;
2172     }
2173
2174     /*
2175      * If the standard error isn't a terminal, don't print packet counts,
2176      * as they won't show up on the user's terminal and they'll get in
2177      * the way of error messages in the file (to which we assume the
2178      * standard error was redirected; if it's redirected to the null
2179      * device, there's no point in printing packet counts anyway).
2180      *
2181      * Otherwise, if we're printing packet information and the standard
2182      * output is a terminal (which we assume means the standard output and
2183      * error are going to the same terminal), don't print packet counts,
2184      * as they'll get in the way of the packet information.
2185      *
2186      * Otherwise, if the user specified -q, don't print packet counts.
2187      *
2188      * Otherwise, print packet counts.
2189      *
2190      * XXX - what if the user wants to do a live capture, doesn't want
2191      * to save it to a file, doesn't want information printed for each
2192      * packet, does want some "-z" statistic, and wants packet counts
2193      * so they know whether they're seeing any packets?  -q will
2194      * suppress the information printed for each packet, but it'll
2195      * also suppress the packet counts.
2196      */
2197     if (!isatty(fileno(stderr)))
2198       print_packet_counts = FALSE;
2199     else if (print_packet_info && isatty(fileno(stdout)))
2200       print_packet_counts = FALSE;
2201     else if (quiet)
2202       print_packet_counts = FALSE;
2203     else
2204       print_packet_counts = TRUE;
2205
2206     if (print_packet_info) {
2207       if (!write_preamble(&cfile)) {
2208         show_print_file_io_error(errno);
2209         return 2;
2210       }
2211     }
2212
2213     /*
2214      * XXX - this returns FALSE if an error occurred, but it also
2215      * returns FALSE if the capture stops because a time limit
2216      * was reached (and possibly other limits), so we can't assume
2217      * it means an error.
2218      *
2219      * The capture code is a bit twisty, so it doesn't appear to
2220      * be an easy fix.  We just ignore the return value for now.
2221      * Instead, pass on the exit status from the capture child.
2222      */
2223     capture();
2224     exit_status = global_capture_session.fork_child_status;
2225
2226     if (print_packet_info) {
2227       if (!write_finale()) {
2228         err = errno;
2229         show_print_file_io_error(err);
2230       }
2231     }
2232 #else
2233     /* No - complain. */
2234     cmdarg_err("This version of TShark was not built with support for capturing packets.");
2235     return 2;
2236 #endif
2237   }
2238
2239   g_free(cf_name);
2240
2241   if (cfile.frames != NULL) {
2242     free_frame_data_sequence(cfile.frames);
2243     cfile.frames = NULL;
2244   }
2245
2246   draw_tap_listeners(TRUE);
2247   funnel_dump_all_text_windows();
2248   epan_free(cfile.epan);
2249   epan_cleanup();
2250
2251   output_fields_free(output_fields);
2252   output_fields = NULL;
2253
2254   return exit_status;
2255 }
2256
2257 /*#define USE_BROKEN_G_MAIN_LOOP*/
2258
2259 #ifdef USE_BROKEN_G_MAIN_LOOP
2260   GMainLoop *loop;
2261 #else
2262   gboolean loop_running = FALSE;
2263 #endif
2264   guint32 packet_count = 0;
2265
2266
2267 typedef struct pipe_input_tag {
2268   gint             source;
2269   gpointer         user_data;
2270   int             *child_process;
2271   pipe_input_cb_t  input_cb;
2272   guint            pipe_input_id;
2273 #ifdef _WIN32
2274   GMutex          *callback_running;
2275 #endif
2276 } pipe_input_t;
2277
2278 static pipe_input_t pipe_input;
2279
2280 #ifdef _WIN32
2281 /* The timer has expired, see if there's stuff to read from the pipe,
2282    if so, do the callback */
2283 static gint
2284 pipe_timer_cb(gpointer data)
2285 {
2286   HANDLE        handle;
2287   DWORD         avail        = 0;
2288   gboolean      result;
2289   DWORD         childstatus;
2290   pipe_input_t *pipe_input_p = data;
2291   gint          iterations   = 0;
2292
2293   g_mutex_lock (pipe_input_p->callback_running);
2294
2295   /* try to read data from the pipe only 5 times, to avoid blocking */
2296   while(iterations < 5) {
2297     /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: new iteration");*/
2298
2299     /* Oddly enough although Named pipes don't work on win9x,
2300        PeekNamedPipe does !!! */
2301     handle = (HANDLE) _get_osfhandle (pipe_input_p->source);
2302     result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
2303
2304     /* Get the child process exit status */
2305     GetExitCodeProcess((HANDLE)*(pipe_input_p->child_process),
2306                        &childstatus);
2307
2308     /* If the Peek returned an error, or there are bytes to be read
2309        or the childwatcher thread has terminated then call the normal
2310        callback */
2311     if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
2312
2313       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: data avail");*/
2314
2315       /* And call the real handler */
2316       if (!pipe_input_p->input_cb(pipe_input_p->source, pipe_input_p->user_data)) {
2317         g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
2318         /* pipe closed, return false so that the timer is stopped */
2319         g_mutex_unlock (pipe_input_p->callback_running);
2320         return FALSE;
2321       }
2322     }
2323     else {
2324       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: no data avail");*/
2325       /* No data, stop now */
2326       break;
2327     }
2328
2329     iterations++;
2330   }
2331
2332   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: finished with iterations: %u, new timer", iterations);*/
2333
2334   g_mutex_unlock (pipe_input_p->callback_running);
2335
2336   /* we didn't stopped the timer, so let it run */
2337   return TRUE;
2338 }
2339 #endif
2340
2341
2342 void
2343 pipe_input_set_handler(gint source, gpointer user_data, int *child_process, pipe_input_cb_t input_cb)
2344 {
2345
2346   pipe_input.source         = source;
2347   pipe_input.child_process  = child_process;
2348   pipe_input.user_data      = user_data;
2349   pipe_input.input_cb       = input_cb;
2350
2351 #ifdef _WIN32
2352 #if GLIB_CHECK_VERSION(2,31,0)
2353   pipe_input.callback_running = g_malloc(sizeof(GMutex));
2354   g_mutex_init(pipe_input.callback_running);
2355 #else
2356   pipe_input.callback_running = g_mutex_new();
2357 #endif
2358   /* Tricky to use pipes in win9x, as no concept of wait.  NT can
2359      do this but that doesn't cover all win32 platforms.  GTK can do
2360      this but doesn't seem to work over processes.  Attempt to do
2361      something similar here, start a timer and check for data on every
2362      timeout. */
2363   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
2364   pipe_input.pipe_input_id = g_timeout_add(200, pipe_timer_cb, &pipe_input);
2365 #endif
2366 }
2367
2368 static const nstime_t *
2369 tshark_get_frame_ts(void *data, guint32 frame_num)
2370 {
2371   capture_file *cf = (capture_file *) data;
2372
2373   if (ref && ref->num == frame_num)
2374     return &ref->abs_ts;
2375
2376   if (prev_dis && prev_dis->num == frame_num)
2377     return &prev_dis->abs_ts;
2378
2379   if (prev_cap && prev_cap->num == frame_num)
2380     return &prev_cap->abs_ts;
2381
2382   if (cf->frames) {
2383      frame_data *fd = frame_data_sequence_find(cf->frames, frame_num);
2384
2385      return (fd) ? &fd->abs_ts : NULL;
2386   }
2387
2388   return NULL;
2389 }
2390
2391 static epan_t *
2392 tshark_epan_new(capture_file *cf)
2393 {
2394   epan_t *epan = epan_new();
2395
2396   epan->data = cf;
2397   epan->get_frame_ts = tshark_get_frame_ts;
2398   epan->get_interface_name = cap_file_get_interface_name;
2399   epan->get_user_comment = NULL;
2400
2401   return epan;
2402 }
2403
2404 #ifdef HAVE_LIBPCAP
2405 static gboolean
2406 capture(void)
2407 {
2408   gboolean          ret;
2409   guint             i;
2410   GString          *str = g_string_new("");
2411 #ifdef USE_TSHARK_SELECT
2412   fd_set            readfds;
2413 #endif
2414 #ifndef _WIN32
2415   struct sigaction  action, oldaction;
2416 #endif
2417
2418   /* Create new dissection section. */
2419   epan_free(cfile.epan);
2420   cfile.epan = tshark_epan_new(&cfile);
2421
2422 #ifdef _WIN32
2423   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
2424   SetConsoleCtrlHandler(capture_cleanup, TRUE);
2425 #else /* _WIN32 */
2426   /* Catch SIGINT and SIGTERM and, if we get either of them,
2427      clean up and exit.  If SIGHUP isn't being ignored, catch
2428      it too and, if we get it, clean up and exit.
2429
2430      We restart any read that was in progress, so that it doesn't
2431      disrupt reading from the sync pipe.  The signal handler tells
2432      the capture child to finish; it will report that it finished,
2433      or will exit abnormally, so  we'll stop reading from the sync
2434      pipe, pick up the exit status, and quit. */
2435   memset(&action, 0, sizeof(action));
2436   action.sa_handler = capture_cleanup;
2437   action.sa_flags = SA_RESTART;
2438   sigemptyset(&action.sa_mask);
2439   sigaction(SIGTERM, &action, NULL);
2440   sigaction(SIGINT, &action, NULL);
2441   sigaction(SIGHUP, NULL, &oldaction);
2442   if (oldaction.sa_handler == SIG_DFL)
2443     sigaction(SIGHUP, &action, NULL);
2444
2445 #ifdef SIGINFO
2446   /* Catch SIGINFO and, if we get it and we're capturing to a file in
2447      quiet mode, report the number of packets we've captured.
2448
2449      Again, restart any read that was in progress, so that it doesn't
2450      disrupt reading from the sync pipe. */
2451   action.sa_handler = report_counts_siginfo;
2452   action.sa_flags = SA_RESTART;
2453   sigemptyset(&action.sa_mask);
2454   sigaction(SIGINFO, &action, NULL);
2455 #endif /* SIGINFO */
2456 #endif /* _WIN32 */
2457
2458   global_capture_session.state = CAPTURE_PREPARING;
2459
2460   /* Let the user know which interfaces were chosen. */
2461   for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2462     interface_options interface_opts;
2463
2464     interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2465     interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
2466     global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
2467     g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
2468   }
2469 #ifdef _WIN32
2470   if (global_capture_opts.ifaces->len < 2)
2471 #else
2472   if (global_capture_opts.ifaces->len < 4)
2473 #endif
2474   {
2475     for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2476       interface_options interface_opts;
2477
2478       interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2479       if (i > 0) {
2480           if (global_capture_opts.ifaces->len > 2) {
2481               g_string_append_printf(str, ",");
2482           }
2483           g_string_append_printf(str, " ");
2484           if (i == global_capture_opts.ifaces->len - 1) {
2485               g_string_append_printf(str, "and ");
2486           }
2487       }
2488       g_string_append_printf(str, "'%s'", interface_opts.descr);
2489     }
2490   } else {
2491     g_string_append_printf(str, "%u interfaces", global_capture_opts.ifaces->len);
2492   }
2493   if (really_quiet == FALSE)
2494     fprintf(stderr, "Capturing on %s\n", str->str);
2495   fflush(stderr);
2496   g_string_free(str, TRUE);
2497
2498   ret = sync_pipe_start(&global_capture_opts, &global_capture_session, NULL);
2499
2500   if (!ret)
2501     return FALSE;
2502
2503   /* the actual capture loop
2504    *
2505    * XXX - glib doesn't seem to provide any event based loop handling.
2506    *
2507    * XXX - for whatever reason,
2508    * calling g_main_loop_new() ends up in 100% cpu load.
2509    *
2510    * But that doesn't matter: in UNIX we can use select() to find an input
2511    * source with something to do.
2512    *
2513    * But that doesn't matter because we're in a CLI (that doesn't need to
2514    * update a GUI or something at the same time) so it's OK if we block
2515    * trying to read from the pipe.
2516    *
2517    * So all the stuff in USE_TSHARK_SELECT could be removed unless I'm
2518    * wrong (but I leave it there in case I am...).
2519    */
2520
2521 #ifdef USE_TSHARK_SELECT
2522   FD_ZERO(&readfds);
2523   FD_SET(pipe_input.source, &readfds);
2524 #endif
2525
2526   loop_running = TRUE;
2527
2528   TRY
2529   {
2530     while (loop_running)
2531     {
2532 #ifdef USE_TSHARK_SELECT
2533       ret = select(pipe_input.source+1, &readfds, NULL, NULL, NULL);
2534
2535       if (ret == -1)
2536       {
2537         fprintf(stderr, "%s: %s\n", "select()", g_strerror(errno));
2538         return TRUE;
2539       } else if (ret == 1) {
2540 #endif
2541         /* Call the real handler */
2542         if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
2543           g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
2544           return FALSE;
2545         }
2546 #ifdef USE_TSHARK_SELECT
2547       }
2548 #endif
2549     }
2550   }
2551   CATCH(OutOfMemoryError) {
2552     fprintf(stderr,
2553             "Out Of Memory.\n"
2554             "\n"
2555             "Sorry, but TShark has to terminate now.\n"
2556             "\n"
2557             "More information and workarounds can be found at\n"
2558             "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2559     exit(1);
2560   }
2561   ENDTRY;
2562   return TRUE;
2563 }
2564
2565 /* capture child detected an error */
2566 void
2567 capture_input_error_message(capture_session *cap_session _U_, char *error_msg, char *secondary_error_msg)
2568 {
2569   cmdarg_err("%s", error_msg);
2570   cmdarg_err_cont("%s", secondary_error_msg);
2571 }
2572
2573
2574 /* capture child detected an capture filter related error */
2575 void
2576 capture_input_cfilter_error_message(capture_session *cap_session, guint i, char *error_message)
2577 {
2578   capture_options *capture_opts = cap_session->capture_opts;
2579   dfilter_t         *rfcode = NULL;
2580   interface_options  interface_opts;
2581
2582   g_assert(i < capture_opts->ifaces->len);
2583   interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
2584
2585   if (dfilter_compile(interface_opts.cfilter, &rfcode) && rfcode != NULL) {
2586     cmdarg_err(
2587       "Invalid capture filter \"%s\" for interface '%s'.\n"
2588       "\n"
2589       "That string looks like a valid display filter; however, it isn't a valid\n"
2590       "capture filter (%s).\n"
2591       "\n"
2592       "Note that display filters and capture filters don't have the same syntax,\n"
2593       "so you can't use most display filter expressions as capture filters.\n"
2594       "\n"
2595       "See the User's Guide for a description of the capture filter syntax.",
2596       interface_opts.cfilter, interface_opts.descr, error_message);
2597     dfilter_free(rfcode);
2598   } else {
2599     cmdarg_err(
2600       "Invalid capture filter \"%s\" for interface '%s'.\n"
2601       "\n"
2602       "That string isn't a valid capture filter (%s).\n"
2603       "See the User's Guide for a description of the capture filter syntax.",
2604       interface_opts.cfilter, interface_opts.descr, error_message);
2605   }
2606 }
2607
2608
2609 /* capture child tells us we have a new (or the first) capture file */
2610 gboolean
2611 capture_input_new_file(capture_session *cap_session, gchar *new_file)
2612 {
2613   capture_options *capture_opts = cap_session->capture_opts;
2614   capture_file *cf = (capture_file *) cap_session->cf;
2615   gboolean is_tempfile;
2616   int      err;
2617
2618   if (cap_session->state == CAPTURE_PREPARING) {
2619     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started.");
2620   }
2621   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
2622
2623   g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
2624
2625   /* free the old filename */
2626   if (capture_opts->save_file != NULL) {
2627
2628     /* we start a new capture file, close the old one (if we had one before) */
2629     if (cf->state != FILE_CLOSED) {
2630       if (cf->wth != NULL) {
2631         wtap_close(cf->wth);
2632         cf->wth = NULL;
2633       }
2634       cf->state = FILE_CLOSED;
2635     }
2636
2637     g_free(capture_opts->save_file);
2638     is_tempfile = FALSE;
2639
2640     epan_free(cf->epan);
2641     cf->epan = tshark_epan_new(cf);
2642   } else {
2643     /* we didn't had a save_file before, must be a tempfile */
2644     is_tempfile = TRUE;
2645   }
2646
2647   /* save the new filename */
2648   capture_opts->save_file = g_strdup(new_file);
2649
2650   /* if we are in real-time mode, open the new file now */
2651   if (do_dissection) {
2652     /* this is probably unecessary, but better safe than sorry */
2653     ((capture_file *)cap_session->cf)->open_type = WTAP_TYPE_AUTO;
2654     /* Attempt to open the capture file and set up to read from it. */
2655     switch(cf_open((capture_file *)cap_session->cf, capture_opts->save_file, WTAP_TYPE_AUTO, is_tempfile, &err)) {
2656     case CF_OK:
2657       break;
2658     case CF_ERROR:
2659       /* Don't unlink (delete) the save file - leave it around,
2660          for debugging purposes. */
2661       g_free(capture_opts->save_file);
2662       capture_opts->save_file = NULL;
2663       return FALSE;
2664     }
2665   }
2666
2667   cap_session->state = CAPTURE_RUNNING;
2668
2669   return TRUE;
2670 }
2671
2672
2673 /* capture child tells us we have new packets to read */
2674 void
2675 capture_input_new_packets(capture_session *cap_session, int to_read)
2676 {
2677   gboolean      ret;
2678   int           err;
2679   gchar        *err_info;
2680   gint64        data_offset;
2681   capture_file *cf = (capture_file *)cap_session->cf;
2682   gboolean      filtering_tap_listeners;
2683   guint         tap_flags;
2684
2685 #ifdef SIGINFO
2686   /*
2687    * Prevent a SIGINFO handler from writing to the standard error while
2688    * we're doing so or writing to the standard output; instead, have it
2689    * just set a flag telling us to print that information when we're done.
2690    */
2691   infodelay = TRUE;
2692 #endif /* SIGINFO */
2693
2694   /* Do we have any tap listeners with filters? */
2695   filtering_tap_listeners = have_filtering_tap_listeners();
2696
2697   /* Get the union of the flags for all tap listeners. */
2698   tap_flags = union_of_tap_listener_flags();
2699
2700   if (do_dissection) {
2701     gboolean create_proto_tree;
2702     epan_dissect_t *edt;
2703
2704     if (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
2705         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
2706       create_proto_tree = TRUE;
2707     else
2708       create_proto_tree = FALSE;
2709
2710     /* The protocol tree will be "visible", i.e., printed, only if we're
2711        printing packet details, which is true if we're printing stuff
2712        ("print_packet_info" is true) and we're in verbose mode
2713        ("packet_details" is true). */
2714     edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
2715
2716     while (to_read-- && cf->wth) {
2717       wtap_cleareof(cf->wth);
2718       ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
2719       if (ret == FALSE) {
2720         /* read from file failed, tell the capture child to stop */
2721         sync_pipe_stop(cap_session);
2722         wtap_close(cf->wth);
2723         cf->wth = NULL;
2724       } else {
2725         ret = process_packet(cf, edt, data_offset, wtap_phdr(cf->wth),
2726                              wtap_buf_ptr(cf->wth),
2727                              tap_flags);
2728       }
2729       if (ret != FALSE) {
2730         /* packet successfully read and gone through the "Read Filter" */
2731         packet_count++;
2732       }
2733     }
2734
2735     epan_dissect_free(edt);
2736
2737   } else {
2738     /*
2739      * Dumpcap's doing all the work; we're not doing any dissection.
2740      * Count all the packets it wrote.
2741      */
2742     packet_count += to_read;
2743   }
2744
2745   if (print_packet_counts) {
2746       /* We're printing packet counts. */
2747       if (packet_count != 0) {
2748         fprintf(stderr, "\r%u ", packet_count);
2749         /* stderr could be line buffered */
2750         fflush(stderr);
2751       }
2752   }
2753
2754 #ifdef SIGINFO
2755   /*
2756    * Allow SIGINFO handlers to write.
2757    */
2758   infodelay = FALSE;
2759
2760   /*
2761    * If a SIGINFO handler asked us to write out capture counts, do so.
2762    */
2763   if (infoprint)
2764     report_counts();
2765 #endif /* SIGINFO */
2766 }
2767
2768 static void
2769 report_counts(void)
2770 {
2771   if ((print_packet_counts == FALSE) && (really_quiet == FALSE)) {
2772     /* Report the count only if we aren't printing a packet count
2773        as packets arrive. */
2774       fprintf(stderr, "%u packet%s captured\n", packet_count,
2775             plurality(packet_count, "", "s"));
2776   }
2777 #ifdef SIGINFO
2778   infoprint = FALSE; /* we just reported it */
2779 #endif /* SIGINFO */
2780 }
2781
2782 #ifdef SIGINFO
2783 static void
2784 report_counts_siginfo(int signum _U_)
2785 {
2786   int sav_errno = errno;
2787   /* If we've been told to delay printing, just set a flag asking
2788      that we print counts (if we're supposed to), otherwise print
2789      the count of packets captured (if we're supposed to). */
2790   if (infodelay)
2791     infoprint = TRUE;
2792   else
2793     report_counts();
2794   errno = sav_errno;
2795 }
2796 #endif /* SIGINFO */
2797
2798
2799 /* capture child detected any packet drops? */
2800 void
2801 capture_input_drops(capture_session *cap_session _U_, guint32 dropped)
2802 {
2803   if (print_packet_counts) {
2804     /* We're printing packet counts to stderr.
2805        Send a newline so that we move to the line after the packet count. */
2806     fprintf(stderr, "\n");
2807   }
2808
2809   if (dropped != 0) {
2810     /* We're printing packet counts to stderr.
2811        Send a newline so that we move to the line after the packet count. */
2812     fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2813   }
2814 }
2815
2816
2817 /*
2818  * Capture child closed its side of the pipe, report any error and
2819  * do the required cleanup.
2820  */
2821 void
2822 capture_input_closed(capture_session *cap_session, gchar *msg)
2823 {
2824   capture_file *cf = (capture_file *) cap_session->cf;
2825
2826   if (msg != NULL)
2827     fprintf(stderr, "tshark: %s\n", msg);
2828
2829   report_counts();
2830
2831   if (cf != NULL && cf->wth != NULL) {
2832     wtap_close(cf->wth);
2833     if (cf->is_tempfile) {
2834       ws_unlink(cf->filename);
2835     }
2836   }
2837 #ifdef USE_BROKEN_G_MAIN_LOOP
2838   /*g_main_loop_quit(loop);*/
2839   g_main_loop_quit(loop);
2840 #else
2841   loop_running = FALSE;
2842 #endif
2843 }
2844
2845
2846
2847
2848 #ifdef _WIN32
2849 static BOOL WINAPI
2850 capture_cleanup(DWORD ctrltype _U_)
2851 {
2852   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2853      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2854      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2855      like SIGTERM at least when the machine's shutting down.
2856
2857      For now, we handle them all as indications that we should clean up
2858      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2859      way on UNIX.
2860
2861      We must return TRUE so that no other handler - such as one that would
2862      terminate the process - gets called.
2863
2864      XXX - for some reason, typing ^C to TShark, if you run this in
2865      a Cygwin console window in at least some versions of Cygwin,
2866      causes TShark to terminate immediately; this routine gets
2867      called, but the main loop doesn't get a chance to run and
2868      exit cleanly, at least if this is compiled with Microsoft Visual
2869      C++ (i.e., it's a property of the Cygwin console window or Bash;
2870      it happens if TShark is not built with Cygwin - for all I know,
2871      building it with Cygwin may make the problem go away). */
2872
2873   /* tell the capture child to stop */
2874   sync_pipe_stop(&global_capture_session);
2875
2876   /* don't stop our own loop already here, otherwise status messages and
2877    * cleanup wouldn't be done properly. The child will indicate the stop of
2878    * everything by calling capture_input_closed() later */
2879
2880   return TRUE;
2881 }
2882 #else
2883 static void
2884 capture_cleanup(int signum _U_)
2885 {
2886   /* tell the capture child to stop */
2887   sync_pipe_stop(&global_capture_session);
2888
2889   /* don't stop our own loop already here, otherwise status messages and
2890    * cleanup wouldn't be done properly. The child will indicate the stop of
2891    * everything by calling capture_input_closed() later */
2892 }
2893 #endif /* _WIN32 */
2894 #endif /* HAVE_LIBPCAP */
2895
2896 static gboolean
2897 process_packet_first_pass(capture_file *cf, epan_dissect_t *edt,
2898                gint64 offset, struct wtap_pkthdr *whdr,
2899                const guchar *pd)
2900 {
2901   frame_data     fdlocal;
2902   guint32        framenum;
2903   gboolean       passed;
2904
2905   /* The frame number of this packet is one more than the count of
2906      frames in this packet. */
2907   framenum = cf->count + 1;
2908
2909   /* If we're not running a display filter and we're not printing any
2910      packet information, we don't need to do a dissection. This means
2911      that all packets can be marked as 'passed'. */
2912   passed = TRUE;
2913
2914   frame_data_init(&fdlocal, framenum, whdr, offset, cum_bytes);
2915
2916   /* If we're going to print packet information, or we're going to
2917      run a read filter, or display filter, or we're going to process taps, set up to
2918      do a dissection and do so. */
2919   if (edt) {
2920     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2921         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2922       /* Grab any resolved addresses */
2923       host_name_lookup_process();
2924
2925     /* If we're running a read filter, prime the epan_dissect_t with that
2926        filter. */
2927     if (cf->rfcode)
2928       epan_dissect_prime_dfilter(edt, cf->rfcode);
2929
2930     if (cf->dfcode)
2931       epan_dissect_prime_dfilter(edt, cf->dfcode);
2932
2933     frame_data_set_before_dissect(&fdlocal, &cf->elapsed_time,
2934                                   &ref, prev_dis);
2935     if (ref == &fdlocal) {
2936       ref_frame = fdlocal;
2937       ref = &ref_frame;
2938     }
2939
2940     epan_dissect_run(edt, cf->cd_t, whdr, frame_tvbuff_new(&fdlocal, pd), &fdlocal, NULL);
2941
2942     /* Run the read filter if we have one. */
2943     if (cf->rfcode)
2944       passed = dfilter_apply_edt(cf->rfcode, edt);
2945   }
2946
2947   if (passed) {
2948     frame_data_set_after_dissect(&fdlocal, &cum_bytes);
2949     prev_cap = prev_dis = frame_data_sequence_add(cf->frames, &fdlocal);
2950
2951     /* If we're not doing dissection then there won't be any dependent frames.
2952      * More importantly, edt.pi.dependent_frames won't be initialized because
2953      * epan hasn't been initialized.
2954      * if we *are* doing dissection, then mark the dependent frames, but only
2955      * if a display filter was given and it matches this packet.
2956      */
2957     if (edt && cf->dfcode) {
2958       if (dfilter_apply_edt(cf->dfcode, edt)) {
2959         g_slist_foreach(edt->pi.dependent_frames, find_and_mark_frame_depended_upon, cf->frames);
2960       }
2961     }
2962
2963     cf->count++;
2964   } else {
2965     /* if we don't add it to the frame_data_sequence, clean it up right now
2966      * to avoid leaks */
2967     frame_data_destroy(&fdlocal);
2968   }
2969
2970   if (edt)
2971     epan_dissect_reset(edt);
2972
2973   return passed;
2974 }
2975
2976 static gboolean
2977 process_packet_second_pass(capture_file *cf, epan_dissect_t *edt, frame_data *fdata,
2978                struct wtap_pkthdr *phdr, Buffer *buf,
2979                guint tap_flags)
2980 {
2981   column_info    *cinfo;
2982   gboolean        passed;
2983
2984   /* If we're not running a display filter and we're not printing any
2985      packet information, we don't need to do a dissection. This means
2986      that all packets can be marked as 'passed'. */
2987   passed = TRUE;
2988
2989   /* If we're going to print packet information, or we're going to
2990      run a read filter, or we're going to process taps, set up to
2991      do a dissection and do so. */
2992   if (edt) {
2993     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2994         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2995       /* Grab any resolved addresses */
2996       host_name_lookup_process();
2997
2998     /* If we're running a display filter, prime the epan_dissect_t with that
2999        filter. */
3000     if (cf->dfcode)
3001       epan_dissect_prime_dfilter(edt, cf->dfcode);
3002
3003     col_custom_prime_edt(edt, &cf->cinfo);
3004
3005     /* We only need the columns if either
3006          1) some tap needs the columns
3007        or
3008          2) we're printing packet info but we're *not* verbose; in verbose
3009             mode, we print the protocol tree, not the protocol summary.
3010      */
3011     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary))
3012       cinfo = &cf->cinfo;
3013     else
3014       cinfo = NULL;
3015
3016     frame_data_set_before_dissect(fdata, &cf->elapsed_time,
3017                                   &ref, prev_dis);
3018     if (ref == fdata) {
3019       ref_frame = *fdata;
3020       ref = &ref_frame;
3021     }
3022
3023     epan_dissect_run_with_taps(edt, cf->cd_t, phdr, frame_tvbuff_new_buffer(fdata, buf), fdata, cinfo);
3024
3025     /* Run the read/display filter if we have one. */
3026     if (cf->dfcode)
3027       passed = dfilter_apply_edt(cf->dfcode, edt);
3028   }
3029
3030   if (passed) {
3031     frame_data_set_after_dissect(fdata, &cum_bytes);
3032     /* Process this packet. */
3033     if (print_packet_info) {
3034       /* We're printing packet information; print the information for
3035          this packet. */
3036       print_packet(cf, edt);
3037
3038       /* The ANSI C standard does not appear to *require* that a line-buffered
3039          stream be flushed to the host environment whenever a newline is
3040          written, it just says that, on such a stream, characters "are
3041          intended to be transmitted to or from the host environment as a
3042          block when a new-line character is encountered".
3043
3044          The Visual C++ 6.0 C implementation doesn't do what is intended;
3045          even if you set a stream to be line-buffered, it still doesn't
3046          flush the buffer at the end of every line.
3047
3048          So, if the "-l" flag was specified, we flush the standard output
3049          at the end of a packet.  This will do the right thing if we're
3050          printing packet summary lines, and, as we print the entire protocol
3051          tree for a single packet without waiting for anything to happen,
3052          it should be as good as line-buffered mode if we're printing
3053          protocol trees.  (The whole reason for the "-l" flag in either
3054          tcpdump or TShark is to allow the output of a live capture to
3055          be piped to a program or script and to have that script see the
3056          information for the packet as soon as it's printed, rather than
3057          having to wait until a standard I/O buffer fills up. */
3058       if (line_buffered)
3059         fflush(stdout);
3060
3061       if (ferror(stdout)) {
3062         show_print_file_io_error(errno);
3063         exit(2);
3064       }
3065     }
3066     prev_dis = fdata;
3067   }
3068   prev_cap = fdata;
3069
3070   if (edt) {
3071     epan_dissect_reset(edt);
3072   }
3073   return passed || fdata->flags.dependent_of_displayed;
3074 }
3075
3076 static int
3077 load_cap_file(capture_file *cf, char *save_file, int out_file_type,
3078     gboolean out_file_name_res, int max_packet_count, gint64 max_byte_count)
3079 {
3080   gint         linktype;
3081   int          snapshot_length;
3082   wtap_dumper *pdh;
3083   guint32      framenum;
3084   int          err;
3085   gchar       *err_info = NULL;
3086   gint64       data_offset;
3087   char        *save_file_string = NULL;
3088   gboolean     filtering_tap_listeners;
3089   guint        tap_flags;
3090   wtapng_section_t            *shb_hdr;
3091   wtapng_iface_descriptions_t *idb_inf;
3092   char         appname[100];
3093   struct wtap_pkthdr phdr;
3094   Buffer       buf;
3095   epan_dissect_t *edt = NULL;
3096
3097   wtap_phdr_init(&phdr);
3098
3099   shb_hdr = wtap_file_get_shb_info(cf->wth);
3100   idb_inf = wtap_file_get_idb_info(cf->wth);
3101 #ifdef PCAP_NG_DEFAULT
3102   if (idb_inf->interface_data->len > 1) {
3103     linktype = WTAP_ENCAP_PER_PACKET;
3104   } else {
3105     linktype = wtap_file_encap(cf->wth);
3106   }
3107 #else
3108   linktype = wtap_file_encap(cf->wth);
3109 #endif
3110   if (save_file != NULL) {
3111     /* Get a string that describes what we're writing to */
3112     save_file_string = output_file_description(save_file);
3113
3114     /* Set up to write to the capture file. */
3115     snapshot_length = wtap_snapshot_length(cf->wth);
3116     if (snapshot_length == 0) {
3117       /* Snapshot length of input file not known. */
3118       snapshot_length = WTAP_MAX_PACKET_SIZE;
3119     }
3120     /* If we don't have an application name add Tshark */
3121     if (shb_hdr->shb_user_appl == NULL) {
3122         g_snprintf(appname, sizeof(appname), "TShark (Wireshark) %s", get_ws_vcs_version_info());
3123         shb_hdr->shb_user_appl = appname;
3124     }
3125
3126     if (linktype != WTAP_ENCAP_PER_PACKET &&
3127         out_file_type == WTAP_FILE_TYPE_SUBTYPE_PCAP)
3128         pdh = wtap_dump_open(save_file, out_file_type, linktype,
3129             snapshot_length, FALSE /* compressed */, &err);
3130     else
3131         pdh = wtap_dump_open_ng(save_file, out_file_type, linktype,
3132             snapshot_length, FALSE /* compressed */, shb_hdr, idb_inf, &err);
3133
3134     g_free(idb_inf);
3135     idb_inf = NULL;
3136
3137     if (pdh == NULL) {
3138       /* We couldn't set up to write to the capture file. */
3139       switch (err) {
3140
3141       case WTAP_ERR_UNWRITABLE_FILE_TYPE:
3142         cmdarg_err("Capture files can't be written in that format.");
3143         break;
3144
3145       case WTAP_ERR_UNWRITABLE_ENCAP:
3146       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
3147         cmdarg_err("The capture file being read can't be written as a "
3148           "\"%s\" file.", wtap_file_type_subtype_short_string(out_file_type));
3149         break;
3150
3151       case WTAP_ERR_CANT_OPEN:
3152         cmdarg_err("The %s couldn't be created for some "
3153           "unknown reason.", save_file_string);
3154         break;
3155
3156       case WTAP_ERR_SHORT_WRITE:
3157         cmdarg_err("A full header couldn't be written to the %s.",
3158                    save_file_string);
3159         break;
3160
3161       default:
3162         cmdarg_err("The %s could not be created: %s.", save_file_string,
3163                    wtap_strerror(err));
3164         break;
3165       }
3166       goto out;
3167     }
3168   } else {
3169     if (print_packet_info) {
3170       if (!write_preamble(cf)) {
3171         err = errno;
3172         show_print_file_io_error(err);
3173         goto out;
3174       }
3175     }
3176     g_free(idb_inf);
3177     idb_inf = NULL;
3178     pdh = NULL;
3179   }
3180
3181   /* Do we have any tap listeners with filters? */
3182   filtering_tap_listeners = have_filtering_tap_listeners();
3183
3184   /* Get the union of the flags for all tap listeners. */
3185   tap_flags = union_of_tap_listener_flags();
3186
3187   if (perform_two_pass_analysis) {
3188     frame_data *fdata;
3189
3190     /* Allocate a frame_data_sequence for all the frames. */
3191     cf->frames = new_frame_data_sequence();
3192
3193     if (do_dissection) {
3194        gboolean create_proto_tree = FALSE;
3195
3196       /* If we're going to be applying a filter, we'll need to
3197          create a protocol tree against which to apply the filter. */
3198       if (cf->rfcode || cf->dfcode)
3199         create_proto_tree = TRUE;
3200
3201       /* We're not going to display the protocol tree on this pass,
3202          so it's not going to be "visible". */
3203       edt = epan_dissect_new(cf->epan, create_proto_tree, FALSE);
3204     }
3205
3206     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
3207       if (process_packet_first_pass(cf, edt, data_offset, wtap_phdr(cf->wth),
3208                          wtap_buf_ptr(cf->wth))) {
3209         /* Stop reading if we have the maximum number of packets;
3210          * When the -c option has not been used, max_packet_count
3211          * starts at 0, which practically means, never stop reading.
3212          * (unless we roll over max_packet_count ?)
3213          */
3214         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3215           err = 0; /* This is not an error */
3216           break;
3217         }
3218       }
3219     }
3220
3221     if (edt) {
3222       epan_dissect_free(edt);
3223       edt = NULL;
3224     }
3225
3226     /* Close the sequential I/O side, to free up memory it requires. */
3227     wtap_sequential_close(cf->wth);
3228
3229     /* Allow the protocol dissectors to free up memory that they
3230      * don't need after the sequential run-through of the packets. */
3231     postseq_cleanup_all_protocols();
3232
3233     prev_dis = NULL;
3234     prev_cap = NULL;
3235     ws_buffer_init(&buf, 1500);
3236
3237     if (do_dissection) {
3238       gboolean create_proto_tree;
3239
3240       if (cf->dfcode || print_details || filtering_tap_listeners ||
3241          (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
3242            create_proto_tree = TRUE;
3243       else
3244            create_proto_tree = FALSE;
3245
3246       /* The protocol tree will be "visible", i.e., printed, only if we're
3247          printing packet details, which is true if we're printing stuff
3248          ("print_packet_info" is true) and we're in verbose mode
3249          ("packet_details" is true). */
3250       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
3251     }
3252
3253     for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
3254       fdata = frame_data_sequence_find(cf->frames, framenum);
3255       if (wtap_seek_read(cf->wth, fdata->file_off, &phdr, &buf, &err,
3256                          &err_info)) {
3257         if (process_packet_second_pass(cf, edt, fdata, &phdr, &buf,
3258                                        tap_flags)) {
3259           /* Either there's no read filtering or this packet passed the
3260              filter, so, if we're writing to a capture file, write
3261              this packet out. */
3262           if (pdh != NULL) {
3263             if (!wtap_dump(pdh, &phdr, ws_buffer_start_ptr(&buf), &err, &err_info)) {
3264               /* Error writing to a capture file */
3265               switch (err) {
3266
3267               case WTAP_ERR_UNWRITABLE_ENCAP:
3268                 /*
3269                  * This is a problem with the particular frame we're writing
3270                  * and the file type and subtype we're writing; note that,
3271                  * and report the frame number and file type/subtype.
3272                  *
3273                  * XXX - framenum is not necessarily the frame number in
3274                  * the input file if there was a read filter.
3275                  */
3276                 fprintf(stderr,
3277                         "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
3278                         framenum, cf->filename,
3279                         wtap_file_type_subtype_short_string(out_file_type));
3280                 break;
3281
3282               case WTAP_ERR_PACKET_TOO_LARGE:
3283                 /*
3284                  * This is a problem with the particular frame we're writing
3285                  * and the file type and subtype we're writing; note that,
3286                  * and report the frame number and file type/subtype.
3287                  *
3288                  * XXX - framenum is not necessarily the frame number in
3289                  * the input file if there was a read filter.
3290                  */
3291                 fprintf(stderr,
3292                         "Frame %u of \"%s\" is too large for a \"%s\" file.\n",
3293                         framenum, cf->filename,
3294                         wtap_file_type_subtype_short_string(out_file_type));
3295                 break;
3296
3297               case WTAP_ERR_UNWRITABLE_REC_TYPE:
3298                 /*
3299                  * This is a problem with the particular record we're writing
3300                  * and the file type and subtype we're writing; note that,
3301                  * and report the record number and file type/subtype.
3302                  *
3303                  * XXX - framenum is not necessarily the record number in
3304                  * the input file if there was a read filter.
3305                  */
3306                 fprintf(stderr,
3307                         "Record %u of \"%s\" has a record type that can't be saved in a \"%s\" file.\n",
3308                         framenum, cf->filename,
3309                         wtap_file_type_subtype_short_string(out_file_type));
3310                 break;
3311
3312               case WTAP_ERR_UNWRITABLE_REC_DATA:
3313                 /*
3314                  * This is a problem with the particular record we're writing
3315                  * and the file type and subtype we're writing; note that,
3316                  * and report the record number and file type/subtype.
3317                  *
3318                  * XXX - framenum is not necessarily the record number in
3319                  * the input file if there was a read filter.
3320                  */
3321                 fprintf(stderr,
3322                         "Record %u of \"%s\" has data that can't be saved in a \"%s\" file.\n(%s)\n",
3323                         framenum, cf->filename,
3324                         wtap_file_type_subtype_short_string(out_file_type),
3325                         err_info != NULL ? err_info : "no information supplied");
3326                 g_free(err_info);
3327                 break;
3328
3329               default:
3330                 show_capture_file_io_error(save_file, err, FALSE);
3331                 break;
3332               }
3333               wtap_dump_close(pdh, &err);
3334               g_free(shb_hdr);
3335               exit(2);
3336             }
3337           }
3338         }
3339       }
3340     }
3341
3342     if (edt) {
3343       epan_dissect_free(edt);
3344       edt = NULL;
3345     }
3346
3347     ws_buffer_free(&buf);
3348   }
3349   else {
3350     framenum = 0;
3351
3352     if (do_dissection) {
3353       gboolean create_proto_tree;
3354
3355       if (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
3356           (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
3357         create_proto_tree = TRUE;
3358       else
3359         create_proto_tree = FALSE;
3360
3361       /* The protocol tree will be "visible", i.e., printed, only if we're
3362          printing packet details, which is true if we're printing stuff
3363          ("print_packet_info" is true) and we're in verbose mode
3364          ("packet_details" is true). */
3365       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
3366     }
3367
3368     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
3369       framenum++;
3370
3371       if (process_packet(cf, edt, data_offset, wtap_phdr(cf->wth),
3372                          wtap_buf_ptr(cf->wth),
3373                          tap_flags)) {
3374         /* Either there's no read filtering or this packet passed the
3375            filter, so, if we're writing to a capture file, write
3376            this packet out. */
3377         if (pdh != NULL) {
3378           if (!wtap_dump(pdh, wtap_phdr(cf->wth), wtap_buf_ptr(cf->wth), &err, &err_info)) {
3379             /* Error writing to a capture file */
3380             switch (err) {
3381
3382             case WTAP_ERR_UNWRITABLE_ENCAP:
3383               /*
3384                * This is a problem with the particular frame we're writing
3385                * and the file type and subtype we're writing; note that,
3386                * and report the frame number and file type/subtype.
3387                */
3388               fprintf(stderr,
3389                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
3390                       framenum, cf->filename,
3391                       wtap_file_type_subtype_short_string(out_file_type));
3392               break;
3393
3394             case WTAP_ERR_PACKET_TOO_LARGE:
3395               /*
3396                * This is a problem with the particular frame we're writing
3397                * and the file type and subtype we're writing; note that,
3398                * and report the frame number and file type/subtype.
3399                */
3400               fprintf(stderr,
3401                       "Frame %u of \"%s\" is too large for a \"%s\" file.\n",
3402                       framenum, cf->filename,
3403                       wtap_file_type_subtype_short_string(out_file_type));
3404               break;
3405
3406             case WTAP_ERR_UNWRITABLE_REC_TYPE:
3407               /*
3408                * This is a problem with the particular record we're writing
3409                * and the file type and subtype we're writing; note that,
3410                * and report the record number and file type/subtype.
3411                */
3412               fprintf(stderr,
3413                       "Record %u of \"%s\" has a record type that can't be saved in a \"%s\" file.\n",
3414                       framenum, cf->filename,
3415                       wtap_file_type_subtype_short_string(out_file_type));
3416               break;
3417
3418             case WTAP_ERR_UNWRITABLE_REC_DATA:
3419               /*
3420                * This is a problem with the particular record we're writing
3421                * and the file type and subtype we're writing; note that,
3422                * and report the record number and file type/subtype.
3423                */
3424               fprintf(stderr,
3425                       "Record %u of \"%s\" has data that can't be saved in a \"%s\" file.\n(%s)\n",
3426                       framenum, cf->filename,
3427                       wtap_file_type_subtype_short_string(out_file_type),
3428                       err_info != NULL ? err_info : "no information supplied");
3429               g_free(err_info);
3430               break;
3431
3432             default:
3433               show_capture_file_io_error(save_file, err, FALSE);
3434               break;
3435             }
3436             wtap_dump_close(pdh, &err);
3437             g_free(shb_hdr);
3438             exit(2);
3439           }
3440         }
3441       }
3442       /* Stop reading if we have the maximum number of packets;
3443        * When the -c option has not been used, max_packet_count
3444        * starts at 0, which practically means, never stop reading.
3445        * (unless we roll over max_packet_count ?)
3446        */
3447       if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3448         err = 0; /* This is not an error */
3449         break;
3450       }
3451     }
3452
3453     if (edt) {
3454       epan_dissect_free(edt);
3455       edt = NULL;
3456     }
3457   }
3458
3459   wtap_phdr_cleanup(&phdr);
3460
3461   if (err != 0) {
3462     /*
3463      * Print a message noting that the read failed somewhere along the line.
3464      *
3465      * If we're printing packet data, and the standard output and error are
3466      * going to the same place, flush the standard output, so everything
3467      * buffered up is written, and then print a newline to the standard error
3468      * before printing the error message, to separate it from the packet
3469      * data.  (Alas, that only works on UN*X; st_dev is meaningless, and
3470      * the _fstat() documentation at Microsoft doesn't indicate whether
3471      * st_ino is even supported.)
3472      */
3473 #ifndef _WIN32
3474     if (print_packet_info) {
3475       ws_statb64 stat_stdout, stat_stderr;
3476
3477       if (ws_fstat64(1, &stat_stdout) == 0 && ws_fstat64(2, &stat_stderr) == 0) {
3478         if (stat_stdout.st_dev == stat_stderr.st_dev &&
3479             stat_stdout.st_ino == stat_stderr.st_ino) {
3480           fflush(stdout);
3481           fprintf(stderr, "\n");
3482         }
3483       }
3484     }
3485 #endif
3486     switch (err) {
3487
3488     case WTAP_ERR_UNSUPPORTED:
3489       cmdarg_err("The file \"%s\" contains record data that TShark doesn't support.\n(%s)",
3490                  cf->filename,
3491                  err_info != NULL ? err_info : "no information supplied");
3492       g_free(err_info);
3493       break;
3494
3495     case WTAP_ERR_SHORT_READ:
3496       cmdarg_err("The file \"%s\" appears to have been cut short in the middle of a packet.",
3497                  cf->filename);
3498       break;
3499
3500     case WTAP_ERR_BAD_FILE:
3501       cmdarg_err("The file \"%s\" appears to be damaged or corrupt.\n(%s)",
3502                  cf->filename,
3503                  err_info != NULL ? err_info : "no information supplied");
3504       g_free(err_info);
3505       break;
3506
3507     case WTAP_ERR_DECOMPRESS:
3508       cmdarg_err("The compressed file \"%s\" appears to be damaged or corrupt.\n"
3509                  "(%s)", cf->filename,
3510                  err_info != NULL ? err_info : "no information supplied");
3511       g_free(err_info);
3512       break;
3513
3514     default:
3515       cmdarg_err("An error occurred while reading the file \"%s\": %s.",
3516                  cf->filename, wtap_strerror(err));
3517       break;
3518     }
3519     if (save_file != NULL) {
3520       /* Now close the capture file. */
3521       if (!wtap_dump_close(pdh, &err))
3522         show_capture_file_io_error(save_file, err, TRUE);
3523     }
3524   } else {
3525     if (save_file != NULL) {
3526       if (pdh && out_file_name_res) {
3527         if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
3528           cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
3529                      wtap_file_type_subtype_short_string(out_file_type));
3530         }
3531       }
3532       /* Now close the capture file. */
3533       if (!wtap_dump_close(pdh, &err))
3534         show_capture_file_io_error(save_file, err, TRUE);
3535     } else {
3536       if (print_packet_info) {
3537         if (!write_finale()) {
3538           err = errno;
3539           show_print_file_io_error(err);
3540         }
3541       }
3542     }
3543   }
3544
3545 out:
3546   wtap_close(cf->wth);
3547   cf->wth = NULL;
3548
3549   g_free(save_file_string);
3550   g_free(shb_hdr);
3551
3552   return err;
3553 }
3554
3555 static gboolean
3556 process_packet(capture_file *cf, epan_dissect_t *edt, gint64 offset, struct wtap_pkthdr *whdr,
3557                const guchar *pd, guint tap_flags)
3558 {
3559   frame_data      fdata;
3560   column_info    *cinfo;
3561   gboolean        passed;
3562
3563   /* Count this packet. */
3564   cf->count++;
3565
3566   /* If we're not running a display filter and we're not printing any
3567      packet information, we don't need to do a dissection. This means
3568      that all packets can be marked as 'passed'. */
3569   passed = TRUE;
3570
3571   frame_data_init(&fdata, cf->count, whdr, offset, cum_bytes);
3572
3573   /* If we're going to print packet information, or we're going to
3574      run a read filter, or we're going to process taps, set up to
3575      do a dissection and do so. */
3576   if (edt) {
3577     if (print_packet_info && (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
3578         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns))
3579       /* Grab any resolved addresses */
3580       host_name_lookup_process();
3581
3582     /* If we're running a filter, prime the epan_dissect_t with that
3583        filter. */
3584     if (cf->dfcode)
3585       epan_dissect_prime_dfilter(edt, cf->dfcode);
3586
3587     col_custom_prime_edt(edt, &cf->cinfo);
3588
3589     /* We only need the columns if either
3590          1) some tap needs the columns
3591        or
3592          2) we're printing packet info but we're *not* verbose; in verbose
3593             mode, we print the protocol tree, not the protocol summary.
3594        or
3595          3) there is a column mapped as an individual field */
3596     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
3597       cinfo = &cf->cinfo;
3598     else
3599       cinfo = NULL;
3600
3601     frame_data_set_before_dissect(&fdata, &cf->elapsed_time,
3602                                   &ref, prev_dis);
3603     if (ref == &fdata) {
3604       ref_frame = fdata;
3605       ref = &ref_frame;
3606     }
3607
3608     epan_dissect_run_with_taps(edt, cf->cd_t, whdr, frame_tvbuff_new(&fdata, pd), &fdata, cinfo);
3609
3610     /* Run the filter if we have it. */
3611     if (cf->dfcode)
3612       passed = dfilter_apply_edt(cf->dfcode, edt);
3613   }
3614
3615   if (passed) {
3616     frame_data_set_after_dissect(&fdata, &cum_bytes);
3617
3618     /* Process this packet. */
3619     if (print_packet_info) {
3620       /* We're printing packet information; print the information for
3621          this packet. */
3622       print_packet(cf, edt);
3623
3624       /* The ANSI C standard does not appear to *require* that a line-buffered
3625          stream be flushed to the host environment whenever a newline is
3626          written, it just says that, on such a stream, characters "are
3627          intended to be transmitted to or from the host environment as a
3628          block when a new-line character is encountered".
3629
3630          The Visual C++ 6.0 C implementation doesn't do what is intended;
3631          even if you set a stream to be line-buffered, it still doesn't
3632          flush the buffer at the end of every line.
3633
3634          So, if the "-l" flag was specified, we flush the standard output
3635          at the end of a packet.  This will do the right thing if we're
3636          printing packet summary lines, and, as we print the entire protocol
3637          tree for a single packet without waiting for anything to happen,