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