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