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