8f004c2502780c0e23d84b84eba60fdd42793844
[obnox/wireshark/wip.git] / tethereal.c
1 /* tethereal.c
2  *
3  * $Id$
4  *
5  * Ethereal - Network traffic analyzer
6  * By Gerald Combs <gerald@ethereal.com>
7  * Copyright 1998 Gerald Combs
8  *
9  * Text-mode variant, by Gilbert Ramirez <gram@alumni.rice.edu>
10  * and Guy Harris <guy@alum.mit.edu>.
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 NEED_GETOPT_H
59 #include "getopt.h"
60 #endif
61
62 #include <glib.h>
63 #include <epan/epan.h>
64 #include <epan/filesystem.h>
65 #include <wiretap/file_util.h>
66
67 #include "globals.h"
68 #include <epan/timestamp.h>
69 #include <epan/packet.h>
70 #include "file.h"
71 #include "disabled_protos.h"
72 #include <epan/prefs.h>
73 #include <epan/column.h>
74 #include "print.h"
75 #include <epan/addr_resolv.h>
76 #include "util.h"
77 #include "clopts_common.h"
78 #include "cmdarg_err.h"
79 #include "version_info.h"
80 #include <epan/conversation.h>
81 #include <epan/plugins.h>
82 #include "register.h"
83 #include "conditions.h"
84 #include "capture_stop_conditions.h"
85 #include "ringbuffer.h"
86 #include "capture_ui_utils.h"
87 #include <epan/epan_dissect.h>
88 #include <epan/tap.h>
89 #include <epan/stat_cmd_args.h>
90 #include <epan/timestamp.h>
91
92 #ifdef HAVE_LIBPCAP
93 #include <pcap.h>
94 #include <setjmp.h>
95 #include "capture-pcap-util.h"
96 #include <wiretap/wtap-capture.h>
97 #ifdef _WIN32
98 #include "capture-wpcap.h"
99 #include "capture_errs.h"
100 #endif /* _WIN32 */
101 #include "capture.h"
102 #include "capture_loop.h"
103 #endif /* HAVE_LIBPCAP */
104 #include "epan/emem.h"
105 #include "log.h"
106
107 /*
108  * This is the template for the decode as option; it is shared between the
109  * various functions that output the usage for this parameter.
110  */
111 static const gchar decode_as_arg_template[] = "<layer_type>==<selector>,<decode_as_protocol>";
112
113 static nstime_t first_ts;
114 static nstime_t prev_ts;
115 static GString *comp_info_str, *runtime_info_str;
116
117 static gboolean print_packet_info;      /* TRUE if we're to print packet information */
118 /*
119  * The way the packet decode is to be written.
120  */
121 typedef enum {
122         WRITE_TEXT,     /* summary or detail text */
123         WRITE_XML       /* PDML or PSML */
124         /* Add CSV and the like here */
125 } output_action_e;
126 static output_action_e output_action;
127 static gboolean do_dissection;  /* TRUE if we have to dissect each packet */
128 static gboolean verbose;
129 static gboolean print_hex;
130 static gboolean line_buffered;
131 static guint32 cum_bytes = 0;
132 static print_format_e print_format = PR_FMT_TEXT;
133 static print_stream_t *print_stream;
134
135 #ifdef HAVE_LIBPCAP
136 /*
137  * TRUE if we're to print packet counts to keep track of captured packets.
138  */
139 static gboolean print_packet_counts;
140
141
142 static loop_data ld;
143
144 #ifdef HAVE_LIBPCAP
145 static capture_options capture_opts;
146
147
148 #ifdef SIGINFO
149 static gboolean infodelay;      /* if TRUE, don't print capture info in SIGINFO handler */
150 static gboolean infoprint;      /* if TRUE, print capture info after clearing infodelay */
151 #endif /* SIGINFO */
152 #endif /* HAVE_LIBPCAP */
153
154
155 static int capture(char *, int);
156 static void capture_pcap_cb(u_char *, const struct pcap_pkthdr *,
157   const u_char *);
158 static void report_counts(void);
159 #ifdef _WIN32
160 static BOOL WINAPI capture_cleanup(DWORD);
161 #else /* _WIN32 */
162 static void capture_cleanup(int);
163 #ifdef SIGINFO
164 static void report_counts_siginfo(int);
165 #endif /* SIGINFO */
166 #endif /* _WIN32 */
167 #endif /* HAVE_LIBPCAP */
168
169 static int load_cap_file(capture_file *, char *, int);
170 static gboolean process_packet(capture_file *cf, wtap_dumper *pdh, long offset,
171     const struct wtap_pkthdr *whdr, union wtap_pseudo_header *pseudo_header,
172     const guchar *pd, int *err);
173 static void show_capture_file_io_error(const char *, int, gboolean);
174 static void show_print_file_io_error(int err);
175 static gboolean write_preamble(capture_file *cf);
176 static gboolean print_packet(capture_file *cf, epan_dissect_t *edt);
177 static gboolean write_finale(void);
178 static const char *cf_open_error_message(int err, gchar *err_info,
179     gboolean for_writing, int file_type);
180
181 static void open_failure_message(const char *filename, int err,
182     gboolean for_writing);
183 static void failure_message(const char *msg_format, va_list ap);
184 static void read_failure_message(const char *filename, int err);
185
186 capture_file cfile;
187
188
189 static void
190 print_usage(gboolean print_ver)
191 {
192   int i;
193   FILE *output;
194
195   if (print_ver) {
196     output = stdout;
197     fprintf(output, "This is t" PACKAGE " " VERSION "%s"
198         "\n (C) 1998-2005 Gerald Combs <gerald@ethereal.com>"
199         "\n%s\n%s\n",
200
201         svnversion, comp_info_str->str, runtime_info_str->str);
202   } else {
203     output = stderr;
204   }
205 #ifdef HAVE_LIBPCAP
206   fprintf(output, "\nt%s [ -vh ] [ -DlLnpqSVx ] [ -a <capture autostop condition> ] ...\n",
207           PACKAGE);
208   fprintf(output, "\t[ -b <capture ring buffer option> ] ...\n");
209 #ifdef _WIN32
210   fprintf(output, "\t[ -B <capture buffer size> ]\n");
211 #endif
212   fprintf(output, "\t[ -c <capture packet count> ]\n");
213   fprintf(output, "\t[ -d %s ] ...\n", decode_as_arg_template);
214   fprintf(output, "\t[ -f <capture filter> ] [ -F <output file type> ]\n");
215   fprintf(output, "\t[ -i <capture interface> ] [ -N <name resolving flags> ]\n");
216   fprintf(output, "\t[ -o <preference setting> ] ... [ -r <infile> ]\n");
217   fprintf(output, "\t[ -R <read (display) filter> ] [ -s <capture snaplen> ]\n");
218   fprintf(output, "\t[ -t <time stamp format> ] [ -T pdml|ps|psml|text ]\n");
219   fprintf(output, "\t[ -w <savefile> ] [ -y <capture link type> ] [ -z <statistics> ]\n");
220 #else
221   fprintf(output, "\nt%s [ -vh ] [ -lnVx ]\n", PACKAGE);
222   fprintf(output, "\t[ -d %s ] ...\n", decode_as_arg_template);
223   fprintf(output, "\t[ -F <output file type> ] [ -N <name resolving flags> ]\n");
224   fprintf(output, "\t[ -o <preference setting> ] ... [ -r <infile> ]\n");
225   fprintf(output, "\t[ -R <read (display) filter> ] \t[ -t <time stamp format> ]\n");
226   fprintf(output, "\t[ -T pdml|ps|psml|text ] [ -w <savefile> ] [ -z <statistics ]\n");
227 #endif
228   fprintf(output, "Valid file type arguments to the \"-F\" flag:\n");
229   for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
230     if (wtap_dump_can_open(i))
231       fprintf(output, "\t%s - %s\n",
232         wtap_file_type_short_string(i), wtap_file_type_string(i));
233   }
234   fprintf(output, "\tdefault is libpcap\n");
235 }
236
237 /*
238  * For a dissector table, print on the stream described by output,
239  * its short name (which is what's used in the "-d" option) and its
240  * descriptive name.
241  */
242 static void
243 display_dissector_table_names(char *table_name, const char *ui_name,
244                               gpointer output)
245 {
246   fprintf((FILE *)output, "\t%s (%s)\n", table_name, ui_name);
247 }
248
249 /*
250  * For a dissector handle, print on the stream described by output,
251  * the filter name (which is what's used in the "-d" option) and the full
252  * name for the protocol that corresponds to this handle.
253  */
254 static void
255 display_dissector_names(const gchar *table _U_, gpointer handle, gpointer output)
256 {
257   int                proto_id;
258   const gchar*       proto_filter_name;
259   const gchar*       proto_ui_name;
260
261   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
262
263   if (proto_id != -1) {
264     proto_filter_name = proto_get_protocol_filter_name(proto_id);
265     proto_ui_name =  proto_get_protocol_name(proto_id);
266     g_assert(proto_filter_name != NULL);
267     g_assert(proto_ui_name != NULL);
268
269     fprintf((FILE *)output, "\t%s (%s)\n",
270             proto_filter_name,
271             proto_ui_name);
272   }
273 }
274
275 /*
276  * The protocol_name_search structure is used by find_protocol_name_func()
277  * to pass parameters and store results
278  */
279 struct protocol_name_search{
280   gchar              *searched_name;  /* Protocol filter name we are looking for */
281   dissector_handle_t  matched_handle; /* Handle for a dissector whose protocol has the specified filter name */
282   guint               nb_match;       /* How many dissectors matched searched_name */
283 };
284 typedef struct protocol_name_search *protocol_name_search_t;
285
286 /*
287  * This function parses all dissectors associated with a table to find the
288  * one whose protocol has the specified filter name.  It is called
289  * as a reference function in a call to dissector_table_foreach_handle.
290  * The name we are looking for, as well as the results, are stored in the
291  * protocol_name_search struct pointed to by user_data.
292  * If called using dissector_table_foreach_handle, we actually parse the
293  * whole list of dissectors.
294  */
295 static void
296 find_protocol_name_func(const gchar *table _U_, gpointer handle, gpointer user_data)
297
298 {
299   int                         proto_id;
300   const gchar                *protocol_filter_name;
301   protocol_name_search_t      search_info;
302
303   g_assert(handle);
304
305   search_info = (protocol_name_search_t)user_data;
306
307   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
308   if (proto_id != -1) {
309     protocol_filter_name = proto_get_protocol_filter_name(proto_id);
310     g_assert(protocol_filter_name != NULL);
311     if (strcmp(protocol_filter_name, search_info->searched_name) == 0) {
312       /* Found a match */
313       if (search_info->nb_match == 0) {
314         /* Record this handle only if this is the first match */
315         search_info->matched_handle = (dissector_handle_t)handle; /* Record the handle for this matching dissector */
316       }
317       search_info->nb_match++;
318     }
319   }
320 }
321
322 /*
323  * Print all layer type names supported.
324  * We send the output to the stream described by the handle output.
325  */
326
327 static void
328 fprint_all_layer_types(FILE *output)
329
330 {
331   dissector_all_tables_foreach_table(display_dissector_table_names, (gpointer)output);
332 }
333
334 /*
335  * Print all protocol names supported for a specific layer type.
336  * table_name contains the layer type name in which the search is performed.
337  * We send the output to the stream described by the handle output.
338  */
339
340 static void
341 fprint_all_protocols_for_layer_types(FILE *output, gchar *table_name)
342
343 {
344   dissector_table_foreach_handle(table_name,
345                                  display_dissector_names,
346                                  (gpointer)output);
347 }
348
349 /*
350  * The function below parses the command-line parameters for the decode as
351  * feature (a string pointer by cl_param).
352  * It checks the format of the command-line, searches for a matching table
353  * and dissector.  If a table/dissector match is not found, we display a
354  * summary of the available tables/dissectors (on stderr) and return FALSE.
355  * If everything is fine, we get the "Decode as" preference activated,
356  * then we return TRUE.
357  */
358 static gboolean
359 add_decode_as(const gchar *cl_param)
360 {
361   gchar                        *table_name;
362   guint32                       selector;
363   gchar                        *decoded_param;
364   gchar                        *remaining_param;
365   gchar                        *selector_str;
366   gchar                        *dissector_str;
367   dissector_handle_t            dissector_matching;
368   dissector_table_t             table_matching;
369   ftenum_t                      dissector_table_selector_type;
370   struct protocol_name_search   user_protocol_name;
371
372 /* The following code will allocate and copy the command-line options in a string pointed by decoded_param */
373
374   g_assert(cl_param);
375   decoded_param = g_malloc( sizeof(gchar) * (strlen(cl_param) + 1) ); /* Allocate enough space to have a working copy of the command-line parameter */
376   g_assert(decoded_param);
377   strcpy(decoded_param, cl_param);
378
379
380   /* The lines below will parse this string (modifying it) to extract all
381     necessary information.  Note that decoded_param is still needed since
382     strings are not copied - we just save pointers. */
383
384   /* This section extracts a layer type (table_name) from decoded_param */
385   table_name = decoded_param; /* Layer type string starts from beginning */
386
387   remaining_param = strchr(table_name, '=');
388   if (remaining_param == NULL) {
389     cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
390     /* If the argument does not follow the template, carry on anyway to check
391        if the table name is at least correct.  If remaining_param is NULL,
392        we'll exit anyway further down */
393   }
394   else {
395     *remaining_param = '\0'; /* Terminate the layer type string (table_name) where '=' was detected */
396   }
397
398   /* Remove leading and trailing spaces from the table name */
399   while ( table_name[0] == ' ' )
400     table_name++; 
401   while ( table_name[strlen(table_name) - 1] == ' ' )
402     table_name[strlen(table_name) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
403
404 /* The following part searches a table matching with the layer type specified */
405   table_matching = NULL;
406
407 /* Look for the requested table */
408   if ( !(*(table_name)) ) { /* Is the table name empty, if so, don't even search for anything, display a message */
409     cmdarg_err("No layer type specified"); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
410   }
411   else {
412     table_matching = find_dissector_table(table_name);
413     if (!table_matching) {
414       cmdarg_err("Unknown layer type -- %s", table_name); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
415     }
416   }
417
418   if (!table_matching) {
419     /* Display a list of supported layer types to help the user, if the 
420        specified layer type was not found */
421     cmdarg_err("Valid layer types are:");
422     fprint_all_layer_types(stderr);
423   }
424   if (remaining_param == NULL || !table_matching) {
425     /* Exit if the layer type was not found, or if no '=' separator was found
426        (see above) */
427     g_free(decoded_param); 
428     return FALSE;
429   }
430   
431   if (*(remaining_param + 1) != '=') { /* Check for "==" and not only '=' */
432     cmdarg_err("WARNING: -d requires \"==\" instead of \"=\". Option will be treated as \"%s==%s\"", table_name, remaining_param + 1);
433   }
434   else {
435     remaining_param++; /* Move to the second '=' */
436     *remaining_param = '\0'; /* Remove the second '=' */
437   }
438   remaining_param++; /* Position after the layer type string */
439
440   /* This section extracts a selector value (selector_str) from decoded_param */
441
442   selector_str = remaining_param; /* Next part starts with the selector number */
443
444   remaining_param = strchr(selector_str, ',');
445   if (remaining_param == NULL) {
446     cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
447     /* If the argument does not follow the template, carry on anyway to check
448        if the selector value is at least correct.  If remaining_param is NULL,
449        we'll exit anyway further down */
450   }
451   else {
452     *remaining_param = '\0'; /* Terminate the selector number string (selector_str) where ',' was detected */
453   }
454
455   dissector_table_selector_type = get_dissector_table_selector_type(table_name);
456
457   switch (dissector_table_selector_type) {
458
459   case FT_UINT8:
460   case FT_UINT16:
461   case FT_UINT24:
462   case FT_UINT32:
463     /* The selector for this table is an unsigned number.  Parse it as such.
464        There's no need to remove leading and trailing spaces from the
465        selector number string, because sscanf will do that for us. */
466     if ( sscanf(selector_str, "%u", &selector) != 1 ) {
467       cmdarg_err("Invalid selector number \"%s\"", selector_str);
468       g_free(decoded_param);
469       return FALSE;
470     }
471     break;
472
473   case FT_STRING:
474   case FT_STRINGZ:
475     /* The selector for this table is a string. */
476     break;
477
478   default:
479     /* There are currently no dissector tables with any types other
480        than the ones listed above. */
481     g_assert_not_reached();
482   }
483
484   if (remaining_param == NULL) {
485     /* Exit if no ',' separator was found (see above) */
486     cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
487     fprint_all_protocols_for_layer_types(stderr, table_name);
488     g_free(decoded_param); 
489     return FALSE;
490   }
491
492   remaining_param++; /* Position after the selector number string */
493
494   /* This section extracts a protocol filter name (dissector_str) from decoded_param */
495
496   dissector_str = remaining_param; /* All the rest of the string is the dissector (decode as protocol) name */
497   
498   /* Remove leading and trailing spaces from the dissector name */
499   while ( dissector_str[0] == ' ' )
500     dissector_str++; 
501   while ( dissector_str[strlen(dissector_str) - 1] == ' ' )
502     dissector_str[strlen(dissector_str) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
503
504   dissector_matching = NULL;
505   
506   /* We now have a pointer to the handle for the requested table inside the variable table_matching */
507   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 */
508     cmdarg_err("No protocol name specified"); /* Note, we don't exit here, but dissector_matching will remain NULL, so we exit below */
509   }
510   else {
511     user_protocol_name.nb_match = 0;
512     user_protocol_name.searched_name = dissector_str;
513     user_protocol_name.matched_handle = NULL;
514     
515     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 */
516     
517     if (user_protocol_name.nb_match != 0) {
518       dissector_matching = user_protocol_name.matched_handle;
519       if (user_protocol_name.nb_match > 1) {
520         cmdarg_err("WARNING: Protocol \"%s\" matched %u dissectors, first one will be used", dissector_str, user_protocol_name.nb_match);
521       }
522     }
523     else {
524       /* OK, check whether the problem is that there isn't any such
525          protocol, or that there is but it's not specified as a protocol
526          that's valid for that dissector table.
527          Note, we don't exit here, but dissector_matching will remain NULL,
528          so we exit below */
529       if (proto_get_id_by_filter_name(dissector_str) == -1) {
530         /* No such protocol */
531         cmdarg_err("Unknown protocol -- \"%s\"", dissector_str);
532       } else {
533         cmdarg_err("Protocol \"%s\" isn't valid for layer type \"%s\"",
534                 dissector_str, table_name);
535       }
536     }
537   }
538
539   if (!dissector_matching) {
540     cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
541     fprint_all_protocols_for_layer_types(stderr, table_name);
542     g_free(decoded_param); 
543     return FALSE;
544   }
545
546 /* This is the end of the code that parses the command-line options.
547    All information is now stored in the variables:
548    table_name
549    selector
550    dissector_matching
551    The above variables that are strings are still pointing to areas within
552    decoded_parm.  decoded_parm thus still needs to be kept allocated in 
553    until we stop needing these variables
554    decoded_param will be deallocated at each exit point of this function */
555
556
557   /* We now have a pointer to the handle for the requested dissector
558      (requested protocol) inside the variable dissector_matching */
559   switch (dissector_table_selector_type) {
560
561   case FT_UINT8:
562   case FT_UINT16:
563   case FT_UINT24:
564   case FT_UINT32:
565     /* The selector for this table is an unsigned number. */
566     dissector_change(table_name, selector, dissector_matching);
567     break;
568
569   case FT_STRING:
570   case FT_STRINGZ:
571     /* The selector for this table is a string. */
572     dissector_change_string(table_name, selector_str, dissector_matching);
573     break;
574
575   default:
576     /* There are currently no dissector tables with any types other
577        than the ones listed above. */
578     g_assert_not_reached();
579   }
580   g_free(decoded_param); /* "Decode As" rule has been succesfully added */
581   return TRUE;
582 }
583
584 static void
585 log_func_ignore (const gchar *log_domain _U_, GLogLevelFlags log_level _U_,
586     const gchar *message _U_, gpointer user_data _U_)
587 {
588 }
589
590 int
591 main(int argc, char *argv[])
592 {
593   int                  opt, i;
594   extern char         *optarg;
595   gboolean             arg_error = FALSE;
596
597 #ifdef _WIN32
598   WSADATA               wsaData;
599 #endif  /* _WIN32 */
600
601   char                *gpf_path, *pf_path;
602   char                *gdp_path, *dp_path;
603   int                  gpf_open_errno, gpf_read_errno;
604   int                  pf_open_errno, pf_read_errno;
605   int                  gdp_open_errno, gdp_read_errno;
606   int                  dp_open_errno, dp_read_errno;
607   int                  err;
608 #ifdef HAVE_LIBPCAP
609   gboolean             capture_filter_specified = FALSE;
610   gboolean             list_link_layer_types = FALSE;
611   gboolean             start_capture = FALSE;
612 #else
613   gboolean             capture_option_specified = FALSE;
614 #endif
615   gboolean             quiet = FALSE;
616   gchar               *save_file = NULL;
617   int                  out_file_type = WTAP_FILE_PCAP;
618   gchar               *cf_name = NULL, *rfilter = NULL;
619 #ifdef HAVE_PCAP_OPEN_DEAD
620   struct bpf_program   fcode;
621 #endif
622   dfilter_t           *rfcode = NULL;
623   e_prefs             *prefs;
624   char                 badopt;
625   GLogLevelFlags       log_flags;
626
627 #define OPTSTRING_INIT "a:b:c:d:Df:F:hi:lLnN:o:pqr:R:s:St:T:vVw:xy:z:"
628 #ifdef HAVE_LIBPCAP
629 #ifdef _WIN32
630 #define OPTSTRING_WIN32 "B:"
631 #else
632 #define OPTSTRING_WIN32 ""
633 #endif  /* _WIN32 */
634 #else
635 #define OPTSTRING_WIN32 ""
636 #endif  /* HAVE_LIBPCAP */
637
638   static const char    optstring[] = OPTSTRING_INIT OPTSTRING_WIN32;
639
640   /* nothing more than the standard GLib handler, but without a warning */
641   log_flags = 
642                     G_LOG_LEVEL_ERROR|
643                     G_LOG_LEVEL_CRITICAL|
644                     G_LOG_LEVEL_WARNING|
645                     G_LOG_LEVEL_MESSAGE|
646                     G_LOG_LEVEL_INFO|
647                     G_LOG_LEVEL_DEBUG|
648                     G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
649
650   g_log_set_handler(NULL,
651                     log_flags,
652                     log_func_ignore, NULL /* user_data */);
653   g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
654                     log_flags,
655                     log_func_ignore, NULL /* user_data */);
656
657   /* initialize memory allocation subsystem */
658   ep_init_chunk();
659   se_init_chunk();
660   
661 #ifdef HAVE_LIBPCAP
662   capture_opts_init(&capture_opts, NULL /* cfile */);
663 #endif
664
665   timestamp_set_type(TS_RELATIVE);
666   timestamp_set_precision(TS_PREC_AUTO);
667
668   /* Register all dissectors; we must do this before checking for the
669      "-G" flag, as the "-G" flag dumps information registered by the
670      dissectors, and we must do it before we read the preferences, in
671      case any dissectors register preferences. */
672   epan_init(PLUGIN_DIR,register_all_protocols,register_all_protocol_handoffs,
673             failure_message,open_failure_message,read_failure_message);
674
675   /* Register all tap listeners; we do this before we parse the arguments,
676      as the "-z" argument can specify a registered tap. */
677   
678   /* we register the plugin taps before the other taps because
679           stats_tree taps plugins will be registered as tap listeners
680           by stats_tree_stat.c and need to registered before that */
681 #ifdef HAVE_PLUGINS
682   register_all_plugin_tap_listeners();
683 #endif
684   register_all_tap_listeners();
685
686   /* Now register the preferences for any non-dissector modules.
687      We must do that before we read the preferences as well. */
688   prefs_register_modules();
689
690   /* If invoked with the "-G" flag, we dump out information based on
691      the argument to the "-G" flag; if no argument is specified,
692      for backwards compatibility we dump out a glossary of display
693      filter symbols.
694
695      XXX - we do this here, for now, to support "-G" with no arguments.
696      If none of our build or other processes uses "-G" with no arguments,
697      we can just process it with the other arguments. */
698   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
699     if (argc == 2)
700       proto_registrar_dump_fields(1);
701     else {
702       if (strcmp(argv[2], "fields") == 0)
703         proto_registrar_dump_fields(1);
704       else if (strcmp(argv[2], "fields2") == 0)
705         proto_registrar_dump_fields(2);
706       else if (strcmp(argv[2], "fields3") == 0)
707         proto_registrar_dump_fields(3);
708       else if (strcmp(argv[2], "protocols") == 0)
709         proto_registrar_dump_protocols();
710       else if (strcmp(argv[2], "values") == 0)
711         proto_registrar_dump_values();
712       else if (strcmp(argv[2], "decodes") == 0)
713         dissector_dump_decodes();
714       else if (strcmp(argv[2], "defaultprefs") == 0)
715         write_prefs(NULL);
716       else if (strcmp(argv[2], "currentprefs") == 0) {
717         read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
718             &pf_open_errno, &pf_read_errno, &pf_path);
719         write_prefs(NULL);
720       } else {
721         cmdarg_err("Invalid \"%s\" option for -G flag", argv[2]);
722         exit(1);
723       }
724     }
725     exit(0);
726   }
727
728   /* Set the C-language locale to the native environment. */
729   setlocale(LC_ALL, "");
730
731   prefs = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
732                      &pf_open_errno, &pf_read_errno, &pf_path);
733   if (gpf_path != NULL) {
734     if (gpf_open_errno != 0) {
735       cmdarg_err("Can't open global preferences file \"%s\": %s.",
736               pf_path, strerror(gpf_open_errno));
737     }
738     if (gpf_read_errno != 0) {
739       cmdarg_err("I/O error reading global preferences file \"%s\": %s.",
740               pf_path, strerror(gpf_read_errno));
741     }
742   }
743   if (pf_path != NULL) {
744     if (pf_open_errno != 0) {
745       cmdarg_err("Can't open your preferences file \"%s\": %s.", pf_path,
746               strerror(pf_open_errno));
747     }
748     if (pf_read_errno != 0) {
749       cmdarg_err("I/O error reading your preferences file \"%s\": %s.",
750               pf_path, strerror(pf_read_errno));
751     }
752     g_free(pf_path);
753     pf_path = NULL;
754   }
755
756   /* Set the name resolution code's flags from the preferences. */
757   g_resolv_flags = prefs->name_resolve;
758
759   /* Read the disabled protocols file. */
760   read_disabled_protos_list(&gdp_path, &gdp_open_errno, &gdp_read_errno,
761                             &dp_path, &dp_open_errno, &dp_read_errno);
762   if (gdp_path != NULL) {
763     if (gdp_open_errno != 0) {
764       cmdarg_err(
765         "Could not open global disabled protocols file\n\"%s\": %s.",
766         gdp_path, strerror(gdp_open_errno));
767     }
768     if (gdp_read_errno != 0) {
769       cmdarg_err(
770         "I/O error reading global disabled protocols file\n\"%s\": %s.",
771         gdp_path, strerror(gdp_read_errno));
772     }
773     g_free(gdp_path);
774   }
775   if (dp_path != NULL) {
776     if (dp_open_errno != 0) {
777       cmdarg_err(
778         "Could not open your disabled protocols file\n\"%s\": %s.", dp_path,
779         strerror(dp_open_errno));
780     }
781     if (dp_read_errno != 0) {
782       cmdarg_err(
783         "I/O error reading your disabled protocols file\n\"%s\": %s.", dp_path,
784         strerror(dp_read_errno));
785     }
786     g_free(dp_path);
787   }
788
789 #ifdef _WIN32
790   /* Load Wpcap, if possible */
791   load_wpcap();
792 #endif
793
794   init_cap_file(&cfile);
795
796   /* Assemble the compile-time version information string */
797   comp_info_str = g_string_new("Compiled ");
798   get_compiled_version_info(comp_info_str);
799
800   /* Assemble the run-time version information string */
801   runtime_info_str = g_string_new("Running ");
802   get_runtime_version_info(runtime_info_str);
803
804   /* Print format defaults to this. */
805   print_format = PR_FMT_TEXT;
806
807   /* Now get our args */
808   while ((opt = getopt(argc, argv, optstring)) != -1) {
809     switch (opt) {
810       case 'a':        /* autostop criteria */
811       case 'b':        /* Ringbuffer option */
812       case 'c':        /* Capture xxx packets */
813       case 'f':        /* capture filter */
814       case 'i':        /* Use interface xxx */
815       case 'p':        /* Don't capture in promiscuous mode */
816       case 's':        /* Set the snapshot (capture) length */
817       case 'y':        /* Set the pcap data link type */
818 #ifdef _WIN32
819       case 'B':        /* Buffer size */
820 #endif /* _WIN32 */
821 #ifdef HAVE_LIBPCAP
822         capture_opts_add_opt(&capture_opts, opt, optarg, &start_capture);
823 #else
824         capture_option_specified = TRUE;
825         arg_error = TRUE;
826 #endif
827         break;
828       case 'd':        /* Decode as rule */
829         if (!add_decode_as(optarg))
830           exit(1);
831         break;
832       case 'D':        /* Print a list of capture devices and exit */
833 #ifdef HAVE_LIBPCAP
834         capture_opts_list_interfaces();
835         exit(0);
836 #else
837         capture_option_specified = TRUE;
838         arg_error = TRUE;
839 #endif
840         break;
841       case 'F':
842         out_file_type = wtap_short_string_to_file_type(optarg);
843         if (out_file_type < 0) {
844           cmdarg_err("\"%s\" isn't a valid capture file type",
845                         optarg);
846           exit(1);
847         }
848         break;
849       case 'h':        /* Print help and exit */
850         print_usage(TRUE);
851         exit(0);
852         break;
853       case 'l':        /* "Line-buffer" standard output */
854         /* This isn't line-buffering, strictly speaking, it's just
855            flushing the standard output after the information for
856            each packet is printed; however, that should be good
857            enough for all the purposes to which "-l" is put (and
858            is probably actually better for "-V", as it does fewer
859            writes).
860
861            See the comment in "process_packet()" for an explanation of
862            why we do that, and why we don't just use "setvbuf()" to
863            make the standard output line-buffered (short version: in
864            Windows, "line-buffered" is the same as "fully-buffered",
865            and the output buffer is only flushed when it fills up). */
866         line_buffered = TRUE;
867         break;
868       case 'L':        /* Print list of link-layer types and exit */
869 #ifdef HAVE_LIBPCAP
870         list_link_layer_types = TRUE;
871         break;
872 #else
873         capture_option_specified = TRUE;
874         arg_error = TRUE;
875 #endif
876         break;
877       case 'n':        /* No name resolution */
878         g_resolv_flags = RESOLV_NONE;
879         break;
880       case 'N':        /* Select what types of addresses/port #s to resolve */
881         if (g_resolv_flags == RESOLV_ALL)
882           g_resolv_flags = RESOLV_NONE;
883         badopt = string_to_name_resolve(optarg, &g_resolv_flags);
884         if (badopt != '\0') {
885           cmdarg_err("-N specifies unknown resolving option '%c'; valid options are 'm', 'n', and 't'",
886                         badopt);
887           exit(1);
888         }
889         break;
890       case 'o':        /* Override preference from command line */
891         switch (prefs_set_pref(optarg)) {
892
893         case PREFS_SET_SYNTAX_ERR:
894           cmdarg_err("Invalid -o flag \"%s\"", optarg);
895           exit(1);
896           break;
897
898         case PREFS_SET_NO_SUCH_PREF:
899         case PREFS_SET_OBSOLETE:
900           cmdarg_err("-o flag \"%s\" specifies unknown preference",
901                         optarg);
902           exit(1);
903           break;
904         }
905         break;
906       case 'q':        /* Quiet */
907         quiet = TRUE;
908         break;
909       case 'r':        /* Read capture file xxx */
910         cf_name = g_strdup(optarg);
911         break;
912       case 'R':        /* Read file filter */
913         rfilter = optarg;
914         break;
915       case 'S':        /* show packets in real time */
916         print_packet_info = TRUE;
917         break;
918       case 't':        /* Time stamp type */
919         if (strcmp(optarg, "r") == 0)
920           timestamp_set_type(TS_RELATIVE);
921         else if (strcmp(optarg, "a") == 0)
922           timestamp_set_type(TS_ABSOLUTE);
923         else if (strcmp(optarg, "ad") == 0)
924           timestamp_set_type(TS_ABSOLUTE_WITH_DATE);
925         else if (strcmp(optarg, "d") == 0)
926           timestamp_set_type(TS_DELTA);
927         else {
928           cmdarg_err("Invalid time stamp type \"%s\"",
929             optarg);
930           cmdarg_err_cont("It must be \"r\" for relative, \"a\" for absolute,");
931           cmdarg_err_cont("\"ad\" for absolute with date, or \"d\" for delta.");
932           exit(1);
933         }
934         break;
935       case 'T':        /* printing Type */
936         if (strcmp(optarg, "text") == 0) {
937           output_action = WRITE_TEXT;
938           print_format = PR_FMT_TEXT;
939         } else if (strcmp(optarg, "ps") == 0) {
940           output_action = WRITE_TEXT;
941           print_format = PR_FMT_PS;
942         } else if (strcmp(optarg, "pdml") == 0) {
943           output_action = WRITE_XML;
944           verbose = TRUE;
945         } else if (strcmp(optarg, "psml") == 0) {
946           output_action = WRITE_XML;
947           verbose = FALSE;
948         } else {
949           cmdarg_err("Invalid -T parameter.");
950           cmdarg_err_cont("It must be \"ps\", \"text\", \"pdml\", or \"psml\".");
951           exit(1);
952         }
953         break;
954       case 'v':        /* Show version and exit */
955         printf("t" PACKAGE " " VERSION "%s\n%s\n%s\n",
956             svnversion, comp_info_str->str, runtime_info_str->str);
957         exit(0);
958         break;
959       case 'w':        /* Write to capture file xxx */
960         save_file = g_strdup(optarg);
961         break;
962       case 'V':        /* Verbose */
963         verbose = TRUE;
964         break;
965       case 'x':        /* Print packet data in hex (and ASCII) */
966         print_hex = TRUE;
967         break;
968       case 'z':
969         /* We won't call the init function for the stat this soon
970            as it would disallow MATE's fields (which are registered
971            by the preferences set callback) from being used as
972            part of a tap filter.  Instead, we just add the argument
973            to a list of stat arguments. */
974         if (!process_stat_cmd_arg(optarg)) {
975           cmdarg_err("invalid -z argument.");
976           cmdarg_err_cont("  -z argument must be one of :");
977           list_stat_cmd_args();
978           exit(1);
979         }
980         break;
981       default:
982       case '?':        /* Bad flag - print usage message */
983         arg_error = TRUE;
984         break;
985     }
986   }
987
988   /* If no capture filter or read filter has been specified, and there are
989      still command-line arguments, treat them as the tokens of a capture
990      filter (if no "-r" flag was specified) or a read filter (if a "-r"
991      flag was specified. */
992   if (optind < argc) {
993     if (cf_name != NULL) {
994       if (rfilter != NULL) {
995         cmdarg_err("Read filters were specified both with \"-R\" "
996             "and with additional command-line arguments");
997         exit(2);
998       }
999       rfilter = get_args_as_string(argc, argv, optind);
1000     } else {
1001 #ifdef HAVE_LIBPCAP
1002       if (capture_filter_specified) {
1003         cmdarg_err("Capture filters were specified both with \"-f\""
1004             " and with additional command-line arguments");
1005         exit(2);
1006       }
1007       capture_opts.cfilter = get_args_as_string(argc, argv, optind);
1008 #else
1009       capture_option_specified = TRUE;
1010 #endif
1011     }
1012   }
1013
1014   /* See if we're writing a capture file and the file is a pipe */
1015 #ifdef HAVE_LIBPCAP
1016   ld.output_to_pipe = FALSE;
1017 #endif
1018   if (save_file != NULL) {
1019     /* We're writing to a capture file. */
1020     if (strcmp(save_file, "-") == 0) {
1021       /* Write to the standard output. */
1022       g_free(save_file);
1023       save_file = g_strdup("");
1024 #ifdef HAVE_LIBPCAP
1025       /* XXX - should we check whether it's a pipe?  It's arguably
1026          silly to do "-w - >output_file" rather than "-w output_file",
1027          but by not checking we might be violating the Principle Of
1028          Least Astonishment. */
1029       ld.output_to_pipe = TRUE;
1030 #endif
1031     }
1032 #ifdef HAVE_LIBPCAP
1033     else {
1034       err = test_for_fifo(save_file);
1035       switch (err) {
1036
1037       case ENOENT:      /* it doesn't exist, so we'll be creating it,
1038                            and it won't be a FIFO */
1039       case 0:           /* found it, but it's not a FIFO */
1040         break;
1041
1042       case ESPIPE:      /* it is a FIFO */
1043         ld.output_to_pipe = TRUE;
1044         break;
1045
1046       default:          /* couldn't stat it */
1047         cmdarg_err("Error testing whether capture file is a pipe: %s",
1048                 strerror(errno));
1049         exit(2);
1050       }
1051     }
1052 #endif
1053   } else {
1054     /* We're not writing to a file, so we should print packet information
1055        unless "-q" was specified. */
1056     if (!quiet)
1057       print_packet_info = TRUE;
1058   }
1059
1060 #ifndef HAVE_LIBPCAP
1061   if (capture_option_specified)
1062     cmdarg_err("This version of Tethereal was not built with support for capturing packets.");
1063 #endif
1064   if (arg_error) {
1065     print_usage(FALSE);
1066     exit(1);
1067   }
1068
1069   /* We don't support capture filters when reading from a capture file
1070      (the BPF compiler doesn't support all link-layer types that we
1071      support in capture files we read). */
1072 #ifdef HAVE_LIBPCAP
1073   if (cf_name != NULL) {
1074     if (capture_filter_specified) {
1075       cmdarg_err("Only read filters, not capture filters, "
1076           "can be specified when reading a capture file.");
1077       exit(2);
1078     }
1079   }
1080 #endif
1081
1082   if (print_hex) {
1083     if (output_action != WRITE_TEXT) {
1084       cmdarg_err("Raw packet hex data can only be printed as text or PostScript");
1085       exit(1);
1086     }
1087   }
1088
1089 #ifdef HAVE_LIBPCAP
1090   if (list_link_layer_types) {
1091     /* We're supposed to list the link-layer types for an interface;
1092        did the user also specify a capture file to be read? */
1093     if (cf_name) {
1094       /* Yes - that's bogus. */
1095       cmdarg_err("You can't specify -L and a capture file to be read.");
1096       exit(1);
1097     }
1098     /* No - did they specify a ring buffer option? */
1099     if (capture_opts.multi_files_on) {
1100       cmdarg_err("Ring buffer requested, but a capture isn't being done.");
1101       exit(1);
1102     }
1103   } else {
1104     /* If they didn't specify a "-w" flag, but specified a maximum capture
1105        file size, tell them that this doesn't work, and exit. */
1106     if (capture_opts.has_autostop_filesize && save_file == NULL) {
1107       cmdarg_err("Maximum capture file size specified, but "
1108         "capture isn't being saved to a file.");
1109       exit(1);
1110     }
1111
1112     if (capture_opts.multi_files_on) {
1113       /* Ring buffer works only under certain conditions:
1114          a) ring buffer does not work if you're not saving the capture to
1115             a file;
1116          b) ring buffer only works if you're saving in libpcap format;
1117          c) it makes no sense to enable the ring buffer if the maximum
1118             file size is set to "infinite";
1119          d) file must not be a pipe. */
1120       if (save_file == NULL) {
1121         cmdarg_err("Ring buffer requested, but capture isn't being saved to a file.");
1122         exit(1);
1123       }
1124       if (out_file_type != WTAP_FILE_PCAP) {
1125         cmdarg_err("Ring buffer requested, but "
1126           "capture isn't being saved in libpcap format.");
1127         exit(2);
1128       }
1129       if (!capture_opts.has_autostop_filesize) {
1130         cmdarg_err("Ring buffer requested, but "
1131           "no maximum capture file size was specified.");
1132         exit(2);
1133       }
1134       if (ld.output_to_pipe) {
1135         cmdarg_err("Ring buffer requested, but capture file is a pipe.");
1136         exit(2);
1137       }
1138     }
1139   }
1140 #endif
1141
1142 #ifdef _WIN32
1143   /* Start windows sockets */
1144   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
1145 #endif  /* _WIN32 */
1146
1147   /* Notify all registered modules that have had any of their preferences
1148      changed either from one of the preferences file or from the command
1149      line that their preferences have changed. */
1150   prefs_apply_all();
1151
1152   /* At this point MATE will have registered its field array so we can
1153      have a tap filter with one of MATE's late-registered fields as part
1154      of the filter.  We can now process all the "-z" arguments. */
1155   start_requested_stats();
1156   
1157   /* disabled protocols as per configuration file */
1158   if (gdp_path == NULL && dp_path == NULL) {
1159     set_disabled_protos_list();
1160   }
1161
1162   /* Build the column format array */
1163   col_setup(&cfile.cinfo, prefs->num_cols);
1164   for (i = 0; i < cfile.cinfo.num_cols; i++) {
1165     cfile.cinfo.col_fmt[i] = get_column_format(i);
1166     cfile.cinfo.col_title[i] = g_strdup(get_column_title(i));
1167     cfile.cinfo.fmt_matx[i] = (gboolean *) g_malloc0(sizeof(gboolean) *
1168       NUM_COL_FMTS);
1169     get_column_format_matches(cfile.cinfo.fmt_matx[i], cfile.cinfo.col_fmt[i]);
1170     cfile.cinfo.col_data[i] = NULL;
1171     if (cfile.cinfo.col_fmt[i] == COL_INFO)
1172       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_INFO_LEN);
1173     else
1174       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
1175     cfile.cinfo.col_fence[i] = 0;
1176     cfile.cinfo.col_expr[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
1177     cfile.cinfo.col_expr_val[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
1178   }
1179
1180   for (i = 0; i < cfile.cinfo.num_cols; i++) {
1181       int j;
1182
1183       for (j = 0; j < NUM_COL_FMTS; j++) {
1184          if (!cfile.cinfo.fmt_matx[i][j])
1185              continue;
1186          
1187          if (cfile.cinfo.col_first[j] == -1)
1188              cfile.cinfo.col_first[j] = i;
1189          cfile.cinfo.col_last[j] = i;
1190       }
1191   }
1192
1193 #ifdef HAVE_LIBPCAP
1194   capture_opts_trim_snaplen(&capture_opts, MIN_PACKET_SIZE);
1195   capture_opts_trim_ring_num_files(&capture_opts);
1196 #endif
1197
1198   if (rfilter != NULL) {
1199     if (!dfilter_compile(rfilter, &rfcode)) {
1200       cmdarg_err("%s", dfilter_error_msg);
1201       epan_cleanup();
1202 #ifdef HAVE_PCAP_OPEN_DEAD
1203       {
1204         pcap_t *pc;
1205
1206         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1207         if (pc != NULL) {
1208           if (pcap_compile(pc, &fcode, rfilter, 0, 0) != -1) {
1209             cmdarg_err_cont(
1210               "  Note: That display filter code looks like a valid capture filter;");
1211             cmdarg_err_cont(
1212               "        maybe you mixed them up?");
1213           }
1214           pcap_close(pc);
1215         }
1216       }
1217 #endif
1218       exit(2);
1219     }
1220   }
1221   cfile.rfcode = rfcode;
1222
1223   if (print_packet_info) {
1224     /* If we're printing as text or PostScript, we have
1225        to create a print stream. */
1226     if (output_action == WRITE_TEXT) {
1227       switch (print_format) {
1228
1229       case PR_FMT_TEXT:
1230         print_stream = print_stream_text_stdio_new(stdout);
1231         break;
1232
1233       case PR_FMT_PS:
1234         print_stream = print_stream_ps_stdio_new(stdout);
1235         break;
1236
1237       default:
1238         g_assert_not_reached();
1239       }
1240     }
1241   }
1242
1243   /* We have to dissect each packet if:
1244
1245         we're printing information about each packet;
1246
1247         we're using a read filter on the packets;
1248
1249         we're using any taps. */
1250   do_dissection = print_packet_info || rfcode || have_tap_listeners();
1251
1252   if (cf_name) {
1253     /*
1254      * We're reading a capture file.
1255      */
1256
1257 #ifndef _WIN32
1258     /*
1259      * Immediately relinquish any set-UID or set-GID privileges we have;
1260      * we must not be allowed to read any capture files the user running
1261      * Tethereal can't open.
1262      */
1263     setuid(getuid());
1264     setgid(getgid());
1265 #endif
1266
1267     if (cf_open(&cfile, cf_name, FALSE, &err) != CF_OK) {
1268       epan_cleanup();
1269       exit(2);
1270     }
1271
1272     /* Set timestamp precision; there should arguably be a command-line
1273        option to let the user set this. */
1274     switch(wtap_file_tsprecision(cfile.wth)) {
1275     case(WTAP_FILE_TSPREC_SEC):
1276       timestamp_set_precision(TS_PREC_AUTO_SEC);
1277       break;
1278     case(WTAP_FILE_TSPREC_DSEC):
1279       timestamp_set_precision(TS_PREC_AUTO_DSEC);
1280       break;
1281     case(WTAP_FILE_TSPREC_CSEC):
1282       timestamp_set_precision(TS_PREC_AUTO_CSEC);
1283       break;
1284     case(WTAP_FILE_TSPREC_MSEC):
1285       timestamp_set_precision(TS_PREC_AUTO_MSEC);
1286       break;
1287     case(WTAP_FILE_TSPREC_USEC):
1288       timestamp_set_precision(TS_PREC_AUTO_USEC);
1289       break;
1290     case(WTAP_FILE_TSPREC_NSEC):
1291       timestamp_set_precision(TS_PREC_AUTO_NSEC);
1292       break;
1293     default:
1294       g_assert_not_reached();
1295     }
1296
1297     /* Process the packets in the file */
1298     err = load_cap_file(&cfile, save_file, out_file_type);
1299     if (err != 0) {
1300       epan_cleanup();
1301       exit(2);
1302     }
1303     cf_name[0] = '\0';
1304   } else {
1305     /* No capture file specified, so we're supposed to do a live capture
1306        (or get a list of link-layer types for a live capture device);
1307        do we have support for live captures? */
1308 #ifdef HAVE_LIBPCAP
1309
1310 #ifdef _WIN32
1311     if (!has_wpcap) {
1312       char *detailed_err;
1313
1314       cmdarg_err("WinPcap couldn't be found.");
1315       detailed_err = cant_load_winpcap_err("Tethereal");
1316       cmdarg_err_cont("%s", detailed_err);
1317       g_free(detailed_err);
1318       exit(2);
1319     }
1320 #endif
1321
1322     /* trim the interface name and exit if that failed */
1323     if (!capture_opts_trim_iface(&capture_opts, 
1324         (prefs->capture_device) ? get_if_name(prefs->capture_device) : NULL)) {
1325         exit(2);
1326     }
1327
1328     /* if requested, list the link layer types and exit */
1329     if (list_link_layer_types) {
1330         capture_opts_list_link_layer_types(&capture_opts);
1331         exit(0);
1332     }
1333
1334     if (!quiet) {
1335       /*
1336        * The user didn't ask us not to print a count of packets as
1337        * they arrive, so do so.
1338        */
1339       print_packet_counts = TRUE;
1340     }
1341
1342     /* For now, assume libpcap gives microsecond precision. */
1343     timestamp_set_precision(TS_PREC_AUTO_USEC);
1344
1345     capture(save_file, out_file_type);
1346
1347     if (capture_opts.multi_files_on) {
1348       ringbuf_free();
1349     }
1350 #else
1351     /* No - complain. */
1352     cmdarg_err("This version of Tethereal was not built with support for capturing packets.");
1353     exit(2);
1354 #endif
1355   }
1356
1357   draw_tap_listeners(TRUE);
1358   epan_cleanup();
1359
1360   return 0;
1361 }
1362
1363 #ifdef HAVE_LIBPCAP
1364 /* Do the low-level work of a capture.
1365    Returns TRUE if it succeeds, FALSE otherwise. */
1366
1367 static condition  *volatile cnd_file_duration = NULL; /* this must be visible in process_packet */
1368
1369 static int
1370 capture(char *save_file, int out_file_type)
1371 {
1372   int         err = 0;
1373   int         volatile volatile_err = 0;
1374   int         volatile inpkts = 0;
1375   int         pcap_cnt;
1376   char        errmsg[1024+1];
1377   condition  *volatile cnd_autostop_size = NULL;
1378   condition  *volatile cnd_autostop_duration = NULL;
1379   char       *descr;
1380 #ifndef _WIN32
1381   void        (*oldhandler)(int);
1382   guchar pcap_data[WTAP_MAX_PACKET_SIZE];
1383 #endif
1384   struct pcap_stat stats;
1385   gboolean    write_ok;
1386   gboolean    close_ok;
1387   int         save_file_fd;
1388
1389   /* Initialize all data structures used for dissection. */
1390   init_dissection();
1391
1392   ld.wtap_linktype  = WTAP_ENCAP_UNKNOWN;
1393   ld.wtap_pdh       = NULL;
1394   ld.packet_cb      = capture_pcap_cb;
1395
1396
1397   /* open the "input file" from network interface or capture pipe */
1398   if (!capture_loop_open_input(&capture_opts, &ld, errmsg, sizeof(errmsg)))
1399   {
1400     goto error;
1401   }
1402
1403 #ifndef _WIN32
1404   /*
1405    * We've opened the capture device, so, if we're set-UID or set-GID,
1406    * relinquish those privileges.
1407    *
1408    * XXX - if we have saved set-user-ID support, we should give up those
1409    * privileges immediately, and then reclaim them long enough to get
1410    * a list of network interfaces and to open one, and then give them
1411    * up again, so that stuff we do while processing the argument list,
1412    * reading the user's preferences, etc. is done as the real user and
1413    * group, not the effective user and group.
1414    */
1415   setuid(getuid());
1416   setgid(getgid());
1417 #endif
1418
1419   capture_opts.save_file = save_file;
1420
1421   /* open the output file (temporary/specified name/ringbuffer) */
1422   if (!capture_loop_open_output(&capture_opts, &save_file_fd, errmsg, sizeof(errmsg))) {
1423     goto error;    
1424   }
1425
1426   /* init the input filter from the network interface (capture pipe will do nothing) */
1427   if(!capture_loop_init_filter(ld.pcap_h, ld.from_cap_pipe, 
1428       capture_opts.iface, capture_opts.cfilter, errmsg, sizeof errmsg)) 
1429   {
1430       goto error;
1431   }
1432
1433   /* open the wiretap part of the output file (the output file is already open) */
1434   if(!capture_loop_init_wiretap_output(&capture_opts, save_file_fd, &ld, errmsg, sizeof errmsg))
1435   {
1436       goto error;
1437   }
1438
1439
1440 #ifdef _WIN32
1441   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
1442   SetConsoleCtrlHandler(capture_cleanup, TRUE);
1443 #else /* _WIN32 */
1444   /* Catch SIGINT and SIGTERM and, if we get either of them, clean up
1445      and exit.
1446      XXX - deal with signal semantics on various UNIX platforms.  Or just
1447      use "sigaction()" and be done with it? */
1448   signal(SIGTERM, capture_cleanup);
1449   signal(SIGINT, capture_cleanup);
1450   if ((oldhandler = signal(SIGHUP, capture_cleanup)) != SIG_DFL)
1451     signal(SIGHUP, oldhandler);
1452
1453 #ifdef SIGINFO
1454   /* Catch SIGINFO and, if we get it and we're capturing to a file in
1455      quiet mode, report the number of packets we've captured. */
1456   signal(SIGINFO, report_counts_siginfo);
1457 #endif /* SIGINFO */
1458 #endif /* _WIN32 */
1459
1460   /* Let the user know what interface was chosen. */
1461   descr = get_interface_descriptive_name(capture_opts.iface);
1462   fprintf(stderr, "Capturing on %s\n", descr);
1463   g_free(descr);
1464
1465   /* initialize capture stop conditions */
1466   init_capture_stop_conditions();
1467   /* create stop conditions */
1468   if (capture_opts.has_autostop_filesize)
1469     cnd_autostop_size = cnd_new((const char*)CND_CLASS_CAPTURESIZE,
1470                                    (long)capture_opts.autostop_filesize * 1024);
1471   if (capture_opts.has_autostop_duration)
1472     cnd_autostop_duration = cnd_new((const char*)CND_CLASS_TIMEOUT,
1473                                (gint32)capture_opts.autostop_duration);
1474
1475   if (capture_opts.multi_files_on && capture_opts.has_file_duration)
1476     cnd_file_duration = cnd_new(CND_CLASS_TIMEOUT, 
1477                                capture_opts.file_duration);
1478
1479   if (!setjmp(ld.stopenv)) {
1480     ld.go = TRUE;
1481     ld.packet_count = 0;
1482   } else
1483     ld.go = FALSE;
1484
1485   while (ld.go) {
1486     /* We need to be careful with automatic variables defined in the
1487        outer scope which are changed inside the loop.  Most compilers
1488        don't try to roll them back to their original values after the
1489        longjmp which causes the loop to finish, but all that the
1490        standards say is that their values are indeterminate.  If we
1491        don't want them to be rolled back, we should define them with the
1492        volatile attribute (paraphrasing W. Richard Stevens, Advanced
1493        Programming in the UNIX Environment, p. 178).
1494
1495        The "err" variable causes a particular problem.  If we give it
1496        the volatile attribute, then when we pass a reference to it (as
1497        in "&err") to a function, GCC warns: "passing arg <n> of
1498        <function> discards qualifiers from pointer target type".
1499        Therefore within the loop and just beyond we don't use "err".
1500        Within the loop we define "loop_err", and assign its value to
1501        "volatile_err", which is in the outer scope and is checked when
1502        the loop finishes.
1503
1504        We also define "packet_count_prev" here to keep things tidy,
1505        since it's used only inside the loop.  If it were defined in the
1506        outer scope, GCC would give a warning (unnecessary in this case)
1507        that it might be clobbered, and we'd need to give it the volatile
1508        attribute to suppress the warning. */
1509
1510     int loop_err = 0;
1511     int packet_count_prev = 0;
1512
1513     if (cnd_autostop_size == NULL && cnd_autostop_duration == NULL) {
1514       /* We're not stopping at a particular capture file size, and we're
1515          not stopping after some particular amount of time has expired,
1516          so either we have no stop condition or the only stop condition
1517          is a maximum packet count.
1518
1519          If there's no maximum packet count, pass it -1, meaning "until
1520          you run out of packets in the bufferful you read".  Otherwise,
1521          pass it the number of packets we have left to capture.
1522
1523          We don't call "pcap_loop()" as, if we're saving to a file that's
1524          a FIFO, we want to flush the FIFO after we're done processing
1525          this libpcap bufferful of packets, so that the program
1526          reading the FIFO sees the packets immediately and doesn't get
1527          any partial packet, forcing it to block in the middle of reading
1528          that packet. */
1529       if (capture_opts.autostop_packets == 0)
1530         pcap_cnt = -1;
1531       else {
1532         if (ld.packet_count >= capture_opts.autostop_packets) {
1533           /* XXX do we need this test here? */
1534           /* It appears there's nothing more to capture. */
1535           break;
1536         }
1537         pcap_cnt = capture_opts.autostop_packets - ld.packet_count;
1538       }
1539     } else {
1540       /* We need to check the capture file size or the timeout after
1541          each packet. */
1542       pcap_cnt = 1;
1543     }
1544 #ifndef _WIN32
1545     if (ld.from_cap_pipe) {
1546       inpkts = cap_pipe_dispatch(ld.cap_pipe_fd, &ld, &ld.cap_pipe_hdr, &ld.cap_pipe_rechdr, pcap_data,
1547         errmsg, sizeof errmsg);
1548     } else
1549 #endif
1550       inpkts = pcap_dispatch(ld.pcap_h, pcap_cnt, capture_pcap_cb, (u_char *) &ld);
1551     if (inpkts < 0) {
1552       /* Error from "pcap_dispatch()", or error or "no more packets" from
1553          "cap_pipe_dispatch(). */
1554       ld.go = FALSE;
1555     } else if (cnd_autostop_duration != NULL && cnd_eval(cnd_autostop_duration)) {
1556       /* The specified capture time has elapsed; stop the capture. */
1557       ld.go = FALSE;
1558     } else if (inpkts > 0) {
1559       if (capture_opts.autostop_packets != 0 &&
1560                  ld.packet_count >= capture_opts.autostop_packets) {
1561         /* The specified number of packets have been captured and have
1562            passed both any capture filter in effect and any read filter
1563            in effect. */
1564         ld.go = FALSE;
1565       } else if (cnd_autostop_size != NULL &&
1566                     cnd_eval(cnd_autostop_size,
1567                               (guint32)wtap_get_bytes_dumped(ld.wtap_pdh))) {
1568         /* We're saving the capture to a file, and the capture file reached
1569            its maximum size. */
1570         if (capture_opts.multi_files_on) {
1571           /* Switch to the next ringbuffer file */
1572           if (ringbuf_switch_file(&ld.wtap_pdh, &save_file, &save_file_fd, &loop_err)) {
1573             /* File switch succeeded: reset the condition */
1574             cnd_reset(cnd_autostop_size);
1575             if (cnd_file_duration) {
1576               cnd_reset(cnd_file_duration);
1577             }
1578           } else {
1579             /* File switch failed: stop here */
1580             volatile_err = loop_err;
1581             ld.go = FALSE;
1582           }
1583         } else {
1584           /* No ringbuffer - just stop. */
1585           ld.go = FALSE;
1586         }
1587       }
1588       if (ld.output_to_pipe) {
1589         if (ld.packet_count > packet_count_prev) {
1590           wtap_dump_flush(ld.wtap_pdh);
1591           packet_count_prev = ld.packet_count;
1592         }
1593       }
1594     } /* inpkts > 0 */
1595   } /* while (ld.go) */
1596
1597   /* delete stop conditions */
1598   if (cnd_autostop_size != NULL)
1599     cnd_delete(cnd_autostop_size);
1600   if (cnd_autostop_duration != NULL)
1601     cnd_delete(cnd_autostop_duration);
1602   if (cnd_file_duration != NULL)
1603     cnd_delete(cnd_file_duration);
1604
1605   if (print_packet_counts) {
1606     /* We're printing packet counts to stderr.
1607        Send a newline so that we move to the line after the packet count. */
1608     fprintf(stderr, "\n");
1609   }
1610
1611   /* If we got an error while capturing, report it. */
1612   if (inpkts < 0) {
1613 #ifndef _WIN32
1614     if (ld.from_cap_pipe) {
1615       if (ld.cap_pipe_err == PIPERR) {
1616         cmdarg_err("Error while capturing packets: %s",
1617           errmsg);
1618       }
1619     } else
1620 #endif
1621     {
1622       cmdarg_err("Error while capturing packets: %s",
1623           pcap_geterr(ld.pcap_h));
1624     }
1625   }
1626
1627   if (volatile_err == 0)
1628     write_ok = TRUE;
1629   else {
1630     show_capture_file_io_error(save_file, volatile_err, FALSE);
1631     write_ok = FALSE;
1632   }
1633
1634   if (save_file != NULL) {
1635     /* We're saving to a file or files; close all files. */
1636     close_ok = capture_loop_close_output(&capture_opts, &ld, &err);
1637
1638     /* If we've displayed a message about a write error, there's no point
1639        in displaying another message about an error on close. */
1640     if (!close_ok && write_ok)
1641       show_capture_file_io_error(save_file, err, TRUE);
1642   }
1643
1644 #ifndef _WIN32
1645   if (ld.from_cap_pipe && ld.cap_pipe_fd >= 0)
1646     eth_close(ld.cap_pipe_fd);
1647   else
1648 #endif
1649   {
1650     /* Get the capture statistics, and, if any packets were dropped, report
1651        that. */
1652     if (pcap_stats(ld.pcap_h, &stats) >= 0) {
1653       if (stats.ps_drop != 0) {
1654         fprintf(stderr, "%u packets dropped\n", stats.ps_drop);
1655       }
1656     } else {
1657       cmdarg_err("Can't get packet-drop statistics: %s",
1658           pcap_geterr(ld.pcap_h));
1659     }
1660     pcap_close(ld.pcap_h);
1661   }
1662
1663   /* Report the number of captured packets if not reported during capture
1664      and we are saving to a file. */
1665   report_counts();
1666
1667   return TRUE;
1668
1669 error:
1670   if (capture_opts.multi_files_on) {
1671     ringbuf_error_cleanup();
1672   }
1673   g_free(save_file);
1674   save_file = NULL;
1675   cmdarg_err("%s", errmsg);
1676 #ifndef _WIN32
1677   if (ld.from_cap_pipe) {
1678     if (ld.cap_pipe_fd >= 0)
1679       eth_close(ld.cap_pipe_fd);
1680   } else
1681 #endif
1682   {
1683   if (ld.pcap_h != NULL)
1684     pcap_close(ld.pcap_h);
1685   }
1686
1687   return FALSE;
1688 }
1689
1690 static void
1691 capture_pcap_cb(u_char *user, const struct pcap_pkthdr *phdr,
1692   const u_char *pd)
1693 {
1694   struct wtap_pkthdr whdr;
1695   union wtap_pseudo_header pseudo_header;
1696   loop_data *ld = (loop_data *) user;
1697   int loop_err;
1698   int err;
1699   int save_file_fd;
1700
1701   /* Convert from libpcap to Wiretap format.
1702      If that fails, ignore the packet (wtap_process_pcap_packet has
1703      written an error message). */
1704   pd = wtap_process_pcap_packet(ld->wtap_linktype, phdr, pd, &pseudo_header,
1705                                 &whdr, &err);
1706   if (pd == NULL)
1707     return;
1708
1709 #ifdef SIGINFO
1710   /*
1711    * Prevent a SIGINFO handler from writing to stdout while we're
1712    * doing so; instead, have it just set a flag telling us to print
1713    * that information when we're done.
1714    */
1715   infodelay = TRUE;
1716 #endif /* SIGINFO */
1717
1718   /* The current packet may have arrived after a very long silence,
1719    * way past the time to switch files.  In order not to have
1720    * the first packet of a new series of events as the last
1721    * [or only] packet in the file, switch before writing!
1722    */
1723   if (cnd_file_duration != NULL && cnd_eval(cnd_file_duration)) {
1724     /* time elapsed for this ring file, switch to the next */
1725     if (ringbuf_switch_file(&ld->wtap_pdh, &ld->save_file, &save_file_fd, &loop_err)) {
1726       /* File switch succeeded: reset the condition */
1727       cnd_reset(cnd_file_duration);
1728     } else {
1729       /* File switch failed: stop here */
1730       /* XXX - we should do something with "loop_err" */
1731       ld->go = FALSE;
1732     }
1733   }
1734
1735   if (!process_packet(&cfile, ld->wtap_pdh, 0, &whdr, &pseudo_header, pd, &err)) {
1736     /* Error writing to a capture file */
1737     if (print_packet_counts) {
1738       /* We're printing counts of packets captured; move to the line after
1739          the count. */
1740       fprintf(stderr, "\n");
1741     }
1742     show_capture_file_io_error(ld->save_file, err, FALSE);
1743     pcap_close(ld->pcap_h);
1744     wtap_dump_close(ld->wtap_pdh, &err);
1745     exit(2);
1746   }
1747
1748 #ifdef SIGINFO
1749   /*
1750    * Allow SIGINFO handlers to write.
1751    */
1752   infodelay = FALSE;
1753
1754   /*
1755    * If a SIGINFO handler asked us to write out capture counts, do so.
1756    */
1757   if (infoprint)
1758     report_counts();
1759 #endif /* SIGINFO */
1760 }
1761
1762 #ifdef _WIN32
1763 static BOOL WINAPI
1764 capture_cleanup(DWORD ctrltype _U_)
1765 {
1766   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
1767      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
1768      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
1769      like SIGTERM at least when the machine's shutting down.
1770
1771      For now, we handle them all as indications that we should clean up
1772      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
1773      way on UNIX.
1774
1775      However, as handlers run in a new thread, we can't just longjmp
1776      out; we have to set "ld.go" to FALSE, and must return TRUE so that
1777      no other handler - such as one that would terminate the process -
1778      gets called.
1779
1780      XXX - for some reason, typing ^C to Tethereal, if you run this in
1781      a Cygwin console window in at least some versions of Cygwin,
1782      causes Tethereal to terminate immediately; this routine gets
1783      called, but the main loop doesn't get a chance to run and
1784      exit cleanly, at least if this is compiled with Microsoft Visual
1785      C++ (i.e., it's a property of the Cygwin console window or Bash;
1786      it happens if Tethereal is not built with Cygwin - for all I know,
1787      building it with Cygwin may make the problem go away). */
1788   ld.go = FALSE;
1789   return TRUE;
1790 }
1791 #else
1792 static void
1793 capture_cleanup(int signum _U_)
1794 {
1795   /* Longjmp back to the starting point; "pcap_dispatch()", on many
1796      UNIX platforms, just keeps looping if it gets EINTR, so if we set
1797      "ld.go" to FALSE and return, we won't break out of it and quit
1798      capturing. */
1799   longjmp(ld.stopenv, 1);
1800 }
1801 #endif /* _WIN32 */
1802
1803 static void
1804 report_counts(void)
1805 {
1806 #ifdef SIGINFO
1807   /* XXX - if we use sigaction, this doesn't have to be done.
1808      (Yes, this isn't necessary on BSD, but just in case a system
1809      where "signal()" has AT&T semantics adopts SIGINFO....) */
1810   signal(SIGINFO, report_counts_siginfo);
1811 #endif /* SIGINFO */
1812
1813   if (!print_packet_counts) {
1814     /* Report the count only if we aren't printing a packet count
1815        as packets arrive. */
1816     fprintf(stderr, "%u packets captured\n", ld.packet_count);
1817   }
1818 #ifdef SIGINFO
1819   infoprint = FALSE;    /* we just reported it */
1820 #endif /* SIGINFO */
1821 }
1822
1823 #ifdef SIGINFO
1824 static void
1825 report_counts_siginfo(int signum _U_)
1826 {
1827   int sav_errno = errno;
1828   /* If we've been told to delay printing, just set a flag asking
1829      that we print counts (if we're supposed to), otherwise print
1830      the count of packets captured (if we're supposed to). */
1831   if (infodelay)
1832     infoprint = TRUE;
1833   else
1834     report_counts();
1835   errno = sav_errno;
1836 }
1837 #endif /* SIGINFO */
1838 #endif /* HAVE_LIBPCAP */
1839
1840 static int
1841 load_cap_file(capture_file *cf, char *save_file, int out_file_type)
1842 {
1843   gint         linktype;
1844   int          snapshot_length;
1845   wtap_dumper *pdh;
1846   int          err;
1847   gchar        *err_info;
1848   long         data_offset;
1849
1850   linktype = wtap_file_encap(cf->wth);
1851   if (save_file != NULL) {
1852     /* Set up to write to the capture file. */
1853     snapshot_length = wtap_snapshot_length(cf->wth);
1854     if (snapshot_length == 0) {
1855       /* Snapshot length of input file not known. */
1856       snapshot_length = WTAP_MAX_PACKET_SIZE;
1857     }
1858     pdh = wtap_dump_open(save_file, out_file_type,
1859                 linktype, snapshot_length, FALSE /* compressed */, &err);
1860
1861     if (pdh == NULL) {
1862       /* We couldn't set up to write to the capture file. */
1863       switch (err) {
1864
1865       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
1866         cmdarg_err("Capture files can't be written in that format.");
1867         break;
1868
1869       case WTAP_ERR_UNSUPPORTED_ENCAP:
1870       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
1871         cmdarg_err("The capture file being read can't be written in "
1872           "that format.");
1873         break;
1874
1875       case WTAP_ERR_CANT_OPEN:
1876         cmdarg_err("The file \"%s\" couldn't be created for some "
1877           "unknown reason.",
1878             *save_file == '\0' ? "stdout" : save_file);
1879         break;
1880
1881       case WTAP_ERR_SHORT_WRITE:
1882         cmdarg_err("A full header couldn't be written to the file \"%s\".",
1883                 *save_file == '\0' ? "stdout" : save_file);
1884         break;
1885
1886       default:
1887         cmdarg_err("The file \"%s\" could not be created: %s.",
1888                 *save_file == '\0' ? "stdout" : save_file,
1889                 wtap_strerror(err));
1890         break;
1891       }
1892       goto out;
1893     }
1894   } else {
1895     if (print_packet_info) {
1896       if (!write_preamble(cf)) {
1897         err = errno;
1898         show_print_file_io_error(err);
1899         goto out;
1900       }
1901     }
1902     pdh = NULL;
1903   }
1904   while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
1905     if (!process_packet(cf, pdh, data_offset, wtap_phdr(cf->wth),
1906                         wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
1907                         &err)) {
1908       /* Error writing to a capture file */
1909       show_capture_file_io_error(save_file, err, FALSE);
1910       wtap_dump_close(pdh, &err);
1911       exit(2);
1912     }
1913   }
1914   if (err != 0) {
1915     /* Print a message noting that the read failed somewhere along the line. */
1916     switch (err) {
1917
1918     case WTAP_ERR_UNSUPPORTED_ENCAP:
1919       cmdarg_err("\"%s\" has a packet with a network type that Tethereal doesn't support.\n(%s)",
1920         cf->filename, err_info);
1921       break;
1922
1923     case WTAP_ERR_CANT_READ:
1924       cmdarg_err("An attempt to read from \"%s\" failed for some unknown reason.",
1925         cf->filename);
1926       break;
1927
1928     case WTAP_ERR_SHORT_READ:
1929       cmdarg_err("\"%s\" appears to have been cut short in the middle of a packet.",
1930         cf->filename);
1931       break;
1932
1933     case WTAP_ERR_BAD_RECORD:
1934       cmdarg_err("\"%s\" appears to be damaged or corrupt.\n(%s)",
1935         cf->filename, err_info);
1936       break;
1937
1938     default:
1939       cmdarg_err("An error occurred while reading \"%s\": %s.",
1940         cf->filename, wtap_strerror(err));
1941       break;
1942     }
1943     if (save_file != NULL) {
1944       /* Now close the capture file. */
1945       if (!wtap_dump_close(pdh, &err))
1946         show_capture_file_io_error(save_file, err, TRUE);
1947     }
1948   } else {
1949     if (save_file != NULL) {
1950       /* Now close the capture file. */
1951       if (!wtap_dump_close(pdh, &err))
1952         show_capture_file_io_error(save_file, err, TRUE);
1953     } else {
1954       if (print_packet_info) {
1955         if (!write_finale()) {
1956           err = errno;
1957           show_print_file_io_error(err);
1958         }
1959       }
1960     }
1961   }
1962
1963 out:
1964   wtap_close(cf->wth);
1965   cf->wth = NULL;
1966
1967   return err;
1968 }
1969
1970 static void
1971 fill_in_fdata(frame_data *fdata, capture_file *cf,
1972         const struct wtap_pkthdr *phdr, long offset)
1973 {
1974   fdata->next = NULL;
1975   fdata->prev = NULL;
1976   fdata->pfd = NULL;
1977   fdata->num = cf->count;
1978   fdata->pkt_len = phdr->len;
1979   cum_bytes += phdr->len;
1980   fdata->cum_bytes  = cum_bytes;
1981   fdata->cap_len = phdr->caplen;
1982   fdata->file_off = offset;
1983   fdata->lnk_t = phdr->pkt_encap;
1984   fdata->abs_ts = *((nstime_t *) &phdr->ts);
1985   fdata->flags.passed_dfilter = 0;
1986   fdata->flags.encoding = CHAR_ASCII;
1987   fdata->flags.visited = 0;
1988   fdata->flags.marked = 0;
1989   fdata->flags.ref_time = 0;
1990
1991   /* If we don't have the time stamp of the first packet in the
1992      capture, it's because this is the first packet.  Save the time
1993      stamp of this packet as the time stamp of the first packet. */
1994   if (nstime_is_zero(&first_ts)) {
1995     first_ts = fdata->abs_ts;
1996   }
1997
1998   /* If we don't have the time stamp of the previous displayed packet,
1999      it's because this is the first displayed packet.  Save the time
2000      stamp of this packet as the time stamp of the previous displayed
2001      packet. */
2002   if (nstime_is_zero(&prev_ts)) {
2003     prev_ts = fdata->abs_ts;
2004   }
2005
2006   /* Get the time elapsed between the first packet and this packet. */
2007   nstime_delta(&fdata->rel_ts, &fdata->abs_ts, &first_ts);
2008
2009   /* If it's greater than the current elapsed time, set the elapsed time
2010      to it (we check for "greater than" so as not to be confused by
2011      time moving backwards). */
2012   if ((gint32)cf->elapsed_time.secs < fdata->rel_ts.secs
2013         || ((gint32)cf->elapsed_time.secs == fdata->rel_ts.secs && (gint32)cf->elapsed_time.nsecs < fdata->rel_ts.nsecs)) {
2014     cf->elapsed_time = fdata->rel_ts;
2015   }
2016
2017   /* Get the time elapsed between the previous displayed packet and
2018      this packet. */
2019   nstime_delta(&fdata->del_ts, &fdata->abs_ts, &prev_ts);
2020   prev_ts = fdata->abs_ts;
2021 }
2022
2023 /* Free up all data attached to a "frame_data" structure. */
2024 static void
2025 clear_fdata(frame_data *fdata)
2026 {
2027   if (fdata->pfd)
2028     g_slist_free(fdata->pfd);
2029 }
2030
2031 static gboolean
2032 process_packet(capture_file *cf, wtap_dumper *pdh, long offset,
2033                const struct wtap_pkthdr *whdr,
2034                union wtap_pseudo_header *pseudo_header, const guchar *pd,
2035                int *err)
2036 {
2037   frame_data fdata;
2038   gboolean create_proto_tree;
2039   epan_dissect_t *edt;
2040   gboolean passed;
2041
2042   /* Count this packet. */
2043   cf->count++;
2044
2045   /* If we're going to print packet information, or we're going to
2046      run a read filter, or we're going to process taps, set up to
2047      do a dissection and do so. */
2048   if (do_dissection) {
2049     fill_in_fdata(&fdata, cf, whdr, offset);
2050
2051     if (print_packet_info) {
2052       /* Grab any resolved addresses */
2053     
2054       if (g_resolv_flags) {
2055         host_name_lookup_process(NULL);
2056       }
2057     }
2058
2059     passed = TRUE;
2060     if (cf->rfcode || verbose || num_tap_filters!=0)
2061       create_proto_tree = TRUE;
2062     else
2063       create_proto_tree = FALSE;
2064     /* The protocol tree will be "visible", i.e., printed, only if we're
2065        printing packet details, which is true if we're printing stuff
2066        ("print_packet_info" is true) and we're in verbose mode ("verbose"
2067        is true). */
2068     edt = epan_dissect_new(create_proto_tree, print_packet_info && verbose);
2069
2070     /* If we're running a read filter, prime the epan_dissect_t with that
2071        filter. */
2072     if (cf->rfcode)
2073       epan_dissect_prime_dfilter(edt, cf->rfcode);
2074
2075     tap_queue_init(edt);
2076
2077     /* We only need the columns if we're printing packet info but we're
2078        *not* verbose; in verbose mode, we print the protocol tree, not
2079        the protocol summary. */
2080     epan_dissect_run(edt, pseudo_header, pd, &fdata,
2081                      (print_packet_info && !verbose) ? &cf->cinfo : NULL);
2082
2083     tap_push_tapped_queue(edt);
2084
2085     /* Run the read filter if we have one. */
2086     if (cf->rfcode)
2087       passed = dfilter_apply_edt(cf->rfcode, edt);
2088     else
2089       passed = TRUE;
2090   } else {
2091     /* We're not running a display filter and we're not printing any
2092        packet information, so we don't need to do a dissection, and all
2093        packets are processed. */
2094     edt = NULL;
2095     passed = TRUE;
2096   }
2097
2098   if (passed) {
2099     /* Count this packet. */
2100 #ifdef HAVE_LIBPCAP
2101     ld.packet_count++;
2102 #endif
2103
2104     /* Process this packet. */
2105     if (pdh != NULL) {
2106       /* We're writing to a capture file; write this packet. */
2107       if (!wtap_dump(pdh, whdr, pseudo_header, pd, err))
2108         return FALSE;
2109 #ifdef HAVE_LIBPCAP
2110       if (print_packet_counts) {
2111         /* We're printing packet counts. */
2112         if (ld.packet_count != 0) {
2113           fprintf(stderr, "\r%u ", ld.packet_count);
2114           /* stderr could be line buffered */
2115           fflush(stderr);
2116         }
2117       }
2118 #endif
2119     }
2120     if (print_packet_info) {
2121       /* We're printing packet information; print the information for
2122          this packet. */
2123       print_packet(cf, edt);
2124
2125       /* The ANSI C standard does not appear to *require* that a line-buffered
2126          stream be flushed to the host environment whenever a newline is
2127          written, it just says that, on such a stream, characters "are
2128          intended to be transmitted to or from the host environment as a
2129          block when a new-line character is encountered".
2130
2131          The Visual C++ 6.0 C implementation doesn't do what is intended;
2132          even if you set a stream to be line-buffered, it still doesn't
2133          flush the buffer at the end of every line.
2134
2135          So, if the "-l" flag was specified, we flush the standard output
2136          at the end of a packet.  This will do the right thing if we're
2137          printing packet summary lines, and, as we print the entire protocol
2138          tree for a single packet without waiting for anything to happen,
2139          it should be as good as line-buffered mode if we're printing
2140          protocol trees.  (The whole reason for the "-l" flag in either
2141          tcpdump or Tethereal is to allow the output of a live capture to
2142          be piped to a program or script and to have that script see the
2143          information for the packet as soon as it's printed, rather than
2144          having to wait until a standard I/O buffer fills up. */
2145       if (line_buffered)
2146         fflush(stdout);
2147
2148       if (ferror(stdout)) {
2149         show_print_file_io_error(errno);
2150         exit(2);
2151       }
2152     }
2153   }
2154
2155   if (do_dissection) {
2156     epan_dissect_free(edt);
2157     clear_fdata(&fdata);
2158   }
2159   return TRUE;
2160 }
2161
2162 static void
2163 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
2164 {
2165   if (*fname == '\0')
2166     fname = "stdout";
2167
2168   switch (err) {
2169
2170   case ENOSPC:
2171     cmdarg_err("Not all the packets could be written to \"%s\" because there is "
2172 "no space left on the file system.",
2173         fname);
2174     break;
2175
2176 #ifdef EDQUOT
2177   case EDQUOT:
2178     cmdarg_err("Not all the packets could be written to \"%s\" because you are "
2179 "too close to, or over your disk quota.",
2180         fname);
2181   break;
2182 #endif
2183
2184   case WTAP_ERR_CANT_CLOSE:
2185     cmdarg_err("\"%s\" couldn't be closed for some unknown reason.",
2186         fname);
2187     break;
2188
2189   case WTAP_ERR_SHORT_WRITE:
2190     cmdarg_err("Not all the packets could be written to \"%s\".",
2191         fname);
2192     break;
2193
2194   default:
2195     if (is_close) {
2196       cmdarg_err("\"%s\" could not be closed: %s.",
2197         fname, wtap_strerror(err));
2198     } else {
2199       cmdarg_err("An error occurred while writing to \"%s\": %s.",
2200         fname, wtap_strerror(err));
2201     }
2202     break;
2203   }
2204 }
2205
2206 static gboolean
2207 write_preamble(capture_file *cf)
2208 {
2209   switch (output_action) {
2210
2211   case WRITE_TEXT:
2212     return print_preamble(print_stream, cf->filename);
2213     break;
2214
2215   case WRITE_XML:
2216     if (verbose)
2217       write_pdml_preamble(stdout);
2218     else
2219       write_psml_preamble(stdout);
2220     return !ferror(stdout);
2221
2222   default:
2223     g_assert_not_reached();
2224     return FALSE;
2225   }
2226 }
2227
2228 static char *
2229 get_line_buf(size_t len)
2230 {
2231   static char *line_bufp = NULL;
2232   static size_t line_buf_len = 256;
2233   size_t new_line_buf_len;
2234
2235   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
2236        new_line_buf_len *= 2)
2237     ;
2238   if (line_bufp == NULL) {
2239     line_buf_len = new_line_buf_len;
2240     line_bufp = g_malloc(line_buf_len + 1);
2241   } else {
2242     if (new_line_buf_len > line_buf_len) {
2243       line_buf_len = new_line_buf_len;
2244       line_bufp = g_realloc(line_bufp, line_buf_len + 1);
2245     }
2246   }
2247   return line_bufp;
2248 }
2249
2250 static gboolean
2251 print_columns(capture_file *cf)
2252 {
2253   char *line_bufp;
2254   int i;
2255   size_t buf_offset;
2256   size_t column_len;
2257
2258   line_bufp = get_line_buf(256);
2259   buf_offset = 0;
2260   *line_bufp = '\0';
2261   for (i = 0; i < cf->cinfo.num_cols; i++) {
2262     switch (cf->cinfo.col_fmt[i]) {
2263     case COL_NUMBER:
2264 #ifdef HAVE_LIBPCAP
2265       /*
2266        * Don't print this if we're doing a live capture from a network
2267        * interface - if we're doing a live capture, you won't be
2268        * able to look at the capture in the future (it's not being
2269        * saved anywhere), so the frame numbers are unlikely to be
2270        * useful.
2271        *
2272        * (XXX - it might be nice to be able to save and print at
2273        * the same time, sort of like an "Update list of packets
2274        * in real time" capture in Ethereal.)
2275        */
2276       if (capture_opts.iface != NULL)
2277         continue;
2278 #endif
2279       column_len = strlen(cf->cinfo.col_data[i]);
2280       if (column_len < 3)
2281         column_len = 3;
2282       line_bufp = get_line_buf(buf_offset + column_len);
2283       sprintf(line_bufp + buf_offset, "%3s", cf->cinfo.col_data[i]);
2284       break;
2285
2286     case COL_CLS_TIME:
2287     case COL_REL_TIME:
2288     case COL_ABS_TIME:
2289     case COL_ABS_DATE_TIME:     /* XXX - wider */
2290       column_len = strlen(cf->cinfo.col_data[i]);
2291       if (column_len < 10)
2292         column_len = 10;
2293       line_bufp = get_line_buf(buf_offset + column_len);
2294       sprintf(line_bufp + buf_offset, "%10s", cf->cinfo.col_data[i]);
2295       break;
2296
2297     case COL_DEF_SRC:
2298     case COL_RES_SRC:
2299     case COL_UNRES_SRC:
2300     case COL_DEF_DL_SRC:
2301     case COL_RES_DL_SRC:
2302     case COL_UNRES_DL_SRC:
2303     case COL_DEF_NET_SRC:
2304     case COL_RES_NET_SRC:
2305     case COL_UNRES_NET_SRC:
2306       column_len = strlen(cf->cinfo.col_data[i]);
2307       if (column_len < 12)
2308         column_len = 12;
2309       line_bufp = get_line_buf(buf_offset + column_len);
2310       sprintf(line_bufp + buf_offset, "%12s", cf->cinfo.col_data[i]);
2311       break;
2312
2313     case COL_DEF_DST:
2314     case COL_RES_DST:
2315     case COL_UNRES_DST:
2316     case COL_DEF_DL_DST:
2317     case COL_RES_DL_DST:
2318     case COL_UNRES_DL_DST:
2319     case COL_DEF_NET_DST:
2320     case COL_RES_NET_DST:
2321     case COL_UNRES_NET_DST:
2322       column_len = strlen(cf->cinfo.col_data[i]);
2323       if (column_len < 12)
2324         column_len = 12;
2325       line_bufp = get_line_buf(buf_offset + column_len);
2326       sprintf(line_bufp + buf_offset, "%-12s", cf->cinfo.col_data[i]);
2327       break;
2328
2329     default:
2330       column_len = strlen(cf->cinfo.col_data[i]);
2331       line_bufp = get_line_buf(buf_offset + column_len);
2332       strcat(line_bufp + buf_offset, cf->cinfo.col_data[i]);
2333       break;
2334     }
2335     buf_offset += column_len;
2336     if (i != cf->cinfo.num_cols - 1) {
2337       /*
2338        * This isn't the last column, so we need to print a
2339        * separator between this column and the next.
2340        *
2341        * If we printed a network source and are printing a
2342        * network destination of the same type next, separate
2343        * them with "->"; if we printed a network destination
2344        * and are printing a network source of the same type
2345        * next, separate them with "<-"; otherwise separate them
2346        * with a space.
2347        *
2348        * We add enough space to the buffer for " <- " or " -> ",
2349        * even if we're only adding " ".
2350        */
2351       line_bufp = get_line_buf(buf_offset + 4);
2352       switch (cf->cinfo.col_fmt[i]) {
2353
2354       case COL_DEF_SRC:
2355       case COL_RES_SRC:
2356       case COL_UNRES_SRC:
2357         switch (cf->cinfo.col_fmt[i + 1]) {
2358
2359         case COL_DEF_DST:
2360         case COL_RES_DST:
2361         case COL_UNRES_DST:
2362           strcat(line_bufp + buf_offset, " -> ");
2363           buf_offset += 4;
2364           break;
2365
2366         default:
2367           strcat(line_bufp + buf_offset, " ");
2368           buf_offset += 1;
2369           break;
2370         }
2371         break;
2372
2373       case COL_DEF_DL_SRC:
2374       case COL_RES_DL_SRC:
2375       case COL_UNRES_DL_SRC:
2376         switch (cf->cinfo.col_fmt[i + 1]) {
2377
2378         case COL_DEF_DL_DST:
2379         case COL_RES_DL_DST:
2380         case COL_UNRES_DL_DST:
2381           strcat(line_bufp + buf_offset, " -> ");
2382           buf_offset += 4;
2383           break;
2384
2385         default:
2386           strcat(line_bufp + buf_offset, " ");
2387           buf_offset += 1;
2388           break;
2389         }
2390         break;
2391
2392       case COL_DEF_NET_SRC:
2393       case COL_RES_NET_SRC:
2394       case COL_UNRES_NET_SRC:
2395         switch (cf->cinfo.col_fmt[i + 1]) {
2396
2397         case COL_DEF_NET_DST:
2398         case COL_RES_NET_DST:
2399         case COL_UNRES_NET_DST:
2400           strcat(line_bufp + buf_offset, " -> ");
2401           buf_offset += 4;
2402           break;
2403
2404         default:
2405           strcat(line_bufp + buf_offset, " ");
2406           buf_offset += 1;
2407           break;
2408         }
2409         break;
2410
2411       case COL_DEF_DST:
2412       case COL_RES_DST:
2413       case COL_UNRES_DST:
2414         switch (cf->cinfo.col_fmt[i + 1]) {
2415
2416         case COL_DEF_SRC:
2417         case COL_RES_SRC:
2418         case COL_UNRES_SRC:
2419           strcat(line_bufp + buf_offset, " <- ");
2420           buf_offset += 4;
2421           break;
2422
2423         default:
2424           strcat(line_bufp + buf_offset, " ");
2425           buf_offset += 1;
2426           break;
2427         }
2428         break;
2429
2430       case COL_DEF_DL_DST:
2431       case COL_RES_DL_DST:
2432       case COL_UNRES_DL_DST:
2433         switch (cf->cinfo.col_fmt[i + 1]) {
2434
2435         case COL_DEF_DL_SRC:
2436         case COL_RES_DL_SRC:
2437         case COL_UNRES_DL_SRC:
2438           strcat(line_bufp + buf_offset, " <- ");
2439           buf_offset += 4;
2440           break;
2441
2442         default:
2443           strcat(line_bufp + buf_offset, " ");
2444           buf_offset += 1;
2445           break;
2446         }
2447         break;
2448
2449       case COL_DEF_NET_DST:
2450       case COL_RES_NET_DST:
2451       case COL_UNRES_NET_DST:
2452         switch (cf->cinfo.col_fmt[i + 1]) {
2453
2454         case COL_DEF_NET_SRC:
2455         case COL_RES_NET_SRC:
2456         case COL_UNRES_NET_SRC:
2457           strcat(line_bufp + buf_offset, " <- ");
2458           buf_offset += 4;
2459           break;
2460
2461         default:
2462           strcat(line_bufp + buf_offset, " ");
2463           buf_offset += 1;
2464           break;
2465         }
2466         break;
2467
2468       default:
2469         strcat(line_bufp + buf_offset, " ");
2470         buf_offset += 1;
2471         break;
2472       }
2473     }
2474   }
2475   return print_line(print_stream, 0, line_bufp);
2476 }
2477
2478 static gboolean
2479 print_packet(capture_file *cf, epan_dissect_t *edt)
2480 {
2481   print_args_t  print_args;
2482
2483   if (verbose) {
2484     /* Print the information in the protocol tree. */
2485     switch (output_action) {
2486
2487     case WRITE_TEXT:
2488       print_args.to_file = TRUE;
2489       print_args.format = print_format;
2490       print_args.print_summary = !verbose;
2491       print_args.print_hex = verbose && print_hex;
2492       print_args.print_formfeed = FALSE;
2493       print_args.print_dissections = verbose ? print_dissections_expanded : print_dissections_none;
2494
2495       /* init the packet range */
2496       packet_range_init(&print_args.range);
2497
2498       if (!proto_tree_print(&print_args, edt, print_stream))
2499         return FALSE;
2500       if (!print_hex) {
2501         /* "print_hex_data()" will put out a leading blank line, as well
2502          as a trailing one; print one here, to separate the packets,
2503          only if "print_hex_data()" won't be called. */
2504         if (!print_line(print_stream, 0, ""))
2505           return FALSE;
2506       }
2507       break;
2508
2509     case WRITE_XML:
2510       proto_tree_write_pdml(edt, stdout);
2511       printf("\n");
2512       return !ferror(stdout);
2513     }
2514   } else {
2515     /* Just fill in the columns. */
2516     epan_dissect_fill_in_columns(edt);
2517
2518     /* Now print them. */
2519     switch (output_action) {
2520
2521     case WRITE_TEXT:
2522         if (!print_columns(cf))
2523           return FALSE;
2524         break;
2525
2526     case WRITE_XML:
2527         proto_tree_write_psml(edt, stdout);
2528         return !ferror(stdout);
2529     }
2530   }
2531   if (print_hex) {
2532     if (!print_hex_data(print_stream, edt))
2533       return FALSE;
2534     if (!print_line(print_stream, 0, ""))
2535       return FALSE;
2536   }
2537   return TRUE;
2538 }
2539
2540 static gboolean
2541 write_finale(void)
2542 {
2543   switch (output_action) {
2544
2545   case WRITE_TEXT:
2546     return print_finale(print_stream);
2547     break;
2548
2549   case WRITE_XML:
2550     if (verbose)
2551       write_pdml_finale(stdout);
2552     else
2553       write_psml_finale(stdout);
2554     return !ferror(stdout);
2555
2556   default:
2557     g_assert_not_reached();
2558     return FALSE;
2559   }
2560 }
2561
2562 static void
2563 show_print_file_io_error(int err)
2564 {
2565   switch (err) {
2566
2567   case ENOSPC:
2568     cmdarg_err("Not all the packets could be printed because there is "
2569 "no space left on the file system.");
2570     break;
2571
2572 #ifdef EDQUOT
2573   case EDQUOT:
2574     cmdarg_err("Not all the packets could be printed because you are "
2575 "too close to, or over your disk quota.");
2576   break;
2577 #endif
2578
2579   default:
2580     cmdarg_err("An error occurred while printing packets: %s.",
2581       strerror(err));
2582     break;
2583   }
2584 }
2585
2586 static const char *
2587 cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
2588                       int file_type)
2589 {
2590   const char *errmsg;
2591   static char errmsg_errno[1024+1];
2592
2593   if (err < 0) {
2594     /* Wiretap error. */
2595     switch (err) {
2596
2597     case WTAP_ERR_NOT_REGULAR_FILE:
2598       errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
2599       break;
2600
2601     case WTAP_ERR_FILE_UNKNOWN_FORMAT:
2602       /* Seen only when opening a capture file for reading. */
2603       errmsg = "The file \"%s\" isn't a capture file in a format Tethereal understands.";
2604       break;
2605
2606     case WTAP_ERR_UNSUPPORTED:
2607       /* Seen only when opening a capture file for reading. */
2608       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2609                "The file \"%%s\" isn't a capture file in a format Tethereal understands.\n"
2610                "(%s)", err_info);
2611       g_free(err_info);
2612       errmsg = errmsg_errno;
2613       break;
2614
2615     case WTAP_ERR_CANT_WRITE_TO_PIPE:
2616       /* Seen only when opening a capture file for writing. */
2617       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2618                "The file \"%%s\" is a pipe, and %s capture files can't be "
2619                "written to a pipe.", wtap_file_type_string(file_type));
2620       errmsg = errmsg_errno;
2621       break;
2622
2623     case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
2624       /* Seen only when opening a capture file for writing. */
2625       errmsg = "Tethereal doesn't support writing capture files in that format.";
2626       break;
2627
2628     case WTAP_ERR_UNSUPPORTED_ENCAP:
2629       if (for_writing)
2630         errmsg = "Tethereal can't save this capture in that format.";
2631       else {
2632         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2633                  "The file \"%%s\" is a capture for a network type that Tethereal doesn't support.\n"
2634                  "(%s)", err_info);
2635         g_free(err_info);
2636         errmsg = errmsg_errno;
2637       }
2638       break;
2639
2640     case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
2641       if (for_writing)
2642         errmsg = "Tethereal can't save this capture in that format.";
2643       else
2644         errmsg = "The file \"%s\" is a capture for a network type that Tethereal doesn't support.";
2645       break;
2646
2647     case WTAP_ERR_BAD_RECORD:
2648       /* Seen only when opening a capture file for reading. */
2649       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2650                "The file \"%%s\" appears to be damaged or corrupt.\n"
2651                "(%s)", err_info);
2652       g_free(err_info);
2653       errmsg = errmsg_errno;
2654       break;
2655
2656     case WTAP_ERR_CANT_OPEN:
2657       if (for_writing)
2658         errmsg = "The file \"%s\" could not be created for some unknown reason.";
2659       else
2660         errmsg = "The file \"%s\" could not be opened for some unknown reason.";
2661       break;
2662
2663     case WTAP_ERR_SHORT_READ:
2664       errmsg = "The file \"%s\" appears to have been cut short"
2665                " in the middle of a packet or other data.";
2666       break;
2667
2668     case WTAP_ERR_SHORT_WRITE:
2669       errmsg = "A full header couldn't be written to the file \"%s\".";
2670       break;
2671
2672     default:
2673       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2674                "The file \"%%s\" could not be %s: %s.",
2675                for_writing ? "created" : "opened",
2676                wtap_strerror(err));
2677       errmsg = errmsg_errno;
2678       break;
2679     }
2680   } else
2681     errmsg = file_open_error_message(err, for_writing);
2682   return errmsg;
2683 }
2684
2685 /*
2686  * Open/create errors are reported with an console message in Tethereal.
2687  */
2688 static void
2689 open_failure_message(const char *filename, int err, gboolean for_writing)
2690 {
2691   fprintf(stderr, "tethereal: ");
2692   fprintf(stderr, file_open_error_message(err, for_writing), filename);
2693   fprintf(stderr, "\n");
2694 }
2695
2696 cf_status_t
2697 cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
2698 {
2699   wtap       *wth;
2700   gchar       *err_info;
2701   char        err_msg[2048+1];
2702
2703   wth = wtap_open_offline(fname, err, &err_info, FALSE);
2704   if (wth == NULL)
2705     goto fail;
2706
2707   /* The open succeeded.  Fill in the information for this file. */
2708
2709   /* Initialize all data structures used for dissection. */
2710   init_dissection();
2711
2712   cf->wth = wth;
2713   cf->f_datalen = 0;    /* not used, but set it anyway */
2714
2715   /* Set the file name because we need it to set the follow stream filter.
2716      XXX - is that still true?  We need it for other reasons, though,
2717      in any case. */
2718   cf->filename = g_strdup(fname);
2719
2720   /* Indicate whether it's a permanent or temporary file. */
2721   cf->is_tempfile = is_tempfile;
2722
2723   /* If it's a temporary capture buffer file, mark it as not saved. */
2724   cf->user_saved = !is_tempfile;
2725
2726   cf->cd_t      = wtap_file_type(cf->wth);
2727   cf->count     = 0;
2728   cf->drops_known = FALSE;
2729   cf->drops     = 0;
2730   cf->snap      = wtap_snapshot_length(cf->wth);
2731   if (cf->snap == 0) {
2732     /* Snapshot length not known. */
2733     cf->has_snap = FALSE;
2734     cf->snap = WTAP_MAX_PACKET_SIZE;
2735   } else
2736     cf->has_snap = TRUE;
2737   nstime_set_zero(&cf->elapsed_time);
2738   nstime_set_zero(&first_ts);
2739   nstime_set_zero(&prev_ts);
2740
2741   return CF_OK;
2742
2743 fail:
2744   g_snprintf(err_msg, sizeof err_msg,
2745            cf_open_error_message(*err, err_info, FALSE, 0), fname);
2746   cmdarg_err("%s", err_msg);
2747   return CF_ERROR;
2748 }
2749
2750
2751 /*
2752  * General errors are reported with an console message in Tethereal.
2753  */
2754 static void
2755 failure_message(const char *msg_format, va_list ap)
2756 {
2757   fprintf(stderr, "tethereal: ");
2758   vfprintf(stderr, msg_format, ap);
2759   fprintf(stderr, "\n");
2760 }
2761
2762 /*
2763  * Read errors are reported with an console message in Tethereal.
2764  */
2765 static void
2766 read_failure_message(const char *filename, int err)
2767 {
2768   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
2769           filename, strerror(err));
2770 }
2771
2772 /*
2773  * Report an error in command-line arguments.
2774  */
2775 void
2776 cmdarg_err(const char *fmt, ...)
2777 {
2778   va_list ap;
2779
2780   va_start(ap, fmt);
2781   fprintf(stderr, "tethereal: ");
2782   vfprintf(stderr, fmt, ap);
2783   fprintf(stderr, "\n");
2784   va_end(ap);
2785 }
2786
2787 /*
2788  * Report additional information for an error in command-line arguments.
2789  */
2790 void
2791 cmdarg_err_cont(const char *fmt, ...)
2792 {
2793   va_list ap;
2794
2795   va_start(ap, fmt);
2796   vfprintf(stderr, fmt, ap);
2797   fprintf(stderr, "\n");
2798   va_end(ap);
2799 }
2800
2801
2802 /****************************************************************************************************************/
2803 /* sync pipe "dummies", needed for capture_loop.c */
2804
2805 #ifdef HAVE_LIBPCAP
2806
2807 /** the child has opened a new capture file, notify the parent */
2808 void
2809 sync_pipe_filename_to_parent(const char *filename)
2810 {
2811     /* shouldn't happen */
2812     g_assert(0);
2813 }
2814
2815 /** the child captured some new packets, notify the parent */
2816 void
2817 sync_pipe_packet_count_to_parent(int packet_count)
2818 {
2819     /* shouldn't happen */
2820     g_assert(0);
2821 }
2822
2823 /** the child stopped capturing, notify the parent */
2824 void
2825 sync_pipe_drops_to_parent(int drops)
2826 {
2827     /* shouldn't happen */
2828     g_assert(0);
2829 }
2830
2831 /** the child encountered an error, notify the parent */
2832 void 
2833 sync_pipe_errmsg_to_parent(const char *errmsg)
2834 {
2835     cmdarg_err(errmsg);
2836 }
2837
2838 #endif /* HAVE_LIBPCAP */
2839
2840
2841 /****************************************************************************************************************/
2842 /* simple_dialog "dummies", needed for capture_loop.c */
2843
2844
2845 #ifdef HAVE_LIBPCAP
2846
2847 char *simple_dialog_primary_start(void)
2848 {
2849     return "";
2850 }
2851
2852 char *simple_dialog_primary_end(void)
2853 {
2854     return "";
2855 }
2856
2857
2858 /* XXX - do we need to convert the string for the console? */
2859 char *
2860 simple_dialog_format_message(const char *msg)
2861 {
2862     char *str;
2863
2864
2865     if (msg) {
2866 #if GTK_MAJOR_VERSION < 2
2867         str = g_strdup(msg);
2868 #else
2869         str = xml_escape(msg);
2870 #endif
2871     } else {
2872         str = NULL;
2873     }
2874     return str;
2875 }
2876
2877 #endif /* HAVE_LIBPCAP */
2878
2879