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