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