Allow taps to have menu item registration routines; the menu item
[obnox/wireshark/wip.git] / tethereal.c
1 /* tethereal.c
2  *
3  * $Id: tethereal.c,v 1.181 2003/04/23 03:50:59 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_FCNTL_H
45 #include <fcntl.h>
46 #endif
47
48 #include <signal.h>
49
50 #ifdef HAVE_LIBPCAP
51 #include <pcap.h>
52 #include <setjmp.h>
53 #endif
54
55 #ifdef HAVE_SYS_STAT_H
56 # include <sys/stat.h>
57 #endif
58
59 #ifdef NEED_SNPRINTF_H
60 # include "snprintf.h"
61 #endif
62
63 #ifdef NEED_STRERROR_H
64 #include "strerror.h"
65 #endif
66
67 #ifdef NEED_GETOPT_H
68 #include "getopt.h"
69 #endif
70
71 #include <glib.h>
72 #include <epan/epan.h>
73 #include <epan/filesystem.h>
74
75 #include "globals.h"
76 #include <epan/timestamp.h>
77 #include <epan/packet.h>
78 #include "file.h"
79 #include "prefs.h"
80 #include "column.h"
81 #include "print.h"
82 #include <epan/resolv.h>
83 #include "util.h"
84 #ifdef HAVE_LIBPCAP
85 #include "pcap-util.h"
86 #endif
87 #include <epan/conversation.h>
88 #include <epan/plugins.h>
89 #include "register.h"
90 #include "conditions.h"
91 #include "capture_stop_conditions.h"
92 #include "ringbuffer.h"
93 #include <epan/epan_dissect.h>
94 #include "tap.h"
95
96 #ifdef HAVE_LIBPCAP
97 #include <wiretap/wtap-capture.h>
98 #include <wiretap/libpcap.h>
99 #endif
100
101 #ifdef _WIN32
102 #include "capture-wpcap.h"
103 #endif
104
105 static guint32 firstsec, firstusec;
106 static guint32 prevsec, prevusec;
107 static GString *comp_info_str, *runtime_info_str;
108 static gboolean quiet;
109 static gboolean decode;
110 static gboolean verbose;
111 static gboolean print_hex;
112 static gboolean line_buffered;
113
114 #ifdef HAVE_LIBPCAP
115 typedef struct _loop_data {
116   gboolean       go;           /* TRUE as long as we're supposed to keep capturing */
117   gint           linktype;
118   gboolean       from_pipe;    /* TRUE if we are capturing data from a pipe */
119   pcap_t        *pch;
120   wtap_dumper   *pdh;
121   jmp_buf        stopenv;
122   gboolean       output_to_pipe;
123   int            packet_count;
124 #ifndef _WIN32
125   gboolean       modified;     /* TRUE if data in the pipe uses modified pcap headers */
126   gboolean       byte_swapped; /* TRUE if data in the pipe is byte swapped */
127   unsigned int   bytes_to_read, bytes_read; /* Used by pipe_dispatch */
128   enum {
129          STATE_EXPECT_REC_HDR, STATE_READ_REC_HDR,
130          STATE_EXPECT_DATA,     STATE_READ_DATA
131        } pipe_state;
132
133   enum { PIPOK, PIPEOF, PIPERR, PIPNEXIST } pipe_err;
134 #endif
135 } loop_data;
136
137 static loop_data ld;
138
139 static int capture(int);
140 static void capture_pcap_cb(guchar *, const struct pcap_pkthdr *,
141   const guchar *);
142 static void report_counts(void);
143 #ifdef _WIN32
144 static BOOL WINAPI capture_cleanup(DWORD);
145 #else /* _WIN32 */
146 static void capture_cleanup(int);
147 #ifdef SIGINFO
148 static void report_counts_siginfo(int);
149 #endif /* SIGINFO */
150 #endif /* _WIN32 */
151 #endif /* HAVE_LIBPCAP */
152
153 typedef struct {
154   capture_file *cf;
155   wtap_dumper *pdh;
156 } cb_args_t;
157
158 static int load_cap_file(capture_file *, int);
159 static void wtap_dispatch_cb_write(guchar *, const struct wtap_pkthdr *, long,
160     union wtap_pseudo_header *, const guchar *);
161 static void show_capture_file_io_error(const char *, int, gboolean);
162 static void wtap_dispatch_cb_print(guchar *, const struct wtap_pkthdr *, long,
163     union wtap_pseudo_header *, const guchar *);
164 #ifndef _WIN32
165 static void adjust_header(loop_data *, struct pcap_hdr *, struct pcaprec_hdr *);
166 static int pipe_open_live(char *, struct pcap_hdr *, loop_data *, char *, int);
167 static int pipe_dispatch(int, loop_data *, struct pcap_hdr *, \
168                 struct pcaprec_modified_hdr *, guchar *, char *, int);
169 #endif
170
171 capture_file cfile;
172 ts_type timestamp_type = RELATIVE;
173 #ifdef HAVE_LIBPCAP
174 typedef struct {
175         int snaplen;                    /* Maximum captured packet length */
176         int promisc_mode;               /* Capture in promiscuous mode */
177         int autostop_count;             /* Maximum packet count */
178         gboolean has_autostop_duration; /* TRUE if maximum capture duration
179                                            is specified */
180         gint32 autostop_duration;       /* Maximum capture duration */
181         gboolean has_autostop_filesize; /* TRUE if maximum capture file size
182                                            is specified */
183         gint32 autostop_filesize;       /* Maximum capture file size */
184         gboolean ringbuffer_on;         /* TRUE if ring buffer in use */
185         guint32 ringbuffer_num_files;   /* Number of ring buffer files */
186 } capture_options;
187
188 static capture_options capture_opts = {
189         WTAP_MAX_PACKET_SIZE,           /* snapshot length - default is
190                                            infinite, in effect */
191         TRUE,                           /* promiscuous mode is the default */
192         0,                              /* max packet count - default is 0,
193                                            meaning infinite */
194         FALSE,                          /* maximum capture duration not
195                                            specified by default */
196         0,                              /* maximum capture duration */
197         FALSE,                          /* maximum capture file size not
198                                            specified by default */
199         0,                              /* maximum capture file size */
200         FALSE,                          /* ring buffer off by default */
201         RINGBUFFER_MIN_NUM_FILES        /* default number of ring buffer
202                                            files */
203 };
204
205 #ifdef SIGINFO
206 static gboolean infodelay;      /* if TRUE, don't print capture info in SIGINFO handler */
207 static gboolean infoprint;      /* if TRUE, print capture info after clearing infodelay */
208 #endif /* SIGINFO */
209 #endif /* HAVE_LIBPCAP */
210
211 static void
212 print_usage(gboolean print_ver)
213 {
214   int i;
215
216   if (print_ver) {
217     fprintf(stderr, "This is GNU t%s %s\n%s\n%s\n", PACKAGE, VERSION,
218         comp_info_str->str, runtime_info_str->str);
219   }
220 #ifdef HAVE_LIBPCAP
221   fprintf(stderr, "\nt%s [ -DvVhqSlp ] [ -a <capture autostop condition> ] ...\n",
222           PACKAGE);
223   fprintf(stderr, "\t[ -b <number of ring buffer files> ] [ -c <count> ]\n");
224   fprintf(stderr, "\t[ -f <capture filter> ] [ -F <output file type> ]\n");
225   fprintf(stderr, "\t[ -i <interface> ] [ -n ] [ -N <resolving> ]\n");
226   fprintf(stderr, "\t[ -o <preference setting> ] ... [ -r <infile> ] [ -R <read filter> ]\n");
227   fprintf(stderr, "\t[ -s <snaplen> ] [ -t <time stamp format> ] [ -w <savefile> ] [ -x ]\n");
228 #else
229   fprintf(stderr, "\nt%s [ -vVhl ] [ -F <output file type> ] [ -n ] [ -N <resolving> ]\n", PACKAGE);
230   fprintf(stderr, "\t[ -o <preference setting> ] ... [ -r <infile> ] [ -R <read filter> ]\n");
231   fprintf(stderr, "\t[ -t <time stamp format> ] [ -w <savefile> ] [ -x ]\n");
232 #endif
233   fprintf(stderr, "\t[ -Z <statistics string> ]\n");
234   fprintf(stderr, "Valid file type arguments to the \"-F\" flag:\n");
235   for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
236     if (wtap_dump_can_open(i))
237       fprintf(stderr, "\t%s - %s\n",
238         wtap_file_type_short_string(i), wtap_file_type_string(i));
239   }
240   fprintf(stderr, "\tdefault is libpcap\n");
241 }
242
243 #ifdef HAVE_LIBPCAP
244 static int
245 get_positive_int(const char *string, const char *name)
246 {
247   long number;
248   char *p;
249
250   number = strtol(string, &p, 10);
251   if (p == string || *p != '\0') {
252     fprintf(stderr, "tethereal: The specified %s \"%s\" is not a decimal number\n",
253             name, string);
254     exit(1);
255   }
256   if (number < 0) {
257     fprintf(stderr, "tethereal: The specified %s is a negative number\n",
258             name);
259     exit(1);
260   }
261   if (number == 0) {
262     fprintf(stderr, "tethereal: The specified %s is zero\n",
263             name);
264     exit(1);
265   }
266   if (number > INT_MAX) {
267     fprintf(stderr, "tethereal: The specified %s is too large (greater than %d)\n",
268             name, INT_MAX);
269     exit(1);
270   }
271   return number;
272 }
273
274 /*
275  * Given a string of the form "<autostop criterion>:<value>", as might appear
276  * as an argument to a "-a" option, parse it and set the criterion in
277  * question.  Return an indication of whether it succeeded or failed
278  * in some fashion.
279  */
280 static gboolean
281 set_autostop_criterion(const char *autostoparg)
282 {
283   guchar *p, *colonp;
284
285   colonp = strchr(autostoparg, ':');
286   if (colonp == NULL)
287     return FALSE;
288
289   p = colonp;
290   *p++ = '\0';
291
292   /*
293    * Skip over any white space (there probably won't be any, but
294    * as we allow it in the preferences file, we might as well
295    * allow it here).
296    */
297   while (isspace(*p))
298     p++;
299   if (*p == '\0') {
300     /*
301      * Put the colon back, so if our caller uses, in an
302      * error message, the string they passed us, the message
303      * looks correct.
304      */
305     *colonp = ':';
306     return FALSE;
307   }
308   if (strcmp(autostoparg,"duration") == 0) {
309     capture_opts.has_autostop_duration = TRUE;
310     capture_opts.autostop_duration = get_positive_int(p,"autostop duration");
311   } else if (strcmp(autostoparg,"filesize") == 0) {
312     capture_opts.has_autostop_filesize = TRUE;
313     capture_opts.autostop_filesize = get_positive_int(p,"autostop filesize");
314   } else {
315     return FALSE;
316   }
317   *colonp = ':';        /* put the colon back */
318   return TRUE;
319 }
320 #endif
321
322 /* structure to keep track of what tap listeners have been registered.
323  */
324 typedef struct _ethereal_tap_list {
325         struct _ethereal_tap_list *next;
326         char *cmd;
327         void (*func)(char *arg);
328 } ethereal_tap_list;
329 static ethereal_tap_list *tap_list=NULL;
330
331 void
332 register_ethereal_tap(char *cmd, void (*func)(char *arg))
333 {
334         ethereal_tap_list *newtl;
335
336         newtl=malloc(sizeof(ethereal_tap_list));
337         newtl->next=tap_list;
338         tap_list=newtl;
339         newtl->cmd=cmd;
340         newtl->func=func;
341
342 }
343
344 int
345 main(int argc, char *argv[])
346 {
347   int                  opt, i;
348   extern char         *optarg;
349   gboolean             arg_error = FALSE;
350
351 #ifdef _WIN32
352   WSADATA               wsaData;
353 #endif  /* _WIN32 */
354
355   char                *gpf_path;
356   char                *pf_path;
357   int                  gpf_open_errno, pf_open_errno;
358   int                  err;
359 #ifdef HAVE_LIBPCAP
360   gboolean             capture_filter_specified = FALSE;
361   GList               *if_list, *if_entry;
362   gchar                err_str[PCAP_ERRBUF_SIZE];
363 #else
364   gboolean             capture_option_specified = FALSE;
365 #endif
366   int                  out_file_type = WTAP_FILE_PCAP;
367   gchar               *cf_name = NULL, *rfilter = NULL;
368 #ifdef HAVE_LIBPCAP
369   gchar               *if_text;
370 #endif
371   dfilter_t           *rfcode = NULL;
372   e_prefs             *prefs;
373   char                 badopt;
374   ethereal_tap_list *tli;
375
376   /* Register all dissectors; we must do this before checking for the
377      "-G" flag, as the "-G" flag dumps information registered by the
378      dissectors, and we must do it before we read the preferences, in
379      case any dissectors register preferences. */
380   epan_init(PLUGIN_DIR,register_all_protocols,register_all_protocol_handoffs);
381
382   /* Register all tap listeners; we do this before we parse the arguments,
383      as the "-z" argument can specify a registered tap. */
384   register_all_tap_listeners();
385
386   /* Now register the preferences for any non-dissector modules.
387      We must do that before we read the preferences as well. */
388   prefs_register_modules();
389
390   /* If invoked with the "-G" flag, we dump out information based on
391      the argument to the "-G" flag; if no argument is specified,
392      for backwards compatibility we dump out a glossary of display
393      filter symbols.
394
395      We do this here to mirror what happens in the GTK+ version, although
396      it's not necessary here. */
397   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
398     if (argc == 2)
399       proto_registrar_dump_fields();
400     else {
401       if (strcmp(argv[2], "fields") == 0)
402         proto_registrar_dump_fields();
403       else if (strcmp(argv[2], "protocols") == 0)
404         proto_registrar_dump_protocols();
405       else {
406         fprintf(stderr, "tethereal: Invalid \"%s\" option for -G flag\n",
407                 argv[2]);
408         exit(1);
409       }
410     }
411     exit(0);
412   }
413
414   /* Set the C-language locale to the native environment. */
415   setlocale(LC_ALL, "");
416
417   prefs = read_prefs(&gpf_open_errno, &gpf_path, &pf_open_errno, &pf_path);
418   if (gpf_path != NULL) {
419     fprintf(stderr, "Can't open global preferences file \"%s\": %s.\n", pf_path,
420         strerror(gpf_open_errno));
421   }
422   if (pf_path != NULL) {
423     fprintf(stderr, "Can't open your preferences file \"%s\": %s.\n", pf_path,
424         strerror(pf_open_errno));
425     g_free(pf_path);
426     pf_path = NULL;
427   }
428
429   /* Set the name resolution code's flags from the preferences. */
430   g_resolv_flags = prefs->name_resolve;
431
432 #ifdef _WIN32
433   /* Load Wpcap, if possible */
434   load_wpcap();
435 #endif
436
437   init_cap_file(&cfile);
438
439   /* Assemble the compile-time version information string */
440   comp_info_str = g_string_new("Compiled ");
441   get_compiled_version_info(comp_info_str);
442
443   /* Assemble the run-time version information string */
444   runtime_info_str = g_string_new("Running ");
445   get_runtime_version_info(runtime_info_str);
446
447   /* Now get our args */
448   while ((opt = getopt(argc, argv, "a:b:c:Df:F:hi:lnN:o:pqr:R:s:St:vw:Vxz:")) != -1) {
449     switch (opt) {
450       case 'a':        /* autostop criteria */
451 #ifdef HAVE_LIBPCAP
452         if (set_autostop_criterion(optarg) == FALSE) {
453           fprintf(stderr, "ethereal: Invalid or unknown -a flag \"%s\"\n", optarg);
454           exit(1);
455         }
456 #else
457         capture_option_specified = TRUE;
458         arg_error = TRUE;
459 #endif
460         break;
461       case 'b':        /* Ringbuffer option */
462 #ifdef HAVE_LIBPCAP
463         capture_opts.ringbuffer_on = TRUE;
464         capture_opts.ringbuffer_num_files =
465             get_positive_int(optarg, "number of ring buffer files");
466 #else
467         capture_option_specified = TRUE;
468         arg_error = TRUE;
469 #endif
470         break;
471       case 'c':        /* Capture xxx packets */
472 #ifdef HAVE_LIBPCAP
473         capture_opts.autostop_count =
474             get_positive_int(optarg, "packet count");
475 #else
476         capture_option_specified = TRUE;
477         arg_error = TRUE;
478 #endif
479         break;
480       case 'D':        /* Print a list of capture devices */
481 #ifdef HAVE_LIBPCAP
482         if_list = get_interface_list(&err, err_str);
483         if (if_list == NULL) {
484             switch (err) {
485
486             case CANT_GET_INTERFACE_LIST:
487                 fprintf(stderr, "tethereal: Can't get list of interfaces: %s\n",
488                         err_str);
489                 break;
490
491             case NO_INTERFACES_FOUND:
492                 fprintf(stderr, "tethereal: There are no interfaces on which a capture can be done\n");
493                 break;
494             }
495             exit(2);
496         }
497         for (if_entry = g_list_first(if_list); if_entry != NULL;
498                 if_entry = g_list_next(if_entry))
499           printf("%s\n", (char *)if_entry->data);
500         free_interface_list(if_list);
501         exit(0);
502 #else
503         capture_option_specified = TRUE;
504         arg_error = TRUE;
505 #endif
506         break;
507       case 'f':
508 #ifdef HAVE_LIBPCAP
509         capture_filter_specified = TRUE;
510         if (cfile.cfilter)
511                 g_free(cfile.cfilter);
512         cfile.cfilter = g_strdup(optarg);
513 #else
514         capture_option_specified = TRUE;
515         arg_error = TRUE;
516 #endif
517         break;
518       case 'F':
519         out_file_type = wtap_short_string_to_file_type(optarg);
520         if (out_file_type < 0) {
521           fprintf(stderr, "tethereal: \"%s\" is not a valid capture file type\n",
522                         optarg);
523           exit(1);
524         }
525         break;
526       case 'h':        /* Print help and exit */
527         print_usage(TRUE);
528         exit(0);
529         break;
530       case 'i':        /* Use interface xxx */
531 #ifdef HAVE_LIBPCAP
532         cfile.iface = g_strdup(optarg);
533 #else
534         capture_option_specified = TRUE;
535         arg_error = TRUE;
536 #endif
537         break;
538       case 'l':        /* "Line-buffer" standard output */
539         /* This isn't line-buffering, strictly speaking, it's just
540            flushing the standard output after the information for
541            each packet is printed; however, that should be good
542            enough for all the purposes to which "-l" is put.
543
544            See the comment in "wtap_dispatch_cb_print()" for an
545            explanation of why we do that, and why we don't just
546            use "setvbuf()" to make the standard output line-buffered
547            (short version: in Windows, "line-buffered" is the same
548            as "fully-buffered", and the output buffer is only flushed
549            when it fills up). */
550         line_buffered = TRUE;
551         break;
552       case 'n':        /* No name resolution */
553         g_resolv_flags = RESOLV_NONE;
554         break;
555       case 'N':        /* Select what types of addresses/port #s to resolve */
556         if (g_resolv_flags == RESOLV_ALL)
557           g_resolv_flags = RESOLV_NONE;
558         badopt = string_to_name_resolve(optarg, &g_resolv_flags);
559         if (badopt != '\0') {
560           fprintf(stderr, "tethereal: -N specifies unknown resolving option '%c'; valid options are 'm', 'n', and 't'\n",
561                         badopt);
562           exit(1);
563         }
564         break;
565       case 'o':        /* Override preference from command line */
566         switch (prefs_set_pref(optarg)) {
567
568         case PREFS_SET_SYNTAX_ERR:
569           fprintf(stderr, "tethereal: Invalid -o flag \"%s\"\n", optarg);
570           exit(1);
571           break;
572
573         case PREFS_SET_NO_SUCH_PREF:
574         case PREFS_SET_OBSOLETE:
575           fprintf(stderr, "tethereal: -o flag \"%s\" specifies unknown preference\n",
576                         optarg);
577           exit(1);
578           break;
579         }
580         break;
581       case 'p':        /* Don't capture in promiscuous mode */
582 #ifdef HAVE_LIBPCAP
583         capture_opts.promisc_mode = FALSE;
584 #else
585         capture_option_specified = TRUE;
586         arg_error = TRUE;
587 #endif
588         break;
589       case 'q':        /* Quiet */
590         quiet = TRUE;
591         break;
592       case 'r':        /* Read capture file xxx */
593         cf_name = g_strdup(optarg);
594         break;
595       case 'R':        /* Read file filter */
596         rfilter = optarg;
597         break;
598       case 's':        /* Set the snapshot (capture) length */
599 #ifdef HAVE_LIBPCAP
600         capture_opts.snaplen = get_positive_int(optarg, "snapshot length");
601 #else
602         capture_option_specified = TRUE;
603         arg_error = TRUE;
604 #endif
605         break;
606       case 'S':        /* show packets in real time */
607         decode = TRUE;
608         break;
609       case 't':        /* Time stamp type */
610         if (strcmp(optarg, "r") == 0)
611           timestamp_type = RELATIVE;
612         else if (strcmp(optarg, "a") == 0)
613           timestamp_type = ABSOLUTE;
614         else if (strcmp(optarg, "ad") == 0)
615           timestamp_type = ABSOLUTE_WITH_DATE;
616         else if (strcmp(optarg, "d") == 0)
617           timestamp_type = DELTA;
618         else {
619           fprintf(stderr, "tethereal: Invalid time stamp type \"%s\"\n",
620             optarg);
621           fprintf(stderr, "It must be \"r\" for relative, \"a\" for absolute,\n");
622           fprintf(stderr, "\"ad\" for absolute with date, or \"d\" for delta.\n");
623           exit(1);
624         }
625         break;
626       case 'v':        /* Show version and exit */
627         printf("t%s %s\n%s\n%s\n", PACKAGE, VERSION, comp_info_str->str,
628                runtime_info_str->str);
629         exit(0);
630         break;
631       case 'w':        /* Write to capture file xxx */
632         cfile.save_file = g_strdup(optarg);
633         break;
634       case 'V':        /* Verbose */
635         verbose = TRUE;
636         break;
637       case 'x':        /* Print packet data in hex (and ASCII) */
638         print_hex = TRUE;
639         break;
640       case 'z':
641         for(tli=tap_list;tli;tli=tli->next){
642           if(!strncmp(tli->cmd,optarg,strlen(tli->cmd))){
643             (*tli->func)(optarg);
644             break;
645           }
646         }
647         if(!tli){
648           fprintf(stderr,"tethereal: invalid -z argument.\n");
649           fprintf(stderr,"  -z argument must be one of :\n");
650           for(tli=tap_list;tli;tli=tli->next){
651             fprintf(stderr,"     %s\n",tli->cmd);
652           }
653           exit(1);
654         }
655         break;
656       default:
657       case '?':        /* Bad flag - print usage message */
658         arg_error = TRUE;
659         break;
660     }
661   }
662
663   /* If no capture filter or read filter has been specified, and there are
664      still command-line arguments, treat them as the tokens of a capture
665      filter (if no "-r" flag was specified) or a read filter (if a "-r"
666      flag was specified. */
667   if (optind < argc) {
668     if (cf_name != NULL) {
669       if (rfilter != NULL) {
670         fprintf(stderr,
671 "tethereal: Read filters were specified both with \"-R\" and with additional command-line arguments\n");
672         exit(2);
673       }
674       rfilter = get_args_as_string(argc, argv, optind);
675     } else {
676 #ifdef HAVE_LIBPCAP
677       if (capture_filter_specified) {
678         fprintf(stderr,
679 "tethereal: Capture filters were specified both with \"-f\" and with additional command-line arguments\n");
680         exit(2);
681       }
682       cfile.cfilter = get_args_as_string(argc, argv, optind);
683 #else
684       capture_option_specified = TRUE;
685 #endif
686     }
687   }
688
689   /* See if we're writing a capture file and the file is a pipe */
690 #ifdef HAVE_LIBPCAP
691   ld.output_to_pipe = FALSE;
692 #endif
693   if (cfile.save_file != NULL) {
694     if (strcmp(cfile.save_file, "-") == 0) {
695       /* stdout */
696       g_free(cfile.save_file);
697       cfile.save_file = g_strdup("");
698 #ifdef HAVE_LIBPCAP
699       ld.output_to_pipe = TRUE;
700 #endif
701     }
702 #ifdef HAVE_LIBPCAP
703     else {
704       err = test_for_fifo(cfile.save_file);
705       switch (err) {
706
707       case ENOENT:      /* it doesn't exist, so we'll be creating it,
708                            and it won't be a FIFO */
709       case 0:           /* found it, but it's not a FIFO */
710         break;
711
712       case ESPIPE:      /* it is a FIFO */
713         ld.output_to_pipe = TRUE;
714         break;
715
716       default:          /* couldn't stat it */
717         fprintf(stderr,
718                 "tethereal: Error testing whether capture file is a pipe: %s\n",
719                 strerror(errno));
720         exit(2);
721       }
722     }
723 #endif
724   }
725
726 #ifdef HAVE_LIBPCAP
727   /* If they didn't specify a "-w" flag, but specified a maximum capture
728      file size, tell them that this doesn't work, and exit. */
729   if (capture_opts.has_autostop_filesize && cfile.save_file == NULL) {
730     fprintf(stderr, "tethereal: Maximum capture file size specified, but "
731       "capture isn't being saved to a file.\n");
732     exit(2);
733   }
734
735   if (capture_opts.ringbuffer_on) {
736     /* Ring buffer works only under certain conditions:
737        a) ring buffer does not work if you're not saving the capture to
738           a file;
739        b) ring buffer only works if you're saving in libpcap format;
740        c) it makes no sense to enable the ring buffer if the maximum
741           file size is set to "infinite";
742        d) file must not be a pipe. */
743     if (cfile.save_file == NULL) {
744       fprintf(stderr, "tethereal: Ring buffer requested, but "
745         "capture isn't being saved to a file.\n");
746       exit(2);
747     }
748     if (out_file_type != WTAP_FILE_PCAP) {
749       fprintf(stderr, "tethereal: Ring buffer requested, but "
750         "capture isn't being saved in libpcap format.\n");
751       exit(2);
752     }
753     if (!capture_opts.has_autostop_filesize) {
754       fprintf(stderr, "tethereal: Ring buffer requested, but "
755         "no maximum capture file size was specified.\n");
756       exit(2);
757     }
758     if (ld.output_to_pipe) {
759       fprintf(stderr, "tethereal: Ring buffer requested, but "
760         "capture file is a pipe.\n");
761       exit(2);
762     }
763   }
764 #endif
765
766 #ifdef _WIN32
767   /* Start windows sockets */
768   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
769 #endif  /* _WIN32 */
770
771   /* Notify all registered modules that have had any of their preferences
772      changed either from one of the preferences file or from the command
773      line that their preferences have changed. */
774   prefs_apply_all();
775
776 #ifndef HAVE_LIBPCAP
777   if (capture_option_specified)
778     fprintf(stderr, "This version of Tethereal was not built with support for capturing packets.\n");
779 #endif
780   if (arg_error) {
781     print_usage(FALSE);
782     exit(1);
783   }
784
785   /* Build the column format array */
786   col_setup(&cfile.cinfo, prefs->num_cols);
787   for (i = 0; i < cfile.cinfo.num_cols; i++) {
788     cfile.cinfo.col_fmt[i] = get_column_format(i);
789     cfile.cinfo.col_title[i] = g_strdup(get_column_title(i));
790     cfile.cinfo.fmt_matx[i] = (gboolean *) g_malloc0(sizeof(gboolean) *
791       NUM_COL_FMTS);
792     get_column_format_matches(cfile.cinfo.fmt_matx[i], cfile.cinfo.col_fmt[i]);
793     cfile.cinfo.col_data[i] = NULL;
794     if (cfile.cinfo.col_fmt[i] == COL_INFO)
795       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_INFO_LEN);
796     else
797       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
798     cfile.cinfo.col_fence[i] = 0;
799     cfile.cinfo.col_expr[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
800     cfile.cinfo.col_expr_val[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
801   }
802
803 #ifdef HAVE_LIBPCAP
804   if (capture_opts.snaplen < 1)
805     capture_opts.snaplen = WTAP_MAX_PACKET_SIZE;
806   else if (capture_opts.snaplen < MIN_PACKET_SIZE)
807     capture_opts.snaplen = MIN_PACKET_SIZE;
808
809   /* Check the value range of the ringbuffer_num_files parameter */
810   if (capture_opts.ringbuffer_num_files < RINGBUFFER_MIN_NUM_FILES)
811     capture_opts.ringbuffer_num_files = RINGBUFFER_MIN_NUM_FILES;
812   else if (capture_opts.ringbuffer_num_files > RINGBUFFER_MAX_NUM_FILES)
813     capture_opts.ringbuffer_num_files = RINGBUFFER_MAX_NUM_FILES;
814 #endif
815
816   if (rfilter != NULL) {
817     if (!dfilter_compile(rfilter, &rfcode)) {
818       fprintf(stderr, "tethereal: %s\n", dfilter_error_msg);
819       epan_cleanup();
820       exit(2);
821     }
822   }
823   cfile.rfcode = rfcode;
824   if (cf_name) {
825     err = open_cap_file(cf_name, FALSE, &cfile);
826     if (err != 0) {
827       epan_cleanup();
828       exit(2);
829     }
830     err = load_cap_file(&cfile, out_file_type);
831     if (err != 0) {
832       epan_cleanup();
833       exit(2);
834     }
835     cf_name[0] = '\0';
836   } else {
837     /* No capture file specified, so we're supposed to do a live capture;
838        do we have support for live captures? */
839 #ifdef HAVE_LIBPCAP
840
841 #ifdef _WIN32
842     if (!has_wpcap) {
843         fprintf(stderr, "tethereal: Could not load wpcap.dll.\n");
844         exit(2);
845     }
846 #endif
847
848     /* Yes; did the user specify an interface to use? */
849     if (cfile.iface == NULL) {
850         /* No - is a default specified in the preferences file? */
851         if (prefs->capture_device != NULL) {
852             /* Yes - use it. */
853             if_text = strrchr(prefs->capture_device, ' ');
854             if (if_text == NULL) {
855                 cfile.iface = g_strdup(prefs->capture_device);
856             } else {
857                 cfile.iface = g_strdup(if_text + 1); /* Skip over space */
858             }
859         } else {
860             /* No - pick the first one from the list of interfaces. */
861             if_list = get_interface_list(&err, err_str);
862             if (if_list == NULL) {
863                 switch (err) {
864
865                 case CANT_GET_INTERFACE_LIST:
866                     fprintf(stderr, "tethereal: Can't get list of interfaces: %s\n",
867                             err_str);
868                     break;
869
870                 case NO_INTERFACES_FOUND:
871                     fprintf(stderr, "tethereal: There are no interfaces on which a capture can be done\n");
872                     break;
873                 }
874                 exit(2);
875             }
876             if_text = strrchr(if_list->data, ' ');      /* first interface */
877             if (if_text == NULL) {
878                 cfile.iface = g_strdup(if_list->data);
879             } else {
880                 cfile.iface = g_strdup(if_text + 1); /* Skip over space */
881             }
882             free_interface_list(if_list);
883         }
884     }
885     capture(out_file_type);
886
887     if (capture_opts.ringbuffer_on) {
888       ringbuf_free();
889     }
890 #else
891     /* No - complain. */
892     fprintf(stderr, "This version of Tethereal was not built with support for capturing packets.\n");
893     exit(2);
894 #endif
895   }
896
897   draw_tap_listeners(TRUE);
898   epan_cleanup();
899
900   return 0;
901 }
902
903 #ifdef HAVE_LIBPCAP
904 /* Do the low-level work of a capture.
905    Returns TRUE if it succeeds, FALSE otherwise. */
906 static int
907 capture(int out_file_type)
908 {
909   int         pcap_encap;
910   int         file_snaplen;
911   gchar       open_err_str[PCAP_ERRBUF_SIZE];
912   gchar       lookup_net_err_str[PCAP_ERRBUF_SIZE];
913   bpf_u_int32 netnum, netmask;
914   struct bpf_program fcode;
915   void        (*oldhandler)(int);
916   int         err = 0;
917   int         volatile volatile_err = 0;
918   int         volatile inpkts = 0;
919   int         pcap_cnt;
920   char        errmsg[1024+1];
921   condition  *volatile cnd_stop_capturesize = NULL;
922   condition  *volatile cnd_stop_timeout = NULL;
923 #ifndef _WIN32
924   static const char ppamsg[] = "can't find PPA for ";
925   char       *libpcap_warn;
926   volatile int pipe_fd = -1;
927   struct pcap_hdr hdr;
928   struct pcaprec_modified_hdr rechdr;
929   guchar pcap_data[WTAP_MAX_PACKET_SIZE];
930 #endif
931   struct pcap_stat stats;
932   gboolean    write_err;
933   gboolean    dump_ok;
934
935   /* Initialize all data structures used for dissection. */
936   init_dissection();
937
938   ld.linktype       = WTAP_ENCAP_UNKNOWN;
939   ld.pdh            = NULL;
940
941   /* Open the network interface to capture from it.
942      Some versions of libpcap may put warnings into the error buffer
943      if they succeed; to tell if that's happened, we have to clear
944      the error buffer, and check if it's still a null string.  */
945   open_err_str[0] = '\0';
946   ld.pch = pcap_open_live(cfile.iface, capture_opts.snaplen,
947                           capture_opts.promisc_mode, 1000, open_err_str);
948
949   if (ld.pch == NULL) {
950     /* We couldn't open "cfile.iface" as a network device. */
951 #ifdef _WIN32
952     /* On Windows, we don't support capturing on pipes, so we give up. */
953
954     /* On Win32 OSes, the capture devices are probably available to all
955        users; don't warn about permissions problems.
956
957        Do, however, warn that WAN devices aren't supported. */
958     snprintf(errmsg, sizeof errmsg,
959         "The capture session could not be initiated (%s).\n"
960         "Please check that you have the proper interface specified.\n"
961         "\n"
962         "Note that the driver Tethereal uses for packet capture on Windows doesn't\n"
963         "support capturing on PPP/WAN interfaces in Windows NT/2000/XP/.NET Server.\n",
964         open_err_str);
965     goto error;
966 #else
967     /* try to open cfile.iface as a pipe */
968     pipe_fd = pipe_open_live(cfile.iface, &hdr, &ld, errmsg, sizeof errmsg);
969
970     if (pipe_fd == -1) {
971
972       if (ld.pipe_err == PIPNEXIST) {
973         /* Pipe doesn't exist, so output message for interface */
974
975         /* If we got a "can't find PPA for XXX" message, warn the user (who
976            is running Tethereal on HP-UX) that they don't have a version
977            of libpcap that properly handles HP-UX (libpcap 0.6.x and later
978            versions, which properly handle HP-UX, say "can't find /dev/dlpi
979            PPA for XXX" rather than "can't find PPA for XXX"). */
980         if (strncmp(open_err_str, ppamsg, sizeof ppamsg - 1) == 0)
981           libpcap_warn =
982             "\n\n"
983             "You are running Tethereal with a version of the libpcap library\n"
984             "that doesn't handle HP-UX network devices well; this means that\n"
985             "Tethereal may not be able to capture packets.\n"
986             "\n"
987             "To fix this, you should install libpcap 0.6.2, or a later version\n"
988             "of libpcap, rather than libpcap 0.4 or 0.5.x.  It is available in\n"
989             "packaged binary form from the Software Porting And Archive Centre\n"
990             "for HP-UX; the Centre is at http://hpux.connect.org.uk/ - the page\n"
991             "at the URL lists a number of mirror sites.";
992         else
993           libpcap_warn = "";
994         snprintf(errmsg, sizeof errmsg,
995           "The capture session could not be initiated (%s).\n"
996           "Please check to make sure you have sufficient permissions, and that\n"
997           "you have the proper interface or pipe specified.%s", open_err_str,
998           libpcap_warn);
999       }
1000       /*
1001        * Else pipe (or file) does exist and pipe_open_live() has
1002        * filled in errmsg
1003        */
1004       goto error;
1005     } else
1006       /* pipe_open_live() succeeded; don't want
1007          error message from pcap_open_live() */
1008       open_err_str[0] = '\0';
1009 #endif
1010   }
1011
1012   if (cfile.cfilter && !ld.from_pipe) {
1013     /* A capture filter was specified; set it up. */
1014     if (pcap_lookupnet(cfile.iface, &netnum, &netmask, lookup_net_err_str) < 0) {
1015       /*
1016        * Well, we can't get the netmask for this interface; it's used
1017        * only for filters that check for broadcast IP addresses, so
1018        * we just warn the user, and punt and use 0.
1019        */
1020       fprintf(stderr,
1021         "Warning:  Couldn't obtain netmask info (%s).\n", lookup_net_err_str);
1022       netmask = 0;
1023     }
1024     if (pcap_compile(ld.pch, &fcode, cfile.cfilter, 1, netmask) < 0) {
1025       snprintf(errmsg, sizeof errmsg, "Unable to parse filter string (%s).",
1026         pcap_geterr(ld.pch));
1027       goto error;
1028     }
1029     if (pcap_setfilter(ld.pch, &fcode) < 0) {
1030       snprintf(errmsg, sizeof errmsg, "Can't install filter (%s).",
1031         pcap_geterr(ld.pch));
1032       goto error;
1033     }
1034   }
1035
1036   /* Set up to write to the capture file. */
1037 #ifndef _WIN32
1038   if (ld.from_pipe) {
1039     pcap_encap = hdr.network;
1040     file_snaplen = hdr.snaplen;
1041   } else
1042 #endif
1043   {
1044     pcap_encap = get_pcap_linktype(ld.pch, cfile.iface);
1045     file_snaplen = pcap_snapshot(ld.pch);
1046   }
1047   ld.linktype = wtap_pcap_encap_to_wtap_encap(pcap_encap);
1048   if (cfile.save_file != NULL) {
1049     /* Set up to write to the capture file. */
1050     if (ld.linktype == WTAP_ENCAP_UNKNOWN) {
1051       strcpy(errmsg, "The network you're capturing from is of a type"
1052                " that Tethereal doesn't support.");
1053       goto error;
1054     }
1055     if (capture_opts.ringbuffer_on) {
1056       cfile.save_file_fd = ringbuf_init(cfile.save_file,
1057         capture_opts.ringbuffer_num_files);
1058       if (cfile.save_file_fd != -1) {
1059         ld.pdh = ringbuf_init_wtap_dump_fdopen(out_file_type, ld.linktype,
1060           pcap_snapshot(ld.pch), &err);
1061       } else {
1062         err = errno;    /* "ringbuf_init()" failed */
1063         ld.pdh = NULL;
1064       }
1065     } else {
1066       ld.pdh = wtap_dump_open(cfile.save_file, out_file_type,
1067                  ld.linktype, pcap_snapshot(ld.pch), &err);
1068     }
1069
1070     if (ld.pdh == NULL) {
1071       snprintf(errmsg, sizeof errmsg,
1072                file_open_error_message(err, TRUE, out_file_type),
1073                *cfile.save_file == '\0' ? "stdout" : cfile.save_file);
1074       goto error;
1075     }
1076   }
1077
1078   /* Does "open_err_str" contain a non-empty string?  If so, "pcap_open_live()"
1079      returned a warning; print it, but keep capturing. */
1080   if (open_err_str[0] != '\0')
1081     fprintf(stderr, "tethereal: WARNING: %s.\n", open_err_str);
1082
1083 #ifdef _WIN32
1084   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
1085   SetConsoleCtrlHandler(capture_cleanup, TRUE);
1086 #else /* _WIN32 */
1087   /* Catch SIGINT and SIGTERM and, if we get either of them, clean up
1088      and exit.
1089      XXX - deal with signal semantics on various UNIX platforms.  Or just
1090      use "sigaction()" and be done with it? */
1091   signal(SIGTERM, capture_cleanup);
1092   signal(SIGINT, capture_cleanup);
1093   if ((oldhandler = signal(SIGHUP, capture_cleanup)) != SIG_DFL)
1094     signal(SIGHUP, oldhandler);
1095
1096 #ifdef SIGINFO
1097   /* Catch SIGINFO and, if we get it and we're capturing to a file in
1098      quiet mode, report the number of packets we've captured. */
1099   signal(SIGINFO, report_counts_siginfo);
1100 #endif /* SIGINFO */
1101 #endif /* _WIN32 */
1102
1103   /* Let the user know what interface was chosen. */
1104   fprintf(stderr, "Capturing on %s\n", cfile.iface);
1105
1106   /* initialize capture stop conditions */
1107   init_capture_stop_conditions();
1108   /* create stop conditions */
1109   if (capture_opts.has_autostop_filesize)
1110     cnd_stop_capturesize = cnd_new((const char*)CND_CLASS_CAPTURESIZE,
1111                                    (long)capture_opts.autostop_filesize * 1000);
1112   if (capture_opts.has_autostop_duration)
1113     cnd_stop_timeout = cnd_new((const char*)CND_CLASS_TIMEOUT,
1114                                (gint32)capture_opts.autostop_duration);
1115
1116   if (!setjmp(ld.stopenv)) {
1117     ld.go = TRUE;
1118     ld.packet_count = 0;
1119   } else
1120     ld.go = FALSE;
1121   while (ld.go) {
1122     /* We need to be careful with automatic variables defined in the
1123        outer scope which are changed inside the loop.  Most compilers
1124        don't try to roll them back to their original values after the
1125        longjmp which causes the loop to finish, but all that the
1126        standards say is that their values are indeterminate.  If we
1127        don't want them to be rolled back, we should define them with the
1128        volatile attribute (paraphrasing W. Richard Stevens, Advanced
1129        Programming in the UNIX Environment, p. 178).
1130
1131        The "err" variable causes a particular problem.  If we give it
1132        the volatile attribute, then when we pass a reference to it (as
1133        in "&err") to a function, GCC warns: "passing arg <n> of
1134        <function> discards qualifiers from pointer target type".
1135        Therefore within the loop and just beyond we don't use "err".
1136        Within the loop we define "loop_err", and assign its value to
1137        "volatile_err", which is in the outer scope and is checked when
1138        the loop finishes.
1139
1140        We also define "packet_count_prev" here to keep things tidy,
1141        since it's used only inside the loop.  If it were defined in the
1142        outer scope, GCC would give a warning (unnecessary in this case)
1143        that it might be clobbered, and we'd need to give it the volatile
1144        attribute to suppress the warning. */
1145
1146     int loop_err = 0;
1147     int packet_count_prev = 0;
1148
1149     if (cnd_stop_capturesize == NULL && cnd_stop_timeout == NULL) {
1150       /* We're not stopping at a particular capture file size, and we're
1151          not stopping after some particular amount of time has expired,
1152          so either we have no stop condition or the only stop condition
1153          is a maximum packet count.
1154
1155          If there's no maximum packet count, pass it -1, meaning "until
1156          you run out of packets in the bufferful you read".  Otherwise,
1157          pass it the number of packets we have left to capture.
1158
1159          We don't call "pcap_loop()" as, if we're saving to a file that's
1160          a FIFO, we want to flush the FIFO after we're done processing
1161          this libpcap bufferful of packets, so that the program
1162          reading the FIFO sees the packets immediately and doesn't get
1163          any partial packet, forcing it to block in the middle of reading
1164          that packet. */
1165       if (capture_opts.autostop_count == 0)
1166         pcap_cnt = -1;
1167       else {
1168         if (ld.packet_count >= capture_opts.autostop_count) {
1169           /* XXX do we need this test here? */
1170           /* It appears there's nothing more to capture. */
1171           break;
1172         }
1173         pcap_cnt = capture_opts.autostop_count - ld.packet_count;
1174       }
1175     } else {
1176       /* We need to check the capture file size or the timeout after
1177          each packet. */
1178       pcap_cnt = 1;
1179     }
1180 #ifndef _WIN32
1181     if (ld.from_pipe) {
1182       inpkts = pipe_dispatch(pipe_fd, &ld, &hdr, &rechdr, pcap_data,
1183         errmsg, sizeof errmsg);
1184     } else
1185 #endif
1186       inpkts = pcap_dispatch(ld.pch, pcap_cnt, capture_pcap_cb, (guchar *) &ld);
1187     if (inpkts < 0) {
1188       /* Error from "pcap_dispatch()", or error or "no more packets" from
1189          "pipe_dispatch(). */
1190       ld.go = FALSE;
1191     } else if (cnd_stop_timeout != NULL && cnd_eval(cnd_stop_timeout)) {
1192       /* The specified capture time has elapsed; stop the capture. */
1193       ld.go = FALSE;
1194     } else if (inpkts > 0) {
1195       if (capture_opts.autostop_count != 0 &&
1196                  ld.packet_count >= capture_opts.autostop_count) {
1197         /* The specified number of packets have been captured and have
1198            passed both any capture filter in effect and any read filter
1199            in effect. */
1200         ld.go = FALSE;
1201       } else if (cnd_stop_capturesize != NULL &&
1202                     cnd_eval(cnd_stop_capturesize,
1203                               (guint32)wtap_get_bytes_dumped(ld.pdh))) {
1204         /* We're saving the capture to a file, and the capture file reached
1205            its maximum size. */
1206         if (capture_opts.ringbuffer_on) {
1207           /* Switch to the next ringbuffer file */
1208           if (ringbuf_switch_file(&cfile, &ld.pdh, &loop_err)) {
1209             /* File switch succeeded: reset the condition */
1210             cnd_reset(cnd_stop_capturesize);
1211           } else {
1212             /* File switch failed: stop here */
1213             volatile_err = loop_err;
1214             ld.go = FALSE;
1215           }
1216         } else {
1217           /* No ringbuffer - just stop. */
1218           ld.go = FALSE;
1219         }
1220       }
1221       if (ld.output_to_pipe) {
1222         if (ld.packet_count > packet_count_prev) {
1223           if (fflush(wtap_dump_file(ld.pdh))) {
1224             volatile_err = errno;
1225             ld.go = FALSE;
1226           }
1227           packet_count_prev = ld.packet_count;
1228         }
1229       }
1230     } /* inpkts > 0 */
1231   } /* while (ld.go) */
1232
1233   /* delete stop conditions */
1234   if (cnd_stop_capturesize != NULL)
1235     cnd_delete(cnd_stop_capturesize);
1236   if (cnd_stop_timeout != NULL)
1237     cnd_delete(cnd_stop_timeout);
1238
1239   if ((cfile.save_file != NULL) && !quiet) {
1240     /* We're saving to a file, which means we're printing packet counts
1241        to stderr if we are not running silent and deep.
1242        Send a newline so that we move to the line after the packet count. */
1243     fprintf(stderr, "\n");
1244   }
1245
1246   /* If we got an error while capturing, report it. */
1247   if (inpkts < 0) {
1248 #ifndef _WIN32
1249     if (ld.from_pipe) {
1250       if (ld.pipe_err == PIPERR) {
1251         fprintf(stderr, "tethereal: Error while capturing packets: %s\n",
1252           errmsg);
1253       }
1254     } else
1255 #endif
1256     {
1257       fprintf(stderr, "tethereal: Error while capturing packets: %s\n",
1258           pcap_geterr(ld.pch));
1259     }
1260   }
1261
1262   if (volatile_err == 0)
1263     write_err = FALSE;
1264   else {
1265     show_capture_file_io_error(cfile.save_file, volatile_err, FALSE);
1266     write_err = TRUE;
1267   }
1268
1269   if (cfile.save_file != NULL) {
1270     /* We're saving to a file or files; close all files. */
1271     if (capture_opts.ringbuffer_on) {
1272       dump_ok = ringbuf_wtap_dump_close(&cfile, &err);
1273     } else {
1274       dump_ok = wtap_dump_close(ld.pdh, &err);
1275     }
1276     /* If we've displayed a message about a write error, there's no point
1277        in displaying another message about an error on close. */
1278     if (!dump_ok && !write_err)
1279       show_capture_file_io_error(cfile.save_file, err, TRUE);
1280   }
1281
1282 #ifndef _WIN32
1283   if (ld.from_pipe && pipe_fd >= 0)
1284     close(pipe_fd);
1285   else
1286 #endif
1287   {
1288     /* Get the capture statistics, and, if any packets were dropped, report
1289        that. */
1290     if (pcap_stats(ld.pch, &stats) >= 0) {
1291       if (stats.ps_drop != 0) {
1292         fprintf(stderr, "%u packets dropped\n", stats.ps_drop);
1293       }
1294     } else {
1295       fprintf(stderr, "tethereal: Can't get packet-drop statistics: %s\n",
1296           pcap_geterr(ld.pch));
1297     }
1298     pcap_close(ld.pch);
1299   }
1300
1301   /* Report the number of captured packets if not reported during capture
1302      and we are saving to a file. */
1303   report_counts();
1304
1305   return TRUE;
1306
1307 error:
1308   if (capture_opts.ringbuffer_on) {
1309     ringbuf_error_cleanup();
1310   }
1311   g_free(cfile.save_file);
1312   cfile.save_file = NULL;
1313   fprintf(stderr, "tethereal: %s\n", errmsg);
1314 #ifndef _WIN32
1315   if (ld.from_pipe) {
1316     if (pipe_fd >= 0)
1317       close(pipe_fd);
1318   } else
1319 #endif
1320   {
1321   if (ld.pch != NULL)
1322     pcap_close(ld.pch);
1323   }
1324
1325   return FALSE;
1326 }
1327
1328 static void
1329 capture_pcap_cb(guchar *user, const struct pcap_pkthdr *phdr,
1330   const guchar *pd)
1331 {
1332   struct wtap_pkthdr whdr;
1333   union wtap_pseudo_header pseudo_header;
1334   loop_data *ld = (loop_data *) user;
1335   cb_args_t args;
1336   int err;
1337
1338   /* Convert from libpcap to Wiretap format.
1339      If that fails, ignore the packet (wtap_process_pcap_packet has
1340      written an error message). */
1341   pd = wtap_process_pcap_packet(ld->linktype, phdr, pd, &pseudo_header,
1342                                 &whdr, &err);
1343   if (pd == NULL) {
1344     return;
1345   }
1346
1347   args.cf = &cfile;
1348   args.pdh = ld->pdh;
1349   if (ld->pdh) {
1350     wtap_dispatch_cb_write((guchar *)&args, &whdr, 0, &pseudo_header, pd);
1351     /* Report packet capture count if not quiet */
1352     if (!quiet) {
1353       if (!decode) {
1354          if (ld->packet_count != 0) {
1355            fprintf(stderr, "\r%u ", ld->packet_count);
1356            /* stderr could be line buffered */
1357            fflush(stderr);
1358          }
1359       } else {
1360            wtap_dispatch_cb_print((guchar *)&args, &whdr, 0,
1361                                   &pseudo_header, pd);
1362       }
1363     }
1364   } else {
1365     wtap_dispatch_cb_print((guchar *)&args, &whdr, 0, &pseudo_header, pd);
1366   }
1367 }
1368
1369 #ifdef _WIN32
1370 static BOOL WINAPI
1371 capture_cleanup(DWORD ctrltype _U_)
1372 {
1373   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
1374      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
1375      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
1376      like SIGTERM at least when the machine's shutting down.
1377
1378      For now, we handle them all as indications that we should clean up
1379      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
1380      way on UNIX.
1381
1382      However, as handlers run in a new thread, we can't just longjmp
1383      out; we have to set "ld.go" to FALSE, and must return TRUE so that
1384      no other handler - such as one that would terminate the process -
1385      gets called.
1386
1387      XXX - for some reason, typing ^C to Tethereal, if you run this in
1388      a Cygwin console window in at least some versions of Cygwin,
1389      causes Tethereal to terminate immediately; this routine gets
1390      called, but the main loop doesn't get a chance to run and
1391      exit cleanly, at least if this is compiled with Microsoft Visual
1392      C++ (i.e., it's a property of the Cygwin console window or Bash;
1393      it happens if Tethereal is not built with Cygwin - for all I know,
1394      building it with Cygwin may make the problem go away). */
1395   ld.go = FALSE;
1396   return TRUE;
1397 }
1398 #else
1399 static void
1400 capture_cleanup(int signum _U_)
1401 {
1402   /* Longjmp back to the starting point; "pcap_dispatch()", on many
1403      UNIX platforms, just keeps looping if it gets EINTR, so if we set
1404      "ld.go" to FALSE and return, we won't break out of it and quit
1405      capturing. */
1406   longjmp(ld.stopenv, 1);
1407 }
1408 #endif /* _WIN32 */
1409
1410 static void
1411 report_counts(void)
1412 {
1413 #ifdef SIGINFO
1414   /* XXX - if we use sigaction, this doesn't have to be done.
1415      (Yes, this isn't necessary on BSD, but just in case a system
1416      where "signal()" has AT&T semantics adopts SIGINFO....) */
1417   signal(SIGINFO, report_counts_siginfo);
1418 #endif /* SIGINFO */
1419
1420   if (cfile.save_file != NULL && quiet) {
1421     /* Report the count only if we're capturing to a file (rather
1422        than printing captured packet information out) and aren't
1423        updating a count as packets arrive. */
1424     fprintf(stderr, "%u packets captured\n", ld.packet_count);
1425   }
1426 #ifdef SIGINFO
1427   infoprint = FALSE;    /* we just reported it */
1428 #endif /* SIGINFO */
1429 }
1430
1431 #ifdef SIGINFO
1432 static void
1433 report_counts_siginfo(int signum _U_)
1434 {
1435   /* If we've been told to delay printing, just set a flag asking
1436      that we print counts (if we're supposed to), otherwise print
1437      the count of packets captured (if we're supposed to). */
1438   if (infodelay)
1439     infoprint = TRUE;
1440   else
1441     report_counts();
1442 }
1443 #endif /* SIGINFO */
1444 #endif /* HAVE_LIBPCAP */
1445
1446 static int
1447 load_cap_file(capture_file *cf, int out_file_type)
1448 {
1449   gint         linktype;
1450   int          snapshot_length;
1451   wtap_dumper *pdh;
1452   int          err;
1453   int          success;
1454   cb_args_t    args;
1455
1456   linktype = wtap_file_encap(cf->wth);
1457   if (cf->save_file != NULL) {
1458     /* Set up to write to the capture file. */
1459     snapshot_length = wtap_snapshot_length(cf->wth);
1460     if (snapshot_length == 0) {
1461       /* Snapshot length of input file not known. */
1462       snapshot_length = WTAP_MAX_PACKET_SIZE;
1463     }
1464     pdh = wtap_dump_open(cf->save_file, out_file_type,
1465                 linktype, snapshot_length, &err);
1466
1467     if (pdh == NULL) {
1468       /* We couldn't set up to write to the capture file. */
1469       switch (err) {
1470
1471       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
1472         fprintf(stderr,
1473                 "tethereal: Capture files can't be written in that format.\n");
1474         break;
1475
1476       case WTAP_ERR_UNSUPPORTED_ENCAP:
1477       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
1478         fprintf(stderr,
1479           "tethereal: The capture file being read cannot be written in "
1480           "that format.\n");
1481         break;
1482
1483       case WTAP_ERR_CANT_OPEN:
1484         fprintf(stderr,
1485           "tethereal: The file \"%s\" couldn't be created for some "
1486           "unknown reason.\n",
1487             *cf->save_file == '\0' ? "stdout" : cf->save_file);
1488         break;
1489
1490       case WTAP_ERR_SHORT_WRITE:
1491         fprintf(stderr,
1492           "tethereal: A full header couldn't be written to the file \"%s\".\n",
1493                 *cf->save_file == '\0' ? "stdout" : cf->save_file);
1494         break;
1495
1496       default:
1497         fprintf(stderr,
1498           "tethereal: The file \"%s\" could not be created: %s\n.",
1499                 *cf->save_file == '\0' ? "stdout" : cf->save_file,
1500                 wtap_strerror(err));
1501         break;
1502       }
1503       goto out;
1504     }
1505     args.cf = cf;
1506     args.pdh = pdh;
1507     success = wtap_loop(cf->wth, 0, wtap_dispatch_cb_write, (guchar *) &args,
1508                         &err);
1509
1510     /* Now close the capture file. */
1511     if (!wtap_dump_close(pdh, &err))
1512       show_capture_file_io_error(cfile.save_file, err, TRUE);
1513   } else {
1514     args.cf = cf;
1515     args.pdh = NULL;
1516     success = wtap_loop(cf->wth, 0, wtap_dispatch_cb_print, (guchar *) &args,
1517                         &err);
1518   }
1519   if (!success) {
1520     /* Print up a message box noting that the read failed somewhere along
1521        the line. */
1522     switch (err) {
1523
1524     case WTAP_ERR_UNSUPPORTED_ENCAP:
1525       fprintf(stderr,
1526 "tethereal: \"%s\" is a capture file is for a network type that Tethereal doesn't support.\n",
1527         cf->filename);
1528       break;
1529
1530     case WTAP_ERR_CANT_READ:
1531       fprintf(stderr,
1532 "tethereal: An attempt to read from \"%s\" failed for some unknown reason.\n",
1533         cf->filename);
1534       break;
1535
1536     case WTAP_ERR_SHORT_READ:
1537       fprintf(stderr,
1538 "tethereal: \"%s\" appears to have been cut short in the middle of a packet.\n",
1539         cf->filename);
1540       break;
1541
1542     case WTAP_ERR_BAD_RECORD:
1543       fprintf(stderr,
1544 "tethereal: \"%s\" appears to be damaged or corrupt.\n",
1545         cf->filename);
1546       break;
1547
1548     default:
1549       fprintf(stderr,
1550 "tethereal: An error occurred while reading \"%s\": %s.\n",
1551         cf->filename, wtap_strerror(err));
1552       break;
1553     }
1554   }
1555
1556 out:
1557   wtap_close(cf->wth);
1558   cf->wth = NULL;
1559
1560   return err;
1561 }
1562
1563 static void
1564 fill_in_fdata(frame_data *fdata, capture_file *cf,
1565         const struct wtap_pkthdr *phdr, long offset)
1566 {
1567   fdata->next = NULL;
1568   fdata->prev = NULL;
1569   fdata->pfd = NULL;
1570   fdata->num = cf->count;
1571   fdata->pkt_len = phdr->len;
1572   fdata->cap_len = phdr->caplen;
1573   fdata->file_off = offset;
1574   fdata->lnk_t = phdr->pkt_encap;
1575   fdata->abs_secs  = phdr->ts.tv_sec;
1576   fdata->abs_usecs = phdr->ts.tv_usec;
1577   fdata->flags.passed_dfilter = 0;
1578   fdata->flags.encoding = CHAR_ASCII;
1579   fdata->flags.visited = 0;
1580   fdata->flags.marked = 0;
1581
1582   /* If we don't have the time stamp of the first packet in the
1583      capture, it's because this is the first packet.  Save the time
1584      stamp of this packet as the time stamp of the first packet. */
1585   if (!firstsec && !firstusec) {
1586     firstsec  = fdata->abs_secs;
1587     firstusec = fdata->abs_usecs;
1588   }
1589
1590   /* If we don't have the time stamp of the previous displayed packet,
1591      it's because this is the first displayed packet.  Save the time
1592      stamp of this packet as the time stamp of the previous displayed
1593      packet. */
1594   if (!prevsec && !prevusec) {
1595     prevsec  = fdata->abs_secs;
1596     prevusec = fdata->abs_usecs;
1597   }
1598
1599   /* Get the time elapsed between the first packet and this packet. */
1600   compute_timestamp_diff(&fdata->rel_secs, &fdata->rel_usecs,
1601                 fdata->abs_secs, fdata->abs_usecs, firstsec, firstusec);
1602
1603   /* If it's greater than the current elapsed time, set the elapsed time
1604      to it (we check for "greater than" so as not to be confused by
1605      time moving backwards). */
1606   if ((gint32)cf->esec < fdata->rel_secs
1607         || ((gint32)cf->esec == fdata->rel_secs && (gint32)cf->eusec < fdata->rel_usecs)) {
1608     cf->esec = fdata->rel_secs;
1609     cf->eusec = fdata->rel_usecs;
1610   }
1611
1612   /* Get the time elapsed between the previous displayed packet and
1613      this packet. */
1614   compute_timestamp_diff(&fdata->del_secs, &fdata->del_usecs,
1615                 fdata->abs_secs, fdata->abs_usecs, prevsec, prevusec);
1616   prevsec = fdata->abs_secs;
1617   prevusec = fdata->abs_usecs;
1618 }
1619
1620 /* Free up all data attached to a "frame_data" structure. */
1621 static void
1622 clear_fdata(frame_data *fdata)
1623 {
1624   if (fdata->pfd)
1625     g_slist_free(fdata->pfd);
1626 }
1627
1628 static void
1629 wtap_dispatch_cb_write(guchar *user, const struct wtap_pkthdr *phdr,
1630   long offset, union wtap_pseudo_header *pseudo_header, const guchar *buf)
1631 {
1632   cb_args_t    *args = (cb_args_t *) user;
1633   capture_file *cf = args->cf;
1634   wtap_dumper  *pdh = args->pdh;
1635   frame_data    fdata;
1636   int           err;
1637   gboolean      passed;
1638   epan_dissect_t *edt;
1639
1640 #ifdef SIGINFO
1641   /*
1642    * Prevent a SIGINFO handler from writing to stdout while we're
1643    * doing so; instead, have it just set a flag telling us to print
1644    * that information when we're done.
1645    */
1646   infodelay = TRUE;
1647 #endif /* SIGINFO */
1648
1649   cf->count++;
1650   if (cf->rfcode) {
1651     fill_in_fdata(&fdata, cf, phdr, offset);
1652     edt = epan_dissect_new(TRUE, FALSE);
1653     epan_dissect_prime_dfilter(edt, cf->rfcode);
1654     epan_dissect_run(edt, pseudo_header, buf, &fdata, NULL);
1655     passed = dfilter_apply_edt(cf->rfcode, edt);
1656   } else {
1657     passed = TRUE;
1658     edt = NULL;
1659   }
1660   if (passed) {
1661     /* The packet passed the read filter. */
1662 #ifdef HAVE_LIBPCAP
1663     ld.packet_count++;
1664 #endif
1665     if (!wtap_dump(pdh, phdr, pseudo_header, buf, &err)) {
1666 #ifdef HAVE_LIBPCAP
1667       if (ld.pch != NULL && !quiet) {
1668         /* We're capturing packets, so (if -q not specified) we're printing
1669            a count of packets captured; move to the line after the count. */
1670         fprintf(stderr, "\n");
1671       }
1672 #endif
1673       show_capture_file_io_error(cf->save_file, err, FALSE);
1674 #ifdef HAVE_LIBPCAP
1675       if (ld.pch != NULL)
1676         pcap_close(ld.pch);
1677 #endif
1678       wtap_dump_close(pdh, &err);
1679       exit(2);
1680     }
1681   }
1682   if (edt != NULL)
1683     epan_dissect_free(edt);
1684   if (cf->rfcode)
1685     clear_fdata(&fdata);
1686
1687 #ifdef SIGINFO
1688   /*
1689    * Allow SIGINFO handlers to write.
1690    */
1691   infodelay = FALSE;
1692
1693   /*
1694    * If a SIGINFO handler asked us to write out capture counts, do so.
1695    */
1696   if (infoprint)
1697     report_counts();
1698 #endif /* SIGINFO */
1699 }
1700
1701 static void
1702 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
1703 {
1704   if (*fname == '\0')
1705     fname = "stdout";
1706
1707   switch (err) {
1708
1709   case ENOSPC:
1710     fprintf(stderr,
1711 "tethereal: Not all the packets could be written to \"%s\" because there is "
1712 "no space left on the file system.\n",
1713         fname);
1714     break;
1715
1716 #ifdef EDQUOT
1717   case EDQUOT:
1718     fprintf(stderr,
1719 "tethereal: Not all the packets could be written to \"%s\" because you are "
1720 "too close to, or over your disk quota.\n",
1721         fname);
1722   break;
1723 #endif
1724
1725   case WTAP_ERR_CANT_CLOSE:
1726     fprintf(stderr,
1727 "tethereal: \"%s\" couldn't be closed for some unknown reason.\n",
1728         fname);
1729     break;
1730
1731   case WTAP_ERR_SHORT_WRITE:
1732     fprintf(stderr,
1733 "tethereal: Not all the packets could be written to \"%s\".\n",
1734         fname);
1735     break;
1736
1737   default:
1738     if (is_close) {
1739       fprintf(stderr,
1740 "tethereal: \"%s\" could not be closed: %s.\n",
1741         fname, wtap_strerror(err));
1742     } else {
1743       fprintf(stderr,
1744 "tethereal: An error occurred while writing to \"%s\": %s.\n",
1745         fname, wtap_strerror(err));
1746     }
1747     break;
1748   }
1749 }
1750
1751 static void
1752 wtap_dispatch_cb_print(guchar *user, const struct wtap_pkthdr *phdr,
1753   long offset, union wtap_pseudo_header *pseudo_header, const guchar *buf)
1754 {
1755   cb_args_t    *args = (cb_args_t *) user;
1756   capture_file *cf = args->cf;
1757   frame_data    fdata;
1758   gboolean      passed;
1759   print_args_t  print_args;
1760   epan_dissect_t *edt;
1761   gboolean      create_proto_tree;
1762   int           i;
1763
1764   cf->count++;
1765
1766   fill_in_fdata(&fdata, cf, phdr, offset);
1767
1768   passed = TRUE;
1769   if (cf->rfcode || verbose || num_tap_filters!=0)
1770     create_proto_tree = TRUE;
1771   else
1772     create_proto_tree = FALSE;
1773   /* The protocol tree will be "visible", i.e., printed, only if we're
1774      not printing a summary.
1775
1776      We only need the columns if we're *not* verbose; in verbose mode,
1777      we print the protocol tree, not the protocol summary. */
1778
1779   edt = epan_dissect_new(create_proto_tree, verbose);
1780   if (cf->rfcode) {
1781     epan_dissect_prime_dfilter(edt, cf->rfcode);
1782   }
1783
1784   tap_queue_init(edt);
1785   epan_dissect_run(edt, pseudo_header, buf, &fdata, verbose ? NULL : &cf->cinfo);
1786   tap_push_tapped_queue(edt);
1787
1788   if (cf->rfcode) {
1789     passed = dfilter_apply_edt(cf->rfcode, edt);
1790   }
1791   if (passed) {
1792     /* The packet passed the read filter. */
1793 #ifdef HAVE_LIBPCAP
1794     ld.packet_count++;
1795 #endif
1796     if (verbose) {
1797       /* Print the information in the protocol tree. */
1798       print_args.to_file = TRUE;
1799       print_args.format = PR_FMT_TEXT;
1800       print_args.print_summary = FALSE;
1801       print_args.print_hex = print_hex;
1802       print_args.expand_all = TRUE;
1803       print_args.suppress_unmarked = FALSE;
1804       proto_tree_print(&print_args, edt, stdout);
1805       if (!print_hex) {
1806         /* "print_hex_data()" will put out a leading blank line, as well
1807            as a trailing one; print one here, to separate the packets,
1808            only if "print_hex_data()" won't be called. */
1809         printf("\n");
1810       }
1811     } else {
1812       /* Just fill in the columns. */
1813       epan_dissect_fill_in_columns(edt);
1814
1815       /* Now print them. */
1816       for (i = 0; i < cf->cinfo.num_cols; i++) {
1817         switch (cf->cinfo.col_fmt[i]) {
1818         case COL_NUMBER:
1819           /*
1820            * Don't print this if we're doing a live capture from a network
1821            * interface - if we're doing a live capture, you won't be
1822            * able to look at the capture in the future (it's not being
1823            * saved anywhere), so the frame numbers are unlikely to be
1824            * useful.
1825            *
1826            * (XXX - it might be nice to be able to save and print at
1827            * the same time, sort of like an "Update list of packets
1828            * in real time" capture in Ethereal.)
1829            */
1830           if (cf->iface != NULL)
1831             continue;
1832           printf("%3s", cf->cinfo.col_data[i]);
1833           break;
1834
1835         case COL_CLS_TIME:
1836         case COL_REL_TIME:
1837         case COL_ABS_TIME:
1838         case COL_ABS_DATE_TIME: /* XXX - wider */
1839           printf("%10s", cf->cinfo.col_data[i]);
1840           break;
1841
1842         case COL_DEF_SRC:
1843         case COL_RES_SRC:
1844         case COL_UNRES_SRC:
1845         case COL_DEF_DL_SRC:
1846         case COL_RES_DL_SRC:
1847         case COL_UNRES_DL_SRC:
1848         case COL_DEF_NET_SRC:
1849         case COL_RES_NET_SRC:
1850         case COL_UNRES_NET_SRC:
1851           printf("%12s", cf->cinfo.col_data[i]);
1852           break;
1853
1854         case COL_DEF_DST:
1855         case COL_RES_DST:
1856         case COL_UNRES_DST:
1857         case COL_DEF_DL_DST:
1858         case COL_RES_DL_DST:
1859         case COL_UNRES_DL_DST:
1860         case COL_DEF_NET_DST:
1861         case COL_RES_NET_DST:
1862         case COL_UNRES_NET_DST:
1863           printf("%-12s", cf->cinfo.col_data[i]);
1864           break;
1865
1866         default:
1867           printf("%s", cf->cinfo.col_data[i]);
1868           break;
1869         }
1870         if (i != cf->cinfo.num_cols - 1) {
1871           /*
1872            * This isn't the last column, so we need to print a
1873            * separator between this column and the next.
1874            *
1875            * If we printed a network source and are printing a
1876            * network destination of the same type next, separate
1877            * them with "->"; if we printed a network destination
1878            * and are printing a network source of the same type
1879            * next, separate them with "<-"; otherwise separate them
1880            * with a space.
1881            */
1882           switch (cf->cinfo.col_fmt[i]) {
1883
1884           case COL_DEF_SRC:
1885           case COL_RES_SRC:
1886           case COL_UNRES_SRC:
1887             switch (cf->cinfo.col_fmt[i + 1]) {
1888
1889             case COL_DEF_DST:
1890             case COL_RES_DST:
1891             case COL_UNRES_DST:
1892               printf(" -> ");
1893               break;
1894
1895             default:
1896               putchar(' ');
1897               break;
1898             }
1899             break;
1900
1901           case COL_DEF_DL_SRC:
1902           case COL_RES_DL_SRC:
1903           case COL_UNRES_DL_SRC:
1904             switch (cf->cinfo.col_fmt[i + 1]) {
1905
1906             case COL_DEF_DL_DST:
1907             case COL_RES_DL_DST:
1908             case COL_UNRES_DL_DST:
1909               printf(" -> ");
1910               break;
1911
1912             default:
1913               putchar(' ');
1914               break;
1915             }
1916             break;
1917
1918           case COL_DEF_NET_SRC:
1919           case COL_RES_NET_SRC:
1920           case COL_UNRES_NET_SRC:
1921             switch (cf->cinfo.col_fmt[i + 1]) {
1922
1923             case COL_DEF_NET_DST:
1924             case COL_RES_NET_DST:
1925             case COL_UNRES_NET_DST:
1926               printf(" -> ");
1927               break;
1928
1929             default:
1930               putchar(' ');
1931               break;
1932             }
1933             break;
1934
1935           case COL_DEF_DST:
1936           case COL_RES_DST:
1937           case COL_UNRES_DST:
1938             switch (cf->cinfo.col_fmt[i + 1]) {
1939
1940             case COL_DEF_SRC:
1941             case COL_RES_SRC:
1942             case COL_UNRES_SRC:
1943               printf(" <- ");
1944               break;
1945
1946             default:
1947               putchar(' ');
1948               break;
1949             }
1950             break;
1951
1952           case COL_DEF_DL_DST:
1953           case COL_RES_DL_DST:
1954           case COL_UNRES_DL_DST:
1955             switch (cf->cinfo.col_fmt[i + 1]) {
1956
1957             case COL_DEF_DL_SRC:
1958             case COL_RES_DL_SRC:
1959             case COL_UNRES_DL_SRC:
1960               printf(" <- ");
1961               break;
1962
1963             default:
1964               putchar(' ');
1965               break;
1966             }
1967             break;
1968
1969           case COL_DEF_NET_DST:
1970           case COL_RES_NET_DST:
1971           case COL_UNRES_NET_DST:
1972             switch (cf->cinfo.col_fmt[i + 1]) {
1973
1974             case COL_DEF_NET_SRC:
1975             case COL_RES_NET_SRC:
1976             case COL_UNRES_NET_SRC:
1977               printf(" <- ");
1978               break;
1979
1980             default:
1981               putchar(' ');
1982               break;
1983             }
1984             break;
1985
1986           default:
1987             putchar(' ');
1988             break;
1989           }
1990         }
1991       }
1992       putchar('\n');
1993     }
1994     if (print_hex) {
1995       print_hex_data(stdout, print_args.format, edt);
1996       putchar('\n');
1997     }
1998   }
1999
2000   /* The ANSI C standard does not appear to *require* that a line-buffered
2001      stream be flushed to the host environment whenever a newline is
2002      written, it just says that, on such a stream, characters "are
2003      intended to be transmitted to or from the host environment as a
2004      block when a new-line character is encountered".
2005
2006      The Visual C++ 6.0 C implementation doesn't do what is intended;
2007      even if you set a stream to be line-buffered, it still doesn't
2008      flush the buffer at the end of every line.
2009
2010      So, if the "-l" flag was specified, we flush the standard output
2011      at the end of a packet.  This will do the right thing if we're
2012      printing packet summary lines, and, as we print the entire protocol
2013      tree for a single packet without waiting for anything to happen,
2014      it should be as good as line-buffered mode if we're printing
2015      protocol trees.  (The whole reason for the "-l" flag in either
2016      tcpdump or Tethereal is to allow the output of a live capture to
2017      be piped to a program or script and to have that script see the
2018      information for the packet as soon as it's printed, rather than
2019      having to wait until a standard I/O buffer fills up. */
2020   if (line_buffered)
2021     fflush(stdout);
2022
2023   epan_dissect_free(edt);
2024
2025   clear_fdata(&fdata);
2026 }
2027
2028 char *
2029 file_open_error_message(int err, gboolean for_writing, int file_type)
2030 {
2031   char *errmsg;
2032   static char errmsg_errno[1024+1];
2033
2034   switch (err) {
2035
2036   case WTAP_ERR_NOT_REGULAR_FILE:
2037     errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
2038     break;
2039
2040   case WTAP_ERR_FILE_UNKNOWN_FORMAT:
2041   case WTAP_ERR_UNSUPPORTED:
2042     /* Seen only when opening a capture file for reading. */
2043     errmsg = "The file \"%s\" is not a capture file in a format Tethereal understands.";
2044     break;
2045
2046   case WTAP_ERR_CANT_WRITE_TO_PIPE:
2047     /* Seen only when opening a capture file for writing. */
2048     snprintf(errmsg_errno, sizeof(errmsg_errno),
2049              "The file \"%%s\" is a pipe, and %s capture files cannot be "
2050              "written to a pipe.", wtap_file_type_string(file_type));
2051     errmsg = errmsg_errno;
2052     break;
2053
2054   case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
2055     /* Seen only when opening a capture file for writing. */
2056     errmsg = "Tethereal does not support writing capture files in that format.";
2057     break;
2058
2059   case WTAP_ERR_UNSUPPORTED_ENCAP:
2060   case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
2061     if (for_writing)
2062       errmsg = "Tethereal cannot save this capture in that format.";
2063     else
2064       errmsg = "The file \"%s\" is a capture for a network type that Tethereal doesn't support.";
2065     break;
2066
2067   case WTAP_ERR_BAD_RECORD:
2068     errmsg = "The file \"%s\" appears to be damaged or corrupt.";
2069     break;
2070
2071   case WTAP_ERR_CANT_OPEN:
2072     if (for_writing)
2073       errmsg = "The file \"%s\" could not be created for some unknown reason.";
2074     else
2075       errmsg = "The file \"%s\" could not be opened for some unknown reason.";
2076     break;
2077
2078   case WTAP_ERR_SHORT_READ:
2079     errmsg = "The file \"%s\" appears to have been cut short"
2080              " in the middle of a packet or other data.";
2081     break;
2082
2083   case WTAP_ERR_SHORT_WRITE:
2084     errmsg = "A full header couldn't be written to the file \"%s\".";
2085     break;
2086
2087   case ENOENT:
2088     if (for_writing)
2089       errmsg = "The path to the file \"%s\" does not exist.";
2090     else
2091       errmsg = "The file \"%s\" does not exist.";
2092     break;
2093
2094   case EACCES:
2095     if (for_writing)
2096       errmsg = "You do not have permission to create or write to the file \"%s\".";
2097     else
2098       errmsg = "You do not have permission to read the file \"%s\".";
2099     break;
2100
2101   case EISDIR:
2102     errmsg = "\"%s\" is a directory (folder), not a file.";
2103     break;
2104
2105   default:
2106     snprintf(errmsg_errno, sizeof(errmsg_errno),
2107              "The file \"%%s\" could not be %s: %s.",
2108              for_writing ? "created" : "opened",
2109              wtap_strerror(err));
2110     errmsg = errmsg_errno;
2111     break;
2112   }
2113   return errmsg;
2114 }
2115
2116 int
2117 open_cap_file(char *fname, gboolean is_tempfile, capture_file *cf)
2118 {
2119   wtap       *wth;
2120   int         err;
2121   char        err_msg[2048+1];
2122
2123   wth = wtap_open_offline(fname, &err, FALSE);
2124   if (wth == NULL)
2125     goto fail;
2126
2127   /* The open succeeded.  Fill in the information for this file. */
2128
2129   /* Initialize all data structures used for dissection. */
2130   init_dissection();
2131
2132   cf->wth = wth;
2133   cf->filed = -1;       /* not used, but set it anyway */
2134   cf->f_len = 0;        /* not used, but set it anyway */
2135
2136   /* Set the file name because we need it to set the follow stream filter.
2137      XXX - is that still true?  We need it for other reasons, though,
2138      in any case. */
2139   cf->filename = g_strdup(fname);
2140
2141   /* Indicate whether it's a permanent or temporary file. */
2142   cf->is_tempfile = is_tempfile;
2143
2144   /* If it's a temporary capture buffer file, mark it as not saved. */
2145   cf->user_saved = !is_tempfile;
2146
2147   cf->cd_t      = wtap_file_type(cf->wth);
2148   cf->count     = 0;
2149   cf->drops_known = FALSE;
2150   cf->drops     = 0;
2151   cf->esec      = 0;
2152   cf->eusec     = 0;
2153   cf->snap      = wtap_snapshot_length(cf->wth);
2154   if (cf->snap == 0) {
2155     /* Snapshot length not known. */
2156     cf->has_snap = FALSE;
2157     cf->snap = WTAP_MAX_PACKET_SIZE;
2158   } else
2159     cf->has_snap = TRUE;
2160   cf->progbar_quantum = 0;
2161   cf->progbar_nextstep = 0;
2162   firstsec = 0, firstusec = 0;
2163   prevsec = 0, prevusec = 0;
2164
2165   return (0);
2166
2167 fail:
2168   snprintf(err_msg, sizeof err_msg, file_open_error_message(err, FALSE, 0),
2169            fname);
2170   fprintf(stderr, "tethereal: %s\n", err_msg);
2171   return (err);
2172 }
2173
2174 #ifndef _WIN32
2175 /* Take care of byte order in the libpcap headers read from pipes.
2176  * (function taken from wiretap/libpcap.c) */
2177 static void
2178 adjust_header(loop_data *ld, struct pcap_hdr *hdr, struct pcaprec_hdr *rechdr)
2179 {
2180   if (ld->byte_swapped) {
2181     /* Byte-swap the record header fields. */
2182     rechdr->ts_sec = BSWAP32(rechdr->ts_sec);
2183     rechdr->ts_usec = BSWAP32(rechdr->ts_usec);
2184     rechdr->incl_len = BSWAP32(rechdr->incl_len);
2185     rechdr->orig_len = BSWAP32(rechdr->orig_len);
2186   }
2187
2188   /* In file format version 2.3, the "incl_len" and "orig_len" fields were
2189      swapped, in order to match the BPF header layout.
2190
2191      Unfortunately, some files were, according to a comment in the "libpcap"
2192      source, written with version 2.3 in their headers but without the
2193      interchanged fields, so if "incl_len" is greater than "orig_len" - which
2194      would make no sense - we assume that we need to swap them.  */
2195   if (hdr->version_major == 2 &&
2196       (hdr->version_minor < 3 ||
2197        (hdr->version_minor == 3 && rechdr->incl_len > rechdr->orig_len))) {
2198     guint32 temp;
2199
2200     temp = rechdr->orig_len;
2201     rechdr->orig_len = rechdr->incl_len;
2202     rechdr->incl_len = temp;
2203   }
2204 }
2205
2206 /* Mimic pcap_open_live() for pipe captures
2207  * We check if "pipename" is "-" (stdin) or a FIFO, open it, and read the
2208  * header.
2209  * N.B. : we can't read the libpcap formats used in RedHat 6.1 or SuSE 6.3
2210  * because we can't seek on pipes (see wiretap/libpcap.c for details) */
2211 static int
2212 pipe_open_live(char *pipename, struct pcap_hdr *hdr, loop_data *ld,
2213                  char *errmsg, int errmsgl)
2214 {
2215   struct stat pipe_stat;
2216   int         fd;
2217   guint32     magic;
2218   int         b;
2219   unsigned int bytes_read;
2220
2221   /*
2222    * XXX Tethereal blocks until we return
2223    */
2224   if (strcmp(pipename, "-") == 0)
2225     fd = 0; /* read from stdin */
2226   else {
2227     if (stat(pipename, &pipe_stat) < 0) {
2228       if (errno == ENOENT || errno == ENOTDIR)
2229         ld->pipe_err = PIPNEXIST;
2230       else {
2231         snprintf(errmsg, errmsgl,
2232           "The capture session could not be initiated "
2233           "due to error on pipe: %s", strerror(errno));
2234         ld->pipe_err = PIPERR;
2235       }
2236       return -1;
2237     }
2238     if (! S_ISFIFO(pipe_stat.st_mode)) {
2239       if (S_ISCHR(pipe_stat.st_mode)) {
2240         /*
2241          * Assume the user specified an interface on a system where
2242          * interfaces are in /dev.  Pretend we haven't seen it.
2243          */
2244          ld->pipe_err = PIPNEXIST;
2245       } else {
2246         snprintf(errmsg, errmsgl,
2247             "The capture session could not be initiated because\n"
2248             "\"%s\" is neither an interface nor a pipe", pipename);
2249         ld->pipe_err = PIPERR;
2250       }
2251       return -1;
2252     }
2253     fd = open(pipename, O_RDONLY);
2254     if (fd == -1) {
2255       snprintf(errmsg, errmsgl,
2256           "The capture session could not be initiated "
2257           "due to error on pipe open: %s", strerror(errno));
2258       ld->pipe_err = PIPERR;
2259       return -1;
2260     }
2261   }
2262
2263   ld->from_pipe = TRUE;
2264
2265   /* read the pcap header */
2266   bytes_read = 0;
2267   while (bytes_read < sizeof magic) {
2268     b = read(fd, ((char *)&magic)+bytes_read, sizeof magic-bytes_read);
2269     if (b <= 0) {
2270       if (b == 0)
2271         snprintf(errmsg, errmsgl, "End of file on pipe during open");
2272       else
2273         snprintf(errmsg, errmsgl, "Error on pipe during open: %s",
2274           strerror(errno));
2275       goto error;
2276     }
2277     bytes_read += b;
2278   }
2279
2280   switch (magic) {
2281   case PCAP_MAGIC:
2282     /* Host that wrote it has our byte order, and was running
2283        a program using either standard or ss990417 libpcap. */
2284     ld->byte_swapped = FALSE;
2285     ld->modified = FALSE;
2286     break;
2287   case PCAP_MODIFIED_MAGIC:
2288     /* Host that wrote it has our byte order, but was running
2289        a program using either ss990915 or ss991029 libpcap. */
2290     ld->byte_swapped = FALSE;
2291     ld->modified = TRUE;
2292     break;
2293   case PCAP_SWAPPED_MAGIC:
2294     /* Host that wrote it has a byte order opposite to ours,
2295        and was running a program using either standard or
2296        ss990417 libpcap. */
2297     ld->byte_swapped = TRUE;
2298     ld->modified = FALSE;
2299     break;
2300   case PCAP_SWAPPED_MODIFIED_MAGIC:
2301     /* Host that wrote it out has a byte order opposite to
2302        ours, and was running a program using either ss990915
2303        or ss991029 libpcap. */
2304     ld->byte_swapped = TRUE;
2305     ld->modified = TRUE;
2306     break;
2307   default:
2308     /* Not a "libpcap" type we know about. */
2309     snprintf(errmsg, errmsgl, "Unrecognized libpcap format");
2310     goto error;
2311   }
2312
2313   /* Read the rest of the header */
2314   bytes_read = 0;
2315   while (bytes_read < sizeof(struct pcap_hdr)) {
2316     b = read(fd, ((char *)hdr)+bytes_read,
2317           sizeof(struct pcap_hdr) - bytes_read);
2318     if (b <= 0) {
2319       if (b == 0)
2320         snprintf(errmsg, errmsgl, "End of file on pipe during open");
2321       else
2322         snprintf(errmsg, errmsgl, "Error on pipe during open: %s",
2323           strerror(errno));
2324       goto error;
2325     }
2326     bytes_read += b;
2327   }
2328
2329   if (ld->byte_swapped) {
2330     /* Byte-swap the header fields about which we care. */
2331     hdr->version_major = BSWAP16(hdr->version_major);
2332     hdr->version_minor = BSWAP16(hdr->version_minor);
2333     hdr->snaplen = BSWAP32(hdr->snaplen);
2334     hdr->network = BSWAP32(hdr->network);
2335   }
2336
2337   if (hdr->version_major < 2) {
2338     snprintf(errmsg, errmsgl, "Unable to read old libpcap format");
2339     goto error;
2340   }
2341
2342   ld->pipe_state = STATE_EXPECT_REC_HDR;
2343   ld->pipe_err = PIPOK;
2344   return fd;
2345
2346 error:
2347   ld->pipe_err = PIPERR;
2348   close(fd);
2349   return -1;
2350
2351 }
2352 /* We read one record from the pipe, take care of byte order in the record
2353  * header, write the record in the capture file, and update capture statistics. */
2354
2355 static int
2356 pipe_dispatch(int fd, loop_data *ld, struct pcap_hdr *hdr,
2357                 struct pcaprec_modified_hdr *rechdr, guchar *data,
2358                 char *errmsg, int errmsgl)
2359 {
2360   struct pcap_pkthdr phdr;
2361   int b;
2362   enum { PD_REC_HDR_READ, PD_DATA_READ, PD_PIPE_EOF, PD_PIPE_ERR,
2363           PD_ERR } result;
2364
2365   switch (ld->pipe_state) {
2366
2367   case STATE_EXPECT_REC_HDR:
2368     ld->bytes_to_read = ld->modified ?
2369       sizeof(struct pcaprec_modified_hdr) : sizeof(struct pcaprec_hdr);
2370     ld->bytes_read = 0;
2371     ld->pipe_state = STATE_READ_REC_HDR;
2372     /* Fall through */
2373
2374   case STATE_READ_REC_HDR:
2375     b = read(fd, ((char *)rechdr)+ld->bytes_read,
2376       ld->bytes_to_read - ld->bytes_read);
2377     if (b <= 0) {
2378       if (b == 0)
2379         result = PD_PIPE_EOF;
2380       else
2381         result = PD_PIPE_ERR;
2382       break;
2383     }
2384     if ((ld->bytes_read += b) < ld->bytes_to_read)
2385         return 0;
2386     result = PD_REC_HDR_READ;
2387     break;
2388
2389   case STATE_EXPECT_DATA:
2390     ld->bytes_read = 0;
2391     ld->pipe_state = STATE_READ_DATA;
2392     /* Fall through */
2393
2394   case STATE_READ_DATA:
2395     b = read(fd, data+ld->bytes_read, rechdr->hdr.incl_len - ld->bytes_read);
2396     if (b <= 0) {
2397       if (b == 0)
2398         result = PD_PIPE_EOF;
2399       else
2400         result = PD_PIPE_ERR;
2401       break;
2402     }
2403     if ((ld->bytes_read += b) < rechdr->hdr.incl_len)
2404       return 0;
2405     result = PD_DATA_READ;
2406     break;
2407
2408   default:
2409     snprintf(errmsg, errmsgl, "pipe_dispatch: invalid state");
2410     result = PD_ERR;
2411
2412   } /* switch (ld->pipe_state) */
2413
2414   /*
2415    * We've now read as much data as we were expecting, so process it.
2416    */
2417   switch (result) {
2418
2419   case PD_REC_HDR_READ:
2420     /* We've read the header. Take care of byte order. */
2421     adjust_header(ld, hdr, &rechdr->hdr);
2422     if (rechdr->hdr.incl_len > WTAP_MAX_PACKET_SIZE) {
2423       snprintf(errmsg, errmsgl, "Frame %u too long (%d bytes)",
2424         ld->packet_count+1, rechdr->hdr.incl_len);
2425       break;
2426     }
2427     ld->pipe_state = STATE_EXPECT_DATA;
2428     return 0;
2429
2430   case PD_DATA_READ:
2431     /* Fill in a "struct pcap_pkthdr", and process the packet. */
2432     phdr.ts.tv_sec = rechdr->hdr.ts_sec;
2433     phdr.ts.tv_usec = rechdr->hdr.ts_usec;
2434     phdr.caplen = rechdr->hdr.incl_len;
2435     phdr.len = rechdr->hdr.orig_len;
2436
2437     capture_pcap_cb((guchar *)ld, &phdr, data);
2438
2439     ld->pipe_state = STATE_EXPECT_REC_HDR;
2440     return 1;
2441
2442   case PD_PIPE_EOF:
2443     ld->pipe_err = PIPEOF;
2444     return -1;
2445
2446   case PD_PIPE_ERR:
2447     snprintf(errmsg, errmsgl, "Error reading from pipe: %s",
2448       strerror(errno));
2449     /* Fall through */
2450   case PD_ERR:
2451     break;
2452   }
2453
2454   ld->pipe_err = PIPERR;
2455   /* Return here rather than inside the switch to prevent GCC warning */
2456   return -1;
2457 }
2458 #endif