tethereal.c

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