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