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