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