Replace the types from sys/types.h and netinet/in.h by their glib.h
[obnox/wireshark/wip.git] / tethereal.c
1 /* tethereal.c
2  *
3  * $Id: tethereal.c,v 1.151 2002/08/02 23:36:07 jmayer Exp $
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_LIBPCAP
51 #include <pcap.h>
52 #include <setjmp.h>
53 #endif
54
55 #ifdef HAVE_LIBZ
56 #include <zlib.h>       /* to get the libz version number */
57 #endif
58
59 #ifdef NEED_SNPRINTF_H
60 # include "snprintf.h"
61 #endif
62
63 #ifdef HAVE_UCD_SNMP_VERSION_H
64 #include <ucd-snmp/version.h>
65 #endif /* HAVE_UCD_SNMP_VERSION_H */
66
67 #ifdef NEED_STRERROR_H
68 #include "strerror.h"
69 #endif
70
71 #ifdef NEED_GETOPT_H
72 #include "getopt.h"
73 #endif
74
75 #include <glib.h>
76 #include <epan/epan.h>
77 #include <epan/filesystem.h>
78
79 #include "globals.h"
80 #include <epan/timestamp.h>
81 #include <epan/packet.h>
82 #include "file.h"
83 #include "prefs.h"
84 #include "column.h"
85 #include "print.h"
86 #include <epan/resolv.h>
87 #include "util.h"
88 #ifdef HAVE_LIBPCAP
89 #include "pcap-util.h"
90 #endif
91 #include <epan/conversation.h>
92 #include <epan/plugins.h>
93 #include "register.h"
94 #include "conditions.h"
95 #include "capture_stop_conditions.h"
96 #include "ringbuffer.h"
97 #include <epan/epan_dissect.h>
98
99 #ifdef HAVE_LIBPCAP
100 #include <wiretap/wtap-capture.h>
101 #endif
102
103 #ifdef WIN32
104 #include "capture-wpcap.h"
105 #endif
106
107 static guint32 firstsec, firstusec;
108 static guint32 prevsec, prevusec;
109 static GString *comp_info_str;
110 static gboolean quiet;
111 static gboolean verbose;
112 static gboolean print_hex;
113 static gboolean line_buffered;
114
115 #ifdef HAVE_LIBPCAP
116 typedef struct _loop_data {
117   gboolean       go;           /* TRUE as long as we're supposed to keep capturing */
118   gint           linktype;
119   pcap_t        *pch;
120   wtap_dumper   *pdh;
121   jmp_buf        stopenv;
122   gboolean       output_to_pipe;
123   int            packet_count;
124 } loop_data;
125
126 static loop_data ld;
127
128 static int capture(int);
129 static void capture_pcap_cb(guchar *, const struct pcap_pkthdr *,
130   const guchar *);
131 #ifdef _WIN32
132 static BOOL WINAPI capture_cleanup(DWORD);
133 #else /* _WIN32 */
134 static void capture_cleanup(int);
135 #endif /* _WIN32 */
136 #endif /* HAVE_LIBPCAP */
137
138 typedef struct {
139   capture_file *cf;
140   wtap_dumper *pdh;
141 } cb_args_t;
142
143 static int load_cap_file(capture_file *, int);
144 static void wtap_dispatch_cb_write(guchar *, const struct wtap_pkthdr *, long,
145     union wtap_pseudo_header *, const guchar *);
146 static void show_capture_file_io_error(const char *, int, gboolean);
147 static void wtap_dispatch_cb_print(guchar *, const struct wtap_pkthdr *, long,
148     union wtap_pseudo_header *, const guchar *);
149
150 capture_file cfile;
151 ts_type timestamp_type = RELATIVE;
152 #ifdef HAVE_LIBPCAP
153 typedef struct {
154         int snaplen;                    /* Maximum captured packet length */
155         int promisc_mode;               /* Capture in promiscuous mode */
156         int autostop_count;             /* Maximum packet count */
157         gboolean has_autostop_duration; /* TRUE if maximum capture duration
158                                            is specified */
159         gint32 autostop_duration;       /* Maximum capture duration */
160         gboolean has_autostop_filesize; /* TRUE if maximum capture file size
161                                            is specified */
162         gint32 autostop_filesize;       /* Maximum capture file size */
163         gboolean ringbuffer_on;         /* TRUE if ring buffer in use */
164         guint32 ringbuffer_num_files;   /* Number of ring buffer files */
165 } capture_options;
166
167 static capture_options capture_opts = {
168         WTAP_MAX_PACKET_SIZE,           /* snapshot length - default is
169                                            infinite, in effect */
170         TRUE,                           /* promiscuous mode is the default */
171         0,                              /* max packet count - default is 0,
172                                            meaning infinite */
173         FALSE,                          /* maximum capture duration not
174                                            specified by default */
175         0,                              /* maximum capture duration */
176         FALSE,                          /* maximum capture file size not
177                                            specified by default */
178         0,                              /* maximum capture file size */
179         FALSE,                          /* ring buffer off by default */
180         RINGBUFFER_MIN_NUM_FILES        /* default number of ring buffer
181                                            files */
182 };
183 #endif
184
185 static void 
186 print_usage(gboolean print_ver)
187 {
188   int i;
189
190   if (print_ver) {
191     fprintf(stderr, "This is GNU t%s %s, compiled %s\n", PACKAGE, VERSION,
192         comp_info_str->str);
193   }
194 #ifdef HAVE_LIBPCAP
195   fprintf(stderr, "\nt%s [ -DvVhqlp ] [ -a <capture autostop condition> ] ...\n",
196           PACKAGE);
197   fprintf(stderr, "\t[ -b <number of ring buffer files> ] [ -c <count> ]\n");
198   fprintf(stderr, "\t[ -f <capture filter> ] [ -F <output file type> ]\n");
199   fprintf(stderr, "\t[ -i <interface> ] [ -n ] [ -N <resolving> ]\n");
200   fprintf(stderr, "\t[ -o <preference setting> ] ... [ -r <infile> ] [ -R <read filter> ]\n");
201   fprintf(stderr, "\t[ -s <snaplen> ] [ -t <time stamp format> ] [ -w <savefile> ] [ -x ]\n");
202 #else
203   fprintf(stderr, "\nt%s [ -vVhl ] [ -F <output file type> ] [ -n ] [ -N <resolving> ]\n", PACKAGE);
204   fprintf(stderr, "\t[ -o <preference setting> ] ... [ -r <infile> ] [ -R <read filter> ]\n");
205   fprintf(stderr, "\t[ -t <time stamp format> ] [ -w <savefile> ] [ -x ]\n");
206 #endif
207   fprintf(stderr, "Valid file type arguments to the \"-F\" flag:\n");
208   for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
209     if (wtap_dump_can_open(i))
210       fprintf(stderr, "\t%s - %s\n",
211         wtap_file_type_short_string(i), wtap_file_type_string(i));
212   }
213   fprintf(stderr, "\tdefault is libpcap\n");
214 }
215
216 #ifdef HAVE_LIBPCAP
217 static int
218 get_positive_int(const char *string, const char *name)
219 {
220   long number;
221   char *p;
222
223   number = strtol(string, &p, 10);
224   if (p == string || *p != '\0') {
225     fprintf(stderr, "tethereal: The specified %s \"%s\" is not a decimal number\n",
226             name, string);
227     exit(1);
228   }
229   if (number < 0) {
230     fprintf(stderr, "tethereal: The specified %s is a negative number\n",
231             name);
232     exit(1);
233   }
234   if (number == 0) {
235     fprintf(stderr, "tethereal: The specified %s is zero\n",
236             name);
237     exit(1);
238   }
239   if (number > INT_MAX) {
240     fprintf(stderr, "tethereal: The specified %s is too large (greater than %d)\n",
241             name, INT_MAX);
242     exit(1);
243   }
244   return number;
245 }
246
247 /*
248  * Given a string of the form "<autostop criterion>:<value>", as might appear
249  * as an argument to a "-a" option, parse it and set the criterion in
250  * question.  Return an indication of whether it succeeded or failed
251  * in some fashion.
252  */
253 static gboolean
254 set_autostop_criterion(const char *autostoparg)
255 {
256   guchar *p, *colonp;
257
258   colonp = strchr(autostoparg, ':');
259   if (colonp == NULL)
260     return FALSE;
261
262   p = colonp;
263   *p++ = '\0';
264
265   /*
266    * Skip over any white space (there probably won't be any, but
267    * as we allow it in the preferences file, we might as well
268    * allow it here).
269    */
270   while (isspace(*p))
271     p++;
272   if (*p == '\0') {
273     /*
274      * Put the colon back, so if our caller uses, in an
275      * error message, the string they passed us, the message
276      * looks correct.
277      */
278     *colonp = ':';
279     return FALSE;
280   }
281   if (strcmp(autostoparg,"duration") == 0) {
282     capture_opts.has_autostop_duration = TRUE;
283     capture_opts.autostop_duration = get_positive_int(p,"autostop duration");
284   } else if (strcmp(autostoparg,"filesize") == 0) {
285     capture_opts.has_autostop_filesize = TRUE;
286     capture_opts.autostop_filesize = get_positive_int(p,"autostop filesize");
287   } else {
288     return FALSE;
289   }
290   *colonp = ':';        /* put the colon back */
291   return TRUE;
292 }
293 #endif
294
295 int
296 main(int argc, char *argv[])
297 {
298   int                  opt, i;
299   extern char         *optarg;
300   gboolean             arg_error = FALSE;
301 #ifdef HAVE_LIBPCAP
302 #ifdef HAVE_PCAP_VERSION
303   extern char          pcap_version[];
304 #endif /* HAVE_PCAP_VERSION */
305 #endif /* HAVE_LIBPCAP */
306
307 #ifdef WIN32
308   WSADATA               wsaData;
309 #endif
310
311   char                *gpf_path;
312   char                *pf_path;
313   int                  gpf_open_errno, pf_open_errno;
314   int                  err;
315 #ifdef HAVE_LIBPCAP
316   gboolean             capture_filter_specified = FALSE;
317   GList               *if_list, *if_entry;
318   gchar                err_str[PCAP_ERRBUF_SIZE];
319 #else
320   gboolean             capture_option_specified = FALSE;
321 #endif
322   int                  out_file_type = WTAP_FILE_PCAP;
323   gchar               *cf_name = NULL, *rfilter = NULL;
324 #ifdef HAVE_LIBPCAP
325   gchar               *if_text;
326 #endif
327   dfilter_t           *rfcode = NULL;
328   e_prefs             *prefs;
329   char                 badopt;
330
331   /* Register all dissectors; we must do this before checking for the
332      "-G" flag, as the "-G" flag dumps information registered by the
333      dissectors, and we must do it before we read the preferences, in
334      case any dissectors register preferences. */
335   epan_init(PLUGIN_DIR,register_all_protocols,register_all_protocol_handoffs);
336
337   /* Now register the preferences for any non-dissector modules.
338      We must do that before we read the preferences as well. */
339   prefs_register_modules();
340
341   /* If invoked with the "-G" flag, we dump out information based on
342      the argument to the "-G" flag; if no argument is specified,
343      for backwards compatibility we dump out a glossary of display
344      filter symbols.
345
346      We do this here to mirror what happens in the GTK+ version, although
347      it's not necessary here. */
348   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
349     if (argc == 2)
350       proto_registrar_dump_fields();
351     else {
352       if (strcmp(argv[2], "fields") == 0)
353         proto_registrar_dump_fields();
354       else if (strcmp(argv[2], "protocols") == 0)
355         proto_registrar_dump_protocols();
356       else {
357         fprintf(stderr, "tethereal: Invalid \"%s\" option for -G flag\n",
358                 argv[2]);
359         exit(1);
360       }
361     }
362     exit(0);
363   }
364
365   /* Set the C-language locale to the native environment. */
366   setlocale(LC_ALL, "");
367
368   prefs = read_prefs(&gpf_open_errno, &gpf_path, &pf_open_errno, &pf_path);
369   if (gpf_path != NULL) {
370     fprintf(stderr, "Can't open global preferences file \"%s\": %s.\n", pf_path,
371         strerror(gpf_open_errno));
372   }
373   if (pf_path != NULL) {
374     fprintf(stderr, "Can't open your preferences file \"%s\": %s.\n", pf_path,
375         strerror(pf_open_errno));
376     g_free(pf_path);
377     pf_path = NULL;
378   }
379
380   /* Set the name resolution code's flags from the preferences. */
381   g_resolv_flags = prefs->name_resolve;
382
383 #ifdef WIN32
384   /* Load Wpcap, if possible */
385   load_wpcap();
386 #endif
387     
388   /* Initialize the capture file struct */
389   cfile.plist           = NULL;
390   cfile.plist_end       = NULL;
391   cfile.wth             = NULL;
392   cfile.filename        = NULL;
393   cfile.user_saved      = FALSE;
394   cfile.is_tempfile     = FALSE;
395   cfile.rfcode          = NULL;
396   cfile.dfilter         = NULL;
397   cfile.dfcode          = NULL;
398 #ifdef HAVE_LIBPCAP
399   cfile.cfilter         = g_strdup("");
400 #endif
401   cfile.iface           = NULL;
402   cfile.save_file       = NULL;
403   cfile.save_file_fd    = -1;
404   cfile.has_snap        = FALSE;
405   cfile.snap            = WTAP_MAX_PACKET_SIZE;
406   cfile.count           = 0;
407
408   /* Assemble the compile-time options */
409   comp_info_str = g_string_new("");
410
411   g_string_append(comp_info_str, "with ");
412   g_string_sprintfa(comp_info_str,
413 #ifdef GLIB_MAJOR_VERSION
414     "GLib %d.%d.%d", GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION,
415     GLIB_MICRO_VERSION);
416 #else
417     "GLib (version unknown)");
418 #endif
419
420 #ifdef HAVE_LIBPCAP
421   g_string_append(comp_info_str, ", with libpcap ");
422 #ifdef HAVE_PCAP_VERSION
423   g_string_append(comp_info_str, pcap_version);
424 #else /* HAVE_PCAP_VERSION */
425   g_string_append(comp_info_str, "(version unknown)");
426 #endif /* HAVE_PCAP_VERSION */
427 #else /* HAVE_LIBPCAP */
428   g_string_append(comp_info_str, ", without libpcap");
429 #endif /* HAVE_LIBPCAP */
430
431 #ifdef HAVE_LIBZ
432   g_string_append(comp_info_str, ", with libz ");
433 #ifdef ZLIB_VERSION
434   g_string_append(comp_info_str, ZLIB_VERSION);
435 #else /* ZLIB_VERSION */
436   g_string_append(comp_info_str, "(version unknown)");
437 #endif /* ZLIB_VERSION */
438 #else /* HAVE_LIBZ */
439   g_string_append(comp_info_str, ", without libz");
440 #endif /* HAVE_LIBZ */
441
442 /* Oh, this is pretty */
443 #ifdef HAVE_UCD_SNMP
444   g_string_append(comp_info_str, ", with UCD SNMP ");
445 #ifdef HAVE_UCD_SNMP_VERSION_H
446   g_string_append(comp_info_str, VersionInfo);
447 #else /* HAVE_UCD_SNMP_VERSION_H */
448   g_string_append(comp_info_str, "(version unknown)");
449 #endif /* HAVE_UCD_SNMP_VERSION_H */
450 #else /* no SNMP library */
451   g_string_append(comp_info_str, ", without UCD SNMP");
452 #endif
453     
454   /* Now get our args */
455   while ((opt = getopt(argc, argv, "a:b:c:Df:F:hi:lnN:o:pqr:R:s:t:vw:Vx")) != -1) {
456     switch (opt) {
457       case 'a':        /* autostop criteria */
458 #ifdef HAVE_LIBPCAP
459         if (set_autostop_criterion(optarg) == FALSE) {
460           fprintf(stderr, "ethereal: Invalid or unknown -a flag \"%s\"\n", optarg);
461           exit(1);          
462         }
463 #else
464         capture_option_specified = TRUE;
465         arg_error = TRUE;
466 #endif
467         break;
468       case 'b':        /* Ringbuffer option */
469 #ifdef HAVE_LIBPCAP
470         capture_opts.ringbuffer_on = TRUE;
471         capture_opts.ringbuffer_num_files =
472             get_positive_int(optarg, "number of ring buffer files");
473 #else
474         capture_option_specified = TRUE;
475         arg_error = TRUE;
476 #endif
477         break;
478       case 'c':        /* Capture xxx packets */
479 #ifdef HAVE_LIBPCAP
480         capture_opts.autostop_count =
481             get_positive_int(optarg, "packet count");
482 #else
483         capture_option_specified = TRUE;
484         arg_error = TRUE;
485 #endif
486         break;
487       case 'D':        /* Print a list of capture devices */
488 #ifdef HAVE_LIBPCAP
489         if_list = get_interface_list(&err, err_str);
490         if (if_list == NULL) {
491             switch (err) {
492
493             case CANT_GET_INTERFACE_LIST:
494                 fprintf(stderr, "tethereal: Can't get list of interfaces: %s\n",
495                         err_str);
496                 break;
497
498             case NO_INTERFACES_FOUND:
499                 fprintf(stderr, "tethereal: There are no interfaces on which a capture can be done\n");
500                 break;
501             }
502             exit(2);
503         }
504         for (if_entry = g_list_first(if_list); if_entry != NULL;
505                 if_entry = g_list_next(if_entry))
506           printf("%s\n", (char *)if_entry->data);
507         free_interface_list(if_list);
508         exit(0);
509 #else
510         capture_option_specified = TRUE;
511         arg_error = TRUE;
512 #endif
513         break;
514       case 'f':
515 #ifdef HAVE_LIBPCAP
516         capture_filter_specified = TRUE;
517         if (cfile.cfilter)
518                 g_free(cfile.cfilter);
519         cfile.cfilter = g_strdup(optarg);
520 #else
521         capture_option_specified = TRUE;
522         arg_error = TRUE;
523 #endif
524         break;
525       case 'F':
526         out_file_type = wtap_short_string_to_file_type(optarg);
527         if (out_file_type < 0) {
528           fprintf(stderr, "tethereal: \"%s\" is not a valid capture file type\n",
529                         optarg);
530           exit(1);
531         }
532         break;
533       case 'h':        /* Print help and exit */
534         print_usage(TRUE);
535         exit(0);
536         break;
537       case 'i':        /* Use interface xxx */
538 #ifdef HAVE_LIBPCAP
539         cfile.iface = g_strdup(optarg);
540 #else
541         capture_option_specified = TRUE;
542         arg_error = TRUE;
543 #endif
544         break;
545       case 'l':        /* "Line-buffer" standard output */
546         /* This isn't line-buffering, strictly speaking, it's just
547            flushing the standard output after the information for
548            each packet is printed; however, that should be good
549            enough for all the purposes to which "-l" is put.
550
551            See the comment in "wtap_dispatch_cb_print()" for an
552            explanation of why we do that, and why we don't just
553            use "setvbuf()" to make the standard output line-buffered
554            (short version: in Windows, "line-buffered" is the same
555            as "fully-buffered", and the output buffer is only flushed
556            when it fills up). */
557         line_buffered = TRUE;
558         break;
559       case 'n':        /* No name resolution */
560         g_resolv_flags = RESOLV_NONE;
561         break;
562       case 'N':        /* Select what types of addresses/port #s to resolve */
563         if (g_resolv_flags == RESOLV_ALL)
564           g_resolv_flags = RESOLV_NONE;
565         badopt = string_to_name_resolve(optarg, &g_resolv_flags);
566         if (badopt != '\0') {
567           fprintf(stderr, "tethereal: -N specifies unknown resolving option '%c'; valid options are 'm', 'n', and 't'\n",
568                         badopt);
569           exit(1);
570         }
571         break;
572       case 'o':        /* Override preference from command line */
573         switch (prefs_set_pref(optarg)) {
574
575         case PREFS_SET_SYNTAX_ERR:
576           fprintf(stderr, "tethereal: Invalid -o flag \"%s\"\n", optarg);
577           exit(1);
578           break;
579
580         case PREFS_SET_NO_SUCH_PREF:
581         case PREFS_SET_OBSOLETE:
582           fprintf(stderr, "tethereal: -o flag \"%s\" specifies unknown preference\n",
583                         optarg);
584           exit(1);
585           break;
586         }
587         break;
588       case 'p':        /* Don't capture in promiscuous mode */
589 #ifdef HAVE_LIBPCAP
590         capture_opts.promisc_mode = FALSE;
591 #else
592         capture_option_specified = TRUE;
593         arg_error = TRUE;
594 #endif
595         break;
596       case 'q':        /* Quiet */
597         quiet = TRUE;
598         break;
599       case 'r':        /* Read capture file xxx */
600         cf_name = g_strdup(optarg);
601         break;
602       case 'R':        /* Read file filter */
603         rfilter = optarg;
604         break;
605       case 's':        /* Set the snapshot (capture) length */
606 #ifdef HAVE_LIBPCAP
607         capture_opts.snaplen = get_positive_int(optarg, "snapshot length");
608 #else
609         capture_option_specified = TRUE;
610         arg_error = TRUE;
611 #endif
612         break;
613       case 't':        /* Time stamp type */
614         if (strcmp(optarg, "r") == 0)
615           timestamp_type = RELATIVE;
616         else if (strcmp(optarg, "a") == 0)
617           timestamp_type = ABSOLUTE;
618         else if (strcmp(optarg, "ad") == 0)
619           timestamp_type = ABSOLUTE_WITH_DATE;
620         else if (strcmp(optarg, "d") == 0)
621           timestamp_type = DELTA;
622         else {
623           fprintf(stderr, "tethereal: Invalid time stamp type \"%s\"\n",
624             optarg);
625           fprintf(stderr, "It must be \"r\" for relative, \"a\" for absolute,\n");
626           fprintf(stderr, "\"ad\" for absolute with date, or \"d\" for delta.\n");
627           exit(1);
628         }
629         break;
630       case 'v':        /* Show version and exit */
631         printf("t%s %s, %s\n", PACKAGE, VERSION, comp_info_str->str);
632         exit(0);
633         break;
634       case 'w':        /* Write to capture file xxx */
635         cfile.save_file = g_strdup(optarg);
636         break;
637       case 'V':        /* Verbose */
638         verbose = TRUE;
639         break;
640       case 'x':        /* Print packet data in hex (and ASCII) */
641         print_hex = TRUE;
642         break;
643       default:
644       case '?':        /* Bad flag - print usage message */
645         arg_error = TRUE;
646         break;
647     }
648   }
649   
650   /* If no capture filter or read filter has been specified, and there are
651      still command-line arguments, treat them as the tokens of a capture
652      filter (if no "-r" flag was specified) or a read filter (if a "-r"
653      flag was specified. */
654   if (optind < argc) {
655     if (cf_name != NULL) {
656       if (rfilter != NULL) {
657         fprintf(stderr,
658 "tethereal: Read filters were specified both with \"-R\" and with additional command-line arguments\n");
659         exit(2);
660       }
661       rfilter = get_args_as_string(argc, argv, optind);
662     } else {
663 #ifdef HAVE_LIBPCAP
664       if (capture_filter_specified) {
665         fprintf(stderr,
666 "tethereal: Capture filters were specified both with \"-f\" and with additional command-line arguments\n");
667         exit(2);
668       }
669       cfile.cfilter = get_args_as_string(argc, argv, optind);
670 #else
671       capture_option_specified = TRUE;
672 #endif
673     }
674   }
675
676   /* See if we're writing a capture file and the file is a pipe */
677 #ifdef HAVE_LIBPCAP
678   ld.output_to_pipe = FALSE;
679 #endif
680   if (cfile.save_file != NULL) {
681     if (!strcmp(cfile.save_file, "-")) {
682       /* stdout */
683       g_free(cfile.save_file);
684       cfile.save_file = g_strdup("");
685 #ifdef HAVE_LIBPCAP
686       ld.output_to_pipe = TRUE;
687 #endif
688     }
689 #ifdef HAVE_LIBPCAP
690     else {
691       err = test_for_fifo(cfile.save_file);
692       switch (err) {
693   
694       case ENOENT:      /* it doesn't exist, so we'll be creating it,
695                            and it won't be a FIFO */
696       case 0:           /* found it, but it's not a FIFO */
697         break;
698   
699       case ESPIPE:      /* it is a FIFO */
700         ld.output_to_pipe = TRUE;
701         break;
702   
703       default:          /* couldn't stat it */
704         fprintf(stderr,
705                 "tethereal: Error testing whether capture file is a pipe: %s\n",
706                 strerror(errno));
707         exit(2);
708       }
709     }
710 #endif
711   }
712
713 #ifdef HAVE_LIBPCAP
714   /* If they didn't specify a "-w" flag, but specified a maximum capture
715      file size, tell them that this doesn't work, and exit. */
716   if (capture_opts.has_autostop_filesize && cfile.save_file == NULL) {
717     fprintf(stderr, "tethereal: Maximum capture file size specified, but "
718       "capture isn't being saved to a file.\n");
719     exit(2);
720   }
721
722   if (capture_opts.ringbuffer_on) {
723     /* Ring buffer works only under certain conditions:
724        a) ring buffer does not work if you're not saving the capture to
725           a file;
726        b) ring buffer only works if you're saving in libpcap format;
727        c) it makes no sense to enable the ring buffer if the maximum
728           file size is set to "infinite";
729        d) file must not be a pipe. */
730     if (cfile.save_file == NULL) {
731       fprintf(stderr, "tethereal: Ring buffer requested, but "
732         "capture isn't being saved to a file.\n");
733       exit(2);
734     }
735     if (out_file_type != WTAP_FILE_PCAP) {
736       fprintf(stderr, "tethereal: Ring buffer requested, but "
737         "capture isn't being saved in libpcap format.\n");
738       exit(2);
739     }
740     if (!capture_opts.has_autostop_filesize) {
741       fprintf(stderr, "tethereal: Ring buffer requested, but "
742         "no maximum capture file size was specified.\n");
743       exit(2);
744     }
745     if (ld.output_to_pipe) {
746       fprintf(stderr, "tethereal: Ring buffer requested, but "
747         "capture file is a pipe.\n");
748       exit(2);
749     }
750   }
751 #endif
752
753 #ifdef WIN32
754   /* Start windows sockets */
755   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
756 #endif
757
758   /* Notify all registered modules that have had any of their preferences
759      changed either from one of the preferences file or from the command
760      line that their preferences have changed. */
761   prefs_apply_all();
762
763 #ifndef HAVE_LIBPCAP
764   if (capture_option_specified)
765     fprintf(stderr, "This version of Tethereal was not built with support for capturing packets.\n");
766 #endif
767   if (arg_error) {
768     print_usage(FALSE);
769     exit(1);
770   }
771
772   /* Build the column format array */  
773   col_init(&cfile.cinfo, prefs->num_cols);
774   for (i = 0; i < cfile.cinfo.num_cols; i++) {
775     cfile.cinfo.col_fmt[i] = get_column_format(i);
776     cfile.cinfo.col_title[i] = g_strdup(get_column_title(i));
777     cfile.cinfo.fmt_matx[i] = (gboolean *) g_malloc0(sizeof(gboolean) *
778       NUM_COL_FMTS);
779     get_column_format_matches(cfile.cinfo.fmt_matx[i], cfile.cinfo.col_fmt[i]);
780     cfile.cinfo.col_data[i] = NULL;
781     if (cfile.cinfo.col_fmt[i] == COL_INFO)
782       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_INFO_LEN);
783     else
784       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
785
786     cfile.cinfo.col_expr[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
787     cfile.cinfo.col_expr_val[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
788   }
789
790 #ifdef HAVE_LIBPCAP
791   if (capture_opts.snaplen < 1)
792     capture_opts.snaplen = WTAP_MAX_PACKET_SIZE;
793   else if (capture_opts.snaplen < MIN_PACKET_SIZE)
794     capture_opts.snaplen = MIN_PACKET_SIZE;
795   
796   /* Check the value range of the ringbuffer_num_files parameter */
797   if (capture_opts.ringbuffer_num_files < RINGBUFFER_MIN_NUM_FILES)
798     capture_opts.ringbuffer_num_files = RINGBUFFER_MIN_NUM_FILES;
799   else if (capture_opts.ringbuffer_num_files > RINGBUFFER_MAX_NUM_FILES)
800     capture_opts.ringbuffer_num_files = RINGBUFFER_MAX_NUM_FILES;
801 #endif
802   
803   if (rfilter != NULL) {
804     if (!dfilter_compile(rfilter, &rfcode)) {
805       fprintf(stderr, "tethereal: %s\n", dfilter_error_msg);
806       epan_cleanup();
807       exit(2);
808     }
809   }
810   cfile.rfcode = rfcode;
811   if (cf_name) {
812     err = open_cap_file(cf_name, FALSE, &cfile);
813     if (err != 0) {
814       epan_cleanup();
815       exit(2);
816     }
817     err = load_cap_file(&cfile, out_file_type);
818     if (err != 0) {
819       epan_cleanup();
820       exit(2);
821     }
822     cf_name[0] = '\0';
823   } else {
824     /* No capture file specified, so we're supposed to do a live capture;
825        do we have support for live captures? */
826 #ifdef HAVE_LIBPCAP
827
828 #ifdef _WIN32
829     if (!has_wpcap) {
830         fprintf(stderr, "tethereal: Could not load wpcap.dll.\n");
831         exit(2);
832     }
833 #endif
834
835     /* Yes; did the user specify an interface to use? */
836     if (cfile.iface == NULL) {
837         /* No - is a default specified in the preferences file? */
838         if (prefs->capture_device != NULL) {
839             /* Yes - use it. */
840             if_text = strrchr(prefs->capture_device, ' ');
841             if (if_text == NULL) {
842                 cfile.iface = g_strdup(prefs->capture_device);
843             } else {
844                 cfile.iface = g_strdup(if_text + 1); /* Skip over space */
845             }
846         } else {
847             /* No - pick the first one from the list of interfaces. */
848             if_list = get_interface_list(&err, err_str);
849             if (if_list == NULL) {
850                 switch (err) {
851
852                 case CANT_GET_INTERFACE_LIST:
853                     fprintf(stderr, "tethereal: Can't get list of interfaces: %s\n",
854                             err_str);
855                     break;
856
857                 case NO_INTERFACES_FOUND:
858                     fprintf(stderr, "tethereal: There are no interfaces on which a capture can be done\n");
859                     break;
860                 }
861                 exit(2);
862             }
863             if_text = strrchr(if_list->data, ' ');      /* first interface */
864             if (if_text == NULL) {
865                 cfile.iface = g_strdup(if_list->data);
866             } else {
867                 cfile.iface = g_strdup(if_text + 1); /* Skip over space */
868             }
869             free_interface_list(if_list);
870         }
871     }
872     capture(out_file_type);
873
874     if (capture_opts.ringbuffer_on) {
875       ringbuf_free();
876     }
877 #else
878     /* No - complain. */
879     fprintf(stderr, "This version of Tethereal was not built with support for capturing packets.\n");
880     exit(2);
881 #endif
882   }
883
884   epan_cleanup();
885
886   return 0;
887 }
888
889 #ifdef HAVE_LIBPCAP
890 /* Do the low-level work of a capture.
891    Returns TRUE if it succeeds, FALSE otherwise. */
892 static int
893 capture(int out_file_type)
894 {
895   gchar       open_err_str[PCAP_ERRBUF_SIZE];
896   gchar       lookup_net_err_str[PCAP_ERRBUF_SIZE];
897   bpf_u_int32 netnum, netmask;
898   struct bpf_program fcode;
899   void        (*oldhandler)(int);
900   int         err = 0;
901   int         volatile volatile_err = 0;
902   int         volatile inpkts = 0;
903   int         pcap_cnt;
904   char        errmsg[1024+1];
905   condition  *volatile cnd_stop_capturesize = NULL;
906   condition  *volatile cnd_stop_timeout = NULL;
907 #ifndef _WIN32
908   static const char ppamsg[] = "can't find PPA for ";
909   char       *libpcap_warn;
910 #endif
911   struct pcap_stat stats;
912   gboolean    write_err;
913   gboolean    dump_ok;
914
915   /* Initialize all data structures used for dissection. */
916   init_dissection();
917
918   ld.linktype       = WTAP_ENCAP_UNKNOWN;
919   ld.pdh            = NULL;
920
921   /* Open the network interface to capture from it.
922      Some versions of libpcap may put warnings into the error buffer
923      if they succeed; to tell if that's happened, we have to clear
924      the error buffer, and check if it's still a null string.  */
925   open_err_str[0] = '\0';
926   ld.pch = pcap_open_live(cfile.iface, capture_opts.snaplen,
927                           capture_opts.promisc_mode, 1000, open_err_str);
928
929   if (ld.pch == NULL) {
930     /* Well, we couldn't start the capture. */
931 #ifdef _WIN32
932     /* On Win32 OSes, the capture devices are probably available to all
933        users; don't warn about permissions problems.
934
935        Do, however, warn that Token Ring and PPP devices aren't supported. */
936     snprintf(errmsg, sizeof errmsg,
937         "The capture session could not be initiated (%s).\n"
938         "Please check that you have the proper interface specified.\n"
939         "\n"
940         "Note that the driver Tethereal uses for packet capture on Windows\n"
941         "doesn't support capturing on Token Ring interfaces, and doesn't\n"
942         "support capturing on PPP/WAN interfaces in Windows NT/2000.\n",
943         open_err_str);
944 #else
945       /* If we got a "can't find PPA for XXX" message, warn the user (who
946          is running Ethereal on HP-UX) that they don't have a version
947          of libpcap that properly handles HP-UX (libpcap 0.6.x and later
948          versions, which properly handle HP-UX, say "can't find /dev/dlpi
949          PPA for XXX" rather than "can't find PPA for XXX"). */
950       if (strncmp(open_err_str, ppamsg, sizeof ppamsg - 1) == 0)
951         libpcap_warn =
952           "\n\n"
953           "You are running Tethereal with a version of the libpcap library\n"
954           "that doesn't handle HP-UX network devices well; this means that\n"
955           "Tethereal may not be able to capture packets.\n"
956           "\n"
957           "To fix this, you should install libpcap 0.6.2, or a later version\n"
958           "of libpcap, rather than libpcap 0.4 or 0.5.x.  It is available in\n"
959           "packaged binary form from the Software Porting And Archive Centre\n"
960           "for HP-UX; the Centre is at http://hpux.connect.org.uk/ - the page\n"
961           "at the URL lists a number of mirror sites.";
962       else
963         libpcap_warn = "";
964     snprintf(errmsg, sizeof errmsg,
965       "The capture session could not be initiated (%s).\n"
966       "Please check to make sure you have sufficient permissions, and that\n"
967       "you have the proper interface specified.%s", open_err_str, libpcap_warn);
968 #endif
969     goto error;
970   }
971
972   if (cfile.cfilter) {
973     /* A capture filter was specified; set it up. */
974     if (pcap_lookupnet(cfile.iface, &netnum, &netmask, lookup_net_err_str) < 0) {
975       /*
976        * Well, we can't get the netmask for this interface; it's used
977        * only for filters that check for broadcast IP addresses, so
978        * we just warn the user, and punt and use 0.
979        */
980       fprintf(stderr, 
981         "Warning:  Couldn't obtain netmask info (%s).\n", lookup_net_err_str);
982       netmask = 0;
983     }
984     if (pcap_compile(ld.pch, &fcode, cfile.cfilter, 1, netmask) < 0) {
985       snprintf(errmsg, sizeof errmsg, "Unable to parse filter string (%s).",
986         pcap_geterr(ld.pch));
987       goto error;
988     }
989     if (pcap_setfilter(ld.pch, &fcode) < 0) {
990       snprintf(errmsg, sizeof errmsg, "Can't install filter (%s).",
991         pcap_geterr(ld.pch));
992       goto error;
993     }
994   }
995
996   ld.linktype = wtap_pcap_encap_to_wtap_encap(get_pcap_linktype(ld.pch,
997         cfile.iface));
998   if (cfile.save_file != NULL) {
999     /* Set up to write to the capture file. */
1000     if (ld.linktype == WTAP_ENCAP_UNKNOWN) {
1001       strcpy(errmsg, "The network you're capturing from is of a type"
1002                " that Tethereal doesn't support.");
1003       goto error;
1004     }
1005     if (capture_opts.ringbuffer_on) {
1006       cfile.save_file_fd = ringbuf_init(cfile.save_file,
1007         capture_opts.ringbuffer_num_files);
1008       if (cfile.save_file_fd != -1) {
1009         ld.pdh = ringbuf_init_wtap_dump_fdopen(out_file_type, ld.linktype,
1010           pcap_snapshot(ld.pch), &err);
1011       } else {
1012         err = errno;    /* "ringbuf_init()" failed */
1013         ld.pdh = NULL;
1014       }
1015     } else {
1016       ld.pdh = wtap_dump_open(cfile.save_file, out_file_type,
1017                  ld.linktype, pcap_snapshot(ld.pch), &err);
1018     }
1019
1020     if (ld.pdh == NULL) {
1021       snprintf(errmsg, sizeof errmsg,
1022                file_open_error_message(err, TRUE, out_file_type),
1023                *cfile.save_file == '\0' ? "stdout" : cfile.save_file);
1024       goto error;
1025     }
1026   }
1027
1028   /* Does "open_err_str" contain a non-empty string?  If so, "pcap_open_live()"
1029      returned a warning; print it, but keep capturing. */
1030   if (open_err_str[0] != '\0')
1031     fprintf(stderr, "tethereal: WARNING: %s.\n", open_err_str);
1032
1033 #ifdef _WIN32
1034   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
1035   SetConsoleCtrlHandler(capture_cleanup, TRUE);
1036 #else /* _WIN32 */
1037   /* Catch SIGINT and SIGTERM and, if we get either of them, clean up
1038      and exit.
1039      XXX - deal with signal semantics on various UNIX platforms.  Or just
1040      use "sigaction()" and be done with it? */
1041   signal(SIGTERM, capture_cleanup);
1042   signal(SIGINT, capture_cleanup);
1043   if ((oldhandler = signal(SIGHUP, capture_cleanup)) != SIG_DFL)
1044     signal(SIGHUP, oldhandler);
1045 #endif /* _WIN32 */
1046
1047   /* Let the user know what interface was chosen. */
1048   fprintf(stderr, "Capturing on %s\n", cfile.iface);
1049
1050   /* initialize capture stop conditions */ 
1051   init_capture_stop_conditions();
1052   /* create stop conditions */
1053   if (capture_opts.has_autostop_filesize)
1054     cnd_stop_capturesize = cnd_new((char*)CND_CLASS_CAPTURESIZE,
1055                                    (long)capture_opts.autostop_filesize * 1000);
1056   if (capture_opts.has_autostop_duration)
1057     cnd_stop_timeout = cnd_new((char*)CND_CLASS_TIMEOUT,
1058                                (gint32)capture_opts.autostop_duration);
1059
1060   if (!setjmp(ld.stopenv))
1061     ld.go = TRUE;
1062   else
1063     ld.go = FALSE;
1064   ld.packet_count = 0;
1065   while (ld.go) {
1066     /* We need to be careful with automatic variables defined in the
1067        outer scope which are changed inside the loop.  Most compilers
1068        don't try to roll them back to their original values after the
1069        longjmp which causes the loop to finish, but all that the
1070        standards say is that their values are indeterminate.  If we
1071        don't want them to be rolled back, we should define them with the
1072        volatile attribute (paraphrasing W. Richard Stevens, Advanced
1073        Programming in the UNIX Environment, p. 178).
1074
1075        The "err" variable causes a particular problem.  If we give it
1076        the volatile attribute, then when we pass a reference to it (as
1077        in "&err") to a function, GCC warns: "passing arg <n> of
1078        <function> discards qualifiers from pointer target type".
1079        Therefore within the loop and just beyond we don't use "err".
1080        Within the loop we define "loop_err", and assign its value to
1081        "volatile_err", which is in the outer scope and is checked when
1082        the loop finishes.
1083
1084        We also define "packet_count_prev" here to keep things tidy,
1085        since it's used only inside the loop.  If it were defined in the
1086        outer scope, GCC would give a warning (unnecessary in this case)
1087        that it might be clobbered, and we'd need to give it the volatile
1088        attribute to suppress the warning. */
1089
1090     int loop_err = 0;
1091     int packet_count_prev = 0;
1092
1093     if (cnd_stop_capturesize == NULL && cnd_stop_timeout == NULL) {
1094       /* We're not stopping at a particular capture file size, and we're
1095          not stopping after some particular amount of time has expired,
1096          so either we have no stop condition or the only stop condition
1097          is a maximum packet count.
1098
1099          If there's no maximum packet count, pass it -1, meaning "until
1100          you run out of packets in the bufferful you read".  Otherwise,
1101          pass it the number of packets we have left to capture.
1102
1103          We don't call "pcap_loop()" as, if we're saving to a file that's
1104          a FIFO, we want to flush the FIFO after we're done processing
1105          this libpcap bufferful of packets, so that the program
1106          reading the FIFO sees the packets immediately and doesn't get
1107          any partial packet, forcing it to block in the middle of reading
1108          that packet. */
1109       if (capture_opts.autostop_count == 0)
1110         pcap_cnt = -1;
1111       else {
1112         if (ld.packet_count >= capture_opts.autostop_count) {
1113           /* XXX do we need this test here? */
1114           /* It appears there's nothing more to capture. */
1115           break;
1116         }
1117         pcap_cnt = capture_opts.autostop_count - ld.packet_count;
1118       }
1119     } else {
1120       /* We need to check the capture file size or the timeout after
1121          each packet. */
1122       pcap_cnt = 1;
1123     }
1124     inpkts = pcap_dispatch(ld.pch, pcap_cnt, capture_pcap_cb, (guchar *) &ld);
1125     if (inpkts < 0) {
1126       /* Error from "pcap_dispatch()". */
1127       ld.go = FALSE;
1128     } else if (cnd_stop_timeout != NULL && cnd_eval(cnd_stop_timeout)) {
1129       /* The specified capture time has elapsed; stop the capture. */
1130       ld.go = FALSE;
1131     } else if (inpkts > 0) {
1132       if (capture_opts.autostop_count != 0 &&
1133                  ld.packet_count >= capture_opts.autostop_count) {
1134         /* The specified number of packets have been captured and have
1135            passed both any capture filter in effect and any read filter
1136            in effect. */
1137         ld.go = FALSE;
1138       } else if (cnd_stop_capturesize != NULL &&
1139                     cnd_eval(cnd_stop_capturesize, 
1140                               (guint32)wtap_get_bytes_dumped(ld.pdh))) {
1141         /* We're saving the capture to a file, and the capture file reached
1142            its maximum size. */
1143         if (capture_opts.ringbuffer_on) {
1144           /* Switch to the next ringbuffer file */
1145           if (ringbuf_switch_file(&cfile, &ld.pdh, &loop_err)) {
1146             /* File switch succeeded: reset the condition */
1147             cnd_reset(cnd_stop_capturesize);
1148           } else {
1149             /* File switch failed: stop here */
1150             volatile_err = loop_err;
1151             ld.go = FALSE;
1152           }
1153         } else {
1154           /* No ringbuffer - just stop. */
1155           ld.go = FALSE;
1156         }
1157       }
1158       if (ld.output_to_pipe) {
1159         if (ld.packet_count > packet_count_prev) {
1160           if (fflush(wtap_dump_file(ld.pdh))) {
1161             volatile_err = errno;
1162             ld.go = FALSE;
1163           }
1164           packet_count_prev = ld.packet_count;
1165         }
1166       }
1167     } /* inpkts > 0 */
1168   } /* while (ld.go) */
1169   
1170   /* delete stop conditions */
1171   if (cnd_stop_capturesize != NULL)
1172     cnd_delete(cnd_stop_capturesize);
1173   if (cnd_stop_timeout != NULL)
1174     cnd_delete(cnd_stop_timeout);
1175
1176   if ((cfile.save_file != NULL) && !quiet) {
1177     /* We're saving to a file, which means we're printing packet counts
1178        to stderr if we are not running silent and deep.
1179        Send a newline so that we move to the line after the packet count. */
1180     fprintf(stderr, "\n");
1181   }
1182
1183   /* If we got an error while capturing, report it. */
1184   if (inpkts < 0) {
1185     fprintf(stderr, "tethereal: Error while capturing packets: %s\n",
1186         pcap_geterr(ld.pch));
1187   }
1188
1189   if (volatile_err == 0)
1190     write_err = FALSE;
1191   else {
1192     show_capture_file_io_error(cfile.save_file, volatile_err, FALSE);
1193     write_err = TRUE;
1194   }
1195
1196   if (cfile.save_file != NULL) {
1197     /* We're saving to a file or files; close all files. */
1198     if (capture_opts.ringbuffer_on) {
1199       dump_ok = ringbuf_wtap_dump_close(&cfile, &err);
1200     } else {
1201       dump_ok = wtap_dump_close(ld.pdh, &err);
1202     }
1203     /* If we've displayed a message about a write error, there's no point
1204        in displaying another message about an error on close. */
1205     if (!dump_ok && !write_err)
1206       show_capture_file_io_error(cfile.save_file, err, TRUE);
1207   }
1208
1209   /* Get the capture statistics, and, if any packets were dropped, report
1210      that. */
1211   if (pcap_stats(ld.pch, &stats) >= 0) {
1212     if (stats.ps_drop != 0) {
1213       fprintf(stderr, "%u packets dropped\n", stats.ps_drop);
1214     }
1215   } else {
1216     fprintf(stderr, "tethereal: Can't get packet-drop statistics: %s\n",
1217         pcap_geterr(ld.pch));
1218   }
1219   /* Report the number of captured packets if not reported during capture
1220      and we are saving to a file. */
1221   if (quiet && (cfile.save_file != NULL)) {
1222     fprintf(stderr, "%u packets captured\n", ld.packet_count);
1223   }
1224
1225   pcap_close(ld.pch);
1226
1227   return TRUE;
1228
1229 error:
1230   if (capture_opts.ringbuffer_on) {
1231     ringbuf_error_cleanup();
1232   }
1233   g_free(cfile.save_file);
1234   cfile.save_file = NULL;
1235   fprintf(stderr, "tethereal: %s\n", errmsg);
1236   if (ld.pch != NULL)
1237     pcap_close(ld.pch);
1238
1239   return FALSE;
1240 }
1241
1242 static void
1243 capture_pcap_cb(guchar *user, const struct pcap_pkthdr *phdr,
1244   const guchar *pd)
1245 {
1246   struct wtap_pkthdr whdr;
1247   union wtap_pseudo_header pseudo_header;
1248   loop_data *ld = (loop_data *) user;
1249   cb_args_t args;
1250   int err;
1251
1252   /* Convert from libpcap to Wiretap format.
1253      If that fails, ignore the packet (wtap_process_pcap_packet has
1254      written an error message). */
1255   pd = wtap_process_pcap_packet(ld->linktype, phdr, pd, &pseudo_header,
1256                                 &whdr, &err);
1257   if (pd == NULL) {
1258     return;
1259   }
1260
1261   args.cf = &cfile;
1262   args.pdh = ld->pdh;
1263   if (ld->pdh) {
1264     wtap_dispatch_cb_write((guchar *)&args, &whdr, 0, &pseudo_header, pd);
1265     /* Report packet capture count if not quiet */
1266     if (!quiet) {
1267       if (ld->packet_count != 0) {
1268         fprintf(stderr, "\r%u ", ld->packet_count);
1269         /* stderr could be line buffered */
1270         fflush(stderr);
1271       }
1272     }
1273   } else {
1274     wtap_dispatch_cb_print((guchar *)&args, &whdr, 0, &pseudo_header, pd);
1275   }
1276 }
1277
1278 #ifdef _WIN32
1279 static BOOL WINAPI
1280 capture_cleanup(DWORD ctrltype _U_)
1281 {
1282   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
1283      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
1284      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
1285      like SIGTERM at least when the machine's shutting down.
1286
1287      For now, we handle them all as indications that we should clean up
1288      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
1289      way on UNIX.
1290
1291      However, as handlers run in a new thread, we can't just longjmp
1292      out; we have to set "ld.go" to FALSE, and must return TRUE so that
1293      no other handler - such as one that would terminate the process -
1294      gets called.
1295
1296      XXX - for some reason, typing ^C to Tethereal, if you run this in
1297      a Cygwin console window in at least some versions of Cygwin,
1298      causes Tethereal to terminate immediately; this routine gets
1299      called, but the main loop doesn't get a chance to run and
1300      exit cleanly, at least if this is compiled with Microsoft Visual
1301      C++ (i.e., it's a property of the Cygwin console window or Bash;
1302      it happens if Tethereal is not built with Cygwin - for all I know,
1303      building it with Cygwin may make the problem go away). */
1304   ld.go = FALSE;
1305   return TRUE;
1306 }
1307 #else
1308 static void
1309 capture_cleanup(int signum _U_)
1310 {
1311   /* Longjmp back to the starting point; "pcap_dispatch()", on many
1312      UNIX platforms, just keeps looping if it gets EINTR, so if we set
1313      "ld.go" to FALSE and return, we won't break out of it and quit
1314      capturing. */
1315   longjmp(ld.stopenv, 1);
1316 }
1317 #endif /* _WIN32 */
1318 #endif /* HAVE_LIBPCAP */
1319
1320 static int
1321 load_cap_file(capture_file *cf, int out_file_type)
1322 {
1323   gint         linktype;
1324   int          snapshot_length;
1325   wtap_dumper *pdh;
1326   int          err;
1327   int          success;
1328   cb_args_t    args;
1329
1330   linktype = wtap_file_encap(cf->wth);
1331   if (cf->save_file != NULL) {
1332     /* Set up to write to the capture file. */
1333     snapshot_length = wtap_snapshot_length(cf->wth);
1334     if (snapshot_length == 0) {
1335       /* Snapshot length of input file not known. */
1336       snapshot_length = WTAP_MAX_PACKET_SIZE;
1337     }
1338     pdh = wtap_dump_open(cf->save_file, out_file_type,
1339                 linktype, snapshot_length, &err);
1340
1341     if (pdh == NULL) {
1342       /* We couldn't set up to write to the capture file. */
1343       switch (err) {
1344
1345       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
1346         fprintf(stderr,
1347                 "tethereal: Capture files can't be written in that format.\n");
1348         break;
1349
1350       case WTAP_ERR_UNSUPPORTED_ENCAP:
1351       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
1352         fprintf(stderr,
1353           "tethereal: The capture file being read cannot be written in "
1354           "that format.\n");
1355         break;
1356
1357       case WTAP_ERR_CANT_OPEN:
1358         fprintf(stderr,
1359           "tethereal: The file \"%s\" couldn't be created for some "
1360           "unknown reason.\n",
1361             *cf->save_file == '\0' ? "stdout" : cf->save_file);
1362         break;
1363
1364       case WTAP_ERR_SHORT_WRITE:
1365         fprintf(stderr,
1366           "tethereal: A full header couldn't be written to the file \"%s\".\n",
1367                 *cf->save_file == '\0' ? "stdout" : cf->save_file);
1368         break;
1369
1370       default:
1371         fprintf(stderr,
1372           "tethereal: The file \"%s\" could not be created: %s\n.",
1373                 *cf->save_file == '\0' ? "stdout" : cf->save_file,
1374                 wtap_strerror(err));
1375         break;
1376       }
1377       goto out;
1378     }
1379     args.cf = cf;
1380     args.pdh = pdh;
1381     success = wtap_loop(cf->wth, 0, wtap_dispatch_cb_write, (guchar *) &args,
1382                         &err);
1383
1384     /* Now close the capture file. */
1385     if (!wtap_dump_close(pdh, &err))
1386       show_capture_file_io_error(cfile.save_file, err, TRUE);
1387   } else {
1388     args.cf = cf;
1389     args.pdh = NULL;
1390     success = wtap_loop(cf->wth, 0, wtap_dispatch_cb_print, (guchar *) &args,
1391                         &err);
1392   }
1393   if (!success) {
1394     /* Print up a message box noting that the read failed somewhere along
1395        the line. */
1396     switch (err) {
1397
1398     case WTAP_ERR_UNSUPPORTED_ENCAP:
1399       fprintf(stderr,
1400 "tethereal: \"%s\" is a capture file is for a network type that Tethereal doesn't support.\n",
1401         cf->filename);
1402       break;
1403
1404     case WTAP_ERR_CANT_READ:
1405       fprintf(stderr,
1406 "tethereal: An attempt to read from \"%s\" failed for some unknown reason.\n",
1407         cf->filename);
1408       break;
1409
1410     case WTAP_ERR_SHORT_READ:
1411       fprintf(stderr,
1412 "tethereal: \"%s\" appears to have been cut short in the middle of a packet.\n",
1413         cf->filename);
1414       break;
1415
1416     case WTAP_ERR_BAD_RECORD:
1417       fprintf(stderr,
1418 "tethereal: \"%s\" appears to be damaged or corrupt.\n",
1419         cf->filename);
1420       break;
1421
1422     default:
1423       fprintf(stderr,
1424 "tethereal: An error occurred while reading \"%s\": %s.\n",
1425         cf->filename, wtap_strerror(err));
1426       break;
1427     }
1428   }
1429
1430 out:
1431   wtap_close(cf->wth);
1432   cf->wth = NULL;
1433
1434   return err;
1435 }
1436
1437 static void
1438 fill_in_fdata(frame_data *fdata, capture_file *cf,
1439         const struct wtap_pkthdr *phdr, long offset)
1440 {
1441   fdata->next = NULL;
1442   fdata->prev = NULL;
1443   fdata->pfd = NULL;
1444   fdata->num = cf->count;
1445   fdata->pkt_len = phdr->len;
1446   fdata->cap_len = phdr->caplen;
1447   fdata->file_off = offset;
1448   fdata->lnk_t = phdr->pkt_encap;
1449   fdata->abs_secs  = phdr->ts.tv_sec;
1450   fdata->abs_usecs = phdr->ts.tv_usec;
1451   fdata->flags.passed_dfilter = 0;
1452   fdata->flags.encoding = CHAR_ASCII;
1453   fdata->flags.visited = 0;
1454   fdata->flags.marked = 0;
1455
1456   /* If we don't have the time stamp of the first packet in the
1457      capture, it's because this is the first packet.  Save the time
1458      stamp of this packet as the time stamp of the first packet. */
1459   if (!firstsec && !firstusec) {
1460     firstsec  = fdata->abs_secs;
1461     firstusec = fdata->abs_usecs;
1462   }
1463
1464   /* If we don't have the time stamp of the previous displayed packet,
1465      it's because this is the first displayed packet.  Save the time
1466      stamp of this packet as the time stamp of the previous displayed
1467      packet. */
1468   if (!prevsec && !prevusec) {
1469     prevsec  = fdata->abs_secs;
1470     prevusec = fdata->abs_usecs;
1471   }
1472
1473   /* Get the time elapsed between the first packet and this packet. */
1474   compute_timestamp_diff(&fdata->rel_secs, &fdata->rel_usecs,
1475                 fdata->abs_secs, fdata->abs_usecs, firstsec, firstusec);
1476
1477   /* If it's greater than the current elapsed time, set the elapsed time
1478      to it (we check for "greater than" so as not to be confused by
1479      time moving backwards). */
1480   if ((gint32)cf->esec < fdata->rel_secs
1481         || ((gint32)cf->esec == fdata->rel_secs && (gint32)cf->eusec < fdata->rel_usecs)) {
1482     cf->esec = fdata->rel_secs;
1483     cf->eusec = fdata->rel_usecs;
1484   }
1485   
1486   /* Get the time elapsed between the previous displayed packet and
1487      this packet. */
1488   compute_timestamp_diff(&fdata->del_secs, &fdata->del_usecs,
1489                 fdata->abs_secs, fdata->abs_usecs, prevsec, prevusec);
1490   prevsec = fdata->abs_secs;
1491   prevusec = fdata->abs_usecs;
1492 }
1493
1494 /* Free up all data attached to a "frame_data" structure. */
1495 static void
1496 clear_fdata(frame_data *fdata)
1497 {
1498   if (fdata->pfd)
1499     g_slist_free(fdata->pfd);
1500 }
1501
1502 static void
1503 wtap_dispatch_cb_write(guchar *user, const struct wtap_pkthdr *phdr,
1504   long offset, union wtap_pseudo_header *pseudo_header, const guchar *buf)
1505 {
1506   cb_args_t    *args = (cb_args_t *) user;
1507   capture_file *cf = args->cf;
1508   wtap_dumper  *pdh = args->pdh;
1509   frame_data    fdata;
1510   int           err;
1511   gboolean      passed;
1512   epan_dissect_t *edt;
1513
1514   cf->count++;
1515   if (cf->rfcode) {
1516     fill_in_fdata(&fdata, cf, phdr, offset);
1517     edt = epan_dissect_new(TRUE, FALSE);
1518     epan_dissect_prime_dfilter(edt, cf->rfcode);
1519     epan_dissect_run(edt, pseudo_header, buf, &fdata, NULL);
1520     passed = dfilter_apply_edt(cf->rfcode, edt);
1521   } else {
1522     passed = TRUE;
1523     edt = NULL;
1524   }
1525   if (passed) {
1526     /* The packet passed the read filter. */
1527 #ifdef HAVE_LIBPCAP
1528     ld.packet_count++;
1529 #endif
1530     if (!wtap_dump(pdh, phdr, pseudo_header, buf, &err)) {
1531 #ifdef HAVE_LIBPCAP
1532       if (ld.pch != NULL && !quiet) {
1533         /* We're capturing packets, so (if -q not specified) we're printing
1534            a count of packets captured; move to the line after the count. */
1535         fprintf(stderr, "\n");
1536       }
1537 #endif
1538       show_capture_file_io_error(cf->save_file, err, FALSE);
1539 #ifdef HAVE_LIBPCAP
1540       if (ld.pch != NULL)
1541         pcap_close(ld.pch);
1542 #endif
1543       wtap_dump_close(pdh, &err);
1544       exit(2);
1545     }
1546   }
1547   if (edt != NULL)
1548     epan_dissect_free(edt);
1549   if (cf->rfcode)
1550     clear_fdata(&fdata);
1551 }
1552
1553 static void
1554 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
1555 {
1556   if (*fname == '\0')
1557     fname = "stdout";
1558
1559   switch (err) {
1560
1561   case ENOSPC:
1562     fprintf(stderr,
1563 "tethereal: Not all the packets could be written to \"%s\" because there is "
1564 "no space left on the file system.\n",
1565         fname);
1566     break;
1567
1568 #ifdef EDQUOT
1569   case EDQUOT:
1570     fprintf(stderr,
1571 "tethereal: Not all the packets could be written to \"%s\" because you are "
1572 "too close to, or over your disk quota.\n",
1573         fname);
1574   break;
1575 #endif
1576
1577   case WTAP_ERR_CANT_CLOSE:
1578     fprintf(stderr,
1579 "tethereal: \"%s\" couldn't be closed for some unknown reason.\n",
1580         fname);
1581     break;
1582
1583   case WTAP_ERR_SHORT_WRITE:
1584     fprintf(stderr,
1585 "tethereal: Not all the packets could be written to \"%s\".\n",
1586         fname);
1587     break;
1588
1589   default:
1590     if (is_close) {
1591       fprintf(stderr,
1592 "tethereal: \"%s\" could not be closed: %s.\n",
1593         fname, wtap_strerror(err));
1594     } else {
1595       fprintf(stderr,
1596 "tethereal: An error occurred while writing to \"%s\": %s.\n",
1597         fname, wtap_strerror(err));
1598     }
1599     break;
1600   }
1601 }
1602
1603 static void
1604 wtap_dispatch_cb_print(guchar *user, const struct wtap_pkthdr *phdr,
1605   long offset, union wtap_pseudo_header *pseudo_header, const guchar *buf)
1606 {
1607   cb_args_t    *args = (cb_args_t *) user;
1608   capture_file *cf = args->cf;
1609   frame_data    fdata;
1610   gboolean      passed;
1611   print_args_t  print_args;
1612   epan_dissect_t *edt;
1613   gboolean      create_proto_tree;
1614   int           i;
1615
1616   cf->count++;
1617
1618   fill_in_fdata(&fdata, cf, phdr, offset);
1619
1620   passed = TRUE;
1621   if (cf->rfcode || verbose)
1622     create_proto_tree = TRUE;
1623   else
1624     create_proto_tree = FALSE;
1625   /* The protocol tree will be "visible", i.e., printed, only if we're
1626      not printing a summary.
1627
1628      We only need the columns if we're *not* verbose; in verbose mode,
1629      we print the protocol tree, not the protocol summary. */
1630   edt = epan_dissect_new(create_proto_tree, verbose);
1631   if (cf->rfcode) {
1632     epan_dissect_prime_dfilter(edt, cf->rfcode);
1633   }
1634   epan_dissect_run(edt, pseudo_header, buf, &fdata, verbose ? NULL : &cf->cinfo);
1635   if (cf->rfcode) {
1636     passed = dfilter_apply_edt(cf->rfcode, edt);
1637   }
1638   if (passed) {
1639     /* The packet passed the read filter. */
1640 #ifdef HAVE_LIBPCAP
1641     ld.packet_count++;
1642 #endif
1643     if (verbose) {
1644       /* Print the information in the protocol tree. */
1645       print_args.to_file = TRUE;
1646       print_args.format = PR_FMT_TEXT;
1647       print_args.print_summary = FALSE;
1648       print_args.print_hex = print_hex;
1649       print_args.expand_all = TRUE;
1650       print_args.suppress_unmarked = FALSE;
1651       proto_tree_print(&print_args, edt, stdout);
1652       if (!print_hex) {
1653         /* "print_hex_data()" will put out a leading blank line, as well
1654            as a trailing one; print one here, to separate the packets,
1655            only if "print_hex_data()" won't be called. */
1656         printf("\n");
1657       }
1658     } else {
1659       /* Just fill in the columns. */
1660       epan_dissect_fill_in_columns(edt);
1661
1662       /* Now print them. */
1663       for (i = 0; i < cf->cinfo.num_cols; i++) {
1664         switch (cf->cinfo.col_fmt[i]) {
1665         case COL_NUMBER:
1666           /*
1667            * Don't print this if we're doing a live capture from a network
1668            * interface - if we're doing a live capture, you won't be
1669            * able to look at the capture in the future (it's not being
1670            * saved anywhere), so the frame numbers are unlikely to be
1671            * useful.
1672            *
1673            * (XXX - it might be nice to be able to save and print at
1674            * the same time, sort of like an "Update list of packets
1675            * in real time" capture in Ethereal.)
1676            */
1677           if (cf->iface != NULL)
1678             continue;
1679           printf("%3s", cf->cinfo.col_data[i]);
1680           break;
1681
1682         case COL_CLS_TIME:
1683         case COL_REL_TIME:
1684         case COL_ABS_TIME:
1685         case COL_ABS_DATE_TIME: /* XXX - wider */
1686           printf("%10s", cf->cinfo.col_data[i]);
1687           break;
1688
1689         case COL_DEF_SRC:
1690         case COL_RES_SRC:
1691         case COL_UNRES_SRC:
1692         case COL_DEF_DL_SRC:
1693         case COL_RES_DL_SRC:
1694         case COL_UNRES_DL_SRC:
1695         case COL_DEF_NET_SRC:
1696         case COL_RES_NET_SRC:
1697         case COL_UNRES_NET_SRC:
1698           printf("%12s", cf->cinfo.col_data[i]);
1699           break;
1700
1701         case COL_DEF_DST:
1702         case COL_RES_DST:
1703         case COL_UNRES_DST:
1704         case COL_DEF_DL_DST:
1705         case COL_RES_DL_DST:
1706         case COL_UNRES_DL_DST:
1707         case COL_DEF_NET_DST:
1708         case COL_RES_NET_DST:
1709         case COL_UNRES_NET_DST:
1710           printf("%-12s", cf->cinfo.col_data[i]);
1711           break;
1712
1713         default:
1714           printf("%s", cf->cinfo.col_data[i]);
1715           break;
1716         }
1717         if (i != cf->cinfo.num_cols - 1) {
1718           /*
1719            * This isn't the last column, so we need to print a
1720            * separator between this column and the next.
1721            *
1722            * If we printed a network source and are printing a
1723            * network destination of the same type next, separate
1724            * them with "->"; if we printed a network destination
1725            * and are printing a network source of the same type
1726            * next, separate them with "<-"; otherwise separate them
1727            * with a space.
1728            */
1729           switch (cf->cinfo.col_fmt[i]) {
1730
1731           case COL_DEF_SRC:
1732           case COL_RES_SRC:
1733           case COL_UNRES_SRC:
1734             switch (cf->cinfo.col_fmt[i + 1]) {
1735
1736             case COL_DEF_DST:
1737             case COL_RES_DST:
1738             case COL_UNRES_DST:
1739               printf(" -> ");
1740               break;
1741
1742             default:
1743               putchar(' ');
1744               break;
1745             }
1746             break;
1747
1748           case COL_DEF_DL_SRC:
1749           case COL_RES_DL_SRC:
1750           case COL_UNRES_DL_SRC:
1751             switch (cf->cinfo.col_fmt[i + 1]) {
1752
1753             case COL_DEF_DL_DST:
1754             case COL_RES_DL_DST:
1755             case COL_UNRES_DL_DST:
1756               printf(" -> ");
1757               break;
1758
1759             default:
1760               putchar(' ');
1761               break;
1762             }
1763             break;
1764
1765           case COL_DEF_NET_SRC:
1766           case COL_RES_NET_SRC:
1767           case COL_UNRES_NET_SRC:
1768             switch (cf->cinfo.col_fmt[i + 1]) {
1769
1770             case COL_DEF_NET_DST:
1771             case COL_RES_NET_DST:
1772             case COL_UNRES_NET_DST:
1773               printf(" -> ");
1774               break;
1775
1776             default:
1777               putchar(' ');
1778               break;
1779             }
1780             break;
1781
1782           case COL_DEF_DST:
1783           case COL_RES_DST:
1784           case COL_UNRES_DST:
1785             switch (cf->cinfo.col_fmt[i + 1]) {
1786
1787             case COL_DEF_SRC:
1788             case COL_RES_SRC:
1789             case COL_UNRES_SRC:
1790               printf(" <- ");
1791               break;
1792
1793             default:
1794               putchar(' ');
1795               break;
1796             }
1797             break;
1798
1799           case COL_DEF_DL_DST:
1800           case COL_RES_DL_DST:
1801           case COL_UNRES_DL_DST:
1802             switch (cf->cinfo.col_fmt[i + 1]) {
1803
1804             case COL_DEF_DL_SRC:
1805             case COL_RES_DL_SRC:
1806             case COL_UNRES_DL_SRC:
1807               printf(" <- ");
1808               break;
1809
1810             default:
1811               putchar(' ');
1812               break;
1813             }
1814             break;
1815
1816           case COL_DEF_NET_DST:
1817           case COL_RES_NET_DST:
1818           case COL_UNRES_NET_DST:
1819             switch (cf->cinfo.col_fmt[i + 1]) {
1820
1821             case COL_DEF_NET_SRC:
1822             case COL_RES_NET_SRC:
1823             case COL_UNRES_NET_SRC:
1824               printf(" <- ");
1825               break;
1826
1827             default:
1828               putchar(' ');
1829               break;
1830             }
1831             break;
1832
1833           default:
1834             putchar(' ');
1835             break;
1836           }
1837         }
1838       }
1839       putchar('\n');
1840     }
1841     if (print_hex) {
1842       print_hex_data(stdout, print_args.format, edt);
1843       putchar('\n');
1844     }
1845   }
1846
1847   /* The ANSI C standard does not appear to *require* that a line-buffered
1848      stream be flushed to the host environment whenever a newline is
1849      written, it just says that, on such a stream, characters "are
1850      intended to be transmitted to or from the host environment as a
1851      block when a new-line character is encountered".
1852
1853      The Visual C++ 6.0 C implementation doesn't do what is intended;
1854      even if you set a stream to be line-buffered, it still doesn't
1855      flush the buffer at the end of every line.
1856
1857      So, if the "-l" flag was specified, we flush the standard output
1858      at the end of a packet.  This will do the right thing if we're
1859      printing packet summary lines, and, as we print the entire protocol
1860      tree for a single packet without waiting for anything to happen,
1861      it should be as good as line-buffered mode if we're printing
1862      protocol trees.  (The whole reason for the "-l" flag in either
1863      tcpdump or Tethereal is to allow the output of a live capture to
1864      be piped to a program or script and to have that script see the
1865      information for the packet as soon as it's printed, rather than
1866      having to wait until a standard I/O buffer fills up. */
1867   if (line_buffered)
1868     fflush(stdout);
1869
1870   epan_dissect_free(edt);
1871
1872   clear_fdata(&fdata);
1873 }
1874
1875 char *
1876 file_open_error_message(int err, gboolean for_writing, int file_type)
1877 {
1878   char *errmsg;
1879   static char errmsg_errno[1024+1];
1880
1881   switch (err) {
1882
1883   case WTAP_ERR_NOT_REGULAR_FILE:
1884     errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
1885     break;
1886
1887   case WTAP_ERR_FILE_UNKNOWN_FORMAT:
1888   case WTAP_ERR_UNSUPPORTED:
1889     /* Seen only when opening a capture file for reading. */
1890     errmsg = "The file \"%s\" is not a capture file in a format Tethereal understands.";
1891     break;
1892
1893   case WTAP_ERR_CANT_WRITE_TO_PIPE:
1894     /* Seen only when opening a capture file for writing. */
1895     snprintf(errmsg_errno, sizeof(errmsg_errno),
1896              "The file \"%%s\" is a pipe, and %s capture files cannot be "
1897              "written to a pipe.", wtap_file_type_string(file_type));
1898     errmsg = errmsg_errno;
1899     break;
1900
1901   case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
1902     /* Seen only when opening a capture file for writing. */
1903     errmsg = "Tethereal does not support writing capture files in that format.";
1904     break;
1905
1906   case WTAP_ERR_UNSUPPORTED_ENCAP:
1907   case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
1908     if (for_writing)
1909       errmsg = "Tethereal cannot save this capture in that format.";
1910     else
1911       errmsg = "The file \"%s\" is a capture for a network type that Tethereal doesn't support.";
1912     break;
1913
1914   case WTAP_ERR_BAD_RECORD:
1915     errmsg = "The file \"%s\" appears to be damaged or corrupt.";
1916     break;
1917
1918   case WTAP_ERR_CANT_OPEN:
1919     if (for_writing)
1920       errmsg = "The file \"%s\" could not be created for some unknown reason.";
1921     else
1922       errmsg = "The file \"%s\" could not be opened for some unknown reason.";
1923     break;
1924
1925   case WTAP_ERR_SHORT_READ:
1926     errmsg = "The file \"%s\" appears to have been cut short"
1927              " in the middle of a packet or other data.";
1928     break;
1929
1930   case WTAP_ERR_SHORT_WRITE:
1931     errmsg = "A full header couldn't be written to the file \"%s\".";
1932     break;
1933
1934   case ENOENT:
1935     if (for_writing)
1936       errmsg = "The path to the file \"%s\" does not exist.";
1937     else
1938       errmsg = "The file \"%s\" does not exist.";
1939     break;
1940
1941   case EACCES:
1942     if (for_writing)
1943       errmsg = "You do not have permission to create or write to the file \"%s\".";
1944     else
1945       errmsg = "You do not have permission to read the file \"%s\".";
1946     break;
1947
1948   case EISDIR:
1949     errmsg = "\"%s\" is a directory (folder), not a file.";
1950     break;
1951
1952   default:
1953     snprintf(errmsg_errno, sizeof(errmsg_errno),
1954              "The file \"%%s\" could not be %s: %s.",
1955              for_writing ? "created" : "opened",
1956              wtap_strerror(err));
1957     errmsg = errmsg_errno;
1958     break;
1959   }
1960   return errmsg;
1961 }
1962
1963 int
1964 open_cap_file(char *fname, gboolean is_tempfile, capture_file *cf)
1965 {
1966   wtap       *wth;
1967   int         err;
1968   char        err_msg[2048+1];
1969
1970   wth = wtap_open_offline(fname, &err, FALSE);
1971   if (wth == NULL)
1972     goto fail;
1973
1974   /* The open succeeded.  Fill in the information for this file. */
1975
1976   /* Initialize all data structures used for dissection. */
1977   init_dissection();
1978
1979   cf->wth = wth;
1980   cf->filed = -1;       /* not used, but set it anyway */
1981   cf->f_len = 0;        /* not used, but set it anyway */
1982
1983   /* Set the file name because we need it to set the follow stream filter.
1984      XXX - is that still true?  We need it for other reasons, though,
1985      in any case. */
1986   cf->filename = g_strdup(fname);
1987
1988   /* Indicate whether it's a permanent or temporary file. */
1989   cf->is_tempfile = is_tempfile;
1990
1991   /* If it's a temporary capture buffer file, mark it as not saved. */
1992   cf->user_saved = !is_tempfile;
1993
1994   cf->cd_t      = wtap_file_type(cf->wth);
1995   cf->count     = 0;
1996   cf->drops_known = FALSE;
1997   cf->drops     = 0;
1998   cf->esec      = 0;
1999   cf->eusec     = 0;
2000   cf->snap      = wtap_snapshot_length(cf->wth);
2001   if (cf->snap == 0) {
2002     /* Snapshot length not known. */
2003     cf->has_snap = FALSE;
2004     cf->snap = WTAP_MAX_PACKET_SIZE;
2005   } else
2006     cf->has_snap = TRUE;
2007   cf->progbar_quantum = 0;
2008   cf->progbar_nextstep = 0;
2009   firstsec = 0, firstusec = 0;
2010   prevsec = 0, prevusec = 0;
2011  
2012   return (0);
2013
2014 fail:
2015   snprintf(err_msg, sizeof err_msg, file_open_error_message(err, FALSE, 0),
2016            fname);
2017   fprintf(stderr, "tethereal: %s\n", err_msg);
2018   return (err);
2019 }