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