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