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