tethereal.c

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