tethereal.c

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