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