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