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