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