db098fa99470edd15fa01b2ec690dec70074fd9a
[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);
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; i++) {
228     if (wtap_dump_can_open(i)) {
229       captypes[i].sstr = wtap_file_type_short_string(i);
230       captypes[i].lstr = wtap_file_type_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_PCAPNG;
919 #else
920   volatile int         out_file_type = WTAP_FILE_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(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_PCAP && out_file_type != WTAP_FILE_PCAPNG) {
1739           cmdarg_err("Live captures can only be saved in libpcap format.");
1740           return 1;
1741         }
1742         if (global_capture_opts.capture_comment && out_file_type != WTAP_FILE_PCAPNG) {
1743           cmdarg_err("A capture comment can only be written to a pcapng file.");
1744           return 1;
1745         }
1746         if (global_capture_opts.multi_files_on) {
1747           /* Multiple-file mode doesn't work under certain conditions:
1748              a) it doesn't work if you're writing to the standard output;
1749              b) it doesn't work if you're writing to a pipe;
1750           */
1751           if (strcmp(global_capture_opts.save_file, "-") == 0) {
1752             cmdarg_err("Multiple capture files requested, but "
1753               "the capture is being written to the standard output.");
1754             return 1;
1755           }
1756           if (global_capture_opts.output_to_pipe) {
1757             cmdarg_err("Multiple capture files requested, but "
1758               "the capture file is a pipe.");
1759             return 1;
1760           }
1761           if (!global_capture_opts.has_autostop_filesize &&
1762               !global_capture_opts.has_file_duration) {
1763             cmdarg_err("Multiple capture files requested, but "
1764               "no maximum capture file size or duration was specified.");
1765             return 1;
1766           }
1767         }
1768         /* Currently, we don't support read or display filters when capturing
1769            and saving the packets. */
1770         if (rfilter != NULL) {
1771           cmdarg_err("Read filters aren't supported when capturing and saving the captured packets.");
1772           return 1;
1773         }
1774         if (dfilter != NULL) {
1775           cmdarg_err("Display filters aren't supported when capturing and saving the captured packets.");
1776           return 1;
1777         }
1778       } else {
1779         /* They didn't specify a "-w" flag, so we won't be saving to a
1780            capture file.  Check for options that only make sense if
1781            we're saving to a file. */
1782         if (global_capture_opts.has_autostop_filesize) {
1783           cmdarg_err("Maximum capture file size specified, but "
1784            "capture isn't being saved to a file.");
1785           return 1;
1786         }
1787         if (global_capture_opts.multi_files_on) {
1788           cmdarg_err("Multiple capture files requested, but "
1789             "the capture isn't being saved to a file.");
1790           return 1;
1791         }
1792         if (global_capture_opts.capture_comment) {
1793           cmdarg_err("A capture comment was specified, but "
1794             "the capture isn't being saved to a file.");
1795           return 1;
1796         }
1797       }
1798     }
1799   }
1800 #endif
1801
1802 #ifdef _WIN32
1803   /* Start windows sockets */
1804   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
1805 #endif /* _WIN32 */
1806
1807   /* Notify all registered modules that have had any of their preferences
1808      changed either from one of the preferences file or from the command
1809      line that their preferences have changed. */
1810   prefs_apply_all();
1811
1812   /* At this point MATE will have registered its field array so we can
1813      have a tap filter with one of MATE's late-registered fields as part
1814      of the filter.  We can now process all the "-z" arguments. */
1815   start_requested_stats();
1816
1817 #ifdef HAVE_LIBPCAP
1818   /* We currently don't support taps, or printing dissected packets,
1819      if we're writing to a pipe. */
1820   if (global_capture_opts.saving_to_file &&
1821       global_capture_opts.output_to_pipe) {
1822     if (tap_listeners_require_dissection()) {
1823       cmdarg_err("Taps aren't supported when saving to a pipe.");
1824       return 1;
1825     }
1826     if (print_packet_info) {
1827       cmdarg_err("Printing dissected packets isn't supported when saving to a pipe.");
1828       return 1;
1829     }
1830   }
1831 #endif
1832
1833   /* disabled protocols as per configuration file */
1834   if (gdp_path == NULL && dp_path == NULL) {
1835     set_disabled_protos_list();
1836   }
1837
1838   /* Build the column format array */
1839   build_column_format_array(&cfile.cinfo, prefs_p->num_cols, TRUE);
1840
1841 #ifdef HAVE_LIBPCAP
1842   capture_opts_trim_snaplen(&global_capture_opts, MIN_PACKET_SIZE);
1843   capture_opts_trim_ring_num_files(&global_capture_opts);
1844 #endif
1845
1846   if (rfilter != NULL) {
1847     if (!dfilter_compile(rfilter, &rfcode)) {
1848       cmdarg_err("%s", dfilter_error_msg);
1849       epan_cleanup();
1850 #ifdef HAVE_PCAP_OPEN_DEAD
1851       {
1852         pcap_t *pc;
1853
1854         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1855         if (pc != NULL) {
1856           if (pcap_compile(pc, &fcode, rfilter, 0, 0) != -1) {
1857             cmdarg_err_cont(
1858               "  Note: That read filter code looks like a valid capture filter;");
1859             cmdarg_err_cont(
1860               "        maybe you mixed them up?");
1861           }
1862           pcap_close(pc);
1863         }
1864       }
1865 #endif
1866       return 2;
1867     }
1868   }
1869   cfile.rfcode = rfcode;
1870
1871   if (dfilter != NULL) {
1872     if (!dfilter_compile(dfilter, &dfcode)) {
1873       cmdarg_err("%s", dfilter_error_msg);
1874       epan_cleanup();
1875 #ifdef HAVE_PCAP_OPEN_DEAD
1876       {
1877         pcap_t *pc;
1878
1879         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1880         if (pc != NULL) {
1881           if (pcap_compile(pc, &fcode, dfilter, 0, 0) != -1) {
1882             cmdarg_err_cont(
1883               "  Note: That display filter code looks like a valid capture filter;");
1884             cmdarg_err_cont(
1885               "        maybe you mixed them up?");
1886           }
1887           pcap_close(pc);
1888         }
1889       }
1890 #endif
1891       return 2;
1892     }
1893   }
1894   cfile.dfcode = dfcode;
1895
1896   if (print_packet_info) {
1897     /* If we're printing as text or PostScript, we have
1898        to create a print stream. */
1899     if (output_action == WRITE_TEXT) {
1900       switch (print_format) {
1901
1902       case PR_FMT_TEXT:
1903         print_stream = print_stream_text_stdio_new(stdout);
1904         break;
1905
1906       case PR_FMT_PS:
1907         print_stream = print_stream_ps_stdio_new(stdout);
1908         break;
1909
1910       default:
1911         g_assert_not_reached();
1912       }
1913     }
1914   }
1915
1916   /* We have to dissect each packet if:
1917
1918         we're printing information about each packet;
1919
1920         we're using a read filter on the packets;
1921
1922         we're using a display filter on the packets;
1923
1924         we're using any taps that need dissection. */
1925   do_dissection = print_packet_info || rfcode || dfcode || tap_listeners_require_dissection();
1926
1927   if (cf_name) {
1928     /*
1929      * We're reading a capture file.
1930      */
1931
1932     /*
1933      * Immediately relinquish any special privileges we have; we must not
1934      * be allowed to read any capture files the user running TShark
1935      * can't open.
1936      */
1937     relinquish_special_privs_perm();
1938     print_current_user();
1939
1940     if (cf_open(&cfile, cf_name, FALSE, &err) != CF_OK) {
1941       epan_cleanup();
1942       return 2;
1943     }
1944
1945     /* Set timestamp precision; there should arguably be a command-line
1946        option to let the user set this. */
1947     switch(wtap_file_tsprecision(cfile.wth)) {
1948     case(WTAP_FILE_TSPREC_SEC):
1949       timestamp_set_precision(TS_PREC_AUTO_SEC);
1950       break;
1951     case(WTAP_FILE_TSPREC_DSEC):
1952       timestamp_set_precision(TS_PREC_AUTO_DSEC);
1953       break;
1954     case(WTAP_FILE_TSPREC_CSEC):
1955       timestamp_set_precision(TS_PREC_AUTO_CSEC);
1956       break;
1957     case(WTAP_FILE_TSPREC_MSEC):
1958       timestamp_set_precision(TS_PREC_AUTO_MSEC);
1959       break;
1960     case(WTAP_FILE_TSPREC_USEC):
1961       timestamp_set_precision(TS_PREC_AUTO_USEC);
1962       break;
1963     case(WTAP_FILE_TSPREC_NSEC):
1964       timestamp_set_precision(TS_PREC_AUTO_NSEC);
1965       break;
1966     default:
1967       g_assert_not_reached();
1968     }
1969
1970     /* Process the packets in the file */
1971     TRY {
1972 #ifdef HAVE_LIBPCAP
1973       err = load_cap_file(&cfile, global_capture_opts.save_file, out_file_type, out_file_name_res,
1974           global_capture_opts.has_autostop_packets ? global_capture_opts.autostop_packets : 0,
1975           global_capture_opts.has_autostop_filesize ? global_capture_opts.autostop_filesize : 0);
1976 #else
1977       err = load_cap_file(&cfile, NULL, out_file_type, out_file_name_res, 0, 0);
1978 #endif
1979     }
1980     CATCH(OutOfMemoryError) {
1981       fprintf(stderr,
1982               "Out Of Memory!\n"
1983               "\n"
1984               "Sorry, but TShark has to terminate now!\n"
1985               "\n"
1986               "Some infos / workarounds can be found at:\n"
1987               "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
1988       err = ENOMEM;
1989     }
1990     ENDTRY;
1991     if (err != 0) {
1992       /* We still dump out the results of taps, etc., as we might have
1993          read some packets; however, we exit with an error status. */
1994       exit_status = 2;
1995     }
1996   } else {
1997     /* No capture file specified, so we're supposed to do a live capture
1998        or get a list of link-layer types for a live capture device;
1999        do we have support for live captures? */
2000 #ifdef HAVE_LIBPCAP
2001     /* if no interface was specified, pick a default */
2002     exit_status = capture_opts_default_iface_if_necessary(&global_capture_opts,
2003         ((prefs_p->capture_device) && (*prefs_p->capture_device != '\0')) ? get_if_name(prefs_p->capture_device) : NULL);
2004     if (exit_status != 0)
2005         return exit_status;
2006
2007     /* if requested, list the link layer types and exit */
2008     if (list_link_layer_types) {
2009         guint i;
2010
2011         /* Get the list of link-layer types for the capture devices. */
2012         for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2013           interface_options  interface_opts;
2014           if_capabilities_t *caps;
2015
2016           interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2017           caps = capture_get_if_capabilities(interface_opts.name, interface_opts.monitor_mode, &err_str, NULL);
2018           if (caps == NULL) {
2019             cmdarg_err("%s", err_str);
2020             g_free(err_str);
2021             return 2;
2022           }
2023           if (caps->data_link_types == NULL) {
2024             cmdarg_err("The capture device \"%s\" has no data link types.", interface_opts.name);
2025             return 2;
2026           }
2027           capture_opts_print_if_capabilities(caps, interface_opts.name, interface_opts.monitor_mode);
2028           free_if_capabilities(caps);
2029         }
2030         return 0;
2031     }
2032
2033     /*
2034      * If the standard error isn't a terminal, don't print packet counts,
2035      * as they won't show up on the user's terminal and they'll get in
2036      * the way of error messages in the file (to which we assume the
2037      * standard error was redirected; if it's redirected to the null
2038      * device, there's no point in printing packet counts anyway).
2039      *
2040      * Otherwise, if we're printing packet information and the standard
2041      * output is a terminal (which we assume means the standard output and
2042      * error are going to the same terminal), don't print packet counts,
2043      * as they'll get in the way of the packet information.
2044      *
2045      * Otherwise, if the user specified -q, don't print packet counts.
2046      *
2047      * Otherwise, print packet counts.
2048      *
2049      * XXX - what if the user wants to do a live capture, doesn't want
2050      * to save it to a file, doesn't want information printed for each
2051      * packet, does want some "-z" statistic, and wants packet counts
2052      * so they know whether they're seeing any packets?  -q will
2053      * suppress the information printed for each packet, but it'll
2054      * also suppress the packet counts.
2055      */
2056     if (!isatty(fileno(stderr)))
2057       print_packet_counts = FALSE;
2058     else if (print_packet_info && isatty(fileno(stdout)))
2059       print_packet_counts = FALSE;
2060     else if (quiet)
2061       print_packet_counts = FALSE;
2062     else
2063       print_packet_counts = TRUE;
2064
2065     if (print_packet_info) {
2066       if (!write_preamble(NULL)) {
2067         show_print_file_io_error(errno);
2068         return 2;
2069       }
2070     }
2071
2072     /* For now, assume libpcap gives microsecond precision. */
2073     timestamp_set_precision(TS_PREC_AUTO_USEC);
2074
2075     /*
2076      * XXX - this returns FALSE if an error occurred, but it also
2077      * returns FALSE if the capture stops because a time limit
2078      * was reached (and possibly other limits), so we can't assume
2079      * it means an error.
2080      *
2081      * The capture code is a bit twisty, so it doesn't appear to
2082      * be an easy fix.  We just ignore the return value for now.
2083      * Instead, pass on the exit status from the capture child.
2084      */
2085     capture();
2086     exit_status = global_capture_session.fork_child_status;
2087
2088     if (print_packet_info) {
2089       if (!write_finale()) {
2090         err = errno;
2091         show_print_file_io_error(err);
2092       }
2093     }
2094 #else
2095     /* No - complain. */
2096     cmdarg_err("This version of TShark was not built with support for capturing packets.");
2097     return 2;
2098 #endif
2099   }
2100
2101   g_free(cf_name);
2102
2103   if (cfile.frames != NULL) {
2104     free_frame_data_sequence(cfile.frames);
2105     cfile.frames = NULL;
2106   }
2107
2108   draw_tap_listeners(TRUE);
2109   funnel_dump_all_text_windows();
2110   epan_free(cfile.epan);
2111   epan_cleanup();
2112
2113   output_fields_free(output_fields);
2114   output_fields = NULL;
2115
2116   return exit_status;
2117 }
2118
2119 /*#define USE_BROKEN_G_MAIN_LOOP*/
2120
2121 #ifdef USE_BROKEN_G_MAIN_LOOP
2122   GMainLoop *loop;
2123 #else
2124   gboolean loop_running = FALSE;
2125 #endif
2126   guint32 packet_count = 0;
2127
2128
2129 /* XXX - move to the right position / file */
2130 /* read from a pipe (callback) */
2131 typedef gboolean (*pipe_input_cb_t) (gint source, gpointer user_data);
2132
2133 typedef struct pipe_input_tag {
2134   gint             source;
2135   gpointer         user_data;
2136   int             *child_process;
2137   pipe_input_cb_t  input_cb;
2138   guint            pipe_input_id;
2139 #ifdef _WIN32
2140   GMutex          *callback_running;
2141 #endif
2142 } pipe_input_t;
2143
2144 static pipe_input_t pipe_input;
2145
2146 #ifdef _WIN32
2147 /* The timer has expired, see if there's stuff to read from the pipe,
2148    if so, do the callback */
2149 static gint
2150 pipe_timer_cb(gpointer data)
2151 {
2152   HANDLE        handle;
2153   DWORD         avail        = 0;
2154   gboolean      result;
2155   DWORD         childstatus;
2156   pipe_input_t *pipe_input_p = data;
2157   gint          iterations   = 0;
2158
2159   g_mutex_lock (pipe_input_p->callback_running);
2160
2161   /* try to read data from the pipe only 5 times, to avoid blocking */
2162   while(iterations < 5) {
2163     /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: new iteration");*/
2164
2165     /* Oddly enough although Named pipes don't work on win9x,
2166        PeekNamedPipe does !!! */
2167     handle = (HANDLE) _get_osfhandle (pipe_input_p->source);
2168     result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
2169
2170     /* Get the child process exit status */
2171     GetExitCodeProcess((HANDLE)*(pipe_input_p->child_process),
2172                        &childstatus);
2173
2174     /* If the Peek returned an error, or there are bytes to be read
2175        or the childwatcher thread has terminated then call the normal
2176        callback */
2177     if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
2178
2179       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: data avail");*/
2180
2181       /* And call the real handler */
2182       if (!pipe_input_p->input_cb(pipe_input_p->source, pipe_input_p->user_data)) {
2183         g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
2184         /* pipe closed, return false so that the timer is stopped */
2185         g_mutex_unlock (pipe_input_p->callback_running);
2186         return FALSE;
2187       }
2188     }
2189     else {
2190       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: no data avail");*/
2191       /* No data, stop now */
2192       break;
2193     }
2194
2195     iterations++;
2196   }
2197
2198   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: finished with iterations: %u, new timer", iterations);*/
2199
2200   g_mutex_unlock (pipe_input_p->callback_running);
2201
2202   /* we didn't stopped the timer, so let it run */
2203   return TRUE;
2204 }
2205 #endif
2206
2207
2208 void
2209 pipe_input_set_handler(gint source, gpointer user_data, int *child_process, pipe_input_cb_t input_cb)
2210 {
2211
2212   pipe_input.source         = source;
2213   pipe_input.child_process  = child_process;
2214   pipe_input.user_data      = user_data;
2215   pipe_input.input_cb       = input_cb;
2216
2217 #ifdef _WIN32
2218 #if GLIB_CHECK_VERSION(2,31,0)
2219   pipe_input.callback_running = g_malloc(sizeof(GMutex));
2220   g_mutex_init(pipe_input.callback_running);
2221 #else
2222   pipe_input.callback_running = g_mutex_new();
2223 #endif
2224   /* Tricky to use pipes in win9x, as no concept of wait.  NT can
2225      do this but that doesn't cover all win32 platforms.  GTK can do
2226      this but doesn't seem to work over processes.  Attempt to do
2227      something similar here, start a timer and check for data on every
2228      timeout. */
2229   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
2230   pipe_input.pipe_input_id = g_timeout_add(200, pipe_timer_cb, &pipe_input);
2231 #endif
2232 }
2233
2234 static const nstime_t *
2235 tshark_get_frame_ts(void *data, guint32 frame_num)
2236 {
2237   capture_file *cf = (capture_file *) data;
2238
2239   if (ref && ref->num == frame_num)
2240     return &ref->abs_ts;
2241
2242   if (prev_dis && prev_dis->num == frame_num)
2243     return &prev_dis->abs_ts;
2244
2245   if (prev_cap && prev_cap->num == frame_num)
2246     return &prev_cap->abs_ts;
2247
2248   if (cf->frames) {
2249      frame_data *fd = frame_data_sequence_find(cf->frames, frame_num);
2250
2251      return (fd) ? &fd->abs_ts : NULL;
2252   }
2253
2254   return NULL;
2255 }
2256
2257 static epan_t *
2258 tshark_epan_new(capture_file *cf)
2259 {
2260   epan_t *epan = epan_new();
2261
2262   epan->data = cf;
2263   epan->get_frame_ts = tshark_get_frame_ts;
2264   epan->get_interface_name = cap_file_get_interface_name;
2265   epan->get_user_comment = NULL;
2266
2267   return epan;
2268 }
2269
2270 #ifdef HAVE_LIBPCAP
2271 static gboolean
2272 capture(void)
2273 {
2274   gboolean          ret;
2275   guint             i;
2276   GString          *str = g_string_new("");
2277 #ifdef USE_TSHARK_SELECT
2278   fd_set            readfds;
2279 #endif
2280 #ifndef _WIN32
2281   struct sigaction  action, oldaction;
2282 #endif
2283
2284   /*
2285    * XXX - dropping privileges is still required, until code cleanup is done
2286    *
2287    * remove all dependencies to pcap specific code and using only dumpcap is almost done.
2288    * when it's done, we don't need special privileges to run tshark at all,
2289    * therefore we don't need to drop these privileges
2290    * The only thing we might want to keep is a warning if tshark is run as root,
2291    * as it's no longer necessary and potentially dangerous.
2292    *
2293    * THE FOLLOWING IS THE FORMER COMMENT WHICH IS NO LONGER REALLY VALID:
2294    * We've opened the capture device, so we shouldn't need any special
2295    * privileges any more; relinquish those privileges.
2296    *
2297    * XXX - if we have saved set-user-ID support, we should give up those
2298    * privileges immediately, and then reclaim them long enough to get
2299    * a list of network interfaces and to open one, and then give them
2300    * up again, so that stuff we do while processing the argument list,
2301    * reading the user's preferences, loading and starting plugins
2302    * (especially *user* plugins), etc. is done with the user's privileges,
2303    * not special privileges.
2304    */
2305   relinquish_special_privs_perm();
2306   print_current_user();
2307
2308   /* Create new dissection section. */
2309   epan_free(cfile.epan);
2310   cfile.epan = tshark_epan_new(&cfile);
2311
2312 #ifdef _WIN32
2313   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
2314   SetConsoleCtrlHandler(capture_cleanup, TRUE);
2315 #else /* _WIN32 */
2316   /* Catch SIGINT and SIGTERM and, if we get either of them,
2317      clean up and exit.  If SIGHUP isn't being ignored, catch
2318      it too and, if we get it, clean up and exit.
2319
2320      We restart any read that was in progress, so that it doesn't
2321      disrupt reading from the sync pipe.  The signal handler tells
2322      the capture child to finish; it will report that it finished,
2323      or will exit abnormally, so  we'll stop reading from the sync
2324      pipe, pick up the exit status, and quit. */
2325   memset(&action, 0, sizeof(action));
2326   action.sa_handler = capture_cleanup;
2327   action.sa_flags = SA_RESTART;
2328   sigemptyset(&action.sa_mask);
2329   sigaction(SIGTERM, &action, NULL);
2330   sigaction(SIGINT, &action, NULL);
2331   sigaction(SIGHUP, NULL, &oldaction);
2332   if (oldaction.sa_handler == SIG_DFL)
2333     sigaction(SIGHUP, &action, NULL);
2334
2335 #ifdef SIGINFO
2336   /* Catch SIGINFO and, if we get it and we're capturing to a file in
2337      quiet mode, report the number of packets we've captured.
2338
2339      Again, restart any read that was in progress, so that it doesn't
2340      disrupt reading from the sync pipe. */
2341   action.sa_handler = report_counts_siginfo;
2342   action.sa_flags = SA_RESTART;
2343   sigemptyset(&action.sa_mask);
2344   sigaction(SIGINFO, &action, NULL);
2345 #endif /* SIGINFO */
2346 #endif /* _WIN32 */
2347
2348   global_capture_session.state = CAPTURE_PREPARING;
2349
2350   /* Let the user know which interfaces were chosen. */
2351   for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2352     interface_options interface_opts;
2353
2354     interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2355     interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
2356     global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
2357     g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
2358   }
2359 #ifdef _WIN32
2360   if (global_capture_opts.ifaces->len < 2)
2361 #else
2362   if (global_capture_opts.ifaces->len < 4)
2363 #endif
2364   {
2365     for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2366       interface_options interface_opts;
2367
2368       interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2369       if (i > 0) {
2370           if (global_capture_opts.ifaces->len > 2) {
2371               g_string_append_printf(str, ",");
2372           }
2373           g_string_append_printf(str, " ");
2374           if (i == global_capture_opts.ifaces->len - 1) {
2375               g_string_append_printf(str, "and ");
2376           }
2377       }
2378       g_string_append_printf(str, "'%s'", interface_opts.descr);
2379     }
2380   } else {
2381     g_string_append_printf(str, "%u interfaces", global_capture_opts.ifaces->len);
2382   }
2383   if (really_quiet == FALSE)
2384     fprintf(stderr, "Capturing on %s\n", str->str);
2385   fflush(stderr);
2386   g_string_free(str, TRUE);
2387
2388   ret = sync_pipe_start(&global_capture_opts, &global_capture_session, NULL);
2389
2390   if (!ret)
2391     return FALSE;
2392
2393   /* the actual capture loop
2394    *
2395    * XXX - glib doesn't seem to provide any event based loop handling.
2396    *
2397    * XXX - for whatever reason,
2398    * calling g_main_loop_new() ends up in 100% cpu load.
2399    *
2400    * But that doesn't matter: in UNIX we can use select() to find an input
2401    * source with something to do.
2402    *
2403    * But that doesn't matter because we're in a CLI (that doesn't need to
2404    * update a GUI or something at the same time) so it's OK if we block
2405    * trying to read from the pipe.
2406    *
2407    * So all the stuff in USE_TSHARK_SELECT could be removed unless I'm
2408    * wrong (but I leave it there in case I am...).
2409    */
2410
2411 #ifdef USE_TSHARK_SELECT
2412   FD_ZERO(&readfds);
2413   FD_SET(pipe_input.source, &readfds);
2414 #endif
2415
2416   loop_running = TRUE;
2417
2418   TRY
2419   {
2420     while (loop_running)
2421     {
2422 #ifdef USE_TSHARK_SELECT
2423       ret = select(pipe_input.source+1, &readfds, NULL, NULL, NULL);
2424
2425       if (ret == -1)
2426       {
2427         perror("select()");
2428         return TRUE;
2429       } else if (ret == 1) {
2430 #endif
2431         /* Call the real handler */
2432         if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
2433           g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
2434           return FALSE;
2435         }
2436 #ifdef USE_TSHARK_SELECT
2437       }
2438 #endif
2439     }
2440   }
2441   CATCH(OutOfMemoryError) {
2442     fprintf(stderr,
2443             "Out Of Memory!\n"
2444             "\n"
2445             "Sorry, but TShark has to terminate now!\n"
2446             "\n"
2447             "Some infos / workarounds can be found at:\n"
2448             "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2449     exit(1);
2450   }
2451   ENDTRY;
2452   return TRUE;
2453 }
2454
2455 /* capture child detected an error */
2456 void
2457 capture_input_error_message(capture_session *cap_session _U_, char *error_msg, char *secondary_error_msg)
2458 {
2459   cmdarg_err("%s", error_msg);
2460   cmdarg_err_cont("%s", secondary_error_msg);
2461 }
2462
2463
2464 /* capture child detected an capture filter related error */
2465 void
2466 capture_input_cfilter_error_message(capture_session *cap_session, guint i, char *error_message)
2467 {
2468   capture_options *capture_opts = cap_session->capture_opts;
2469   dfilter_t         *rfcode = NULL;
2470   interface_options  interface_opts;
2471
2472   g_assert(i < capture_opts->ifaces->len);
2473   interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
2474
2475   if (dfilter_compile(interface_opts.cfilter, &rfcode) && rfcode != NULL) {
2476     cmdarg_err(
2477       "Invalid capture filter \"%s\" for interface %s!\n"
2478       "\n"
2479       "That string looks like a valid display filter; however, it isn't a valid\n"
2480       "capture filter (%s).\n"
2481       "\n"
2482       "Note that display filters and capture filters don't have the same syntax,\n"
2483       "so you can't use most display filter expressions as capture filters.\n"
2484       "\n"
2485       "See the User's Guide for a description of the capture filter syntax.",
2486       interface_opts.cfilter, interface_opts.descr, error_message);
2487     dfilter_free(rfcode);
2488   } else {
2489     cmdarg_err(
2490       "Invalid capture filter \"%s\" for interface %s!\n"
2491       "\n"
2492       "That string isn't a valid capture filter (%s).\n"
2493       "See the User's Guide for a description of the capture filter syntax.",
2494       interface_opts.cfilter, interface_opts.descr, error_message);
2495   }
2496 }
2497
2498
2499 /* capture child tells us we have a new (or the first) capture file */
2500 gboolean
2501 capture_input_new_file(capture_session *cap_session, gchar *new_file)
2502 {
2503   capture_options *capture_opts = cap_session->capture_opts;
2504   gboolean is_tempfile;
2505   int      err;
2506
2507   if (cap_session->state == CAPTURE_PREPARING) {
2508     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!");
2509   }
2510   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
2511
2512   g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
2513
2514   /* free the old filename */
2515   if (capture_opts->save_file != NULL) {
2516
2517     /* we start a new capture file, close the old one (if we had one before) */
2518     if ( ((capture_file *) cap_session->cf)->state != FILE_CLOSED) {
2519       if ( ((capture_file *) cap_session->cf)->wth != NULL) {
2520         wtap_close(((capture_file *) cap_session->cf)->wth);
2521         ((capture_file *) cap_session->cf)->wth = NULL;
2522       }
2523       ((capture_file *) cap_session->cf)->state = FILE_CLOSED;
2524     }
2525
2526     g_free(capture_opts->save_file);
2527     is_tempfile = FALSE;
2528   } else {
2529     /* we didn't had a save_file before, must be a tempfile */
2530     is_tempfile = TRUE;
2531   }
2532
2533   /* save the new filename */
2534   capture_opts->save_file = g_strdup(new_file);
2535
2536   /* if we are in real-time mode, open the new file now */
2537   if (do_dissection) {
2538     /* Attempt to open the capture file and set up to read from it. */
2539     switch(cf_open((capture_file *)cap_session->cf, capture_opts->save_file, is_tempfile, &err)) {
2540     case CF_OK:
2541       break;
2542     case CF_ERROR:
2543       /* Don't unlink (delete) the save file - leave it around,
2544          for debugging purposes. */
2545       g_free(capture_opts->save_file);
2546       capture_opts->save_file = NULL;
2547       return FALSE;
2548     }
2549   }
2550
2551   cap_session->state = CAPTURE_RUNNING;
2552
2553   return TRUE;
2554 }
2555
2556
2557 /* capture child tells us we have new packets to read */
2558 void
2559 capture_input_new_packets(capture_session *cap_session, int to_read)
2560 {
2561   gboolean      ret;
2562   int           err;
2563   gchar        *err_info;
2564   gint64        data_offset;
2565   capture_file *cf = (capture_file *)cap_session->cf;
2566   gboolean      filtering_tap_listeners;
2567   guint         tap_flags;
2568
2569 #ifdef SIGINFO
2570   /*
2571    * Prevent a SIGINFO handler from writing to the standard error while
2572    * we're doing so or writing to the standard output; instead, have it
2573    * just set a flag telling us to print that information when we're done.
2574    */
2575   infodelay = TRUE;
2576 #endif /* SIGINFO */
2577
2578   /* Do we have any tap listeners with filters? */
2579   filtering_tap_listeners = have_filtering_tap_listeners();
2580
2581   /* Get the union of the flags for all tap listeners. */
2582   tap_flags = union_of_tap_listener_flags();
2583
2584   if (do_dissection) {
2585     gboolean create_proto_tree;
2586     epan_dissect_t *edt;
2587
2588     if (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
2589         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
2590       create_proto_tree = TRUE;
2591     else
2592       create_proto_tree = FALSE;
2593
2594     /* The protocol tree will be "visible", i.e., printed, only if we're
2595        printing packet details, which is true if we're printing stuff
2596        ("print_packet_info" is true) and we're in verbose mode
2597        ("packet_details" is true). */
2598     edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
2599
2600     while (to_read-- && cf->wth) {
2601       wtap_cleareof(cf->wth);
2602       ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
2603       if (ret == FALSE) {
2604         /* read from file failed, tell the capture child to stop */
2605         sync_pipe_stop(cap_session);
2606         wtap_close(cf->wth);
2607         cf->wth = NULL;
2608       } else {
2609         ret = process_packet(cf, edt, data_offset, wtap_phdr(cf->wth),
2610                              wtap_buf_ptr(cf->wth),
2611                              tap_flags);
2612       }
2613       if (ret != FALSE) {
2614         /* packet successfully read and gone through the "Read Filter" */
2615         packet_count++;
2616       }
2617     }
2618
2619     epan_dissect_free(edt);
2620
2621   } else {
2622     /*
2623      * Dumpcap's doing all the work; we're not doing any dissection.
2624      * Count all the packets it wrote.
2625      */
2626     packet_count += to_read;
2627   }
2628
2629   if (print_packet_counts) {
2630       /* We're printing packet counts. */
2631       if (packet_count != 0) {
2632         fprintf(stderr, "\r%u ", packet_count);
2633         /* stderr could be line buffered */
2634         fflush(stderr);
2635       }
2636   }
2637
2638 #ifdef SIGINFO
2639   /*
2640    * Allow SIGINFO handlers to write.
2641    */
2642   infodelay = FALSE;
2643
2644   /*
2645    * If a SIGINFO handler asked us to write out capture counts, do so.
2646    */
2647   if (infoprint)
2648     report_counts();
2649 #endif /* SIGINFO */
2650 }
2651
2652 static void
2653 report_counts(void)
2654 {
2655   if ((print_packet_counts == FALSE) && (really_quiet == FALSE)) {
2656     /* Report the count only if we aren't printing a packet count
2657        as packets arrive. */
2658       fprintf(stderr, "%u packet%s captured\n", packet_count,
2659             plurality(packet_count, "", "s"));
2660   }
2661 #ifdef SIGINFO
2662   infoprint = FALSE; /* we just reported it */
2663 #endif /* SIGINFO */
2664 }
2665
2666 #ifdef SIGINFO
2667 static void
2668 report_counts_siginfo(int signum _U_)
2669 {
2670   int sav_errno = errno;
2671   /* If we've been told to delay printing, just set a flag asking
2672      that we print counts (if we're supposed to), otherwise print
2673      the count of packets captured (if we're supposed to). */
2674   if (infodelay)
2675     infoprint = TRUE;
2676   else
2677     report_counts();
2678   errno = sav_errno;
2679 }
2680 #endif /* SIGINFO */
2681
2682
2683 /* capture child detected any packet drops? */
2684 void
2685 capture_input_drops(capture_session *cap_session _U_, guint32 dropped)
2686 {
2687   if (print_packet_counts) {
2688     /* We're printing packet counts to stderr.
2689        Send a newline so that we move to the line after the packet count. */
2690     fprintf(stderr, "\n");
2691   }
2692
2693   if (dropped != 0) {
2694     /* We're printing packet counts to stderr.
2695        Send a newline so that we move to the line after the packet count. */
2696     fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2697   }
2698 }
2699
2700
2701 /*
2702  * Capture child closed its side of the pipe, report any error and
2703  * do the required cleanup.
2704  */
2705 void
2706 capture_input_closed(capture_session *cap_session, gchar *msg)
2707 {
2708   capture_file *cf = (capture_file *) cap_session->cf;
2709
2710   if (msg != NULL)
2711     fprintf(stderr, "tshark: %s\n", msg);
2712
2713   report_counts();
2714
2715   if (cf != NULL && cf->wth != NULL) {
2716     wtap_close(cf->wth);
2717     if (cf->is_tempfile) {
2718       ws_unlink(cf->filename);
2719     }
2720   }
2721 #ifdef USE_BROKEN_G_MAIN_LOOP
2722   /*g_main_loop_quit(loop);*/
2723   g_main_quit(loop);
2724 #else
2725   loop_running = FALSE;
2726 #endif
2727 }
2728
2729
2730
2731
2732 #ifdef _WIN32
2733 static BOOL WINAPI
2734 capture_cleanup(DWORD ctrltype _U_)
2735 {
2736   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2737      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2738      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2739      like SIGTERM at least when the machine's shutting down.
2740
2741      For now, we handle them all as indications that we should clean up
2742      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2743      way on UNIX.
2744
2745      We must return TRUE so that no other handler - such as one that would
2746      terminate the process - gets called.
2747
2748      XXX - for some reason, typing ^C to TShark, if you run this in
2749      a Cygwin console window in at least some versions of Cygwin,
2750      causes TShark to terminate immediately; this routine gets
2751      called, but the main loop doesn't get a chance to run and
2752      exit cleanly, at least if this is compiled with Microsoft Visual
2753      C++ (i.e., it's a property of the Cygwin console window or Bash;
2754      it happens if TShark is not built with Cygwin - for all I know,
2755      building it with Cygwin may make the problem go away). */
2756
2757   /* tell the capture child to stop */
2758   sync_pipe_stop(&global_capture_session);
2759
2760   /* don't stop our own loop already here, otherwise status messages and
2761    * cleanup wouldn't be done properly. The child will indicate the stop of
2762    * everything by calling capture_input_closed() later */
2763
2764   return TRUE;
2765 }
2766 #else
2767 static void
2768 capture_cleanup(int signum _U_)
2769 {
2770   /* tell the capture child to stop */
2771   sync_pipe_stop(&global_capture_session);
2772
2773   /* don't stop our own loop already here, otherwise status messages and
2774    * cleanup wouldn't be done properly. The child will indicate the stop of
2775    * everything by calling capture_input_closed() later */
2776 }
2777 #endif /* _WIN32 */
2778 #endif /* HAVE_LIBPCAP */
2779
2780 static gboolean
2781 process_packet_first_pass(capture_file *cf, epan_dissect_t *edt,
2782                gint64 offset, struct wtap_pkthdr *whdr,
2783                const guchar *pd)
2784 {
2785   frame_data     fdlocal;
2786   guint32        framenum;
2787   gboolean       passed;
2788
2789   /* The frame number of this packet is one more than the count of
2790      frames in this packet. */
2791   framenum = cf->count + 1;
2792
2793   /* If we're not running a display filter and we're not printing any
2794      packet information, we don't need to do a dissection. This means
2795      that all packets can be marked as 'passed'. */
2796   passed = TRUE;
2797
2798   frame_data_init(&fdlocal, framenum, whdr, offset, cum_bytes);
2799
2800   /* If we're going to print packet information, or we're going to
2801      run a read filter, or display filter, or we're going to process taps, set up to
2802      do a dissection and do so. */
2803   if (edt) {
2804     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2805         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2806       /* Grab any resolved addresses */
2807       host_name_lookup_process();
2808
2809     /* If we're running a read filter, prime the epan_dissect_t with that
2810        filter. */
2811     if (cf->rfcode)
2812       epan_dissect_prime_dfilter(edt, cf->rfcode);
2813
2814     frame_data_set_before_dissect(&fdlocal, &cf->elapsed_time,
2815                                   &ref, prev_dis);
2816     if (ref == &fdlocal) {
2817       ref_frame = fdlocal;
2818       ref = &ref_frame;
2819     }
2820
2821     epan_dissect_run(edt, whdr, frame_tvbuff_new(&fdlocal, pd), &fdlocal, NULL);
2822
2823     /* Run the read filter if we have one. */
2824     if (cf->rfcode)
2825       passed = dfilter_apply_edt(cf->rfcode, edt);
2826   }
2827
2828   if (passed) {
2829     frame_data_set_after_dissect(&fdlocal, &cum_bytes);
2830     prev_cap = prev_dis = frame_data_sequence_add(cf->frames, &fdlocal);
2831
2832     /* If we're not doing dissection then there won't be any dependent frames.
2833      * More importantly, edt.pi.dependent_frames won't be initialized because
2834      * epan hasn't been initialized.
2835      */
2836     if (edt) {
2837       g_slist_foreach(edt->pi.dependent_frames, find_and_mark_frame_depended_upon, cf->frames);
2838     }
2839
2840     cf->count++;
2841   } else {
2842     /* if we don't add it to the frame_data_sequence, clean it up right now
2843      * to avoid leaks */
2844     frame_data_destroy(&fdlocal);
2845   }
2846
2847   if (edt)
2848     epan_dissect_reset(edt);
2849
2850   return passed;
2851 }
2852
2853 static gboolean
2854 process_packet_second_pass(capture_file *cf, epan_dissect_t *edt, frame_data *fdata,
2855                struct wtap_pkthdr *phdr, Buffer *buf,
2856                guint tap_flags)
2857 {
2858   column_info    *cinfo;
2859   gboolean        passed;
2860
2861   /* If we're not running a display filter and we're not printing any
2862      packet information, we don't need to do a dissection. This means
2863      that all packets can be marked as 'passed'. */
2864   passed = TRUE;
2865
2866   /* If we're going to print packet information, or we're going to
2867      run a read filter, or we're going to process taps, set up to
2868      do a dissection and do so. */
2869   if (edt) {
2870     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2871         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2872       /* Grab any resolved addresses */
2873       host_name_lookup_process();
2874
2875     /* If we're running a display filter, prime the epan_dissect_t with that
2876        filter. */
2877     if (cf->dfcode)
2878       epan_dissect_prime_dfilter(edt, cf->dfcode);
2879
2880     col_custom_prime_edt(edt, &cf->cinfo);
2881
2882     /* We only need the columns if either
2883          1) some tap needs the columns
2884        or
2885          2) we're printing packet info but we're *not* verbose; in verbose
2886             mode, we print the protocol tree, not the protocol summary.
2887      */
2888     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary))
2889       cinfo = &cf->cinfo;
2890     else
2891       cinfo = NULL;
2892
2893     frame_data_set_before_dissect(fdata, &cf->elapsed_time,
2894                                   &ref, prev_dis);
2895     if (ref == fdata) {
2896       ref_frame = *fdata;
2897       ref = &ref_frame;
2898     }
2899
2900     epan_dissect_run_with_taps(edt, phdr, frame_tvbuff_new_buffer(fdata, buf), fdata, cinfo);
2901
2902     /* Run the read/display filter if we have one. */
2903     if (cf->dfcode)
2904       passed = dfilter_apply_edt(cf->dfcode, edt);
2905   }
2906
2907   if (passed) {
2908     frame_data_set_after_dissect(fdata, &cum_bytes);
2909     /* Process this packet. */
2910     if (print_packet_info) {
2911       /* We're printing packet information; print the information for
2912          this packet. */
2913       print_packet(cf, edt);
2914
2915       /* The ANSI C standard does not appear to *require* that a line-buffered
2916          stream be flushed to the host environment whenever a newline is
2917          written, it just says that, on such a stream, characters "are
2918          intended to be transmitted to or from the host environment as a
2919          block when a new-line character is encountered".
2920
2921          The Visual C++ 6.0 C implementation doesn't do what is intended;
2922          even if you set a stream to be line-buffered, it still doesn't
2923          flush the buffer at the end of every line.
2924
2925          So, if the "-l" flag was specified, we flush the standard output
2926          at the end of a packet.  This will do the right thing if we're
2927          printing packet summary lines, and, as we print the entire protocol
2928          tree for a single packet without waiting for anything to happen,
2929          it should be as good as line-buffered mode if we're printing
2930          protocol trees.  (The whole reason for the "-l" flag in either
2931          tcpdump or TShark is to allow the output of a live capture to
2932          be piped to a program or script and to have that script see the
2933          information for the packet as soon as it's printed, rather than
2934          having to wait until a standard I/O buffer fills up. */
2935       if (line_buffered)
2936         fflush(stdout);
2937
2938       if (ferror(stdout)) {
2939         show_print_file_io_error(errno);
2940         exit(2);
2941       }
2942     }
2943     prev_dis = fdata;
2944   }
2945   prev_cap = fdata;
2946
2947   if (edt) {
2948     epan_dissect_reset(edt);
2949   }
2950   return passed || fdata->flags.dependent_of_displayed;
2951 }
2952
2953 static int
2954 load_cap_file(capture_file *cf, char *save_file, int out_file_type,
2955     gboolean out_file_name_res, int max_packet_count, gint64 max_byte_count)
2956 {
2957   gint         linktype;
2958   int          snapshot_length;
2959   wtap_dumper *pdh;
2960   guint32      framenum;
2961   int          err;
2962   gchar       *err_info = NULL;
2963   gint64       data_offset;
2964   char        *save_file_string = NULL;
2965   gboolean     filtering_tap_listeners;
2966   guint        tap_flags;
2967   wtapng_section_t            *shb_hdr;
2968   wtapng_iface_descriptions_t *idb_inf;
2969   char         appname[100];
2970   Buffer       buf;
2971   epan_dissect_t *edt = NULL;
2972
2973   shb_hdr = wtap_file_get_shb_info(cf->wth);
2974   idb_inf = wtap_file_get_idb_info(cf->wth);
2975 #ifdef PCAP_NG_DEFAULT
2976   if (idb_inf->number_of_interfaces > 1) {
2977     linktype = WTAP_ENCAP_PER_PACKET;
2978   } else {
2979     linktype = wtap_file_encap(cf->wth);
2980   }
2981 #else
2982   linktype = wtap_file_encap(cf->wth);
2983 #endif
2984   if (save_file != NULL) {
2985     /* Get a string that describes what we're writing to */
2986     save_file_string = output_file_description(save_file);
2987
2988     /* Set up to write to the capture file. */
2989     snapshot_length = wtap_snapshot_length(cf->wth);
2990     if (snapshot_length == 0) {
2991       /* Snapshot length of input file not known. */
2992       snapshot_length = WTAP_MAX_PACKET_SIZE;
2993     }
2994     /* If we don't have an application name add Tshark */
2995     if (shb_hdr->shb_user_appl == NULL) {
2996         g_snprintf(appname, sizeof(appname), "TShark " VERSION "%s", wireshark_svnversion);
2997         shb_hdr->shb_user_appl = appname;
2998     }
2999
3000     if (linktype != WTAP_ENCAP_PER_PACKET && out_file_type == WTAP_FILE_PCAP)
3001         pdh = wtap_dump_open(save_file, out_file_type, linktype,
3002             snapshot_length, FALSE /* compressed */, &err);
3003     else
3004         pdh = wtap_dump_open_ng(save_file, out_file_type, linktype,
3005             snapshot_length, FALSE /* compressed */, shb_hdr, idb_inf, &err);
3006
3007     g_free(idb_inf);
3008     idb_inf = NULL;
3009
3010     if (pdh == NULL) {
3011       /* We couldn't set up to write to the capture file. */
3012       switch (err) {
3013
3014       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
3015         cmdarg_err("Capture files can't be written in that format.");
3016         break;
3017
3018       case WTAP_ERR_UNSUPPORTED_ENCAP:
3019       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
3020         cmdarg_err("The capture file being read can't be written as a "
3021           "\"%s\" file.", wtap_file_type_short_string(out_file_type));
3022         break;
3023
3024       case WTAP_ERR_CANT_OPEN:
3025         cmdarg_err("The %s couldn't be created for some "
3026           "unknown reason.", save_file_string);
3027         break;
3028
3029       case WTAP_ERR_SHORT_WRITE:
3030         cmdarg_err("A full header couldn't be written to the %s.",
3031                    save_file_string);
3032         break;
3033
3034       default:
3035         cmdarg_err("The %s could not be created: %s.", save_file_string,
3036                    wtap_strerror(err));
3037         break;
3038       }
3039       goto out;
3040     }
3041   } else {
3042     if (print_packet_info) {
3043       if (!write_preamble(cf)) {
3044         err = errno;
3045         show_print_file_io_error(err);
3046         goto out;
3047       }
3048     }
3049     g_free(idb_inf);
3050     idb_inf = NULL;
3051     pdh = NULL;
3052   }
3053
3054   if (pdh && out_file_name_res) {
3055     if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
3056       cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
3057                  wtap_file_type_short_string(out_file_type));
3058     }
3059   }
3060
3061   /* Do we have any tap listeners with filters? */
3062   filtering_tap_listeners = have_filtering_tap_listeners();
3063
3064   /* Get the union of the flags for all tap listeners. */
3065   tap_flags = union_of_tap_listener_flags();
3066
3067   if (perform_two_pass_analysis) {
3068     frame_data *fdata;
3069
3070     /* Allocate a frame_data_sequence for all the frames. */
3071     cf->frames = new_frame_data_sequence();
3072
3073     if (do_dissection) {
3074        gboolean create_proto_tree = FALSE;
3075
3076       /* If we're going to be applying a filter, we'll need to
3077          create a protocol tree against which to apply the filter. */
3078       if (cf->rfcode)
3079         create_proto_tree = TRUE;
3080
3081       /* We're not going to display the protocol tree on this pass,
3082          so it's not going to be "visible". */
3083       edt = epan_dissect_new(cf->epan, create_proto_tree, FALSE);
3084     }
3085
3086     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
3087       if (process_packet_first_pass(cf, edt, data_offset, wtap_phdr(cf->wth),
3088                          wtap_buf_ptr(cf->wth))) {
3089         /* Stop reading if we have the maximum number of packets;
3090          * When the -c option has not been used, max_packet_count
3091          * starts at 0, which practically means, never stop reading.
3092          * (unless we roll over max_packet_count ?)
3093          */
3094         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3095           err = 0; /* This is not an error */
3096           break;
3097         }
3098       }
3099     }
3100
3101     if (edt) {
3102       epan_dissect_free(edt);
3103       edt = NULL;
3104     }
3105
3106     /* Close the sequential I/O side, to free up memory it requires. */
3107     wtap_sequential_close(cf->wth);
3108
3109     /* Allow the protocol dissectors to free up memory that they
3110      * don't need after the sequential run-through of the packets. */
3111     postseq_cleanup_all_protocols();
3112
3113     prev_dis = NULL;
3114     prev_cap = NULL;
3115     buffer_init(&buf, 1500);
3116
3117     if (do_dissection) {
3118       gboolean create_proto_tree;
3119
3120       if (cf->dfcode || print_details || filtering_tap_listeners ||
3121          (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
3122            create_proto_tree = TRUE;
3123       else
3124            create_proto_tree = FALSE;
3125
3126       /* The protocol tree will be "visible", i.e., printed, only if we're
3127          printing packet details, which is true if we're printing stuff
3128          ("print_packet_info" is true) and we're in verbose mode
3129          ("packet_details" is true). */
3130       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
3131     }
3132
3133     for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
3134       fdata = frame_data_sequence_find(cf->frames, framenum);
3135       if (wtap_seek_read(cf->wth, fdata->file_off, &cf->phdr,
3136           &buf, fdata->cap_len, &err, &err_info)) {
3137         if (process_packet_second_pass(cf, edt, fdata, &cf->phdr, &buf,
3138                                        tap_flags)) {
3139           /* Either there's no read filtering or this packet passed the
3140              filter, so, if we're writing to a capture file, write
3141              this packet out. */
3142           if (pdh != NULL) {
3143             if (!wtap_dump(pdh, &cf->phdr, buffer_start_ptr(&cf->buf), &err)) {
3144               /* Error writing to a capture file */
3145               switch (err) {
3146
3147               case WTAP_ERR_UNSUPPORTED_ENCAP:
3148                 /*
3149                  * This is a problem with the particular frame we're writing;
3150                  * note that, and give the frame number.
3151                  *
3152                  * XXX - framenum is not necessarily the frame number in
3153                  * the input file if there was a read filter.
3154                  */
3155                 fprintf(stderr,
3156                         "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
3157                         framenum, cf->filename,
3158                         wtap_file_type_short_string(out_file_type));
3159                 break;
3160
3161               default:
3162                 show_capture_file_io_error(save_file, err, FALSE);
3163                 break;
3164               }
3165               wtap_dump_close(pdh, &err);
3166               g_free(shb_hdr);
3167               exit(2);
3168             }
3169           }
3170         }
3171       }
3172     }
3173
3174     if (edt) {
3175       epan_dissect_free(edt);
3176       edt = NULL;
3177     }
3178
3179     buffer_free(&buf);
3180   }
3181   else {
3182     framenum = 0;
3183
3184     if (do_dissection) {
3185       gboolean create_proto_tree;
3186
3187       if (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
3188           (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
3189         create_proto_tree = TRUE;
3190       else
3191         create_proto_tree = FALSE;
3192
3193       /* The protocol tree will be "visible", i.e., printed, only if we're
3194          printing packet details, which is true if we're printing stuff
3195          ("print_packet_info" is true) and we're in verbose mode
3196          ("packet_details" is true). */
3197       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
3198     }
3199
3200     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
3201       framenum++;
3202
3203       if (process_packet(cf, edt, data_offset, wtap_phdr(cf->wth),
3204                          wtap_buf_ptr(cf->wth),
3205                          tap_flags)) {
3206         /* Either there's no read filtering or this packet passed the
3207            filter, so, if we're writing to a capture file, write
3208            this packet out. */
3209         if (pdh != NULL) {
3210           if (!wtap_dump(pdh, wtap_phdr(cf->wth), wtap_buf_ptr(cf->wth), &err)) {
3211             /* Error writing to a capture file */
3212             switch (err) {
3213
3214             case WTAP_ERR_UNSUPPORTED_ENCAP:
3215               /*
3216                * This is a problem with the particular frame we're writing;
3217                * note that, and give the frame number.
3218                */
3219               fprintf(stderr,
3220                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
3221                       framenum, cf->filename,
3222                       wtap_file_type_short_string(out_file_type));
3223               break;
3224
3225             default:
3226               show_capture_file_io_error(save_file, err, FALSE);
3227               break;
3228             }
3229             wtap_dump_close(pdh, &err);
3230             g_free(shb_hdr);
3231             exit(2);
3232           }
3233         }
3234       }
3235       /* Stop reading if we have the maximum number of packets;
3236        * When the -c option has not been used, max_packet_count
3237        * starts at 0, which practically means, never stop reading.
3238        * (unless we roll over max_packet_count ?)
3239        */
3240       if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3241         err = 0; /* This is not an error */
3242         break;
3243       }
3244     }
3245
3246     if (edt) {
3247       epan_dissect_free(edt);
3248       edt = NULL;
3249     }
3250   }
3251
3252   if (err != 0) {
3253     /*
3254      * Print a message noting that the read failed somewhere along the line.
3255      *
3256      * If we're printing packet data, and the standard output and error are
3257      * going to the same place, flush the standard output, so everything
3258      * buffered up is written, and then print a newline to the standard error
3259      * before printing the error message, to separate it from the packet
3260      * data.  (Alas, that only works on UN*X; st_dev is meaningless, and
3261      * the _fstat() documentation at Microsoft doesn't indicate whether
3262      * st_ino is even supported.)
3263      */
3264 #ifndef _WIN32
3265     if (print_packet_info) {
3266       struct stat stat_stdout, stat_stderr;
3267
3268       if (fstat(1, &stat_stdout) == 0 && fstat(2, &stat_stderr) == 0) {
3269         if (stat_stdout.st_dev == stat_stderr.st_dev &&
3270             stat_stdout.st_ino == stat_stderr.st_ino) {
3271           fflush(stdout);
3272           fprintf(stderr, "\n");
3273         }
3274       }
3275     }
3276 #endif
3277     switch (err) {
3278
3279     case WTAP_ERR_UNSUPPORTED:
3280       cmdarg_err("The file \"%s\" contains record data that TShark doesn't support.\n(%s)",
3281                  cf->filename, err_info);
3282       g_free(err_info);
3283       break;
3284
3285     case WTAP_ERR_UNSUPPORTED_ENCAP:
3286       cmdarg_err("The file \"%s\" has a packet with a network type that TShark doesn't support.\n(%s)",
3287                  cf->filename, err_info);
3288       g_free(err_info);
3289       break;
3290
3291     case WTAP_ERR_CANT_READ:
3292       cmdarg_err("An attempt to read from the file \"%s\" failed for some unknown reason.",
3293                  cf->filename);
3294       break;
3295
3296     case WTAP_ERR_SHORT_READ:
3297       cmdarg_err("The file \"%s\" appears to have been cut short in the middle of a packet.",
3298                  cf->filename);
3299       break;
3300
3301     case WTAP_ERR_BAD_FILE:
3302       cmdarg_err("The file \"%s\" appears to be damaged or corrupt.\n(%s)",
3303                  cf->filename, err_info);
3304       g_free(err_info);
3305       break;
3306
3307     case WTAP_ERR_DECOMPRESS:
3308       cmdarg_err("The compressed file \"%s\" appears to be damaged or corrupt.\n"
3309                  "(%s)", cf->filename, err_info);
3310       break;
3311
3312     default:
3313       cmdarg_err("An error occurred while reading the file \"%s\": %s.",
3314                  cf->filename, wtap_strerror(err));
3315       break;
3316     }
3317     if (save_file != NULL) {
3318       /* Now close the capture file. */
3319       if (!wtap_dump_close(pdh, &err))
3320         show_capture_file_io_error(save_file, err, TRUE);
3321     }
3322   } else {
3323     if (save_file != NULL) {
3324       /* Now close the capture file. */
3325       if (!wtap_dump_close(pdh, &err))
3326         show_capture_file_io_error(save_file, err, TRUE);
3327     } else {
3328       if (print_packet_info) {
3329         if (!write_finale()) {
3330           err = errno;
3331           show_print_file_io_error(err);
3332         }
3333       }
3334     }
3335   }
3336
3337 out:
3338   wtap_close(cf->wth);
3339   cf->wth = NULL;
3340
3341   g_free(save_file_string);
3342   g_free(shb_hdr);
3343
3344   return err;
3345 }
3346
3347 static gboolean
3348 process_packet(capture_file *cf, epan_dissect_t *edt, gint64 offset, struct wtap_pkthdr *whdr,
3349                const guchar *pd, guint tap_flags)
3350 {
3351   frame_data      fdata;
3352   column_info    *cinfo;
3353   gboolean        passed;
3354
3355   /* Count this packet. */
3356   cf->count++;
3357
3358   /* If we're not running a display filter and we're not printing any
3359      packet information, we don't need to do a dissection. This means
3360      that all packets can be marked as 'passed'. */
3361   passed = TRUE;
3362
3363   frame_data_init(&fdata, cf->count, whdr, offset, cum_bytes);
3364
3365   /* If we're going to print packet information, or we're going to
3366      run a read filter, or we're going to process taps, set up to
3367      do a dissection and do so. */
3368   if (edt) {
3369     if (print_packet_info && (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
3370         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns))
3371       /* Grab any resolved addresses */
3372       host_name_lookup_process();
3373
3374     /* If we're running a filter, prime the epan_dissect_t with that
3375        filter. */
3376     if (cf->dfcode)
3377       epan_dissect_prime_dfilter(edt, cf->dfcode);
3378
3379     col_custom_prime_edt(edt, &cf->cinfo);
3380
3381     /* We only need the columns if either
3382          1) some tap needs the columns
3383        or
3384          2) we're printing packet info but we're *not* verbose; in verbose
3385             mode, we print the protocol tree, not the protocol summary.
3386        or
3387          3) there is a column mapped as an individual field */
3388     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
3389       cinfo = &cf->cinfo;
3390     else
3391       cinfo = NULL;
3392
3393     frame_data_set_before_dissect(&fdata, &cf->elapsed_time,
3394                                   &ref, prev_dis);
3395     if (ref == &fdata) {
3396       ref_frame = fdata;
3397       ref = &ref_frame;
3398     }
3399
3400     epan_dissect_run_with_taps(edt, whdr, frame_tvbuff_new(&fdata, pd), &fdata, cinfo);
3401
3402     /* Run the filter if we have it. */
3403     if (cf->dfcode)
3404       passed = dfilter_apply_edt(cf->dfcode, edt);
3405   }
3406
3407   if (passed) {
3408     frame_data_set_after_dissect(&fdata, &cum_bytes);
3409
3410     /* Process this packet. */
3411     if (print_packet_info) {
3412       /* We're printing packet information; print the information for
3413          this packet. */
3414       print_packet(cf, edt);
3415
3416       /* The ANSI C standard does not appear to *require* that a line-buffered
3417          stream be flushed to the host environment whenever a newline is
3418          written, it just says that, on such a stream, characters "are
3419          intended to be transmitted to or from the host environment as a
3420          block when a new-line character is encountered".
3421
3422          The Visual C++ 6.0 C implementation doesn't do what is intended;
3423          even if you set a stream to be line-buffered, it still doesn't
3424          flush the buffer at the end of every line.
3425
3426          So, if the "-l" flag was specified, we flush the standard output
3427          at the end of a packet.  This will do the right thing if we're
3428          printing packet summary lines, and, as we print the entire protocol
3429          tree for a single packet without waiting for anything to happen,
3430          it should be as good as line-buffered mode if we're printing
3431          protocol trees.  (The whole reason for the "-l" flag in either
3432          tcpdump or TShark is to allow the output of a live capture to
3433          be piped to a program or script and to have that script see the
3434          information for the packet as soon as it's printed, rather than
3435          having to wait until a standard I/O buffer fills up. */
3436       if (line_buffered)
3437         fflush(stdout);
3438
3439       if (ferror(stdout)) {
3440         show_print_file_io_error(errno);
3441         exit(2);
3442       }
3443     }
3444
3445     /* this must be set after print_packet() [bug #8160] */
3446     prev_dis_frame = fdata;
3447     prev_dis = &prev_dis_frame;
3448   }
3449
3450   prev_cap_frame = fdata;
3451   prev_cap = &prev_cap_frame;
3452
3453   if (edt) {
3454     epan_dissect_reset(edt);
3455     frame_data_destroy(&fdata);
3456   }
3457   return passed;
3458 }
3459
3460 static gboolean
3461 write_preamble(capture_file *cf)
3462 {
3463   switch (output_action) {
3464
3465   case WRITE_TEXT:
3466     return print_preamble(print_stream, cf ? cf->filename : NULL, wireshark_svnversion);
3467
3468   case WRITE_XML:
3469     if (print_details)
3470       write_pdml_preamble(stdout, cf ? cf->filename : NULL);
3471     else
3472       write_psml_preamble(stdout);
3473     return !ferror(stdout);
3474
3475   case WRITE_FIELDS:
3476     write_fields_preamble(output_fields, stdout);
3477     return !ferror(stdout);
3478
3479   default:
3480     g_assert_not_reached();
3481     return FALSE;
3482   }
3483 }
3484
3485 static char *
3486 get_line_buf(size_t len)
3487 {
3488   static char   *line_bufp    = NULL;
3489   static size_t  line_buf_len = 256;
3490   size_t         new_line_buf_len;
3491
3492   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
3493        new_line_buf_len *= 2)
3494     ;
3495   if (line_bufp == NULL) {
3496     line_buf_len = new_line_buf_len;
3497     line_bufp = (char *)g_malloc(line_buf_len + 1);
3498   } else {
3499     if (new_line_buf_len > line_buf_len) {
3500       line_buf_len = new_line_buf_len;
3501       line_bufp = (char *)g_realloc(line_bufp, line_buf_len + 1);
3502     }
3503   }
3504   return line_bufp;
3505 }
3506
3507 static inline void
3508 put_string(char *dest, const char *str, size_t str_len)
3509 {
3510   memcpy(dest, str, str_len);
3511   dest[str_len] = '\0';
3512 }
3513
3514 static inline void
3515 put_spaces_string(char *dest, const char *str, size_t str_len, size_t str_with_spaces)
3516 {
3517   size_t i;
3518
3519   for (i = str_len; i < str_with_spaces; i++)
3520     *dest++ = ' ';
3521
3522   put_string(dest, str, str_len);
3523 }
3524
3525 static inline void
3526 put_string_spaces(char *dest, const char *str, size_t str_len, size_t str_with_spaces)
3527 {
3528   size_t i;
3529
3530   memcpy(dest, str, str_len);
3531   for (i = str_len; i < str_with_spaces; i++)
3532     dest[i] = ' ';
3533
3534   dest[str_with_spaces] = '\0';
3535 }
3536
3537 static gboolean
3538 print_columns(capture_file *cf)
3539 {
3540   char   *line_bufp;
3541   int     i;
3542   size_t  buf_offset;
3543   size_t  column_len;
3544   size_t  col_len;
3545
3546   line_bufp = get_line_buf(256);
3547   buf_offset = 0;
3548   *line_bufp = '\0';
3549   for (i = 0; i < cf->cinfo.num_cols; i++) {
3550     /* Skip columns not marked as visible. */
3551     if (!get_column_visible(i))
3552       continue;
3553     switch (cf->cinfo.col_fmt[i]) {
3554     case COL_NUMBER:
3555       column_len = col_len = strlen(cf->cinfo.col_data[i]);
3556       if (column_len < 3)
3557         column_len = 3;
3558       line_bufp = get_line_buf(buf_offset + column_len);
3559       put_spaces_string(line_bufp + buf_offset, cf->cinfo.col_data[i], col_len, column_len);
3560       break;
3561
3562     case COL_CLS_TIME:
3563     case COL_REL_TIME:
3564     case COL_ABS_TIME:
3565     case COL_ABS_YMD_TIME:  /* XXX - wider */
3566     case COL_ABS_YDOY_TIME: /* XXX - wider */
3567     case COL_UTC_TIME:
3568     case COL_UTC_YMD_TIME:  /* XXX - wider */
3569     case COL_UTC_YDOY_TIME: /* XXX - wider */
3570       column_len = col_len = strlen(cf->cinfo.col_data[i]);
3571       if (column_len < 10)
3572         column_len = 10;
3573       line_bufp = get_line_buf(buf_offset + column_len);
3574       put_spaces_string(line_bufp + buf_offset, cf->cinfo.col_data[i], col_len, column_len);
3575       break;
3576
3577     case COL_DEF_SRC:
3578     case COL_RES_SRC:
3579     case COL_UNRES_SRC:
3580     case COL_DEF_DL_SRC:
3581     case COL_RES_DL_SRC:
3582     case COL_UNRES_DL_SRC:
3583     case COL_DEF_NET_SRC:
3584     case COL_RES_NET_SRC:
3585     case COL_UNRES_NET_SRC:
3586       column_len = col_len = strlen(cf->cinfo.col_data[i]);
3587       if (column_len < 12)
3588         column_len = 12;
3589       line_bufp = get_line_buf(buf_offset + column_len);
3590       put_spaces_string(line_bufp + buf_offset, cf->cinfo.col_data[i], col_len, column_len);
3591       break;
3592
3593     case COL_DEF_DST:
3594     case COL_RES_DST:
3595     case COL_UNRES_DST:
3596     case COL_DEF_DL_DST:
3597     case COL_RES_DL_DST:
3598     case COL_UNRES_DL_DST:
3599     case COL_DEF_NET_DST:
3600     case COL_RES_NET_DST:
3601     case COL_UNRES_NET_DST:
3602       column_len = col_len = strlen(cf->cinfo.col_data[i]);
3603       if (column_len < 12)
3604         column_len = 12;
3605       line_bufp = get_line_buf(buf_offset + column_len);
3606       put_string_spaces(line_bufp + buf_offset, cf->cinfo.col_data[i], col_len, column_len);
3607       break;
3608
3609     default:
3610       column_len = strlen(cf->cinfo.col_data[i]);
3611       line_bufp = get_line_buf(buf_offset + column_len);
3612       put_string(line_bufp + buf_offset, cf->cinfo.col_data[i], column_len);
3613       break;
3614     }
3615     buf_offset += column_len;
3616     if (i != cf->cinfo.num_cols - 1) {
3617       /*
3618        * This isn't the last column, so we need to print a
3619        * separator between this column and the next.
3620        *
3621        * If we printed a network source and are printing a
3622        * network destination of the same type next, separate
3623        * them with " -> "; if we printed a network destination
3624        * and are printing a network source of the same type
3625        * next, separate them with " <- "; otherwise separate them
3626        * with a space.
3627        *
3628        * We add enough space to the buffer for " <- " or " -> ",
3629        * even if we're only adding " ".
3630        */
3631       line_bufp = get_line_buf(buf_offset + 4);
3632       switch (cf->cinfo.col_fmt[i]) {
3633
3634       case COL_DEF_SRC:
3635       case COL_RES_SRC:
3636       case COL_UNRES_SRC:
3637         switch (cf->cinfo.col_fmt[i + 1]) {
3638
3639         case COL_DEF_DST:
3640         case COL_RES_DST:
3641         case COL_UNRES_DST:
3642           put_string(line_bufp + buf_offset, " -> ", 4);
3643           buf_offset += 4;
3644           break;
3645
3646         default:
3647           put_string(line_bufp + buf_offset, " ", 1);
3648           buf_offset += 1;
3649           break;
3650         }
3651         break;
3652
3653       case COL_DEF_DL_SRC:
3654       case COL_RES_DL_SRC:
3655       case COL_UNRES_DL_SRC:
3656         switch (cf->cinfo.col_fmt[i + 1]) {
3657
3658         case COL_DEF_DL_DST:
3659         case COL_RES_DL_DST:
3660         case COL_UNRES_DL_DST:
3661           put_string(line_bufp + buf_offset, " -> ", 4);
3662           buf_offset += 4;
3663           break;
3664
3665         default:
3666           put_string(line_bufp + buf_offset, " ", 1);
3667           buf_offset += 1;
3668           break;
3669         }
3670         break;
3671
3672       case COL_DEF_NET_SRC:
3673       case COL_RES_NET_SRC:
3674       case COL_UNRES_NET_SRC:
3675         switch (cf->cinfo.col_fmt[i + 1]) {
3676
3677         case COL_DEF_NET_DST:
3678         case COL_RES_NET_DST:
3679         case COL_UNRES_NET_DST:
3680           put_string(line_bufp + buf_offset, " -> ", 4);
3681           buf_offset += 4;
3682           break;
3683
3684         default:
3685           put_string(line_bufp + buf_offset, " ", 1);
3686           buf_offset += 1;
3687           break;
3688         }
3689         break;
3690
3691       case COL_DEF_DST:
3692       case COL_RES_DST:
3693       case COL_UNRES_DST:
3694         switch (cf->cinfo.col_fmt[i + 1]) {
3695
3696         case COL_DEF_SRC:
3697         case COL_RES_SRC:
3698         case COL_UNRES_SRC:
3699           put_string(line_bufp + buf_offset, " <- ", 4);
3700           buf_offset += 4;
3701           break;
3702
3703         default:
3704           put_string(line_bufp + buf_offset, " ", 1);
3705           buf_offset += 1;
3706           break;
3707         }
3708         break;
3709
3710       case COL_DEF_DL_DST:
3711       case COL_RES_DL_DST:
3712       case COL_UNRES_DL_DST:
3713         switch (cf->cinfo.col_fmt[i + 1]) {
3714
3715         case COL_DEF_DL_SRC:
3716         case COL_RES_DL_SRC:
3717         case COL_UNRES_DL_SRC:
3718           put_string(line_bufp + buf_offset, " <- ", 4);
3719           buf_offset += 4;
3720           break;
3721
3722         default:
3723           put_string(line_bufp + buf_offset, " ", 1);
3724           buf_offset += 1;
3725           break;
3726         }
3727         break;
3728
3729       case COL_DEF_NET_DST:
3730       case COL_RES_NET_DST:
3731       case COL_UNRES_NET_DST:
3732         switch (cf->cinfo.col_fmt[i + 1]) {
3733
3734         case COL_DEF_NET_SRC:
3735         case COL_RES_NET_SRC:
3736         case COL_UNRES_NET_SRC:
3737           put_string(line_bufp + buf_offset, " <- ", 4);
3738           buf_offset += 4;
3739           break;
3740
3741         default:
3742           put_string(line_bufp + buf_offset, " ", 1);
3743           buf_offset += 1;
3744           break;
3745         }
3746         break;
3747
3748       default:
3749         put_string(line_bufp + buf_offset, " ", 1);
3750         buf_offset += 1;
3751         break;
3752       }
3753     }
3754   }
3755   return print_line(print_stream, 0, line_bufp);
3756 }
3757
3758 static gboolean
3759 print_packet(capture_file *cf, epan_dissect_t *edt)
3760 {
3761   print_args_t print_args;
3762
3763   if (print_summary || output_fields_has_cols(output_fields)) {
3764     /* Just fill in the columns. */
3765     epan_dissect_fill_in_columns(edt, FALSE, TRUE);
3766
3767     if (print_summary) {
3768       /* Now print them. */
3769       switch (output_action) {
3770
3771       case WRITE_TEXT:
3772         if (!print_columns(cf))
3773           return FALSE;
3774         break;
3775
3776       case WRITE_XML:
3777         proto_tree_write_psml(edt, stdout);
3778         return !ferror(stdout);
3779       case WRITE_FIELDS: /*No non-verbose "fields" format */
3780         g_assert_not_reached();
3781         break;
3782       }
3783     }
3784   }
3785   if (print_details) {
3786     /* Print the information in the protocol tree. */
3787     switch (output_action) {
3788
3789     case WRITE_TEXT:
3790       /* Only initialize the fields that are actually used in proto_tree_print.
3791        * This is particularly important for .range, as that's heap memory which
3792        * we would otherwise have to g_free().
3793       print_args.to_file = TRUE;
3794       print_args.format = print_format;
3795       print_args.print_summary = print_summary;
3796       print_args.print_formfeed = FALSE;
3797       packet_range_init(&print_args.range, &cfile);
3798       */
3799       print_args.print_hex = print_hex;
3800       print_args.print_dissections = print_details ? print_dissections_expanded : print_dissections_none;
3801
3802       if (!proto_tree_print(&print_args, edt, print_stream))
3803         return FALSE;
3804       if (!print_hex) {
3805         if (!print_line(print_stream, 0, separator))
3806           return FALSE;
3807       }
3808       break;
3809
3810     case WRITE_XML:
3811       proto_tree_write_pdml(edt, stdout);
3812       printf("\n");
3813       return !ferror(stdout);
3814     case WRITE_FIELDS:
3815       proto_tree_write_fields(output_fields, edt, &cf->cinfo, stdout);
3816       printf("\n");
3817       return !ferror(stdout);
3818     }
3819   }
3820   if (print_hex) {
3821     if (print_summary || print_details) {
3822       if (!print_line(print_stream, 0, ""))
3823         return FALSE;
3824     }
3825     if (!print_hex_data(print_stream, edt))
3826       return FALSE;
3827     if (!print_line(print_stream, 0, separator))
3828       return FALSE;
3829   }
3830   return TRUE;
3831 }
3832
3833 static gboolean
3834 write_finale(void)
3835 {
3836   switch (output_action) {
3837
3838   case WRITE_TEXT:
3839     return print_finale(print_stream);
3840
3841   case WRITE_XML:
3842     if (print_details)
3843       write_pdml_finale(stdout);
3844     else
3845       write_psml_finale(stdout);
3846     return !ferror(stdout);
3847
3848   case WRITE_FIELDS:
3849     write_fields_finale(output_fields, stdout);
3850     return !ferror(stdout);
3851
3852   default:
3853     g_assert_not_reached();
3854     return FALSE;
3855   }
3856 }
3857
3858 cf_status_t
3859 cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
3860 {
3861   wtap  *wth;
3862   gchar *err_info;
3863   char   err_msg[2048+1];
3864
3865   wth = wtap_open_offline(fname, err, &err_info, perform_two_pass_analysis);
3866   if (wth == NULL)
3867     goto fail;
3868
3869   /* The open succeeded.  Fill in the information for this file. */
3870
3871   /* Create new epan session for dissection. */
3872   epan_free(cf->epan);
3873   cf->epan = tshark_epan_new(cf);
3874
3875   cf->wth = wth;
3876   cf->f_datalen = 0; /* not used, but set it anyway */
3877
3878   /* Set the file name because we need it to set the follow stream filter.
3879      XXX - is that still true?  We need it for other reasons, though,
3880      in any case. */
3881   cf->filename = g_strdup(fname);
3882
3883   /* Indicate whether it's a permanent or temporary file. */
3884   cf->is_tempfile = is_tempfile;
3885
3886   /* No user changes yet. */
3887   cf->unsaved_changes = FALSE;
3888
3889   cf->cd_t      = wtap_file_type(cf->wth);
3890   cf->count     = 0;
3891   cf->drops_known = FALSE;
3892   cf->drops     = 0;
3893   cf->snap      = wtap_snapshot_length(cf->wth);
3894   if (cf->snap == 0) {
3895     /* Snapshot length not known. */
3896     cf->has_snap = FALSE;
3897     cf->snap = WTAP_MAX_PACKET_SIZE;
3898   } else
3899     cf->has_snap = TRUE;
3900   nstime_set_zero(&cf->elapsed_time);
3901   ref = NULL;
3902   prev_dis = NULL;
3903   prev_cap = NULL;
3904
3905   cf->state = FILE_READ_IN_PROGRESS;
3906
3907   wtap_set_cb_new_ipv4(cf->wth, add_ipv4_name);
3908   wtap_set_cb_new_ipv6(cf->wth, (wtap_new_ipv6_callback_t) add_ipv6_name);
3909
3910   return CF_OK;
3911
3912 fail:
3913   g_snprintf(err_msg, sizeof err_msg,
3914              cf_open_error_message(*err, err_info, FALSE, cf->cd_t), fname);
3915   cmdarg_err("%s", err_msg);
3916   return CF_ERROR;
3917 }
3918
3919 static void
3920 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
3921 {
3922   char *save_file_string;
3923
3924   save_file_string = output_file_description(fname);
3925
3926   switch (err) {
3927
3928   case ENOSPC:
3929     cmdarg_err("Not all the packets could be written to the %s because there is "
3930                "no space left on the file system.",
3931                save_file_string);
3932     break;
3933
3934 #ifdef EDQUOT
3935   case EDQUOT:
3936     cmdarg_err("Not all the packets could be written to the %s because you are "
3937                "too close to, or over your disk quota.",
3938                save_file_string);
3939   break;
3940 #endif
3941
3942   case WTAP_ERR_CANT_CLOSE:
3943     cmdarg_err("The %s couldn't be closed for some unknown reason.",
3944                save_file_string);
3945     break;
3946
3947   case WTAP_ERR_SHORT_WRITE:
3948     cmdarg_err("Not all the packets could be written to the %s.",
3949                save_file_string);
3950     break;
3951
3952   default:
3953     if (is_close) {
3954       cmdarg_err("The %s could not be closed: %s.", save_file_string,
3955                  wtap_strerror(err));
3956     } else {
3957       cmdarg_err("An error occurred while writing to the %s: %s.",
3958                  save_file_string, wtap_strerror(err));
3959     }
3960     break;
3961   }
3962   g_free(save_file_string);
3963 }
3964
3965 static void
3966 show_print_file_io_error(int err)
3967 {
3968   switch (err) {
3969
3970   case ENOSPC:
3971     cmdarg_err("Not all the packets could be printed because there is "
3972 "no space left on the file system.");
3973     break;
3974
3975 #ifdef EDQUOT
3976   case EDQUOT:
3977     cmdarg_err("Not all the packets could be printed because you are "
3978 "too close to, or over your disk quota.");
3979   break;
3980 #endif
3981
3982   default:
3983     cmdarg_err("An error occurred while printing packets: %s.",
3984       g_strerror(err));
3985     break;
3986   }
3987 }
3988
3989 static const char *
3990 cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
3991                       int file_type)
3992 {
3993   const char *errmsg;
3994   static char errmsg_errno[1024+1];
3995
3996   if (err < 0) {
3997     /* Wiretap error. */
3998     switch (err) {
3999
4000     case WTAP_ERR_NOT_REGULAR_FILE:
4001       errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
4002       break;
4003
4004     case WTAP_ERR_RANDOM_OPEN_PIPE:
4005       /* Seen only when opening a capture file for reading. */
4006       errmsg = "The file \"%s\" is a pipe or FIFO; TShark can't read pipe or FIFO files in two-pass mode.";
4007       break;
4008
4009     case WTAP_ERR_FILE_UNKNOWN_FORMAT:
4010       /* Seen only when opening a capture file for reading. */
4011       errmsg = "The file \"%s\" isn't a capture file in a format TShark understands.";
4012       break;
4013
4014     case WTAP_ERR_UNSUPPORTED:
4015       /* Seen only when opening a capture file for reading. */
4016       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4017                "The file \"%%s\" isn't a capture file in a format TShark understands.\n"
4018                "(%s)", err_info);
4019       g_free(err_info);
4020       errmsg = errmsg_errno;
4021       break;
4022
4023     case WTAP_ERR_CANT_WRITE_TO_PIPE:
4024       /* Seen only when opening a capture file for writing. */
4025       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4026                  "The file \"%%s\" is a pipe, and \"%s\" capture files can't be "
4027                  "written to a pipe.", wtap_file_type_short_string(file_type));
4028       errmsg = errmsg_errno;
4029       break;
4030
4031     case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
4032       /* Seen only when opening a capture file for writing. */
4033       errmsg = "TShark doesn't support writing capture files in that format.";
4034       break;
4035
4036     case WTAP_ERR_UNSUPPORTED_ENCAP:
4037       if (for_writing) {
4038         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4039                    "TShark can't save this capture as a \"%s\" file.",
4040                    wtap_file_type_short_string(file_type));
4041       } else {
4042         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4043                  "The file \"%%s\" is a capture for a network type that TShark doesn't support.\n"
4044                  "(%s)", err_info);
4045         g_free(err_info);
4046       }
4047       errmsg = errmsg_errno;
4048       break;
4049
4050     case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
4051       if (for_writing) {
4052         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4053                    "TShark can't save this capture as a \"%s\" file.",
4054                    wtap_file_type_short_string(file_type));
4055         errmsg = errmsg_errno;
4056       } else
4057         errmsg = "The file \"%s\" is a capture for a network type that TShark doesn't support.";
4058       break;
4059
4060     case WTAP_ERR_BAD_FILE:
4061       /* Seen only when opening a capture file for reading. */
4062       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4063                "The file \"%%s\" appears to be damaged or corrupt.\n"
4064                "(%s)", err_info);
4065       g_free(err_info);
4066       errmsg = errmsg_errno;
4067       break;
4068
4069     case WTAP_ERR_CANT_OPEN:
4070       if (for_writing)
4071         errmsg = "The file \"%s\" could not be created for some unknown reason.";
4072       else
4073         errmsg = "The file \"%s\" could not be opened for some unknown reason.";
4074       break;
4075
4076     case WTAP_ERR_SHORT_READ:
4077       errmsg = "The file \"%s\" appears to have been cut short"
4078                " in the middle of a packet or other data.";
4079       break;
4080
4081     case WTAP_ERR_SHORT_WRITE:
4082       errmsg = "A full header couldn't be written to the file \"%s\".";
4083       break;
4084
4085     case WTAP_ERR_COMPRESSION_NOT_SUPPORTED:
4086       errmsg = "This file type cannot be written as a compressed file.";
4087       break;
4088
4089     case WTAP_ERR_DECOMPRESS:
4090       /* Seen only when opening a capture file for reading. */
4091       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4092                  "The compressed file \"%%s\" appears to be damaged or corrupt.\n"
4093                  "(%s)", err_info);
4094       g_free(err_info);
4095       errmsg = errmsg_errno;
4096       break;
4097
4098     default:
4099       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4100                  "The file \"%%s\" could not be %s: %s.",
4101                  for_writing ? "created" : "opened",
4102                  wtap_strerror(err));
4103       errmsg = errmsg_errno;
4104       break;
4105     }
4106   } else
4107     errmsg = file_open_error_message(err, for_writing);
4108   return errmsg;
4109 }
4110
4111 /*
4112  * Open/create errors are reported with an console message in TShark.
4113  */
4114 static void
4115 open_failure_message(const char *filename, int err, gboolean for_writing)
4116 {
4117   fprintf(stderr, "tshark: ");
4118   fprintf(stderr, file_open_error_message(err, for_writing), filename);
4119   fprintf(stderr, "\n");
4120 }
4121
4122
4123 /*
4124  * General errors are reported with an console message in TShark.
4125  */
4126 static void
4127 failure_message(const char *msg_format, va_list ap)
4128 {
4129   fprintf(stderr, "tshark: ");
4130   vfprintf(stderr, msg_format, ap);
4131   fprintf(stderr, "\n");
4132 }
4133
4134 /*
4135  * Read errors are reported with an console message in TShark.
4136  */
4137 static void
4138 read_failure_message(const char *filename, int err)
4139 {
4140   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
4141           filename, g_strerror(err));
4142 }
4143
4144 /*
4145  * Write errors are reported with an console message in TShark.
4146  */
4147 static void
4148 write_failure_message(const char *filename, int err)
4149 {
4150   cmdarg_err("An error occurred while writing to the file \"%s\": %s.",
4151           filename, g_strerror(err));
4152 }
4153
4154 /*
4155  * Report an error in command-line arguments.
4156  */
4157 void
4158 cmdarg_err(const char *fmt, ...)
4159 {
4160   va_list ap;
4161
4162   va_start(ap, fmt);
4163   failure_message(fmt, ap);
4164   va_end(ap);
4165 }
4166
4167 /*
4168  * Report additional information for an error in command-line arguments.
4169  */
4170 void
4171 cmdarg_err_cont(const char *fmt, ...)
4172 {
4173   va_list ap;
4174
4175   va_start(ap, fmt);
4176   vfprintf(stderr, fmt, ap);
4177   fprintf(stderr, "\n");
4178   va_end(ap);
4179 }
4180
4181
4182 /*
4183  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
4184  *
4185  * Local variables:
4186  * c-basic-offset: 2
4187  * tab-width: 8
4188  * indent-tabs-mode: nil
4189  * End:
4190  *
4191  * vi: set shiftwidth=2 tabstop=8 expandtab:
4192  * :indentSize=2:tabSize=8:noTabs=true:
4193  */