tshark.c

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