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