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