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