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   {
2342     for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2343       interface_options interface_opts;
2344
2345       interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2346       if (i > 0) {
2347           if (global_capture_opts.ifaces->len > 2) {
2348               g_string_append_printf(str, ",");
2349           }
2350           g_string_append_printf(str, " ");
2351           if (i == global_capture_opts.ifaces->len - 1) {
2352               g_string_append_printf(str, "and ");
2353           }
2354       }
2355       g_string_append_printf(str, "'%s'", interface_opts.descr);
2356     }
2357   } else {
2358     g_string_append_printf(str, "%u interfaces", global_capture_opts.ifaces->len);
2359   }
2360   if (really_quiet == FALSE)
2361     fprintf(stderr, "Capturing on %s\n", str->str);
2362   fflush(stderr);
2363   g_string_free(str, TRUE);
2364
2365   ret = sync_pipe_start(&global_capture_opts, &global_capture_session, NULL);
2366
2367   if (!ret)
2368     return FALSE;
2369
2370   /* the actual capture loop
2371    *
2372    * XXX - glib doesn't seem to provide any event based loop handling.
2373    *
2374    * XXX - for whatever reason,
2375    * calling g_main_loop_new() ends up in 100% cpu load.
2376    *
2377    * But that doesn't matter: in UNIX we can use select() to find an input
2378    * source with something to do.
2379    *
2380    * But that doesn't matter because we're in a CLI (that doesn't need to
2381    * update a GUI or something at the same time) so it's OK if we block
2382    * trying to read from the pipe.
2383    *
2384    * So all the stuff in USE_TSHARK_SELECT could be removed unless I'm
2385    * wrong (but I leave it there in case I am...).
2386    */
2387
2388 #ifdef USE_TSHARK_SELECT
2389   FD_ZERO(&readfds);
2390   FD_SET(pipe_input.source, &readfds);
2391 #endif
2392
2393   loop_running = TRUE;
2394
2395   TRY
2396   {
2397     while (loop_running)
2398     {
2399 #ifdef USE_TSHARK_SELECT
2400       ret = select(pipe_input.source+1, &readfds, NULL, NULL, NULL);
2401
2402       if (ret == -1)
2403       {
2404         perror("select()");
2405         return TRUE;
2406       } else if (ret == 1) {
2407 #endif
2408         /* Call the real handler */
2409         if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
2410           g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
2411           return FALSE;
2412         }
2413 #ifdef USE_TSHARK_SELECT
2414       }
2415 #endif
2416     }
2417   }
2418   CATCH(OutOfMemoryError) {
2419     fprintf(stderr,
2420             "Out Of Memory!\n"
2421             "\n"
2422             "Sorry, but TShark has to terminate now!\n"
2423             "\n"
2424             "Some infos / workarounds can be found at:\n"
2425             "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2426     exit(1);
2427   }
2428   ENDTRY;
2429   return TRUE;
2430 }
2431
2432 /* capture child detected an error */
2433 void
2434 capture_input_error_message(capture_session *cap_session _U_, char *error_msg, char *secondary_error_msg)
2435 {
2436   cmdarg_err("%s", error_msg);
2437   cmdarg_err_cont("%s", secondary_error_msg);
2438 }
2439
2440
2441 /* capture child detected an capture filter related error */
2442 void
2443 capture_input_cfilter_error_message(capture_session *cap_session, guint i, char *error_message)
2444 {
2445   capture_options *capture_opts = cap_session->capture_opts;
2446   dfilter_t         *rfcode = NULL;
2447   interface_options  interface_opts;
2448
2449   g_assert(i < capture_opts->ifaces->len);
2450   interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
2451
2452   if (dfilter_compile(interface_opts.cfilter, &rfcode) && rfcode != NULL) {
2453     cmdarg_err(
2454       "Invalid capture filter \"%s\" for interface %s!\n"
2455       "\n"
2456       "That string looks like a valid display filter; however, it isn't a valid\n"
2457       "capture filter (%s).\n"
2458       "\n"
2459       "Note that display filters and capture filters don't have the same syntax,\n"
2460       "so you can't use most display filter expressions as capture filters.\n"
2461       "\n"
2462       "See the User's Guide for a description of the capture filter syntax.",
2463       interface_opts.cfilter, interface_opts.descr, error_message);
2464     dfilter_free(rfcode);
2465   } else {
2466     cmdarg_err(
2467       "Invalid capture filter \"%s\" for interface %s!\n"
2468       "\n"
2469       "That string isn't a valid capture filter (%s).\n"
2470       "See the User's Guide for a description of the capture filter syntax.",
2471       interface_opts.cfilter, interface_opts.descr, error_message);
2472   }
2473 }
2474
2475
2476 /* capture child tells us we have a new (or the first) capture file */
2477 gboolean
2478 capture_input_new_file(capture_session *cap_session, gchar *new_file)
2479 {
2480   capture_options *capture_opts = cap_session->capture_opts;
2481   gboolean is_tempfile;
2482   int      err;
2483
2484   if (cap_session->state == CAPTURE_PREPARING) {
2485     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!");
2486   }
2487   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
2488
2489   g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
2490
2491   /* free the old filename */
2492   if (capture_opts->save_file != NULL) {
2493
2494     /* we start a new capture file, close the old one (if we had one before) */
2495     if ( ((capture_file *) cap_session->cf)->state != FILE_CLOSED) {
2496       if ( ((capture_file *) cap_session->cf)->wth != NULL) {
2497         wtap_close(((capture_file *) cap_session->cf)->wth);
2498       }
2499       ((capture_file *) cap_session->cf)->state = FILE_CLOSED;
2500     }
2501
2502     g_free(capture_opts->save_file);
2503     is_tempfile = FALSE;
2504   } else {
2505     /* we didn't had a save_file before, must be a tempfile */
2506     is_tempfile = TRUE;
2507   }
2508
2509   /* save the new filename */
2510   capture_opts->save_file = g_strdup(new_file);
2511
2512   /* if we are in real-time mode, open the new file now */
2513   if (do_dissection) {
2514     /* Attempt to open the capture file and set up to read from it. */
2515     switch(cf_open((capture_file *)cap_session->cf, capture_opts->save_file, is_tempfile, &err)) {
2516     case CF_OK:
2517       break;
2518     case CF_ERROR:
2519       /* Don't unlink (delete) the save file - leave it around,
2520          for debugging purposes. */
2521       g_free(capture_opts->save_file);
2522       capture_opts->save_file = NULL;
2523       return FALSE;
2524     }
2525   }
2526
2527   cap_session->state = CAPTURE_RUNNING;
2528
2529   return TRUE;
2530 }
2531
2532
2533 /* capture child tells us we have new packets to read */
2534 void
2535 capture_input_new_packets(capture_session *cap_session, int to_read)
2536 {
2537   gboolean      ret;
2538   int           err;
2539   gchar        *err_info;
2540   gint64        data_offset;
2541   capture_file *cf = (capture_file *)cap_session->cf;
2542   gboolean      filtering_tap_listeners;
2543   guint         tap_flags;
2544
2545 #ifdef SIGINFO
2546   /*
2547    * Prevent a SIGINFO handler from writing to the standard error while
2548    * we're doing so or writing to the standard output; instead, have it
2549    * just set a flag telling us to print that information when we're done.
2550    */
2551   infodelay = TRUE;
2552 #endif /* SIGINFO */
2553
2554   /* Do we have any tap listeners with filters? */
2555   filtering_tap_listeners = have_filtering_tap_listeners();
2556
2557   /* Get the union of the flags for all tap listeners. */
2558   tap_flags = union_of_tap_listener_flags();
2559
2560   if (do_dissection) {
2561     while (to_read-- && cf->wth) {
2562       wtap_cleareof(cf->wth);
2563       ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
2564       if (ret == FALSE) {
2565         /* read from file failed, tell the capture child to stop */
2566         sync_pipe_stop(cap_session);
2567         wtap_close(cf->wth);
2568         cf->wth = NULL;
2569       } else {
2570         ret = process_packet(cf, data_offset, wtap_phdr(cf->wth),
2571                              wtap_buf_ptr(cf->wth),
2572                              filtering_tap_listeners, tap_flags);
2573       }
2574       if (ret != FALSE) {
2575         /* packet successfully read and gone through the "Read Filter" */
2576         packet_count++;
2577       }
2578     }
2579   } else {
2580     /*
2581      * Dumpcap's doing all the work; we're not doing any dissection.
2582      * Count all the packets it wrote.
2583      */
2584     packet_count += to_read;
2585   }
2586
2587   if (print_packet_counts) {
2588       /* We're printing packet counts. */
2589       if (packet_count != 0) {
2590         fprintf(stderr, "\r%u ", packet_count);
2591         /* stderr could be line buffered */
2592         fflush(stderr);
2593       }
2594   }
2595
2596 #ifdef SIGINFO
2597   /*
2598    * Allow SIGINFO handlers to write.
2599    */
2600   infodelay = FALSE;
2601
2602   /*
2603    * If a SIGINFO handler asked us to write out capture counts, do so.
2604    */
2605   if (infoprint)
2606     report_counts();
2607 #endif /* SIGINFO */
2608 }
2609
2610 static void
2611 report_counts(void)
2612 {
2613   if ((print_packet_counts == FALSE) && (really_quiet == FALSE)) {
2614     /* Report the count only if we aren't printing a packet count
2615        as packets arrive. */
2616       fprintf(stderr, "%u packet%s captured\n", packet_count,
2617             plurality(packet_count, "", "s"));
2618   }
2619 #ifdef SIGINFO
2620   infoprint = FALSE; /* we just reported it */
2621 #endif /* SIGINFO */
2622 }
2623
2624 #ifdef SIGINFO
2625 static void
2626 report_counts_siginfo(int signum _U_)
2627 {
2628   int sav_errno = errno;
2629   /* If we've been told to delay printing, just set a flag asking
2630      that we print counts (if we're supposed to), otherwise print
2631      the count of packets captured (if we're supposed to). */
2632   if (infodelay)
2633     infoprint = TRUE;
2634   else
2635     report_counts();
2636   errno = sav_errno;
2637 }
2638 #endif /* SIGINFO */
2639
2640
2641 /* capture child detected any packet drops? */
2642 void
2643 capture_input_drops(capture_session *cap_session _U_, guint32 dropped)
2644 {
2645   if (print_packet_counts) {
2646     /* We're printing packet counts to stderr.
2647        Send a newline so that we move to the line after the packet count. */
2648     fprintf(stderr, "\n");
2649   }
2650
2651   if (dropped != 0) {
2652     /* We're printing packet counts to stderr.
2653        Send a newline so that we move to the line after the packet count. */
2654     fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2655   }
2656 }
2657
2658
2659 /*
2660  * Capture child closed its side of the pipe, report any error and
2661  * do the required cleanup.
2662  */
2663 void
2664 capture_input_closed(capture_session *cap_session, gchar *msg)
2665 {
2666   capture_file *cf = (capture_file *) cap_session->cf;
2667
2668   if (msg != NULL)
2669     fprintf(stderr, "tshark: %s\n", msg);
2670
2671   report_counts();
2672
2673   if (cf != NULL && cf->wth != NULL) {
2674     wtap_close(cf->wth);
2675     if (cf->is_tempfile) {
2676       ws_unlink(cf->filename);
2677     }
2678   }
2679 #ifdef USE_BROKEN_G_MAIN_LOOP
2680   /*g_main_loop_quit(loop);*/
2681   g_main_quit(loop);
2682 #else
2683   loop_running = FALSE;
2684 #endif
2685 }
2686
2687
2688
2689
2690 #ifdef _WIN32
2691 static BOOL WINAPI
2692 capture_cleanup(DWORD ctrltype _U_)
2693 {
2694   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2695      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2696      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2697      like SIGTERM at least when the machine's shutting down.
2698
2699      For now, we handle them all as indications that we should clean up
2700      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2701      way on UNIX.
2702
2703      We must return TRUE so that no other handler - such as one that would
2704      terminate the process - gets called.
2705
2706      XXX - for some reason, typing ^C to TShark, if you run this in
2707      a Cygwin console window in at least some versions of Cygwin,
2708      causes TShark to terminate immediately; this routine gets
2709      called, but the main loop doesn't get a chance to run and
2710      exit cleanly, at least if this is compiled with Microsoft Visual
2711      C++ (i.e., it's a property of the Cygwin console window or Bash;
2712      it happens if TShark is not built with Cygwin - for all I know,
2713      building it with Cygwin may make the problem go away). */
2714
2715   /* tell the capture child to stop */
2716   sync_pipe_stop(&global_capture_session);
2717
2718   /* don't stop our own loop already here, otherwise status messages and
2719    * cleanup wouldn't be done properly. The child will indicate the stop of
2720    * everything by calling capture_input_closed() later */
2721
2722   return TRUE;
2723 }
2724 #else
2725 static void
2726 capture_cleanup(int signum _U_)
2727 {
2728   /* tell the capture child to stop */
2729   sync_pipe_stop(&global_capture_session);
2730
2731   /* don't stop our own loop already here, otherwise status messages and
2732    * cleanup wouldn't be done properly. The child will indicate the stop of
2733    * everything by calling capture_input_closed() later */
2734 }
2735 #endif /* _WIN32 */
2736 #endif /* HAVE_LIBPCAP */
2737
2738 static gboolean
2739 process_packet_first_pass(capture_file *cf,
2740                gint64 offset, struct wtap_pkthdr *whdr,
2741                const guchar *pd)
2742 {
2743   frame_data     fdlocal;
2744   guint32        framenum;
2745   gboolean       create_proto_tree = FALSE;
2746   epan_dissect_t edt;
2747   gboolean       passed;
2748
2749   /* The frame number of this packet is one more than the count of
2750      frames in this packet. */
2751   framenum = cf->count + 1;
2752
2753   /* If we're not running a display filter and we're not printing any
2754      packet information, we don't need to do a dissection. This means
2755      that all packets can be marked as 'passed'. */
2756   passed = TRUE;
2757
2758   frame_data_init(&fdlocal, framenum, whdr, offset, cum_bytes);
2759
2760   /* If we're going to print packet information, or we're going to
2761      run a read filter, or display filter, or we're going to process taps, set up to
2762      do a dissection and do so. */
2763   if (do_dissection) {
2764     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2765         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2766       /* Grab any resolved addresses */
2767       host_name_lookup_process();
2768
2769     /* If we're going to be applying a filter, we'll need to
2770        create a protocol tree against which to apply the filter. */
2771     if (cf->rfcode)
2772       create_proto_tree = TRUE;
2773
2774     /* We're not going to display the protocol tree on this pass,
2775        so it's not going to be "visible". */
2776     epan_dissect_init(&edt, cf->epan, create_proto_tree, FALSE);
2777
2778     /* If we're running a read filter, prime the epan_dissect_t with that
2779        filter. */
2780     if (cf->rfcode)
2781       epan_dissect_prime_dfilter(&edt, cf->rfcode);
2782
2783     frame_data_set_before_dissect(&fdlocal, &cf->elapsed_time,
2784                                   &ref, prev_dis);
2785     if (ref == &fdlocal) {
2786       ref_frame = fdlocal;
2787       ref = &ref_frame;
2788     }
2789
2790     epan_dissect_run(&edt, whdr, frame_tvbuff_new(&fdlocal, pd), &fdlocal, NULL);
2791
2792     /* Run the read filter if we have one. */
2793     if (cf->rfcode)
2794       passed = dfilter_apply_edt(cf->rfcode, &edt);
2795   }
2796
2797   if (passed) {
2798     frame_data_set_after_dissect(&fdlocal, &cum_bytes);
2799     prev_cap = prev_dis = frame_data_sequence_add(cf->frames, &fdlocal);
2800
2801     /* If we're not doing dissection then there won't be any dependent frames.
2802      * More importantly, edt.pi.dependent_frames won't be initialized because
2803      * epan hasn't been initialized.
2804      */
2805     if (do_dissection) {
2806       g_slist_foreach(edt.pi.dependent_frames, find_and_mark_frame_depended_upon, cf->frames);
2807     }
2808
2809     cf->count++;
2810   } else {
2811     /* if we don't add it to the frame_data_sequence, clean it up right now
2812      * to avoid leaks */
2813     frame_data_destroy(&fdlocal);
2814   }
2815
2816   if (do_dissection)
2817     epan_dissect_cleanup(&edt);
2818
2819   return passed;
2820 }
2821
2822 static gboolean
2823 process_packet_second_pass(capture_file *cf, frame_data *fdata,
2824                struct wtap_pkthdr *phdr, Buffer *buf,
2825                gboolean filtering_tap_listeners, guint tap_flags)
2826 {
2827   gboolean        create_proto_tree;
2828   column_info    *cinfo;
2829   epan_dissect_t  edt;
2830   gboolean        passed;
2831
2832   /* If we're not running a display filter and we're not printing any
2833      packet information, we don't need to do a dissection. This means
2834      that all packets can be marked as 'passed'. */
2835   passed = TRUE;
2836
2837   /* If we're going to print packet information, or we're going to
2838      run a read filter, or we're going to process taps, set up to
2839      do a dissection and do so. */
2840   if (do_dissection) {
2841     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2842         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2843       /* Grab any resolved addresses */
2844       host_name_lookup_process();
2845
2846     if (cf->dfcode || print_details || filtering_tap_listeners ||
2847         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
2848       create_proto_tree = TRUE;
2849     else
2850       create_proto_tree = FALSE;
2851
2852     /* The protocol tree will be "visible", i.e., printed, only if we're
2853        printing packet details, which is true if we're printing stuff
2854        ("print_packet_info" is true) and we're in verbose mode
2855        ("packet_details" is true). */
2856     epan_dissect_init(&edt, cf->epan, create_proto_tree, print_packet_info && print_details);
2857
2858     /* If we're running a display filter, prime the epan_dissect_t with that
2859        filter. */
2860     if (cf->dfcode)
2861       epan_dissect_prime_dfilter(&edt, cf->dfcode);
2862
2863     col_custom_prime_edt(&edt, &cf->cinfo);
2864
2865     /* We only need the columns if either
2866          1) some tap needs the columns
2867        or
2868          2) we're printing packet info but we're *not* verbose; in verbose
2869             mode, we print the protocol tree, not the protocol summary.
2870      */
2871     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary))
2872       cinfo = &cf->cinfo;
2873     else
2874       cinfo = NULL;
2875
2876     frame_data_set_before_dissect(fdata, &cf->elapsed_time,
2877                                   &ref, prev_dis);
2878     if (ref == fdata) {
2879       ref_frame = *fdata;
2880       ref = &ref_frame;
2881     }
2882
2883     epan_dissect_run_with_taps(&edt, phdr, frame_tvbuff_new_buffer(fdata, buf), fdata, cinfo);
2884
2885     /* Run the read/display filter if we have one. */
2886     if (cf->dfcode)
2887       passed = dfilter_apply_edt(cf->dfcode, &edt);
2888   }
2889
2890   if (passed) {
2891     frame_data_set_after_dissect(fdata, &cum_bytes);
2892     /* Process this packet. */
2893     if (print_packet_info) {
2894       /* We're printing packet information; print the information for
2895          this packet. */
2896       if (do_dissection)
2897         print_packet(cf, &edt);
2898       else
2899         print_packet(cf, NULL);
2900
2901       /* The ANSI C standard does not appear to *require* that a line-buffered
2902          stream be flushed to the host environment whenever a newline is
2903          written, it just says that, on such a stream, characters "are
2904          intended to be transmitted to or from the host environment as a
2905          block when a new-line character is encountered".
2906
2907          The Visual C++ 6.0 C implementation doesn't do what is intended;
2908          even if you set a stream to be line-buffered, it still doesn't
2909          flush the buffer at the end of every line.
2910
2911          So, if the "-l" flag was specified, we flush the standard output
2912          at the end of a packet.  This will do the right thing if we're
2913          printing packet summary lines, and, as we print the entire protocol
2914          tree for a single packet without waiting for anything to happen,
2915          it should be as good as line-buffered mode if we're printing
2916          protocol trees.  (The whole reason for the "-l" flag in either
2917          tcpdump or TShark is to allow the output of a live capture to
2918          be piped to a program or script and to have that script see the
2919          information for the packet as soon as it's printed, rather than
2920          having to wait until a standard I/O buffer fills up. */
2921       if (line_buffered)
2922         fflush(stdout);
2923
2924       if (ferror(stdout)) {
2925         show_print_file_io_error(errno);
2926         exit(2);
2927       }
2928     }
2929     prev_dis = fdata;
2930   }
2931   prev_cap = fdata;
2932
2933   if (do_dissection) {
2934     epan_dissect_cleanup(&edt);
2935   }
2936   return passed || fdata->flags.dependent_of_displayed;
2937 }
2938
2939 static int
2940 load_cap_file(capture_file *cf, char *save_file, int out_file_type,
2941     gboolean out_file_name_res, int max_packet_count, gint64 max_byte_count)
2942 {
2943   gint         linktype;
2944   int          snapshot_length;
2945   wtap_dumper *pdh;
2946   guint32      framenum;
2947   int          err;
2948   gchar       *err_info = NULL;
2949   gint64       data_offset;
2950   char        *save_file_string = NULL;
2951   gboolean     filtering_tap_listeners;
2952   guint        tap_flags;
2953   wtapng_section_t            *shb_hdr;
2954   wtapng_iface_descriptions_t *idb_inf;
2955   char         appname[100];
2956   Buffer       buf;
2957
2958   shb_hdr = wtap_file_get_shb_info(cf->wth);
2959   idb_inf = wtap_file_get_idb_info(cf->wth);
2960 #ifdef PCAP_NG_DEFAULT
2961   if (idb_inf->number_of_interfaces > 1) {
2962     linktype = WTAP_ENCAP_PER_PACKET;
2963   } else {
2964     linktype = wtap_file_encap(cf->wth);
2965   }
2966 #else
2967   linktype = wtap_file_encap(cf->wth);
2968 #endif
2969   if (save_file != NULL) {
2970     /* Get a string that describes what we're writing to */
2971     save_file_string = output_file_description(save_file);
2972
2973     /* Set up to write to the capture file. */
2974     snapshot_length = wtap_snapshot_length(cf->wth);
2975     if (snapshot_length == 0) {
2976       /* Snapshot length of input file not known. */
2977       snapshot_length = WTAP_MAX_PACKET_SIZE;
2978     }
2979     /* If we don't have an application name add Tshark */
2980     if (shb_hdr->shb_user_appl == NULL) {
2981         g_snprintf(appname, sizeof(appname), "TShark " VERSION "%s", wireshark_svnversion);
2982         shb_hdr->shb_user_appl = appname;
2983     }
2984
2985     if (linktype != WTAP_ENCAP_PER_PACKET && out_file_type == WTAP_FILE_PCAP)
2986         pdh = wtap_dump_open(save_file, out_file_type, linktype,
2987             snapshot_length, FALSE /* compressed */, &err);
2988     else
2989         pdh = wtap_dump_open_ng(save_file, out_file_type, linktype,
2990             snapshot_length, FALSE /* compressed */, shb_hdr, idb_inf, &err);
2991
2992     g_free(idb_inf);
2993     idb_inf = NULL;
2994
2995     if (pdh == NULL) {
2996       /* We couldn't set up to write to the capture file. */
2997       switch (err) {
2998
2999       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
3000         cmdarg_err("Capture files can't be written in that format.");
3001         break;
3002
3003       case WTAP_ERR_UNSUPPORTED_ENCAP:
3004       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
3005         cmdarg_err("The capture file being read can't be written as a "
3006           "\"%s\" file.", wtap_file_type_short_string(out_file_type));
3007         break;
3008
3009       case WTAP_ERR_CANT_OPEN:
3010         cmdarg_err("The %s couldn't be created for some "
3011           "unknown reason.", save_file_string);
3012         break;
3013
3014       case WTAP_ERR_SHORT_WRITE:
3015         cmdarg_err("A full header couldn't be written to the %s.",
3016                    save_file_string);
3017         break;
3018
3019       default:
3020         cmdarg_err("The %s could not be created: %s.", save_file_string,
3021                    wtap_strerror(err));
3022         break;
3023       }
3024       goto out;
3025     }
3026   } else {
3027     if (print_packet_info) {
3028       if (!write_preamble(cf)) {
3029         err = errno;
3030         show_print_file_io_error(err);
3031         goto out;
3032       }
3033     }
3034     pdh = NULL;
3035   }
3036
3037   if (pdh && out_file_name_res) {
3038     if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
3039       cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
3040                  wtap_file_type_short_string(out_file_type));
3041     }
3042   }
3043
3044   /* Do we have any tap listeners with filters? */
3045   filtering_tap_listeners = have_filtering_tap_listeners();
3046
3047   /* Get the union of the flags for all tap listeners. */
3048   tap_flags = union_of_tap_listener_flags();
3049
3050   if (perform_two_pass_analysis) {
3051     frame_data *fdata;
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     prev_dis = NULL;
3079     prev_cap = NULL;
3080     buffer_init(&buf, 1500);
3081     for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
3082       fdata = frame_data_sequence_find(cf->frames, framenum);
3083       if (wtap_seek_read(cf->wth, fdata->file_off, &cf->phdr,
3084           &buf, fdata->cap_len, &err, &err_info)) {
3085         if (process_packet_second_pass(cf, fdata, &cf->phdr, &buf,
3086                                        filtering_tap_listeners, tap_flags)) {
3087           /* Either there's no read filtering or this packet passed the
3088              filter, so, if we're writing to a capture file, write
3089              this packet out. */
3090           if (pdh != NULL) {
3091             if (!wtap_dump(pdh, &cf->phdr, buffer_start_ptr(&cf->buf), &err)) {
3092               /* Error writing to a capture file */
3093               switch (err) {
3094
3095               case WTAP_ERR_UNSUPPORTED_ENCAP:
3096                 /*
3097                  * This is a problem with the particular frame we're writing;
3098                  * note that, and give the frame number.
3099                  *
3100                  * XXX - framenum is not necessarily the frame number in
3101                  * the input file if there was a read filter.
3102                  */
3103                 fprintf(stderr,
3104                         "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
3105                         framenum, cf->filename,
3106                         wtap_file_type_short_string(out_file_type));
3107                 break;
3108
3109               default:
3110                 show_capture_file_io_error(save_file, err, FALSE);
3111                 break;
3112               }
3113               wtap_dump_close(pdh, &err);
3114               g_free(shb_hdr);
3115               exit(2);
3116             }
3117           }
3118         }
3119       }
3120     }
3121     buffer_free(&buf);
3122   }
3123   else {
3124     framenum = 0;
3125     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
3126       framenum++;
3127
3128       if (process_packet(cf, data_offset, wtap_phdr(cf->wth),
3129                          wtap_buf_ptr(cf->wth),
3130                          filtering_tap_listeners, tap_flags)) {
3131         /* Either there's no read filtering or this packet passed the
3132            filter, so, if we're writing to a capture file, write
3133            this packet out. */
3134         if (pdh != NULL) {
3135           if (!wtap_dump(pdh, wtap_phdr(cf->wth), wtap_buf_ptr(cf->wth), &err)) {
3136             /* Error writing to a capture file */
3137             switch (err) {
3138
3139             case WTAP_ERR_UNSUPPORTED_ENCAP:
3140               /*
3141                * This is a problem with the particular frame we're writing;
3142                * note that, and give the frame number.
3143                */
3144               fprintf(stderr,
3145                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
3146                       framenum, cf->filename,
3147                       wtap_file_type_short_string(out_file_type));
3148               break;
3149
3150             default:
3151               show_capture_file_io_error(save_file, err, FALSE);
3152               break;
3153             }
3154             wtap_dump_close(pdh, &err);
3155             g_free(shb_hdr);
3156             exit(2);
3157           }
3158         }
3159         /* Stop reading if we have the maximum number of packets;
3160          * When the -c option has not been used, max_packet_count
3161          * starts at 0, which practically means, never stop reading.
3162          * (unless we roll over max_packet_count ?)
3163          */
3164         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3165           err = 0; /* This is not an error */
3166           break;
3167         }
3168       }
3169     }
3170   }
3171
3172   if (err != 0) {
3173     /*
3174      * Print a message noting that the read failed somewhere along the line.
3175      *
3176      * If we're printing packet data, and the standard output and error are
3177      * going to the same place, flush the standard output, so everything
3178      * buffered up is written, and then print a newline to the standard error
3179      * before printing the error message, to separate it from the packet
3180      * data.  (Alas, that only works on UN*X; st_dev is meaningless, and
3181      * the _fstat() documentation at Microsoft doesn't indicate whether
3182      * st_ino is even supported.)
3183      */
3184 #ifndef _WIN32
3185     if (print_packet_info) {
3186       struct stat stat_stdout, stat_stderr;
3187
3188       if (fstat(1, &stat_stdout) == 0 && fstat(2, &stat_stderr) == 0) {
3189         if (stat_stdout.st_dev == stat_stderr.st_dev &&
3190             stat_stdout.st_ino == stat_stderr.st_ino) {
3191           fflush(stdout);
3192           fprintf(stderr, "\n");
3193         }
3194       }
3195     }
3196 #endif
3197     switch (err) {
3198
3199     case WTAP_ERR_UNSUPPORTED:
3200       cmdarg_err("The file \"%s\" contains record data that TShark doesn't support.\n(%s)",
3201                  cf->filename, err_info);
3202       g_free(err_info);
3203       break;
3204
3205     case WTAP_ERR_UNSUPPORTED_ENCAP:
3206       cmdarg_err("The file \"%s\" has a packet with a network type that TShark doesn't support.\n(%s)",
3207                  cf->filename, err_info);
3208       g_free(err_info);
3209       break;
3210
3211     case WTAP_ERR_CANT_READ:
3212       cmdarg_err("An attempt to read from the file \"%s\" failed for some unknown reason.",
3213                  cf->filename);
3214       break;
3215
3216     case WTAP_ERR_SHORT_READ:
3217       cmdarg_err("The file \"%s\" appears to have been cut short in the middle of a packet.",
3218                  cf->filename);
3219       break;
3220
3221     case WTAP_ERR_BAD_FILE:
3222       cmdarg_err("The file \"%s\" appears to be damaged or corrupt.\n(%s)",
3223                  cf->filename, err_info);
3224       g_free(err_info);
3225       break;
3226
3227     case WTAP_ERR_DECOMPRESS:
3228       cmdarg_err("The compressed file \"%s\" appears to be damaged or corrupt.\n"
3229                  "(%s)", cf->filename, err_info);
3230       break;
3231
3232     default:
3233       cmdarg_err("An error occurred while reading the file \"%s\": %s.",
3234                  cf->filename, wtap_strerror(err));
3235       break;
3236     }
3237     if (save_file != NULL) {
3238       /* Now close the capture file. */
3239       if (!wtap_dump_close(pdh, &err))
3240         show_capture_file_io_error(save_file, err, TRUE);
3241     }
3242   } else {
3243     if (save_file != NULL) {
3244       /* Now close the capture file. */
3245       if (!wtap_dump_close(pdh, &err))
3246         show_capture_file_io_error(save_file, err, TRUE);
3247     } else {
3248       if (print_packet_info) {
3249         if (!write_finale()) {
3250           err = errno;
3251           show_print_file_io_error(err);
3252         }
3253       }
3254     }
3255   }
3256
3257 out:
3258   wtap_close(cf->wth);
3259   cf->wth = NULL;
3260
3261   g_free(save_file_string);
3262   g_free(shb_hdr);
3263
3264   return err;
3265 }
3266
3267 static gboolean
3268 process_packet(capture_file *cf, gint64 offset, struct wtap_pkthdr *whdr,
3269                const guchar *pd,
3270                gboolean filtering_tap_listeners, guint tap_flags)
3271 {
3272   frame_data      fdata;
3273   gboolean        create_proto_tree;
3274   column_info    *cinfo;
3275   epan_dissect_t  edt;
3276   gboolean        passed;
3277
3278   /* Count this packet. */
3279   cf->count++;
3280
3281   /* If we're not running a display filter and we're not printing any
3282      packet information, we don't need to do a dissection. This means
3283      that all packets can be marked as 'passed'. */
3284   passed = TRUE;
3285
3286   frame_data_init(&fdata, cf->count, whdr, offset, cum_bytes);
3287
3288   /* If we're going to print packet information, or we're going to
3289      run a read filter, or we're going to process taps, set up to
3290      do a dissection and do so. */
3291   if (do_dissection) {
3292     if (print_packet_info && (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
3293         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns))
3294       /* Grab any resolved addresses */
3295       host_name_lookup_process();
3296
3297     if (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
3298         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
3299       create_proto_tree = TRUE;
3300     else
3301       create_proto_tree = FALSE;
3302
3303     /* The protocol tree will be "visible", i.e., printed, only if we're
3304        printing packet details, which is true if we're printing stuff
3305        ("print_packet_info" is true) and we're in verbose mode
3306        ("packet_details" is true). */
3307     epan_dissect_init(&edt, cf->epan, create_proto_tree, print_packet_info && print_details);
3308
3309     /* If we're running a filter, prime the epan_dissect_t with that
3310        filter. */
3311     if (cf->rfcode)
3312       epan_dissect_prime_dfilter(&edt, cf->rfcode);
3313     if (cf->dfcode)
3314       epan_dissect_prime_dfilter(&edt, cf->dfcode);
3315
3316     col_custom_prime_edt(&edt, &cf->cinfo);
3317
3318     /* We only need the columns if either
3319          1) some tap needs the columns
3320        or
3321          2) we're printing packet info but we're *not* verbose; in verbose
3322             mode, we print the protocol tree, not the protocol summary.
3323        or
3324          3) there is a column mapped as an individual field */
3325     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
3326       cinfo = &cf->cinfo;
3327     else
3328       cinfo = NULL;
3329
3330     frame_data_set_before_dissect(&fdata, &cf->elapsed_time,
3331                                   &ref, prev_dis);
3332     if (ref == &fdata) {
3333       ref_frame = fdata;
3334       ref = &ref_frame;
3335     }
3336
3337     epan_dissect_run_with_taps(&edt, whdr, frame_tvbuff_new(&fdata, pd), &fdata, cinfo);
3338
3339     /* Run the filters if we have them. */
3340     if (cf->rfcode)
3341       passed = dfilter_apply_edt(cf->rfcode, &edt);
3342     if (passed && cf->dfcode)
3343       passed = dfilter_apply_edt(cf->dfcode, &edt);
3344   }
3345
3346   if (passed) {
3347     frame_data_set_after_dissect(&fdata, &cum_bytes);
3348
3349     /* Process this packet. */
3350     if (print_packet_info) {
3351       /* We're printing packet information; print the information for
3352          this packet. */
3353       if (do_dissection)
3354         print_packet(cf, &edt);
3355       else
3356         print_packet(cf, NULL);
3357
3358       /* The ANSI C standard does not appear to *require* that a line-buffered
3359          stream be flushed to the host environment whenever a newline is
3360          written, it just says that, on such a stream, characters "are
3361          intended to be transmitted to or from the host environment as a
3362          block when a new-line character is encountered".
3363
3364          The Visual C++ 6.0 C implementation doesn't do what is intended;
3365          even if you set a stream to be line-buffered, it still doesn't
3366          flush the buffer at the end of every line.
3367
3368          So, if the "-l" flag was specified, we flush the standard output
3369          at the end of a packet.  This will do the right thing if we're
3370          printing packet summary lines, and, as we print the entire protocol
3371          tree for a single packet without waiting for anything to happen,
3372          it should be as good as line-buffered mode if we're printing
3373          protocol trees.  (The whole reason for the "-l" flag in either
3374          tcpdump or TShark is to allow the output of a live capture to
3375          be piped to a program or script and to have that script see the
3376          information for the packet as soon as it's printed, rather than
3377          having to wait until a standard I/O buffer fills up. */
3378       if (line_buffered)
3379         fflush(stdout);
3380
3381       if (ferror(stdout)) {
3382         show_print_file_io_error(errno);
3383         exit(2);
3384       }
3385     }
3386
3387     /* this must be set after print_packet() [bug #8160] */
3388     prev_dis_frame = fdata;
3389     prev_dis = &prev_dis_frame;
3390   }
3391
3392   prev_cap_frame = fdata;
3393   prev_cap = &prev_cap_frame;
3394
3395   if (do_dissection) {
3396     epan_dissect_cleanup(&edt);
3397     frame_data_destroy(&fdata);
3398   }
3399   return passed;
3400 }
3401
3402 static gboolean
3403 write_preamble(capture_file *cf)
3404 {
3405   switch (output_action) {
3406
3407   case WRITE_TEXT:
3408     return print_preamble(print_stream, cf ? cf->filename : NULL, wireshark_svnversion);
3409
3410   case WRITE_XML:
3411     if (print_details)
3412       write_pdml_preamble(stdout, cf ? cf->filename : NULL);
3413     else
3414       write_psml_preamble(stdout);
3415     return !ferror(stdout);
3416
3417   case WRITE_FIELDS:
3418     write_fields_preamble(output_fields, stdout);
3419     return !ferror(stdout);
3420
3421   default:
3422     g_assert_not_reached();
3423     return FALSE;
3424   }
3425 }
3426
3427 static char *
3428 get_line_buf(size_t len)
3429 {
3430   static char   *line_bufp    = NULL;
3431   static size_t  line_buf_len = 256;
3432   size_t         new_line_buf_len;
3433
3434   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
3435        new_line_buf_len *= 2)
3436     ;
3437   if (line_bufp == NULL) {
3438     line_buf_len = new_line_buf_len;
3439     line_bufp = (char *)g_malloc(line_buf_len + 1);
3440   } else {
3441     if (new_line_buf_len > line_buf_len) {
3442       line_buf_len = new_line_buf_len;
3443       line_bufp = (char *)g_realloc(line_bufp, line_buf_len + 1);
3444     }
3445   }
3446   return line_bufp;
3447 }
3448
3449 static gboolean
3450 print_columns(capture_file *cf)
3451 {
3452   char   *line_bufp;
3453   int     i;
3454   size_t  buf_offset;
3455   size_t  column_len;
3456
3457   line_bufp = get_line_buf(256);
3458   buf_offset = 0;
3459   *line_bufp = '\0';
3460   for (i = 0; i < cf->cinfo.num_cols; i++) {
3461     /* Skip columns not marked as visible. */
3462     if (!get_column_visible(i))
3463       continue;
3464     switch (cf->cinfo.col_fmt[i]) {
3465     case COL_NUMBER:
3466 #ifdef HAVE_LIBPCAP
3467       /*
3468        * Don't print this if we're doing a live capture from a network
3469        * interface - if we're doing a live capture, you won't be
3470        * able to look at the capture in the future (it's not being
3471        * saved anywhere), so the frame numbers are unlikely to be
3472        * useful.
3473        *
3474        * (XXX - it might be nice to be able to save and print at
3475        * the same time, sort of like an "Update list of packets
3476        * in real time" capture in Wireshark.)
3477        */
3478       if (global_capture_opts.ifaces->len > 0)
3479         continue;
3480 #endif
3481       column_len = strlen(cf->cinfo.col_data[i]);
3482       if (column_len < 3)
3483         column_len = 3;
3484       line_bufp = get_line_buf(buf_offset + column_len);
3485       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%3s", cf->cinfo.col_data[i]);
3486       break;
3487
3488     case COL_CLS_TIME:
3489     case COL_REL_TIME:
3490     case COL_ABS_TIME:
3491     case COL_ABS_DATE_TIME:
3492     case COL_UTC_TIME:
3493     case COL_UTC_DATE_TIME: /* XXX - wider */
3494       column_len = strlen(cf->cinfo.col_data[i]);
3495       if (column_len < 10)
3496         column_len = 10;
3497       line_bufp = get_line_buf(buf_offset + column_len);
3498       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%10s", cf->cinfo.col_data[i]);
3499       break;
3500
3501     case COL_DEF_SRC:
3502     case COL_RES_SRC:
3503     case COL_UNRES_SRC:
3504     case COL_DEF_DL_SRC:
3505     case COL_RES_DL_SRC:
3506     case COL_UNRES_DL_SRC:
3507     case COL_DEF_NET_SRC:
3508     case COL_RES_NET_SRC:
3509     case COL_UNRES_NET_SRC:
3510       column_len = strlen(cf->cinfo.col_data[i]);
3511       if (column_len < 12)
3512         column_len = 12;
3513       line_bufp = get_line_buf(buf_offset + column_len);
3514       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%12s", cf->cinfo.col_data[i]);
3515       break;
3516
3517     case COL_DEF_DST:
3518     case COL_RES_DST:
3519     case COL_UNRES_DST:
3520     case COL_DEF_DL_DST:
3521     case COL_RES_DL_DST:
3522     case COL_UNRES_DL_DST:
3523     case COL_DEF_NET_DST:
3524     case COL_RES_NET_DST:
3525     case COL_UNRES_NET_DST:
3526       column_len = strlen(cf->cinfo.col_data[i]);
3527       if (column_len < 12)
3528         column_len = 12;
3529       line_bufp = get_line_buf(buf_offset + column_len);
3530       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%-12s", cf->cinfo.col_data[i]);
3531       break;
3532
3533     default:
3534       column_len = strlen(cf->cinfo.col_data[i]);
3535       line_bufp = get_line_buf(buf_offset + column_len);
3536       g_strlcat(line_bufp + buf_offset, cf->cinfo.col_data[i], column_len + 1);
3537       break;
3538     }
3539     buf_offset += column_len;
3540     if (i != cf->cinfo.num_cols - 1) {
3541       /*
3542        * This isn't the last column, so we need to print a
3543        * separator between this column and the next.
3544        *
3545        * If we printed a network source and are printing a
3546        * network destination of the same type next, separate
3547        * them with " -> "; if we printed a network destination
3548        * and are printing a network source of the same type
3549        * next, separate them with " <- "; otherwise separate them
3550        * with a space.
3551        *
3552        * We add enough space to the buffer for " <- " or " -> ",
3553        * even if we're only adding " ".
3554        */
3555       line_bufp = get_line_buf(buf_offset + 4);
3556       switch (cf->cinfo.col_fmt[i]) {
3557
3558       case COL_DEF_SRC:
3559       case COL_RES_SRC:
3560       case COL_UNRES_SRC:
3561         switch (cf->cinfo.col_fmt[i + 1]) {
3562
3563         case COL_DEF_DST:
3564         case COL_RES_DST:
3565         case COL_UNRES_DST:
3566           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3567           buf_offset += 4;
3568           break;
3569
3570         default:
3571           g_strlcat(line_bufp + buf_offset, " ", 5);
3572           buf_offset += 1;
3573           break;
3574         }
3575         break;
3576
3577       case COL_DEF_DL_SRC:
3578       case COL_RES_DL_SRC:
3579       case COL_UNRES_DL_SRC:
3580         switch (cf->cinfo.col_fmt[i + 1]) {
3581
3582         case COL_DEF_DL_DST:
3583         case COL_RES_DL_DST:
3584         case COL_UNRES_DL_DST:
3585           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3586           buf_offset += 4;
3587           break;
3588
3589         default:
3590           g_strlcat(line_bufp + buf_offset, " ", 5);
3591           buf_offset += 1;
3592           break;
3593         }
3594         break;
3595
3596       case COL_DEF_NET_SRC:
3597       case COL_RES_NET_SRC:
3598       case COL_UNRES_NET_SRC:
3599         switch (cf->cinfo.col_fmt[i + 1]) {
3600
3601         case COL_DEF_NET_DST:
3602         case COL_RES_NET_DST:
3603         case COL_UNRES_NET_DST:
3604           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3605           buf_offset += 4;
3606           break;
3607
3608         default:
3609           g_strlcat(line_bufp + buf_offset, " ", 5);
3610           buf_offset += 1;
3611           break;
3612         }
3613         break;
3614
3615       case COL_DEF_DST:
3616       case COL_RES_DST:
3617       case COL_UNRES_DST:
3618         switch (cf->cinfo.col_fmt[i + 1]) {
3619
3620         case COL_DEF_SRC:
3621         case COL_RES_SRC:
3622         case COL_UNRES_SRC:
3623           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3624           buf_offset += 4;
3625           break;
3626
3627         default:
3628           g_strlcat(line_bufp + buf_offset, " ", 5);
3629           buf_offset += 1;
3630           break;
3631         }
3632         break;
3633
3634       case COL_DEF_DL_DST:
3635       case COL_RES_DL_DST:
3636       case COL_UNRES_DL_DST:
3637         switch (cf->cinfo.col_fmt[i + 1]) {
3638
3639         case COL_DEF_DL_SRC:
3640         case COL_RES_DL_SRC:
3641         case COL_UNRES_DL_SRC:
3642           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3643           buf_offset += 4;
3644           break;
3645
3646         default:
3647           g_strlcat(line_bufp + buf_offset, " ", 5);
3648           buf_offset += 1;
3649           break;
3650         }
3651         break;
3652
3653       case COL_DEF_NET_DST:
3654       case COL_RES_NET_DST:
3655       case COL_UNRES_NET_DST:
3656         switch (cf->cinfo.col_fmt[i + 1]) {
3657
3658         case COL_DEF_NET_SRC:
3659         case COL_RES_NET_SRC:
3660         case COL_UNRES_NET_SRC:
3661           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3662           buf_offset += 4;
3663           break;
3664
3665         default:
3666           g_strlcat(line_bufp + buf_offset, " ", 5);
3667           buf_offset += 1;
3668           break;
3669         }
3670         break;
3671
3672       default:
3673         g_strlcat(line_bufp + buf_offset, " ", 5);
3674         buf_offset += 1;
3675         break;
3676       }
3677     }
3678   }
3679   return print_line(print_stream, 0, line_bufp);
3680 }
3681
3682 static gboolean
3683 print_packet(capture_file *cf, epan_dissect_t *edt)
3684 {
3685   print_args_t print_args;
3686
3687   if (print_summary || output_fields_has_cols(output_fields)) {
3688     /* Just fill in the columns. */
3689     epan_dissect_fill_in_columns(edt, FALSE, TRUE);
3690
3691     if (print_summary) {
3692       /* Now print them. */
3693       switch (output_action) {
3694
3695       case WRITE_TEXT:
3696         if (!print_columns(cf))
3697           return FALSE;
3698         break;
3699
3700       case WRITE_XML:
3701         proto_tree_write_psml(edt, stdout);
3702         return !ferror(stdout);
3703       case WRITE_FIELDS: /*No non-verbose "fields" format */
3704         g_assert_not_reached();
3705         break;
3706       }
3707     }
3708   }
3709   if (print_details) {
3710     /* Print the information in the protocol tree. */
3711     switch (output_action) {
3712
3713     case WRITE_TEXT:
3714       /* Only initialize the fields that are actually used in proto_tree_print.
3715        * This is particularly important for .range, as that's heap memory which
3716        * we would otherwise have to g_free().
3717       print_args.to_file = TRUE;
3718       print_args.format = print_format;
3719       print_args.print_summary = print_summary;
3720       print_args.print_formfeed = FALSE;
3721       packet_range_init(&print_args.range, &cfile);
3722       */
3723       print_args.print_hex = print_hex;
3724       print_args.print_dissections = print_details ? print_dissections_expanded : print_dissections_none;
3725
3726       if (!proto_tree_print(&print_args, edt, print_stream))
3727         return FALSE;
3728       if (!print_hex) {
3729         if (!print_line(print_stream, 0, separator))
3730           return FALSE;
3731       }
3732       break;
3733
3734     case WRITE_XML:
3735       proto_tree_write_pdml(edt, stdout);
3736       printf("\n");
3737       return !ferror(stdout);
3738     case WRITE_FIELDS:
3739       proto_tree_write_fields(output_fields, edt, &cf->cinfo, stdout);
3740       printf("\n");
3741       return !ferror(stdout);
3742     }
3743   }
3744   if (print_hex) {
3745     if (print_summary || print_details) {
3746       if (!print_line(print_stream, 0, ""))
3747         return FALSE;
3748     }
3749     if (!print_hex_data(print_stream, edt))
3750       return FALSE;
3751     if (!print_line(print_stream, 0, separator))
3752       return FALSE;
3753   }
3754   return TRUE;
3755 }
3756
3757 static gboolean
3758 write_finale(void)
3759 {
3760   switch (output_action) {
3761
3762   case WRITE_TEXT:
3763     return print_finale(print_stream);
3764
3765   case WRITE_XML:
3766     if (print_details)
3767       write_pdml_finale(stdout);
3768     else
3769       write_psml_finale(stdout);
3770     return !ferror(stdout);
3771
3772   case WRITE_FIELDS:
3773     write_fields_finale(output_fields, stdout);
3774     return !ferror(stdout);
3775
3776   default:
3777     g_assert_not_reached();
3778     return FALSE;
3779   }
3780 }
3781
3782 cf_status_t
3783 cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
3784 {
3785   wtap  *wth;
3786   gchar *err_info;
3787   char   err_msg[2048+1];
3788
3789   wth = wtap_open_offline(fname, err, &err_info, perform_two_pass_analysis);
3790   if (wth == NULL)
3791     goto fail;
3792
3793   /* The open succeeded.  Fill in the information for this file. */
3794
3795   /* Create new epan session for dissection. */
3796   epan_free(cf->epan);
3797   cf->epan = tshark_epan_new(cf);
3798
3799   cf->wth = wth;
3800   cf->f_datalen = 0; /* not used, but set it anyway */
3801
3802   /* Set the file name because we need it to set the follow stream filter.
3803      XXX - is that still true?  We need it for other reasons, though,
3804      in any case. */
3805   cf->filename = g_strdup(fname);
3806
3807   /* Indicate whether it's a permanent or temporary file. */
3808   cf->is_tempfile = is_tempfile;
3809
3810   /* No user changes yet. */
3811   cf->unsaved_changes = FALSE;
3812
3813   cf->cd_t      = wtap_file_type(cf->wth);
3814   cf->count     = 0;
3815   cf->drops_known = FALSE;
3816   cf->drops     = 0;
3817   cf->snap      = wtap_snapshot_length(cf->wth);
3818   if (cf->snap == 0) {
3819     /* Snapshot length not known. */
3820     cf->has_snap = FALSE;
3821     cf->snap = WTAP_MAX_PACKET_SIZE;
3822   } else
3823     cf->has_snap = TRUE;
3824   nstime_set_zero(&cf->elapsed_time);
3825   ref = NULL;
3826   prev_dis = NULL;
3827   prev_cap = NULL;
3828
3829   cf->state = FILE_READ_IN_PROGRESS;
3830
3831   wtap_set_cb_new_ipv4(cf->wth, add_ipv4_name);
3832   wtap_set_cb_new_ipv6(cf->wth, (wtap_new_ipv6_callback_t) add_ipv6_name);
3833
3834   return CF_OK;
3835
3836 fail:
3837   g_snprintf(err_msg, sizeof err_msg,
3838              cf_open_error_message(*err, err_info, FALSE, cf->cd_t), fname);
3839   cmdarg_err("%s", err_msg);
3840   return CF_ERROR;
3841 }
3842
3843 static void
3844 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
3845 {
3846   char *save_file_string;
3847
3848   save_file_string = output_file_description(fname);
3849
3850   switch (err) {
3851
3852   case ENOSPC:
3853     cmdarg_err("Not all the packets could be written to the %s because there is "
3854                "no space left on the file system.",
3855                save_file_string);
3856     break;
3857
3858 #ifdef EDQUOT
3859   case EDQUOT:
3860     cmdarg_err("Not all the packets could be written to the %s because you are "
3861                "too close to, or over your disk quota.",
3862                save_file_string);
3863   break;
3864 #endif
3865
3866   case WTAP_ERR_CANT_CLOSE:
3867     cmdarg_err("The %s couldn't be closed for some unknown reason.",
3868                save_file_string);
3869     break;
3870
3871   case WTAP_ERR_SHORT_WRITE:
3872     cmdarg_err("Not all the packets could be written to the %s.",
3873                save_file_string);
3874     break;
3875
3876   default:
3877     if (is_close) {
3878       cmdarg_err("The %s could not be closed: %s.", save_file_string,
3879                  wtap_strerror(err));
3880     } else {
3881       cmdarg_err("An error occurred while writing to the %s: %s.",
3882                  save_file_string, wtap_strerror(err));
3883     }
3884     break;
3885   }
3886   g_free(save_file_string);
3887 }
3888
3889 static void
3890 show_print_file_io_error(int err)
3891 {
3892   switch (err) {
3893
3894   case ENOSPC:
3895     cmdarg_err("Not all the packets could be printed because there is "
3896 "no space left on the file system.");
3897     break;
3898
3899 #ifdef EDQUOT
3900   case EDQUOT:
3901     cmdarg_err("Not all the packets could be printed because you are "
3902 "too close to, or over your disk quota.");
3903   break;
3904 #endif
3905
3906   default:
3907     cmdarg_err("An error occurred while printing packets: %s.",
3908       g_strerror(err));
3909     break;
3910   }
3911 }
3912
3913 static const char *
3914 cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
3915                       int file_type)
3916 {
3917   const char *errmsg;
3918   static char errmsg_errno[1024+1];
3919
3920   if (err < 0) {
3921     /* Wiretap error. */
3922     switch (err) {
3923
3924     case WTAP_ERR_NOT_REGULAR_FILE:
3925       errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
3926       break;
3927
3928     case WTAP_ERR_RANDOM_OPEN_PIPE:
3929       /* Seen only when opening a capture file for reading. */
3930       errmsg = "The file \"%s\" is a pipe or FIFO; TShark can't read pipe or FIFO files in two-pass mode.";
3931       break;
3932
3933     case WTAP_ERR_FILE_UNKNOWN_FORMAT:
3934       /* Seen only when opening a capture file for reading. */
3935       errmsg = "The file \"%s\" isn't a capture file in a format TShark understands.";
3936       break;
3937
3938     case WTAP_ERR_UNSUPPORTED:
3939       /* Seen only when opening a capture file for reading. */
3940       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3941                "The file \"%%s\" isn't a capture file in a format TShark understands.\n"
3942                "(%s)", err_info);
3943       g_free(err_info);
3944       errmsg = errmsg_errno;
3945       break;
3946
3947     case WTAP_ERR_CANT_WRITE_TO_PIPE:
3948       /* Seen only when opening a capture file for writing. */
3949       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3950                  "The file \"%%s\" is a pipe, and \"%s\" capture files can't be "
3951                  "written to a pipe.", wtap_file_type_short_string(file_type));
3952       errmsg = errmsg_errno;
3953       break;
3954
3955     case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
3956       /* Seen only when opening a capture file for writing. */
3957       errmsg = "TShark doesn't support writing capture files in that format.";
3958       break;
3959
3960     case WTAP_ERR_UNSUPPORTED_ENCAP:
3961       if (for_writing) {
3962         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3963                    "TShark can't save this capture as a \"%s\" file.",
3964                    wtap_file_type_short_string(file_type));
3965       } else {
3966         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3967                  "The file \"%%s\" is a capture for a network type that TShark doesn't support.\n"
3968                  "(%s)", err_info);
3969         g_free(err_info);
3970       }
3971       errmsg = errmsg_errno;
3972       break;
3973
3974     case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
3975       if (for_writing) {
3976         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3977                    "TShark can't save this capture as a \"%s\" file.",
3978                    wtap_file_type_short_string(file_type));
3979         errmsg = errmsg_errno;
3980       } else
3981         errmsg = "The file \"%s\" is a capture for a network type that TShark doesn't support.";
3982       break;
3983
3984     case WTAP_ERR_BAD_FILE:
3985       /* Seen only when opening a capture file for reading. */
3986       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3987                "The file \"%%s\" appears to be damaged or corrupt.\n"
3988                "(%s)", err_info);
3989       g_free(err_info);
3990       errmsg = errmsg_errno;
3991       break;
3992
3993     case WTAP_ERR_CANT_OPEN:
3994       if (for_writing)
3995         errmsg = "The file \"%s\" could not be created for some unknown reason.";
3996       else
3997         errmsg = "The file \"%s\" could not be opened for some unknown reason.";
3998       break;
3999
4000     case WTAP_ERR_SHORT_READ:
4001       errmsg = "The file \"%s\" appears to have been cut short"
4002                " in the middle of a packet or other data.";
4003       break;
4004
4005     case WTAP_ERR_SHORT_WRITE:
4006       errmsg = "A full header couldn't be written to the file \"%s\".";
4007       break;
4008
4009     case WTAP_ERR_COMPRESSION_NOT_SUPPORTED:
4010       errmsg = "This file type cannot be written as a compressed file.";
4011       break;
4012
4013     case WTAP_ERR_DECOMPRESS:
4014       /* Seen only when opening a capture file for reading. */
4015       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4016                  "The compressed file \"%%s\" appears to be damaged or corrupt.\n"
4017                  "(%s)", err_info);
4018       g_free(err_info);
4019       errmsg = errmsg_errno;
4020       break;
4021
4022     default:
4023       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4024                  "The file \"%%s\" could not be %s: %s.",
4025                  for_writing ? "created" : "opened",
4026                  wtap_strerror(err));
4027       errmsg = errmsg_errno;
4028       break;
4029     }
4030   } else
4031     errmsg = file_open_error_message(err, for_writing);
4032   return errmsg;
4033 }
4034
4035 /*
4036  * Open/create errors are reported with an console message in TShark.
4037  */
4038 static void
4039 open_failure_message(const char *filename, int err, gboolean for_writing)
4040 {
4041   fprintf(stderr, "tshark: ");
4042   fprintf(stderr, file_open_error_message(err, for_writing), filename);
4043   fprintf(stderr, "\n");
4044 }
4045
4046
4047 /*
4048  * General errors are reported with an console message in TShark.
4049  */
4050 static void
4051 failure_message(const char *msg_format, va_list ap)
4052 {
4053   fprintf(stderr, "tshark: ");
4054   vfprintf(stderr, msg_format, ap);
4055   fprintf(stderr, "\n");
4056 }
4057
4058 /*
4059  * Read errors are reported with an console message in TShark.
4060  */
4061 static void
4062 read_failure_message(const char *filename, int err)
4063 {
4064   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
4065           filename, g_strerror(err));
4066 }
4067
4068 /*
4069  * Write errors are reported with an console message in TShark.
4070  */
4071 static void
4072 write_failure_message(const char *filename, int err)
4073 {
4074   cmdarg_err("An error occurred while writing to the file \"%s\": %s.",
4075           filename, g_strerror(err));
4076 }
4077
4078 /*
4079  * Report an error in command-line arguments.
4080  */
4081 void
4082 cmdarg_err(const char *fmt, ...)
4083 {
4084   va_list ap;
4085
4086   va_start(ap, fmt);
4087   failure_message(fmt, ap);
4088   va_end(ap);
4089 }
4090
4091 /*
4092  * Report additional information for an error in command-line arguments.
4093  */
4094 void
4095 cmdarg_err_cont(const char *fmt, ...)
4096 {
4097   va_list ap;
4098
4099   va_start(ap, fmt);
4100   vfprintf(stderr, fmt, ap);
4101   fprintf(stderr, "\n");
4102   va_end(ap);
4103 }
4104
4105
4106 /*
4107  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
4108  *
4109  * Local variables:
4110  * c-basic-offset: 2
4111  * tab-width: 8
4112  * indent-tabs-mode: nil
4113  * End:
4114  *
4115  * vi: set shiftwidth=2 tabstop=8 expandtab:
4116  * :indentSize=2:tabSize=8:noTabs=true:
4117  */