tshark.c

   1 /* tshark.c
   2  *
   3  * Text-mode variant of Wireshark, along the lines of tcpdump and snoop,
   4  * by Gilbert Ramirez <gram@alumni.rice.edu> and Guy Harris <guy@alum.mit.edu>.
   5  *
   6  * $Id$
   7  *
   8  * Wireshark - Network traffic analyzer
   9  * By Gerald Combs <gerald@wireshark.org>
  10  * Copyright 1998 Gerald Combs
  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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include "config.h"
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33 #include <locale.h>
  34 #include <limits.h>
  35
  36 #ifdef HAVE_UNISTD_H
  37 #include <unistd.h>
  38 #endif
  39
  40 #include <errno.h>
  41
  42 #ifdef HAVE_FCNTL_H
  43 #include <fcntl.h>
  44 #endif
  45
  46 #include <signal.h>
  47
  48 #ifdef HAVE_SYS_STAT_H
  49 # include <sys/stat.h>
  50 #endif
  51
  52 #ifndef HAVE_GETOPT
  53 #include "wsutil/wsgetopt.h"
  54 #endif
  55
  56 #include <glib.h>
  57 #include <epan/epan.h>
  58 #include <epan/filesystem.h>
  59 #include <wsutil/crash_info.h>
  60 #include <wsutil/privileges.h>
  61 #include <wsutil/file_util.h>
  62
  63 #include "globals.h"
  64 #include <epan/timestamp.h>
  65 #include <epan/packet.h>
  66 #include "file.h"
  67 #include "disabled_protos.h"
  68 #include <epan/prefs.h>
  69 #include <epan/column.h>
  70 #include "print.h"
  71 #include <epan/addr_resolv.h>
  72 #include "ui/util.h"
  73 #include "clopts_common.h"
  74 #include "cmdarg_err.h"
  75 #include "version_info.h"
  76 #include <epan/plugins.h>
  77 #include "register.h"
  78 #include <epan/epan_dissect.h>
  79 #include <epan/tap.h>
  80 #include <epan/stat_cmd_args.h>
  81 #include <epan/timestamp.h>
  82 #include <epan/ex-opt.h>
  83
  84 #ifdef HAVE_LIBPCAP
  85 #include "capture_ui_utils.h"
  86 #include "capture_ifinfo.h"
  87 #include "capture-pcap-util.h"
  88 #ifdef _WIN32
  89 #include "capture-wpcap.h"
  90 #include <wsutil/unicode-utils.h>
  91 #endif /* _WIN32 */
  92 #include "capture_sync.h"
  93 #endif /* HAVE_LIBPCAP */
  94 #include "log.h"
  95 #include <epan/funnel.h>
  96 #include "capture_opts.h"
  97
  98 /*
  99  * This is the template for the decode as option; it is shared between the
 100  * various functions that output the usage for this parameter.
 101  */
 102 static const gchar decode_as_arg_template[] = "<layer_type>==<selector>,<decode_as_protocol>";
 103
 104 static guint32 cum_bytes;
 105 static nstime_t first_ts;
 106 static frame_data *prev_dis;
 107 static frame_data prev_dis_frame;
 108 static frame_data *prev_cap;
 109 static frame_data prev_cap_frame;
 110
 111 static const char* prev_display_dissector_name = NULL;
 112
 113 static gboolean perform_two_pass_analysis;
 114
 115 /*
 116  * The way the packet decode is to be written.
 117  */
 118 typedef enum {
 119   WRITE_TEXT,   /* summary or detail text */
 120   WRITE_XML,    /* PDML or PSML */
 121   WRITE_FIELDS  /* User defined list of fields */
 122   /* Add CSV and the like here */
 123 } output_action_e;
 124
 125 static output_action_e output_action;
 126 static gboolean do_dissection;     /* TRUE if we have to dissect each packet */
 127 static gboolean print_packet_info; /* TRUE if we're to print packet information */
 128 static gint print_summary = -1;    /* TRUE if we're to print packet summary information */
 129 static gboolean print_details;     /* TRUE if we're to print packet details information */
 130 static gboolean print_hex;         /* TRUE if we're to print hex/ascci information */
 131 static gboolean line_buffered;
 132 static gboolean really_quiet = FALSE;
 133
 134 static print_format_e print_format = PR_FMT_TEXT;
 135 static print_stream_t *print_stream;
 136
 137 static output_fields_t* output_fields  = NULL;
 138
 139 /* The line separator used between packets, changeable via the -S option */
 140 static const char *separator = "";
 141
 142 #ifdef HAVE_LIBPCAP
 143 /*
 144  * TRUE if we're to print packet counts to keep track of captured packets.
 145  */
 146 static gboolean print_packet_counts = TRUE;
 147
 148 static capture_options global_capture_opts;
 149
 150 #ifdef SIGINFO
 151 static gboolean infodelay;      /* if TRUE, don't print capture info in SIGINFO handler */
 152 static gboolean infoprint;      /* if TRUE, print capture info after clearing infodelay */
 153 #endif /* SIGINFO */
 154
 155 static gboolean capture(void);
 156 static void report_counts(void);
 157 #ifdef _WIN32
 158 static BOOL WINAPI capture_cleanup(DWORD);
 159 #else /* _WIN32 */
 160 static void capture_cleanup(int);
 161 #ifdef SIGINFO
 162 static void report_counts_siginfo(int);
 163 #endif /* SIGINFO */
 164 #endif /* _WIN32 */
 165 #endif /* HAVE_LIBPCAP */
 166
 167 static int load_cap_file(capture_file *, char *, int, gboolean, int, gint64);
 168 static gboolean process_packet(capture_file *cf, gint64 offset,
 169     struct wtap_pkthdr *whdr, const guchar *pd,
 170     gboolean filtering_tap_listeners, guint tap_flags);
 171 static void show_capture_file_io_error(const char *, int, gboolean);
 172 static void show_print_file_io_error(int err);
 173 static gboolean write_preamble(capture_file *cf);
 174 static gboolean print_packet(capture_file *cf, epan_dissect_t *edt);
 175 static gboolean write_finale(void);
 176 static const char *cf_open_error_message(int err, gchar *err_info,
 177     gboolean for_writing, int file_type);
 178
 179 static void open_failure_message(const char *filename, int err,
 180     gboolean for_writing);
 181 static void failure_message(const char *msg_format, va_list ap);
 182 static void read_failure_message(const char *filename, int err);
 183 static void write_failure_message(const char *filename, int err);
 184
 185 capture_file cfile;
 186
 187 struct string_elem {
 188   const char *sstr;   /* The short string */
 189   const char *lstr;   /* The long string */
 190 };
 191
 192 static gint
 193 string_compare(gconstpointer a, gconstpointer b)
 194 {
 195   return strcmp(((const struct string_elem *)a)->sstr,
 196                 ((const struct string_elem *)b)->sstr);
 197 }
 198
 199 static void
 200 string_elem_print(gpointer data, gpointer not_used _U_)
 201 {
 202   fprintf(stderr, "    %s - %s\n",
 203           ((struct string_elem *)data)->sstr,
 204           ((struct string_elem *)data)->lstr);
 205 }
 206
 207 static void
 208 list_capture_types(void) {
 209   int                 i;
 210   struct string_elem *captypes;
 211   GSList             *list = NULL;
 212
 213   captypes = g_new(struct string_elem, WTAP_NUM_FILE_TYPES);
 214
 215   fprintf(stderr, "tshark: The available capture file types for the \"-F\" flag are:\n");
 216   for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
 217     if (wtap_dump_can_open(i)) {
 218       captypes[i].sstr = wtap_file_type_short_string(i);
 219       captypes[i].lstr = wtap_file_type_string(i);
 220       list = g_slist_insert_sorted(list, &captypes[i], string_compare);
 221     }
 222   }
 223   g_slist_foreach(list, string_elem_print, NULL);
 224   g_slist_free(list);
 225   g_free(captypes);
 226 }
 227
 228 static void
 229 print_usage(gboolean print_ver)
 230 {
 231   FILE *output;
 232
 233   if (print_ver) {
 234     output = stdout;
 235     fprintf(output,
 236         "TShark " VERSION "%s\n"
 237         "Dump and analyze network traffic.\n"
 238         "See http://www.wireshark.org for more information.\n"
 239         "\n"
 240         "%s",
 241          wireshark_svnversion, get_copyright_info());
 242   } else {
 243     output = stderr;
 244   }
 245   fprintf(output, "\n");
 246   fprintf(output, "Usage: tshark [options] ...\n");
 247   fprintf(output, "\n");
 248
 249 #ifdef HAVE_LIBPCAP
 250   fprintf(output, "Capture interface:\n");
 251   fprintf(output, "  -i <interface>           name or idx of interface (def: first non-loopback)\n");
 252   fprintf(output, "  -f <capture filter>      packet filter in libpcap filter syntax\n");
 253   fprintf(output, "  -s <snaplen>             packet snapshot length (def: 65535)\n");
 254   fprintf(output, "  -p                       don't capture in promiscuous mode\n");
 255 #ifdef HAVE_PCAP_CREATE
 256   fprintf(output, "  -I                       capture in monitor mode, if available\n");
 257 #endif
 258 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
 259   fprintf(output, "  -B <buffer size>         size of kernel buffer (def: %dMB)\n", DEFAULT_CAPTURE_BUFFER_SIZE);
 260 #endif
 261   fprintf(output, "  -y <link type>           link layer type (def: first appropriate)\n");
 262   fprintf(output, "  -D                       print list of interfaces and exit\n");
 263   fprintf(output, "  -L                       print list of link-layer types of iface and exit\n");
 264   fprintf(output, "\n");
 265   fprintf(output, "Capture stop conditions:\n");
 266   fprintf(output, "  -c <packet count>        stop after n packets (def: infinite)\n");
 267   fprintf(output, "  -a <autostop cond.> ...  duration:NUM - stop after NUM seconds\n");
 268   fprintf(output, "                           filesize:NUM - stop this file after NUM KB\n");
 269   fprintf(output, "                              files:NUM - stop after NUM files\n");
 270   /*fprintf(output, "\n");*/
 271   fprintf(output, "Capture output:\n");
 272   fprintf(output, "  -b <ringbuffer opt.> ... duration:NUM - switch to next file after NUM secs\n");
 273   fprintf(output, "                           filesize:NUM - switch to next file after NUM KB\n");
 274   fprintf(output, "                              files:NUM - ringbuffer: replace after NUM files\n");
 275 #endif  /* HAVE_LIBPCAP */
 276 #ifdef HAVE_PCAP_REMOTE
 277   fprintf(output, "RPCAP options:\n");
 278   fprintf(output, "  -A <user>:<password>     use RPCAP password authentication\n");
 279 #endif
 280   /*fprintf(output, "\n");*/
 281   fprintf(output, "Input file:\n");
 282   fprintf(output, "  -r <infile>              set the filename to read from (no pipes or stdin!)\n");
 283
 284   fprintf(output, "\n");
 285   fprintf(output, "Processing:\n");
 286   fprintf(output, "  -2                       perform a two-pass analysis\n");
 287   fprintf(output, "  -R <read filter>         packet Read filter in Wireshark display filter syntax\n");
 288   fprintf(output, "  -Y <display filter>      packet displaY filter in Wireshark display filter syntax\n");
 289   fprintf(output, "  -n                       disable all name resolutions (def: all enabled)\n");
 290   fprintf(output, "  -N <name resolve flags>  enable specific name resolution(s): \"mntC\"\n");
 291   fprintf(output, "  -d %s ...\n", decode_as_arg_template);
 292   fprintf(output, "                           \"Decode As\", see the man page for details\n");
 293   fprintf(output, "                           Example: tcp.port==8888,http\n");
 294   fprintf(output, "  -H <hosts file>          read a list of entries from a hosts file, which will\n");
 295   fprintf(output, "                           then be written to a capture file. (Implies -W n)\n");
 296
 297   /*fprintf(output, "\n");*/
 298   fprintf(output, "Output:\n");
 299   fprintf(output, "  -w <outfile|->           write packets to a pcap-format file named \"outfile\"\n");
 300   fprintf(output, "                           (or to the standard output for \"-\")\n");
 301   fprintf(output, "  -C <config profile>      start with specified configuration profile\n");
 302   fprintf(output, "  -F <output file type>    set the output file type, default is pcapng\n");
 303   fprintf(output, "                           an empty \"-F\" option will list the file types\n");
 304   fprintf(output, "  -V                       add output of packet tree        (Packet Details)\n");
 305   fprintf(output, "  -O <protocols>           Only show packet details of these protocols, comma\n");
 306   fprintf(output, "                           separated\n");
 307   fprintf(output, "  -P                       print packet summary even when writing to a file\n");
 308   fprintf(output, "  -S <separator>           the line separator to print between packets\n");
 309   fprintf(output, "  -x                       add output of hex and ASCII dump (Packet Bytes)\n");
 310   fprintf(output, "  -T pdml|ps|psml|text|fields\n");
 311   fprintf(output, "                           format of text output (def: text)\n");
 312   fprintf(output, "  -e <field>               field to print if -Tfields selected (e.g. tcp.port, col.Info);\n");
 313   fprintf(output, "                           this option can be repeated to print multiple fields\n");
 314   fprintf(output, "  -E<fieldsoption>=<value> set options for output when -Tfields selected:\n");
 315   fprintf(output, "     header=y|n            switch headers on and off\n");
 316   fprintf(output, "     separator=/t|/s|<char> select tab, space, printable character as separator\n");
 317   fprintf(output, "     occurrence=f|l|a      print first, last or all occurrences of each field\n");
 318   fprintf(output, "     aggregator=,|/s|<char> select comma, space, printable character as\n");
 319   fprintf(output, "                           aggregator\n");
 320   fprintf(output, "     quote=d|s|n           select double, single, no quotes for values\n");
 321   fprintf(output, "  -t ad|a|r|d|dd|e         output format of time stamps (def: r: rel. to first)\n");
 322   fprintf(output, "  -u s|hms                 output format of seconds (def: s: seconds)\n");
 323   fprintf(output, "  -l                       flush standard output after each packet\n");
 324   fprintf(output, "  -q                       be more quiet on stdout (e.g. when using statistics)\n");
 325   fprintf(output, "  -Q                       only log true errors to stderr (quieter than -q)\n");
 326   fprintf(output, "  -g                       enable group read access on the output file(s)\n");
 327   fprintf(output, "  -W n                     Save extra information in the file, if supported.\n");
 328   fprintf(output, "                           n = write network address resolution information\n");
 329   fprintf(output, "  -X <key>:<value>         eXtension options, see the man page for details\n");
 330   fprintf(output, "  -z <statistics>          various statistics, see the man page for details\n");
 331
 332   fprintf(output, "\n");
 333   fprintf(output, "Miscellaneous:\n");
 334   fprintf(output, "  -h                       display this help and exit\n");
 335   fprintf(output, "  -v                       display version info and exit\n");
 336   fprintf(output, "  -o <name>:<value> ...    override preference setting\n");
 337   fprintf(output, "  -K <keytab>              keytab file to use for kerberos decryption\n");
 338   fprintf(output, "  -G [report]              dump one of several available reports and exit\n");
 339   fprintf(output, "                           default report=\"fields\"\n");
 340   fprintf(output, "                           use \"-G ?\" for more help\n");
 341 }
 342
 343 static void
 344 glossary_option_help(void)
 345 {
 346   FILE *output;
 347
 348   output = stdout;
 349
 350   fprintf(output, "TShark " VERSION "%s\n", wireshark_svnversion);
 351
 352   fprintf(output, "\n");
 353   fprintf(output, "Usage: tshark -G [report]\n");
 354   fprintf(output, "\n");
 355   fprintf(output, "Glossary table reports:\n");
 356   fprintf(output, "  -G fields                dump fields glossary and exit\n");
 357   fprintf(output, "  -G protocols             dump protocols in registration database and exit\n");
 358   fprintf(output, "  -G values                dump value, range, true/false strings and exit\n");
 359   fprintf(output, "  -G ftypes                dump field type basic and descriptive names\n");
 360   fprintf(output, "  -G decodes               dump \"layer type\"/\"decode as\" associations and exit\n");
 361   fprintf(output, "  -G heuristic-decodes     dump heuristic dissector tables\n");
 362   fprintf(output, "\n");
 363   fprintf(output, "Preference reports:\n");
 364   fprintf(output, "  -G defaultprefs          dump default preferences and exit\n");
 365   fprintf(output, "  -G currentprefs          dump current preferences and exit\n");
 366   fprintf(output, "\n");
 367 }
 368
 369 /*
 370  * For a dissector table, print on the stream described by output,
 371  * its short name (which is what's used in the "-d" option) and its
 372  * descriptive name.
 373  */
 374 static void
 375 display_dissector_table_names(const char *table_name, const char *ui_name,
 376                               gpointer output)
 377 {
 378   if ((prev_display_dissector_name == NULL) ||
 379       (strcmp(prev_display_dissector_name, table_name) != 0)) {
 380      fprintf((FILE *)output, "\t%s (%s)\n", table_name, ui_name);
 381      prev_display_dissector_name = table_name;
 382   }
 383 }
 384
 385 /*
 386  * For a dissector handle, print on the stream described by output,
 387  * the filter name (which is what's used in the "-d" option) and the full
 388  * name for the protocol that corresponds to this handle.
 389  */
 390 static void
 391 display_dissector_names(const gchar *table _U_, gpointer handle, gpointer output)
 392 {
 393   int          proto_id;
 394   const gchar *proto_filter_name;
 395   const gchar *proto_ui_name;
 396
 397   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
 398
 399   if (proto_id != -1) {
 400     proto_filter_name = proto_get_protocol_filter_name(proto_id);
 401     proto_ui_name =  proto_get_protocol_name(proto_id);
 402     g_assert(proto_filter_name != NULL);
 403     g_assert(proto_ui_name != NULL);
 404
 405     if ((prev_display_dissector_name == NULL) ||
 406         (strcmp(prev_display_dissector_name, proto_filter_name) != 0)) {
 407       fprintf((FILE *)output, "\t%s (%s)\n",
 408               proto_filter_name,
 409               proto_ui_name);
 410        prev_display_dissector_name = proto_filter_name;
 411     }
 412   }
 413 }
 414
 415 /*
 416  * The protocol_name_search structure is used by find_protocol_name_func()
 417  * to pass parameters and store results
 418  */
 419 struct protocol_name_search{
 420   gchar              *searched_name;  /* Protocol filter name we are looking for */
 421   dissector_handle_t  matched_handle; /* Handle for a dissector whose protocol has the specified filter name */
 422   guint               nb_match;       /* How many dissectors matched searched_name */
 423 };
 424 typedef struct protocol_name_search *protocol_name_search_t;
 425
 426 /*
 427  * This function parses all dissectors associated with a table to find the
 428  * one whose protocol has the specified filter name.  It is called
 429  * as a reference function in a call to dissector_table_foreach_handle.
 430  * The name we are looking for, as well as the results, are stored in the
 431  * protocol_name_search struct pointed to by user_data.
 432  * If called using dissector_table_foreach_handle, we actually parse the
 433  * whole list of dissectors.
 434  */
 435 static void
 436 find_protocol_name_func(const gchar *table _U_, gpointer handle, gpointer user_data)
 437
 438 {
 439   int                     proto_id;
 440   const gchar            *protocol_filter_name;
 441   protocol_name_search_t  search_info;
 442
 443   g_assert(handle);
 444
 445   search_info = (protocol_name_search_t)user_data;
 446
 447   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
 448   if (proto_id != -1) {
 449     protocol_filter_name = proto_get_protocol_filter_name(proto_id);
 450     g_assert(protocol_filter_name != NULL);
 451     if (strcmp(protocol_filter_name, search_info->searched_name) == 0) {
 452       /* Found a match */
 453       if (search_info->nb_match == 0) {
 454         /* Record this handle only if this is the first match */
 455         search_info->matched_handle = (dissector_handle_t)handle; /* Record the handle for this matching dissector */
 456       }
 457       search_info->nb_match++;
 458     }
 459   }
 460 }
 461
 462 /*
 463  * Allow dissector key names to be sorted alphabetically
 464  */
 465
 466 static gint
 467 compare_dissector_key_name(gconstpointer dissector_a, gconstpointer dissector_b)
 468 {
 469   return strcmp((const char*)dissector_a, (const char*)dissector_b);
 470 }
 471
 472 /*
 473  * Print all layer type names supported.
 474  * We send the output to the stream described by the handle output.
 475  */
 476
 477 static void
 478 fprint_all_layer_types(FILE *output)
 479
 480 {
 481   prev_display_dissector_name = NULL;
 482   dissector_all_tables_foreach_table(display_dissector_table_names, (gpointer)output, (GCompareFunc)compare_dissector_key_name);
 483 }
 484
 485 /*
 486  * Print all protocol names supported for a specific layer type.
 487  * table_name contains the layer type name in which the search is performed.
 488  * We send the output to the stream described by the handle output.
 489  */
 490
 491 static void
 492 fprint_all_protocols_for_layer_types(FILE *output, gchar *table_name)
 493
 494 {
 495   prev_display_dissector_name = NULL;
 496   dissector_table_foreach_handle(table_name,
 497                                  display_dissector_names,
 498                                  (gpointer)output);
 499 }
 500
 501 /*
 502  * The function below parses the command-line parameters for the decode as
 503  * feature (a string pointer by cl_param).
 504  * It checks the format of the command-line, searches for a matching table
 505  * and dissector.  If a table/dissector match is not found, we display a
 506  * summary of the available tables/dissectors (on stderr) and return FALSE.
 507  * If everything is fine, we get the "Decode as" preference activated,
 508  * then we return TRUE.
 509  */
 510 static gboolean
 511 add_decode_as(const gchar *cl_param)
 512 {
 513   gchar                        *table_name;
 514   guint32                       selector, selector2;
 515   gchar                        *decoded_param;
 516   gchar                        *remaining_param;
 517   gchar                        *selector_str;
 518   gchar                        *dissector_str;
 519   dissector_handle_t            dissector_matching;
 520   dissector_table_t             table_matching;
 521   ftenum_t                      dissector_table_selector_type;
 522   struct protocol_name_search   user_protocol_name;
 523   guint64                       i;
 524   char                          op;
 525
 526   /* The following code will allocate and copy the command-line options in a string pointed by decoded_param */
 527
 528   g_assert(cl_param);
 529   decoded_param = g_strdup(cl_param);
 530   g_assert(decoded_param);
 531
 532
 533   /* The lines below will parse this string (modifying it) to extract all
 534     necessary information.  Note that decoded_param is still needed since
 535     strings are not copied - we just save pointers. */
 536
 537   /* This section extracts a layer type (table_name) from decoded_param */
 538   table_name = decoded_param; /* Layer type string starts from beginning */
 539
 540   remaining_param = strchr(table_name, '=');
 541   if (remaining_param == NULL) {
 542     cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
 543     /* If the argument does not follow the template, carry on anyway to check
 544        if the table name is at least correct.  If remaining_param is NULL,
 545        we'll exit anyway further down */
 546   }
 547   else {
 548     *remaining_param = '\0'; /* Terminate the layer type string (table_name) where '=' was detected */
 549   }
 550
 551   /* Remove leading and trailing spaces from the table name */
 552   while ( table_name[0] == ' ' )
 553     table_name++;
 554   while ( table_name[strlen(table_name) - 1] == ' ' )
 555     table_name[strlen(table_name) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
 556
 557 /* The following part searches a table matching with the layer type specified */
 558   table_matching = NULL;
 559
 560 /* Look for the requested table */
 561   if ( !(*(table_name)) ) { /* Is the table name empty, if so, don't even search for anything, display a message */
 562     cmdarg_err("No layer type specified"); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
 563   }
 564   else {
 565     table_matching = find_dissector_table(table_name);
 566     if (!table_matching) {
 567       cmdarg_err("Unknown layer type -- %s", table_name); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
 568     }
 569   }
 570
 571   if (!table_matching) {
 572     /* Display a list of supported layer types to help the user, if the
 573        specified layer type was not found */
 574     cmdarg_err("Valid layer types are:");
 575     fprint_all_layer_types(stderr);
 576   }
 577   if (remaining_param == NULL || !table_matching) {
 578     /* Exit if the layer type was not found, or if no '=' separator was found
 579        (see above) */
 580     g_free(decoded_param);
 581     return FALSE;
 582   }
 583
 584   if (*(remaining_param + 1) != '=') { /* Check for "==" and not only '=' */
 585     cmdarg_err("WARNING: -d requires \"==\" instead of \"=\". Option will be treated as \"%s==%s\"", table_name, remaining_param + 1);
 586   }
 587   else {
 588     remaining_param++; /* Move to the second '=' */
 589     *remaining_param = '\0'; /* Remove the second '=' */
 590   }
 591   remaining_param++; /* Position after the layer type string */
 592
 593   /* This section extracts a selector value (selector_str) from decoded_param */
 594
 595   selector_str = remaining_param; /* Next part starts with the selector number */
 596
 597   remaining_param = strchr(selector_str, ',');
 598   if (remaining_param == NULL) {
 599     cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
 600     /* If the argument does not follow the template, carry on anyway to check
 601        if the selector value is at least correct.  If remaining_param is NULL,
 602        we'll exit anyway further down */
 603   }
 604   else {
 605     *remaining_param = '\0'; /* Terminate the selector number string (selector_str) where ',' was detected */
 606   }
 607
 608   dissector_table_selector_type = get_dissector_table_selector_type(table_name);
 609
 610   switch (dissector_table_selector_type) {
 611
 612   case FT_UINT8:
 613   case FT_UINT16:
 614   case FT_UINT24:
 615   case FT_UINT32:
 616     /* The selector for this table is an unsigned number.  Parse it as such.
 617        There's no need to remove leading and trailing spaces from the
 618        selector number string, because sscanf will do that for us. */
 619     switch (sscanf(selector_str, "%u%c%u", &selector, &op, &selector2)) {
 620       case 1:
 621         op = '\0';
 622         break;
 623       case 3:
 624         if (op != ':' && op != '-') {
 625             cmdarg_err("Invalid selector numeric range \"%s\"", selector_str);
 626             g_free(decoded_param);
 627             return FALSE;
 628         }
 629         if (op == ':') {
 630             if ((selector2 == 0) || ((guint64)selector + selector2 - 1) > G_MAXUINT32) {
 631                 cmdarg_err("Invalid selector numeric range \"%s\"", selector_str);
 632                 g_free(decoded_param);
 633                 return FALSE;
 634             }
 635         }
 636         else if (selector2 < selector) {
 637             /* We could swap them for the user, but maybe it's better to call
 638              * this out as an error in case it's not what was intended? */
 639             cmdarg_err("Invalid selector numeric range \"%s\"", selector_str);
 640             g_free(decoded_param);
 641             return FALSE;
 642         }
 643         break;
 644       default:
 645         cmdarg_err("Invalid selector number \"%s\"", selector_str);
 646         g_free(decoded_param);
 647         return FALSE;
 648     }
 649     break;
 650
 651   case FT_STRING:
 652   case FT_STRINGZ:
 653     /* The selector for this table is a string. */
 654     break;
 655
 656   default:
 657     /* There are currently no dissector tables with any types other
 658        than the ones listed above. */
 659     g_assert_not_reached();
 660   }
 661
 662   if (remaining_param == NULL) {
 663     /* Exit if no ',' separator was found (see above) */
 664     cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
 665     fprint_all_protocols_for_layer_types(stderr, table_name);
 666     g_free(decoded_param);
 667     return FALSE;
 668   }
 669
 670   remaining_param++; /* Position after the selector number string */
 671
 672   /* This section extracts a protocol filter name (dissector_str) from decoded_param */
 673
 674   dissector_str = remaining_param; /* All the rest of the string is the dissector (decode as protocol) name */
 675
 676   /* Remove leading and trailing spaces from the dissector name */
 677   while ( dissector_str[0] == ' ' )
 678     dissector_str++;
 679   while ( dissector_str[strlen(dissector_str) - 1] == ' ' )
 680     dissector_str[strlen(dissector_str) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
 681
 682   dissector_matching = NULL;
 683
 684   /* We now have a pointer to the handle for the requested table inside the variable table_matching */
 685   if ( ! (*dissector_str) ) { /* Is the dissector name empty, if so, don't even search for a matching dissector and display all dissectors found for the selected table */
 686     cmdarg_err("No protocol name specified"); /* Note, we don't exit here, but dissector_matching will remain NULL, so we exit below */
 687   }
 688   else {
 689     user_protocol_name.nb_match = 0;
 690     user_protocol_name.searched_name = dissector_str;
 691     user_protocol_name.matched_handle = NULL;
 692
 693     dissector_table_foreach_handle(table_name, find_protocol_name_func, &user_protocol_name); /* Go and perform the search for this dissector in the this table's dissectors' names and shortnames */
 694
 695     if (user_protocol_name.nb_match != 0) {
 696       dissector_matching = user_protocol_name.matched_handle;
 697       if (user_protocol_name.nb_match > 1) {
 698         cmdarg_err("WARNING: Protocol \"%s\" matched %u dissectors, first one will be used", dissector_str, user_protocol_name.nb_match);
 699       }
 700     }
 701     else {
 702       /* OK, check whether the problem is that there isn't any such
 703          protocol, or that there is but it's not specified as a protocol
 704          that's valid for that dissector table.
 705          Note, we don't exit here, but dissector_matching will remain NULL,
 706          so we exit below */
 707       if (proto_get_id_by_filter_name(dissector_str) == -1) {
 708         /* No such protocol */
 709         cmdarg_err("Unknown protocol -- \"%s\"", dissector_str);
 710       } else {
 711         cmdarg_err("Protocol \"%s\" isn't valid for layer type \"%s\"",
 712                    dissector_str, table_name);
 713       }
 714     }
 715   }
 716
 717   if (!dissector_matching) {
 718     cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
 719     fprint_all_protocols_for_layer_types(stderr, table_name);
 720     g_free(decoded_param);
 721     return FALSE;
 722   }
 723
 724 /* This is the end of the code that parses the command-line options.
 725    All information is now stored in the variables:
 726    table_name
 727    selector
 728    dissector_matching
 729    The above variables that are strings are still pointing to areas within
 730    decoded_parm.  decoded_parm thus still needs to be kept allocated in
 731    until we stop needing these variables
 732    decoded_param will be deallocated at each exit point of this function */
 733
 734
 735   /* We now have a pointer to the handle for the requested dissector
 736      (requested protocol) inside the variable dissector_matching */
 737   switch (dissector_table_selector_type) {
 738
 739   case FT_UINT8:
 740   case FT_UINT16:
 741   case FT_UINT24:
 742   case FT_UINT32:
 743     /* The selector for this table is an unsigned number. */
 744     if (op == '\0') {
 745       dissector_change_uint(table_name, selector, dissector_matching);
 746     } else if (op == ':') {
 747       for (i = selector; i < (guint64)selector + selector2; i++) {
 748         dissector_change_uint(table_name, (guint32)i, dissector_matching);
 749       }
 750     } else { /* op == '-' */
 751       for (i = selector; i <= selector2; i++) {
 752         dissector_change_uint(table_name, (guint32)i, dissector_matching);
 753       }
 754     }
 755     break;
 756
 757   case FT_STRING:
 758   case FT_STRINGZ:
 759     /* The selector for this table is a string. */
 760     dissector_change_string(table_name, selector_str, dissector_matching);
 761     break;
 762
 763   default:
 764     /* There are currently no dissector tables with any types other
 765        than the ones listed above. */
 766     g_assert_not_reached();
 767   }
 768   g_free(decoded_param); /* "Decode As" rule has been successfully added */
 769   return TRUE;
 770 }
 771
 772 static void
 773 tshark_log_handler (const gchar *log_domain, GLogLevelFlags log_level,
 774     const gchar *message, gpointer user_data)
 775 {
 776   /* ignore log message, if log_level isn't interesting based
 777      upon the console log preferences.
 778      If the preferences haven't been loaded loaded yet, display the
 779      message anyway.
 780
 781      The default console_log_level preference value is such that only
 782        ERROR, CRITICAL and WARNING level messages are processed;
 783        MESSAGE, INFO and DEBUG level messages are ignored.
 784
 785      XXX: Aug 07, 2009: Prior tshark g_log code was hardwired to process only
 786            ERROR and CRITICAL level messages so the current code is a behavioral
 787            change.  The current behavior is the same as in Wireshark.
 788   */
 789   if ((log_level & G_LOG_LEVEL_MASK & prefs.console_log_level) == 0 &&
 790      prefs.console_log_level != 0) {
 791     return;
 792   }
 793
 794   g_log_default_handler(log_domain, log_level, message, user_data);
 795
 796 }
 797
 798 static char *
 799 output_file_description(const char *fname)
 800 {
 801   char *save_file_string;
 802
 803   /* Get a string that describes what we're writing to */
 804   if (strcmp(fname, "-") == 0) {
 805     /* We're writing to the standard output */
 806     save_file_string = g_strdup("standard output");
 807   } else {
 808     /* We're writing to a file with the name in save_file */
 809     save_file_string = g_strdup_printf("file \"%s\"", fname);
 810   }
 811   return save_file_string;
 812 }
 813
 814 static void
 815 print_current_user(void) {
 816   gchar *cur_user, *cur_group;
 817
 818   if (started_with_special_privs()) {
 819     cur_user = get_cur_username();
 820     cur_group = get_cur_groupname();
 821     fprintf(stderr, "Running as user \"%s\" and group \"%s\".",
 822       cur_user, cur_group);
 823     g_free(cur_user);
 824     g_free(cur_group);
 825     if (running_with_special_privs()) {
 826       fprintf(stderr, " This could be dangerous.");
 827     }
 828     fprintf(stderr, "\n");
 829   }
 830 }
 831
 832 static void
 833 check_capture_privs(void) {
 834 #ifdef _WIN32
 835   load_wpcap();
 836   /* Warn the user if npf.sys isn't loaded. */
 837   if (!npf_sys_is_running() && get_os_major_version() >= 6) {
 838     fprintf(stderr, "The NPF driver isn't running.  You may have trouble "
 839       "capturing or\nlisting interfaces.\n");
 840   }
 841 #endif
 842 }
 843
 844 static void
 845 show_version(GString *comp_info_str, GString *runtime_info_str)
 846 {
 847   printf("TShark " VERSION "%s\n"
 848          "\n"
 849          "%s"
 850          "\n"
 851          "%s"
 852          "\n"
 853          "%s",
 854          wireshark_svnversion, get_copyright_info(), comp_info_str->str,
 855          runtime_info_str->str);
 856 }
 857
 858 int
 859 main(int argc, char *argv[])
 860 {
 861   GString             *comp_info_str;
 862   GString             *runtime_info_str;
 863   char                *init_progfile_dir_error;
 864   int                  opt;
 865   gboolean             arg_error = FALSE;
 866
 867 #ifdef _WIN32
 868   WSADATA              wsaData;
 869 #endif  /* _WIN32 */
 870
 871   char                *gpf_path, *pf_path;
 872   char                *gdp_path, *dp_path;
 873   int                  gpf_open_errno, gpf_read_errno;
 874   int                  pf_open_errno, pf_read_errno;
 875   int                  gdp_open_errno, gdp_read_errno;
 876   int                  dp_open_errno, dp_read_errno;
 877   int                  err;
 878   volatile int         exit_status = 0;
 879 #ifdef HAVE_LIBPCAP
 880   gboolean             list_link_layer_types = FALSE;
 881   gboolean             start_capture = FALSE;
 882   int                  status;
 883   GList               *if_list;
 884   gchar               *err_str;
 885 #else
 886   gboolean             capture_option_specified = FALSE;
 887 #endif
 888   gboolean             quiet = FALSE;
 889 #ifdef PCAP_NG_DEFAULT
 890   volatile int         out_file_type = WTAP_FILE_PCAPNG;
 891 #else
 892   volatile int         out_file_type = WTAP_FILE_PCAP;
 893 #endif
 894   volatile gboolean    out_file_name_res = FALSE;
 895   gchar               *volatile cf_name = NULL;
 896   gchar               *rfilter = NULL;
 897   gchar               *dfilter = NULL;
 898 #ifdef HAVE_PCAP_OPEN_DEAD
 899   struct bpf_program   fcode;
 900 #endif
 901   dfilter_t           *rfcode = NULL;
 902   dfilter_t           *dfcode = NULL;
 903   e_prefs             *prefs_p;
 904   char                 badopt;
 905   int                  log_flags;
 906   int                  optind_initial;
 907   gchar               *output_only = NULL;
 908
 909 #ifdef HAVE_PCAP_REMOTE
 910 #define OPTSTRING_A "A:"
 911 #else
 912 #define OPTSTRING_A ""
 913 #endif
 914 #ifdef HAVE_LIBPCAP
 915 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
 916 #define OPTSTRING_B "B:"
 917 #else
 918 #define OPTSTRING_B ""
 919 #endif  /* _WIN32 or HAVE_PCAP_CREATE */
 920 #else /* HAVE_LIBPCAP */
 921 #define OPTSTRING_B ""
 922 #endif  /* HAVE_LIBPCAP */
 923
 924 #ifdef HAVE_PCAP_CREATE
 925 #define OPTSTRING_I "I"
 926 #else
 927 #define OPTSTRING_I ""
 928 #endif
 929
 930 #define OPTSTRING "2a:" OPTSTRING_A "b:" OPTSTRING_B "c:C:d:De:E:f:F:gG:hH:i:" OPTSTRING_I "K:lLnN:o:O:pPqQr:R:s:S:t:T:u:vVw:W:xX:y:Y:z:"
 931
 932   static const char    optstring[] = OPTSTRING;
 933
 934   /* Assemble the compile-time version information string */
 935   comp_info_str = g_string_new("Compiled ");
 936   get_compiled_version_info(comp_info_str, NULL, epan_get_compiled_version_info);
 937
 938   /* Assemble the run-time version information string */
 939   runtime_info_str = g_string_new("Running ");
 940   get_runtime_version_info(runtime_info_str, NULL);
 941
 942   /* Add it to the information to be reported on a crash. */
 943   ws_add_crash_info("TShark " VERSION "%s\n"
 944          "\n"
 945          "%s"
 946          "\n"
 947          "%s",
 948       wireshark_svnversion, comp_info_str->str, runtime_info_str->str);
 949
 950 #ifdef _WIN32
 951   arg_list_utf_16to8(argc, argv);
 952   create_app_running_mutex();
 953 #if !GLIB_CHECK_VERSION(2,31,0)
 954   g_thread_init(NULL);
 955 #endif
 956 #endif /* _WIN32 */
 957
 958   /*
 959    * Get credential information for later use.
 960    */
 961   init_process_policies();
 962
 963   /*
 964    * Attempt to get the pathname of the executable file.
 965    */
 966   init_progfile_dir_error = init_progfile_dir(argv[0], main);
 967   if (init_progfile_dir_error != NULL) {
 968     fprintf(stderr, "tshark: Can't get pathname of tshark program: %s.\n",
 969             init_progfile_dir_error);
 970   }
 971
 972   /*
 973    * In order to have the -X opts assigned before the wslua machine starts
 974    * we need to call getopts before epan_init() gets called.
 975    */
 976   opterr = 0;
 977   optind_initial = optind;
 978
 979   while ((opt = getopt(argc, argv, optstring)) != -1) {
 980     switch (opt) {
 981     case 'C':        /* Configuration Profile */
 982       if (profile_exists (optarg, FALSE)) {
 983         set_profile_name (optarg);
 984       } else {
 985         cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
 986         return 1;
 987       }
 988       break;
 989     case 'P':        /* Print packet summary info even when writing to a file */
 990       print_packet_info = TRUE;
 991       print_summary = TRUE;
 992       break;
 993     case 'O':        /* Only output these protocols */
 994       output_only = g_strdup(optarg);
 995       /* FALLTHROUGH */
 996     case 'V':        /* Verbose */
 997       print_details = TRUE;
 998       print_packet_info = TRUE;
 999       break;
1000     case 'x':        /* Print packet data in hex (and ASCII) */
1001       print_hex = TRUE;
1002       /*  The user asked for hex output, so let's ensure they get it,
1003        *  even if they're writing to a file.
1004        */
1005       print_packet_info = TRUE;
1006       break;
1007     case 'X':
1008       ex_opt_add(optarg);
1009       break;
1010     default:
1011       break;
1012     }
1013   }
1014
1015   /*
1016    * Print packet summary information is the default, unless either -V or -x
1017    * were specified and -P was not.  Note that this is new behavior, which
1018    * allows for the possibility of printing only hex/ascii output without
1019    * necessarily requiring that either the summary or details be printed too.
1020    */
1021   if (print_summary == -1)
1022     print_summary = (print_details || print_hex) ? FALSE : TRUE;
1023
1024   optind = optind_initial;
1025   opterr = 1;
1026
1027
1028
1029 /** Send All g_log messages to our own handler **/
1030
1031   log_flags =
1032                     G_LOG_LEVEL_ERROR|
1033                     G_LOG_LEVEL_CRITICAL|
1034                     G_LOG_LEVEL_WARNING|
1035                     G_LOG_LEVEL_MESSAGE|
1036                     G_LOG_LEVEL_INFO|
1037                     G_LOG_LEVEL_DEBUG|
1038                     G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
1039
1040   g_log_set_handler(NULL,
1041                     (GLogLevelFlags)log_flags,
1042                     tshark_log_handler, NULL /* user_data */);
1043   g_log_set_handler(LOG_DOMAIN_MAIN,
1044                     (GLogLevelFlags)log_flags,
1045                     tshark_log_handler, NULL /* user_data */);
1046
1047 #ifdef HAVE_LIBPCAP
1048   g_log_set_handler(LOG_DOMAIN_CAPTURE,
1049                     (GLogLevelFlags)log_flags,
1050                     tshark_log_handler, NULL /* user_data */);
1051   g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
1052                     (GLogLevelFlags)log_flags,
1053                     tshark_log_handler, NULL /* user_data */);
1054 #endif
1055
1056   initialize_funnel_ops();
1057
1058 #ifdef HAVE_LIBPCAP
1059   capture_opts_init(&global_capture_opts, &cfile);
1060 #endif
1061
1062   timestamp_set_type(TS_RELATIVE);
1063   timestamp_set_precision(TS_PREC_AUTO);
1064   timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
1065
1066   /* Register all dissectors; we must do this before checking for the
1067      "-G" flag, as the "-G" flag dumps information registered by the
1068      dissectors, and we must do it before we read the preferences, in
1069      case any dissectors register preferences. */
1070   epan_init(register_all_protocols, register_all_protocol_handoffs, NULL, NULL,
1071             failure_message, open_failure_message, read_failure_message,
1072             write_failure_message);
1073
1074   /* Register all tap listeners; we do this before we parse the arguments,
1075      as the "-z" argument can specify a registered tap. */
1076
1077   /* we register the plugin taps before the other taps because
1078      stats_tree taps plugins will be registered as tap listeners
1079      by stats_tree_stat.c and need to registered before that */
1080 #ifdef HAVE_PLUGINS
1081   register_all_plugin_tap_listeners();
1082 #endif
1083   register_all_tap_listeners();
1084
1085   /* If invoked with the "-G" flag, we dump out information based on
1086      the argument to the "-G" flag; if no argument is specified,
1087      for backwards compatibility we dump out a glossary of display
1088      filter symbols.
1089
1090      XXX - we do this here, for now, to support "-G" with no arguments.
1091      If none of our build or other processes uses "-G" with no arguments,
1092      we can just process it with the other arguments. */
1093   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
1094     proto_initialize_all_prefixes();
1095
1096     if (argc == 2)
1097       proto_registrar_dump_fields();
1098     else {
1099       if (strcmp(argv[2], "fields") == 0)
1100         proto_registrar_dump_fields();
1101       else if (strcmp(argv[2], "protocols") == 0)
1102         proto_registrar_dump_protocols();
1103       else if (strcmp(argv[2], "values") == 0)
1104         proto_registrar_dump_values();
1105       else if (strcmp(argv[2], "ftypes") == 0)
1106         proto_registrar_dump_ftypes();
1107       else if (strcmp(argv[2], "decodes") == 0)
1108         dissector_dump_decodes();
1109       else if (strcmp(argv[2], "heuristic-decodes") == 0)
1110         dissector_dump_heur_decodes();
1111       else if (strcmp(argv[2], "defaultprefs") == 0)
1112         write_prefs(NULL);
1113       else if (strcmp(argv[2], "plugins") == 0)
1114         plugins_dump_all();
1115       else if (strcmp(argv[2], "?") == 0)
1116         glossary_option_help();
1117       else if (strcmp(argv[2], "-?") == 0)
1118         glossary_option_help();
1119       else if (strcmp(argv[2], "currentprefs") == 0) {
1120         read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
1121             &pf_open_errno, &pf_read_errno, &pf_path);
1122         write_prefs(NULL);
1123       } else {
1124         cmdarg_err("Invalid \"%s\" option for -G flag, enter -G ? for more help.", argv[2]);
1125         return 1;
1126       }
1127     }
1128     return 0;
1129   }
1130
1131   /* Set the C-language locale to the native environment. */
1132   setlocale(LC_ALL, "");
1133
1134   prefs_p = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
1135                      &pf_open_errno, &pf_read_errno, &pf_path);
1136   if (gpf_path != NULL) {
1137     if (gpf_open_errno != 0) {
1138       cmdarg_err("Can't open global preferences file \"%s\": %s.",
1139               pf_path, g_strerror(gpf_open_errno));
1140     }
1141     if (gpf_read_errno != 0) {
1142       cmdarg_err("I/O error reading global preferences file \"%s\": %s.",
1143               pf_path, g_strerror(gpf_read_errno));
1144     }
1145   }
1146   if (pf_path != NULL) {
1147     if (pf_open_errno != 0) {
1148       cmdarg_err("Can't open your preferences file \"%s\": %s.", pf_path,
1149               g_strerror(pf_open_errno));
1150     }
1151     if (pf_read_errno != 0) {
1152       cmdarg_err("I/O error reading your preferences file \"%s\": %s.",
1153               pf_path, g_strerror(pf_read_errno));
1154     }
1155     g_free(pf_path);
1156     pf_path = NULL;
1157   }
1158
1159   /* Read the disabled protocols file. */
1160   read_disabled_protos_list(&gdp_path, &gdp_open_errno, &gdp_read_errno,
1161                             &dp_path, &dp_open_errno, &dp_read_errno);
1162   if (gdp_path != NULL) {
1163     if (gdp_open_errno != 0) {
1164       cmdarg_err("Could not open global disabled protocols file\n\"%s\": %s.",
1165                  gdp_path, g_strerror(gdp_open_errno));
1166     }
1167     if (gdp_read_errno != 0) {
1168       cmdarg_err("I/O error reading global disabled protocols file\n\"%s\": %s.",
1169                  gdp_path, g_strerror(gdp_read_errno));
1170     }
1171     g_free(gdp_path);
1172   }
1173   if (dp_path != NULL) {
1174     if (dp_open_errno != 0) {
1175       cmdarg_err(
1176         "Could not open your disabled protocols file\n\"%s\": %s.", dp_path,
1177         g_strerror(dp_open_errno));
1178     }
1179     if (dp_read_errno != 0) {
1180       cmdarg_err(
1181         "I/O error reading your disabled protocols file\n\"%s\": %s.", dp_path,
1182         g_strerror(dp_read_errno));
1183     }
1184     g_free(dp_path);
1185   }
1186
1187   check_capture_privs();
1188
1189   cap_file_init(&cfile);
1190
1191   /* Print format defaults to this. */
1192   print_format = PR_FMT_TEXT;
1193
1194   output_fields = output_fields_new();
1195
1196   /* Now get our args */
1197   while ((opt = getopt(argc, argv, optstring)) != -1) {
1198     switch (opt) {
1199     case '2':        /* Perform two pass analysis */
1200       perform_two_pass_analysis = TRUE;
1201       break;
1202     case 'a':        /* autostop criteria */
1203     case 'b':        /* Ringbuffer option */
1204     case 'c':        /* Capture x packets */
1205     case 'f':        /* capture filter */
1206     case 'g':        /* enable group read access on file(s) */
1207     case 'i':        /* Use interface x */
1208     case 'p':        /* Don't capture in promiscuous mode */
1209 #ifdef HAVE_PCAP_REMOTE
1210     case 'A':        /* Authentication */
1211 #endif
1212 #ifdef HAVE_PCAP_CREATE
1213     case 'I':        /* Capture in monitor mode, if available */
1214 #endif
1215     case 's':        /* Set the snapshot (capture) length */
1216     case 'w':        /* Write to capture file x */
1217     case 'y':        /* Set the pcap data link type */
1218 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
1219     case 'B':        /* Buffer size */
1220 #endif /* _WIN32 or HAVE_PCAP_CREATE */
1221 #ifdef HAVE_LIBPCAP
1222       status = capture_opts_add_opt(&global_capture_opts, opt, optarg, &start_capture);
1223       if (status != 0) {
1224         return status;
1225       }
1226 #else
1227       capture_option_specified = TRUE;
1228       arg_error = TRUE;
1229 #endif
1230       break;
1231     case 'C':
1232       /* Configuration profile settings were already processed just ignore them this time*/
1233       break;
1234     case 'd':        /* Decode as rule */
1235       if (!add_decode_as(optarg))
1236         return 1;
1237       break;
1238 #if defined(HAVE_HEIMDAL_KERBEROS) || defined(HAVE_MIT_KERBEROS)
1239     case 'K':        /* Kerberos keytab file */
1240       read_keytab_file(optarg);
1241       break;
1242 #endif
1243     case 'D':        /* Print a list of capture devices and exit */
1244 #ifdef HAVE_LIBPCAP
1245       if_list = capture_interface_list(&err, &err_str);
1246       if (if_list == NULL) {
1247         switch (err) {
1248         case CANT_GET_INTERFACE_LIST:
1249         case DONT_HAVE_PCAP:
1250           cmdarg_err("%s", err_str);
1251           g_free(err_str);
1252           break;
1253
1254         case NO_INTERFACES_FOUND:
1255           cmdarg_err("There are no interfaces on which a capture can be done");
1256           break;
1257         }
1258         return 2;
1259       }
1260       capture_opts_print_interfaces(if_list);
1261       free_interface_list(if_list);
1262       return 0;
1263 #else
1264       capture_option_specified = TRUE;
1265       arg_error = TRUE;
1266 #endif
1267       break;
1268     case 'e':
1269       /* Field entry */
1270       output_fields_add(output_fields, optarg);
1271       break;
1272     case 'E':
1273       /* Field option */
1274       if (!output_fields_set_option(output_fields, optarg)) {
1275         cmdarg_err("\"%s\" is not a valid field output option=value pair.", optarg);
1276         output_fields_list_options(stderr);
1277         return 1;
1278       }
1279       break;
1280     case 'F':
1281       out_file_type = wtap_short_string_to_file_type(optarg);
1282       if (out_file_type < 0) {
1283         cmdarg_err("\"%s\" isn't a valid capture file type", optarg);
1284         list_capture_types();
1285         return 1;
1286       }
1287       break;
1288     case 'W':        /* Select extra information to save in our capture file */
1289       /* This is patterned after the -N flag which may not be the best idea. */
1290       if (strchr(optarg, 'n')) {
1291         out_file_name_res = TRUE;
1292       } else {
1293         cmdarg_err("Invalid -W argument \"%s\"", optarg);
1294         return 1;
1295       }
1296       break;
1297     case 'H':        /* Read address to name mappings from a hosts file */
1298       if (! add_hosts_file(optarg))
1299       {
1300         cmdarg_err("Can't read host entries from \"%s\"", optarg);
1301         return 1;
1302       }
1303       out_file_name_res = TRUE;
1304       break;
1305
1306     case 'h':        /* Print help and exit */
1307       print_usage(TRUE);
1308       return 0;
1309       break;
1310     case 'l':        /* "Line-buffer" standard output */
1311       /* This isn't line-buffering, strictly speaking, it's just
1312          flushing the standard output after the information for
1313          each packet is printed; however, that should be good
1314          enough for all the purposes to which "-l" is put (and
1315          is probably actually better for "-V", as it does fewer
1316          writes).
1317
1318          See the comment in "process_packet()" for an explanation of
1319          why we do that, and why we don't just use "setvbuf()" to
1320          make the standard output line-buffered (short version: in
1321          Windows, "line-buffered" is the same as "fully-buffered",
1322          and the output buffer is only flushed when it fills up). */
1323       line_buffered = TRUE;
1324       break;
1325     case 'L':        /* Print list of link-layer types and exit */
1326 #ifdef HAVE_LIBPCAP
1327       list_link_layer_types = TRUE;
1328 #else
1329       capture_option_specified = TRUE;
1330       arg_error = TRUE;
1331 #endif
1332       break;
1333     case 'n':        /* No name resolution */
1334       gbl_resolv_flags.mac_name = FALSE;
1335       gbl_resolv_flags.network_name = FALSE;
1336       gbl_resolv_flags.transport_name = FALSE;
1337       gbl_resolv_flags.concurrent_dns = FALSE;
1338       break;
1339     case 'N':        /* Select what types of addresses/port #s to resolve */
1340       badopt = string_to_name_resolve(optarg, &gbl_resolv_flags);
1341       if (badopt != '\0') {
1342         cmdarg_err("-N specifies unknown resolving option '%c';",
1343                    badopt);
1344         cmdarg_err_cont( "           Valid options are 'm', 'n', 't', and 'C'");
1345         return 1;
1346       }
1347       break;
1348     case 'o':        /* Override preference from command line */
1349       switch (prefs_set_pref(optarg)) {
1350
1351       case PREFS_SET_OK:
1352         break;
1353
1354       case PREFS_SET_SYNTAX_ERR:
1355         cmdarg_err("Invalid -o flag \"%s\"", optarg);
1356         return 1;
1357         break;
1358
1359       case PREFS_SET_NO_SUCH_PREF:
1360       case PREFS_SET_OBSOLETE:
1361         cmdarg_err("-o flag \"%s\" specifies unknown preference", optarg);
1362         return 1;
1363         break;
1364       }
1365       break;
1366     case 'q':        /* Quiet */
1367       quiet = TRUE;
1368       break;
1369     case 'Q':        /* Really quiet */
1370       quiet = TRUE;
1371       really_quiet = TRUE;
1372       break;
1373     case 'r':        /* Read capture file x */
1374       cf_name = g_strdup(optarg);
1375       break;
1376     case 'R':        /* Read file filter */
1377       rfilter = optarg;
1378       break;
1379     case 'P':
1380         /* already processed; just ignore it now */
1381         break;
1382     case 'S':        /* Set the line Separator to be printed between packets */
1383       separator = strdup(optarg);
1384       break;
1385     case 't':        /* Time stamp type */
1386       if (strcmp(optarg, "r") == 0)
1387         timestamp_set_type(TS_RELATIVE);
1388       else if (strcmp(optarg, "a") == 0)
1389         timestamp_set_type(TS_ABSOLUTE);
1390       else if (strcmp(optarg, "ad") == 0)
1391         timestamp_set_type(TS_ABSOLUTE_WITH_DATE);
1392       else if (strcmp(optarg, "d") == 0)
1393         timestamp_set_type(TS_DELTA);
1394       else if (strcmp(optarg, "dd") == 0)
1395         timestamp_set_type(TS_DELTA_DIS);
1396       else if (strcmp(optarg, "e") == 0)
1397         timestamp_set_type(TS_EPOCH);
1398       else if (strcmp(optarg, "u") == 0)
1399         timestamp_set_type(TS_UTC);
1400       else if (strcmp(optarg, "ud") == 0)
1401         timestamp_set_type(TS_UTC_WITH_DATE);
1402       else {
1403         cmdarg_err("Invalid time stamp type \"%s\"",
1404                    optarg);
1405         cmdarg_err_cont("It must be \"r\" for relative, \"a\" for absolute,");
1406         cmdarg_err_cont("\"ad\" for absolute with date, or \"d\" for delta.");
1407         return 1;
1408       }
1409       break;
1410     case 'T':        /* printing Type */
1411       if (strcmp(optarg, "text") == 0) {
1412         output_action = WRITE_TEXT;
1413         print_format = PR_FMT_TEXT;
1414       } else if (strcmp(optarg, "ps") == 0) {
1415         output_action = WRITE_TEXT;
1416         print_format = PR_FMT_PS;
1417       } else if (strcmp(optarg, "pdml") == 0) {
1418         output_action = WRITE_XML;
1419         print_details = TRUE;   /* Need details */
1420         print_summary = FALSE;  /* Don't allow summary */
1421       } else if (strcmp(optarg, "psml") == 0) {
1422         output_action = WRITE_XML;
1423         print_details = FALSE;  /* Don't allow details */
1424         print_summary = TRUE;   /* Need summary */
1425       } else if (strcmp(optarg, "fields") == 0) {
1426         output_action = WRITE_FIELDS;
1427         print_details = TRUE;   /* Need full tree info */
1428         print_summary = FALSE;  /* Don't allow summary */
1429       } else {
1430         cmdarg_err("Invalid -T parameter.");
1431         cmdarg_err_cont("It must be \"ps\", \"text\", \"pdml\", \"psml\" or \"fields\".");
1432         return 1;
1433       }
1434       break;
1435     case 'u':        /* Seconds type */
1436       if (strcmp(optarg, "s") == 0)
1437         timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
1438       else if (strcmp(optarg, "hms") == 0)
1439         timestamp_set_seconds_type(TS_SECONDS_HOUR_MIN_SEC);
1440       else {
1441         cmdarg_err("Invalid seconds type \"%s\"", optarg);
1442         cmdarg_err_cont("It must be \"s\" for seconds or \"hms\" for hours, minutes and seconds.");
1443         return 1;
1444       }
1445       break;
1446     case 'v':         /* Show version and exit */
1447     {
1448       show_version(comp_info_str, runtime_info_str);
1449       g_string_free(comp_info_str, TRUE);
1450       g_string_free(runtime_info_str, TRUE);
1451       /* We don't really have to cleanup here, but it's a convenient way to test
1452        * start-up and shut-down of the epan library without any UI-specific
1453        * cruft getting in the way. Makes the results of running
1454        * $ ./tools/valgrind-wireshark -n
1455        * much more useful. */
1456       epan_cleanup();
1457       return 0;
1458     }
1459     case 'O':        /* Only output these protocols */
1460       /* already processed; just ignore it now */
1461       break;
1462     case 'V':        /* Verbose */
1463       /* already processed; just ignore it now */
1464       break;
1465     case 'x':        /* Print packet data in hex (and ASCII) */
1466       /* already processed; just ignore it now */
1467       break;
1468     case 'X':
1469       break;
1470     case 'Y':
1471       dfilter = optarg;
1472       break;
1473     case 'z':
1474       /* We won't call the init function for the stat this soon
1475          as it would disallow MATE's fields (which are registered
1476          by the preferences set callback) from being used as
1477          part of a tap filter.  Instead, we just add the argument
1478          to a list of stat arguments. */
1479       if (!process_stat_cmd_arg(optarg)) {
1480         if (strcmp("help", optarg)==0) {
1481           fprintf(stderr, "tshark: The available statistics for the \"-z\" option are:\n");
1482           list_stat_cmd_args();
1483           return 0;
1484         }
1485         cmdarg_err("Invalid -z argument \"%s\".", optarg);
1486         cmdarg_err_cont("  -z argument must be one of :");
1487         list_stat_cmd_args();
1488         return 1;
1489       }
1490       break;
1491     default:
1492     case '?':        /* Bad flag - print usage message */
1493       switch(optopt) {
1494       case 'F':
1495         list_capture_types();
1496         break;
1497       default:
1498         print_usage(TRUE);
1499       }
1500       return 1;
1501       break;
1502     }
1503   }
1504
1505   /* If we specified output fields, but not the output field type... */
1506   if (WRITE_FIELDS != output_action && 0 != output_fields_num_fields(output_fields)) {
1507         cmdarg_err("Output fields were specified with \"-e\", "
1508             "but \"-Tfields\" was not specified.");
1509         return 1;
1510   } else if (WRITE_FIELDS == output_action && 0 == output_fields_num_fields(output_fields)) {
1511         cmdarg_err("\"-Tfields\" was specified, but no fields were "
1512                     "specified with \"-e\".");
1513
1514         return 1;
1515   }
1516
1517   /* If no capture filter or display filter has been specified, and there are
1518      still command-line arguments, treat them as the tokens of a capture
1519      filter (if no "-r" flag was specified) or a display filter (if a "-r"
1520      flag was specified. */
1521   if (optind < argc) {
1522     if (cf_name != NULL) {
1523       if (dfilter != NULL) {
1524         cmdarg_err("Display filters were specified both with \"-d\" "
1525             "and with additional command-line arguments.");
1526         return 1;
1527       }
1528       dfilter = get_args_as_string(argc, argv, optind);
1529     } else {
1530 #ifdef HAVE_LIBPCAP
1531       guint i;
1532
1533       if (global_capture_opts.default_options.cfilter) {
1534         cmdarg_err("A default capture filter was specified both with \"-f\""
1535             " and with additional command-line arguments.");
1536         return 1;
1537       }
1538       for (i = 0; i < global_capture_opts.ifaces->len; i++) {
1539         interface_options interface_opts;
1540         interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
1541         if (interface_opts.cfilter == NULL) {
1542           interface_opts.cfilter = get_args_as_string(argc, argv, optind);
1543           global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
1544           g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
1545         } else {
1546           cmdarg_err("A capture filter was specified both with \"-f\""
1547               " and with additional command-line arguments.");
1548           return 1;
1549         }
1550       }
1551       global_capture_opts.default_options.cfilter = get_args_as_string(argc, argv, optind);
1552 #else
1553       capture_option_specified = TRUE;
1554 #endif
1555     }
1556   }
1557
1558 #ifdef HAVE_LIBPCAP
1559   if (!global_capture_opts.saving_to_file) {
1560     /* We're not saving the capture to a file; if "-q" wasn't specified,
1561        we should print packet information */
1562     if (!quiet)
1563       print_packet_info = TRUE;
1564   } else {
1565     /* We're saving to a file; if we're writing to the standard output.
1566        and we'll also be writing dissected packets to the standard
1567        output, reject the request.  At best, we could redirect that
1568        to the standard error; we *can't* write both to the standard
1569        output and have either of them be useful. */
1570     if (strcmp(global_capture_opts.save_file, "-") == 0 && print_packet_info) {
1571       cmdarg_err("You can't write both raw packet data and dissected packets"
1572           " to the standard output.");
1573       return 1;
1574     }
1575   }
1576 #else
1577   /* We're not saving the capture to a file; if "-q" wasn't specified,
1578      we should print packet information */
1579   if (!quiet)
1580     print_packet_info = TRUE;
1581 #endif
1582
1583 #ifndef HAVE_LIBPCAP
1584   if (capture_option_specified)
1585     cmdarg_err("This version of TShark was not built with support for capturing packets.");
1586 #endif
1587   if (arg_error) {
1588     print_usage(FALSE);
1589     return 1;
1590   }
1591
1592   /* We don't support capture filters when reading from a capture file
1593      (the BPF compiler doesn't support all link-layer types that we
1594      support in capture files we read). */
1595 #ifdef HAVE_LIBPCAP
1596   if (cf_name != NULL) {
1597     if (global_capture_opts.default_options.cfilter) {
1598       cmdarg_err("Only read filters, not capture filters, "
1599           "can be specified when reading a capture file.");
1600       return 1;
1601     }
1602   }
1603 #endif
1604
1605   if (print_hex) {
1606     if (output_action != WRITE_TEXT) {
1607       cmdarg_err("Raw packet hex data can only be printed as text or PostScript");
1608       return 1;
1609     }
1610   }
1611
1612   if (output_only != NULL) {
1613     char *ps;
1614
1615     if (!print_details) {
1616       cmdarg_err("-O requires -V");
1617       return 1;
1618     }
1619
1620     output_only_tables = g_hash_table_new (g_str_hash, g_str_equal);
1621     for (ps = strtok (output_only, ","); ps; ps = strtok (NULL, ",")) {
1622       g_hash_table_insert(output_only_tables, (gpointer)ps, (gpointer)ps);
1623     }
1624   }
1625
1626   if (rfilter != NULL && !perform_two_pass_analysis) {
1627     /* Just a warning, so we don't return */
1628     cmdarg_err("-R without -2 is deprecated. For single-pass filtering use -Y.");
1629   }
1630
1631 #ifdef HAVE_LIBPCAP
1632   if (list_link_layer_types) {
1633     /* We're supposed to list the link-layer types for an interface;
1634        did the user also specify a capture file to be read? */
1635     if (cf_name) {
1636       /* Yes - that's bogus. */
1637       cmdarg_err("You can't specify -L and a capture file to be read.");
1638       return 1;
1639     }
1640     /* No - did they specify a ring buffer option? */
1641     if (global_capture_opts.multi_files_on) {
1642       cmdarg_err("Ring buffer requested, but a capture isn't being done.");
1643       return 1;
1644     }
1645   } else {
1646     if (cf_name) {
1647       /*
1648        * "-r" was specified, so we're reading a capture file.
1649        * Capture options don't apply here.
1650        */
1651       if (global_capture_opts.multi_files_on) {
1652         cmdarg_err("Multiple capture files requested, but "
1653                    "a capture isn't being done.");
1654         return 1;
1655       }
1656       if (global_capture_opts.has_file_duration) {
1657         cmdarg_err("Switching capture files after a time interval was specified, but "
1658                    "a capture isn't being done.");
1659         return 1;
1660       }
1661       if (global_capture_opts.has_ring_num_files) {
1662         cmdarg_err("A ring buffer of capture files was specified, but "
1663           "a capture isn't being done.");
1664         return 1;
1665       }
1666       if (global_capture_opts.has_autostop_files) {
1667         cmdarg_err("A maximum number of capture files was specified, but "
1668           "a capture isn't being done.");
1669         return 1;
1670       }
1671
1672       /* Note: TShark now allows the restriction of a _read_ file by packet count
1673        * and byte count as well as a write file. Other autostop options remain valid
1674        * only for a write file.
1675        */
1676       if (global_capture_opts.has_autostop_duration) {
1677         cmdarg_err("A maximum capture time was specified, but "
1678           "a capture isn't being done.");
1679         return 1;
1680       }
1681     } else {
1682       /*
1683        * "-r" wasn't specified, so we're doing a live capture.
1684        */
1685       if (global_capture_opts.saving_to_file) {
1686         /* They specified a "-w" flag, so we'll be saving to a capture file. */
1687
1688         /* When capturing, we only support writing pcap or pcap-ng format. */
1689         if (out_file_type != WTAP_FILE_PCAP && out_file_type != WTAP_FILE_PCAPNG) {
1690           cmdarg_err("Live captures can only be saved in libpcap format.");
1691           return 1;
1692         }
1693         if (global_capture_opts.multi_files_on) {
1694           /* Multiple-file mode doesn't work under certain conditions:
1695              a) it doesn't work if you're writing to the standard output;
1696              b) it doesn't work if you're writing to a pipe;
1697           */
1698           if (strcmp(global_capture_opts.save_file, "-") == 0) {
1699             cmdarg_err("Multiple capture files requested, but "
1700               "the capture is being written to the standard output.");
1701             return 1;
1702           }
1703           if (global_capture_opts.output_to_pipe) {
1704             cmdarg_err("Multiple capture files requested, but "
1705               "the capture file is a pipe.");
1706             return 1;
1707           }
1708           if (!global_capture_opts.has_autostop_filesize &&
1709               !global_capture_opts.has_file_duration) {
1710             cmdarg_err("Multiple capture files requested, but "
1711               "no maximum capture file size or duration was specified.");
1712             return 1;
1713           }
1714         }
1715         /* Currently, we don't support read or display filters when capturing
1716            and saving the packets. */
1717         if (rfilter != NULL) {
1718           cmdarg_err("Read filters aren't supported when capturing and saving the captured packets.");
1719           return 1;
1720         }
1721         if (dfilter != NULL) {
1722           cmdarg_err("Display filters aren't supported when capturing and saving the captured packets.");
1723           return 1;
1724         }
1725       } else {
1726         /* They didn't specify a "-w" flag, so we won't be saving to a
1727            capture file.  Check for options that only make sense if
1728            we're saving to a file. */
1729         if (global_capture_opts.has_autostop_filesize) {
1730           cmdarg_err("Maximum capture file size specified, but "
1731            "capture isn't being saved to a file.");
1732           return 1;
1733         }
1734         if (global_capture_opts.multi_files_on) {
1735           cmdarg_err("Multiple capture files requested, but "
1736             "the capture isn't being saved to a file.");
1737           return 1;
1738         }
1739       }
1740     }
1741   }
1742 #endif
1743
1744 #ifdef _WIN32
1745   /* Start windows sockets */
1746   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
1747 #endif /* _WIN32 */
1748
1749   /* Notify all registered modules that have had any of their preferences
1750      changed either from one of the preferences file or from the command
1751      line that their preferences have changed. */
1752   prefs_apply_all();
1753
1754   /* At this point MATE will have registered its field array so we can
1755      have a tap filter with one of MATE's late-registered fields as part
1756      of the filter.  We can now process all the "-z" arguments. */
1757   start_requested_stats();
1758
1759 #ifdef HAVE_LIBPCAP
1760   /* We currently don't support taps, or printing dissected packets,
1761      if we're writing to a pipe. */
1762   if (global_capture_opts.saving_to_file &&
1763       global_capture_opts.output_to_pipe) {
1764     if (tap_listeners_require_dissection()) {
1765       cmdarg_err("Taps aren't supported when saving to a pipe.");
1766       return 1;
1767     }
1768     if (print_packet_info) {
1769       cmdarg_err("Printing dissected packets isn't supported when saving to a pipe.");
1770       return 1;
1771     }
1772   }
1773 #endif
1774
1775   /* disabled protocols as per configuration file */
1776   if (gdp_path == NULL && dp_path == NULL) {
1777     set_disabled_protos_list();
1778   }
1779
1780   /* Build the column format array */
1781   build_column_format_array(&cfile.cinfo, prefs_p->num_cols, TRUE);
1782
1783 #ifdef HAVE_LIBPCAP
1784   capture_opts_trim_snaplen(&global_capture_opts, MIN_PACKET_SIZE);
1785   capture_opts_trim_ring_num_files(&global_capture_opts);
1786 #endif
1787
1788   if (rfilter != NULL) {
1789     if (!dfilter_compile(rfilter, &rfcode)) {
1790       cmdarg_err("%s", dfilter_error_msg);
1791       epan_cleanup();
1792 #ifdef HAVE_PCAP_OPEN_DEAD
1793       {
1794         pcap_t *pc;
1795
1796         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1797         if (pc != NULL) {
1798           if (pcap_compile(pc, &fcode, rfilter, 0, 0) != -1) {
1799             cmdarg_err_cont(
1800               "  Note: That read filter code looks like a valid capture filter;");
1801             cmdarg_err_cont(
1802               "        maybe you mixed them up?");
1803           }
1804           pcap_close(pc);
1805         }
1806       }
1807 #endif
1808       return 2;
1809     }
1810   }
1811   cfile.rfcode = rfcode;
1812
1813   if (dfilter != NULL) {
1814     if (!dfilter_compile(dfilter, &dfcode)) {
1815       cmdarg_err("%s", dfilter_error_msg);
1816       epan_cleanup();
1817 #ifdef HAVE_PCAP_OPEN_DEAD
1818       {
1819         pcap_t *pc;
1820
1821         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1822         if (pc != NULL) {
1823           if (pcap_compile(pc, &fcode, dfilter, 0, 0) != -1) {
1824             cmdarg_err_cont(
1825               "  Note: That display filter code looks like a valid capture filter;");
1826             cmdarg_err_cont(
1827               "        maybe you mixed them up?");
1828           }
1829           pcap_close(pc);
1830         }
1831       }
1832 #endif
1833       return 2;
1834     }
1835   }
1836   cfile.dfcode = dfcode;
1837
1838   if (print_packet_info) {
1839     /* If we're printing as text or PostScript, we have
1840        to create a print stream. */
1841     if (output_action == WRITE_TEXT) {
1842       switch (print_format) {
1843
1844       case PR_FMT_TEXT:
1845         print_stream = print_stream_text_stdio_new(stdout);
1846         break;
1847
1848       case PR_FMT_PS:
1849         print_stream = print_stream_ps_stdio_new(stdout);
1850         break;
1851
1852       default:
1853         g_assert_not_reached();
1854       }
1855     }
1856   }
1857
1858   /* We have to dissect each packet if:
1859
1860         we're printing information about each packet;
1861
1862         we're using a read filter on the packets;
1863
1864         we're using a display filter on the packets;
1865
1866         we're using any taps that need dissection. */
1867   do_dissection = print_packet_info || rfcode || dfcode || tap_listeners_require_dissection();
1868
1869   if (cf_name) {
1870     /*
1871      * We're reading a capture file.
1872      */
1873
1874     /*
1875      * Immediately relinquish any special privileges we have; we must not
1876      * be allowed to read any capture files the user running TShark
1877      * can't open.
1878      */
1879     relinquish_special_privs_perm();
1880     print_current_user();
1881
1882     if (cf_open(&cfile, cf_name, FALSE, &err) != CF_OK) {
1883       epan_cleanup();
1884       return 2;
1885     }
1886
1887     /* Set timestamp precision; there should arguably be a command-line
1888        option to let the user set this. */
1889     switch(wtap_file_tsprecision(cfile.wth)) {
1890     case(WTAP_FILE_TSPREC_SEC):
1891       timestamp_set_precision(TS_PREC_AUTO_SEC);
1892       break;
1893     case(WTAP_FILE_TSPREC_DSEC):
1894       timestamp_set_precision(TS_PREC_AUTO_DSEC);
1895       break;
1896     case(WTAP_FILE_TSPREC_CSEC):
1897       timestamp_set_precision(TS_PREC_AUTO_CSEC);
1898       break;
1899     case(WTAP_FILE_TSPREC_MSEC):
1900       timestamp_set_precision(TS_PREC_AUTO_MSEC);
1901       break;
1902     case(WTAP_FILE_TSPREC_USEC):
1903       timestamp_set_precision(TS_PREC_AUTO_USEC);
1904       break;
1905     case(WTAP_FILE_TSPREC_NSEC):
1906       timestamp_set_precision(TS_PREC_AUTO_NSEC);
1907       break;
1908     default:
1909       g_assert_not_reached();
1910     }
1911
1912     /* Process the packets in the file */
1913     TRY {
1914 #ifdef HAVE_LIBPCAP
1915       err = load_cap_file(&cfile, global_capture_opts.save_file, out_file_type, out_file_name_res,
1916           global_capture_opts.has_autostop_packets ? global_capture_opts.autostop_packets : 0,
1917           global_capture_opts.has_autostop_filesize ? global_capture_opts.autostop_filesize : 0);
1918 #else
1919       err = load_cap_file(&cfile, NULL, out_file_type, out_file_name_res, 0, 0);
1920 #endif
1921     }
1922     CATCH(OutOfMemoryError) {
1923       fprintf(stderr,
1924               "Out Of Memory!\n"
1925               "\n"
1926               "Sorry, but TShark has to terminate now!\n"
1927               "\n"
1928               "Some infos / workarounds can be found at:\n"
1929               "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
1930       err = ENOMEM;
1931     }
1932     ENDTRY;
1933     if (err != 0) {
1934       /* We still dump out the results of taps, etc., as we might have
1935          read some packets; however, we exit with an error status. */
1936       exit_status = 2;
1937     }
1938   } else {
1939     /* No capture file specified, so we're supposed to do a live capture
1940        (or get a list of link-layer types for a live capture device);
1941        do we have support for live captures? */
1942 #ifdef HAVE_LIBPCAP
1943     /* trim the interface name and exit if that failed */
1944     exit_status = capture_opts_trim_iface(&global_capture_opts,
1945         ((prefs_p->capture_device) && (*prefs_p->capture_device != '\0')) ? get_if_name(prefs_p->capture_device) : NULL);
1946     if (exit_status != 0)
1947         return exit_status;
1948
1949     /* if requested, list the link layer types and exit */
1950     if (list_link_layer_types) {
1951         guint i;
1952
1953         /* Get the list of link-layer types for the capture devices. */
1954         for (i = 0; i < global_capture_opts.ifaces->len; i++) {
1955           interface_options  interface_opts;
1956           if_capabilities_t *caps;
1957
1958           interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
1959           caps = capture_get_if_capabilities(interface_opts.name, interface_opts.monitor_mode, &err_str);
1960           if (caps == NULL) {
1961             cmdarg_err("%s", err_str);
1962             g_free(err_str);
1963             return 2;
1964           }
1965           if (caps->data_link_types == NULL) {
1966             cmdarg_err("The capture device \"%s\" has no data link types.", interface_opts.name);
1967             return 2;
1968           }
1969           capture_opts_print_if_capabilities(caps, interface_opts.name, interface_opts.monitor_mode);
1970           free_if_capabilities(caps);
1971         }
1972         return 0;
1973     }
1974
1975     if (print_packet_info) {
1976       if (!write_preamble(NULL)) {
1977         show_print_file_io_error(errno);
1978         return 2;
1979       }
1980     } else if (!quiet) {
1981       /*
1982        * We're not printing information for each packet, and the user
1983        * didn't ask us not to print a count of packets as they arrive,
1984        * so print that count so the user knows that packets are arriving.
1985        *
1986        * XXX - what if the user wants to do a live capture, doesn't want
1987        * to save it to a file, doesn't want information printed for each
1988        * packet, does want some "-z" statistic, and wants packet counts
1989        * so they know whether they're seeing any packets?
1990        */
1991       print_packet_counts = TRUE;
1992     }
1993
1994     /* For now, assume libpcap gives microsecond precision. */
1995     timestamp_set_precision(TS_PREC_AUTO_USEC);
1996
1997     /*
1998      * XXX - this returns FALSE if an error occurred, but it also
1999      * returns FALSE if the capture stops because a time limit
2000      * was reached (and possibly other limits), so we can't assume
2001      * it means an error.
2002      *
2003      * The capture code is a bit twisty, so it doesn't appear to
2004      * be an easy fix.  We just ignore the return value for now.
2005      * Instead, pass on the exit status from the capture child.
2006      */
2007     capture();
2008     exit_status = global_capture_opts.fork_child_status;
2009
2010     if (print_packet_info) {
2011       if (!write_finale()) {
2012         err = errno;
2013         show_print_file_io_error(err);
2014       }
2015     }
2016 #else
2017     /* No - complain. */
2018     cmdarg_err("This version of TShark was not built with support for capturing packets.");
2019     return 2;
2020 #endif
2021   }
2022
2023   g_free(cf_name);
2024
2025   if (cfile.frames != NULL) {
2026     free_frame_data_sequence(cfile.frames);
2027     cfile.frames = NULL;
2028   }
2029
2030   draw_tap_listeners(TRUE);
2031   funnel_dump_all_text_windows();
2032   epan_cleanup();
2033
2034   output_fields_free(output_fields);
2035   output_fields = NULL;
2036
2037   return exit_status;
2038 }
2039
2040 /*#define USE_BROKEN_G_MAIN_LOOP*/
2041
2042 #ifdef USE_BROKEN_G_MAIN_LOOP
2043   GMainLoop *loop;
2044 #else
2045   gboolean loop_running = FALSE;
2046 #endif
2047   guint32 packet_count = 0;
2048
2049
2050 /* XXX - move to the right position / file */
2051 /* read from a pipe (callback) */
2052 typedef gboolean (*pipe_input_cb_t) (gint source, gpointer user_data);
2053
2054 typedef struct pipe_input_tag {
2055   gint             source;
2056   gpointer         user_data;
2057   int             *child_process;
2058   pipe_input_cb_t  input_cb;
2059   guint            pipe_input_id;
2060 #ifdef _WIN32
2061   GMutex          *callback_running;
2062 #endif
2063 } pipe_input_t;
2064
2065 static pipe_input_t pipe_input;
2066
2067 #ifdef _WIN32
2068 /* The timer has expired, see if there's stuff to read from the pipe,
2069    if so, do the callback */
2070 static gint
2071 pipe_timer_cb(gpointer data)
2072 {
2073   HANDLE        handle;
2074   DWORD         avail        = 0;
2075   gboolean      result;
2076   DWORD         childstatus;
2077   pipe_input_t *pipe_input_p = data;
2078   gint          iterations   = 0;
2079
2080   g_mutex_lock (pipe_input_p->callback_running);
2081
2082   /* try to read data from the pipe only 5 times, to avoid blocking */
2083   while(iterations < 5) {
2084     /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: new iteration");*/
2085
2086     /* Oddly enough although Named pipes don't work on win9x,
2087        PeekNamedPipe does !!! */
2088     handle = (HANDLE) _get_osfhandle (pipe_input_p->source);
2089     result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
2090
2091     /* Get the child process exit status */
2092     GetExitCodeProcess((HANDLE)*(pipe_input_p->child_process),
2093                        &childstatus);
2094
2095     /* If the Peek returned an error, or there are bytes to be read
2096        or the childwatcher thread has terminated then call the normal
2097        callback */
2098     if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
2099
2100       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: data avail");*/
2101
2102       /* And call the real handler */
2103       if (!pipe_input_p->input_cb(pipe_input_p->source, pipe_input_p->user_data)) {
2104         g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
2105         /* pipe closed, return false so that the timer is stopped */
2106         g_mutex_unlock (pipe_input_p->callback_running);
2107         return FALSE;
2108       }
2109     }
2110     else {
2111       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: no data avail");*/
2112       /* No data, stop now */
2113       break;
2114     }
2115
2116     iterations++;
2117   }
2118
2119   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: finished with iterations: %u, new timer", iterations);*/
2120
2121   g_mutex_unlock (pipe_input_p->callback_running);
2122
2123   /* we didn't stopped the timer, so let it run */
2124   return TRUE;
2125 }
2126 #endif
2127
2128
2129 void
2130 pipe_input_set_handler(gint source, gpointer user_data, int *child_process, pipe_input_cb_t input_cb)
2131 {
2132
2133   pipe_input.source         = source;
2134   pipe_input.child_process  = child_process;
2135   pipe_input.user_data      = user_data;
2136   pipe_input.input_cb       = input_cb;
2137
2138 #ifdef _WIN32
2139 #if GLIB_CHECK_VERSION(2,31,0)
2140   pipe_input.callback_running = g_malloc(sizeof(GMutex));
2141   g_mutex_init(pipe_input.callback_running);
2142 #else
2143   pipe_input.callback_running = g_mutex_new();
2144 #endif
2145   /* Tricky to use pipes in win9x, as no concept of wait.  NT can
2146      do this but that doesn't cover all win32 platforms.  GTK can do
2147      this but doesn't seem to work over processes.  Attempt to do
2148      something similar here, start a timer and check for data on every
2149      timeout. */
2150   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
2151   pipe_input.pipe_input_id = g_timeout_add(200, pipe_timer_cb, &pipe_input);
2152 #endif
2153 }
2154
2155
2156 #ifdef HAVE_LIBPCAP
2157 static gboolean
2158 capture(void)
2159 {
2160   gboolean          ret;
2161   guint             i;
2162   GString          *str = g_string_new("");
2163 #ifdef USE_TSHARK_SELECT
2164   fd_set            readfds;
2165 #endif
2166 #ifndef _WIN32
2167   struct sigaction  action, oldaction;
2168 #endif
2169
2170   /*
2171    * XXX - dropping privileges is still required, until code cleanup is done
2172    *
2173    * remove all dependencies to pcap specific code and using only dumpcap is almost done.
2174    * when it's done, we don't need special privileges to run tshark at all,
2175    * therefore we don't need to drop these privileges
2176    * The only thing we might want to keep is a warning if tshark is run as root,
2177    * as it's no longer necessary and potentially dangerous.
2178    *
2179    * THE FOLLOWING IS THE FORMER COMMENT WHICH IS NO LONGER REALLY VALID:
2180    * We've opened the capture device, so we shouldn't need any special
2181    * privileges any more; relinquish those privileges.
2182    *
2183    * XXX - if we have saved set-user-ID support, we should give up those
2184    * privileges immediately, and then reclaim them long enough to get
2185    * a list of network interfaces and to open one, and then give them
2186    * up again, so that stuff we do while processing the argument list,
2187    * reading the user's preferences, loading and starting plugins
2188    * (especially *user* plugins), etc. is done with the user's privileges,
2189    * not special privileges.
2190    */
2191   relinquish_special_privs_perm();
2192   print_current_user();
2193
2194   /* Cleanup all data structures used for dissection. */
2195   cleanup_dissection();
2196   /* Initialize all data structures used for dissection. */
2197   init_dissection();
2198
2199 #ifdef _WIN32
2200   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
2201   SetConsoleCtrlHandler(capture_cleanup, TRUE);
2202 #else /* _WIN32 */
2203   /* Catch SIGINT and SIGTERM and, if we get either of them,
2204      clean up and exit.  If SIGHUP isn't being ignored, catch
2205      it too and, if we get it, clean up and exit.
2206
2207      We restart any read that was in progress, so that it doesn't
2208      disrupt reading from the sync pipe.  The signal handler tells
2209      the capture child to finish; it will report that it finished,
2210      or will exit abnormally, so  we'll stop reading from the sync
2211      pipe, pick up the exit status, and quit. */
2212   memset(&action, 0, sizeof(action));
2213   action.sa_handler = capture_cleanup;
2214   action.sa_flags = SA_RESTART;
2215   sigemptyset(&action.sa_mask);
2216   sigaction(SIGTERM, &action, NULL);
2217   sigaction(SIGINT, &action, NULL);
2218   sigaction(SIGHUP, NULL, &oldaction);
2219   if (oldaction.sa_handler == SIG_DFL)
2220     sigaction(SIGHUP, &action, NULL);
2221
2222 #ifdef SIGINFO
2223   /* Catch SIGINFO and, if we get it and we're capturing to a file in
2224      quiet mode, report the number of packets we've captured.
2225
2226      Again, restart any read that was in progress, so that it doesn't
2227      disrupt reading from the sync pipe. */
2228   action.sa_handler = report_counts_siginfo;
2229   action.sa_flags = SA_RESTART;
2230   sigemptyset(&action.sa_mask);
2231   sigaction(SIGINFO, &action, NULL);
2232 #endif /* SIGINFO */
2233 #endif /* _WIN32 */
2234
2235   global_capture_opts.state = CAPTURE_PREPARING;
2236
2237   /* Let the user know which interfaces were chosen. */
2238   for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2239     interface_options interface_opts;
2240
2241     interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2242     interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
2243     global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
2244     g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
2245   }
2246 #ifdef _WIN32
2247   if (global_capture_opts.ifaces->len < 2) {
2248 #else
2249   if (global_capture_opts.ifaces->len < 4) {
2250 #endif
2251     for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2252       interface_options interface_opts;
2253
2254       interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2255       if (i > 0) {
2256           if (global_capture_opts.ifaces->len > 2) {
2257               g_string_append_printf(str, ",");
2258           }
2259           g_string_append_printf(str, " ");
2260           if (i == global_capture_opts.ifaces->len - 1) {
2261               g_string_append_printf(str, "and ");
2262           }
2263       }
2264       g_string_append_printf(str, "'%s'", interface_opts.descr);
2265     }
2266   } else {
2267     g_string_append_printf(str, "%u interfaces", global_capture_opts.ifaces->len);
2268   }
2269   if (really_quiet == FALSE)
2270     fprintf(stderr, "Capturing on %s\n", str->str);
2271   fflush(stderr);
2272   g_string_free(str, TRUE);
2273
2274   ret = sync_pipe_start(&global_capture_opts);
2275
2276   if (!ret)
2277     return FALSE;
2278
2279   /* the actual capture loop
2280    *
2281    * XXX - glib doesn't seem to provide any event based loop handling.
2282    *
2283    * XXX - for whatever reason,
2284    * calling g_main_loop_new() ends up in 100% cpu load.
2285    *
2286    * But that doesn't matter: in UNIX we can use select() to find an input
2287    * source with something to do.
2288    *
2289    * But that doesn't matter because we're in a CLI (that doesn't need to
2290    * update a GUI or something at the same time) so it's OK if we block
2291    * trying to read from the pipe.
2292    *
2293    * So all the stuff in USE_TSHARK_SELECT could be removed unless I'm
2294    * wrong (but I leave it there in case I am...).
2295    */
2296
2297 #ifdef USE_TSHARK_SELECT
2298   FD_ZERO(&readfds);
2299   FD_SET(pipe_input.source, &readfds);
2300 #endif
2301
2302   loop_running = TRUE;
2303
2304   TRY
2305   {
2306     while (loop_running)
2307     {
2308 #ifdef USE_TSHARK_SELECT
2309       ret = select(pipe_input.source+1, &readfds, NULL, NULL, NULL);
2310
2311       if (ret == -1)
2312       {
2313         perror("select()");
2314         return TRUE;
2315       } else if (ret == 1) {
2316 #endif
2317         /* Call the real handler */
2318         if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
2319           g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
2320           return FALSE;
2321         }
2322 #ifdef USE_TSHARK_SELECT
2323       }
2324 #endif
2325     }
2326   }
2327   CATCH(OutOfMemoryError) {
2328     fprintf(stderr,
2329             "Out Of Memory!\n"
2330             "\n"
2331             "Sorry, but TShark has to terminate now!\n"
2332             "\n"
2333             "Some infos / workarounds can be found at:\n"
2334             "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2335     exit(1);
2336   }
2337   ENDTRY;
2338   return TRUE;
2339 }
2340
2341
2342 /* XXX - move the call to main_window_update() out of capture_sync.c */
2343 /* dummy for capture_sync.c to make linker happy */
2344 void main_window_update(void)
2345 {
2346 }
2347
2348 /* capture child detected an error */
2349 void
2350 capture_input_error_message(capture_options *capture_opts _U_, char *error_msg, char *secondary_error_msg)
2351 {
2352   cmdarg_err("%s", error_msg);
2353   cmdarg_err_cont("%s", secondary_error_msg);
2354 }
2355
2356
2357 /* capture child detected an capture filter related error */
2358 void
2359 capture_input_cfilter_error_message(capture_options *capture_opts, guint i, char *error_message)
2360 {
2361   dfilter_t         *rfcode = NULL;
2362   interface_options  interface_opts;
2363
2364   g_assert(i < capture_opts->ifaces->len);
2365   interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
2366
2367   if (dfilter_compile(interface_opts.cfilter, &rfcode) && rfcode != NULL) {
2368     cmdarg_err(
2369       "Invalid capture filter \"%s\" for interface %s!\n"
2370       "\n"
2371       "That string looks like a valid display filter; however, it isn't a valid\n"
2372       "capture filter (%s).\n"
2373       "\n"
2374       "Note that display filters and capture filters don't have the same syntax,\n"
2375       "so you can't use most display filter expressions as capture filters.\n"
2376       "\n"
2377       "See the User's Guide for a description of the capture filter syntax.",
2378       interface_opts.cfilter, interface_opts.descr, error_message);
2379     dfilter_free(rfcode);
2380   } else {
2381     cmdarg_err(
2382       "Invalid capture filter \"%s\" for interface %s!\n"
2383       "\n"
2384       "That string isn't a valid capture filter (%s).\n"
2385       "See the User's Guide for a description of the capture filter syntax.",
2386       interface_opts.cfilter, interface_opts.descr, error_message);
2387   }
2388 }
2389
2390
2391 /* capture child tells us we have a new (or the first) capture file */
2392 gboolean
2393 capture_input_new_file(capture_options *capture_opts, gchar *new_file)
2394 {
2395   gboolean is_tempfile;
2396   int      err;
2397
2398   if (capture_opts->state == CAPTURE_PREPARING) {
2399     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!");
2400   }
2401   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
2402
2403   g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING);
2404
2405   /* free the old filename */
2406   if (capture_opts->save_file != NULL) {
2407
2408     /* we start a new capture file, close the old one (if we had one before) */
2409     if ( ((capture_file *) capture_opts->cf)->state != FILE_CLOSED) {
2410       if ( ((capture_file *) capture_opts->cf)->wth != NULL) {
2411         wtap_close(((capture_file *) capture_opts->cf)->wth);
2412       }
2413       ((capture_file *) capture_opts->cf)->state = FILE_CLOSED;
2414     }
2415
2416     g_free(capture_opts->save_file);
2417     is_tempfile = FALSE;
2418   } else {
2419     /* we didn't had a save_file before, must be a tempfile */
2420     is_tempfile = TRUE;
2421   }
2422
2423   /* save the new filename */
2424   capture_opts->save_file = g_strdup(new_file);
2425
2426   /* if we are in real-time mode, open the new file now */
2427   if (do_dissection) {
2428     /* Attempt to open the capture file and set up to read from it. */
2429     switch(cf_open((capture_file *)capture_opts->cf, capture_opts->save_file, is_tempfile, &err)) {
2430     case CF_OK:
2431       break;
2432     case CF_ERROR:
2433       /* Don't unlink (delete) the save file - leave it around,
2434          for debugging purposes. */
2435       g_free(capture_opts->save_file);
2436       capture_opts->save_file = NULL;
2437       return FALSE;
2438     }
2439   }
2440
2441   capture_opts->state = CAPTURE_RUNNING;
2442
2443   return TRUE;
2444 }
2445
2446
2447 /* capture child tells us we have new packets to read */
2448 void
2449 capture_input_new_packets(capture_options *capture_opts, int to_read)
2450 {
2451   gboolean      ret;
2452   int           err;
2453   gchar        *err_info;
2454   gint64        data_offset;
2455   capture_file *cf = (capture_file *)capture_opts->cf;
2456   gboolean      filtering_tap_listeners;
2457   guint         tap_flags;
2458
2459 #ifdef SIGINFO
2460   /*
2461    * Prevent a SIGINFO handler from writing to the standard error while
2462    * we're doing so or writing to the standard output; instead, have it
2463    * just set a flag telling us to print that information when we're done.
2464    */
2465   infodelay = TRUE;
2466 #endif /* SIGINFO */
2467
2468   /* Do we have any tap listeners with filters? */
2469   filtering_tap_listeners = have_filtering_tap_listeners();
2470
2471   /* Get the union of the flags for all tap listeners. */
2472   tap_flags = union_of_tap_listener_flags();
2473
2474   if (do_dissection) {
2475     while (to_read-- && cf->wth) {
2476       wtap_cleareof(cf->wth);
2477       ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
2478       if (ret == FALSE) {
2479         /* read from file failed, tell the capture child to stop */
2480         sync_pipe_stop(capture_opts);
2481         wtap_close(cf->wth);
2482         cf->wth = NULL;
2483       } else {
2484         ret = process_packet(cf, data_offset, wtap_phdr(cf->wth),
2485                              wtap_buf_ptr(cf->wth),
2486                              filtering_tap_listeners, tap_flags);
2487       }
2488       if (ret != FALSE) {
2489         /* packet successfully read and gone through the "Read Filter" */
2490         packet_count++;
2491       }
2492     }
2493   } else {
2494     /*
2495      * Dumpcap's doing all the work; we're not doing any dissection.
2496      * Count all the packets it wrote.
2497      */
2498     packet_count += to_read;
2499   }
2500
2501   if (print_packet_counts) {
2502       /* We're printing packet counts. */
2503       if (packet_count != 0) {
2504         fprintf(stderr, "\r%u ", packet_count);
2505         /* stderr could be line buffered */
2506         fflush(stderr);
2507       }
2508   }
2509
2510 #ifdef SIGINFO
2511   /*
2512    * Allow SIGINFO handlers to write.
2513    */
2514   infodelay = FALSE;
2515
2516   /*
2517    * If a SIGINFO handler asked us to write out capture counts, do so.
2518    */
2519   if (infoprint)
2520     report_counts();
2521 #endif /* SIGINFO */
2522 }
2523
2524 static void
2525 report_counts(void)
2526 {
2527   if ((print_packet_counts == FALSE) && (really_quiet == FALSE)) {
2528     /* Report the count only if we aren't printing a packet count
2529        as packets arrive. */
2530       fprintf(stderr, "%u packet%s captured\n", packet_count,
2531             plurality(packet_count, "", "s"));
2532   }
2533 #ifdef SIGINFO
2534   infoprint = FALSE; /* we just reported it */
2535 #endif /* SIGINFO */
2536 }
2537
2538 #ifdef SIGINFO
2539 static void
2540 report_counts_siginfo(int signum _U_)
2541 {
2542   int sav_errno = errno;
2543   /* If we've been told to delay printing, just set a flag asking
2544      that we print counts (if we're supposed to), otherwise print
2545      the count of packets captured (if we're supposed to). */
2546   if (infodelay)
2547     infoprint = TRUE;
2548   else
2549     report_counts();
2550   errno = sav_errno;
2551 }
2552 #endif /* SIGINFO */
2553
2554
2555 /* capture child detected any packet drops? */
2556 void
2557 capture_input_drops(capture_options *capture_opts _U_, guint32 dropped)
2558 {
2559   if (print_packet_counts) {
2560     /* We're printing packet counts to stderr.
2561        Send a newline so that we move to the line after the packet count. */
2562     fprintf(stderr, "\n");
2563   }
2564
2565   if (dropped != 0) {
2566     /* We're printing packet counts to stderr.
2567        Send a newline so that we move to the line after the packet count. */
2568     fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2569   }
2570 }
2571
2572
2573 /*
2574  * Capture child closed its side of the pipe, report any error and
2575  * do the required cleanup.
2576  */
2577 void
2578 capture_input_closed(capture_options *capture_opts, gchar *msg)
2579 {
2580   capture_file *cf = (capture_file *) capture_opts->cf;
2581
2582   if (msg != NULL)
2583     fprintf(stderr, "tshark: %s\n", msg);
2584
2585   report_counts();
2586
2587   if (cf != NULL && cf->wth != NULL) {
2588     wtap_close(cf->wth);
2589     if (cf->is_tempfile) {
2590       ws_unlink(cf->filename);
2591     }
2592   }
2593 #ifdef USE_BROKEN_G_MAIN_LOOP
2594   /*g_main_loop_quit(loop);*/
2595   g_main_quit(loop);
2596 #else
2597   loop_running = FALSE;
2598 #endif
2599 }
2600
2601
2602
2603
2604 #ifdef _WIN32
2605 static BOOL WINAPI
2606 capture_cleanup(DWORD ctrltype _U_)
2607 {
2608   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2609      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2610      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2611      like SIGTERM at least when the machine's shutting down.
2612
2613      For now, we handle them all as indications that we should clean up
2614      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2615      way on UNIX.
2616
2617      We must return TRUE so that no other handler - such as one that would
2618      terminate the process - gets called.
2619
2620      XXX - for some reason, typing ^C to TShark, if you run this in
2621      a Cygwin console window in at least some versions of Cygwin,
2622      causes TShark to terminate immediately; this routine gets
2623      called, but the main loop doesn't get a chance to run and
2624      exit cleanly, at least if this is compiled with Microsoft Visual
2625      C++ (i.e., it's a property of the Cygwin console window or Bash;
2626      it happens if TShark is not built with Cygwin - for all I know,
2627      building it with Cygwin may make the problem go away). */
2628
2629   /* tell the capture child to stop */
2630   sync_pipe_stop(&global_capture_opts);
2631
2632   /* don't stop our own loop already here, otherwise status messages and
2633    * cleanup wouldn't be done properly. The child will indicate the stop of
2634    * everything by calling capture_input_closed() later */
2635
2636   return TRUE;
2637 }
2638 #else
2639 static void
2640 capture_cleanup(int signum _U_)
2641 {
2642   /* tell the capture child to stop */
2643   sync_pipe_stop(&global_capture_opts);
2644
2645   /* don't stop our own loop already here, otherwise status messages and
2646    * cleanup wouldn't be done properly. The child will indicate the stop of
2647    * everything by calling capture_input_closed() later */
2648 }
2649 #endif /* _WIN32 */
2650 #endif /* HAVE_LIBPCAP */
2651
2652 static gboolean
2653 process_packet_first_pass(capture_file *cf,
2654                gint64 offset, struct wtap_pkthdr *whdr,
2655                const guchar *pd)
2656 {
2657   frame_data     fdlocal;
2658   guint32        framenum;
2659   gboolean       create_proto_tree = FALSE;
2660   epan_dissect_t edt;
2661   gboolean       passed;
2662
2663   /* The frame number of this packet is one more than the count of
2664      frames in this packet. */
2665   framenum = cf->count + 1;
2666
2667   /* If we're not running a display filter and we're not printing any
2668      packet information, we don't need to do a dissection. This means
2669      that all packets can be marked as 'passed'. */
2670   passed = TRUE;
2671
2672   frame_data_init(&fdlocal, framenum, whdr, offset, cum_bytes);
2673
2674   /* If we're going to print packet information, or we're going to
2675      run a read filter, or display filter, or we're going to process taps, set up to
2676      do a dissection and do so. */
2677   if (do_dissection) {
2678     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2679         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2680       /* Grab any resolved addresses */
2681       host_name_lookup_process();
2682
2683     /* If we're going to be applying a filter, we'll need to
2684        create a protocol tree against which to apply the filter. */
2685     if (cf->rfcode)
2686       create_proto_tree = TRUE;
2687
2688     /* We're not going to display the protocol tree on this pass,
2689        so it's not going to be "visible". */
2690     epan_dissect_init(&edt, create_proto_tree, FALSE);
2691
2692     /* If we're running a read filter, prime the epan_dissect_t with that
2693        filter. */
2694     if (cf->rfcode)
2695       epan_dissect_prime_dfilter(&edt, cf->rfcode);
2696
2697     frame_data_set_before_dissect(&fdlocal, &cf->elapsed_time,
2698                                   &first_ts, prev_dis, prev_cap);
2699
2700     epan_dissect_run(&edt, whdr, pd, &fdlocal, NULL);
2701
2702     /* Run the read filter if we have one. */
2703     if (cf->rfcode)
2704       passed = dfilter_apply_edt(cf->rfcode, &edt);
2705   }
2706
2707   if (passed) {
2708     frame_data_set_after_dissect(&fdlocal, &cum_bytes);
2709     prev_cap = prev_dis = frame_data_sequence_add(cf->frames, &fdlocal);
2710
2711     g_slist_foreach(edt.pi.dependent_frames, find_and_mark_frame_depended_upon, cf->frames);
2712
2713     cf->count++;
2714   } else {
2715     /* if we don't add it to the frame_data_sequence, clean it up right now
2716      * to avoid leaks */
2717     frame_data_destroy(&fdlocal);
2718     /* TODO, bug #8160 */
2719     /*
2720     prev_cap_frame = fdlocal;
2721     prev_cap = &prev_cap_frame;
2722      */
2723   }
2724
2725   if (do_dissection)
2726     epan_dissect_cleanup(&edt);
2727
2728   return passed;
2729 }
2730
2731 static gboolean
2732 process_packet_second_pass(capture_file *cf, frame_data *fdata,
2733                struct wtap_pkthdr *phdr, const guchar *pd,
2734                gboolean filtering_tap_listeners, guint tap_flags)
2735 {
2736   gboolean        create_proto_tree;
2737   column_info    *cinfo;
2738   epan_dissect_t  edt;
2739   gboolean        passed;
2740
2741   /* If we're not running a display filter and we're not printing any
2742      packet information, we don't need to do a dissection. This means
2743      that all packets can be marked as 'passed'. */
2744   passed = TRUE;
2745
2746   /* If we're going to print packet information, or we're going to
2747      run a read filter, or we're going to process taps, set up to
2748      do a dissection and do so. */
2749   if (do_dissection) {
2750     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2751         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2752       /* Grab any resolved addresses */
2753       host_name_lookup_process();
2754
2755     if (cf->dfcode || print_details || filtering_tap_listeners ||
2756         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
2757       create_proto_tree = TRUE;
2758     else
2759       create_proto_tree = FALSE;
2760
2761     /* The protocol tree will be "visible", i.e., printed, only if we're
2762        printing packet details, which is true if we're printing stuff
2763        ("print_packet_info" is true) and we're in verbose mode
2764        ("packet_details" is true). */
2765     epan_dissect_init(&edt, create_proto_tree, print_packet_info && print_details);
2766
2767     /* If we're running a display filter, prime the epan_dissect_t with that
2768        filter. */
2769     if (cf->dfcode)
2770       epan_dissect_prime_dfilter(&edt, cf->dfcode);
2771
2772     col_custom_prime_edt(&edt, &cf->cinfo);
2773
2774     /* We only need the columns if either
2775          1) some tap needs the columns
2776        or
2777          2) we're printing packet info but we're *not* verbose; in verbose
2778             mode, we print the protocol tree, not the protocol summary.
2779      */
2780     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary))
2781       cinfo = &cf->cinfo;
2782     else
2783       cinfo = NULL;
2784
2785     epan_dissect_run_with_taps(&edt, phdr, pd, fdata, cinfo);
2786
2787     /* Run the read/display filter if we have one. */
2788     if (cf->dfcode)
2789       passed = dfilter_apply_edt(cf->dfcode, &edt);
2790   }
2791
2792   if (passed) {
2793     /* Process this packet. */
2794     if (print_packet_info) {
2795       /* We're printing packet information; print the information for
2796          this packet. */
2797       if (do_dissection)
2798         print_packet(cf, &edt);
2799       else
2800         print_packet(cf, NULL);
2801
2802       /* The ANSI C standard does not appear to *require* that a line-buffered
2803          stream be flushed to the host environment whenever a newline is
2804          written, it just says that, on such a stream, characters "are
2805          intended to be transmitted to or from the host environment as a
2806          block when a new-line character is encountered".
2807
2808          The Visual C++ 6.0 C implementation doesn't do what is intended;
2809          even if you set a stream to be line-buffered, it still doesn't
2810          flush the buffer at the end of every line.
2811
2812          So, if the "-l" flag was specified, we flush the standard output
2813          at the end of a packet.  This will do the right thing if we're
2814          printing packet summary lines, and, as we print the entire protocol
2815          tree for a single packet without waiting for anything to happen,
2816          it should be as good as line-buffered mode if we're printing
2817          protocol trees.  (The whole reason for the "-l" flag in either
2818          tcpdump or TShark is to allow the output of a live capture to
2819          be piped to a program or script and to have that script see the
2820          information for the packet as soon as it's printed, rather than
2821          having to wait until a standard I/O buffer fills up. */
2822       if (line_buffered)
2823         fflush(stdout);
2824
2825       if (ferror(stdout)) {
2826         show_print_file_io_error(errno);
2827         exit(2);
2828       }
2829     }
2830   }
2831
2832   if (do_dissection) {
2833     epan_dissect_cleanup(&edt);
2834   }
2835   return passed || fdata->flags.dependent_of_displayed;
2836 }
2837
2838 static int
2839 load_cap_file(capture_file *cf, char *save_file, int out_file_type,
2840     gboolean out_file_name_res, int max_packet_count, gint64 max_byte_count)
2841 {
2842   gint         linktype;
2843   int          snapshot_length;
2844   wtap_dumper *pdh;
2845   guint32      framenum;
2846   int          err;
2847   gchar       *err_info = NULL;
2848   gint64       data_offset;
2849   char        *save_file_string = NULL;
2850   gboolean     filtering_tap_listeners;
2851   guint        tap_flags;
2852   wtapng_section_t            *shb_hdr;
2853   wtapng_iface_descriptions_t *idb_inf;
2854   char         appname[100];
2855
2856   shb_hdr = wtap_file_get_shb_info(cf->wth);
2857   idb_inf = wtap_file_get_idb_info(cf->wth);
2858 #ifdef PCAP_NG_DEFAULT
2859   if (idb_inf->number_of_interfaces > 0) {
2860     linktype = WTAP_ENCAP_PER_PACKET;
2861   } else {
2862     linktype = wtap_file_encap(cf->wth);
2863   }
2864 #else
2865   linktype = wtap_file_encap(cf->wth);
2866 #endif
2867   if (save_file != NULL) {
2868     /* Get a string that describes what we're writing to */
2869     save_file_string = output_file_description(save_file);
2870
2871     /* Set up to write to the capture file. */
2872     snapshot_length = wtap_snapshot_length(cf->wth);
2873     if (snapshot_length == 0) {
2874       /* Snapshot length of input file not known. */
2875       snapshot_length = WTAP_MAX_PACKET_SIZE;
2876     }
2877     /* If we don't have an application name add Tshark */
2878     if (shb_hdr->shb_user_appl == NULL) {
2879         g_snprintf(appname, sizeof(appname), "TShark " VERSION "%s", wireshark_svnversion);
2880         shb_hdr->shb_user_appl = appname;
2881     }
2882
2883     pdh = wtap_dump_open_ng(save_file, out_file_type, linktype, snapshot_length,
2884         FALSE /* compressed */, shb_hdr, idb_inf, &err);
2885
2886     g_free(idb_inf);
2887     idb_inf = NULL;
2888
2889     if (pdh == NULL) {
2890       /* We couldn't set up to write to the capture file. */
2891       switch (err) {
2892
2893       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
2894         cmdarg_err("Capture files can't be written in that format.");
2895         break;
2896
2897       case WTAP_ERR_UNSUPPORTED_ENCAP:
2898       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
2899         cmdarg_err("The capture file being read can't be written as a "
2900           "\"%s\" file.", wtap_file_type_short_string(out_file_type));
2901         break;
2902
2903       case WTAP_ERR_CANT_OPEN:
2904         cmdarg_err("The %s couldn't be created for some "
2905           "unknown reason.", save_file_string);
2906         break;
2907
2908       case WTAP_ERR_SHORT_WRITE:
2909         cmdarg_err("A full header couldn't be written to the %s.",
2910                    save_file_string);
2911         break;
2912
2913       default:
2914         cmdarg_err("The %s could not be created: %s.", save_file_string,
2915                    wtap_strerror(err));
2916         break;
2917       }
2918       goto out;
2919     }
2920   } else {
2921     if (print_packet_info) {
2922       if (!write_preamble(cf)) {
2923         err = errno;
2924         show_print_file_io_error(err);
2925         goto out;
2926       }
2927     }
2928     pdh = NULL;
2929   }
2930
2931   if (pdh && out_file_name_res) {
2932     if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
2933       cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
2934                  wtap_file_type_short_string(out_file_type));
2935     }
2936   }
2937
2938   /* Do we have any tap listeners with filters? */
2939   filtering_tap_listeners = have_filtering_tap_listeners();
2940
2941   /* Get the union of the flags for all tap listeners. */
2942   tap_flags = union_of_tap_listener_flags();
2943
2944   if (perform_two_pass_analysis) {
2945     frame_data *fdata;
2946     int old_max_packet_count = max_packet_count;
2947
2948     /* Allocate a frame_data_sequence for all the frames. */
2949     cf->frames = new_frame_data_sequence();
2950
2951     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
2952       if (process_packet_first_pass(cf, data_offset, wtap_phdr(cf->wth),
2953                          wtap_buf_ptr(cf->wth))) {
2954         /* Stop reading if we have the maximum number of packets;
2955          * When the -c option has not been used, max_packet_count
2956          * starts at 0, which practically means, never stop reading.
2957          * (unless we roll over max_packet_count ?)
2958          */
2959         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
2960           err = 0; /* This is not an error */
2961           break;
2962         }
2963       }
2964     }
2965
2966     /* Close the sequential I/O side, to free up memory it requires. */
2967     wtap_sequential_close(cf->wth);
2968
2969     /* Allow the protocol dissectors to free up memory that they
2970      * don't need after the sequential run-through of the packets. */
2971     postseq_cleanup_all_protocols();
2972
2973     max_packet_count = old_max_packet_count;
2974
2975     for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
2976       fdata = frame_data_sequence_find(cf->frames, framenum);
2977       if (wtap_seek_read(cf->wth, fdata->file_off, &cf->phdr,
2978           cf->pd, fdata->cap_len, &err, &err_info)) {
2979         if (process_packet_second_pass(cf, fdata,
2980                            &cf->phdr, cf->pd,
2981                            filtering_tap_listeners, tap_flags)) {
2982           /* Either there's no read filtering or this packet passed the
2983              filter, so, if we're writing to a capture file, write
2984              this packet out. */
2985           if (pdh != NULL) {
2986             if (!wtap_dump(pdh, &cf->phdr, cf->pd, &err)) {
2987               /* Error writing to a capture file */
2988               switch (err) {
2989
2990               case WTAP_ERR_UNSUPPORTED_ENCAP:
2991                 /*
2992                  * This is a problem with the particular frame we're writing;
2993                  * note that, and give the frame number.
2994                  *
2995                  * XXX - framenum is not necessarily the frame number in
2996                  * the input file if there was a read filter.
2997                  */
2998                 fprintf(stderr,
2999                         "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
3000                         framenum, cf->filename,
3001                         wtap_file_type_short_string(out_file_type));
3002                 break;
3003
3004               default:
3005                 show_capture_file_io_error(save_file, err, FALSE);
3006                 break;
3007               }
3008               wtap_dump_close(pdh, &err);
3009               g_free(shb_hdr);
3010               exit(2);
3011             }
3012           }
3013           /* Stop reading if we have the maximum number of packets;
3014            * When the -c option has not been used, max_packet_count
3015            * starts at 0, which practically means, never stop reading.
3016            * (unless we roll over max_packet_count ?)
3017            */
3018           if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3019             err = 0; /* This is not an error */
3020             break;
3021           }
3022         }
3023       }
3024     }
3025   }
3026   else {
3027     framenum = 0;
3028     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
3029       framenum++;
3030
3031       if (process_packet(cf, data_offset, wtap_phdr(cf->wth),
3032                          wtap_buf_ptr(cf->wth),
3033                          filtering_tap_listeners, tap_flags)) {
3034         /* Either there's no read filtering or this packet passed the
3035            filter, so, if we're writing to a capture file, write
3036            this packet out. */
3037         if (pdh != NULL) {
3038           if (!wtap_dump(pdh, wtap_phdr(cf->wth), wtap_buf_ptr(cf->wth), &err)) {
3039             /* Error writing to a capture file */
3040             switch (err) {
3041
3042             case WTAP_ERR_UNSUPPORTED_ENCAP:
3043               /*
3044                * This is a problem with the particular frame we're writing;
3045                * note that, and give the frame number.
3046                */
3047               fprintf(stderr,
3048                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
3049                       framenum, cf->filename,
3050                       wtap_file_type_short_string(out_file_type));
3051               break;
3052
3053             default:
3054               show_capture_file_io_error(save_file, err, FALSE);
3055               break;
3056             }
3057             wtap_dump_close(pdh, &err);
3058             g_free(shb_hdr);
3059             exit(2);
3060           }
3061         }
3062         /* Stop reading if we have the maximum number of packets;
3063          * When the -c option has not been used, max_packet_count
3064          * starts at 0, which practically means, never stop reading.
3065          * (unless we roll over max_packet_count ?)
3066          */
3067         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3068           err = 0; /* This is not an error */
3069           break;
3070         }
3071       }
3072     }
3073   }
3074
3075   if (err != 0) {
3076     /*
3077      * Print a message noting that the read failed somewhere along the line.
3078      *
3079      * If we're printing packet data, and the standard output and error are
3080      * going to the same place, flush the standard output, so everything
3081      * buffered up is written, and then print a newline to the standard error
3082      * before printing the error message, to separate it from the packet
3083      * data.  (Alas, that only works on UN*X; st_dev is meaningless, and
3084      * the _fstat() documentation at Microsoft doesn't indicate whether
3085      * st_ino is even supported.)
3086      */
3087 #ifndef _WIN32
3088     if (print_packet_info) {
3089       struct stat stat_stdout, stat_stderr;
3090
3091       if (fstat(1, &stat_stdout) == 0 && fstat(2, &stat_stderr) == 0) {
3092         if (stat_stdout.st_dev == stat_stderr.st_dev &&
3093             stat_stdout.st_ino == stat_stderr.st_ino) {
3094           fflush(stdout);
3095           fprintf(stderr, "\n");
3096         }
3097       }
3098     }
3099 #endif
3100     switch (err) {
3101
3102     case WTAP_ERR_UNSUPPORTED:
3103       cmdarg_err("The file \"%s\" contains record data that TShark doesn't support.\n(%s)",
3104                  cf->filename, err_info);
3105       g_free(err_info);
3106       break;
3107
3108     case WTAP_ERR_UNSUPPORTED_ENCAP:
3109       cmdarg_err("The file \"%s\" has a packet with a network type that TShark doesn't support.\n(%s)",
3110                  cf->filename, err_info);
3111       g_free(err_info);
3112       break;
3113
3114     case WTAP_ERR_CANT_READ:
3115       cmdarg_err("An attempt to read from the file \"%s\" failed for some unknown reason.",
3116                  cf->filename);
3117       break;
3118
3119     case WTAP_ERR_SHORT_READ:
3120       cmdarg_err("The file \"%s\" appears to have been cut short in the middle of a packet.",
3121                  cf->filename);
3122       break;
3123
3124     case WTAP_ERR_BAD_FILE:
3125       cmdarg_err("The file \"%s\" appears to be damaged or corrupt.\n(%s)",
3126                  cf->filename, err_info);
3127       g_free(err_info);
3128       break;
3129
3130     case WTAP_ERR_DECOMPRESS:
3131       cmdarg_err("The compressed file \"%s\" appears to be damaged or corrupt.\n"
3132                  "(%s)", cf->filename, err_info);
3133       break;
3134
3135     default:
3136       cmdarg_err("An error occurred while reading the file \"%s\": %s.",
3137                  cf->filename, wtap_strerror(err));
3138       break;
3139     }
3140     if (save_file != NULL) {
3141       /* Now close the capture file. */
3142       if (!wtap_dump_close(pdh, &err))
3143         show_capture_file_io_error(save_file, err, TRUE);
3144     }
3145   } else {
3146     if (save_file != NULL) {
3147       /* Now close the capture file. */
3148       if (!wtap_dump_close(pdh, &err))
3149         show_capture_file_io_error(save_file, err, TRUE);
3150     } else {
3151       if (print_packet_info) {
3152         if (!write_finale()) {
3153           err = errno;
3154           show_print_file_io_error(err);
3155         }
3156       }
3157     }
3158   }
3159
3160 out:
3161   wtap_close(cf->wth);
3162   cf->wth = NULL;
3163
3164   g_free(save_file_string);
3165   g_free(shb_hdr);
3166
3167   return err;
3168 }
3169
3170 static gboolean
3171 process_packet(capture_file *cf, gint64 offset, struct wtap_pkthdr *whdr,
3172                const guchar *pd,
3173                gboolean filtering_tap_listeners, guint tap_flags)
3174 {
3175   frame_data      fdata;
3176   gboolean        create_proto_tree;
3177   column_info    *cinfo;
3178   epan_dissect_t  edt;
3179   gboolean        passed;
3180
3181   /* Count this packet. */
3182   cf->count++;
3183
3184   /* If we're not running a display filter and we're not printing any
3185      packet information, we don't need to do a dissection. This means
3186      that all packets can be marked as 'passed'. */
3187   passed = TRUE;
3188
3189   frame_data_init(&fdata, cf->count, whdr, offset, cum_bytes);
3190
3191   /* If we're going to print packet information, or we're going to
3192      run a read filter, or we're going to process taps, set up to
3193      do a dissection and do so. */
3194   if (do_dissection) {
3195     if (print_packet_info && (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
3196         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns))
3197       /* Grab any resolved addresses */
3198       host_name_lookup_process();
3199
3200     if (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
3201         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
3202       create_proto_tree = TRUE;
3203     else
3204       create_proto_tree = FALSE;
3205
3206     /* The protocol tree will be "visible", i.e., printed, only if we're
3207        printing packet details, which is true if we're printing stuff
3208        ("print_packet_info" is true) and we're in verbose mode
3209        ("packet_details" is true). */
3210     epan_dissect_init(&edt, create_proto_tree, print_packet_info && print_details);
3211
3212     /* If we're running a filter, prime the epan_dissect_t with that
3213        filter. */
3214     if (cf->rfcode)
3215       epan_dissect_prime_dfilter(&edt, cf->rfcode);
3216     if (cf->dfcode)
3217       epan_dissect_prime_dfilter(&edt, cf->dfcode);
3218
3219     col_custom_prime_edt(&edt, &cf->cinfo);
3220
3221     /* We only need the columns if either
3222          1) some tap needs the columns
3223        or
3224          2) we're printing packet info but we're *not* verbose; in verbose
3225             mode, we print the protocol tree, not the protocol summary.
3226        or
3227          3) there is a column mapped as an individual field */
3228     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
3229       cinfo = &cf->cinfo;
3230     else
3231       cinfo = NULL;
3232
3233     frame_data_set_before_dissect(&fdata, &cf->elapsed_time,
3234                                   &first_ts, prev_dis, prev_cap);
3235
3236     epan_dissect_run_with_taps(&edt, whdr, pd, &fdata, cinfo);
3237
3238     /* Run the filters if we have them. */
3239     if (cf->rfcode)
3240       passed = dfilter_apply_edt(cf->rfcode, &edt);
3241     if (passed && cf->dfcode)
3242       passed = dfilter_apply_edt(cf->dfcode, &edt);
3243   }
3244
3245   if (passed) {
3246     frame_data_set_after_dissect(&fdata, &cum_bytes);
3247
3248     /* Process this packet. */
3249     if (print_packet_info) {
3250       /* We're printing packet information; print the information for
3251          this packet. */
3252       if (do_dissection)
3253         print_packet(cf, &edt);
3254       else
3255         print_packet(cf, NULL);
3256
3257       /* The ANSI C standard does not appear to *require* that a line-buffered
3258          stream be flushed to the host environment whenever a newline is
3259          written, it just says that, on such a stream, characters "are
3260          intended to be transmitted to or from the host environment as a
3261          block when a new-line character is encountered".
3262
3263          The Visual C++ 6.0 C implementation doesn't do what is intended;
3264          even if you set a stream to be line-buffered, it still doesn't
3265          flush the buffer at the end of every line.
3266
3267          So, if the "-l" flag was specified, we flush the standard output
3268          at the end of a packet.  This will do the right thing if we're
3269          printing packet summary lines, and, as we print the entire protocol
3270          tree for a single packet without waiting for anything to happen,
3271          it should be as good as line-buffered mode if we're printing
3272          protocol trees.  (The whole reason for the "-l" flag in either
3273          tcpdump or TShark is to allow the output of a live capture to
3274          be piped to a program or script and to have that script see the
3275          information for the packet as soon as it's printed, rather than
3276          having to wait until a standard I/O buffer fills up. */
3277       if (line_buffered)
3278         fflush(stdout);
3279
3280       if (ferror(stdout)) {
3281         show_print_file_io_error(errno);
3282         exit(2);
3283       }
3284     }
3285
3286     /* this must be set after print_packet() [bug #8160] */
3287     prev_dis_frame = fdata;
3288     prev_dis = &prev_dis_frame;
3289   }
3290
3291   prev_cap_frame = fdata;
3292   prev_cap = &prev_cap_frame;
3293
3294   if (do_dissection) {
3295     epan_dissect_cleanup(&edt);
3296     frame_data_destroy(&fdata);
3297   }
3298   return passed;
3299 }
3300
3301 static gboolean
3302 write_preamble(capture_file *cf)
3303 {
3304   switch (output_action) {
3305
3306   case WRITE_TEXT:
3307     return print_preamble(print_stream, cf ? cf->filename : NULL);
3308
3309   case WRITE_XML:
3310     if (print_details)
3311       write_pdml_preamble(stdout, cf ? cf->filename : NULL);
3312     else
3313       write_psml_preamble(stdout);
3314     return !ferror(stdout);
3315
3316   case WRITE_FIELDS:
3317     write_fields_preamble(output_fields, stdout);
3318     return !ferror(stdout);
3319
3320   default:
3321     g_assert_not_reached();
3322     return FALSE;
3323   }
3324 }
3325
3326 static char *
3327 get_line_buf(size_t len)
3328 {
3329   static char   *line_bufp    = NULL;
3330   static size_t  line_buf_len = 256;
3331   size_t         new_line_buf_len;
3332
3333   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
3334        new_line_buf_len *= 2)
3335     ;
3336   if (line_bufp == NULL) {
3337     line_buf_len = new_line_buf_len;
3338     line_bufp = (char *)g_malloc(line_buf_len + 1);
3339   } else {
3340     if (new_line_buf_len > line_buf_len) {
3341       line_buf_len = new_line_buf_len;
3342       line_bufp = (char *)g_realloc(line_bufp, line_buf_len + 1);
3343     }
3344   }
3345   return line_bufp;
3346 }
3347
3348 static gboolean
3349 print_columns(capture_file *cf)
3350 {
3351   char   *line_bufp;
3352   int     i;
3353   size_t  buf_offset;
3354   size_t  column_len;
3355
3356   line_bufp = get_line_buf(256);
3357   buf_offset = 0;
3358   *line_bufp = '\0';
3359   for (i = 0; i < cf->cinfo.num_cols; i++) {
3360     /* Skip columns not marked as visible. */
3361     if (!get_column_visible(i))
3362       continue;
3363     switch (cf->cinfo.col_fmt[i]) {
3364     case COL_NUMBER:
3365 #ifdef HAVE_LIBPCAP
3366       /*
3367        * Don't print this if we're doing a live capture from a network
3368        * interface - if we're doing a live capture, you won't be
3369        * able to look at the capture in the future (it's not being
3370        * saved anywhere), so the frame numbers are unlikely to be
3371        * useful.
3372        *
3373        * (XXX - it might be nice to be able to save and print at
3374        * the same time, sort of like an "Update list of packets
3375        * in real time" capture in Wireshark.)
3376        */
3377       if (global_capture_opts.ifaces->len > 0)
3378         continue;
3379 #endif
3380       column_len = strlen(cf->cinfo.col_data[i]);
3381       if (column_len < 3)
3382         column_len = 3;
3383       line_bufp = get_line_buf(buf_offset + column_len);
3384       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%3s", cf->cinfo.col_data[i]);
3385       break;
3386
3387     case COL_CLS_TIME:
3388     case COL_REL_TIME:
3389     case COL_ABS_TIME:
3390     case COL_ABS_DATE_TIME:
3391     case COL_UTC_TIME:
3392     case COL_UTC_DATE_TIME: /* XXX - wider */
3393       column_len = strlen(cf->cinfo.col_data[i]);
3394       if (column_len < 10)
3395         column_len = 10;
3396       line_bufp = get_line_buf(buf_offset + column_len);
3397       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%10s", cf->cinfo.col_data[i]);
3398       break;
3399
3400     case COL_DEF_SRC:
3401     case COL_RES_SRC:
3402     case COL_UNRES_SRC:
3403     case COL_DEF_DL_SRC:
3404     case COL_RES_DL_SRC:
3405     case COL_UNRES_DL_SRC:
3406     case COL_DEF_NET_SRC:
3407     case COL_RES_NET_SRC:
3408     case COL_UNRES_NET_SRC:
3409       column_len = strlen(cf->cinfo.col_data[i]);
3410       if (column_len < 12)
3411         column_len = 12;
3412       line_bufp = get_line_buf(buf_offset + column_len);
3413       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%12s", cf->cinfo.col_data[i]);
3414       break;
3415
3416     case COL_DEF_DST:
3417     case COL_RES_DST:
3418     case COL_UNRES_DST:
3419     case COL_DEF_DL_DST:
3420     case COL_RES_DL_DST:
3421     case COL_UNRES_DL_DST:
3422     case COL_DEF_NET_DST:
3423     case COL_RES_NET_DST:
3424     case COL_UNRES_NET_DST:
3425       column_len = strlen(cf->cinfo.col_data[i]);
3426       if (column_len < 12)
3427         column_len = 12;
3428       line_bufp = get_line_buf(buf_offset + column_len);
3429       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%-12s", cf->cinfo.col_data[i]);
3430       break;
3431
3432     default:
3433       column_len = strlen(cf->cinfo.col_data[i]);
3434       line_bufp = get_line_buf(buf_offset + column_len);
3435       g_strlcat(line_bufp + buf_offset, cf->cinfo.col_data[i], column_len + 1);
3436       break;
3437     }
3438     buf_offset += column_len;
3439     if (i != cf->cinfo.num_cols - 1) {
3440       /*
3441        * This isn't the last column, so we need to print a
3442        * separator between this column and the next.
3443        *
3444        * If we printed a network source and are printing a
3445        * network destination of the same type next, separate
3446        * them with " -> "; if we printed a network destination
3447        * and are printing a network source of the same type
3448        * next, separate them with " <- "; otherwise separate them
3449        * with a space.
3450        *
3451        * We add enough space to the buffer for " <- " or " -> ",
3452        * even if we're only adding " ".
3453        */
3454       line_bufp = get_line_buf(buf_offset + 4);
3455       switch (cf->cinfo.col_fmt[i]) {
3456
3457       case COL_DEF_SRC:
3458       case COL_RES_SRC:
3459       case COL_UNRES_SRC:
3460         switch (cf->cinfo.col_fmt[i + 1]) {
3461
3462         case COL_DEF_DST:
3463         case COL_RES_DST:
3464         case COL_UNRES_DST:
3465           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3466           buf_offset += 4;
3467           break;
3468
3469         default:
3470           g_strlcat(line_bufp + buf_offset, " ", 5);
3471           buf_offset += 1;
3472           break;
3473         }
3474         break;
3475
3476       case COL_DEF_DL_SRC:
3477       case COL_RES_DL_SRC:
3478       case COL_UNRES_DL_SRC:
3479         switch (cf->cinfo.col_fmt[i + 1]) {
3480
3481         case COL_DEF_DL_DST:
3482         case COL_RES_DL_DST:
3483         case COL_UNRES_DL_DST:
3484           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3485           buf_offset += 4;
3486           break;
3487
3488         default:
3489           g_strlcat(line_bufp + buf_offset, " ", 5);
3490           buf_offset += 1;
3491           break;
3492         }
3493         break;
3494
3495       case COL_DEF_NET_SRC:
3496       case COL_RES_NET_SRC:
3497       case COL_UNRES_NET_SRC:
3498         switch (cf->cinfo.col_fmt[i + 1]) {
3499
3500         case COL_DEF_NET_DST:
3501         case COL_RES_NET_DST:
3502         case COL_UNRES_NET_DST:
3503           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3504           buf_offset += 4;
3505           break;
3506
3507         default:
3508           g_strlcat(line_bufp + buf_offset, " ", 5);
3509           buf_offset += 1;
3510           break;
3511         }
3512         break;
3513
3514       case COL_DEF_DST:
3515       case COL_RES_DST:
3516       case COL_UNRES_DST:
3517         switch (cf->cinfo.col_fmt[i + 1]) {
3518
3519         case COL_DEF_SRC:
3520         case COL_RES_SRC:
3521         case COL_UNRES_SRC:
3522           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3523           buf_offset += 4;
3524           break;
3525
3526         default:
3527           g_strlcat(line_bufp + buf_offset, " ", 5);
3528           buf_offset += 1;
3529           break;
3530         }
3531         break;
3532
3533       case COL_DEF_DL_DST:
3534       case COL_RES_DL_DST:
3535       case COL_UNRES_DL_DST:
3536         switch (cf->cinfo.col_fmt[i + 1]) {
3537
3538         case COL_DEF_DL_SRC:
3539         case COL_RES_DL_SRC:
3540         case COL_UNRES_DL_SRC:
3541           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3542           buf_offset += 4;
3543           break;
3544
3545         default:
3546           g_strlcat(line_bufp + buf_offset, " ", 5);
3547           buf_offset += 1;
3548           break;
3549         }
3550         break;
3551
3552       case COL_DEF_NET_DST:
3553       case COL_RES_NET_DST:
3554       case COL_UNRES_NET_DST:
3555         switch (cf->cinfo.col_fmt[i + 1]) {
3556
3557         case COL_DEF_NET_SRC:
3558         case COL_RES_NET_SRC:
3559         case COL_UNRES_NET_SRC:
3560           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3561           buf_offset += 4;
3562           break;
3563
3564         default:
3565           g_strlcat(line_bufp + buf_offset, " ", 5);
3566           buf_offset += 1;
3567           break;
3568         }
3569         break;
3570
3571       default:
3572         g_strlcat(line_bufp + buf_offset, " ", 5);
3573         buf_offset += 1;
3574         break;
3575       }
3576     }
3577   }
3578   return print_line(print_stream, 0, line_bufp);
3579 }
3580
3581 static gboolean
3582 print_packet(capture_file *cf, epan_dissect_t *edt)
3583 {
3584   print_args_t print_args;
3585
3586   if (print_summary || output_fields_has_cols(output_fields)) {
3587     /* Just fill in the columns. */
3588     epan_dissect_fill_in_columns(edt, FALSE, TRUE);
3589
3590     if (print_summary) {
3591       /* Now print them. */
3592       switch (output_action) {
3593
3594       case WRITE_TEXT:
3595         if (!print_columns(cf))
3596           return FALSE;
3597         break;
3598
3599       case WRITE_XML:
3600         proto_tree_write_psml(edt, stdout);
3601         return !ferror(stdout);
3602       case WRITE_FIELDS: /*No non-verbose "fields" format */
3603         g_assert_not_reached();
3604         break;
3605       }
3606     }
3607   }
3608   if (print_details) {
3609     /* Print the information in the protocol tree. */
3610     switch (output_action) {
3611
3612     case WRITE_TEXT:
3613       /* Only initialize the fields that are actually used in proto_tree_print.
3614        * This is particularly important for .range, as that's heap memory which
3615        * we would otherwise have to g_free().
3616       print_args.to_file = TRUE;
3617       print_args.format = print_format;
3618       print_args.print_summary = print_summary;
3619       print_args.print_formfeed = FALSE;
3620       packet_range_init(&print_args.range, &cfile);
3621       */
3622       print_args.print_hex = print_hex;
3623       print_args.print_dissections = print_details ? print_dissections_expanded : print_dissections_none;
3624
3625       if (!proto_tree_print(&print_args, edt, print_stream))
3626         return FALSE;
3627       if (!print_hex) {
3628         if (!print_line(print_stream, 0, separator))
3629           return FALSE;
3630       }
3631       break;
3632
3633     case WRITE_XML:
3634       proto_tree_write_pdml(edt, stdout);
3635       printf("\n");
3636       return !ferror(stdout);
3637     case WRITE_FIELDS:
3638       proto_tree_write_fields(output_fields, edt, &cf->cinfo, stdout);
3639       printf("\n");
3640       return !ferror(stdout);
3641     }
3642   }
3643   if (print_hex) {
3644     if (print_summary || print_details) {
3645       if (!print_line(print_stream, 0, ""))
3646         return FALSE;
3647     }
3648     if (!print_hex_data(print_stream, edt))
3649       return FALSE;
3650     if (!print_line(print_stream, 0, separator))
3651       return FALSE;
3652   }
3653   return TRUE;
3654 }
3655
3656 static gboolean
3657 write_finale(void)
3658 {
3659   switch (output_action) {
3660
3661   case WRITE_TEXT:
3662     return print_finale(print_stream);
3663
3664   case WRITE_XML:
3665     if (print_details)
3666       write_pdml_finale(stdout);
3667     else
3668       write_psml_finale(stdout);
3669     return !ferror(stdout);
3670
3671   case WRITE_FIELDS:
3672     write_fields_finale(output_fields, stdout);
3673     return !ferror(stdout);
3674
3675   default:
3676     g_assert_not_reached();
3677     return FALSE;
3678   }
3679 }
3680
3681 cf_status_t
3682 cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
3683 {
3684   wtap  *wth;
3685   gchar *err_info;
3686   char   err_msg[2048+1];
3687
3688   wth = wtap_open_offline(fname, err, &err_info, perform_two_pass_analysis);
3689   if (wth == NULL)
3690     goto fail;
3691
3692   /* The open succeeded.  Fill in the information for this file. */
3693
3694   /* Cleanup all data structures used for dissection. */
3695   cleanup_dissection();
3696   /* Initialize all data structures used for dissection. */
3697   init_dissection();
3698
3699   cf->wth = wth;
3700   cf->f_datalen = 0; /* not used, but set it anyway */
3701
3702   /* Set the file name because we need it to set the follow stream filter.
3703      XXX - is that still true?  We need it for other reasons, though,
3704      in any case. */
3705   cf->filename = g_strdup(fname);
3706
3707   /* Indicate whether it's a permanent or temporary file. */
3708   cf->is_tempfile = is_tempfile;
3709
3710   /* No user changes yet. */
3711   cf->unsaved_changes = FALSE;
3712
3713   cf->cd_t      = wtap_file_type(cf->wth);
3714   cf->count     = 0;
3715   cf->drops_known = FALSE;
3716   cf->drops     = 0;
3717   cf->snap      = wtap_snapshot_length(cf->wth);
3718   if (cf->snap == 0) {
3719     /* Snapshot length not known. */
3720     cf->has_snap = FALSE;
3721     cf->snap = WTAP_MAX_PACKET_SIZE;
3722   } else
3723     cf->has_snap = TRUE;
3724   nstime_set_zero(&cf->elapsed_time);
3725   nstime_set_unset(&first_ts);
3726   prev_dis = NULL;
3727   prev_cap = NULL;
3728
3729   cf->state = FILE_READ_IN_PROGRESS;
3730
3731   wtap_set_cb_new_ipv4(cf->wth, add_ipv4_name);
3732   wtap_set_cb_new_ipv6(cf->wth, (wtap_new_ipv6_callback_t) add_ipv6_name);
3733
3734   return CF_OK;
3735
3736 fail:
3737   g_snprintf(err_msg, sizeof err_msg,
3738              cf_open_error_message(*err, err_info, FALSE, cf->cd_t), fname);
3739   cmdarg_err("%s", err_msg);
3740   return CF_ERROR;
3741 }
3742
3743 static void
3744 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
3745 {
3746   char *save_file_string;
3747
3748   save_file_string = output_file_description(fname);
3749
3750   switch (err) {
3751
3752   case ENOSPC:
3753     cmdarg_err("Not all the packets could be written to the %s because there is "
3754                "no space left on the file system.",
3755                save_file_string);
3756     break;
3757
3758 #ifdef EDQUOT
3759   case EDQUOT:
3760     cmdarg_err("Not all the packets could be written to the %s because you are "
3761                "too close to, or over your disk quota.",
3762                save_file_string);
3763   break;
3764 #endif
3765
3766   case WTAP_ERR_CANT_CLOSE:
3767     cmdarg_err("The %s couldn't be closed for some unknown reason.",
3768                save_file_string);
3769     break;
3770
3771   case WTAP_ERR_SHORT_WRITE:
3772     cmdarg_err("Not all the packets could be written to the %s.",
3773                save_file_string);
3774     break;
3775
3776   default:
3777     if (is_close) {
3778       cmdarg_err("The %s could not be closed: %s.", save_file_string,
3779                  wtap_strerror(err));
3780     } else {
3781       cmdarg_err("An error occurred while writing to the %s: %s.",
3782                  save_file_string, wtap_strerror(err));
3783     }
3784     break;
3785   }
3786   g_free(save_file_string);
3787 }
3788
3789 static void
3790 show_print_file_io_error(int err)
3791 {
3792   switch (err) {
3793
3794   case ENOSPC:
3795     cmdarg_err("Not all the packets could be printed because there is "
3796 "no space left on the file system.");
3797     break;
3798
3799 #ifdef EDQUOT
3800   case EDQUOT:
3801     cmdarg_err("Not all the packets could be printed because you are "
3802 "too close to, or over your disk quota.");
3803   break;
3804 #endif
3805
3806   default:
3807     cmdarg_err("An error occurred while printing packets: %s.",
3808       g_strerror(err));
3809     break;
3810   }
3811 }
3812
3813 static const char *
3814 cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
3815                       int file_type)
3816 {
3817   const char *errmsg;
3818   static char errmsg_errno[1024+1];
3819
3820   if (err < 0) {
3821     /* Wiretap error. */
3822     switch (err) {
3823
3824     case WTAP_ERR_NOT_REGULAR_FILE:
3825       errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
3826       break;
3827
3828     case WTAP_ERR_RANDOM_OPEN_PIPE:
3829       /* Seen only when opening a capture file for reading. */
3830       errmsg = "The file \"%s\" is a pipe or FIFO; TShark can't read pipe or FIFO files in two-pass mode.";
3831       break;
3832
3833     case WTAP_ERR_FILE_UNKNOWN_FORMAT:
3834       /* Seen only when opening a capture file for reading. */
3835       errmsg = "The file \"%s\" isn't a capture file in a format TShark understands.";
3836       break;
3837
3838     case WTAP_ERR_UNSUPPORTED:
3839       /* Seen only when opening a capture file for reading. */
3840       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3841                "The file \"%%s\" isn't a capture file in a format TShark understands.\n"
3842                "(%s)", err_info);
3843       g_free(err_info);
3844       errmsg = errmsg_errno;
3845       break;
3846
3847     case WTAP_ERR_CANT_WRITE_TO_PIPE:
3848       /* Seen only when opening a capture file for writing. */
3849       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3850                  "The file \"%%s\" is a pipe, and \"%s\" capture files can't be "
3851                  "written to a pipe.", wtap_file_type_short_string(file_type));
3852       errmsg = errmsg_errno;
3853       break;
3854
3855     case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
3856       /* Seen only when opening a capture file for writing. */
3857       errmsg = "TShark doesn't support writing capture files in that format.";
3858       break;
3859
3860     case WTAP_ERR_UNSUPPORTED_ENCAP:
3861       if (for_writing) {
3862         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3863                    "TShark can't save this capture as a \"%s\" file.",
3864                    wtap_file_type_short_string(file_type));
3865       } else {
3866         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3867                  "The file \"%%s\" is a capture for a network type that TShark doesn't support.\n"
3868                  "(%s)", err_info);
3869         g_free(err_info);
3870       }
3871       errmsg = errmsg_errno;
3872       break;
3873
3874     case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
3875       if (for_writing) {
3876         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3877                    "TShark can't save this capture as a \"%s\" file.",
3878                    wtap_file_type_short_string(file_type));
3879         errmsg = errmsg_errno;
3880       } else
3881         errmsg = "The file \"%s\" is a capture for a network type that TShark doesn't support.";
3882       break;
3883
3884     case WTAP_ERR_BAD_FILE:
3885       /* Seen only when opening a capture file for reading. */
3886       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3887                "The file \"%%s\" appears to be damaged or corrupt.\n"
3888                "(%s)", err_info);
3889       g_free(err_info);
3890       errmsg = errmsg_errno;
3891       break;
3892
3893     case WTAP_ERR_CANT_OPEN:
3894       if (for_writing)
3895         errmsg = "The file \"%s\" could not be created for some unknown reason.";
3896       else
3897         errmsg = "The file \"%s\" could not be opened for some unknown reason.";
3898       break;
3899
3900     case WTAP_ERR_SHORT_READ:
3901       errmsg = "The file \"%s\" appears to have been cut short"
3902                " in the middle of a packet or other data.";
3903       break;
3904
3905     case WTAP_ERR_SHORT_WRITE:
3906       errmsg = "A full header couldn't be written to the file \"%s\".";
3907       break;
3908
3909     case WTAP_ERR_COMPRESSION_NOT_SUPPORTED:
3910       errmsg = "This file type cannot be written as a compressed file.";
3911       break;
3912
3913     case WTAP_ERR_DECOMPRESS:
3914       /* Seen only when opening a capture file for reading. */
3915       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3916                  "The compressed file \"%%s\" appears to be damaged or corrupt.\n"
3917                  "(%s)", err_info);
3918       g_free(err_info);
3919       errmsg = errmsg_errno;
3920       break;
3921
3922     default:
3923       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3924                  "The file \"%%s\" could not be %s: %s.",
3925                  for_writing ? "created" : "opened",
3926                  wtap_strerror(err));
3927       errmsg = errmsg_errno;
3928       break;
3929     }
3930   } else
3931     errmsg = file_open_error_message(err, for_writing);
3932   return errmsg;
3933 }
3934
3935 /*
3936  * Open/create errors are reported with an console message in TShark.
3937  */
3938 static void
3939 open_failure_message(const char *filename, int err, gboolean for_writing)
3940 {
3941   fprintf(stderr, "tshark: ");
3942   fprintf(stderr, file_open_error_message(err, for_writing), filename);
3943   fprintf(stderr, "\n");
3944 }
3945
3946
3947 /*
3948  * General errors are reported with an console message in TShark.
3949  */
3950 static void
3951 failure_message(const char *msg_format, va_list ap)
3952 {
3953   fprintf(stderr, "tshark: ");
3954   vfprintf(stderr, msg_format, ap);
3955   fprintf(stderr, "\n");
3956 }
3957
3958 /*
3959  * Read errors are reported with an console message in TShark.
3960  */
3961 static void
3962 read_failure_message(const char *filename, int err)
3963 {
3964   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
3965           filename, g_strerror(err));
3966 }
3967
3968 /*
3969  * Write errors are reported with an console message in TShark.
3970  */
3971 static void
3972 write_failure_message(const char *filename, int err)
3973 {
3974   cmdarg_err("An error occurred while writing to the file \"%s\": %s.",
3975           filename, g_strerror(err));
3976 }
3977
3978 /*
3979  * Report an error in command-line arguments.
3980  */
3981 void
3982 cmdarg_err(const char *fmt, ...)
3983 {
3984   va_list ap;
3985
3986   va_start(ap, fmt);
3987   failure_message(fmt, ap);
3988   va_end(ap);
3989 }
3990
3991 /*
3992  * Report additional information for an error in command-line arguments.
3993  */
3994 void
3995 cmdarg_err_cont(const char *fmt, ...)
3996 {
3997   va_list ap;
3998
3999   va_start(ap, fmt);
4000   vfprintf(stderr, fmt, ap);
4001   fprintf(stderr, "\n");
4002   va_end(ap);
4003 }
4004
4005
4006 /*
4007  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
4008  *
4009  * Local variables:
4010  * c-basic-offset: 2
4011  * tab-width: 8
4012  * indent-tabs-mode: nil
4013  * End:
4014  *
4015  * vi: set shiftwidth=2 tabstop=8 expandtab:
4016  * :indentSize=2:tabSize=8:noTabs=true:
4017  */