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 (perform_two_pass_analysis) {
1787         /* Two-pass analysis doesn't work with live capture since it requires us
1788          * to buffer packets until we've read all of them, but a live capture
1789          * has no useful/meaningful definition of "all" */
1790         cmdarg_err("Live captures do not support two-pass analysis.");
1791         return 1;
1792       }
1793
1794       if (global_capture_opts.saving_to_file) {
1795         /* They specified a "-w" flag, so we'll be saving to a capture file. */
1796
1797         /* When capturing, we only support writing pcap or pcap-ng format. */
1798         if (out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAP &&
1799             out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAPNG) {
1800           cmdarg_err("Live captures can only be saved in libpcap format.");
1801           return 1;
1802         }
1803         if (global_capture_opts.capture_comment &&
1804             out_file_type != WTAP_FILE_TYPE_SUBTYPE_PCAPNG) {
1805           cmdarg_err("A capture comment can only be written to a pcapng file.");
1806           return 1;
1807         }
1808         if (global_capture_opts.multi_files_on) {
1809           /* Multiple-file mode doesn't work under certain conditions:
1810              a) it doesn't work if you're writing to the standard output;
1811              b) it doesn't work if you're writing to a pipe;
1812           */
1813           if (strcmp(global_capture_opts.save_file, "-") == 0) {
1814             cmdarg_err("Multiple capture files requested, but "
1815               "the capture is being written to the standard output.");
1816             return 1;
1817           }
1818           if (global_capture_opts.output_to_pipe) {
1819             cmdarg_err("Multiple capture files requested, but "
1820               "the capture file is a pipe.");
1821             return 1;
1822           }
1823           if (!global_capture_opts.has_autostop_filesize &&
1824               !global_capture_opts.has_file_duration) {
1825             cmdarg_err("Multiple capture files requested, but "
1826               "no maximum capture file size or duration was specified.");
1827             return 1;
1828           }
1829         }
1830         /* Currently, we don't support read or display filters when capturing
1831            and saving the packets. */
1832         if (rfilter != NULL) {
1833           cmdarg_err("Read filters aren't supported when capturing and saving the captured packets.");
1834           return 1;
1835         }
1836         if (dfilter != NULL) {
1837           cmdarg_err("Display filters aren't supported when capturing and saving the captured packets.");
1838           return 1;
1839         }
1840       } else {
1841         /* They didn't specify a "-w" flag, so we won't be saving to a
1842            capture file.  Check for options that only make sense if
1843            we're saving to a file. */
1844         if (global_capture_opts.has_autostop_filesize) {
1845           cmdarg_err("Maximum capture file size specified, but "
1846            "capture isn't being saved to a file.");
1847           return 1;
1848         }
1849         if (global_capture_opts.multi_files_on) {
1850           cmdarg_err("Multiple capture files requested, but "
1851             "the capture isn't being saved to a file.");
1852           return 1;
1853         }
1854         if (global_capture_opts.capture_comment) {
1855           cmdarg_err("A capture comment was specified, but "
1856             "the capture isn't being saved to a file.");
1857           return 1;
1858         }
1859       }
1860     }
1861   }
1862 #endif
1863
1864 #ifdef _WIN32
1865   /* Start windows sockets */
1866   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
1867 #endif /* _WIN32 */
1868
1869   /* Notify all registered modules that have had any of their preferences
1870      changed either from one of the preferences file or from the command
1871      line that their preferences have changed. */
1872   prefs_apply_all();
1873
1874   /* At this point MATE will have registered its field array so we can
1875      have a tap filter with one of MATE's late-registered fields as part
1876      of the filter.  We can now process all the "-z" arguments. */
1877   start_requested_stats();
1878
1879 #ifdef HAVE_LIBPCAP
1880   /* We currently don't support taps, or printing dissected packets,
1881      if we're writing to a pipe. */
1882   if (global_capture_opts.saving_to_file &&
1883       global_capture_opts.output_to_pipe) {
1884     if (tap_listeners_require_dissection()) {
1885       cmdarg_err("Taps aren't supported when saving to a pipe.");
1886       return 1;
1887     }
1888     if (print_packet_info) {
1889       cmdarg_err("Printing dissected packets isn't supported when saving to a pipe.");
1890       return 1;
1891     }
1892   }
1893 #endif
1894
1895   /* disabled protocols as per configuration file */
1896   if (gdp_path == NULL && dp_path == NULL) {
1897     set_disabled_protos_list();
1898   }
1899
1900   /* Build the column format array */
1901   build_column_format_array(&cfile.cinfo, prefs_p->num_cols, TRUE);
1902
1903 #ifdef HAVE_LIBPCAP
1904   capture_opts_trim_snaplen(&global_capture_opts, MIN_PACKET_SIZE);
1905   capture_opts_trim_ring_num_files(&global_capture_opts);
1906 #endif
1907
1908   if (rfilter != NULL) {
1909     if (!dfilter_compile(rfilter, &rfcode)) {
1910       cmdarg_err("%s", dfilter_error_msg);
1911       epan_cleanup();
1912 #ifdef HAVE_PCAP_OPEN_DEAD
1913       {
1914         pcap_t *pc;
1915
1916         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1917         if (pc != NULL) {
1918           if (pcap_compile(pc, &fcode, rfilter, 0, 0) != -1) {
1919             cmdarg_err_cont(
1920               "  Note: That read filter code looks like a valid capture filter;\n"
1921               "        maybe you mixed them up?");
1922           }
1923           pcap_close(pc);
1924         }
1925       }
1926 #endif
1927       return 2;
1928     }
1929   }
1930   cfile.rfcode = rfcode;
1931
1932   if (dfilter != NULL) {
1933     if (!dfilter_compile(dfilter, &dfcode)) {
1934       cmdarg_err("%s", dfilter_error_msg);
1935       epan_cleanup();
1936 #ifdef HAVE_PCAP_OPEN_DEAD
1937       {
1938         pcap_t *pc;
1939
1940         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1941         if (pc != NULL) {
1942           if (pcap_compile(pc, &fcode, dfilter, 0, 0) != -1) {
1943             cmdarg_err_cont(
1944               "  Note: That display filter code looks like a valid capture filter;\n"
1945               "        maybe you mixed them up?");
1946           }
1947           pcap_close(pc);
1948         }
1949       }
1950 #endif
1951       return 2;
1952     }
1953   }
1954   cfile.dfcode = dfcode;
1955
1956   if (print_packet_info) {
1957     /* If we're printing as text or PostScript, we have
1958        to create a print stream. */
1959     if (output_action == WRITE_TEXT) {
1960       switch (print_format) {
1961
1962       case PR_FMT_TEXT:
1963         print_stream = print_stream_text_stdio_new(stdout);
1964         break;
1965
1966       case PR_FMT_PS:
1967         print_stream = print_stream_ps_stdio_new(stdout);
1968         break;
1969
1970       default:
1971         g_assert_not_reached();
1972       }
1973     }
1974   }
1975
1976   /* We have to dissect each packet if:
1977
1978         we're printing information about each packet;
1979
1980         we're using a read filter on the packets;
1981
1982         we're using a display filter on the packets;
1983
1984         we're using any taps that need dissection. */
1985   do_dissection = print_packet_info || rfcode || dfcode || tap_listeners_require_dissection();
1986
1987   if (cf_name) {
1988     /*
1989      * We're reading a capture file.
1990      */
1991
1992     /*
1993      * Immediately relinquish any special privileges we have; we must not
1994      * be allowed to read any capture files the user running TShark
1995      * can't open.
1996      */
1997     relinquish_special_privs_perm();
1998     print_current_user();
1999
2000     if (cf_open(&cfile, cf_name, FALSE, &err) != CF_OK) {
2001       epan_cleanup();
2002       return 2;
2003     }
2004
2005     /* Set timestamp precision; there should arguably be a command-line
2006        option to let the user set this. */
2007     switch(wtap_file_tsprecision(cfile.wth)) {
2008     case(WTAP_FILE_TSPREC_SEC):
2009       timestamp_set_precision(TS_PREC_AUTO_SEC);
2010       break;
2011     case(WTAP_FILE_TSPREC_DSEC):
2012       timestamp_set_precision(TS_PREC_AUTO_DSEC);
2013       break;
2014     case(WTAP_FILE_TSPREC_CSEC):
2015       timestamp_set_precision(TS_PREC_AUTO_CSEC);
2016       break;
2017     case(WTAP_FILE_TSPREC_MSEC):
2018       timestamp_set_precision(TS_PREC_AUTO_MSEC);
2019       break;
2020     case(WTAP_FILE_TSPREC_USEC):
2021       timestamp_set_precision(TS_PREC_AUTO_USEC);
2022       break;
2023     case(WTAP_FILE_TSPREC_NSEC):
2024       timestamp_set_precision(TS_PREC_AUTO_NSEC);
2025       break;
2026     default:
2027       g_assert_not_reached();
2028     }
2029
2030     /* Process the packets in the file */
2031     TRY {
2032 #ifdef HAVE_LIBPCAP
2033       err = load_cap_file(&cfile, global_capture_opts.save_file, out_file_type, out_file_name_res,
2034           global_capture_opts.has_autostop_packets ? global_capture_opts.autostop_packets : 0,
2035           global_capture_opts.has_autostop_filesize ? global_capture_opts.autostop_filesize : 0);
2036 #else
2037       err = load_cap_file(&cfile, NULL, out_file_type, out_file_name_res, 0, 0);
2038 #endif
2039     }
2040     CATCH(OutOfMemoryError) {
2041       fprintf(stderr,
2042               "Out Of Memory!\n"
2043               "\n"
2044               "Sorry, but TShark has to terminate now!\n"
2045               "\n"
2046               "Some infos / workarounds can be found at:\n"
2047               "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2048       err = ENOMEM;
2049     }
2050     ENDTRY;
2051     if (err != 0) {
2052       /* We still dump out the results of taps, etc., as we might have
2053          read some packets; however, we exit with an error status. */
2054       exit_status = 2;
2055     }
2056   } else {
2057     /* No capture file specified, so we're supposed to do a live capture
2058        or get a list of link-layer types for a live capture device;
2059        do we have support for live captures? */
2060 #ifdef HAVE_LIBPCAP
2061     /* if no interface was specified, pick a default */
2062     exit_status = capture_opts_default_iface_if_necessary(&global_capture_opts,
2063         ((prefs_p->capture_device) && (*prefs_p->capture_device != '\0')) ? get_if_name(prefs_p->capture_device) : NULL);
2064     if (exit_status != 0)
2065         return exit_status;
2066
2067     /* if requested, list the link layer types and exit */
2068     if (list_link_layer_types) {
2069         guint i;
2070
2071         /* Get the list of link-layer types for the capture devices. */
2072         for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2073           interface_options  interface_opts;
2074           if_capabilities_t *caps;
2075
2076           interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2077           caps = capture_get_if_capabilities(interface_opts.name, interface_opts.monitor_mode, &err_str, NULL);
2078           if (caps == NULL) {
2079             cmdarg_err("%s", err_str);
2080             g_free(err_str);
2081             return 2;
2082           }
2083           if (caps->data_link_types == NULL) {
2084             cmdarg_err("The capture device \"%s\" has no data link types.", interface_opts.name);
2085             return 2;
2086           }
2087           capture_opts_print_if_capabilities(caps, interface_opts.name, interface_opts.monitor_mode);
2088           free_if_capabilities(caps);
2089         }
2090         return 0;
2091     }
2092
2093     /*
2094      * If the standard error isn't a terminal, don't print packet counts,
2095      * as they won't show up on the user's terminal and they'll get in
2096      * the way of error messages in the file (to which we assume the
2097      * standard error was redirected; if it's redirected to the null
2098      * device, there's no point in printing packet counts anyway).
2099      *
2100      * Otherwise, if we're printing packet information and the standard
2101      * output is a terminal (which we assume means the standard output and
2102      * error are going to the same terminal), don't print packet counts,
2103      * as they'll get in the way of the packet information.
2104      *
2105      * Otherwise, if the user specified -q, don't print packet counts.
2106      *
2107      * Otherwise, print packet counts.
2108      *
2109      * XXX - what if the user wants to do a live capture, doesn't want
2110      * to save it to a file, doesn't want information printed for each
2111      * packet, does want some "-z" statistic, and wants packet counts
2112      * so they know whether they're seeing any packets?  -q will
2113      * suppress the information printed for each packet, but it'll
2114      * also suppress the packet counts.
2115      */
2116     if (!isatty(fileno(stderr)))
2117       print_packet_counts = FALSE;
2118     else if (print_packet_info && isatty(fileno(stdout)))
2119       print_packet_counts = FALSE;
2120     else if (quiet)
2121       print_packet_counts = FALSE;
2122     else
2123       print_packet_counts = TRUE;
2124
2125     if (print_packet_info) {
2126       if (!write_preamble(NULL)) {
2127         show_print_file_io_error(errno);
2128         return 2;
2129       }
2130     }
2131
2132     /* For now, assume libpcap gives microsecond precision. */
2133     timestamp_set_precision(TS_PREC_AUTO_USEC);
2134
2135     /*
2136      * XXX - this returns FALSE if an error occurred, but it also
2137      * returns FALSE if the capture stops because a time limit
2138      * was reached (and possibly other limits), so we can't assume
2139      * it means an error.
2140      *
2141      * The capture code is a bit twisty, so it doesn't appear to
2142      * be an easy fix.  We just ignore the return value for now.
2143      * Instead, pass on the exit status from the capture child.
2144      */
2145     capture();
2146     exit_status = global_capture_session.fork_child_status;
2147
2148     if (print_packet_info) {
2149       if (!write_finale()) {
2150         err = errno;
2151         show_print_file_io_error(err);
2152       }
2153     }
2154 #else
2155     /* No - complain. */
2156     cmdarg_err("This version of TShark was not built with support for capturing packets.");
2157     return 2;
2158 #endif
2159   }
2160
2161   g_free(cf_name);
2162
2163   if (cfile.frames != NULL) {
2164     free_frame_data_sequence(cfile.frames);
2165     cfile.frames = NULL;
2166   }
2167
2168   draw_tap_listeners(TRUE);
2169   funnel_dump_all_text_windows();
2170   epan_free(cfile.epan);
2171   epan_cleanup();
2172
2173   output_fields_free(output_fields);
2174   output_fields = NULL;
2175
2176   return exit_status;
2177 }
2178
2179 /*#define USE_BROKEN_G_MAIN_LOOP*/
2180
2181 #ifdef USE_BROKEN_G_MAIN_LOOP
2182   GMainLoop *loop;
2183 #else
2184   gboolean loop_running = FALSE;
2185 #endif
2186   guint32 packet_count = 0;
2187
2188
2189 /* XXX - move to the right position / file */
2190 /* read from a pipe (callback) */
2191 typedef gboolean (*pipe_input_cb_t) (gint source, gpointer user_data);
2192
2193 typedef struct pipe_input_tag {
2194   gint             source;
2195   gpointer         user_data;
2196   int             *child_process;
2197   pipe_input_cb_t  input_cb;
2198   guint            pipe_input_id;
2199 #ifdef _WIN32
2200   GMutex          *callback_running;
2201 #endif
2202 } pipe_input_t;
2203
2204 static pipe_input_t pipe_input;
2205
2206 #ifdef _WIN32
2207 /* The timer has expired, see if there's stuff to read from the pipe,
2208    if so, do the callback */
2209 static gint
2210 pipe_timer_cb(gpointer data)
2211 {
2212   HANDLE        handle;
2213   DWORD         avail        = 0;
2214   gboolean      result;
2215   DWORD         childstatus;
2216   pipe_input_t *pipe_input_p = data;
2217   gint          iterations   = 0;
2218
2219   g_mutex_lock (pipe_input_p->callback_running);
2220
2221   /* try to read data from the pipe only 5 times, to avoid blocking */
2222   while(iterations < 5) {
2223     /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: new iteration");*/
2224
2225     /* Oddly enough although Named pipes don't work on win9x,
2226        PeekNamedPipe does !!! */
2227     handle = (HANDLE) _get_osfhandle (pipe_input_p->source);
2228     result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
2229
2230     /* Get the child process exit status */
2231     GetExitCodeProcess((HANDLE)*(pipe_input_p->child_process),
2232                        &childstatus);
2233
2234     /* If the Peek returned an error, or there are bytes to be read
2235        or the childwatcher thread has terminated then call the normal
2236        callback */
2237     if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
2238
2239       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: data avail");*/
2240
2241       /* And call the real handler */
2242       if (!pipe_input_p->input_cb(pipe_input_p->source, pipe_input_p->user_data)) {
2243         g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
2244         /* pipe closed, return false so that the timer is stopped */
2245         g_mutex_unlock (pipe_input_p->callback_running);
2246         return FALSE;
2247       }
2248     }
2249     else {
2250       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: no data avail");*/
2251       /* No data, stop now */
2252       break;
2253     }
2254
2255     iterations++;
2256   }
2257
2258   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: finished with iterations: %u, new timer", iterations);*/
2259
2260   g_mutex_unlock (pipe_input_p->callback_running);
2261
2262   /* we didn't stopped the timer, so let it run */
2263   return TRUE;
2264 }
2265 #endif
2266
2267
2268 void
2269 pipe_input_set_handler(gint source, gpointer user_data, int *child_process, pipe_input_cb_t input_cb)
2270 {
2271
2272   pipe_input.source         = source;
2273   pipe_input.child_process  = child_process;
2274   pipe_input.user_data      = user_data;
2275   pipe_input.input_cb       = input_cb;
2276
2277 #ifdef _WIN32
2278 #if GLIB_CHECK_VERSION(2,31,0)
2279   pipe_input.callback_running = g_malloc(sizeof(GMutex));
2280   g_mutex_init(pipe_input.callback_running);
2281 #else
2282   pipe_input.callback_running = g_mutex_new();
2283 #endif
2284   /* Tricky to use pipes in win9x, as no concept of wait.  NT can
2285      do this but that doesn't cover all win32 platforms.  GTK can do
2286      this but doesn't seem to work over processes.  Attempt to do
2287      something similar here, start a timer and check for data on every
2288      timeout. */
2289   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
2290   pipe_input.pipe_input_id = g_timeout_add(200, pipe_timer_cb, &pipe_input);
2291 #endif
2292 }
2293
2294 static const nstime_t *
2295 tshark_get_frame_ts(void *data, guint32 frame_num)
2296 {
2297   capture_file *cf = (capture_file *) data;
2298
2299   if (ref && ref->num == frame_num)
2300     return &ref->abs_ts;
2301
2302   if (prev_dis && prev_dis->num == frame_num)
2303     return &prev_dis->abs_ts;
2304
2305   if (prev_cap && prev_cap->num == frame_num)
2306     return &prev_cap->abs_ts;
2307
2308   if (cf->frames) {
2309      frame_data *fd = frame_data_sequence_find(cf->frames, frame_num);
2310
2311      return (fd) ? &fd->abs_ts : NULL;
2312   }
2313
2314   return NULL;
2315 }
2316
2317 static epan_t *
2318 tshark_epan_new(capture_file *cf)
2319 {
2320   epan_t *epan = epan_new();
2321
2322   epan->data = cf;
2323   epan->get_frame_ts = tshark_get_frame_ts;
2324   epan->get_interface_name = cap_file_get_interface_name;
2325   epan->get_user_comment = NULL;
2326
2327   return epan;
2328 }
2329
2330 #ifdef HAVE_LIBPCAP
2331 static gboolean
2332 capture(void)
2333 {
2334   gboolean          ret;
2335   guint             i;
2336   GString          *str = g_string_new("");
2337 #ifdef USE_TSHARK_SELECT
2338   fd_set            readfds;
2339 #endif
2340 #ifndef _WIN32
2341   struct sigaction  action, oldaction;
2342 #endif
2343
2344   /*
2345    * XXX - dropping privileges is still required, until code cleanup is done
2346    *
2347    * remove all dependencies to pcap specific code and using only dumpcap is almost done.
2348    * when it's done, we don't need special privileges to run tshark at all,
2349    * therefore we don't need to drop these privileges
2350    * The only thing we might want to keep is a warning if tshark is run as root,
2351    * as it's no longer necessary and potentially dangerous.
2352    *
2353    * THE FOLLOWING IS THE FORMER COMMENT WHICH IS NO LONGER REALLY VALID:
2354    * We've opened the capture device, so we shouldn't need any special
2355    * privileges any more; relinquish those privileges.
2356    *
2357    * XXX - if we have saved set-user-ID support, we should give up those
2358    * privileges immediately, and then reclaim them long enough to get
2359    * a list of network interfaces and to open one, and then give them
2360    * up again, so that stuff we do while processing the argument list,
2361    * reading the user's preferences, loading and starting plugins
2362    * (especially *user* plugins), etc. is done with the user's privileges,
2363    * not special privileges.
2364    */
2365   relinquish_special_privs_perm();
2366   print_current_user();
2367
2368   /* Create new dissection section. */
2369   epan_free(cfile.epan);
2370   cfile.epan = tshark_epan_new(&cfile);
2371
2372 #ifdef _WIN32
2373   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
2374   SetConsoleCtrlHandler(capture_cleanup, TRUE);
2375 #else /* _WIN32 */
2376   /* Catch SIGINT and SIGTERM and, if we get either of them,
2377      clean up and exit.  If SIGHUP isn't being ignored, catch
2378      it too and, if we get it, clean up and exit.
2379
2380      We restart any read that was in progress, so that it doesn't
2381      disrupt reading from the sync pipe.  The signal handler tells
2382      the capture child to finish; it will report that it finished,
2383      or will exit abnormally, so  we'll stop reading from the sync
2384      pipe, pick up the exit status, and quit. */
2385   memset(&action, 0, sizeof(action));
2386   action.sa_handler = capture_cleanup;
2387   action.sa_flags = SA_RESTART;
2388   sigemptyset(&action.sa_mask);
2389   sigaction(SIGTERM, &action, NULL);
2390   sigaction(SIGINT, &action, NULL);
2391   sigaction(SIGHUP, NULL, &oldaction);
2392   if (oldaction.sa_handler == SIG_DFL)
2393     sigaction(SIGHUP, &action, NULL);
2394
2395 #ifdef SIGINFO
2396   /* Catch SIGINFO and, if we get it and we're capturing to a file in
2397      quiet mode, report the number of packets we've captured.
2398
2399      Again, restart any read that was in progress, so that it doesn't
2400      disrupt reading from the sync pipe. */
2401   action.sa_handler = report_counts_siginfo;
2402   action.sa_flags = SA_RESTART;
2403   sigemptyset(&action.sa_mask);
2404   sigaction(SIGINFO, &action, NULL);
2405 #endif /* SIGINFO */
2406 #endif /* _WIN32 */
2407
2408   global_capture_session.state = CAPTURE_PREPARING;
2409
2410   /* Let the user know which interfaces were chosen. */
2411   for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2412     interface_options interface_opts;
2413
2414     interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2415     interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
2416     global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
2417     g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
2418   }
2419 #ifdef _WIN32
2420   if (global_capture_opts.ifaces->len < 2)
2421 #else
2422   if (global_capture_opts.ifaces->len < 4)
2423 #endif
2424   {
2425     for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2426       interface_options interface_opts;
2427
2428       interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2429       if (i > 0) {
2430           if (global_capture_opts.ifaces->len > 2) {
2431               g_string_append_printf(str, ",");
2432           }
2433           g_string_append_printf(str, " ");
2434           if (i == global_capture_opts.ifaces->len - 1) {
2435               g_string_append_printf(str, "and ");
2436           }
2437       }
2438       g_string_append_printf(str, "'%s'", interface_opts.descr);
2439     }
2440   } else {
2441     g_string_append_printf(str, "%u interfaces", global_capture_opts.ifaces->len);
2442   }
2443   if (really_quiet == FALSE)
2444     fprintf(stderr, "Capturing on %s\n", str->str);
2445   fflush(stderr);
2446   g_string_free(str, TRUE);
2447
2448   ret = sync_pipe_start(&global_capture_opts, &global_capture_session, NULL);
2449
2450   if (!ret)
2451     return FALSE;
2452
2453   /* the actual capture loop
2454    *
2455    * XXX - glib doesn't seem to provide any event based loop handling.
2456    *
2457    * XXX - for whatever reason,
2458    * calling g_main_loop_new() ends up in 100% cpu load.
2459    *
2460    * But that doesn't matter: in UNIX we can use select() to find an input
2461    * source with something to do.
2462    *
2463    * But that doesn't matter because we're in a CLI (that doesn't need to
2464    * update a GUI or something at the same time) so it's OK if we block
2465    * trying to read from the pipe.
2466    *
2467    * So all the stuff in USE_TSHARK_SELECT could be removed unless I'm
2468    * wrong (but I leave it there in case I am...).
2469    */
2470
2471 #ifdef USE_TSHARK_SELECT
2472   FD_ZERO(&readfds);
2473   FD_SET(pipe_input.source, &readfds);
2474 #endif
2475
2476   loop_running = TRUE;
2477
2478   TRY
2479   {
2480     while (loop_running)
2481     {
2482 #ifdef USE_TSHARK_SELECT
2483       ret = select(pipe_input.source+1, &readfds, NULL, NULL, NULL);
2484
2485       if (ret == -1)
2486       {
2487         perror("select()");
2488         return TRUE;
2489       } else if (ret == 1) {
2490 #endif
2491         /* Call the real handler */
2492         if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
2493           g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
2494           return FALSE;
2495         }
2496 #ifdef USE_TSHARK_SELECT
2497       }
2498 #endif
2499     }
2500   }
2501   CATCH(OutOfMemoryError) {
2502     fprintf(stderr,
2503             "Out Of Memory!\n"
2504             "\n"
2505             "Sorry, but TShark has to terminate now!\n"
2506             "\n"
2507             "Some infos / workarounds can be found at:\n"
2508             "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2509     exit(1);
2510   }
2511   ENDTRY;
2512   return TRUE;
2513 }
2514
2515 /* capture child detected an error */
2516 void
2517 capture_input_error_message(capture_session *cap_session _U_, char *error_msg, char *secondary_error_msg)
2518 {
2519   cmdarg_err("%s", error_msg);
2520   cmdarg_err_cont("%s", secondary_error_msg);
2521 }
2522
2523
2524 /* capture child detected an capture filter related error */
2525 void
2526 capture_input_cfilter_error_message(capture_session *cap_session, guint i, char *error_message)
2527 {
2528   capture_options *capture_opts = cap_session->capture_opts;
2529   dfilter_t         *rfcode = NULL;
2530   interface_options  interface_opts;
2531
2532   g_assert(i < capture_opts->ifaces->len);
2533   interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
2534
2535   if (dfilter_compile(interface_opts.cfilter, &rfcode) && rfcode != NULL) {
2536     cmdarg_err(
2537       "Invalid capture filter \"%s\" for interface '%s'!\n"
2538       "\n"
2539       "That string looks like a valid display filter; however, it isn't a valid\n"
2540       "capture filter (%s).\n"
2541       "\n"
2542       "Note that display filters and capture filters don't have the same syntax,\n"
2543       "so you can't use most display filter expressions as capture filters.\n"
2544       "\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     dfilter_free(rfcode);
2548   } else {
2549     cmdarg_err(
2550       "Invalid capture filter \"%s\" for interface '%s'!\n"
2551       "\n"
2552       "That string isn't a valid capture filter (%s).\n"
2553       "See the User's Guide for a description of the capture filter syntax.",
2554       interface_opts.cfilter, interface_opts.descr, error_message);
2555   }
2556 }
2557
2558
2559 /* capture child tells us we have a new (or the first) capture file */
2560 gboolean
2561 capture_input_new_file(capture_session *cap_session, gchar *new_file)
2562 {
2563   capture_options *capture_opts = cap_session->capture_opts;
2564   gboolean is_tempfile;
2565   int      err;
2566
2567   if (cap_session->state == CAPTURE_PREPARING) {
2568     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!");
2569   }
2570   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
2571
2572   g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
2573
2574   /* free the old filename */
2575   if (capture_opts->save_file != NULL) {
2576
2577     /* we start a new capture file, close the old one (if we had one before) */
2578     if ( ((capture_file *) cap_session->cf)->state != FILE_CLOSED) {
2579       if ( ((capture_file *) cap_session->cf)->wth != NULL) {
2580         wtap_close(((capture_file *) cap_session->cf)->wth);
2581         ((capture_file *) cap_session->cf)->wth = NULL;
2582       }
2583       ((capture_file *) cap_session->cf)->state = FILE_CLOSED;
2584     }
2585
2586     g_free(capture_opts->save_file);
2587     is_tempfile = FALSE;
2588   } else {
2589     /* we didn't had a save_file before, must be a tempfile */
2590     is_tempfile = TRUE;
2591   }
2592
2593   /* save the new filename */
2594   capture_opts->save_file = g_strdup(new_file);
2595
2596   /* if we are in real-time mode, open the new file now */
2597   if (do_dissection) {
2598     /* Attempt to open the capture file and set up to read from it. */
2599     switch(cf_open((capture_file *)cap_session->cf, capture_opts->save_file, is_tempfile, &err)) {
2600     case CF_OK:
2601       break;
2602     case CF_ERROR:
2603       /* Don't unlink (delete) the save file - leave it around,
2604          for debugging purposes. */
2605       g_free(capture_opts->save_file);
2606       capture_opts->save_file = NULL;
2607       return FALSE;
2608     }
2609   }
2610
2611   cap_session->state = CAPTURE_RUNNING;
2612
2613   return TRUE;
2614 }
2615
2616
2617 /* capture child tells us we have new packets to read */
2618 void
2619 capture_input_new_packets(capture_session *cap_session, int to_read)
2620 {
2621   gboolean      ret;
2622   int           err;
2623   gchar        *err_info;
2624   gint64        data_offset;
2625   capture_file *cf = (capture_file *)cap_session->cf;
2626   gboolean      filtering_tap_listeners;
2627   guint         tap_flags;
2628
2629 #ifdef SIGINFO
2630   /*
2631    * Prevent a SIGINFO handler from writing to the standard error while
2632    * we're doing so or writing to the standard output; instead, have it
2633    * just set a flag telling us to print that information when we're done.
2634    */
2635   infodelay = TRUE;
2636 #endif /* SIGINFO */
2637
2638   /* Do we have any tap listeners with filters? */
2639   filtering_tap_listeners = have_filtering_tap_listeners();
2640
2641   /* Get the union of the flags for all tap listeners. */
2642   tap_flags = union_of_tap_listener_flags();
2643
2644   if (do_dissection) {
2645     gboolean create_proto_tree;
2646     epan_dissect_t *edt;
2647
2648     if (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
2649         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
2650       create_proto_tree = TRUE;
2651     else
2652       create_proto_tree = FALSE;
2653
2654     /* The protocol tree will be "visible", i.e., printed, only if we're
2655        printing packet details, which is true if we're printing stuff
2656        ("print_packet_info" is true) and we're in verbose mode
2657        ("packet_details" is true). */
2658     edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
2659
2660     while (to_read-- && cf->wth) {
2661       wtap_cleareof(cf->wth);
2662       ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
2663       if (ret == FALSE) {
2664         /* read from file failed, tell the capture child to stop */
2665         sync_pipe_stop(cap_session);
2666         wtap_close(cf->wth);
2667         cf->wth = NULL;
2668       } else {
2669         ret = process_packet(cf, edt, data_offset, wtap_phdr(cf->wth),
2670                              wtap_buf_ptr(cf->wth),
2671                              tap_flags);
2672       }
2673       if (ret != FALSE) {
2674         /* packet successfully read and gone through the "Read Filter" */
2675         packet_count++;
2676       }
2677     }
2678
2679     epan_dissect_free(edt);
2680
2681   } else {
2682     /*
2683      * Dumpcap's doing all the work; we're not doing any dissection.
2684      * Count all the packets it wrote.
2685      */
2686     packet_count += to_read;
2687   }
2688
2689   if (print_packet_counts) {
2690       /* We're printing packet counts. */
2691       if (packet_count != 0) {
2692         fprintf(stderr, "\r%u ", packet_count);
2693         /* stderr could be line buffered */
2694         fflush(stderr);
2695       }
2696   }
2697
2698 #ifdef SIGINFO
2699   /*
2700    * Allow SIGINFO handlers to write.
2701    */
2702   infodelay = FALSE;
2703
2704   /*
2705    * If a SIGINFO handler asked us to write out capture counts, do so.
2706    */
2707   if (infoprint)
2708     report_counts();
2709 #endif /* SIGINFO */
2710 }
2711
2712 static void
2713 report_counts(void)
2714 {
2715   if ((print_packet_counts == FALSE) && (really_quiet == FALSE)) {
2716     /* Report the count only if we aren't printing a packet count
2717        as packets arrive. */
2718       fprintf(stderr, "%u packet%s captured\n", packet_count,
2719             plurality(packet_count, "", "s"));
2720   }
2721 #ifdef SIGINFO
2722   infoprint = FALSE; /* we just reported it */
2723 #endif /* SIGINFO */
2724 }
2725
2726 #ifdef SIGINFO
2727 static void
2728 report_counts_siginfo(int signum _U_)
2729 {
2730   int sav_errno = errno;
2731   /* If we've been told to delay printing, just set a flag asking
2732      that we print counts (if we're supposed to), otherwise print
2733      the count of packets captured (if we're supposed to). */
2734   if (infodelay)
2735     infoprint = TRUE;
2736   else
2737     report_counts();
2738   errno = sav_errno;
2739 }
2740 #endif /* SIGINFO */
2741
2742
2743 /* capture child detected any packet drops? */
2744 void
2745 capture_input_drops(capture_session *cap_session _U_, guint32 dropped)
2746 {
2747   if (print_packet_counts) {
2748     /* We're printing packet counts to stderr.
2749        Send a newline so that we move to the line after the packet count. */
2750     fprintf(stderr, "\n");
2751   }
2752
2753   if (dropped != 0) {
2754     /* We're printing packet counts to stderr.
2755        Send a newline so that we move to the line after the packet count. */
2756     fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2757   }
2758 }
2759
2760
2761 /*
2762  * Capture child closed its side of the pipe, report any error and
2763  * do the required cleanup.
2764  */
2765 void
2766 capture_input_closed(capture_session *cap_session, gchar *msg)
2767 {
2768   capture_file *cf = (capture_file *) cap_session->cf;
2769
2770   if (msg != NULL)
2771     fprintf(stderr, "tshark: %s\n", msg);
2772
2773   report_counts();
2774
2775   if (cf != NULL && cf->wth != NULL) {
2776     wtap_close(cf->wth);
2777     if (cf->is_tempfile) {
2778       ws_unlink(cf->filename);
2779     }
2780   }
2781 #ifdef USE_BROKEN_G_MAIN_LOOP
2782   /*g_main_loop_quit(loop);*/
2783   g_main_quit(loop);
2784 #else
2785   loop_running = FALSE;
2786 #endif
2787 }
2788
2789
2790
2791
2792 #ifdef _WIN32
2793 static BOOL WINAPI
2794 capture_cleanup(DWORD ctrltype _U_)
2795 {
2796   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2797      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2798      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2799      like SIGTERM at least when the machine's shutting down.
2800
2801      For now, we handle them all as indications that we should clean up
2802      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2803      way on UNIX.
2804
2805      We must return TRUE so that no other handler - such as one that would
2806      terminate the process - gets called.
2807
2808      XXX - for some reason, typing ^C to TShark, if you run this in
2809      a Cygwin console window in at least some versions of Cygwin,
2810      causes TShark to terminate immediately; this routine gets
2811      called, but the main loop doesn't get a chance to run and
2812      exit cleanly, at least if this is compiled with Microsoft Visual
2813      C++ (i.e., it's a property of the Cygwin console window or Bash;
2814      it happens if TShark is not built with Cygwin - for all I know,
2815      building it with Cygwin may make the problem go away). */
2816
2817   /* tell the capture child to stop */
2818   sync_pipe_stop(&global_capture_session);
2819
2820   /* don't stop our own loop already here, otherwise status messages and
2821    * cleanup wouldn't be done properly. The child will indicate the stop of
2822    * everything by calling capture_input_closed() later */
2823
2824   return TRUE;
2825 }
2826 #else
2827 static void
2828 capture_cleanup(int signum _U_)
2829 {
2830   /* tell the capture child to stop */
2831   sync_pipe_stop(&global_capture_session);
2832
2833   /* don't stop our own loop already here, otherwise status messages and
2834    * cleanup wouldn't be done properly. The child will indicate the stop of
2835    * everything by calling capture_input_closed() later */
2836 }
2837 #endif /* _WIN32 */
2838 #endif /* HAVE_LIBPCAP */
2839
2840 static gboolean
2841 process_packet_first_pass(capture_file *cf, epan_dissect_t *edt,
2842                gint64 offset, struct wtap_pkthdr *whdr,
2843                const guchar *pd)
2844 {
2845   frame_data     fdlocal;
2846   guint32        framenum;
2847   gboolean       passed;
2848
2849   /* The frame number of this packet is one more than the count of
2850      frames in this packet. */
2851   framenum = cf->count + 1;
2852
2853   /* If we're not running a display filter and we're not printing any
2854      packet information, we don't need to do a dissection. This means
2855      that all packets can be marked as 'passed'. */
2856   passed = TRUE;
2857
2858   frame_data_init(&fdlocal, framenum, whdr, offset, cum_bytes);
2859
2860   /* If we're going to print packet information, or we're going to
2861      run a read filter, or display filter, or we're going to process taps, set up to
2862      do a dissection and do so. */
2863   if (edt) {
2864     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2865         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2866       /* Grab any resolved addresses */
2867       host_name_lookup_process();
2868
2869     /* If we're running a read filter, prime the epan_dissect_t with that
2870        filter. */
2871     if (cf->rfcode)
2872       epan_dissect_prime_dfilter(edt, cf->rfcode);
2873
2874     frame_data_set_before_dissect(&fdlocal, &cf->elapsed_time,
2875                                   &ref, prev_dis);
2876     if (ref == &fdlocal) {
2877       ref_frame = fdlocal;
2878       ref = &ref_frame;
2879     }
2880
2881     epan_dissect_run(edt, whdr, frame_tvbuff_new(&fdlocal, pd), &fdlocal, NULL);
2882
2883     /* Run the read filter if we have one. */
2884     if (cf->rfcode)
2885       passed = dfilter_apply_edt(cf->rfcode, edt);
2886   }
2887
2888   if (passed) {
2889     frame_data_set_after_dissect(&fdlocal, &cum_bytes);
2890     prev_cap = prev_dis = frame_data_sequence_add(cf->frames, &fdlocal);
2891
2892     /* If we're not doing dissection then there won't be any dependent frames.
2893      * More importantly, edt.pi.dependent_frames won't be initialized because
2894      * epan hasn't been initialized.
2895      */
2896     if (edt) {
2897       g_slist_foreach(edt->pi.dependent_frames, find_and_mark_frame_depended_upon, cf->frames);
2898     }
2899
2900     cf->count++;
2901   } else {
2902     /* if we don't add it to the frame_data_sequence, clean it up right now
2903      * to avoid leaks */
2904     frame_data_destroy(&fdlocal);
2905   }
2906
2907   if (edt)
2908     epan_dissect_reset(edt);
2909
2910   return passed;
2911 }
2912
2913 static gboolean
2914 process_packet_second_pass(capture_file *cf, epan_dissect_t *edt, frame_data *fdata,
2915                struct wtap_pkthdr *phdr, Buffer *buf,
2916                guint tap_flags)
2917 {
2918   column_info    *cinfo;
2919   gboolean        passed;
2920
2921   /* If we're not running a display filter and we're not printing any
2922      packet information, we don't need to do a dissection. This means
2923      that all packets can be marked as 'passed'. */
2924   passed = TRUE;
2925
2926   /* If we're going to print packet information, or we're going to
2927      run a read filter, or we're going to process taps, set up to
2928      do a dissection and do so. */
2929   if (edt) {
2930     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2931         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2932       /* Grab any resolved addresses */
2933       host_name_lookup_process();
2934
2935     /* If we're running a display filter, prime the epan_dissect_t with that
2936        filter. */
2937     if (cf->dfcode)
2938       epan_dissect_prime_dfilter(edt, cf->dfcode);
2939
2940     col_custom_prime_edt(edt, &cf->cinfo);
2941
2942     /* We only need the columns if either
2943          1) some tap needs the columns
2944        or
2945          2) we're printing packet info but we're *not* verbose; in verbose
2946             mode, we print the protocol tree, not the protocol summary.
2947      */
2948     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary))
2949       cinfo = &cf->cinfo;
2950     else
2951       cinfo = NULL;
2952
2953     frame_data_set_before_dissect(fdata, &cf->elapsed_time,
2954                                   &ref, prev_dis);
2955     if (ref == fdata) {
2956       ref_frame = *fdata;
2957       ref = &ref_frame;
2958     }
2959
2960     epan_dissect_run_with_taps(edt, phdr, frame_tvbuff_new_buffer(fdata, buf), fdata, cinfo);
2961
2962     /* Run the read/display filter if we have one. */
2963     if (cf->dfcode)
2964       passed = dfilter_apply_edt(cf->dfcode, edt);
2965   }
2966
2967   if (passed) {
2968     frame_data_set_after_dissect(fdata, &cum_bytes);
2969     /* Process this packet. */
2970     if (print_packet_info) {
2971       /* We're printing packet information; print the information for
2972          this packet. */
2973       print_packet(cf, edt);
2974
2975       /* The ANSI C standard does not appear to *require* that a line-buffered
2976          stream be flushed to the host environment whenever a newline is
2977          written, it just says that, on such a stream, characters "are
2978          intended to be transmitted to or from the host environment as a
2979          block when a new-line character is encountered".
2980
2981          The Visual C++ 6.0 C implementation doesn't do what is intended;
2982          even if you set a stream to be line-buffered, it still doesn't
2983          flush the buffer at the end of every line.
2984
2985          So, if the "-l" flag was specified, we flush the standard output
2986          at the end of a packet.  This will do the right thing if we're
2987          printing packet summary lines, and, as we print the entire protocol
2988          tree for a single packet without waiting for anything to happen,
2989          it should be as good as line-buffered mode if we're printing
2990          protocol trees.  (The whole reason for the "-l" flag in either
2991          tcpdump or TShark is to allow the output of a live capture to
2992          be piped to a program or script and to have that script see the
2993          information for the packet as soon as it's printed, rather than
2994          having to wait until a standard I/O buffer fills up. */
2995       if (line_buffered)
2996         fflush(stdout);
2997
2998       if (ferror(stdout)) {
2999         show_print_file_io_error(errno);
3000         exit(2);
3001       }
3002     }
3003     prev_dis = fdata;
3004   }
3005   prev_cap = fdata;
3006
3007   if (edt) {
3008     epan_dissect_reset(edt);
3009   }
3010   return passed || fdata->flags.dependent_of_displayed;
3011 }
3012
3013 static int
3014 load_cap_file(capture_file *cf, char *save_file, int out_file_type,
3015     gboolean out_file_name_res, int max_packet_count, gint64 max_byte_count)
3016 {
3017   gint         linktype;
3018   int          snapshot_length;
3019   wtap_dumper *pdh;
3020   guint32      framenum;
3021   int          err;
3022   gchar       *err_info = NULL;
3023   gint64       data_offset;
3024   char        *save_file_string = NULL;
3025   gboolean     filtering_tap_listeners;
3026   guint        tap_flags;
3027   wtapng_section_t            *shb_hdr;
3028   wtapng_iface_descriptions_t *idb_inf;
3029   char         appname[100];
3030   Buffer       buf;
3031   epan_dissect_t *edt = NULL;
3032
3033   shb_hdr = wtap_file_get_shb_info(cf->wth);
3034   idb_inf = wtap_file_get_idb_info(cf->wth);
3035 #ifdef PCAP_NG_DEFAULT
3036   if (idb_inf->number_of_interfaces > 1) {
3037     linktype = WTAP_ENCAP_PER_PACKET;
3038   } else {
3039     linktype = wtap_file_encap(cf->wth);
3040   }
3041 #else
3042   linktype = wtap_file_encap(cf->wth);
3043 #endif
3044   if (save_file != NULL) {
3045     /* Get a string that describes what we're writing to */
3046     save_file_string = output_file_description(save_file);
3047
3048     /* Set up to write to the capture file. */
3049     snapshot_length = wtap_snapshot_length(cf->wth);
3050     if (snapshot_length == 0) {
3051       /* Snapshot length of input file not known. */
3052       snapshot_length = WTAP_MAX_PACKET_SIZE;
3053     }
3054     /* If we don't have an application name add Tshark */
3055     if (shb_hdr->shb_user_appl == NULL) {
3056         g_snprintf(appname, sizeof(appname), "TShark " VERSION "%s", wireshark_svnversion);
3057         shb_hdr->shb_user_appl = appname;
3058     }
3059
3060     if (linktype != WTAP_ENCAP_PER_PACKET &&
3061         out_file_type == WTAP_FILE_TYPE_SUBTYPE_PCAP)
3062         pdh = wtap_dump_open(save_file, out_file_type, linktype,
3063             snapshot_length, FALSE /* compressed */, &err);
3064     else
3065         pdh = wtap_dump_open_ng(save_file, out_file_type, linktype,
3066             snapshot_length, FALSE /* compressed */, shb_hdr, idb_inf, &err);
3067
3068     g_free(idb_inf);
3069     idb_inf = NULL;
3070
3071     if (pdh == NULL) {
3072       /* We couldn't set up to write to the capture file. */
3073       switch (err) {
3074
3075       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
3076         cmdarg_err("Capture files can't be written in that format.");
3077         break;
3078
3079       case WTAP_ERR_UNSUPPORTED_ENCAP:
3080       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
3081         cmdarg_err("The capture file being read can't be written as a "
3082           "\"%s\" file.", wtap_file_type_subtype_short_string(out_file_type));
3083         break;
3084
3085       case WTAP_ERR_CANT_OPEN:
3086         cmdarg_err("The %s couldn't be created for some "
3087           "unknown reason.", save_file_string);
3088         break;
3089
3090       case WTAP_ERR_SHORT_WRITE:
3091         cmdarg_err("A full header couldn't be written to the %s.",
3092                    save_file_string);
3093         break;
3094
3095       default:
3096         cmdarg_err("The %s could not be created: %s.", save_file_string,
3097                    wtap_strerror(err));
3098         break;
3099       }
3100       goto out;
3101     }
3102   } else {
3103     if (print_packet_info) {
3104       if (!write_preamble(cf)) {
3105         err = errno;
3106         show_print_file_io_error(err);
3107         goto out;
3108       }
3109     }
3110     g_free(idb_inf);
3111     idb_inf = NULL;
3112     pdh = NULL;
3113   }
3114
3115   if (pdh && out_file_name_res) {
3116     if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
3117       cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
3118                  wtap_file_type_subtype_short_string(out_file_type));
3119     }
3120   }
3121
3122   /* Do we have any tap listeners with filters? */
3123   filtering_tap_listeners = have_filtering_tap_listeners();
3124
3125   /* Get the union of the flags for all tap listeners. */
3126   tap_flags = union_of_tap_listener_flags();
3127
3128   if (perform_two_pass_analysis) {
3129     frame_data *fdata;
3130
3131     /* Allocate a frame_data_sequence for all the frames. */
3132     cf->frames = new_frame_data_sequence();
3133
3134     if (do_dissection) {
3135        gboolean create_proto_tree = FALSE;
3136
3137       /* If we're going to be applying a filter, we'll need to
3138          create a protocol tree against which to apply the filter. */
3139       if (cf->rfcode)
3140         create_proto_tree = TRUE;
3141
3142       /* We're not going to display the protocol tree on this pass,
3143          so it's not going to be "visible". */
3144       edt = epan_dissect_new(cf->epan, create_proto_tree, FALSE);
3145     }
3146
3147     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
3148       if (process_packet_first_pass(cf, edt, data_offset, wtap_phdr(cf->wth),
3149                          wtap_buf_ptr(cf->wth))) {
3150         /* Stop reading if we have the maximum number of packets;
3151          * When the -c option has not been used, max_packet_count
3152          * starts at 0, which practically means, never stop reading.
3153          * (unless we roll over max_packet_count ?)
3154          */
3155         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3156           err = 0; /* This is not an error */
3157           break;
3158         }
3159       }
3160     }
3161
3162     if (edt) {
3163       epan_dissect_free(edt);
3164       edt = NULL;
3165     }
3166
3167     /* Close the sequential I/O side, to free up memory it requires. */
3168     wtap_sequential_close(cf->wth);
3169
3170     /* Allow the protocol dissectors to free up memory that they
3171      * don't need after the sequential run-through of the packets. */
3172     postseq_cleanup_all_protocols();
3173
3174     prev_dis = NULL;
3175     prev_cap = NULL;
3176     buffer_init(&buf, 1500);
3177
3178     if (do_dissection) {
3179       gboolean create_proto_tree;
3180
3181       if (cf->dfcode || print_details || filtering_tap_listeners ||
3182          (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
3183            create_proto_tree = TRUE;
3184       else
3185            create_proto_tree = FALSE;
3186
3187       /* The protocol tree will be "visible", i.e., printed, only if we're
3188          printing packet details, which is true if we're printing stuff
3189          ("print_packet_info" is true) and we're in verbose mode
3190          ("packet_details" is true). */
3191       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
3192     }
3193
3194     for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
3195       fdata = frame_data_sequence_find(cf->frames, framenum);
3196       if (wtap_seek_read(cf->wth, fdata->file_off, &cf->phdr,
3197           &buf, &err, &err_info)) {
3198         if (process_packet_second_pass(cf, edt, fdata, &cf->phdr, &buf,
3199                                        tap_flags)) {
3200           /* Either there's no read filtering or this packet passed the
3201              filter, so, if we're writing to a capture file, write
3202              this packet out. */
3203           if (pdh != NULL) {
3204             if (!wtap_dump(pdh, &cf->phdr, buffer_start_ptr(&cf->buf), &err)) {
3205               /* Error writing to a capture file */
3206               switch (err) {
3207
3208               case WTAP_ERR_UNSUPPORTED_ENCAP:
3209                 /*
3210                  * This is a problem with the particular frame we're writing;
3211                  * note that, and give the frame number.
3212                  *
3213                  * XXX - framenum is not necessarily the frame number in
3214                  * the input file if there was a read filter.
3215                  */
3216                 fprintf(stderr,
3217                         "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
3218                         framenum, cf->filename,
3219                         wtap_file_type_subtype_short_string(out_file_type));
3220                 break;
3221
3222               default:
3223                 show_capture_file_io_error(save_file, err, FALSE);
3224                 break;
3225               }
3226               wtap_dump_close(pdh, &err);
3227               g_free(shb_hdr);
3228               exit(2);
3229             }
3230           }
3231         }
3232       }
3233     }
3234
3235     if (edt) {
3236       epan_dissect_free(edt);
3237       edt = NULL;
3238     }
3239
3240     buffer_free(&buf);
3241   }
3242   else {
3243     framenum = 0;
3244
3245     if (do_dissection) {
3246       gboolean create_proto_tree;
3247
3248       if (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
3249           (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
3250         create_proto_tree = TRUE;
3251       else
3252         create_proto_tree = FALSE;
3253
3254       /* The protocol tree will be "visible", i.e., printed, only if we're
3255          printing packet details, which is true if we're printing stuff
3256          ("print_packet_info" is true) and we're in verbose mode
3257          ("packet_details" is true). */
3258       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
3259     }
3260
3261     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
3262       framenum++;
3263
3264       if (process_packet(cf, edt, data_offset, wtap_phdr(cf->wth),
3265                          wtap_buf_ptr(cf->wth),
3266                          tap_flags)) {
3267         /* Either there's no read filtering or this packet passed the
3268            filter, so, if we're writing to a capture file, write
3269            this packet out. */
3270         if (pdh != NULL) {
3271           if (!wtap_dump(pdh, wtap_phdr(cf->wth), wtap_buf_ptr(cf->wth), &err)) {
3272             /* Error writing to a capture file */
3273             switch (err) {
3274
3275             case WTAP_ERR_UNSUPPORTED_ENCAP:
3276               /*
3277                * This is a problem with the particular frame we're writing;
3278                * note that, and give the frame number.
3279                */
3280               fprintf(stderr,
3281                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
3282                       framenum, cf->filename,
3283                       wtap_file_type_subtype_short_string(out_file_type));
3284               break;
3285
3286             default:
3287               show_capture_file_io_error(save_file, err, FALSE);
3288               break;
3289             }
3290             wtap_dump_close(pdh, &err);
3291             g_free(shb_hdr);
3292             exit(2);
3293           }
3294         }
3295       }
3296       /* Stop reading if we have the maximum number of packets;
3297        * When the -c option has not been used, max_packet_count
3298        * starts at 0, which practically means, never stop reading.
3299        * (unless we roll over max_packet_count ?)
3300        */
3301       if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
3302         err = 0; /* This is not an error */
3303         break;
3304       }
3305     }
3306
3307     if (edt) {
3308       epan_dissect_free(edt);
3309       edt = NULL;
3310     }
3311   }
3312
3313   if (err != 0) {
3314     /*
3315      * Print a message noting that the read failed somewhere along the line.
3316      *
3317      * If we're printing packet data, and the standard output and error are
3318      * going to the same place, flush the standard output, so everything
3319      * buffered up is written, and then print a newline to the standard error
3320      * before printing the error message, to separate it from the packet
3321      * data.  (Alas, that only works on UN*X; st_dev is meaningless, and
3322      * the _fstat() documentation at Microsoft doesn't indicate whether
3323      * st_ino is even supported.)
3324      */
3325 #ifndef _WIN32
3326     if (print_packet_info) {
3327       struct stat stat_stdout, stat_stderr;
3328
3329       if (fstat(1, &stat_stdout) == 0 && fstat(2, &stat_stderr) == 0) {
3330         if (stat_stdout.st_dev == stat_stderr.st_dev &&
3331             stat_stdout.st_ino == stat_stderr.st_ino) {
3332           fflush(stdout);
3333           fprintf(stderr, "\n");
3334         }
3335       }
3336     }
3337 #endif
3338     switch (err) {
3339
3340     case WTAP_ERR_UNSUPPORTED:
3341       cmdarg_err("The file \"%s\" contains record data that TShark doesn't support.\n(%s)",
3342                  cf->filename, err_info);
3343       g_free(err_info);
3344       break;
3345
3346     case WTAP_ERR_UNSUPPORTED_ENCAP:
3347       cmdarg_err("The file \"%s\" has a packet with a network type that TShark doesn't support.\n(%s)",
3348                  cf->filename, err_info);
3349       g_free(err_info);
3350       break;
3351
3352     case WTAP_ERR_CANT_READ:
3353       cmdarg_err("An attempt to read from the file \"%s\" failed for some unknown reason.",
3354                  cf->filename);
3355       break;
3356
3357     case WTAP_ERR_SHORT_READ:
3358       cmdarg_err("The file \"%s\" appears to have been cut short in the middle of a packet.",
3359                  cf->filename);
3360       break;
3361
3362     case WTAP_ERR_BAD_FILE:
3363       cmdarg_err("The file \"%s\" appears to be damaged or corrupt.\n(%s)",
3364                  cf->filename, err_info);
3365       g_free(err_info);
3366       break;
3367
3368     case WTAP_ERR_DECOMPRESS:
3369       cmdarg_err("The compressed file \"%s\" appears to be damaged or corrupt.\n"
3370                  "(%s)", cf->filename, err_info);
3371       break;
3372
3373     default:
3374       cmdarg_err("An error occurred while reading the file \"%s\": %s.",
3375                  cf->filename, wtap_strerror(err));
3376       break;
3377     }
3378     if (save_file != NULL) {
3379       /* Now close the capture file. */
3380       if (!wtap_dump_close(pdh, &err))
3381         show_capture_file_io_error(save_file, err, TRUE);
3382     }
3383   } else {
3384     if (save_file != NULL) {
3385       /* Now close the capture file. */
3386       if (!wtap_dump_close(pdh, &err))
3387         show_capture_file_io_error(save_file, err, TRUE);
3388     } else {
3389       if (print_packet_info) {
3390         if (!write_finale()) {
3391           err = errno;
3392           show_print_file_io_error(err);
3393         }
3394       }
3395     }
3396   }
3397
3398 out:
3399   wtap_close(cf->wth);
3400   cf->wth = NULL;
3401
3402   g_free(save_file_string);
3403   g_free(shb_hdr);
3404
3405   return err;
3406 }
3407
3408 static gboolean
3409 process_packet(capture_file *cf, epan_dissect_t *edt, gint64 offset, struct wtap_pkthdr *whdr,
3410                const guchar *pd, guint tap_flags)
3411 {
3412   frame_data      fdata;
3413   column_info    *cinfo;
3414   gboolean        passed;
3415
3416   /* Count this packet. */
3417   cf->count++;
3418
3419   /* If we're not running a display filter and we're not printing any
3420      packet information, we don't need to do a dissection. This means
3421      that all packets can be marked as 'passed'. */
3422   passed = TRUE;
3423
3424   frame_data_init(&fdata, cf->count, whdr, offset, cum_bytes);
3425
3426   /* If we're going to print packet information, or we're going to
3427      run a read filter, or we're going to process taps, set up to
3428      do a dissection and do so. */
3429   if (edt) {
3430     if (print_packet_info && (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
3431         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns))
3432       /* Grab any resolved addresses */
3433       host_name_lookup_process();
3434
3435     /* If we're running a filter, prime the epan_dissect_t with that
3436        filter. */
3437     if (cf->dfcode)
3438       epan_dissect_prime_dfilter(edt, cf->dfcode);
3439
3440     col_custom_prime_edt(edt, &cf->cinfo);
3441
3442     /* We only need the columns if either
3443          1) some tap needs the columns
3444        or
3445          2) we're printing packet info but we're *not* verbose; in verbose
3446             mode, we print the protocol tree, not the protocol summary.
3447        or
3448          3) there is a column mapped as an individual field */
3449     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
3450       cinfo = &cf->cinfo;
3451     else
3452       cinfo = NULL;
3453
3454     frame_data_set_before_dissect(&fdata, &cf->elapsed_time,
3455                                   &ref, prev_dis);
3456     if (ref == &fdata) {
3457       ref_frame = fdata;
3458       ref = &ref_frame;
3459     }
3460
3461     epan_dissect_run_with_taps(edt, whdr, frame_tvbuff_new(&fdata, pd), &fdata, cinfo);
3462
3463     /* Run the filter if we have it. */
3464     if (cf->dfcode)
3465       passed = dfilter_apply_edt(cf->dfcode, edt);
3466   }
3467
3468   if (passed) {
3469     frame_data_set_after_dissect(&fdata, &cum_bytes);
3470
3471     /* Process this packet. */
3472     if (print_packet_info) {
3473       /* We're printing packet information; print the information for
3474          this packet. */
3475       print_packet(cf, edt);
3476
3477       /* The ANSI C standard does not appear to *require* that a line-buffered
3478          stream be flushed to the host environment whenever a newline is
3479          written, it just says that, on such a stream, characters "are
3480          intended to be transmitted to or from the host environment as a
3481          block when a new-line character is encountered".
3482
3483          The Visual C++ 6.0 C implementation doesn't do what is intended;
3484          even if you set a stream to be line-buffered, it still doesn't
3485          flush the buffer at the end of every line.
3486
3487          So, if the "-l" flag was specified, we flush the standard output
3488          at the end of a packet.  This will do the right thing if we're
3489          printing packet summary lines, and, as we print the entire protocol
3490          tree for a single packet without waiting for anything to happen,
3491          it should be as good as line-buffered mode if we're printing
3492          protocol trees.  (The whole reason for the "-l" flag in either
3493          tcpdump or TShark is to allow the output of a live capture to
3494          be piped to a program or script and to have that script see the
3495          information for the packet as soon as it's printed, rather than
3496          having to wait until a standard I/O buffer fills up. */
3497       if (line_buffered)
3498         fflush(stdout);
3499
3500       if (ferror(stdout)) {
3501         show_print_file_io_error(errno);
3502         exit(2);
3503       }
3504     }
3505
3506     /* this must be set after print_packet() [bug #8160] */
3507     prev_dis_frame = fdata;
3508     prev_dis = &prev_dis_frame;
3509   }
3510
3511   prev_cap_frame = fdata;
3512   prev_cap = &prev_cap_frame;
3513
3514   if (edt) {
3515     epan_dissect_reset(edt);
3516     frame_data_destroy(&fdata);
3517   }
3518   return passed;
3519 }
3520
3521 static gboolean
3522 write_preamble(capture_file *cf)
3523 {
3524   switch (output_action) {
3525
3526   case WRITE_TEXT:
3527     return print_preamble(print_stream, cf ? cf->filename : NULL, wireshark_svnversion);
3528
3529   case WRITE_XML:
3530     if (print_details)
3531       write_pdml_preamble(stdout, cf ? cf->filename : NULL);
3532     else
3533       write_psml_preamble(stdout);
3534     return !ferror(stdout);
3535
3536   case WRITE_FIELDS:
3537     write_fields_preamble(output_fields, stdout);
3538     return !ferror(stdout);
3539
3540   default:
3541     g_assert_not_reached();
3542     return FALSE;
3543   }
3544 }
3545
3546 static char *
3547 get_line_buf(size_t len)
3548 {
3549   static char   *line_bufp    = NULL;
3550   static size_t  line_buf_len = 256;
3551   size_t         new_line_buf_len;
3552
3553   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
3554        new_line_buf_len *= 2)
3555     ;
3556   if (line_bufp == NULL) {
3557     line_buf_len = new_line_buf_len;
3558     line_bufp = (char *)g_malloc(line_buf_len + 1);
3559   } else {
3560     if (new_line_buf_len > line_buf_len) {
3561       line_buf_len = new_line_buf_len;
3562       line_bufp = (char *)g_realloc(line_bufp, line_buf_len + 1);
3563     }
3564   }
3565   return line_bufp;
3566 }
3567
3568 static inline void
3569 put_string(char *dest, const char *str, size_t str_len)
3570 {
3571   memcpy(dest, str, str_len);
3572   dest[str_len] = '\0';
3573 }
3574
3575 static inline void
3576 put_spaces_string(char *dest, const char *str, size_t str_len, size_t str_with_spaces)
3577 {
3578   size_t i;
3579
3580   for (i = str_len; i < str_with_spaces; i++)
3581     *dest++ = ' ';
3582
3583   put_string(dest, str, str_len);
3584 }
3585
3586 static inline void
3587 put_string_spaces(char *dest, const char *str, size_t str_len, size_t str_with_spaces)
3588 {
3589   size_t i;
3590
3591   memcpy(dest, str, str_len);
3592   for (i = str_len; i < str_with_spaces; i++)
3593     dest[i] = ' ';
3594
3595   dest[str_with_spaces] = '\0';
3596 }
3597
3598 static gboolean
3599 print_columns(capture_file *cf)
3600 {
3601   char   *line_bufp;
3602   int     i;
3603   size_t  buf_offset;
3604   size_t  column_len;
3605   size_t  col_len;
3606
3607   line_bufp = get_line_buf(256);
3608   buf_offset = 0;
3609   *line_bufp = '\0';
3610   for (i = 0; i < cf->cinfo.num_cols; i++) {
3611     /* Skip columns not marked as visible. */
3612     if (!get_column_visible(i))
3613       continue;
3614     switch (cf->cinfo.col_fmt[i]) {
3615     case COL_NUMBER:
3616       column_len = col_len = strlen(cf->cinfo.col_data[i]);
3617       if (column_len < 3)
3618         column_len = 3;
3619       line_bufp = get_line_buf(buf_offset + column_len);
3620       put_spaces_string(line_bufp + buf_offset, cf->cinfo.col_data[i], col_len, column_len);
3621       break;
3622
3623     case COL_CLS_TIME:
3624     case COL_REL_TIME:
3625     case COL_ABS_TIME:
3626     case COL_ABS_YMD_TIME:  /* XXX - wider */
3627     case COL_ABS_YDOY_TIME: /* XXX - wider */
3628     case COL_UTC_TIME:
3629     case COL_UTC_YMD_TIME:  /* XXX - wider */
3630     case COL_UTC_YDOY_TIME: /* XXX - wider */
3631       column_len = col_len = strlen(cf->cinfo.col_data[i]);
3632       if (column_len < 10)
3633         column_len = 10;
3634       line_bufp = get_line_buf(buf_offset + column_len);
3635       put_spaces_string(line_bufp + buf_offset, cf->cinfo.col_data[i], col_len, column_len);
3636       break;
3637
3638     case COL_DEF_SRC:
3639     case COL_RES_SRC:
3640     case COL_UNRES_SRC:
3641     case COL_DEF_DL_SRC:
3642     case COL_RES_DL_SRC:
3643     case COL_UNRES_DL_SRC:
3644     case COL_DEF_NET_SRC:
3645     case COL_RES_NET_SRC:
3646     case COL_UNRES_NET_SRC:
3647       column_len = col_len = strlen(cf->cinfo.col_data[i]);
3648       if (column_len < 12)
3649         column_len = 12;
3650       line_bufp = get_line_buf(buf_offset + column_len);
3651       put_spaces_string(line_bufp + buf_offset, cf->cinfo.col_data[i], col_len, column_len);
3652       break;
3653
3654     case COL_DEF_DST:
3655     case COL_RES_DST:
3656     case COL_UNRES_DST:
3657     case COL_DEF_DL_DST:
3658     case COL_RES_DL_DST:
3659     case COL_UNRES_DL_DST:
3660     case COL_DEF_NET_DST:
3661     case COL_RES_NET_DST:
3662     case COL_UNRES_NET_DST:
3663       column_len = col_len = strlen(cf->cinfo.col_data[i]);
3664       if (column_len < 12)
3665         column_len = 12;
3666       line_bufp = get_line_buf(buf_offset + column_len);
3667       put_string_spaces(line_bufp + buf_offset, cf->cinfo.col_data[i], col_len, column_len);
3668       break;
3669
3670     default:
3671       column_len = strlen(cf->cinfo.col_data[i]);
3672       line_bufp = get_line_buf(buf_offset + column_len);
3673       put_string(line_bufp + buf_offset, cf->cinfo.col_data[i], column_len);
3674       break;
3675     }
3676     buf_offset += column_len;
3677     if (i != cf->cinfo.num_cols - 1) {
3678       /*
3679        * This isn't the last column, so we need to print a
3680        * separator between this column and the next.
3681        *
3682        * If we printed a network source and are printing a
3683        * network destination of the same type next, separate
3684        * them with " -> "; if we printed a network destination
3685        * and are printing a network source of the same type
3686        * next, separate them with " <- "; otherwise separate them
3687        * with a space.
3688        *
3689        * We add enough space to the buffer for " <- " or " -> ",
3690        * even if we're only adding " ".
3691        */
3692       line_bufp = get_line_buf(buf_offset + 4);
3693       switch (cf->cinfo.col_fmt[i]) {
3694
3695       case COL_DEF_SRC:
3696       case COL_RES_SRC:
3697       case COL_UNRES_SRC:
3698         switch (cf->cinfo.col_fmt[i + 1]) {
3699
3700         case COL_DEF_DST:
3701         case COL_RES_DST:
3702         case COL_UNRES_DST:
3703           put_string(line_bufp + buf_offset, " -> ", 4);
3704           buf_offset += 4;
3705           break;
3706
3707         default:
3708           put_string(line_bufp + buf_offset, " ", 1);
3709           buf_offset += 1;
3710           break;
3711         }
3712         break;
3713
3714       case COL_DEF_DL_SRC:
3715       case COL_RES_DL_SRC:
3716       case COL_UNRES_DL_SRC:
3717         switch (cf->cinfo.col_fmt[i + 1]) {
3718
3719         case COL_DEF_DL_DST:
3720         case COL_RES_DL_DST:
3721         case COL_UNRES_DL_DST:
3722           put_string(line_bufp + buf_offset, " -> ", 4);
3723           buf_offset += 4;
3724           break;
3725
3726         default:
3727           put_string(line_bufp + buf_offset, " ", 1);
3728           buf_offset += 1;
3729           break;
3730         }
3731         break;
3732
3733       case COL_DEF_NET_SRC:
3734       case COL_RES_NET_SRC:
3735       case COL_UNRES_NET_SRC:
3736         switch (cf->cinfo.col_fmt[i + 1]) {
3737
3738         case COL_DEF_NET_DST:
3739         case COL_RES_NET_DST:
3740         case COL_UNRES_NET_DST:
3741           put_string(line_bufp + buf_offset, " -> ", 4);
3742           buf_offset += 4;
3743           break;
3744
3745         default:
3746           put_string(line_bufp + buf_offset, " ", 1);
3747           buf_offset += 1;
3748           break;
3749         }
3750         break;
3751
3752       case COL_DEF_DST:
3753       case COL_RES_DST:
3754       case COL_UNRES_DST:
3755         switch (cf->cinfo.col_fmt[i + 1]) {
3756
3757         case COL_DEF_SRC:
3758         case COL_RES_SRC:
3759         case COL_UNRES_SRC:
3760           put_string(line_bufp + buf_offset, " <- ", 4);
3761           buf_offset += 4;
3762           break;
3763
3764         default:
3765           put_string(line_bufp + buf_offset, " ", 1);
3766           buf_offset += 1;
3767           break;
3768         }
3769         break;
3770
3771       case COL_DEF_DL_DST:
3772       case COL_RES_DL_DST:
3773       case COL_UNRES_DL_DST:
3774         switch (cf->cinfo.col_fmt[i + 1]) {
3775
3776         case COL_DEF_DL_SRC:
3777         case COL_RES_DL_SRC:
3778         case COL_UNRES_DL_SRC:
3779           put_string(line_bufp + buf_offset, " <- ", 4);
3780           buf_offset += 4;
3781           break;
3782
3783         default:
3784           put_string(line_bufp + buf_offset, " ", 1);
3785           buf_offset += 1;
3786           break;
3787         }
3788         break;
3789
3790       case COL_DEF_NET_DST:
3791       case COL_RES_NET_DST:
3792       case COL_UNRES_NET_DST:
3793         switch (cf->cinfo.col_fmt[i + 1]) {
3794
3795         case COL_DEF_NET_SRC:
3796         case COL_RES_NET_SRC:
3797         case COL_UNRES_NET_SRC:
3798           put_string(line_bufp + buf_offset, " <- ", 4);
3799           buf_offset += 4;
3800           break;
3801
3802         default:
3803           put_string(line_bufp + buf_offset, " ", 1);
3804           buf_offset += 1;
3805           break;
3806         }
3807         break;
3808
3809       default:
3810         put_string(line_bufp + buf_offset, " ", 1);
3811         buf_offset += 1;
3812         break;
3813       }
3814     }
3815   }
3816   return print_line(print_stream, 0, line_bufp);
3817 }
3818
3819 static gboolean
3820 print_packet(capture_file *cf, epan_dissect_t *edt)
3821 {
3822   print_args_t print_args;
3823
3824   if (print_summary || output_fields_has_cols(output_fields)) {
3825     /* Just fill in the columns. */
3826     epan_dissect_fill_in_columns(edt, FALSE, TRUE);
3827
3828     if (print_summary) {
3829       /* Now print them. */
3830       switch (output_action) {
3831
3832       case WRITE_TEXT:
3833         if (!print_columns(cf))
3834           return FALSE;
3835         break;
3836
3837       case WRITE_XML:
3838         proto_tree_write_psml(edt, stdout);
3839         return !ferror(stdout);
3840       case WRITE_FIELDS: /*No non-verbose "fields" format */
3841         g_assert_not_reached();
3842         break;
3843       }
3844     }
3845   }
3846   if (print_details) {
3847     /* Print the information in the protocol tree. */
3848     switch (output_action) {
3849
3850     case WRITE_TEXT:
3851       /* Only initialize the fields that are actually used in proto_tree_print.
3852        * This is particularly important for .range, as that's heap memory which
3853        * we would otherwise have to g_free().
3854       print_args.to_file = TRUE;
3855       print_args.format = print_format;
3856       print_args.print_summary = print_summary;
3857       print_args.print_formfeed = FALSE;
3858       packet_range_init(&print_args.range, &cfile);
3859       */
3860       print_args.print_hex = print_hex;
3861       print_args.print_dissections = print_details ? print_dissections_expanded : print_dissections_none;
3862
3863       if (!proto_tree_print(&print_args, edt, print_stream))
3864         return FALSE;
3865       if (!print_hex) {
3866         if (!print_line(print_stream, 0, separator))
3867           return FALSE;
3868       }
3869       break;
3870
3871     case WRITE_XML:
3872       proto_tree_write_pdml(edt, stdout);
3873       printf("\n");
3874       return !ferror(stdout);
3875     case WRITE_FIELDS:
3876       proto_tree_write_fields(output_fields, edt, &cf->cinfo, stdout);
3877       printf("\n");
3878       return !ferror(stdout);
3879     }
3880   }
3881   if (print_hex) {
3882     if (print_summary || print_details) {
3883       if (!print_line(print_stream, 0, ""))
3884         return FALSE;
3885     }
3886     if (!print_hex_data(print_stream, edt))
3887       return FALSE;
3888     if (!print_line(print_stream, 0, separator))
3889       return FALSE;
3890   }
3891   return TRUE;
3892 }
3893
3894 static gboolean
3895 write_finale(void)
3896 {
3897   switch (output_action) {
3898
3899   case WRITE_TEXT:
3900     return print_finale(print_stream);
3901
3902   case WRITE_XML:
3903     if (print_details)
3904       write_pdml_finale(stdout);
3905     else
3906       write_psml_finale(stdout);
3907     return !ferror(stdout);
3908
3909   case WRITE_FIELDS:
3910     write_fields_finale(output_fields, stdout);
3911     return !ferror(stdout);
3912
3913   default:
3914     g_assert_not_reached();
3915     return FALSE;
3916   }
3917 }
3918
3919 cf_status_t
3920 cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
3921 {
3922   wtap  *wth;
3923   gchar *err_info;
3924   char   err_msg[2048+1];
3925
3926   wth = wtap_open_offline(fname, err, &err_info, perform_two_pass_analysis);
3927   if (wth == NULL)
3928     goto fail;
3929
3930   /* The open succeeded.  Fill in the information for this file. */
3931
3932   /* Create new epan session for dissection. */
3933   epan_free(cf->epan);
3934   cf->epan = tshark_epan_new(cf);
3935
3936   cf->wth = wth;
3937   cf->f_datalen = 0; /* not used, but set it anyway */
3938
3939   /* Set the file name because we need it to set the follow stream filter.
3940      XXX - is that still true?  We need it for other reasons, though,
3941      in any case. */
3942   cf->filename = g_strdup(fname);
3943
3944   /* Indicate whether it's a permanent or temporary file. */
3945   cf->is_tempfile = is_tempfile;
3946
3947   /* No user changes yet. */
3948   cf->unsaved_changes = FALSE;
3949
3950   cf->cd_t      = wtap_file_type_subtype(cf->wth);
3951   cf->count     = 0;
3952   cf->drops_known = FALSE;
3953   cf->drops     = 0;
3954   cf->snap      = wtap_snapshot_length(cf->wth);
3955   if (cf->snap == 0) {
3956     /* Snapshot length not known. */
3957     cf->has_snap = FALSE;
3958     cf->snap = WTAP_MAX_PACKET_SIZE;
3959   } else
3960     cf->has_snap = TRUE;
3961   nstime_set_zero(&cf->elapsed_time);
3962   ref = NULL;
3963   prev_dis = NULL;
3964   prev_cap = NULL;
3965
3966   cf->state = FILE_READ_IN_PROGRESS;
3967
3968   wtap_set_cb_new_ipv4(cf->wth, add_ipv4_name);
3969   wtap_set_cb_new_ipv6(cf->wth, (wtap_new_ipv6_callback_t) add_ipv6_name);
3970
3971   return CF_OK;
3972
3973 fail:
3974   g_snprintf(err_msg, sizeof err_msg,
3975              cf_open_error_message(*err, err_info, FALSE, cf->cd_t), fname);
3976   cmdarg_err("%s", err_msg);
3977   return CF_ERROR;
3978 }
3979
3980 static void
3981 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
3982 {
3983   char *save_file_string;
3984
3985   save_file_string = output_file_description(fname);
3986
3987   switch (err) {
3988
3989   case ENOSPC:
3990     cmdarg_err("Not all the packets could be written to the %s because there is "
3991                "no space left on the file system.",
3992                save_file_string);
3993     break;
3994
3995 #ifdef EDQUOT
3996   case EDQUOT:
3997     cmdarg_err("Not all the packets could be written to the %s because you are "
3998                "too close to, or over your disk quota.",
3999                save_file_string);
4000   break;
4001 #endif
4002
4003   case WTAP_ERR_CANT_CLOSE:
4004     cmdarg_err("The %s couldn't be closed for some unknown reason.",
4005                save_file_string);
4006     break;
4007
4008   case WTAP_ERR_SHORT_WRITE:
4009     cmdarg_err("Not all the packets could be written to the %s.",
4010                save_file_string);
4011     break;
4012
4013   default:
4014     if (is_close) {
4015       cmdarg_err("The %s could not be closed: %s.", save_file_string,
4016                  wtap_strerror(err));
4017     } else {
4018       cmdarg_err("An error occurred while writing to the %s: %s.",
4019                  save_file_string, wtap_strerror(err));
4020     }
4021     break;
4022   }
4023   g_free(save_file_string);
4024 }
4025
4026 static void
4027 show_print_file_io_error(int err)
4028 {
4029   switch (err) {
4030
4031   case ENOSPC:
4032     cmdarg_err("Not all the packets could be printed because there is "
4033 "no space left on the file system.");
4034     break;
4035
4036 #ifdef EDQUOT
4037   case EDQUOT:
4038     cmdarg_err("Not all the packets could be printed because you are "
4039 "too close to, or over your disk quota.");
4040   break;
4041 #endif
4042
4043   default:
4044     cmdarg_err("An error occurred while printing packets: %s.",
4045       g_strerror(err));
4046     break;
4047   }
4048 }
4049
4050 static const char *
4051 cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
4052                       int file_type)
4053 {
4054   const char *errmsg;
4055   static char errmsg_errno[1024+1];
4056
4057   if (err < 0) {
4058     /* Wiretap error. */
4059     switch (err) {
4060
4061     case WTAP_ERR_NOT_REGULAR_FILE:
4062       errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
4063       break;
4064
4065     case WTAP_ERR_RANDOM_OPEN_PIPE:
4066       /* Seen only when opening a capture file for reading. */
4067       errmsg = "The file \"%s\" is a pipe or FIFO; TShark can't read pipe or FIFO files in two-pass mode.";
4068       break;
4069
4070     case WTAP_ERR_FILE_UNKNOWN_FORMAT:
4071       /* Seen only when opening a capture file for reading. */
4072       errmsg = "The file \"%s\" isn't a capture file in a format TShark understands.";
4073       break;
4074
4075     case WTAP_ERR_UNSUPPORTED:
4076       /* Seen only when opening a capture file for reading. */
4077       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4078                "The file \"%%s\" isn't a capture file in a format TShark understands.\n"
4079                "(%s)", err_info);
4080       g_free(err_info);
4081       errmsg = errmsg_errno;
4082       break;
4083
4084     case WTAP_ERR_CANT_WRITE_TO_PIPE:
4085       /* Seen only when opening a capture file for writing. */
4086       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4087                  "The file \"%%s\" is a pipe, and \"%s\" capture files can't be "
4088                  "written to a pipe.", wtap_file_type_subtype_short_string(file_type));
4089       errmsg = errmsg_errno;
4090       break;
4091
4092     case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
4093       /* Seen only when opening a capture file for writing. */
4094       errmsg = "TShark doesn't support writing capture files in that format.";
4095       break;
4096
4097     case WTAP_ERR_UNSUPPORTED_ENCAP:
4098       if (for_writing) {
4099         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4100                    "TShark can't save this capture as a \"%s\" file.",
4101                    wtap_file_type_subtype_short_string(file_type));
4102       } else {
4103         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4104                  "The file \"%%s\" is a capture for a network type that TShark doesn't support.\n"
4105                  "(%s)", err_info);
4106         g_free(err_info);
4107       }
4108       errmsg = errmsg_errno;
4109       break;
4110
4111     case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
4112       if (for_writing) {
4113         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4114                    "TShark can't save this capture as a \"%s\" file.",
4115                    wtap_file_type_subtype_short_string(file_type));
4116         errmsg = errmsg_errno;
4117       } else
4118         errmsg = "The file \"%s\" is a capture for a network type that TShark doesn't support.";
4119       break;
4120
4121     case WTAP_ERR_BAD_FILE:
4122       /* Seen only when opening a capture file for reading. */
4123       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4124                "The file \"%%s\" appears to be damaged or corrupt.\n"
4125                "(%s)", err_info);
4126       g_free(err_info);
4127       errmsg = errmsg_errno;
4128       break;
4129
4130     case WTAP_ERR_CANT_OPEN:
4131       if (for_writing)
4132         errmsg = "The file \"%s\" could not be created for some unknown reason.";
4133       else
4134         errmsg = "The file \"%s\" could not be opened for some unknown reason.";
4135       break;
4136
4137     case WTAP_ERR_SHORT_READ:
4138       errmsg = "The file \"%s\" appears to have been cut short"
4139                " in the middle of a packet or other data.";
4140       break;
4141
4142     case WTAP_ERR_SHORT_WRITE:
4143       errmsg = "A full header couldn't be written to the file \"%s\".";
4144       break;
4145
4146     case WTAP_ERR_COMPRESSION_NOT_SUPPORTED:
4147       errmsg = "This file type cannot be written as a compressed file.";
4148       break;
4149
4150     case WTAP_ERR_DECOMPRESS:
4151       /* Seen only when opening a capture file for reading. */
4152       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4153                  "The compressed file \"%%s\" appears to be damaged or corrupt.\n"
4154                  "(%s)", err_info);
4155       g_free(err_info);
4156       errmsg = errmsg_errno;
4157       break;
4158
4159     default:
4160       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
4161                  "The file \"%%s\" could not be %s: %s.",
4162                  for_writing ? "created" : "opened",
4163                  wtap_strerror(err));
4164       errmsg = errmsg_errno;
4165       break;
4166     }
4167   } else
4168     errmsg = file_open_error_message(err, for_writing);
4169   return errmsg;
4170 }
4171
4172 /*
4173  * Open/create errors are reported with an console message in TShark.
4174  */
4175 static void
4176 open_failure_message(const char *filename, int err, gboolean for_writing)
4177 {
4178   fprintf(stderr, "tshark: ");
4179   fprintf(stderr, file_open_error_message(err, for_writing), filename);
4180   fprintf(stderr, "\n");
4181 }
4182
4183
4184 /*
4185  * General errors are reported with an console message in TShark.
4186  */
4187 static void
4188 failure_message(const char *msg_format, va_list ap)
4189 {
4190   fprintf(stderr, "tshark: ");
4191   vfprintf(stderr, msg_format, ap);
4192   fprintf(stderr, "\n");
4193 }
4194
4195 /*
4196  * Read errors are reported with an console message in TShark.
4197  */
4198 static void
4199 read_failure_message(const char *filename, int err)
4200 {
4201   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
4202           filename, g_strerror(err));
4203 }
4204
4205 /*
4206  * Write errors are reported with an console message in TShark.
4207  */
4208 static void
4209 write_failure_message(const char *filename, int err)
4210 {
4211   cmdarg_err("An error occurred while writing to the file \"%s\": %s.",
4212           filename, g_strerror(err));
4213 }
4214
4215 /*
4216  * Report an error in command-line arguments.
4217  */
4218 void
4219 cmdarg_err(const char *fmt, ...)
4220 {
4221   va_list ap;
4222
4223   va_start(ap, fmt);
4224   failure_message(fmt, ap);
4225   va_end(ap);
4226 }
4227
4228 /*
4229  * Report additional information for an error in command-line arguments.
4230  */
4231 void
4232 cmdarg_err_cont(const char *fmt, ...)
4233 {
4234   va_list ap;
4235
4236   va_start(ap, fmt);
4237   vfprintf(stderr, fmt, ap);
4238   fprintf(stderr, "\n");
4239   va_end(ap);
4240 }
4241
4242
4243 /*
4244  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
4245  *
4246  * Local variables:
4247  * c-basic-offset: 2
4248  * tab-width: 8
4249  * indent-tabs-mode: nil
4250  * End:
4251  *
4252  * vi: set shiftwidth=2 tabstop=8 expandtab:
4253  * :indentSize=2:tabSize=8:noTabs=true:
4254  */