tshark.c

   1 /* tshark.c
   2  *
   3  * Text-mode variant of Wireshark, along the lines of tcpdump and snoop,
   4  * by Gilbert Ramirez <gram@alumni.rice.edu> and Guy Harris <guy@alum.mit.edu>.
   5  *
   6  * $Id$
   7  *
   8  * Wireshark - Network traffic analyzer
   9  * By Gerald Combs <gerald@wireshark.org>
  10  * Copyright 1998 Gerald Combs
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include "config.h"
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33 #include <locale.h>
  34 #include <limits.h>
  35
  36 #ifdef HAVE_UNISTD_H
  37 #include <unistd.h>
  38 #endif
  39
  40 #ifdef HAVE_GETOPT_H
  41 #include <getopt.h>
  42 #endif
  43
  44 #include <errno.h>
  45
  46 #ifdef HAVE_FCNTL_H
  47 #include <fcntl.h>
  48 #endif
  49
  50 #include <signal.h>
  51
  52 #ifdef HAVE_SYS_STAT_H
  53 # include <sys/stat.h>
  54 #endif
  55
  56 #ifndef HAVE_GETOPT
  57 #include "wsutil/wsgetopt.h"
  58 #endif
  59
  60 #include <glib.h>
  61 #include <epan/epan-int.h>
  62 #include <epan/epan.h>
  63 #include <epan/filesystem.h>
  64 #include <wsutil/crash_info.h>
  65 #include <wsutil/privileges.h>
  66 #include <wsutil/file_util.h>
  67
  68 #include "globals.h"
  69 #include <epan/timestamp.h>
  70 #include <epan/packet.h>
  71 #include "file.h"
  72 #include "frame_tvbuff.h"
  73 #include <epan/disabled_protos.h>
  74 #include <epan/prefs.h>
  75 #include <epan/column.h>
  76 #include <epan/print.h>
  77 #include <epan/addr_resolv.h>
  78 #include "ui/util.h"
  79 #include "clopts_common.h"
  80 #include "cmdarg_err.h"
  81 #include "version_info.h"
  82 #include <epan/plugins.h>
  83 #include "register.h"
  84 #include <epan/epan_dissect.h>
  85 #include <epan/tap.h>
  86 #include <epan/stat_cmd_args.h>
  87 #include <epan/timestamp.h>
  88 #include <epan/ex-opt.h>
  89
  90 #include "capture_opts.h"
  91
  92 #ifdef HAVE_LIBPCAP
  93 #include "capture_ui_utils.h"
  94 #include "capture_ifinfo.h"
  95 #include "capture-pcap-util.h"
  96 #ifdef _WIN32
  97 #include "capture-wpcap.h"
  98 #include <wsutil/unicode-utils.h>
  99 #endif /* _WIN32 */
 100 #include "capture_session.h"
 101 #include "capture_sync.h"
 102 #include "capture_opts.h"
 103 #endif /* HAVE_LIBPCAP */
 104 #include "log.h"
 105 #include <epan/funnel.h>
 106
 107 /*
 108  * This is the template for the decode as option; it is shared between the
 109  * various functions that output the usage for this parameter.
 110  */
 111 static const gchar decode_as_arg_template[] = "<layer_type>==<selector>,<decode_as_protocol>";
 112
 113 static guint32 cum_bytes;
 114 static const frame_data *ref;
 115 static frame_data ref_frame;
 116 static frame_data *prev_dis;
 117 static frame_data prev_dis_frame;
 118 static frame_data *prev_cap;
 119 static frame_data prev_cap_frame;
 120
 121 static const char* prev_display_dissector_name = NULL;
 122
 123 static gboolean perform_two_pass_analysis;
 124
 125 /*
 126  * The way the packet decode is to be written.
 127  */
 128 typedef enum {
 129   WRITE_TEXT,   /* summary or detail text */
 130   WRITE_XML,    /* PDML or PSML */
 131   WRITE_FIELDS  /* User defined list of fields */
 132   /* Add CSV and the like here */
 133 } output_action_e;
 134
 135 static output_action_e output_action;
 136 static gboolean do_dissection;     /* TRUE if we have to dissect each packet */
 137 static gboolean print_packet_info; /* TRUE if we're to print packet information */
 138 static gint print_summary = -1;    /* TRUE if we're to print packet summary information */
 139 static gboolean print_details;     /* TRUE if we're to print packet details information */
 140 static gboolean print_hex;         /* TRUE if we're to print hex/ascci information */
 141 static gboolean line_buffered;
 142 static gboolean really_quiet = FALSE;
 143
 144 static print_format_e print_format = PR_FMT_TEXT;
 145 static print_stream_t *print_stream;
 146
 147 static output_fields_t* output_fields  = NULL;
 148
 149 /* The line separator used between packets, changeable via the -S option */
 150 static const char *separator = "";
 151
 152 #ifdef HAVE_LIBPCAP
 153 /*
 154  * TRUE if we're to print packet counts to keep track of captured packets.
 155  */
 156 static gboolean print_packet_counts;
 157
 158 static capture_options global_capture_opts;
 159 static capture_session global_capture_session;
 160
 161 #ifdef SIGINFO
 162 static gboolean infodelay;      /* if TRUE, don't print capture info in SIGINFO handler */
 163 static gboolean infoprint;      /* if TRUE, print capture info after clearing infodelay */
 164 #endif /* SIGINFO */
 165
 166 static gboolean capture(void);
 167 static void report_counts(void);
 168 #ifdef _WIN32
 169 static BOOL WINAPI capture_cleanup(DWORD);
 170 #else /* _WIN32 */
 171 static void capture_cleanup(int);
 172 #ifdef SIGINFO
 173 static void report_counts_siginfo(int);
 174 #endif /* SIGINFO */
 175 #endif /* _WIN32 */
 176 #endif /* HAVE_LIBPCAP */
 177
 178 static int load_cap_file(capture_file *, char *, int, gboolean, int, gint64);
 179 static gboolean process_packet(capture_file *cf, gint64 offset,
 180     struct wtap_pkthdr *whdr, const guchar *pd,
 181     gboolean filtering_tap_listeners, guint tap_flags);
 182 static void show_capture_file_io_error(const char *, int, gboolean);
 183 static void show_print_file_io_error(int err);
 184 static gboolean write_preamble(capture_file *cf);
 185 static gboolean print_packet(capture_file *cf, epan_dissect_t *edt);
 186 static gboolean write_finale(void);
 187 static const char *cf_open_error_message(int err, gchar *err_info,
 188     gboolean for_writing, int file_type);
 189
 190 static void open_failure_message(const char *filename, int err,
 191     gboolean for_writing);
 192 static void failure_message(const char *msg_format, va_list ap);
 193 static void read_failure_message(const char *filename, int err);
 194 static void write_failure_message(const char *filename, int err);
 195
 196 capture_file cfile;
 197
 198 struct string_elem {
 199   const char *sstr;   /* The short string */
 200   const char *lstr;   /* The long string */
 201 };
 202
 203 static gint
 204 string_compare(gconstpointer a, gconstpointer b)
 205 {
 206   return strcmp(((const struct string_elem *)a)->sstr,
 207                 ((const struct string_elem *)b)->sstr);
 208 }
 209
 210 static void
 211 string_elem_print(gpointer data, gpointer not_used _U_)
 212 {
 213   fprintf(stderr, "    %s - %s\n",
 214           ((struct string_elem *)data)->sstr,
 215           ((struct string_elem *)data)->lstr);
 216 }
 217
 218 static void
 219 list_capture_types(void) {
 220   int                 i;
 221   struct string_elem *captypes;
 222   GSList             *list = NULL;
 223
 224   captypes = g_new(struct string_elem, WTAP_NUM_FILE_TYPES);
 225
 226   fprintf(stderr, "tshark: The available capture file types for the \"-F\" flag are:\n");
 227   for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
 228     if (wtap_dump_can_open(i)) {
 229       captypes[i].sstr = wtap_file_type_short_string(i);
 230       captypes[i].lstr = wtap_file_type_string(i);
 231       list = g_slist_insert_sorted(list, &captypes[i], string_compare);
 232     }
 233   }
 234   g_slist_foreach(list, string_elem_print, NULL);
 235   g_slist_free(list);
 236   g_free(captypes);
 237 }
 238
 239 static void
 240 print_usage(gboolean print_ver)
 241 {
 242   FILE *output;
 243
 244   if (print_ver) {
 245     output = stdout;
 246     fprintf(output,
 247         "TShark " VERSION "%s\n"
 248         "Dump and analyze network traffic.\n"
 249         "See http://www.wireshark.org for more information.\n"
 250         "\n"
 251         "%s",
 252          wireshark_svnversion, get_copyright_info());
 253   } else {
 254     output = stderr;
 255   }
 256   fprintf(output, "\n");
 257   fprintf(output, "Usage: tshark [options] ...\n");
 258   fprintf(output, "\n");
 259
 260 #ifdef HAVE_LIBPCAP
 261   fprintf(output, "Capture interface:\n");
 262   fprintf(output, "  -i <interface>           name or idx of interface (def: first non-loopback)\n");
 263   fprintf(output, "  -f <capture filter>      packet filter in libpcap filter syntax\n");
 264   fprintf(output, "  -s <snaplen>             packet snapshot length (def: 65535)\n");
 265   fprintf(output, "  -p                       don't capture in promiscuous mode\n");
 266 #ifdef HAVE_PCAP_CREATE
 267   fprintf(output, "  -I                       capture in monitor mode, if available\n");
 268 #endif
 269 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
 270   fprintf(output, "  -B <buffer size>         size of kernel buffer (def: %dMB)\n", DEFAULT_CAPTURE_BUFFER_SIZE);
 271 #endif
 272   fprintf(output, "  -y <link type>           link layer type (def: first appropriate)\n");
 273   fprintf(output, "  -D                       print list of interfaces and exit\n");
 274   fprintf(output, "  -L                       print list of link-layer types of iface and exit\n");
 275   fprintf(output, "\n");
 276   fprintf(output, "Capture stop conditions:\n");
 277   fprintf(output, "  -c <packet count>        stop after n packets (def: infinite)\n");
 278   fprintf(output, "  -a <autostop cond.> ...  duration:NUM - stop after NUM seconds\n");
 279   fprintf(output, "                           filesize:NUM - stop this file after NUM KB\n");
 280   fprintf(output, "                              files:NUM - stop after NUM files\n");
 281   /*fprintf(output, "\n");*/
 282   fprintf(output, "Capture output:\n");
 283   fprintf(output, "  -b <ringbuffer opt.> ... duration:NUM - switch to next file after NUM secs\n");
 284   fprintf(output, "                           filesize:NUM - switch to next file after NUM KB\n");
 285   fprintf(output, "                              files:NUM - ringbuffer: replace after NUM files\n");
 286 #endif  /* HAVE_LIBPCAP */
 287 #ifdef HAVE_PCAP_REMOTE
 288   fprintf(output, "RPCAP options:\n");
 289   fprintf(output, "  -A <user>:<password>     use RPCAP password authentication\n");
 290 #endif
 291   /*fprintf(output, "\n");*/
 292   fprintf(output, "Input file:\n");
 293   fprintf(output, "  -r <infile>              set the filename to read from (no pipes or stdin!)\n");
 294
 295   fprintf(output, "\n");
 296   fprintf(output, "Processing:\n");
 297   fprintf(output, "  -2                       perform a two-pass analysis\n");
 298   fprintf(output, "  -R <read filter>         packet Read filter in Wireshark display filter syntax\n");
 299   fprintf(output, "  -Y <display filter>      packet displaY filter in Wireshark display filter syntax\n");
 300   fprintf(output, "  -n                       disable all name resolutions (def: all enabled)\n");
 301   fprintf(output, "  -N <name resolve flags>  enable specific name resolution(s): \"mntC\"\n");
 302   fprintf(output, "  -d %s ...\n", decode_as_arg_template);
 303   fprintf(output, "                           \"Decode As\", see the man page for details\n");
 304   fprintf(output, "                           Example: tcp.port==8888,http\n");
 305   fprintf(output, "  -H <hosts file>          read a list of entries from a hosts file, which will\n");
 306   fprintf(output, "                           then be written to a capture file. (Implies -W n)\n");
 307
 308   /*fprintf(output, "\n");*/
 309   fprintf(output, "Output:\n");
 310   fprintf(output, "  -w <outfile|->           write packets to a pcap-format file named \"outfile\"\n");
 311   fprintf(output, "                           (or to the standard output for \"-\")\n");
 312   fprintf(output, "  -C <config profile>      start with specified configuration profile\n");
 313   fprintf(output, "  -F <output file type>    set the output file type, default is pcapng\n");
 314   fprintf(output, "                           an empty \"-F\" option will list the file types\n");
 315   fprintf(output, "  -V                       add output of packet tree        (Packet Details)\n");
 316   fprintf(output, "  -O <protocols>           Only show packet details of these protocols, comma\n");
 317   fprintf(output, "                           separated\n");
 318   fprintf(output, "  -P                       print packet summary even when writing to a file\n");
 319   fprintf(output, "  -S <separator>           the line separator to print between packets\n");
 320   fprintf(output, "  -x                       add output of hex and ASCII dump (Packet Bytes)\n");
 321   fprintf(output, "  -T pdml|ps|psml|text|fields\n");
 322   fprintf(output, "                           format of text output (def: text)\n");
 323   fprintf(output, "  -e <field>               field to print if -Tfields selected (e.g. tcp.port, col.Info);\n");
 324   fprintf(output, "                           this option can be repeated to print multiple fields\n");
 325   fprintf(output, "  -E<fieldsoption>=<value> set options for output when -Tfields selected:\n");
 326   fprintf(output, "     header=y|n            switch headers on and off\n");
 327   fprintf(output, "     separator=/t|/s|<char> select tab, space, printable character as separator\n");
 328   fprintf(output, "     occurrence=f|l|a      print first, last or all occurrences of each field\n");
 329   fprintf(output, "     aggregator=,|/s|<char> select comma, space, printable character as\n");
 330   fprintf(output, "                           aggregator\n");
 331   fprintf(output, "     quote=d|s|n           select double, single, no quotes for values\n");
 332   fprintf(output, "  -t a|ad|d|dd|e|r|u|ud    output format of time stamps (def: r: rel. to first)\n");
 333   fprintf(output, "  -u s|hms                 output format of seconds (def: s: seconds)\n");
 334   fprintf(output, "  -l                       flush standard output after each packet\n");
 335   fprintf(output, "  -q                       be more quiet on stdout (e.g. when using statistics)\n");
 336   fprintf(output, "  -Q                       only log true errors to stderr (quieter than -q)\n");
 337   fprintf(output, "  -g                       enable group read access on the output file(s)\n");
 338   fprintf(output, "  -W n                     Save extra information in the file, if supported.\n");
 339   fprintf(output, "                           n = write network address resolution information\n");
 340   fprintf(output, "  -X <key>:<value>         eXtension options, see the man page for details\n");
 341   fprintf(output, "  -z <statistics>          various statistics, see the man page for details\n");
 342   fprintf(output, "  --capture-comment <comment>\n");
 343   fprintf(output, "                           add a capture comment to the newly created\n");
 344   fprintf(output, "                           output file (only for pcapng)\n");
 345
 346   fprintf(output, "\n");
 347   fprintf(output, "Miscellaneous:\n");
 348   fprintf(output, "  -h                       display this help and exit\n");
 349   fprintf(output, "  -v                       display version info and exit\n");
 350   fprintf(output, "  -o <name>:<value> ...    override preference setting\n");
 351   fprintf(output, "  -K <keytab>              keytab file to use for kerberos decryption\n");
 352   fprintf(output, "  -G [report]              dump one of several available reports and exit\n");
 353   fprintf(output, "                           default report=\"fields\"\n");
 354   fprintf(output, "                           use \"-G ?\" for more help\n");
 355 #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     /* Just a warning, so we don't return */
1647     cmdarg_err("-R without -2 is deprecated. For single-pass filtering use -Y.");
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       }
2507       ((capture_file *) cap_session->cf)->state = FILE_CLOSED;
2508     }
2509
2510     g_free(capture_opts->save_file);
2511     is_tempfile = FALSE;
2512   } else {
2513     /* we didn't had a save_file before, must be a tempfile */
2514     is_tempfile = TRUE;
2515   }
2516
2517   /* save the new filename */
2518   capture_opts->save_file = g_strdup(new_file);
2519
2520   /* if we are in real-time mode, open the new file now */
2521   if (do_dissection) {
2522     /* Attempt to open the capture file and set up to read from it. */
2523     switch(cf_open((capture_file *)cap_session->cf, capture_opts->save_file, is_tempfile, &err)) {
2524     case CF_OK:
2525       break;
2526     case CF_ERROR:
2527       /* Don't unlink (delete) the save file - leave it around,
2528          for debugging purposes. */
2529       g_free(capture_opts->save_file);
2530       capture_opts->save_file = NULL;
2531       return FALSE;
2532     }
2533   }
2534
2535   cap_session->state = CAPTURE_RUNNING;
2536
2537   return TRUE;
2538 }
2539
2540
2541 /* capture child tells us we have new packets to read */
2542 void
2543 capture_input_new_packets(capture_session *cap_session, int to_read)
2544 {
2545   gboolean      ret;
2546   int           err;
2547   gchar        *err_info;
2548   gint64        data_offset;
2549   capture_file *cf = (capture_file *)cap_session->cf;
2550   gboolean      filtering_tap_listeners;
2551   guint         tap_flags;
2552
2553 #ifdef SIGINFO
2554   /*
2555    * Prevent a SIGINFO handler from writing to the standard error while
2556    * we're doing so or writing to the standard output; instead, have it
2557    * just set a flag telling us to print that information when we're done.
2558    */
2559   infodelay = TRUE;
2560 #endif /* SIGINFO */
2561
2562   /* Do we have any tap listeners with filters? */
2563   filtering_tap_listeners = have_filtering_tap_listeners();
2564
2565   /* Get the union of the flags for all tap listeners. */
2566   tap_flags = union_of_tap_listener_flags();
2567
2568   if (do_dissection) {
2569     while (to_read-- && cf->wth) {
2570       wtap_cleareof(cf->wth);
2571       ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
2572       if (ret == FALSE) {
2573         /* read from file failed, tell the capture child to stop */
2574         sync_pipe_stop(cap_session);
2575         wtap_close(cf->wth);
2576         cf->wth = NULL;
2577       } else {
2578         ret = process_packet(cf, data_offset, wtap_phdr(cf->wth),
2579                              wtap_buf_ptr(cf->wth),
2580                              filtering_tap_listeners, tap_flags);
2581       }
2582       if (ret != FALSE) {
2583         /* packet successfully read and gone through the "Read Filter" */
2584         packet_count++;
2585       }
2586     }
2587   } else {
2588     /*
2589      * Dumpcap's doing all the work; we're not doing any dissection.
2590      * Count all the packets it wrote.
2591      */
2592     packet_count += to_read;
2593   }
2594
2595   if (print_packet_counts) {
2596       /* We're printing packet counts. */
2597       if (packet_count != 0) {
2598         fprintf(stderr, "\r%u ", packet_count);
2599         /* stderr could be line buffered */
2600         fflush(stderr);
2601       }
2602   }
2603
2604 #ifdef SIGINFO
2605   /*
2606    * Allow SIGINFO handlers to write.
2607    */
2608   infodelay = FALSE;
2609
2610   /*
2611    * If a SIGINFO handler asked us to write out capture counts, do so.
2612    */
2613   if (infoprint)
2614     report_counts();
2615 #endif /* SIGINFO */
2616 }
2617
2618 static void
2619 report_counts(void)
2620 {
2621   if ((print_packet_counts == FALSE) && (really_quiet == FALSE)) {
2622     /* Report the count only if we aren't printing a packet count
2623        as packets arrive. */
2624       fprintf(stderr, "%u packet%s captured\n", packet_count,
2625             plurality(packet_count, "", "s"));
2626   }
2627 #ifdef SIGINFO
2628   infoprint = FALSE; /* we just reported it */
2629 #endif /* SIGINFO */
2630 }
2631
2632 #ifdef SIGINFO
2633 static void
2634 report_counts_siginfo(int signum _U_)
2635 {
2636   int sav_errno = errno;
2637   /* If we've been told to delay printing, just set a flag asking
2638      that we print counts (if we're supposed to), otherwise print
2639      the count of packets captured (if we're supposed to). */
2640   if (infodelay)
2641     infoprint = TRUE;
2642   else
2643     report_counts();
2644   errno = sav_errno;
2645 }
2646 #endif /* SIGINFO */
2647
2648
2649 /* capture child detected any packet drops? */
2650 void
2651 capture_input_drops(capture_session *cap_session _U_, guint32 dropped)
2652 {
2653   if (print_packet_counts) {
2654     /* We're printing packet counts to stderr.
2655        Send a newline so that we move to the line after the packet count. */
2656     fprintf(stderr, "\n");
2657   }
2658
2659   if (dropped != 0) {
2660     /* We're printing packet counts to stderr.
2661        Send a newline so that we move to the line after the packet count. */
2662     fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2663   }
2664 }
2665
2666
2667 /*
2668  * Capture child closed its side of the pipe, report any error and
2669  * do the required cleanup.
2670  */
2671 void
2672 capture_input_closed(capture_session *cap_session, gchar *msg)
2673 {
2674   capture_file *cf = (capture_file *) cap_session->cf;
2675
2676   if (msg != NULL)
2677     fprintf(stderr, "tshark: %s\n", msg);
2678
2679   report_counts();
2680
2681   if (cf != NULL && cf->wth != NULL) {
2682     wtap_close(cf->wth);
2683     if (cf->is_tempfile) {
2684       ws_unlink(cf->filename);
2685     }
2686   }
2687 #ifdef USE_BROKEN_G_MAIN_LOOP
2688   /*g_main_loop_quit(loop);*/
2689   g_main_quit(loop);
2690 #else
2691   loop_running = FALSE;
2692 #endif
2693 }
2694
2695
2696
2697
2698 #ifdef _WIN32
2699 static BOOL WINAPI
2700 capture_cleanup(DWORD ctrltype _U_)
2701 {
2702   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2703      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2704      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2705      like SIGTERM at least when the machine's shutting down.
2706
2707      For now, we handle them all as indications that we should clean up
2708      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2709      way on UNIX.
2710
2711      We must return TRUE so that no other handler - such as one that would
2712      terminate the process - gets called.
2713
2714      XXX - for some reason, typing ^C to TShark, if you run this in
2715      a Cygwin console window in at least some versions of Cygwin,
2716      causes TShark to terminate immediately; this routine gets
2717      called, but the main loop doesn't get a chance to run and
2718      exit cleanly, at least if this is compiled with Microsoft Visual
2719      C++ (i.e., it's a property of the Cygwin console window or Bash;
2720      it happens if TShark is not built with Cygwin - for all I know,
2721      building it with Cygwin may make the problem go away). */
2722
2723   /* tell the capture child to stop */
2724   sync_pipe_stop(&global_capture_session);
2725
2726   /* don't stop our own loop already here, otherwise status messages and
2727    * cleanup wouldn't be done properly. The child will indicate the stop of
2728    * everything by calling capture_input_closed() later */
2729
2730   return TRUE;
2731 }
2732 #else
2733 static void
2734 capture_cleanup(int signum _U_)
2735 {
2736   /* tell the capture child to stop */
2737   sync_pipe_stop(&global_capture_session);
2738
2739   /* don't stop our own loop already here, otherwise status messages and
2740    * cleanup wouldn't be done properly. The child will indicate the stop of
2741    * everything by calling capture_input_closed() later */
2742 }
2743 #endif /* _WIN32 */
2744 #endif /* HAVE_LIBPCAP */
2745
2746 static gboolean
2747 process_packet_first_pass(capture_file *cf,
2748                gint64 offset, struct wtap_pkthdr *whdr,
2749                const guchar *pd)
2750 {
2751   frame_data     fdlocal;
2752   guint32        framenum;
2753   gboolean       create_proto_tree = FALSE;
2754   epan_dissect_t edt;
2755   gboolean       passed;
2756
2757   /* The frame number of this packet is one more than the count of
2758      frames in this packet. */
2759   framenum = cf->count + 1;
2760
2761   /* If we're not running a display filter and we're not printing any
2762      packet information, we don't need to do a dissection. This means
2763      that all packets can be marked as 'passed'. */
2764   passed = TRUE;
2765
2766   frame_data_init(&fdlocal, framenum, whdr, offset, cum_bytes);
2767
2768   /* If we're going to print packet information, or we're going to
2769      run a read filter, or display filter, or we're going to process taps, set up to
2770      do a dissection and do so. */
2771   if (do_dissection) {
2772     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2773         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2774       /* Grab any resolved addresses */
2775       host_name_lookup_process();
2776
2777     /* If we're going to be applying a filter, we'll need to
2778        create a protocol tree against which to apply the filter. */
2779     if (cf->rfcode)
2780       create_proto_tree = TRUE;
2781
2782     /* We're not going to display the protocol tree on this pass,
2783        so it's not going to be "visible". */
2784     epan_dissect_init(&edt, cf->epan, create_proto_tree, FALSE);
2785
2786     /* If we're running a read filter, prime the epan_dissect_t with that
2787        filter. */
2788     if (cf->rfcode)
2789       epan_dissect_prime_dfilter(&edt, cf->rfcode);
2790
2791     frame_data_set_before_dissect(&fdlocal, &cf->elapsed_time,
2792                                   &ref, prev_dis);
2793     if (ref == &fdlocal) {
2794       ref_frame = fdlocal;
2795       ref = &ref_frame;
2796     }
2797
2798     epan_dissect_run(&edt, whdr, frame_tvbuff_new(&fdlocal, pd), &fdlocal, NULL);
2799
2800     /* Run the read filter if we have one. */
2801     if (cf->rfcode)
2802       passed = dfilter_apply_edt(cf->rfcode, &edt);
2803   }
2804
2805   if (passed) {
2806     frame_data_set_after_dissect(&fdlocal, &cum_bytes);
2807     prev_cap = prev_dis = frame_data_sequence_add(cf->frames, &fdlocal);
2808
2809     /* If we're not doing dissection then there won't be any dependent frames.
2810      * More importantly, edt.pi.dependent_frames won't be initialized because
2811      * epan hasn't been initialized.
2812      */
2813     if (do_dissection) {
2814       g_slist_foreach(edt.pi.dependent_frames, find_and_mark_frame_depended_upon, cf->frames);
2815     }
2816
2817     cf->count++;
2818   } else {
2819     /* if we don't add it to the frame_data_sequence, clean it up right now
2820      * to avoid leaks */
2821     frame_data_destroy(&fdlocal);
2822   }
2823
2824   if (do_dissection)
2825     epan_dissect_cleanup(&edt);
2826
2827   return passed;
2828 }
2829
2830 static gboolean
2831 process_packet_second_pass(capture_file *cf, frame_data *fdata,
2832                struct wtap_pkthdr *phdr, Buffer *buf,
2833                gboolean filtering_tap_listeners, guint tap_flags)
2834 {
2835   gboolean        create_proto_tree;
2836   column_info    *cinfo;
2837   epan_dissect_t  edt;
2838   gboolean        passed;
2839
2840   /* If we're not running a display filter and we're not printing any
2841      packet information, we don't need to do a dissection. This means
2842      that all packets can be marked as 'passed'. */
2843   passed = TRUE;
2844
2845   /* If we're going to print packet information, or we're going to
2846      run a read filter, or we're going to process taps, set up to
2847      do a dissection and do so. */
2848   if (do_dissection) {
2849     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2850         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2851       /* Grab any resolved addresses */
2852       host_name_lookup_process();
2853
2854     if (cf->dfcode || print_details || filtering_tap_listeners ||
2855         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
2856       create_proto_tree = TRUE;
2857     else
2858       create_proto_tree = FALSE;
2859
2860     /* The protocol tree will be "visible", i.e., printed, only if we're
2861        printing packet details, which is true if we're printing stuff
2862        ("print_packet_info" is true) and we're in verbose mode
2863        ("packet_details" is true). */
2864     epan_dissect_init(&edt, cf->epan, create_proto_tree, print_packet_info && print_details);
2865
2866     /* If we're running a display filter, prime the epan_dissect_t with that
2867        filter. */
2868     if (cf->dfcode)
2869       epan_dissect_prime_dfilter(&edt, cf->dfcode);
2870
2871     col_custom_prime_edt(&edt, &cf->cinfo);
2872
2873     /* We only need the columns if either
2874          1) some tap needs the columns
2875        or
2876          2) we're printing packet info but we're *not* verbose; in verbose
2877             mode, we print the protocol tree, not the protocol summary.
2878      */
2879     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary))
2880       cinfo = &cf->cinfo;
2881     else
2882       cinfo = NULL;
2883
2884     frame_data_set_before_dissect(fdata, &cf->elapsed_time,
2885                                   &ref, prev_dis);
2886     if (ref == fdata) {
2887       ref_frame = *fdata;
2888       ref = &ref_frame;
2889     }
2890
2891     epan_dissect_run_with_taps(&edt, phdr, frame_tvbuff_new_buffer(fdata, buf), fdata, cinfo);
2892
2893     /* Run the read/display filter if we have one. */
2894     if (cf->dfcode)
2895       passed = dfilter_apply_edt(cf->dfcode, &edt);
2896   }
2897
2898   if (passed) {
2899     frame_data_set_after_dissect(fdata, &cum_bytes);
2900     /* Process this packet. */
2901     if (print_packet_info) {
2902       /* We're printing packet information; print the information for
2903          this packet. */
2904       if (do_dissection)
2905         print_packet(cf, &edt);
2906       else
2907         print_packet(cf, NULL);
2908
2909       /* The ANSI C standard does not appear to *require* that a line-buffered
2910          stream be flushed to the host environment whenever a newline is
2911          written, it just says that, on such a stream, characters "are
2912          intended to be transmitted to or from the host environment as a
2913          block when a new-line character is encountered".
2914
2915          The Visual C++ 6.0 C implementation doesn't do what is intended;
2916          even if you set a stream to be line-buffered, it still doesn't
2917          flush the buffer at the end of every line.
2918
2919          So, if the "-l" flag was specified, we flush the standard output
2920          at the end of a packet.  This will do the right thing if we're
2921          printing packet summary lines, and, as we print the entire protocol
2922          tree for a single packet without waiting for anything to happen,
2923          it should be as good as line-buffered mode if we're printing
2924          protocol trees.  (The whole reason for the "-l" flag in either
2925          tcpdump or TShark is to allow the output of a live capture to
2926          be piped to a program or script and to have that script see the
2927          information for the packet as soon as it's printed, rather than
2928          having to wait until a standard I/O buffer fills up. */
2929       if (line_buffered)
2930         fflush(stdout);
2931
2932       if (ferror(stdout)) {
2933         show_print_file_io_error(errno);
2934         exit(2);
2935       }
2936     }
2937     prev_dis = fdata;
2938   }
2939   prev_cap = fdata;
2940
2941   if (do_dissection) {
2942     epan_dissect_cleanup(&edt);
2943   }
2944   return passed || fdata->flags.dependent_of_displayed;
2945 }
2946
2947 static int
2948 load_cap_file(capture_file *cf, char *save_file, int out_file_type,
2949     gboolean out_file_name_res, int max_packet_count, gint64 max_byte_count)
2950 {
2951   gint         linktype;
2952   int          snapshot_length;
2953   wtap_dumper *pdh;
2954   guint32      framenum;
2955   int          err;
2956   gchar       *err_info = NULL;
2957   gint64       data_offset;
2958   char        *save_file_string = NULL;
2959   gboolean     filtering_tap_listeners;
2960   guint        tap_flags;
2961   wtapng_section_t            *shb_hdr;
2962   wtapng_iface_descriptions_t *idb_inf;
2963   char         appname[100];
2964   Buffer       buf;
2965
2966   shb_hdr = wtap_file_get_shb_info(cf->wth);
2967   idb_inf = wtap_file_get_idb_info(cf->wth);
2968 #ifdef PCAP_NG_DEFAULT
2969   if (idb_inf->number_of_interfaces > 1) {
2970     linktype = WTAP_ENCAP_PER_PACKET;
2971   } else {
2972     linktype = wtap_file_encap(cf->wth);
2973   }
2974 #else
2975   linktype = wtap_file_encap(cf->wth);
2976 #endif
2977   if (save_file != NULL) {
2978     /* Get a string that describes what we're writing to */
2979     save_file_string = output_file_description(save_file);
2980
2981     /* Set up to write to the capture file. */
2982     snapshot_length = wtap_snapshot_length(cf->wth);
2983     if (snapshot_length == 0) {
2984       /* Snapshot length of input file not known. */
2985       snapshot_length = WTAP_MAX_PACKET_SIZE;
2986     }
2987     /* If we don't have an application name add Tshark */
2988     if (shb_hdr->shb_user_appl == NULL) {
2989         g_snprintf(appname, sizeof(appname), "TShark " VERSION "%s", wireshark_svnversion);
2990         shb_hdr->shb_user_appl = appname;
2991     }
2992
2993     if (linktype != WTAP_ENCAP_PER_PACKET && out_file_type == WTAP_FILE_PCAP)
2994         pdh = wtap_dump_open(save_file, out_file_type, linktype,
2995             snapshot_length, FALSE /* compressed */, &err);
2996     else
2997         pdh = wtap_dump_open_ng(save_file, out_file_type, linktype,
2998             snapshot_length, FALSE /* compressed */, shb_hdr, idb_inf, &err);
2999
3000     g_free(idb_inf);
3001     idb_inf = NULL;
3002
3003     if (pdh == NULL) {
3004       /* We couldn't set up to write to the capture file. */
3005       switch (err) {
3006
3007       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
3008         cmdarg_err("Capture files can't be written in that format.");
3009         break;
3010
3011       case WTAP_ERR_UNSUPPORTED_ENCAP:
3012       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
3013         cmdarg_err("The capture file being read can't be written as a "
3014           "\"%s\" file.", wtap_file_type_short_string(out_file_type));
3015         break;
3016
3017       case WTAP_ERR_CANT_OPEN:
3018         cmdarg_err("The %s couldn't be created for some "
3019           "unknown reason.", save_file_string);
3020         break;
3021
3022       case WTAP_ERR_SHORT_WRITE:
3023         cmdarg_err("A full header couldn't be written to the %s.",
3024                    save_file_string);
3025         break;
3026
3027       default:
3028         cmdarg_err("The %s could not be created: %s.", save_file_string,
3029                    wtap_strerror(err));
3030         break;
3031       }
3032       goto out;
3033     }
3034   } else {
3035     if (print_packet_info) {
3036       if (!write_preamble(cf)) {
3037         err = errno;
3038         show_print_file_io_error(err);
3039         goto out;
3040       }
3041     }
3042     pdh = NULL;
3043   }
3044
3045   if (pdh && out_file_name_res) {
3046     if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
3047       cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
3048                  wtap_file_type_short_string(out_file_type));
3049     }
3050   }
3051
3052   /* Do we have any tap listeners with filters? */
3053   filtering_tap_listeners = have_filtering_tap_listeners();
3054
3055   /* Get the union of the flags for all tap listeners. */
3056   tap_flags = union_of_tap_listener_flags();
3057
3058   if (perform_two_pass_analysis) {
3059     frame_data *fdata;
3060
3061     /* Allocate a frame_data_sequence for all the frames. */
3062     cf->frames = new_frame_data_sequence();
3063
3064     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
3065       if (process_packet_first_pass(cf, data_offset, wtap_phdr(cf->wth),
3066                          wtap_buf_ptr(cf->wth))) {
3067         /* Stop reading if we have the maximum number of packets;
3068          * When the -c option has not been used, max_packet_count
3069          * starts at 0, which practically means, never stop reading.
3070          * (unless we roll over max_packet_count ?)
3071          */
3072         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3073           err = 0; /* This is not an error */
3074           break;
3075         }
3076       }
3077     }
3078
3079     /* Close the sequential I/O side, to free up memory it requires. */
3080     wtap_sequential_close(cf->wth);
3081
3082     /* Allow the protocol dissectors to free up memory that they
3083      * don't need after the sequential run-through of the packets. */
3084     postseq_cleanup_all_protocols();
3085
3086     prev_dis = NULL;
3087     prev_cap = NULL;
3088     buffer_init(&buf, 1500);
3089     for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
3090       fdata = frame_data_sequence_find(cf->frames, framenum);
3091       if (wtap_seek_read(cf->wth, fdata->file_off, &cf->phdr,
3092           &buf, fdata->cap_len, &err, &err_info)) {
3093         if (process_packet_second_pass(cf, fdata, &cf->phdr, &buf,
3094                                        filtering_tap_listeners, tap_flags)) {
3095           /* Either there's no read filtering or this packet passed the
3096              filter, so, if we're writing to a capture file, write
3097              this packet out. */
3098           if (pdh != NULL) {
3099             if (!wtap_dump(pdh, &cf->phdr, buffer_start_ptr(&cf->buf), &err)) {
3100               /* Error writing to a capture file */
3101               switch (err) {
3102
3103               case WTAP_ERR_UNSUPPORTED_ENCAP:
3104                 /*
3105                  * This is a problem with the particular frame we're writing;
3106                  * note that, and give the frame number.
3107                  *
3108                  * XXX - framenum is not necessarily the frame number in
3109                  * the input file if there was a read filter.
3110                  */
3111                 fprintf(stderr,
3112                         "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
3113                         framenum, cf->filename,
3114                         wtap_file_type_short_string(out_file_type));
3115                 break;
3116
3117               default:
3118                 show_capture_file_io_error(save_file, err, FALSE);
3119                 break;
3120               }
3121               wtap_dump_close(pdh, &err);
3122               g_free(shb_hdr);
3123               exit(2);
3124             }
3125           }
3126         }
3127       }
3128     }
3129     buffer_free(&buf);
3130   }
3131   else {
3132     framenum = 0;
3133     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
3134       framenum++;
3135
3136       if (process_packet(cf, data_offset, wtap_phdr(cf->wth),
3137                          wtap_buf_ptr(cf->wth),
3138                          filtering_tap_listeners, tap_flags)) {
3139         /* Either there's no read filtering or this packet passed the
3140            filter, so, if we're writing to a capture file, write
3141            this packet out. */
3142         if (pdh != NULL) {
3143           if (!wtap_dump(pdh, wtap_phdr(cf->wth), wtap_buf_ptr(cf->wth), &err)) {
3144             /* Error writing to a capture file */
3145             switch (err) {
3146
3147             case WTAP_ERR_UNSUPPORTED_ENCAP:
3148               /*
3149                * This is a problem with the particular frame we're writing;
3150                * note that, and give the frame number.
3151                */
3152               fprintf(stderr,
3153                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
3154                       framenum, cf->filename,
3155                       wtap_file_type_short_string(out_file_type));
3156               break;
3157
3158             default:
3159               show_capture_file_io_error(save_file, err, FALSE);
3160               break;
3161             }
3162             wtap_dump_close(pdh, &err);
3163             g_free(shb_hdr);
3164             exit(2);
3165           }
3166         }
3167         /* Stop reading if we have the maximum number of packets;
3168          * When the -c option has not been used, max_packet_count
3169          * starts at 0, which practically means, never stop reading.
3170          * (unless we roll over max_packet_count ?)
3171          */
3172         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3173           err = 0; /* This is not an error */
3174           break;
3175         }
3176       }
3177     }
3178   }
3179
3180   if (err != 0) {
3181     /*
3182      * Print a message noting that the read failed somewhere along the line.
3183      *
3184      * If we're printing packet data, and the standard output and error are
3185      * going to the same place, flush the standard output, so everything
3186      * buffered up is written, and then print a newline to the standard error
3187      * before printing the error message, to separate it from the packet
3188      * data.  (Alas, that only works on UN*X; st_dev is meaningless, and
3189      * the _fstat() documentation at Microsoft doesn't indicate whether
3190      * st_ino is even supported.)
3191      */
3192 #ifndef _WIN32
3193     if (print_packet_info) {
3194       struct stat stat_stdout, stat_stderr;
3195
3196       if (fstat(1, &stat_stdout) == 0 && fstat(2, &stat_stderr) == 0) {
3197         if (stat_stdout.st_dev == stat_stderr.st_dev &&
3198             stat_stdout.st_ino == stat_stderr.st_ino) {
3199           fflush(stdout);
3200           fprintf(stderr, "\n");
3201         }
3202       }
3203     }
3204 #endif
3205     switch (err) {
3206
3207     case WTAP_ERR_UNSUPPORTED:
3208       cmdarg_err("The file \"%s\" contains record data that TShark doesn't support.\n(%s)",
3209                  cf->filename, err_info);
3210       g_free(err_info);
3211       break;
3212
3213     case WTAP_ERR_UNSUPPORTED_ENCAP:
3214       cmdarg_err("The file \"%s\" has a packet with a network type that TShark doesn't support.\n(%s)",
3215                  cf->filename, err_info);
3216       g_free(err_info);
3217       break;
3218
3219     case WTAP_ERR_CANT_READ:
3220       cmdarg_err("An attempt to read from the file \"%s\" failed for some unknown reason.",
3221                  cf->filename);
3222       break;
3223
3224     case WTAP_ERR_SHORT_READ:
3225       cmdarg_err("The file \"%s\" appears to have been cut short in the middle of a packet.",
3226                  cf->filename);
3227       break;
3228
3229     case WTAP_ERR_BAD_FILE:
3230       cmdarg_err("The file \"%s\" appears to be damaged or corrupt.\n(%s)",
3231                  cf->filename, err_info);
3232       g_free(err_info);
3233       break;
3234
3235     case WTAP_ERR_DECOMPRESS:
3236       cmdarg_err("The compressed file \"%s\" appears to be damaged or corrupt.\n"
3237                  "(%s)", cf->filename, err_info);
3238       break;
3239
3240     default:
3241       cmdarg_err("An error occurred while reading the file \"%s\": %s.",
3242                  cf->filename, wtap_strerror(err));
3243       break;
3244     }
3245     if (save_file != NULL) {
3246       /* Now close the capture file. */
3247       if (!wtap_dump_close(pdh, &err))
3248         show_capture_file_io_error(save_file, err, TRUE);
3249     }
3250   } else {
3251     if (save_file != NULL) {
3252       /* Now close the capture file. */
3253       if (!wtap_dump_close(pdh, &err))
3254         show_capture_file_io_error(save_file, err, TRUE);
3255     } else {
3256       if (print_packet_info) {
3257         if (!write_finale()) {
3258           err = errno;
3259           show_print_file_io_error(err);
3260         }
3261       }
3262     }
3263   }
3264
3265 out:
3266   wtap_close(cf->wth);
3267   cf->wth = NULL;
3268
3269   g_free(save_file_string);
3270   g_free(shb_hdr);
3271
3272   return err;
3273 }
3274
3275 static gboolean
3276 process_packet(capture_file *cf, gint64 offset, struct wtap_pkthdr *whdr,
3277                const guchar *pd,
3278                gboolean filtering_tap_listeners, guint tap_flags)
3279 {
3280   frame_data      fdata;
3281   gboolean        create_proto_tree;
3282   column_info    *cinfo;
3283   epan_dissect_t  edt;
3284   gboolean        passed;
3285
3286   /* Count this packet. */
3287   cf->count++;
3288
3289   /* If we're not running a display filter and we're not printing any
3290      packet information, we don't need to do a dissection. This means
3291      that all packets can be marked as 'passed'. */
3292   passed = TRUE;
3293
3294   frame_data_init(&fdata, cf->count, whdr, offset, cum_bytes);
3295
3296   /* If we're going to print packet information, or we're going to
3297      run a read filter, or we're going to process taps, set up to
3298      do a dissection and do so. */
3299   if (do_dissection) {
3300     if (print_packet_info && (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
3301         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns))
3302       /* Grab any resolved addresses */
3303       host_name_lookup_process();
3304
3305     if (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
3306         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
3307       create_proto_tree = TRUE;
3308     else
3309       create_proto_tree = FALSE;
3310
3311     /* The protocol tree will be "visible", i.e., printed, only if we're
3312        printing packet details, which is true if we're printing stuff
3313        ("print_packet_info" is true) and we're in verbose mode
3314        ("packet_details" is true). */
3315     epan_dissect_init(&edt, cf->epan, create_proto_tree, print_packet_info && print_details);
3316
3317     /* If we're running a filter, prime the epan_dissect_t with that
3318        filter. */
3319     if (cf->rfcode)
3320       epan_dissect_prime_dfilter(&edt, cf->rfcode);
3321     if (cf->dfcode)
3322       epan_dissect_prime_dfilter(&edt, cf->dfcode);
3323
3324     col_custom_prime_edt(&edt, &cf->cinfo);
3325
3326     /* We only need the columns if either
3327          1) some tap needs the columns
3328        or
3329          2) we're printing packet info but we're *not* verbose; in verbose
3330             mode, we print the protocol tree, not the protocol summary.
3331        or
3332          3) there is a column mapped as an individual field */
3333     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
3334       cinfo = &cf->cinfo;
3335     else
3336       cinfo = NULL;
3337
3338     frame_data_set_before_dissect(&fdata, &cf->elapsed_time,
3339                                   &ref, prev_dis);
3340     if (ref == &fdata) {
3341       ref_frame = fdata;
3342       ref = &ref_frame;
3343     }
3344
3345     epan_dissect_run_with_taps(&edt, whdr, frame_tvbuff_new(&fdata, pd), &fdata, cinfo);
3346
3347     /* Run the filters if we have them. */
3348     if (cf->rfcode)
3349       passed = dfilter_apply_edt(cf->rfcode, &edt);
3350     if (passed && cf->dfcode)
3351       passed = dfilter_apply_edt(cf->dfcode, &edt);
3352   }
3353
3354   if (passed) {
3355     frame_data_set_after_dissect(&fdata, &cum_bytes);
3356
3357     /* Process this packet. */
3358     if (print_packet_info) {
3359       /* We're printing packet information; print the information for
3360          this packet. */
3361       if (do_dissection)
3362         print_packet(cf, &edt);
3363       else
3364         print_packet(cf, NULL);
3365
3366       /* The ANSI C standard does not appear to *require* that a line-buffered
3367          stream be flushed to the host environment whenever a newline is
3368          written, it just says that, on such a stream, characters "are
3369          intended to be transmitted to or from the host environment as a
3370          block when a new-line character is encountered".
3371
3372          The Visual C++ 6.0 C implementation doesn't do what is intended;
3373          even if you set a stream to be line-buffered, it still doesn't
3374          flush the buffer at the end of every line.
3375
3376          So, if the "-l" flag was specified, we flush the standard output
3377          at the end of a packet.  This will do the right thing if we're
3378          printing packet summary lines, and, as we print the entire protocol
3379          tree for a single packet without waiting for anything to happen,
3380          it should be as good as line-buffered mode if we're printing
3381          protocol trees.  (The whole reason for the "-l" flag in either
3382          tcpdump or TShark is to allow the output of a live capture to
3383          be piped to a program or script and to have that script see the
3384          information for the packet as soon as it's printed, rather than
3385          having to wait until a standard I/O buffer fills up. */
3386       if (line_buffered)
3387         fflush(stdout);
3388
3389       if (ferror(stdout)) {
3390         show_print_file_io_error(errno);
3391         exit(2);
3392       }
3393     }
3394
3395     /* this must be set after print_packet() [bug #8160] */
3396     prev_dis_frame = fdata;
3397     prev_dis = &prev_dis_frame;
3398   }
3399
3400   prev_cap_frame = fdata;
3401   prev_cap = &prev_cap_frame;
3402
3403   if (do_dissection) {
3404     epan_dissect_cleanup(&edt);
3405     frame_data_destroy(&fdata);
3406   }
3407   return passed;
3408 }
3409
3410 static gboolean
3411 write_preamble(capture_file *cf)
3412 {
3413   switch (output_action) {
3414
3415   case WRITE_TEXT:
3416     return print_preamble(print_stream, cf ? cf->filename : NULL, wireshark_svnversion);
3417
3418   case WRITE_XML:
3419     if (print_details)
3420       write_pdml_preamble(stdout, cf ? cf->filename : NULL);
3421     else
3422       write_psml_preamble(stdout);
3423     return !ferror(stdout);
3424
3425   case WRITE_FIELDS:
3426     write_fields_preamble(output_fields, stdout);
3427     return !ferror(stdout);
3428
3429   default:
3430     g_assert_not_reached();
3431     return FALSE;
3432   }
3433 }
3434
3435 static char *
3436 get_line_buf(size_t len)
3437 {
3438   static char   *line_bufp    = NULL;
3439   static size_t  line_buf_len = 256;
3440   size_t         new_line_buf_len;
3441
3442   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
3443        new_line_buf_len *= 2)
3444     ;
3445   if (line_bufp == NULL) {
3446     line_buf_len = new_line_buf_len;
3447     line_bufp = (char *)g_malloc(line_buf_len + 1);
3448   } else {
3449     if (new_line_buf_len > line_buf_len) {
3450       line_buf_len = new_line_buf_len;
3451       line_bufp = (char *)g_realloc(line_bufp, line_buf_len + 1);
3452     }
3453   }
3454   return line_bufp;
3455 }
3456
3457 static gboolean
3458 print_columns(capture_file *cf)
3459 {
3460   char   *line_bufp;
3461   int     i;
3462   size_t  buf_offset;
3463   size_t  column_len;
3464
3465   line_bufp = get_line_buf(256);
3466   buf_offset = 0;
3467   *line_bufp = '\0';
3468   for (i = 0; i < cf->cinfo.num_cols; i++) {
3469     /* Skip columns not marked as visible. */
3470     if (!get_column_visible(i))
3471       continue;
3472     switch (cf->cinfo.col_fmt[i]) {
3473     case COL_NUMBER:
3474 #ifdef HAVE_LIBPCAP
3475       /*
3476        * Don't print this if we're doing a live capture from a network
3477        * interface - if we're doing a live capture, you won't be
3478        * able to look at the capture in the future (it's not being
3479        * saved anywhere), so the frame numbers are unlikely to be
3480        * useful.
3481        *
3482        * (XXX - it might be nice to be able to save and print at
3483        * the same time, sort of like an "Update list of packets
3484        * in real time" capture in Wireshark.)
3485        */
3486       if (global_capture_opts.ifaces->len > 0)
3487         continue;
3488 #endif
3489       column_len = strlen(cf->cinfo.col_data[i]);
3490       if (column_len < 3)
3491         column_len = 3;
3492       line_bufp = get_line_buf(buf_offset + column_len);
3493       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%3s", cf->cinfo.col_data[i]);
3494       break;
3495
3496     case COL_CLS_TIME:
3497     case COL_REL_TIME:
3498     case COL_ABS_TIME:
3499     case COL_ABS_DATE_TIME:
3500     case COL_UTC_TIME:
3501     case COL_UTC_DATE_TIME: /* XXX - wider */
3502       column_len = strlen(cf->cinfo.col_data[i]);
3503       if (column_len < 10)
3504         column_len = 10;
3505       line_bufp = get_line_buf(buf_offset + column_len);
3506       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%10s", cf->cinfo.col_data[i]);
3507       break;
3508
3509     case COL_DEF_SRC:
3510     case COL_RES_SRC:
3511     case COL_UNRES_SRC:
3512     case COL_DEF_DL_SRC:
3513     case COL_RES_DL_SRC:
3514     case COL_UNRES_DL_SRC:
3515     case COL_DEF_NET_SRC:
3516     case COL_RES_NET_SRC:
3517     case COL_UNRES_NET_SRC:
3518       column_len = strlen(cf->cinfo.col_data[i]);
3519       if (column_len < 12)
3520         column_len = 12;
3521       line_bufp = get_line_buf(buf_offset + column_len);
3522       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%12s", cf->cinfo.col_data[i]);
3523       break;
3524
3525     case COL_DEF_DST:
3526     case COL_RES_DST:
3527     case COL_UNRES_DST:
3528     case COL_DEF_DL_DST:
3529     case COL_RES_DL_DST:
3530     case COL_UNRES_DL_DST:
3531     case COL_DEF_NET_DST:
3532     case COL_RES_NET_DST:
3533     case COL_UNRES_NET_DST:
3534       column_len = strlen(cf->cinfo.col_data[i]);
3535       if (column_len < 12)
3536         column_len = 12;
3537       line_bufp = get_line_buf(buf_offset + column_len);
3538       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%-12s", cf->cinfo.col_data[i]);
3539       break;
3540
3541     default:
3542       column_len = strlen(cf->cinfo.col_data[i]);
3543       line_bufp = get_line_buf(buf_offset + column_len);
3544       g_strlcat(line_bufp + buf_offset, cf->cinfo.col_data[i], column_len + 1);
3545       break;
3546     }
3547     buf_offset += column_len;
3548     if (i != cf->cinfo.num_cols - 1) {
3549       /*
3550        * This isn't the last column, so we need to print a
3551        * separator between this column and the next.
3552        *
3553        * If we printed a network source and are printing a
3554        * network destination of the same type next, separate
3555        * them with " -> "; if we printed a network destination
3556        * and are printing a network source of the same type
3557        * next, separate them with " <- "; otherwise separate them
3558        * with a space.
3559        *
3560        * We add enough space to the buffer for " <- " or " -> ",
3561        * even if we're only adding " ".
3562        */
3563       line_bufp = get_line_buf(buf_offset + 4);
3564       switch (cf->cinfo.col_fmt[i]) {
3565
3566       case COL_DEF_SRC:
3567       case COL_RES_SRC:
3568       case COL_UNRES_SRC:
3569         switch (cf->cinfo.col_fmt[i + 1]) {
3570
3571         case COL_DEF_DST:
3572         case COL_RES_DST:
3573         case COL_UNRES_DST:
3574           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3575           buf_offset += 4;
3576           break;
3577
3578         default:
3579           g_strlcat(line_bufp + buf_offset, " ", 5);
3580           buf_offset += 1;
3581           break;
3582         }
3583         break;
3584
3585       case COL_DEF_DL_SRC:
3586       case COL_RES_DL_SRC:
3587       case COL_UNRES_DL_SRC:
3588         switch (cf->cinfo.col_fmt[i + 1]) {
3589
3590         case COL_DEF_DL_DST:
3591         case COL_RES_DL_DST:
3592         case COL_UNRES_DL_DST:
3593           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3594           buf_offset += 4;
3595           break;
3596
3597         default:
3598           g_strlcat(line_bufp + buf_offset, " ", 5);
3599           buf_offset += 1;
3600           break;
3601         }
3602         break;
3603
3604       case COL_DEF_NET_SRC:
3605       case COL_RES_NET_SRC:
3606       case COL_UNRES_NET_SRC:
3607         switch (cf->cinfo.col_fmt[i + 1]) {
3608
3609         case COL_DEF_NET_DST:
3610         case COL_RES_NET_DST:
3611         case COL_UNRES_NET_DST:
3612           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3613           buf_offset += 4;
3614           break;
3615
3616         default:
3617           g_strlcat(line_bufp + buf_offset, " ", 5);
3618           buf_offset += 1;
3619           break;
3620         }
3621         break;
3622
3623       case COL_DEF_DST:
3624       case COL_RES_DST:
3625       case COL_UNRES_DST:
3626         switch (cf->cinfo.col_fmt[i + 1]) {
3627
3628         case COL_DEF_SRC:
3629         case COL_RES_SRC:
3630         case COL_UNRES_SRC:
3631           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3632           buf_offset += 4;
3633           break;
3634
3635         default:
3636           g_strlcat(line_bufp + buf_offset, " ", 5);
3637           buf_offset += 1;
3638           break;
3639         }
3640         break;
3641
3642       case COL_DEF_DL_DST:
3643       case COL_RES_DL_DST:
3644       case COL_UNRES_DL_DST:
3645         switch (cf->cinfo.col_fmt[i + 1]) {
3646
3647         case COL_DEF_DL_SRC:
3648         case COL_RES_DL_SRC:
3649         case COL_UNRES_DL_SRC:
3650           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3651           buf_offset += 4;
3652           break;
3653
3654         default:
3655           g_strlcat(line_bufp + buf_offset, " ", 5);
3656           buf_offset += 1;
3657           break;
3658         }
3659         break;
3660
3661       case COL_DEF_NET_DST:
3662       case COL_RES_NET_DST:
3663       case COL_UNRES_NET_DST:
3664         switch (cf->cinfo.col_fmt[i + 1]) {
3665
3666         case COL_DEF_NET_SRC:
3667         case COL_RES_NET_SRC:
3668         case COL_UNRES_NET_SRC:
3669           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3670           buf_offset += 4;
3671           break;
3672
3673         default:
3674           g_strlcat(line_bufp + buf_offset, " ", 5);
3675           buf_offset += 1;
3676           break;
3677         }
3678         break;
3679
3680       default:
3681         g_strlcat(line_bufp + buf_offset, " ", 5);
3682         buf_offset += 1;
3683         break;
3684       }
3685     }
3686   }
3687   return print_line(print_stream, 0, line_bufp);
3688 }
3689
3690 static gboolean
3691 print_packet(capture_file *cf, epan_dissect_t *edt)
3692 {
3693   print_args_t print_args;
3694
3695   if (print_summary || output_fields_has_cols(output_fields)) {
3696     /* Just fill in the columns. */
3697     epan_dissect_fill_in_columns(edt, FALSE, TRUE);
3698
3699     if (print_summary) {
3700       /* Now print them. */
3701       switch (output_action) {
3702
3703       case WRITE_TEXT:
3704         if (!print_columns(cf))
3705           return FALSE;
3706         break;
3707
3708       case WRITE_XML:
3709         proto_tree_write_psml(edt, stdout);
3710         return !ferror(stdout);
3711       case WRITE_FIELDS: /*No non-verbose "fields" format */
3712         g_assert_not_reached();
3713         break;
3714       }
3715     }
3716   }
3717   if (print_details) {
3718     /* Print the information in the protocol tree. */
3719     switch (output_action) {
3720
3721     case WRITE_TEXT:
3722       /* Only initialize the fields that are actually used in proto_tree_print.
3723        * This is particularly important for .range, as that's heap memory which
3724        * we would otherwise have to g_free().
3725       print_args.to_file = TRUE;
3726       print_args.format = print_format;
3727       print_args.print_summary = print_summary;
3728       print_args.print_formfeed = FALSE;
3729       packet_range_init(&print_args.range, &cfile);
3730       */
3731       print_args.print_hex = print_hex;
3732       print_args.print_dissections = print_details ? print_dissections_expanded : print_dissections_none;
3733
3734       if (!proto_tree_print(&print_args, edt, print_stream))
3735         return FALSE;
3736       if (!print_hex) {
3737         if (!print_line(print_stream, 0, separator))
3738           return FALSE;
3739       }
3740       break;
3741
3742     case WRITE_XML:
3743       proto_tree_write_pdml(edt, stdout);
3744       printf("\n");
3745       return !ferror(stdout);
3746     case WRITE_FIELDS:
3747       proto_tree_write_fields(output_fields, edt, &cf->cinfo, stdout);
3748       printf("\n");
3749       return !ferror(stdout);
3750     }
3751   }
3752   if (print_hex) {
3753     if (print_summary || print_details) {
3754       if (!print_line(print_stream, 0, ""))
3755         return FALSE;
3756     }
3757     if (!print_hex_data(print_stream, edt))
3758       return FALSE;
3759     if (!print_line(print_stream, 0, separator))
3760       return FALSE;
3761   }
3762   return TRUE;
3763 }
3764
3765 static gboolean
3766 write_finale(void)
3767 {
3768   switch (output_action) {
3769
3770   case WRITE_TEXT:
3771     return print_finale(print_stream);
3772
3773   case WRITE_XML:
3774     if (print_details)
3775       write_pdml_finale(stdout);
3776     else
3777       write_psml_finale(stdout);
3778     return !ferror(stdout);
3779
3780   case WRITE_FIELDS:
3781     write_fields_finale(output_fields, stdout);
3782     return !ferror(stdout);
3783
3784   default:
3785     g_assert_not_reached();
3786     return FALSE;
3787   }
3788 }
3789
3790 cf_status_t
3791 cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
3792 {
3793   wtap  *wth;
3794   gchar *err_info;
3795   char   err_msg[2048+1];
3796
3797   wth = wtap_open_offline(fname, err, &err_info, perform_two_pass_analysis);
3798   if (wth == NULL)
3799     goto fail;
3800
3801   /* The open succeeded.  Fill in the information for this file. */
3802
3803   /* Create new epan session for dissection. */
3804   epan_free(cf->epan);
3805   cf->epan = tshark_epan_new(cf);
3806
3807   cf->wth = wth;
3808   cf->f_datalen = 0; /* not used, but set it anyway */
3809
3810   /* Set the file name because we need it to set the follow stream filter.
3811      XXX - is that still true?  We need it for other reasons, though,
3812      in any case. */
3813   cf->filename = g_strdup(fname);
3814
3815   /* Indicate whether it's a permanent or temporary file. */
3816   cf->is_tempfile = is_tempfile;
3817
3818   /* No user changes yet. */
3819   cf->unsaved_changes = FALSE;
3820
3821   cf->cd_t      = wtap_file_type(cf->wth);
3822   cf->count     = 0;
3823   cf->drops_known = FALSE;
3824   cf->drops     = 0;
3825   cf->snap      = wtap_snapshot_length(cf->wth);
3826   if (cf->snap == 0) {
3827     /* Snapshot length not known. */
3828     cf->has_snap = FALSE;
3829     cf->snap = WTAP_MAX_PACKET_SIZE;
3830   } else
3831     cf->has_snap = TRUE;
3832   nstime_set_zero(&cf->elapsed_time);
3833   ref = NULL;
3834   prev_dis = NULL;
3835   prev_cap = NULL;
3836
3837   cf->state = FILE_READ_IN_PROGRESS;
3838
3839   wtap_set_cb_new_ipv4(cf->wth, add_ipv4_name);
3840   wtap_set_cb_new_ipv6(cf->wth, (wtap_new_ipv6_callback_t) add_ipv6_name);
3841
3842   return CF_OK;
3843
3844 fail:
3845   g_snprintf(err_msg, sizeof err_msg,
3846              cf_open_error_message(*err, err_info, FALSE, cf->cd_t), fname);
3847   cmdarg_err("%s", err_msg);
3848   return CF_ERROR;
3849 }
3850
3851 static void
3852 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
3853 {
3854   char *save_file_string;
3855
3856   save_file_string = output_file_description(fname);
3857
3858   switch (err) {
3859
3860   case ENOSPC:
3861     cmdarg_err("Not all the packets could be written to the %s because there is "
3862                "no space left on the file system.",
3863                save_file_string);
3864     break;
3865
3866 #ifdef EDQUOT
3867   case EDQUOT:
3868     cmdarg_err("Not all the packets could be written to the %s because you are "
3869                "too close to, or over your disk quota.",
3870                save_file_string);
3871   break;
3872 #endif
3873
3874   case WTAP_ERR_CANT_CLOSE:
3875     cmdarg_err("The %s couldn't be closed for some unknown reason.",
3876                save_file_string);
3877     break;
3878
3879   case WTAP_ERR_SHORT_WRITE:
3880     cmdarg_err("Not all the packets could be written to the %s.",
3881                save_file_string);
3882     break;
3883
3884   default:
3885     if (is_close) {
3886       cmdarg_err("The %s could not be closed: %s.", save_file_string,
3887                  wtap_strerror(err));
3888     } else {
3889       cmdarg_err("An error occurred while writing to the %s: %s.",
3890                  save_file_string, wtap_strerror(err));
3891     }
3892     break;
3893   }
3894   g_free(save_file_string);
3895 }
3896
3897 static void
3898 show_print_file_io_error(int err)
3899 {
3900   switch (err) {
3901
3902   case ENOSPC:
3903     cmdarg_err("Not all the packets could be printed because there is "
3904 "no space left on the file system.");
3905     break;
3906
3907 #ifdef EDQUOT
3908   case EDQUOT:
3909     cmdarg_err("Not all the packets could be printed because you are "
3910 "too close to, or over your disk quota.");
3911   break;
3912 #endif
3913
3914   default:
3915     cmdarg_err("An error occurred while printing packets: %s.",
3916       g_strerror(err));
3917     break;
3918   }
3919 }
3920
3921 static const char *
3922 cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
3923                       int file_type)
3924 {
3925   const char *errmsg;
3926   static char errmsg_errno[1024+1];
3927
3928   if (err < 0) {
3929     /* Wiretap error. */
3930     switch (err) {
3931
3932     case WTAP_ERR_NOT_REGULAR_FILE:
3933       errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
3934       break;
3935
3936     case WTAP_ERR_RANDOM_OPEN_PIPE:
3937       /* Seen only when opening a capture file for reading. */
3938       errmsg = "The file \"%s\" is a pipe or FIFO; TShark can't read pipe or FIFO files in two-pass mode.";
3939       break;
3940
3941     case WTAP_ERR_FILE_UNKNOWN_FORMAT:
3942       /* Seen only when opening a capture file for reading. */
3943       errmsg = "The file \"%s\" isn't a capture file in a format TShark understands.";
3944       break;
3945
3946     case WTAP_ERR_UNSUPPORTED:
3947       /* Seen only when opening a capture file for reading. */
3948       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3949                "The file \"%%s\" isn't a capture file in a format TShark understands.\n"
3950                "(%s)", err_info);
3951       g_free(err_info);
3952       errmsg = errmsg_errno;
3953       break;
3954
3955     case WTAP_ERR_CANT_WRITE_TO_PIPE:
3956       /* Seen only when opening a capture file for writing. */
3957       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3958                  "The file \"%%s\" is a pipe, and \"%s\" capture files can't be "
3959                  "written to a pipe.", wtap_file_type_short_string(file_type));
3960       errmsg = errmsg_errno;
3961       break;
3962
3963     case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
3964       /* Seen only when opening a capture file for writing. */
3965       errmsg = "TShark doesn't support writing capture files in that format.";
3966       break;
3967
3968     case WTAP_ERR_UNSUPPORTED_ENCAP:
3969       if (for_writing) {
3970         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3971                    "TShark can't save this capture as a \"%s\" file.",
3972                    wtap_file_type_short_string(file_type));
3973       } else {
3974         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3975                  "The file \"%%s\" is a capture for a network type that TShark doesn't support.\n"
3976                  "(%s)", err_info);
3977         g_free(err_info);
3978       }
3979       errmsg = errmsg_errno;
3980       break;
3981
3982     case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
3983       if (for_writing) {
3984         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3985                    "TShark can't save this capture as a \"%s\" file.",
3986                    wtap_file_type_short_string(file_type));
3987         errmsg = errmsg_errno;
3988       } else
3989         errmsg = "The file \"%s\" is a capture for a network type that TShark doesn't support.";
3990       break;
3991
3992     case WTAP_ERR_BAD_FILE:
3993       /* Seen only when opening a capture file for reading. */
3994       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3995                "The file \"%%s\" appears to be damaged or corrupt.\n"
3996                "(%s)", err_info);
3997       g_free(err_info);
3998       errmsg = errmsg_errno;
3999       break;
4000
4001     case WTAP_ERR_CANT_OPEN:
4002       if (for_writing)
4003         errmsg = "The file \"%s\" could not be created for some unknown reason.";
4004       else
4005         errmsg = "The file \"%s\" could not be opened for some unknown reason.";
4006       break;
4007
4008     case WTAP_ERR_SHORT_READ:
4009       errmsg = "The file \"%s\" appears to have been cut short"
4010                " in the middle of a packet or other data.";
4011       break;
4012
4013     case WTAP_ERR_SHORT_WRITE:
4014       errmsg = "A full header couldn't be written to the file \"%s\".";
4015       break;
4016
4017     case WTAP_ERR_COMPRESSION_NOT_SUPPORTED:
4018       errmsg = "This file type cannot be written as a compressed file.";
4019       break;
4020
4021     case WTAP_ERR_DECOMPRESS:
4022       /* Seen only when opening a capture file for reading. */
4023       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4024                  "The compressed file \"%%s\" appears to be damaged or corrupt.\n"
4025                  "(%s)", err_info);
4026       g_free(err_info);
4027       errmsg = errmsg_errno;
4028       break;
4029
4030     default:
4031       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4032                  "The file \"%%s\" could not be %s: %s.",
4033                  for_writing ? "created" : "opened",
4034                  wtap_strerror(err));
4035       errmsg = errmsg_errno;
4036       break;
4037     }
4038   } else
4039     errmsg = file_open_error_message(err, for_writing);
4040   return errmsg;
4041 }
4042
4043 /*
4044  * Open/create errors are reported with an console message in TShark.
4045  */
4046 static void
4047 open_failure_message(const char *filename, int err, gboolean for_writing)
4048 {
4049   fprintf(stderr, "tshark: ");
4050   fprintf(stderr, file_open_error_message(err, for_writing), filename);
4051   fprintf(stderr, "\n");
4052 }
4053
4054
4055 /*
4056  * General errors are reported with an console message in TShark.
4057  */
4058 static void
4059 failure_message(const char *msg_format, va_list ap)
4060 {
4061   fprintf(stderr, "tshark: ");
4062   vfprintf(stderr, msg_format, ap);
4063   fprintf(stderr, "\n");
4064 }
4065
4066 /*
4067  * Read errors are reported with an console message in TShark.
4068  */
4069 static void
4070 read_failure_message(const char *filename, int err)
4071 {
4072   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
4073           filename, g_strerror(err));
4074 }
4075
4076 /*
4077  * Write errors are reported with an console message in TShark.
4078  */
4079 static void
4080 write_failure_message(const char *filename, int err)
4081 {
4082   cmdarg_err("An error occurred while writing to the file \"%s\": %s.",
4083           filename, g_strerror(err));
4084 }
4085
4086 /*
4087  * Report an error in command-line arguments.
4088  */
4089 void
4090 cmdarg_err(const char *fmt, ...)
4091 {
4092   va_list ap;
4093
4094   va_start(ap, fmt);
4095   failure_message(fmt, ap);
4096   va_end(ap);
4097 }
4098
4099 /*
4100  * Report additional information for an error in command-line arguments.
4101  */
4102 void
4103 cmdarg_err_cont(const char *fmt, ...)
4104 {
4105   va_list ap;
4106
4107   va_start(ap, fmt);
4108   vfprintf(stderr, fmt, ap);
4109   fprintf(stderr, "\n");
4110   va_end(ap);
4111 }
4112
4113
4114 /*
4115  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
4116  *
4117  * Local variables:
4118  * c-basic-offset: 2
4119  * tab-width: 8
4120  * indent-tabs-mode: nil
4121  * End:
4122  *
4123  * vi: set shiftwidth=2 tabstop=8 expandtab:
4124  * :indentSize=2:tabSize=8:noTabs=true:
4125  */