tshark.c

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