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