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