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