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