tfshark.c

   1 /* tfshark.c
   2  *
   3  * Text-mode variant of Fileshark, based off of TShark,
   4  *
   5  * Wireshark - Network traffic analyzer
   6  * By Gerald Combs <gerald@wireshark.org>
   7  * Copyright 1998 Gerald Combs
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version 2
  12  * of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  22  */
  23
  24 #include "config.h"
  25
  26 #include <stdlib.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29 #include <ctype.h>
  30 #include <locale.h>
  31 #include <limits.h>
  32
  33 #ifdef HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36
  37 #ifdef HAVE_GETOPT_H
  38 #include <getopt.h>
  39 #endif
  40
  41 #include <errno.h>
  42
  43 #ifdef HAVE_FCNTL_H
  44 #include <fcntl.h>
  45 #endif
  46
  47 #include <signal.h>
  48
  49 #ifdef HAVE_SYS_STAT_H
  50 # include <sys/stat.h>
  51 #endif
  52
  53 #ifndef HAVE_GETOPT
  54 #include "wsutil/wsgetopt.h"
  55 #endif
  56
  57 #include <glib.h>
  58
  59 #include <epan/exceptions.h>
  60 #include <epan/epan-int.h>
  61 #include <epan/epan.h>
  62 #include <wsutil/crash_info.h>
  63 #include <wsutil/privileges.h>
  64 #include <wsutil/file_util.h>
  65 #include <wsutil/filesystem.h>
  66 #include <wsutil/report_err.h>
  67
  68 #include "globals.h"
  69 #include <epan/timestamp.h>
  70 #include <epan/packet.h>
  71 #ifdef HAVE_LUA
  72 #include <epan/wslua/init_wslua.h>
  73 #endif
  74 #include "file.h"
  75 #include "frame_tvbuff.h"
  76 #include <epan/disabled_protos.h>
  77 #include <epan/prefs.h>
  78 #include <epan/column.h>
  79 #include <epan/print.h>
  80 #include <epan/addr_resolv.h>
  81 #include "ui/util.h"
  82 #include "clopts_common.h"
  83 #include "cmdarg_err.h"
  84 #include "version_info.h"
  85 #include "register.h"
  86 #include <epan/epan_dissect.h>
  87 #include <epan/tap.h>
  88 #include <epan/stat_cmd_args.h>
  89 #include <epan/timestamp.h>
  90 #include <epan/ex-opt.h>
  91 #include <filetap/ftap.h>
  92 #include <wiretap/wtap-int.h>
  93 #include <wiretap/file_wrappers.h>
  94
  95 #ifdef _WIN32
  96 #include <wsutil/unicode-utils.h>
  97 #endif /* _WIN32 */
  98
  99 #include "log.h"
 100 #include <epan/funnel.h>
 101
 102 #ifdef HAVE_PLUGINS
 103 #include <wsutil/plugins.h>
 104 #endif
 105
 106 /*
 107  * This is the template for the decode as option; it is shared between the
 108  * various functions that output the usage for this parameter.
 109  */
 110 static const gchar decode_as_arg_template[] = "<layer_type>==<selector>,<decode_as_protocol>";
 111
 112 static guint32 cum_bytes;
 113 static const frame_data *ref;
 114 static frame_data ref_frame;
 115 static frame_data *prev_dis;
 116 static frame_data prev_dis_frame;
 117 static frame_data *prev_cap;
 118 static frame_data prev_cap_frame;
 119
 120 static const char* prev_display_dissector_name = NULL;
 121
 122 static gboolean perform_two_pass_analysis;
 123
 124 /*
 125  * The way the packet decode is to be written.
 126  */
 127 typedef enum {
 128   WRITE_TEXT,   /* summary or detail text */
 129   WRITE_XML,    /* PDML or PSML */
 130   WRITE_FIELDS  /* User defined list of fields */
 131   /* Add CSV and the like here */
 132 } output_action_e;
 133
 134 static output_action_e output_action;
 135 static gboolean do_dissection;     /* TRUE if we have to dissect each packet */
 136 static gboolean print_packet_info; /* TRUE if we're to print packet information */
 137 static gint print_summary = -1;    /* TRUE if we're to print packet summary information */
 138 static gboolean print_details;     /* TRUE if we're to print packet details information */
 139 static gboolean print_hex;         /* TRUE if we're to print hex/ascci information */
 140 static gboolean line_buffered;
 141 static gboolean really_quiet = FALSE;
 142
 143 static print_format_e print_format = PR_FMT_TEXT;
 144 static print_stream_t *print_stream;
 145
 146 static output_fields_t* output_fields  = NULL;
 147
 148 /* The line separator used between packets, changeable via the -S option */
 149 static const char *separator = "";
 150
 151 static int load_cap_file(capture_file *, int, gint64);
 152 static gboolean process_packet(capture_file *cf, epan_dissect_t *edt, gint64 offset,
 153     struct wtap_pkthdr *whdr, const guchar *pd, guint tap_flags);
 154 static void show_print_file_io_error(int err);
 155 static gboolean write_preamble(capture_file *cf);
 156 static gboolean print_packet(capture_file *cf, epan_dissect_t *edt);
 157 static gboolean write_finale(void);
 158 static const char *cf_open_error_message(int err, gchar *err_info,
 159     gboolean for_writing, int file_type);
 160
 161 static void open_failure_message(const char *filename, int err,
 162     gboolean for_writing);
 163 static void failure_message(const char *msg_format, va_list ap);
 164 static void read_failure_message(const char *filename, int err);
 165 static void write_failure_message(const char *filename, int err);
 166
 167 capture_file cfile;
 168
 169 #if 0
 170 struct string_elem {
 171   const char *sstr;   /* The short string */
 172   const char *lstr;   /* The long string */
 173 };
 174
 175 static gint
 176 string_compare(gconstpointer a, gconstpointer b)
 177 {
 178   return strcmp(((const struct string_elem *)a)->sstr,
 179                 ((const struct string_elem *)b)->sstr);
 180 }
 181
 182 static void
 183 string_elem_print(gpointer data, gpointer not_used _U_)
 184 {
 185   fprintf(stderr, "    %s - %s\n",
 186           ((struct string_elem *)data)->sstr,
 187           ((struct string_elem *)data)->lstr);
 188 }
 189 #endif
 190
 191 static void
 192 print_usage(gboolean print_ver)
 193 {
 194   FILE *output;
 195
 196   if (print_ver) {
 197     output = stdout;
 198     fprintf(output,
 199         "TFShark " VERSION "%s\n"
 200         "Dump and analyze network traffic.\n"
 201         "See http://www.wireshark.org for more information.\n"
 202         "\n"
 203         "%s",
 204          wireshark_gitversion, get_copyright_info());
 205   } else {
 206     output = stderr;
 207   }
 208   fprintf(output, "\n");
 209   fprintf(output, "Usage: tfshark [options] ...\n");
 210   fprintf(output, "\n");
 211
 212   /*fprintf(output, "\n");*/
 213   fprintf(output, "Input file:\n");
 214   fprintf(output, "  -r <infile>              set the filename to read from (no pipes or stdin!)\n");
 215
 216   fprintf(output, "\n");
 217   fprintf(output, "Processing:\n");
 218   fprintf(output, "  -2                       perform a two-pass analysis\n");
 219   fprintf(output, "  -R <read filter>         packet Read filter in Wireshark display filter syntax\n");
 220   fprintf(output, "  -Y <display filter>      packet displaY filter in Wireshark display filter\n");
 221   fprintf(output, "                           syntax\n");
 222   fprintf(output, "  -d %s ...\n", decode_as_arg_template);
 223   fprintf(output, "                           \"Decode As\", see the man page for details\n");
 224   fprintf(output, "                           Example: tcp.port==8888,http\n");
 225
 226   /*fprintf(output, "\n");*/
 227   fprintf(output, "Output:\n");
 228   fprintf(output, "  -C <config profile>      start with specified configuration profile\n");
 229   fprintf(output, "  -V                       add output of packet tree        (Packet Details)\n");
 230   fprintf(output, "  -O <protocols>           Only show packet details of these protocols, comma\n");
 231   fprintf(output, "                           separated\n");
 232   fprintf(output, "  -S <separator>           the line separator to print between packets\n");
 233   fprintf(output, "  -x                       add output of hex and ASCII dump (Packet Bytes)\n");
 234   fprintf(output, "  -T pdml|ps|psml|text|fields\n");
 235   fprintf(output, "                           format of text output (def: text)\n");
 236   fprintf(output, "  -e <field>               field to print if -Tfields selected (e.g. tcp.port,\n");
 237   fprintf(output, "                           _ws.col.Info)\n");
 238   fprintf(output, "                           this option can be repeated to print multiple fields\n");
 239   fprintf(output, "  -E<fieldsoption>=<value> set options for output when -Tfields selected:\n");
 240   fprintf(output, "     header=y|n            switch headers on and off\n");
 241   fprintf(output, "     separator=/t|/s|<char> select tab, space, printable character as separator\n");
 242   fprintf(output, "     occurrence=f|l|a      print first, last or all occurrences of each field\n");
 243   fprintf(output, "     aggregator=,|/s|<char> select comma, space, printable character as\n");
 244   fprintf(output, "                           aggregator\n");
 245   fprintf(output, "     quote=d|s|n           select double, single, no quotes for values\n");
 246   fprintf(output, "  -t a|ad|d|dd|e|r|u|ud    output format of time stamps (def: r: rel. to first)\n");
 247   fprintf(output, "  -u s|hms                 output format of seconds (def: s: seconds)\n");
 248   fprintf(output, "  -l                       flush standard output after each packet\n");
 249   fprintf(output, "  -q                       be more quiet on stdout (e.g. when using statistics)\n");
 250   fprintf(output, "  -Q                       only log true errors to stderr (quieter than -q)\n");
 251   fprintf(output, "  -X <key>:<value>         eXtension options, see the man page for details\n");
 252   fprintf(output, "  -z <statistics>          various statistics, see the man page for details\n");
 253
 254   fprintf(output, "\n");
 255   fprintf(output, "Miscellaneous:\n");
 256   fprintf(output, "  -h                       display this help and exit\n");
 257   fprintf(output, "  -v                       display version info and exit\n");
 258   fprintf(output, "  -o <name>:<value> ...    override preference setting\n");
 259   fprintf(output, "  -K <keytab>              keytab file to use for kerberos decryption\n");
 260   fprintf(output, "  -G [report]              dump one of several available reports and exit\n");
 261   fprintf(output, "                           default report=\"fields\"\n");
 262   fprintf(output, "                           use \"-G ?\" for more help\n");
 263 }
 264
 265 static void
 266 glossary_option_help(void)
 267 {
 268   FILE *output;
 269
 270   output = stdout;
 271
 272   fprintf(output, "TFShark " VERSION "%s\n", wireshark_gitversion);
 273
 274   fprintf(output, "\n");
 275   fprintf(output, "Usage: tfshark -G [report]\n");
 276   fprintf(output, "\n");
 277   fprintf(output, "Glossary table reports:\n");
 278   fprintf(output, "  -G column-formats        dump column format codes and exit\n");
 279   fprintf(output, "  -G decodes               dump \"layer type\"/\"decode as\" associations and exit\n");
 280   fprintf(output, "  -G fields                dump fields glossary and exit\n");
 281   fprintf(output, "  -G ftypes                dump field type basic and descriptive names\n");
 282   fprintf(output, "  -G heuristic-decodes     dump heuristic dissector tables\n");
 283   fprintf(output, "  -G plugins               dump installed plugins and exit\n");
 284   fprintf(output, "  -G protocols             dump protocols in registration database and exit\n");
 285   fprintf(output, "  -G values                dump value, range, true/false strings and exit\n");
 286   fprintf(output, "\n");
 287   fprintf(output, "Preference reports:\n");
 288   fprintf(output, "  -G currentprefs          dump current preferences and exit\n");
 289   fprintf(output, "  -G defaultprefs          dump default preferences and exit\n");
 290   fprintf(output, "\n");
 291 }
 292
 293 /*
 294  * For a dissector table, print on the stream described by output,
 295  * its short name (which is what's used in the "-d" option) and its
 296  * descriptive name.
 297  */
 298 static void
 299 display_dissector_table_names(const char *table_name, const char *ui_name,
 300                               gpointer output)
 301 {
 302   if ((prev_display_dissector_name == NULL) ||
 303       (strcmp(prev_display_dissector_name, table_name) != 0)) {
 304      fprintf((FILE *)output, "\t%s (%s)\n", table_name, ui_name);
 305      prev_display_dissector_name = table_name;
 306   }
 307 }
 308
 309 /*
 310  * For a dissector handle, print on the stream described by output,
 311  * the filter name (which is what's used in the "-d" option) and the full
 312  * name for the protocol that corresponds to this handle.
 313  */
 314 static void
 315 display_dissector_names(const gchar *table _U_, gpointer handle, gpointer output)
 316 {
 317   int          proto_id;
 318   const gchar *proto_filter_name;
 319   const gchar *proto_ui_name;
 320
 321   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
 322
 323   if (proto_id != -1) {
 324     proto_filter_name = proto_get_protocol_filter_name(proto_id);
 325     proto_ui_name =  proto_get_protocol_name(proto_id);
 326     g_assert(proto_filter_name != NULL);
 327     g_assert(proto_ui_name != NULL);
 328
 329     if ((prev_display_dissector_name == NULL) ||
 330         (strcmp(prev_display_dissector_name, proto_filter_name) != 0)) {
 331       fprintf((FILE *)output, "\t%s (%s)\n",
 332               proto_filter_name,
 333               proto_ui_name);
 334        prev_display_dissector_name = proto_filter_name;
 335     }
 336   }
 337 }
 338
 339 /*
 340  * The protocol_name_search structure is used by find_protocol_name_func()
 341  * to pass parameters and store results
 342  */
 343 struct protocol_name_search{
 344   gchar              *searched_name;  /* Protocol filter name we are looking for */
 345   dissector_handle_t  matched_handle; /* Handle for a dissector whose protocol has the specified filter name */
 346   guint               nb_match;       /* How many dissectors matched searched_name */
 347 };
 348 typedef struct protocol_name_search *protocol_name_search_t;
 349
 350 /*
 351  * This function parses all dissectors associated with a table to find the
 352  * one whose protocol has the specified filter name.  It is called
 353  * as a reference function in a call to dissector_table_foreach_handle.
 354  * The name we are looking for, as well as the results, are stored in the
 355  * protocol_name_search struct pointed to by user_data.
 356  * If called using dissector_table_foreach_handle, we actually parse the
 357  * whole list of dissectors.
 358  */
 359 static void
 360 find_protocol_name_func(const gchar *table _U_, gpointer handle, gpointer user_data)
 361
 362 {
 363   int                     proto_id;
 364   const gchar            *protocol_filter_name;
 365   protocol_name_search_t  search_info;
 366
 367   g_assert(handle);
 368
 369   search_info = (protocol_name_search_t)user_data;
 370
 371   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
 372   if (proto_id != -1) {
 373     protocol_filter_name = proto_get_protocol_filter_name(proto_id);
 374     g_assert(protocol_filter_name != NULL);
 375     if (strcmp(protocol_filter_name, search_info->searched_name) == 0) {
 376       /* Found a match */
 377       if (search_info->nb_match == 0) {
 378         /* Record this handle only if this is the first match */
 379         search_info->matched_handle = (dissector_handle_t)handle; /* Record the handle for this matching dissector */
 380       }
 381       search_info->nb_match++;
 382     }
 383   }
 384 }
 385
 386 /*
 387  * Allow dissector key names to be sorted alphabetically
 388  */
 389
 390 static gint
 391 compare_dissector_key_name(gconstpointer dissector_a, gconstpointer dissector_b)
 392 {
 393   return strcmp((const char*)dissector_a, (const char*)dissector_b);
 394 }
 395
 396 /*
 397  * Print all layer type names supported.
 398  * We send the output to the stream described by the handle output.
 399  */
 400
 401 static void
 402 fprint_all_layer_types(FILE *output)
 403
 404 {
 405   prev_display_dissector_name = NULL;
 406   dissector_all_tables_foreach_table(display_dissector_table_names, (gpointer)output, (GCompareFunc)compare_dissector_key_name);
 407 }
 408
 409 /*
 410  * Print all protocol names supported for a specific layer type.
 411  * table_name contains the layer type name in which the search is performed.
 412  * We send the output to the stream described by the handle output.
 413  */
 414
 415 static void
 416 fprint_all_protocols_for_layer_types(FILE *output, gchar *table_name)
 417
 418 {
 419   prev_display_dissector_name = NULL;
 420   dissector_table_foreach_handle(table_name,
 421                                  display_dissector_names,
 422                                  (gpointer)output);
 423 }
 424
 425 /*
 426  * The function below parses the command-line parameters for the decode as
 427  * feature (a string pointer by cl_param).
 428  * It checks the format of the command-line, searches for a matching table
 429  * and dissector.  If a table/dissector match is not found, we display a
 430  * summary of the available tables/dissectors (on stderr) and return FALSE.
 431  * If everything is fine, we get the "Decode as" preference activated,
 432  * then we return TRUE.
 433  */
 434 static gboolean
 435 add_decode_as(const gchar *cl_param)
 436 {
 437   gchar                        *table_name;
 438   guint32                       selector, selector2;
 439   gchar                        *decoded_param;
 440   gchar                        *remaining_param;
 441   gchar                        *selector_str;
 442   gchar                        *dissector_str;
 443   dissector_handle_t            dissector_matching;
 444   dissector_table_t             table_matching;
 445   ftenum_t                      dissector_table_selector_type;
 446   struct protocol_name_search   user_protocol_name;
 447   guint64                       i;
 448   char                          op;
 449
 450   /* The following code will allocate and copy the command-line options in a string pointed by decoded_param */
 451
 452   g_assert(cl_param);
 453   decoded_param = g_strdup(cl_param);
 454   g_assert(decoded_param);
 455
 456
 457   /* The lines below will parse this string (modifying it) to extract all
 458     necessary information.  Note that decoded_param is still needed since
 459     strings are not copied - we just save pointers. */
 460
 461   /* This section extracts a layer type (table_name) from decoded_param */
 462   table_name = decoded_param; /* Layer type string starts from beginning */
 463
 464   remaining_param = strchr(table_name, '=');
 465   if (remaining_param == NULL) {
 466     cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
 467     /* If the argument does not follow the template, carry on anyway to check
 468        if the table name is at least correct.  If remaining_param is NULL,
 469        we'll exit anyway further down */
 470   }
 471   else {
 472     *remaining_param = '\0'; /* Terminate the layer type string (table_name) where '=' was detected */
 473   }
 474
 475   /* Remove leading and trailing spaces from the table name */
 476   while ( table_name[0] == ' ' )
 477     table_name++;
 478   while ( table_name[strlen(table_name) - 1] == ' ' )
 479     table_name[strlen(table_name) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
 480
 481 /* The following part searches a table matching with the layer type specified */
 482   table_matching = NULL;
 483
 484 /* Look for the requested table */
 485   if ( !(*(table_name)) ) { /* Is the table name empty, if so, don't even search for anything, display a message */
 486     cmdarg_err("No layer type specified"); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
 487   }
 488   else {
 489     table_matching = find_dissector_table(table_name);
 490     if (!table_matching) {
 491       cmdarg_err("Unknown layer type -- %s", table_name); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
 492     }
 493   }
 494
 495   if (!table_matching) {
 496     /* Display a list of supported layer types to help the user, if the
 497        specified layer type was not found */
 498     cmdarg_err("Valid layer types are:");
 499     fprint_all_layer_types(stderr);
 500   }
 501   if (remaining_param == NULL || !table_matching) {
 502     /* Exit if the layer type was not found, or if no '=' separator was found
 503        (see above) */
 504     g_free(decoded_param);
 505     return FALSE;
 506   }
 507
 508   if (*(remaining_param + 1) != '=') { /* Check for "==" and not only '=' */
 509     cmdarg_err("WARNING: -d requires \"==\" instead of \"=\". Option will be treated as \"%s==%s\"", table_name, remaining_param + 1);
 510   }
 511   else {
 512     remaining_param++; /* Move to the second '=' */
 513     *remaining_param = '\0'; /* Remove the second '=' */
 514   }
 515   remaining_param++; /* Position after the layer type string */
 516
 517   /* This section extracts a selector value (selector_str) from decoded_param */
 518
 519   selector_str = remaining_param; /* Next part starts with the selector number */
 520
 521   remaining_param = strchr(selector_str, ',');
 522   if (remaining_param == NULL) {
 523     cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
 524     /* If the argument does not follow the template, carry on anyway to check
 525        if the selector value is at least correct.  If remaining_param is NULL,
 526        we'll exit anyway further down */
 527   }
 528   else {
 529     *remaining_param = '\0'; /* Terminate the selector number string (selector_str) where ',' was detected */
 530   }
 531
 532   dissector_table_selector_type = get_dissector_table_selector_type(table_name);
 533
 534   switch (dissector_table_selector_type) {
 535
 536   case FT_UINT8:
 537   case FT_UINT16:
 538   case FT_UINT24:
 539   case FT_UINT32:
 540     /* The selector for this table is an unsigned number.  Parse it as such.
 541        There's no need to remove leading and trailing spaces from the
 542        selector number string, because sscanf will do that for us. */
 543     switch (sscanf(selector_str, "%u%c%u", &selector, &op, &selector2)) {
 544       case 1:
 545         op = '\0';
 546         break;
 547       case 3:
 548         if (op != ':' && op != '-') {
 549             cmdarg_err("Invalid selector numeric range \"%s\"", selector_str);
 550             g_free(decoded_param);
 551             return FALSE;
 552         }
 553         if (op == ':') {
 554             if ((selector2 == 0) || ((guint64)selector + selector2 - 1) > G_MAXUINT32) {
 555                 cmdarg_err("Invalid selector numeric range \"%s\"", selector_str);
 556                 g_free(decoded_param);
 557                 return FALSE;
 558             }
 559         }
 560         else if (selector2 < selector) {
 561             /* We could swap them for the user, but maybe it's better to call
 562              * this out as an error in case it's not what was intended? */
 563             cmdarg_err("Invalid selector numeric range \"%s\"", selector_str);
 564             g_free(decoded_param);
 565             return FALSE;
 566         }
 567         break;
 568       default:
 569         cmdarg_err("Invalid selector number \"%s\"", selector_str);
 570         g_free(decoded_param);
 571         return FALSE;
 572     }
 573     break;
 574
 575   case FT_STRING:
 576   case FT_STRINGZ:
 577   case FT_UINT_STRING:
 578   case FT_STRINGZPAD:
 579     /* The selector for this table is a string. */
 580     break;
 581
 582   default:
 583     /* There are currently no dissector tables with any types other
 584        than the ones listed above. */
 585     g_assert_not_reached();
 586   }
 587
 588   if (remaining_param == NULL) {
 589     /* Exit if no ',' separator was found (see above) */
 590     cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
 591     fprint_all_protocols_for_layer_types(stderr, table_name);
 592     g_free(decoded_param);
 593     return FALSE;
 594   }
 595
 596   remaining_param++; /* Position after the selector number string */
 597
 598   /* This section extracts a protocol filter name (dissector_str) from decoded_param */
 599
 600   dissector_str = remaining_param; /* All the rest of the string is the dissector (decode as protocol) name */
 601
 602   /* Remove leading and trailing spaces from the dissector name */
 603   while ( dissector_str[0] == ' ' )
 604     dissector_str++;
 605   while ( dissector_str[strlen(dissector_str) - 1] == ' ' )
 606     dissector_str[strlen(dissector_str) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
 607
 608   dissector_matching = NULL;
 609
 610   /* We now have a pointer to the handle for the requested table inside the variable table_matching */
 611   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 */
 612     cmdarg_err("No protocol name specified"); /* Note, we don't exit here, but dissector_matching will remain NULL, so we exit below */
 613   }
 614   else {
 615     user_protocol_name.nb_match = 0;
 616     user_protocol_name.searched_name = dissector_str;
 617     user_protocol_name.matched_handle = NULL;
 618
 619     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 */
 620
 621     if (user_protocol_name.nb_match != 0) {
 622       dissector_matching = user_protocol_name.matched_handle;
 623       if (user_protocol_name.nb_match > 1) {
 624         cmdarg_err("WARNING: Protocol \"%s\" matched %u dissectors, first one will be used", dissector_str, user_protocol_name.nb_match);
 625       }
 626     }
 627     else {
 628       /* OK, check whether the problem is that there isn't any such
 629          protocol, or that there is but it's not specified as a protocol
 630          that's valid for that dissector table.
 631          Note, we don't exit here, but dissector_matching will remain NULL,
 632          so we exit below */
 633       if (proto_get_id_by_filter_name(dissector_str) == -1) {
 634         /* No such protocol */
 635         cmdarg_err("Unknown protocol -- \"%s\"", dissector_str);
 636       } else {
 637         cmdarg_err("Protocol \"%s\" isn't valid for layer type \"%s\"",
 638                    dissector_str, table_name);
 639       }
 640     }
 641   }
 642
 643   if (!dissector_matching) {
 644     cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
 645     fprint_all_protocols_for_layer_types(stderr, table_name);
 646     g_free(decoded_param);
 647     return FALSE;
 648   }
 649
 650 /* This is the end of the code that parses the command-line options.
 651    All information is now stored in the variables:
 652    table_name
 653    selector
 654    dissector_matching
 655    The above variables that are strings are still pointing to areas within
 656    decoded_parm.  decoded_parm thus still needs to be kept allocated in
 657    until we stop needing these variables
 658    decoded_param will be deallocated at each exit point of this function */
 659
 660
 661   /* We now have a pointer to the handle for the requested dissector
 662      (requested protocol) inside the variable dissector_matching */
 663   switch (dissector_table_selector_type) {
 664
 665   case FT_UINT8:
 666   case FT_UINT16:
 667   case FT_UINT24:
 668   case FT_UINT32:
 669     /* The selector for this table is an unsigned number. */
 670     if (op == '\0') {
 671       dissector_change_uint(table_name, selector, dissector_matching);
 672     } else if (op == ':') {
 673       for (i = selector; i < (guint64)selector + selector2; i++) {
 674         dissector_change_uint(table_name, (guint32)i, dissector_matching);
 675       }
 676     } else { /* op == '-' */
 677       for (i = selector; i <= selector2; i++) {
 678         dissector_change_uint(table_name, (guint32)i, dissector_matching);
 679       }
 680     }
 681     break;
 682
 683   case FT_STRING:
 684   case FT_STRINGZ:
 685   case FT_UINT_STRING:
 686   case FT_STRINGZPAD:
 687     /* The selector for this table is a string. */
 688     dissector_change_string(table_name, selector_str, dissector_matching);
 689     break;
 690
 691   default:
 692     /* There are currently no dissector tables with any types other
 693        than the ones listed above. */
 694     g_assert_not_reached();
 695   }
 696   g_free(decoded_param); /* "Decode As" rule has been successfully added */
 697   return TRUE;
 698 }
 699
 700 static void
 701 tfshark_log_handler (const gchar *log_domain, GLogLevelFlags log_level,
 702     const gchar *message, gpointer user_data)
 703 {
 704   /* ignore log message, if log_level isn't interesting based
 705      upon the console log preferences.
 706      If the preferences haven't been loaded loaded yet, display the
 707      message anyway.
 708
 709      The default console_log_level preference value is such that only
 710        ERROR, CRITICAL and WARNING level messages are processed;
 711        MESSAGE, INFO and DEBUG level messages are ignored.
 712
 713      XXX: Aug 07, 2009: Prior tshark g_log code was hardwired to process only
 714            ERROR and CRITICAL level messages so the current code is a behavioral
 715            change.  The current behavior is the same as in Wireshark.
 716   */
 717   if ((log_level & G_LOG_LEVEL_MASK & prefs.console_log_level) == 0 &&
 718      prefs.console_log_level != 0) {
 719     return;
 720   }
 721
 722   g_log_default_handler(log_domain, log_level, message, user_data);
 723
 724 }
 725
 726 static void
 727 print_current_user(void) {
 728   gchar *cur_user, *cur_group;
 729
 730   if (started_with_special_privs()) {
 731     cur_user = get_cur_username();
 732     cur_group = get_cur_groupname();
 733     fprintf(stderr, "Running as user \"%s\" and group \"%s\".",
 734       cur_user, cur_group);
 735     g_free(cur_user);
 736     g_free(cur_group);
 737     if (running_with_special_privs()) {
 738       fprintf(stderr, " This could be dangerous.");
 739     }
 740     fprintf(stderr, "\n");
 741   }
 742 }
 743
 744 static void
 745 show_version(GString *comp_info_str, GString *runtime_info_str)
 746 {
 747   printf("TFShark " VERSION "%s\n"
 748          "\n"
 749          "%s"
 750          "\n"
 751          "%s"
 752          "\n"
 753          "%s",
 754          wireshark_gitversion, get_copyright_info(), comp_info_str->str,
 755          runtime_info_str->str);
 756 }
 757
 758 int
 759 main(int argc, char *argv[])
 760 {
 761   GString             *comp_info_str;
 762   GString             *runtime_info_str;
 763   char                *init_progfile_dir_error;
 764   int                  opt;
 765   gboolean             arg_error = FALSE;
 766
 767   char                *gpf_path, *pf_path;
 768   char                *gdp_path, *dp_path;
 769   int                  gpf_open_errno, gpf_read_errno;
 770   int                  pf_open_errno, pf_read_errno;
 771   int                  gdp_open_errno, gdp_read_errno;
 772   int                  dp_open_errno, dp_read_errno;
 773   int                  err;
 774   volatile int         exit_status = 0;
 775   gboolean             quiet = FALSE;
 776   gchar               *volatile cf_name = NULL;
 777   gchar               *rfilter = NULL;
 778   gchar               *dfilter = NULL;
 779   dfilter_t           *rfcode = NULL;
 780   dfilter_t           *dfcode = NULL;
 781   e_prefs             *prefs_p;
 782   int                  log_flags;
 783   int                  optind_initial;
 784   gchar               *output_only = NULL;
 785
 786 /* the leading - ensures that getopt() does not permute the argv[] entries
 787    we have to make sure that the first getopt() preserves the content of argv[]
 788    for the subsequent getopt_long() call */
 789 #define OPTSTRING "-2C:d:e:E:hK:lo:O:qQr:R:S:t:T:u:vVxX:Y:z:"
 790
 791   static const char    optstring[] = OPTSTRING;
 792
 793   /* Assemble the compile-time version information string */
 794   comp_info_str = g_string_new("Compiled ");
 795   get_compiled_version_info(comp_info_str, NULL, epan_get_compiled_version_info);
 796
 797   /* Assemble the run-time version information string */
 798   runtime_info_str = g_string_new("Running ");
 799   get_runtime_version_info(runtime_info_str, NULL);
 800
 801   /* Add it to the information to be reported on a crash. */
 802   ws_add_crash_info("TFShark " VERSION "%s\n"
 803          "\n"
 804          "%s"
 805          "\n"
 806          "%s",
 807       wireshark_gitversion, comp_info_str->str, runtime_info_str->str);
 808
 809 #ifdef _WIN32
 810   arg_list_utf_16to8(argc, argv);
 811   create_app_running_mutex();
 812 #if !GLIB_CHECK_VERSION(2,31,0)
 813   g_thread_init(NULL);
 814 #endif
 815 #endif /* _WIN32 */
 816
 817   /*
 818    * Get credential information for later use.
 819    */
 820   init_process_policies();
 821
 822   /*
 823    * Attempt to get the pathname of the executable file.
 824    */
 825   init_progfile_dir_error = init_progfile_dir(argv[0], main);
 826   if (init_progfile_dir_error != NULL) {
 827     fprintf(stderr, "tfshark: Can't get pathname of tfshark program: %s.\n",
 828             init_progfile_dir_error);
 829   }
 830
 831   /*
 832    * In order to have the -X opts assigned before the wslua machine starts
 833    * we need to call getopts before epan_init() gets called.
 834    */
 835   opterr = 0;
 836   optind_initial = optind;
 837
 838   while ((opt = getopt(argc, argv, optstring)) != -1) {
 839     switch (opt) {
 840     case 'C':        /* Configuration Profile */
 841       if (profile_exists (optarg, FALSE)) {
 842         set_profile_name (optarg);
 843       } else {
 844         cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
 845         return 1;
 846       }
 847       break;
 848     case 'O':        /* Only output these protocols */
 849       output_only = g_strdup(optarg);
 850       /* FALLTHROUGH */
 851     case 'V':        /* Verbose */
 852       print_details = TRUE;
 853       print_packet_info = TRUE;
 854       break;
 855     case 'x':        /* Print packet data in hex (and ASCII) */
 856       print_hex = TRUE;
 857       /*  The user asked for hex output, so let's ensure they get it,
 858        *  even if they're writing to a file.
 859        */
 860       print_packet_info = TRUE;
 861       break;
 862     case 'X':
 863       ex_opt_add(optarg);
 864       break;
 865     default:
 866       break;
 867     }
 868   }
 869
 870   /*
 871    * Print packet summary information is the default, unless either -V or -x
 872    * were specified.  Note that this is new behavior, which
 873    * allows for the possibility of printing only hex/ascii output without
 874    * necessarily requiring that either the summary or details be printed too.
 875    */
 876   if (print_summary == -1)
 877     print_summary = (print_details || print_hex) ? FALSE : TRUE;
 878
 879   optind = optind_initial;
 880   opterr = 1;
 881
 882
 883
 884 /** Send All g_log messages to our own handler **/
 885
 886   log_flags =
 887                     G_LOG_LEVEL_ERROR|
 888                     G_LOG_LEVEL_CRITICAL|
 889                     G_LOG_LEVEL_WARNING|
 890                     G_LOG_LEVEL_MESSAGE|
 891                     G_LOG_LEVEL_INFO|
 892                     G_LOG_LEVEL_DEBUG|
 893                     G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
 894
 895   g_log_set_handler(NULL,
 896                     (GLogLevelFlags)log_flags,
 897                     tfshark_log_handler, NULL /* user_data */);
 898   g_log_set_handler(LOG_DOMAIN_MAIN,
 899                     (GLogLevelFlags)log_flags,
 900                     tfshark_log_handler, NULL /* user_data */);
 901
 902   initialize_funnel_ops();
 903
 904   init_report_err(failure_message, open_failure_message, read_failure_message,
 905                   write_failure_message);
 906
 907   timestamp_set_type(TS_RELATIVE);
 908   timestamp_set_precision(TS_PREC_AUTO);
 909   timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
 910
 911   init_open_routines();
 912
 913 #ifdef HAVE_PLUGINS
 914   /* Register all the plugin types we have. */
 915   epan_register_plugin_types(); /* Types known to libwireshark */
 916   ftap_register_plugin_types(); /* Types known to libfiletap */
 917
 918   /* Scan for plugins.  This does *not* call their registration routines;
 919      that's done later. */
 920   scan_plugins();
 921
 922   /* Register all libfiletap plugin modules. */
 923   register_all_filetap_modules();
 924
 925 #endif
 926
 927   /* Register all dissectors; we must do this before checking for the
 928      "-G" flag, as the "-G" flag dumps information registered by the
 929      dissectors, and we must do it before we read the preferences, in
 930      case any dissectors register preferences. */
 931   epan_init(register_all_protocols, register_all_protocol_handoffs, NULL, NULL);
 932
 933   /* Register all tap listeners; we do this before we parse the arguments,
 934      as the "-z" argument can specify a registered tap. */
 935
 936   /* we register the plugin taps before the other taps because
 937      stats_tree taps plugins will be registered as tap listeners
 938      by stats_tree_stat.c and need to registered before that */
 939
 940   /* XXX Disable tap registration for now until we can get tfshark set up with
 941    * its own set of taps and the necessary registration function etc.
 942 #ifdef HAVE_PLUGINS
 943   register_all_plugin_tap_listeners();
 944 #endif
 945   register_all_tap_listeners();
 946   */
 947
 948   /* If invoked with the "-G" flag, we dump out information based on
 949      the argument to the "-G" flag; if no argument is specified,
 950      for backwards compatibility we dump out a glossary of display
 951      filter symbols.
 952
 953      XXX - we do this here, for now, to support "-G" with no arguments.
 954      If none of our build or other processes uses "-G" with no arguments,
 955      we can just process it with the other arguments. */
 956   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
 957     proto_initialize_all_prefixes();
 958
 959     if (argc == 2)
 960       proto_registrar_dump_fields();
 961     else {
 962       if (strcmp(argv[2], "column-formats") == 0)
 963         column_dump_column_formats();
 964       else if (strcmp(argv[2], "currentprefs") == 0) {
 965         read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
 966             &pf_open_errno, &pf_read_errno, &pf_path);
 967         write_prefs(NULL);
 968       }
 969       else if (strcmp(argv[2], "decodes") == 0)
 970         dissector_dump_decodes();
 971       else if (strcmp(argv[2], "defaultprefs") == 0)
 972         write_prefs(NULL);
 973       else if (strcmp(argv[2], "fields") == 0)
 974         proto_registrar_dump_fields();
 975       else if (strcmp(argv[2], "ftypes") == 0)
 976         proto_registrar_dump_ftypes();
 977       else if (strcmp(argv[2], "heuristic-decodes") == 0)
 978         dissector_dump_heur_decodes();
 979       else if (strcmp(argv[2], "plugins") == 0) {
 980 #ifdef HAVE_PLUGINS
 981         plugins_dump_all();
 982 #endif
 983 #ifdef HAVE_LUA
 984         wslua_plugins_dump_all();
 985 #endif
 986       }
 987       else if (strcmp(argv[2], "protocols") == 0)
 988         proto_registrar_dump_protocols();
 989       else if (strcmp(argv[2], "values") == 0)
 990         proto_registrar_dump_values();
 991       else if (strcmp(argv[2], "?") == 0)
 992         glossary_option_help();
 993       else if (strcmp(argv[2], "-?") == 0)
 994         glossary_option_help();
 995       else {
 996         cmdarg_err("Invalid \"%s\" option for -G flag, enter -G ? for more help.", argv[2]);
 997         return 1;
 998       }
 999     }
1000     return 0;
1001   }
1002
1003   /* Set the C-language locale to the native environment. */
1004   setlocale(LC_ALL, "");
1005
1006   prefs_p = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
1007                      &pf_open_errno, &pf_read_errno, &pf_path);
1008   if (gpf_path != NULL) {
1009     if (gpf_open_errno != 0) {
1010       cmdarg_err("Can't open global preferences file \"%s\": %s.",
1011               pf_path, g_strerror(gpf_open_errno));
1012     }
1013     if (gpf_read_errno != 0) {
1014       cmdarg_err("I/O error reading global preferences file \"%s\": %s.",
1015               pf_path, g_strerror(gpf_read_errno));
1016     }
1017   }
1018   if (pf_path != NULL) {
1019     if (pf_open_errno != 0) {
1020       cmdarg_err("Can't open your preferences file \"%s\": %s.", pf_path,
1021               g_strerror(pf_open_errno));
1022     }
1023     if (pf_read_errno != 0) {
1024       cmdarg_err("I/O error reading your preferences file \"%s\": %s.",
1025               pf_path, g_strerror(pf_read_errno));
1026     }
1027     g_free(pf_path);
1028     pf_path = NULL;
1029   }
1030
1031   /* Read the disabled protocols file. */
1032   read_disabled_protos_list(&gdp_path, &gdp_open_errno, &gdp_read_errno,
1033                             &dp_path, &dp_open_errno, &dp_read_errno);
1034   if (gdp_path != NULL) {
1035     if (gdp_open_errno != 0) {
1036       cmdarg_err("Could not open global disabled protocols file\n\"%s\": %s.",
1037                  gdp_path, g_strerror(gdp_open_errno));
1038     }
1039     if (gdp_read_errno != 0) {
1040       cmdarg_err("I/O error reading global disabled protocols file\n\"%s\": %s.",
1041                  gdp_path, g_strerror(gdp_read_errno));
1042     }
1043     g_free(gdp_path);
1044   }
1045   if (dp_path != NULL) {
1046     if (dp_open_errno != 0) {
1047       cmdarg_err(
1048         "Could not open your disabled protocols file\n\"%s\": %s.", dp_path,
1049         g_strerror(dp_open_errno));
1050     }
1051     if (dp_read_errno != 0) {
1052       cmdarg_err(
1053         "I/O error reading your disabled protocols file\n\"%s\": %s.", dp_path,
1054         g_strerror(dp_read_errno));
1055     }
1056     g_free(dp_path);
1057   }
1058
1059   cap_file_init(&cfile);
1060
1061   /* Print format defaults to this. */
1062   print_format = PR_FMT_TEXT;
1063
1064   output_fields = output_fields_new();
1065
1066   /* Now get our args */
1067   while ((opt = getopt(argc, argv, optstring)) != -1) {
1068     switch (opt) {
1069     case '2':        /* Perform two pass analysis */
1070       perform_two_pass_analysis = TRUE;
1071       break;
1072     case 'C':
1073       /* Configuration profile settings were already processed just ignore them this time*/
1074       break;
1075     case 'd':        /* Decode as rule */
1076       if (!add_decode_as(optarg))
1077         return 1;
1078       break;
1079 #if defined(HAVE_HEIMDAL_KERBEROS) || defined(HAVE_MIT_KERBEROS)
1080     case 'K':        /* Kerberos keytab file */
1081       read_keytab_file(optarg);
1082       break;
1083 #endif
1084     case 'e':
1085       /* Field entry */
1086       output_fields_add(output_fields, optarg);
1087       break;
1088     case 'E':
1089       /* Field option */
1090       if (!output_fields_set_option(output_fields, optarg)) {
1091         cmdarg_err("\"%s\" is not a valid field output option=value pair.", optarg);
1092         output_fields_list_options(stderr);
1093         return 1;
1094       }
1095       break;
1096
1097     case 'h':        /* Print help and exit */
1098       print_usage(TRUE);
1099       return 0;
1100       break;
1101     case 'l':        /* "Line-buffer" standard output */
1102       /* This isn't line-buffering, strictly speaking, it's just
1103          flushing the standard output after the information for
1104          each packet is printed; however, that should be good
1105          enough for all the purposes to which "-l" is put (and
1106          is probably actually better for "-V", as it does fewer
1107          writes).
1108
1109          See the comment in "process_packet()" for an explanation of
1110          why we do that, and why we don't just use "setvbuf()" to
1111          make the standard output line-buffered (short version: in
1112          Windows, "line-buffered" is the same as "fully-buffered",
1113          and the output buffer is only flushed when it fills up). */
1114       line_buffered = TRUE;
1115       break;
1116     case 'o':        /* Override preference from command line */
1117       switch (prefs_set_pref(optarg)) {
1118
1119       case PREFS_SET_OK:
1120         break;
1121
1122       case PREFS_SET_SYNTAX_ERR:
1123         cmdarg_err("Invalid -o flag \"%s\"", optarg);
1124         return 1;
1125         break;
1126
1127       case PREFS_SET_NO_SUCH_PREF:
1128       case PREFS_SET_OBSOLETE:
1129         cmdarg_err("-o flag \"%s\" specifies unknown preference", optarg);
1130         return 1;
1131         break;
1132       }
1133       break;
1134     case 'q':        /* Quiet */
1135       quiet = TRUE;
1136       break;
1137     case 'Q':        /* Really quiet */
1138       quiet = TRUE;
1139       really_quiet = TRUE;
1140       break;
1141     case 'r':        /* Read capture file x */
1142       cf_name = g_strdup(optarg);
1143       break;
1144     case 'R':        /* Read file filter */
1145       rfilter = optarg;
1146       break;
1147     case 'S':        /* Set the line Separator to be printed between packets */
1148       separator = strdup(optarg);
1149       break;
1150     case 't':        /* Time stamp type */
1151       if (strcmp(optarg, "r") == 0)
1152         timestamp_set_type(TS_RELATIVE);
1153       else if (strcmp(optarg, "a") == 0)
1154         timestamp_set_type(TS_ABSOLUTE);
1155       else if (strcmp(optarg, "ad") == 0)
1156         timestamp_set_type(TS_ABSOLUTE_WITH_YMD);
1157       else if (strcmp(optarg, "adoy") == 0)
1158         timestamp_set_type(TS_ABSOLUTE_WITH_YDOY);
1159       else if (strcmp(optarg, "d") == 0)
1160         timestamp_set_type(TS_DELTA);
1161       else if (strcmp(optarg, "dd") == 0)
1162         timestamp_set_type(TS_DELTA_DIS);
1163       else if (strcmp(optarg, "e") == 0)
1164         timestamp_set_type(TS_EPOCH);
1165       else if (strcmp(optarg, "u") == 0)
1166         timestamp_set_type(TS_UTC);
1167       else if (strcmp(optarg, "ud") == 0)
1168         timestamp_set_type(TS_UTC_WITH_YMD);
1169       else if (strcmp(optarg, "udoy") == 0)
1170         timestamp_set_type(TS_UTC_WITH_YDOY);
1171       else {
1172         cmdarg_err("Invalid time stamp type \"%s\"; it must be one of:", optarg);
1173         cmdarg_err_cont("\t\"a\"    for absolute\n"
1174                         "\t\"ad\"   for absolute with YYYY-MM-DD date\n"
1175                         "\t\"adoy\" for absolute with YYYY/DOY date\n"
1176                         "\t\"d\"    for delta\n"
1177                         "\t\"dd\"   for delta displayed\n"
1178                         "\t\"e\"    for epoch\n"
1179                         "\t\"r\"    for relative\n"
1180                         "\t\"u\"    for absolute UTC\n"
1181                         "\t\"ud\"   for absolute UTC with YYYY-MM-DD date\n"
1182                         "\t\"udoy\" for absolute UTC with YYYY/DOY date");
1183         return 1;
1184       }
1185       break;
1186     case 'T':        /* printing Type */
1187       if (strcmp(optarg, "text") == 0) {
1188         output_action = WRITE_TEXT;
1189         print_format = PR_FMT_TEXT;
1190       } else if (strcmp(optarg, "ps") == 0) {
1191         output_action = WRITE_TEXT;
1192         print_format = PR_FMT_PS;
1193       } else if (strcmp(optarg, "pdml") == 0) {
1194         output_action = WRITE_XML;
1195         print_details = TRUE;   /* Need details */
1196         print_summary = FALSE;  /* Don't allow summary */
1197       } else if (strcmp(optarg, "psml") == 0) {
1198         output_action = WRITE_XML;
1199         print_details = FALSE;  /* Don't allow details */
1200         print_summary = TRUE;   /* Need summary */
1201       } else if (strcmp(optarg, "fields") == 0) {
1202         output_action = WRITE_FIELDS;
1203         print_details = TRUE;   /* Need full tree info */
1204         print_summary = FALSE;  /* Don't allow summary */
1205       } else {
1206         cmdarg_err("Invalid -T parameter \"%s\"; it must be one of:", optarg);                   /* x */
1207         cmdarg_err_cont("\t\"fields\" The values of fields specified with the -e option, in a form\n"
1208                         "\t         specified by the -E option.\n"
1209                         "\t\"pdml\"   Packet Details Markup Language, an XML-based format for the\n"
1210                         "\t         details of a decoded packet. This information is equivalent to\n"
1211                         "\t         the packet details printed with the -V flag.\n"
1212                         "\t\"ps\"     PostScript for a human-readable one-line summary of each of\n"
1213                         "\t         the packets, or a multi-line view of the details of each of\n"
1214                         "\t         the packets, depending on whether the -V flag was specified.\n"
1215                         "\t\"psml\"   Packet Summary Markup Language, an XML-based format for the\n"
1216                         "\t         summary information of a decoded packet. This information is\n"
1217                         "\t         equivalent to the information shown in the one-line summary\n"
1218                         "\t         printed by default.\n"
1219                         "\t\"text\"   Text of a human-readable one-line summary of each of the\n"
1220                         "\t         packets, or a multi-line view of the details of each of the\n"
1221                         "\t         packets, depending on whether the -V flag was specified.\n"
1222                         "\t         This is the default.");
1223         return 1;
1224       }
1225       break;
1226     case 'u':        /* Seconds type */
1227       if (strcmp(optarg, "s") == 0)
1228         timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
1229       else if (strcmp(optarg, "hms") == 0)
1230         timestamp_set_seconds_type(TS_SECONDS_HOUR_MIN_SEC);
1231       else {
1232         cmdarg_err("Invalid seconds type \"%s\"; it must be one of:", optarg);
1233         cmdarg_err_cont("\t\"s\"   for seconds\n"
1234                         "\t\"hms\" for hours, minutes and seconds");
1235         return 1;
1236       }
1237       break;
1238     case 'v':         /* Show version and exit */
1239     {
1240       show_version(comp_info_str, runtime_info_str);
1241       g_string_free(comp_info_str, TRUE);
1242       g_string_free(runtime_info_str, TRUE);
1243       /* We don't really have to cleanup here, but it's a convenient way to test
1244        * start-up and shut-down of the epan library without any UI-specific
1245        * cruft getting in the way. Makes the results of running
1246        * $ ./tools/valgrind-wireshark -n
1247        * much more useful. */
1248       epan_cleanup();
1249       return 0;
1250     }
1251     case 'O':        /* Only output these protocols */
1252       /* already processed; just ignore it now */
1253       break;
1254     case 'V':        /* Verbose */
1255       /* already processed; just ignore it now */
1256       break;
1257     case 'x':        /* Print packet data in hex (and ASCII) */
1258       /* already processed; just ignore it now */
1259       break;
1260     case 'X':
1261       break;
1262     case 'Y':
1263       dfilter = optarg;
1264       break;
1265     case 'z':
1266       /* We won't call the init function for the stat this soon
1267          as it would disallow MATE's fields (which are registered
1268          by the preferences set callback) from being used as
1269          part of a tap filter.  Instead, we just add the argument
1270          to a list of stat arguments. */
1271       if (!process_stat_cmd_arg(optarg)) {
1272         if (strcmp("help", optarg)==0) {
1273           fprintf(stderr, "tfshark: The available statistics for the \"-z\" option are:\n");
1274           list_stat_cmd_args();
1275           return 0;
1276         }
1277         cmdarg_err("Invalid -z argument \"%s\"; it must be one of:", optarg);
1278         list_stat_cmd_args();
1279         return 1;
1280       }
1281       break;
1282     default:
1283     case '?':        /* Bad flag - print usage message */
1284       print_usage(TRUE);
1285       return 1;
1286       break;
1287     }
1288   }
1289
1290   /* If we specified output fields, but not the output field type... */
1291   if (WRITE_FIELDS != output_action && 0 != output_fields_num_fields(output_fields)) {
1292         cmdarg_err("Output fields were specified with \"-e\", "
1293             "but \"-Tfields\" was not specified.");
1294         return 1;
1295   } else if (WRITE_FIELDS == output_action && 0 == output_fields_num_fields(output_fields)) {
1296         cmdarg_err("\"-Tfields\" was specified, but no fields were "
1297                     "specified with \"-e\".");
1298
1299         return 1;
1300   }
1301
1302   /* If no capture filter or display filter has been specified, and there are
1303      still command-line arguments, treat them as the tokens of a capture
1304      filter (if no "-r" flag was specified) or a display filter (if a "-r"
1305      flag was specified. */
1306   if (optind < argc) {
1307     if (cf_name != NULL) {
1308       if (dfilter != NULL) {
1309         cmdarg_err("Display filters were specified both with \"-d\" "
1310             "and with additional command-line arguments.");
1311         return 1;
1312       }
1313       dfilter = get_args_as_string(argc, argv, optind);
1314     }
1315   }
1316
1317   /* if "-q" wasn't specified, we should print packet information */
1318   if (!quiet)
1319     print_packet_info = TRUE;
1320
1321   if (arg_error) {
1322     print_usage(FALSE);
1323     return 1;
1324   }
1325
1326   if (print_hex) {
1327     if (output_action != WRITE_TEXT) {
1328       cmdarg_err("Raw packet hex data can only be printed as text or PostScript");
1329       return 1;
1330     }
1331   }
1332
1333   if (output_only != NULL) {
1334     char *ps;
1335
1336     if (!print_details) {
1337       cmdarg_err("-O requires -V");
1338       return 1;
1339     }
1340
1341     output_only_tables = g_hash_table_new (g_str_hash, g_str_equal);
1342     for (ps = strtok (output_only, ","); ps; ps = strtok (NULL, ",")) {
1343       g_hash_table_insert(output_only_tables, (gpointer)ps, (gpointer)ps);
1344     }
1345   }
1346
1347   if (rfilter != NULL && !perform_two_pass_analysis) {
1348     cmdarg_err("-R without -2 is deprecated. For single-pass filtering use -Y.");
1349     return 1;
1350   }
1351
1352   /* Notify all registered modules that have had any of their preferences
1353      changed either from one of the preferences file or from the command
1354      line that their preferences have changed. */
1355   prefs_apply_all();
1356
1357   /* At this point MATE will have registered its field array so we can
1358      have a tap filter with one of MATE's late-registered fields as part
1359      of the filter.  We can now process all the "-z" arguments. */
1360   start_requested_stats();
1361
1362   /* disabled protocols as per configuration file */
1363   if (gdp_path == NULL && dp_path == NULL) {
1364     set_disabled_protos_list();
1365   }
1366
1367   /* Build the column format array */
1368   build_column_format_array(&cfile.cinfo, prefs_p->num_cols, TRUE);
1369
1370   if (rfilter != NULL) {
1371     if (!dfilter_compile(rfilter, &rfcode)) {
1372       cmdarg_err("%s", dfilter_error_msg);
1373       epan_cleanup();
1374       return 2;
1375     }
1376   }
1377   cfile.rfcode = rfcode;
1378
1379   if (dfilter != NULL) {
1380     if (!dfilter_compile(dfilter, &dfcode)) {
1381       cmdarg_err("%s", dfilter_error_msg);
1382       epan_cleanup();
1383       return 2;
1384     }
1385   }
1386   cfile.dfcode = dfcode;
1387
1388   if (print_packet_info) {
1389     /* If we're printing as text or PostScript, we have
1390        to create a print stream. */
1391     if (output_action == WRITE_TEXT) {
1392       switch (print_format) {
1393
1394       case PR_FMT_TEXT:
1395         print_stream = print_stream_text_stdio_new(stdout);
1396         break;
1397
1398       case PR_FMT_PS:
1399         print_stream = print_stream_ps_stdio_new(stdout);
1400         break;
1401
1402       default:
1403         g_assert_not_reached();
1404       }
1405     }
1406   }
1407
1408   /* We have to dissect each packet if:
1409
1410         we're printing information about each packet;
1411
1412         we're using a read filter on the packets;
1413
1414         we're using a display filter on the packets;
1415
1416         we're using any taps that need dissection. */
1417   do_dissection = print_packet_info || rfcode || dfcode || tap_listeners_require_dissection();
1418
1419   if (cf_name) {
1420     /*
1421      * We're reading a capture file.
1422      */
1423
1424     /*
1425      * Immediately relinquish any special privileges we have; we must not
1426      * be allowed to read any capture files the user running TShark
1427      * can't open.
1428      */
1429     relinquish_special_privs_perm();
1430     print_current_user();
1431
1432     /* TODO: if tfshark is ever changed to give the user a choice of which
1433        open_routine reader to use, then the following needs to change. */
1434     if (cf_open(&cfile, cf_name, WTAP_TYPE_AUTO, FALSE, &err) != CF_OK) {
1435       epan_cleanup();
1436       return 2;
1437     }
1438
1439     /* Process the packets in the file */
1440     TRY {
1441       /* XXX - for now there is only 1 packet */
1442       err = load_cap_file(&cfile, 1, 0);
1443     }
1444     CATCH(OutOfMemoryError) {
1445       fprintf(stderr,
1446               "Out Of Memory!\n"
1447               "\n"
1448               "Sorry, but TFShark has to terminate now!\n"
1449               "\n"
1450               "Some infos / workarounds can be found at:\n"
1451               "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
1452       err = ENOMEM;
1453     }
1454     ENDTRY;
1455
1456     if (err != 0) {
1457       /* We still dump out the results of taps, etc., as we might have
1458          read some packets; however, we exit with an error status. */
1459       exit_status = 2;
1460     }
1461   }
1462
1463   g_free(cf_name);
1464
1465   if (cfile.frames != NULL) {
1466     free_frame_data_sequence(cfile.frames);
1467     cfile.frames = NULL;
1468   }
1469
1470   draw_tap_listeners(TRUE);
1471   funnel_dump_all_text_windows();
1472   epan_free(cfile.epan);
1473   epan_cleanup();
1474
1475   output_fields_free(output_fields);
1476   output_fields = NULL;
1477
1478   return exit_status;
1479 }
1480
1481 static const nstime_t *
1482 tfshark_get_frame_ts(void *data, guint32 frame_num)
1483 {
1484   capture_file *cf = (capture_file *) data;
1485
1486   if (ref && ref->num == frame_num)
1487     return &ref->abs_ts;
1488
1489   if (prev_dis && prev_dis->num == frame_num)
1490     return &prev_dis->abs_ts;
1491
1492   if (prev_cap && prev_cap->num == frame_num)
1493     return &prev_cap->abs_ts;
1494
1495   if (cf->frames) {
1496      frame_data *fd = frame_data_sequence_find(cf->frames, frame_num);
1497
1498      return (fd) ? &fd->abs_ts : NULL;
1499   }
1500
1501   return NULL;
1502 }
1503
1504 static const char *
1505 no_interface_name(void *data _U_, guint32 interface_id _U_)
1506 {
1507     return "";
1508 }
1509
1510 static epan_t *
1511 tfshark_epan_new(capture_file *cf)
1512 {
1513   epan_t *epan = epan_new();
1514
1515   epan->data = cf;
1516   epan->get_frame_ts = tfshark_get_frame_ts;
1517   epan->get_interface_name = no_interface_name;
1518   epan->get_user_comment = NULL;
1519
1520   return epan;
1521 }
1522
1523 static gboolean
1524 process_packet_first_pass(capture_file *cf, epan_dissect_t *edt,
1525                gint64 offset, struct wtap_pkthdr *whdr,
1526                const guchar *pd)
1527 {
1528   frame_data     fdlocal;
1529   guint32        framenum;
1530   gboolean       passed;
1531
1532   /* The frame number of this packet is one more than the count of
1533      frames in this packet. */
1534   framenum = cf->count + 1;
1535
1536   /* If we're not running a display filter and we're not printing any
1537      packet information, we don't need to do a dissection. This means
1538      that all packets can be marked as 'passed'. */
1539   passed = TRUE;
1540
1541   frame_data_init(&fdlocal, framenum, whdr, offset, cum_bytes);
1542
1543   /* If we're going to print packet information, or we're going to
1544      run a read filter, or display filter, or we're going to process taps, set up to
1545      do a dissection and do so. */
1546   if (edt) {
1547     /* If we're running a read filter, prime the epan_dissect_t with that
1548        filter. */
1549     if (cf->rfcode)
1550       epan_dissect_prime_dfilter(edt, cf->rfcode);
1551
1552     frame_data_set_before_dissect(&fdlocal, &cf->elapsed_time,
1553                                   &ref, prev_dis);
1554     if (ref == &fdlocal) {
1555       ref_frame = fdlocal;
1556       ref = &ref_frame;
1557     }
1558
1559     epan_dissect_file_run(edt, whdr, file_tvbuff_new(&fdlocal, pd), &fdlocal, NULL);
1560
1561     /* Run the read filter if we have one. */
1562     if (cf->rfcode)
1563       passed = dfilter_apply_edt(cf->rfcode, edt);
1564   }
1565
1566   if (passed) {
1567     frame_data_set_after_dissect(&fdlocal, &cum_bytes);
1568     prev_cap = prev_dis = frame_data_sequence_add(cf->frames, &fdlocal);
1569
1570     /* If we're not doing dissection then there won't be any dependent frames.
1571      * More importantly, edt.pi.dependent_frames won't be initialized because
1572      * epan hasn't been initialized.
1573      */
1574     if (edt) {
1575       g_slist_foreach(edt->pi.dependent_frames, find_and_mark_frame_depended_upon, cf->frames);
1576     }
1577
1578     cf->count++;
1579   } else {
1580     /* if we don't add it to the frame_data_sequence, clean it up right now
1581      * to avoid leaks */
1582     frame_data_destroy(&fdlocal);
1583   }
1584
1585   if (edt)
1586     epan_dissect_reset(edt);
1587
1588   return passed;
1589 }
1590
1591 static gboolean
1592 process_packet_second_pass(capture_file *cf, epan_dissect_t *edt, frame_data *fdata,
1593                struct wtap_pkthdr *phdr, Buffer *buf,
1594                guint tap_flags)
1595 {
1596   column_info    *cinfo;
1597   gboolean        passed;
1598
1599   /* If we're not running a display filter and we're not printing any
1600      packet information, we don't need to do a dissection. This means
1601      that all packets can be marked as 'passed'. */
1602   passed = TRUE;
1603
1604   /* If we're going to print packet information, or we're going to
1605      run a read filter, or we're going to process taps, set up to
1606      do a dissection and do so. */
1607   if (edt) {
1608
1609     /* If we're running a display filter, prime the epan_dissect_t with that
1610        filter. */
1611     if (cf->dfcode)
1612       epan_dissect_prime_dfilter(edt, cf->dfcode);
1613
1614     col_custom_prime_edt(edt, &cf->cinfo);
1615
1616     /* We only need the columns if either
1617          1) some tap needs the columns
1618        or
1619          2) we're printing packet info but we're *not* verbose; in verbose
1620             mode, we print the protocol tree, not the protocol summary.
1621      */
1622     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary))
1623       cinfo = &cf->cinfo;
1624     else
1625       cinfo = NULL;
1626
1627     frame_data_set_before_dissect(fdata, &cf->elapsed_time,
1628                                   &ref, prev_dis);
1629     if (ref == fdata) {
1630       ref_frame = *fdata;
1631       ref = &ref_frame;
1632     }
1633
1634     epan_dissect_file_run_with_taps(edt, phdr, file_tvbuff_new_buffer(fdata, buf), fdata, cinfo);
1635
1636     /* Run the read/display filter if we have one. */
1637     if (cf->dfcode)
1638       passed = dfilter_apply_edt(cf->dfcode, edt);
1639   }
1640
1641   if (passed) {
1642     frame_data_set_after_dissect(fdata, &cum_bytes);
1643     /* Process this packet. */
1644     if (print_packet_info) {
1645       /* We're printing packet information; print the information for
1646          this packet. */
1647       print_packet(cf, edt);
1648
1649       /* The ANSI C standard does not appear to *require* that a line-buffered
1650          stream be flushed to the host environment whenever a newline is
1651          written, it just says that, on such a stream, characters "are
1652          intended to be transmitted to or from the host environment as a
1653          block when a new-line character is encountered".
1654
1655          The Visual C++ 6.0 C implementation doesn't do what is intended;
1656          even if you set a stream to be line-buffered, it still doesn't
1657          flush the buffer at the end of every line.
1658
1659          So, if the "-l" flag was specified, we flush the standard output
1660          at the end of a packet.  This will do the right thing if we're
1661          printing packet summary lines, and, as we print the entire protocol
1662          tree for a single packet without waiting for anything to happen,
1663          it should be as good as line-buffered mode if we're printing
1664          protocol trees.  (The whole reason for the "-l" flag in either
1665          tcpdump or TShark is to allow the output of a live capture to
1666          be piped to a program or script and to have that script see the
1667          information for the packet as soon as it's printed, rather than
1668          having to wait until a standard I/O buffer fills up. */
1669       if (line_buffered)
1670         fflush(stdout);
1671
1672       if (ferror(stdout)) {
1673         show_print_file_io_error(errno);
1674         exit(2);
1675       }
1676     }
1677     prev_dis = fdata;
1678   }
1679   prev_cap = fdata;
1680
1681   if (edt) {
1682     epan_dissect_reset(edt);
1683   }
1684   return passed || fdata->flags.dependent_of_displayed;
1685 }
1686
1687 gboolean
1688 local_wtap_read(capture_file *cf, struct wtap_pkthdr* file_phdr, int *err, gchar **err_info, gint64 *data_offset _U_, guint8** data_buffer)
1689 {
1690     int bytes_read;
1691     gint64 packet_size = wtap_file_size(cf->wth, err);
1692
1693     *data_buffer = (guint8*)g_malloc((gsize)packet_size);
1694     bytes_read = file_read(*data_buffer, (unsigned int)packet_size, cf->wth->fh);
1695
1696     if (bytes_read < 0) {
1697         *err = file_error(cf->wth->fh, err_info);
1698         if (*err == 0)
1699             *err = FTAP_ERR_SHORT_READ;
1700         return FALSE;
1701     } else if (bytes_read == 0) {
1702         /* Done with file, no error */
1703         return FALSE;
1704     }
1705
1706
1707     /* XXX - SET FRAME SIZE EQUAL TO TOTAL FILE SIZE */
1708     file_phdr->caplen = (guint32)packet_size;
1709     file_phdr->len = (guint32)packet_size;
1710
1711 #if 0
1712     /*
1713      * Set the packet encapsulation to the file's encapsulation
1714      * value; if that's not WTAP_ENCAP_PER_PACKET, it's the
1715      * right answer (and means that the read routine for this
1716      * capture file type doesn't have to set it), and if it
1717      * *is* WTAP_ENCAP_PER_PACKET, the caller needs to set it
1718      * anyway.
1719      */
1720     wth->phdr.pkt_encap = wth->file_encap;
1721
1722     if (!wth->subtype_read(wth, err, err_info, data_offset)) {
1723         /*
1724          * If we didn't get an error indication, we read
1725          * the last packet.  See if there's any deferred
1726          * error, as might, for example, occur if we're
1727          * reading a compressed file, and we got an error
1728          * reading compressed data from the file, but
1729          * got enough compressed data to decompress the
1730          * last packet of the file.
1731          */
1732         if (*err == 0)
1733             *err = file_error(wth->fh, err_info);
1734         return FALSE;    /* failure */
1735     }
1736
1737     /*
1738      * It makes no sense for the captured data length to be bigger
1739      * than the actual data length.
1740      */
1741     if (wth->phdr.caplen > wth->phdr.len)
1742         wth->phdr.caplen = wth->phdr.len;
1743
1744     /*
1745      * Make sure that it's not WTAP_ENCAP_PER_PACKET, as that
1746      * probably means the file has that encapsulation type
1747      * but the read routine didn't set this packet's
1748      * encapsulation type.
1749      */
1750     g_assert(wth->phdr.pkt_encap != WTAP_ENCAP_PER_PACKET);
1751 #endif
1752
1753     return TRUE; /* success */
1754 }
1755
1756 static int
1757 load_cap_file(capture_file *cf, int max_packet_count, gint64 max_byte_count)
1758 {
1759   guint32      framenum;
1760   int          err;
1761   gchar       *err_info = NULL;
1762   gint64       data_offset = 0;
1763   gboolean     filtering_tap_listeners;
1764   guint        tap_flags;
1765   Buffer       buf;
1766   epan_dissect_t *edt = NULL;
1767   struct wtap_pkthdr file_phdr;
1768   guint8* raw_data;
1769
1770   if (print_packet_info) {
1771     if (!write_preamble(cf)) {
1772       err = errno;
1773       show_print_file_io_error(err);
1774       goto out;
1775     }
1776   }
1777
1778   /* Do we have any tap listeners with filters? */
1779   filtering_tap_listeners = have_filtering_tap_listeners();
1780
1781   /* Get the union of the flags for all tap listeners. */
1782   tap_flags = union_of_tap_listener_flags();
1783
1784   memset(&file_phdr, 0, sizeof(file_phdr));
1785
1786   /* XXX - TEMPORARY HACK TO ELF DISSECTOR */
1787   file_phdr.pkt_encap = 1234;
1788
1789   if (perform_two_pass_analysis) {
1790     frame_data *fdata;
1791
1792     /* Allocate a frame_data_sequence for all the frames. */
1793     cf->frames = new_frame_data_sequence();
1794
1795     if (do_dissection) {
1796        gboolean create_proto_tree = FALSE;
1797
1798       /* If we're going to be applying a filter, we'll need to
1799          create a protocol tree against which to apply the filter. */
1800       if (cf->rfcode)
1801         create_proto_tree = TRUE;
1802
1803       /* We're not going to display the protocol tree on this pass,
1804          so it's not going to be "visible". */
1805       edt = epan_dissect_new(cf->epan, create_proto_tree, FALSE);
1806     }
1807     while (local_wtap_read(cf, &file_phdr, &err, &err_info, &data_offset, &raw_data)) {
1808       if (process_packet_first_pass(cf, edt, data_offset, &file_phdr/*wtap_phdr(cf->wth)*/,
1809                          wtap_buf_ptr(cf->wth))) {
1810
1811         /* Stop reading if we have the maximum number of packets;
1812          * When the -c option has not been used, max_packet_count
1813          * starts at 0, which practically means, never stop reading.
1814          * (unless we roll over max_packet_count ?)
1815          */
1816         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
1817           err = 0; /* This is not an error */
1818           break;
1819         }
1820       }
1821     }
1822
1823     if (edt) {
1824       epan_dissect_free(edt);
1825       edt = NULL;
1826     }
1827
1828 #if 0
1829     /* Close the sequential I/O side, to free up memory it requires. */
1830     wtap_sequential_close(cf->wth);
1831 #endif
1832
1833     /* Allow the protocol dissectors to free up memory that they
1834      * don't need after the sequential run-through of the packets. */
1835     postseq_cleanup_all_protocols();
1836
1837     prev_dis = NULL;
1838     prev_cap = NULL;
1839     buffer_init(&buf, 1500);
1840
1841     if (do_dissection) {
1842       gboolean create_proto_tree;
1843
1844       if (cf->dfcode || print_details || filtering_tap_listeners ||
1845          (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
1846            create_proto_tree = TRUE;
1847       else
1848            create_proto_tree = FALSE;
1849
1850       /* The protocol tree will be "visible", i.e., printed, only if we're
1851          printing packet details, which is true if we're printing stuff
1852          ("print_packet_info" is true) and we're in verbose mode
1853          ("packet_details" is true). */
1854       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
1855     }
1856
1857     for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
1858       fdata = frame_data_sequence_find(cf->frames, framenum);
1859 #if 0
1860       if (wtap_seek_read(cf->wth, fdata->file_off,
1861           &buf, fdata->cap_len, &err, &err_info)) {
1862         process_packet_second_pass(cf, edt, fdata, &cf->phdr, &buf, tap_flags);
1863       }
1864 #else
1865         process_packet_second_pass(cf, edt, fdata, &cf->phdr, &buf, tap_flags);
1866 #endif
1867     }
1868
1869     if (edt) {
1870       epan_dissect_free(edt);
1871       edt = NULL;
1872     }
1873
1874     buffer_free(&buf);
1875   }
1876   else {
1877     framenum = 0;
1878
1879     if (do_dissection) {
1880       gboolean create_proto_tree;
1881
1882       if (cf->rfcode || cf->dfcode || print_details || filtering_tap_listeners ||
1883           (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
1884         create_proto_tree = TRUE;
1885       else
1886         create_proto_tree = FALSE;
1887
1888       /* The protocol tree will be "visible", i.e., printed, only if we're
1889          printing packet details, which is true if we're printing stuff
1890          ("print_packet_info" is true) and we're in verbose mode
1891          ("packet_details" is true). */
1892       edt = epan_dissect_new(cf->epan, create_proto_tree, print_packet_info && print_details);
1893     }
1894
1895     while (local_wtap_read(cf, &file_phdr, &err, &err_info, &data_offset, &raw_data)) {
1896
1897       framenum++;
1898
1899       process_packet(cf, edt, data_offset, &file_phdr/*wtap_phdr(cf->wth)*/,
1900                              raw_data, tap_flags);
1901
1902         /* Stop reading if we have the maximum number of packets;
1903         * When the -c option has not been used, max_packet_count
1904         * starts at 0, which practically means, never stop reading.
1905         * (unless we roll over max_packet_count ?)
1906         */
1907         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
1908             err = 0; /* This is not an error */
1909             break;
1910         }
1911     }
1912
1913     if (edt) {
1914       epan_dissect_free(edt);
1915       edt = NULL;
1916     }
1917   }
1918
1919   if (err != 0) {
1920     /*
1921      * Print a message noting that the read failed somewhere along the line.
1922      *
1923      * If we're printing packet data, and the standard output and error are
1924      * going to the same place, flush the standard output, so everything
1925      * buffered up is written, and then print a newline to the standard error
1926      * before printing the error message, to separate it from the packet
1927      * data.  (Alas, that only works on UN*X; st_dev is meaningless, and
1928      * the _fstat() documentation at Microsoft doesn't indicate whether
1929      * st_ino is even supported.)
1930      */
1931 #ifndef _WIN32
1932     if (print_packet_info) {
1933       struct stat stat_stdout, stat_stderr;
1934
1935       if (fstat(1, &stat_stdout) == 0 && fstat(2, &stat_stderr) == 0) {
1936         if (stat_stdout.st_dev == stat_stderr.st_dev &&
1937             stat_stdout.st_ino == stat_stderr.st_ino) {
1938           fflush(stdout);
1939           fprintf(stderr, "\n");
1940         }
1941       }
1942     }
1943 #endif
1944     switch (err) {
1945
1946     case FTAP_ERR_UNSUPPORTED:
1947       cmdarg_err("The file \"%s\" contains record data that TFShark doesn't support.\n(%s)",
1948                  cf->filename, err_info);
1949       g_free(err_info);
1950       break;
1951
1952     case FTAP_ERR_UNSUPPORTED_ENCAP:
1953       cmdarg_err("The file \"%s\" has a packet with a network type that TFShark doesn't support.\n(%s)",
1954                  cf->filename, err_info);
1955       g_free(err_info);
1956       break;
1957
1958     case FTAP_ERR_CANT_READ:
1959       cmdarg_err("An attempt to read from the file \"%s\" failed for some unknown reason.",
1960                  cf->filename);
1961       break;
1962
1963     case FTAP_ERR_SHORT_READ:
1964       cmdarg_err("The file \"%s\" appears to have been cut short in the middle of a packet.",
1965                  cf->filename);
1966       break;
1967
1968     case FTAP_ERR_BAD_FILE:
1969       cmdarg_err("The file \"%s\" appears to be damaged or corrupt.\n(%s)",
1970                  cf->filename, err_info);
1971       g_free(err_info);
1972       break;
1973
1974     case FTAP_ERR_DECOMPRESS:
1975       cmdarg_err("The compressed file \"%s\" appears to be damaged or corrupt.\n"
1976                  "(%s)", cf->filename, err_info);
1977       break;
1978
1979     default:
1980       cmdarg_err("An error occurred while reading the file \"%s\": %s.",
1981                  cf->filename, ftap_strerror(err));
1982       break;
1983     }
1984   } else {
1985     if (print_packet_info) {
1986       if (!write_finale()) {
1987         err = errno;
1988         show_print_file_io_error(err);
1989       }
1990     }
1991   }
1992
1993 out:
1994   wtap_close(cf->wth);
1995   cf->wth = NULL;
1996
1997   return err;
1998 }
1999
2000 static gboolean
2001 process_packet(capture_file *cf, epan_dissect_t *edt, gint64 offset,
2002                struct wtap_pkthdr *whdr, const guchar *pd, guint tap_flags)
2003 {
2004   frame_data      fdata;
2005   column_info    *cinfo;
2006   gboolean        passed;
2007
2008   /* Count this packet. */
2009   cf->count++;
2010
2011   /* If we're not running a display filter and we're not printing any
2012      packet information, we don't need to do a dissection. This means
2013      that all packets can be marked as 'passed'. */
2014   passed = TRUE;
2015
2016   frame_data_init(&fdata, cf->count, whdr, offset, cum_bytes);
2017
2018   /* If we're going to print packet information, or we're going to
2019      run a read filter, or we're going to process taps, set up to
2020      do a dissection and do so. */
2021   if (edt) {
2022     /* If we're running a filter, prime the epan_dissect_t with that
2023        filter. */
2024     if (cf->dfcode)
2025       epan_dissect_prime_dfilter(edt, cf->dfcode);
2026
2027     col_custom_prime_edt(edt, &cf->cinfo);
2028
2029     /* We only need the columns if either
2030          1) some tap needs the columns
2031        or
2032          2) we're printing packet info but we're *not* verbose; in verbose
2033             mode, we print the protocol tree, not the protocol summary.
2034        or
2035          3) there is a column mapped as an individual field */
2036     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
2037       cinfo = &cf->cinfo;
2038     else
2039       cinfo = NULL;
2040
2041     frame_data_set_before_dissect(&fdata, &cf->elapsed_time,
2042                                   &ref, prev_dis);
2043     if (ref == &fdata) {
2044       ref_frame = fdata;
2045       ref = &ref_frame;
2046     }
2047
2048     epan_dissect_file_run_with_taps(edt, whdr, frame_tvbuff_new(&fdata, pd), &fdata, cinfo);
2049
2050     /* Run the filter if we have it. */
2051     if (cf->dfcode)
2052       passed = dfilter_apply_edt(cf->dfcode, edt);
2053   }
2054
2055   if (passed) {
2056     frame_data_set_after_dissect(&fdata, &cum_bytes);
2057
2058     /* Process this packet. */
2059     if (print_packet_info) {
2060       /* We're printing packet information; print the information for
2061          this packet. */
2062       print_packet(cf, edt);
2063
2064       /* The ANSI C standard does not appear to *require* that a line-buffered
2065          stream be flushed to the host environment whenever a newline is
2066          written, it just says that, on such a stream, characters "are
2067          intended to be transmitted to or from the host environment as a
2068          block when a new-line character is encountered".
2069
2070          The Visual C++ 6.0 C implementation doesn't do what is intended;
2071          even if you set a stream to be line-buffered, it still doesn't
2072          flush the buffer at the end of every line.
2073
2074          So, if the "-l" flag was specified, we flush the standard output
2075          at the end of a packet.  This will do the right thing if we're
2076          printing packet summary lines, and, as we print the entire protocol
2077          tree for a single packet without waiting for anything to happen,
2078          it should be as good as line-buffered mode if we're printing
2079          protocol trees.  (The whole reason for the "-l" flag in either
2080          tcpdump or TShark is to allow the output of a live capture to
2081          be piped to a program or script and to have that script see the
2082          information for the packet as soon as it's printed, rather than
2083          having to wait until a standard I/O buffer fills up. */
2084       if (line_buffered)
2085         fflush(stdout);
2086
2087       if (ferror(stdout)) {
2088         show_print_file_io_error(errno);
2089         exit(2);
2090       }
2091     }
2092
2093     /* this must be set after print_packet() [bug #8160] */
2094     prev_dis_frame = fdata;
2095     prev_dis = &prev_dis_frame;
2096   }
2097
2098   prev_cap_frame = fdata;
2099   prev_cap = &prev_cap_frame;
2100
2101   if (edt) {
2102     epan_dissect_reset(edt);
2103     frame_data_destroy(&fdata);
2104   }
2105   return passed;
2106 }
2107
2108 static gboolean
2109 write_preamble(capture_file *cf)
2110 {
2111   switch (output_action) {
2112
2113   case WRITE_TEXT:
2114     return print_preamble(print_stream, cf ? cf->filename : NULL, wireshark_gitversion);
2115
2116   case WRITE_XML:
2117     if (print_details)
2118       write_pdml_preamble(stdout, cf ? cf->filename : NULL);
2119     else
2120       write_psml_preamble(stdout);
2121     return !ferror(stdout);
2122
2123   case WRITE_FIELDS:
2124     write_fields_preamble(output_fields, stdout);
2125     return !ferror(stdout);
2126
2127   default:
2128     g_assert_not_reached();
2129     return FALSE;
2130   }
2131 }
2132
2133 static char *
2134 get_line_buf(size_t len)
2135 {
2136   static char   *line_bufp    = NULL;
2137   static size_t  line_buf_len = 256;
2138   size_t         new_line_buf_len;
2139
2140   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
2141        new_line_buf_len *= 2)
2142     ;
2143   if (line_bufp == NULL) {
2144     line_buf_len = new_line_buf_len;
2145     line_bufp = (char *)g_malloc(line_buf_len + 1);
2146   } else {
2147     if (new_line_buf_len > line_buf_len) {
2148       line_buf_len = new_line_buf_len;
2149       line_bufp = (char *)g_realloc(line_bufp, line_buf_len + 1);
2150     }
2151   }
2152   return line_bufp;
2153 }
2154
2155 static inline void
2156 put_string(char *dest, const char *str, size_t str_len)
2157 {
2158   memcpy(dest, str, str_len);
2159   dest[str_len] = '\0';
2160 }
2161
2162 static inline void
2163 put_spaces_string(char *dest, const char *str, size_t str_len, size_t str_with_spaces)
2164 {
2165   size_t i;
2166
2167   for (i = str_len; i < str_with_spaces; i++)
2168     *dest++ = ' ';
2169
2170   put_string(dest, str, str_len);
2171 }
2172
2173 static inline void
2174 put_string_spaces(char *dest, const char *str, size_t str_len, size_t str_with_spaces)
2175 {
2176   size_t i;
2177
2178   memcpy(dest, str, str_len);
2179   for (i = str_len; i < str_with_spaces; i++)
2180     dest[i] = ' ';
2181
2182   dest[str_with_spaces] = '\0';
2183 }
2184
2185 static gboolean
2186 print_columns(capture_file *cf)
2187 {
2188   char   *line_bufp;
2189   int     i;
2190   size_t  buf_offset;
2191   size_t  column_len;
2192   size_t  col_len;
2193
2194   line_bufp = get_line_buf(256);
2195   buf_offset = 0;
2196   *line_bufp = '\0';
2197   for (i = 0; i < cf->cinfo.num_cols; i++) {
2198     /* Skip columns not marked as visible. */
2199     if (!get_column_visible(i))
2200       continue;
2201     switch (cf->cinfo.col_fmt[i]) {
2202     case COL_NUMBER:
2203       column_len = col_len = strlen(cf->cinfo.col_data[i]);
2204       if (column_len < 3)
2205         column_len = 3;
2206       line_bufp = get_line_buf(buf_offset + column_len);
2207       put_spaces_string(line_bufp + buf_offset, cf->cinfo.col_data[i], col_len, column_len);
2208       break;
2209
2210     case COL_CLS_TIME:
2211     case COL_REL_TIME:
2212     case COL_ABS_TIME:
2213     case COL_ABS_YMD_TIME:  /* XXX - wider */
2214     case COL_ABS_YDOY_TIME: /* XXX - wider */
2215     case COL_UTC_TIME:
2216     case COL_UTC_YMD_TIME:  /* XXX - wider */
2217     case COL_UTC_YDOY_TIME: /* XXX - wider */
2218       column_len = col_len = strlen(cf->cinfo.col_data[i]);
2219       if (column_len < 10)
2220         column_len = 10;
2221       line_bufp = get_line_buf(buf_offset + column_len);
2222       put_spaces_string(line_bufp + buf_offset, cf->cinfo.col_data[i], col_len, column_len);
2223       break;
2224
2225     case COL_DEF_SRC:
2226     case COL_RES_SRC:
2227     case COL_UNRES_SRC:
2228     case COL_DEF_DL_SRC:
2229     case COL_RES_DL_SRC:
2230     case COL_UNRES_DL_SRC:
2231     case COL_DEF_NET_SRC:
2232     case COL_RES_NET_SRC:
2233     case COL_UNRES_NET_SRC:
2234       column_len = col_len = strlen(cf->cinfo.col_data[i]);
2235       if (column_len < 12)
2236         column_len = 12;
2237       line_bufp = get_line_buf(buf_offset + column_len);
2238       put_spaces_string(line_bufp + buf_offset, cf->cinfo.col_data[i], col_len, column_len);
2239       break;
2240
2241     case COL_DEF_DST:
2242     case COL_RES_DST:
2243     case COL_UNRES_DST:
2244     case COL_DEF_DL_DST:
2245     case COL_RES_DL_DST:
2246     case COL_UNRES_DL_DST:
2247     case COL_DEF_NET_DST:
2248     case COL_RES_NET_DST:
2249     case COL_UNRES_NET_DST:
2250       column_len = col_len = strlen(cf->cinfo.col_data[i]);
2251       if (column_len < 12)
2252         column_len = 12;
2253       line_bufp = get_line_buf(buf_offset + column_len);
2254       put_string_spaces(line_bufp + buf_offset, cf->cinfo.col_data[i], col_len, column_len);
2255       break;
2256
2257     default:
2258       column_len = strlen(cf->cinfo.col_data[i]);
2259       line_bufp = get_line_buf(buf_offset + column_len);
2260       put_string(line_bufp + buf_offset, cf->cinfo.col_data[i], column_len);
2261       break;
2262     }
2263     buf_offset += column_len;
2264     if (i != cf->cinfo.num_cols - 1) {
2265       /*
2266        * This isn't the last column, so we need to print a
2267        * separator between this column and the next.
2268        *
2269        * If we printed a network source and are printing a
2270        * network destination of the same type next, separate
2271        * them with " -> "; if we printed a network destination
2272        * and are printing a network source of the same type
2273        * next, separate them with " <- "; otherwise separate them
2274        * with a space.
2275        *
2276        * We add enough space to the buffer for " <- " or " -> ",
2277        * even if we're only adding " ".
2278        */
2279       line_bufp = get_line_buf(buf_offset + 4);
2280       switch (cf->cinfo.col_fmt[i]) {
2281
2282       case COL_DEF_SRC:
2283       case COL_RES_SRC:
2284       case COL_UNRES_SRC:
2285         switch (cf->cinfo.col_fmt[i + 1]) {
2286
2287         case COL_DEF_DST:
2288         case COL_RES_DST:
2289         case COL_UNRES_DST:
2290           put_string(line_bufp + buf_offset, " -> ", 4);
2291           buf_offset += 4;
2292           break;
2293
2294         default:
2295           put_string(line_bufp + buf_offset, " ", 1);
2296           buf_offset += 1;
2297           break;
2298         }
2299         break;
2300
2301       case COL_DEF_DL_SRC:
2302       case COL_RES_DL_SRC:
2303       case COL_UNRES_DL_SRC:
2304         switch (cf->cinfo.col_fmt[i + 1]) {
2305
2306         case COL_DEF_DL_DST:
2307         case COL_RES_DL_DST:
2308         case COL_UNRES_DL_DST:
2309           put_string(line_bufp + buf_offset, " -> ", 4);
2310           buf_offset += 4;
2311           break;
2312
2313         default:
2314           put_string(line_bufp + buf_offset, " ", 1);
2315           buf_offset += 1;
2316           break;
2317         }
2318         break;
2319
2320       case COL_DEF_NET_SRC:
2321       case COL_RES_NET_SRC:
2322       case COL_UNRES_NET_SRC:
2323         switch (cf->cinfo.col_fmt[i + 1]) {
2324
2325         case COL_DEF_NET_DST:
2326         case COL_RES_NET_DST:
2327         case COL_UNRES_NET_DST:
2328           put_string(line_bufp + buf_offset, " -> ", 4);
2329           buf_offset += 4;
2330           break;
2331
2332         default:
2333           put_string(line_bufp + buf_offset, " ", 1);
2334           buf_offset += 1;
2335           break;
2336         }
2337         break;
2338
2339       case COL_DEF_DST:
2340       case COL_RES_DST:
2341       case COL_UNRES_DST:
2342         switch (cf->cinfo.col_fmt[i + 1]) {
2343
2344         case COL_DEF_SRC:
2345         case COL_RES_SRC:
2346         case COL_UNRES_SRC:
2347           put_string(line_bufp + buf_offset, " <- ", 4);
2348           buf_offset += 4;
2349           break;
2350
2351         default:
2352           put_string(line_bufp + buf_offset, " ", 1);
2353           buf_offset += 1;
2354           break;
2355         }
2356         break;
2357
2358       case COL_DEF_DL_DST:
2359       case COL_RES_DL_DST:
2360       case COL_UNRES_DL_DST:
2361         switch (cf->cinfo.col_fmt[i + 1]) {
2362
2363         case COL_DEF_DL_SRC:
2364         case COL_RES_DL_SRC:
2365         case COL_UNRES_DL_SRC:
2366           put_string(line_bufp + buf_offset, " <- ", 4);
2367           buf_offset += 4;
2368           break;
2369
2370         default:
2371           put_string(line_bufp + buf_offset, " ", 1);
2372           buf_offset += 1;
2373           break;
2374         }
2375         break;
2376
2377       case COL_DEF_NET_DST:
2378       case COL_RES_NET_DST:
2379       case COL_UNRES_NET_DST:
2380         switch (cf->cinfo.col_fmt[i + 1]) {
2381
2382         case COL_DEF_NET_SRC:
2383         case COL_RES_NET_SRC:
2384         case COL_UNRES_NET_SRC:
2385           put_string(line_bufp + buf_offset, " <- ", 4);
2386           buf_offset += 4;
2387           break;
2388
2389         default:
2390           put_string(line_bufp + buf_offset, " ", 1);
2391           buf_offset += 1;
2392           break;
2393         }
2394         break;
2395
2396       default:
2397         put_string(line_bufp + buf_offset, " ", 1);
2398         buf_offset += 1;
2399         break;
2400       }
2401     }
2402   }
2403   return print_line(print_stream, 0, line_bufp);
2404 }
2405
2406 static gboolean
2407 print_packet(capture_file *cf, epan_dissect_t *edt)
2408 {
2409   print_args_t print_args;
2410
2411   if (print_summary || output_fields_has_cols(output_fields)) {
2412     /* Just fill in the columns. */
2413     epan_dissect_fill_in_columns(edt, FALSE, TRUE);
2414
2415     if (print_summary) {
2416       /* Now print them. */
2417       switch (output_action) {
2418
2419       case WRITE_TEXT:
2420         if (!print_columns(cf))
2421           return FALSE;
2422         break;
2423
2424       case WRITE_XML:
2425         proto_tree_write_psml(edt, stdout);
2426         return !ferror(stdout);
2427       case WRITE_FIELDS: /*No non-verbose "fields" format */
2428         g_assert_not_reached();
2429         break;
2430       }
2431     }
2432   }
2433   if (print_details) {
2434     /* Print the information in the protocol tree. */
2435     switch (output_action) {
2436
2437     case WRITE_TEXT:
2438       /* Only initialize the fields that are actually used in proto_tree_print.
2439        * This is particularly important for .range, as that's heap memory which
2440        * we would otherwise have to g_free().
2441       print_args.to_file = TRUE;
2442       print_args.format = print_format;
2443       print_args.print_summary = print_summary;
2444       print_args.print_formfeed = FALSE;
2445       packet_range_init(&print_args.range, &cfile);
2446       */
2447       print_args.print_hex = print_hex;
2448       print_args.print_dissections = print_details ? print_dissections_expanded : print_dissections_none;
2449
2450       if (!proto_tree_print(&print_args, edt, print_stream))
2451         return FALSE;
2452       if (!print_hex) {
2453         if (!print_line(print_stream, 0, separator))
2454           return FALSE;
2455       }
2456       break;
2457
2458     case WRITE_XML:
2459       proto_tree_write_pdml(edt, stdout);
2460       printf("\n");
2461       return !ferror(stdout);
2462     case WRITE_FIELDS:
2463       proto_tree_write_fields(output_fields, edt, &cf->cinfo, stdout);
2464       printf("\n");
2465       return !ferror(stdout);
2466     }
2467   }
2468   if (print_hex) {
2469     if (print_summary || print_details) {
2470       if (!print_line(print_stream, 0, ""))
2471         return FALSE;
2472     }
2473     if (!print_hex_data(print_stream, edt))
2474       return FALSE;
2475     if (!print_line(print_stream, 0, separator))
2476       return FALSE;
2477   }
2478   return TRUE;
2479 }
2480
2481 static gboolean
2482 write_finale(void)
2483 {
2484   switch (output_action) {
2485
2486   case WRITE_TEXT:
2487     return print_finale(print_stream);
2488
2489   case WRITE_XML:
2490     if (print_details)
2491       write_pdml_finale(stdout);
2492     else
2493       write_psml_finale(stdout);
2494     return !ferror(stdout);
2495
2496   case WRITE_FIELDS:
2497     write_fields_finale(output_fields, stdout);
2498     return !ferror(stdout);
2499
2500   default:
2501     g_assert_not_reached();
2502     return FALSE;
2503   }
2504 }
2505
2506 cf_status_t
2507 cf_open(capture_file *cf, const char *fname, unsigned int type, gboolean is_tempfile, int *err)
2508 {
2509 #if USE_FTAP
2510   ftap  *fth;
2511 #else
2512   wtap  *wth;
2513 #endif
2514   gchar *err_info;
2515   char   err_msg[2048+1];
2516
2517 #if USE_FTAP
2518   fth = ftap_open_offline(fname, err, &err_info, perform_two_pass_analysis);
2519   if (fth == NULL)
2520     goto fail;
2521 #else
2522   wth = wtap_open_offline(fname, type, err, &err_info, perform_two_pass_analysis);
2523   if (wth == NULL)
2524     goto fail;
2525 #endif
2526
2527   /* The open succeeded.  Fill in the information for this file. */
2528
2529   /* Create new epan session for dissection. */
2530   epan_free(cf->epan);
2531   cf->epan = tfshark_epan_new(cf);
2532
2533 #if USE_FTAP
2534   cf->wth = (struct wtap*)fth; /**** XXX - DOESN'T WORK RIGHT NOW!!!! */
2535 #else
2536   cf->wth = wth;
2537 #endif
2538   cf->f_datalen = 0; /* not used, but set it anyway */
2539
2540   /* Set the file name because we need it to set the follow stream filter.
2541      XXX - is that still true?  We need it for other reasons, though,
2542      in any case. */
2543   cf->filename = g_strdup(fname);
2544
2545   /* Indicate whether it's a permanent or temporary file. */
2546   cf->is_tempfile = is_tempfile;
2547
2548   /* No user changes yet. */
2549   cf->unsaved_changes = FALSE;
2550
2551   cf->cd_t      = ftap_file_type_subtype((struct ftap*)cf->wth); /**** XXX - DOESN'T WORK RIGHT NOW!!!! */
2552   cf->open_type = type;
2553   cf->count     = 0;
2554   cf->drops_known = FALSE;
2555   cf->drops     = 0;
2556   cf->snap      = ftap_snapshot_length((struct ftap*)cf->wth); /**** XXX - DOESN'T WORK RIGHT NOW!!!! */
2557   if (cf->snap == 0) {
2558     /* Snapshot length not known. */
2559     cf->has_snap = FALSE;
2560     cf->snap = FTAP_MAX_RECORD_SIZE;
2561   } else
2562     cf->has_snap = TRUE;
2563   nstime_set_zero(&cf->elapsed_time);
2564   ref = NULL;
2565   prev_dis = NULL;
2566   prev_cap = NULL;
2567
2568   cf->state = FILE_READ_IN_PROGRESS;
2569
2570   return CF_OK;
2571
2572 fail:
2573   g_snprintf(err_msg, sizeof err_msg,
2574              cf_open_error_message(*err, err_info, FALSE, cf->cd_t), fname);
2575   cmdarg_err("%s", err_msg);
2576   return CF_ERROR;
2577 }
2578
2579 static void
2580 show_print_file_io_error(int err)
2581 {
2582   switch (err) {
2583
2584   case ENOSPC:
2585     cmdarg_err("Not all the packets could be printed because there is "
2586 "no space left on the file system.");
2587     break;
2588
2589 #ifdef EDQUOT
2590   case EDQUOT:
2591     cmdarg_err("Not all the packets could be printed because you are "
2592 "too close to, or over your disk quota.");
2593   break;
2594 #endif
2595
2596   default:
2597     cmdarg_err("An error occurred while printing packets: %s.",
2598       g_strerror(err));
2599     break;
2600   }
2601 }
2602
2603 static const char *
2604 cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
2605                       int file_type)
2606 {
2607   const char *errmsg;
2608   static char errmsg_errno[1024+1];
2609
2610   if (err < 0) {
2611     /* Wiretap error. */
2612     switch (err) {
2613
2614     case FTAP_ERR_NOT_REGULAR_FILE:
2615       errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
2616       break;
2617
2618     case FTAP_ERR_RANDOM_OPEN_PIPE:
2619       /* Seen only when opening a capture file for reading. */
2620       errmsg = "The file \"%s\" is a pipe or FIFO; TFShark can't read pipe or FIFO files in two-pass mode.";
2621       break;
2622
2623     case FTAP_ERR_FILE_UNKNOWN_FORMAT:
2624       /* Seen only when opening a capture file for reading. */
2625       errmsg = "The file \"%s\" isn't a capture file in a format TFShark understands.";
2626       break;
2627
2628     case FTAP_ERR_UNSUPPORTED:
2629       /* Seen only when opening a capture file for reading. */
2630       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2631                "The file \"%%s\" isn't a capture file in a format TFShark understands.\n"
2632                "(%s)", err_info);
2633       g_free(err_info);
2634       errmsg = errmsg_errno;
2635       break;
2636
2637     case FTAP_ERR_CANT_WRITE_TO_PIPE:
2638       /* Seen only when opening a capture file for writing. */
2639       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2640                  "The file \"%%s\" is a pipe, and \"%s\" capture files can't be "
2641                  "written to a pipe.", ftap_file_type_subtype_short_string(file_type));
2642       errmsg = errmsg_errno;
2643       break;
2644
2645     case FTAP_ERR_UNSUPPORTED_FILE_TYPE:
2646       /* Seen only when opening a capture file for writing. */
2647       errmsg = "TFShark doesn't support writing capture files in that format.";
2648       break;
2649
2650     case FTAP_ERR_UNSUPPORTED_ENCAP:
2651       if (for_writing) {
2652         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2653                    "TFShark can't save this capture as a \"%s\" file.",
2654                    ftap_file_type_subtype_short_string(file_type));
2655       } else {
2656         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2657                  "The file \"%%s\" is a capture for a network type that TFShark doesn't support.\n"
2658                  "(%s)", err_info);
2659         g_free(err_info);
2660       }
2661       errmsg = errmsg_errno;
2662       break;
2663
2664     case FTAP_ERR_ENCAP_PER_RECORD_UNSUPPORTED:
2665       if (for_writing) {
2666         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2667                    "TFShark can't save this capture as a \"%s\" file.",
2668                    ftap_file_type_subtype_short_string(file_type));
2669         errmsg = errmsg_errno;
2670       } else
2671         errmsg = "The file \"%s\" is a capture for a network type that TFShark doesn't support.";
2672       break;
2673
2674     case FTAP_ERR_BAD_FILE:
2675       /* Seen only when opening a capture file for reading. */
2676       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2677                "The file \"%%s\" appears to be damaged or corrupt.\n"
2678                "(%s)", err_info);
2679       g_free(err_info);
2680       errmsg = errmsg_errno;
2681       break;
2682
2683     case FTAP_ERR_CANT_OPEN:
2684       if (for_writing)
2685         errmsg = "The file \"%s\" could not be created for some unknown reason.";
2686       else
2687         errmsg = "The file \"%s\" could not be opened for some unknown reason.";
2688       break;
2689
2690     case FTAP_ERR_SHORT_READ:
2691       errmsg = "The file \"%s\" appears to have been cut short"
2692                " in the middle of a packet or other data.";
2693       break;
2694
2695     case FTAP_ERR_SHORT_WRITE:
2696       errmsg = "A full header couldn't be written to the file \"%s\".";
2697       break;
2698
2699     case FTAP_ERR_COMPRESSION_NOT_SUPPORTED:
2700       errmsg = "This file type cannot be written as a compressed file.";
2701       break;
2702
2703     case FTAP_ERR_DECOMPRESS:
2704       /* Seen only when opening a capture file for reading. */
2705       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2706                  "The compressed file \"%%s\" appears to be damaged or corrupt.\n"
2707                  "(%s)", err_info);
2708       g_free(err_info);
2709       errmsg = errmsg_errno;
2710       break;
2711
2712     default:
2713       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2714                  "The file \"%%s\" could not be %s: %s.",
2715                  for_writing ? "created" : "opened",
2716                  ftap_strerror(err));
2717       errmsg = errmsg_errno;
2718       break;
2719     }
2720   } else
2721     errmsg = file_open_error_message(err, for_writing);
2722   return errmsg;
2723 }
2724
2725 /*
2726  * Open/create errors are reported with an console message in TFShark.
2727  */
2728 static void
2729 open_failure_message(const char *filename, int err, gboolean for_writing)
2730 {
2731   fprintf(stderr, "tfshark: ");
2732   fprintf(stderr, file_open_error_message(err, for_writing), filename);
2733   fprintf(stderr, "\n");
2734 }
2735
2736
2737 /*
2738  * General errors are reported with an console message in TFShark.
2739  */
2740 static void
2741 failure_message(const char *msg_format, va_list ap)
2742 {
2743   fprintf(stderr, "tfshark: ");
2744   vfprintf(stderr, msg_format, ap);
2745   fprintf(stderr, "\n");
2746 }
2747
2748 /*
2749  * Read errors are reported with an console message in TFShark.
2750  */
2751 static void
2752 read_failure_message(const char *filename, int err)
2753 {
2754   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
2755           filename, g_strerror(err));
2756 }
2757
2758 /*
2759  * Write errors are reported with an console message in TFShark.
2760  */
2761 static void
2762 write_failure_message(const char *filename, int err)
2763 {
2764   cmdarg_err("An error occurred while writing to the file \"%s\": %s.",
2765           filename, g_strerror(err));
2766 }
2767
2768 /*
2769  * Report an error in command-line arguments.
2770  */
2771 void
2772 cmdarg_err(const char *fmt, ...)
2773 {
2774   va_list ap;
2775
2776   va_start(ap, fmt);
2777   failure_message(fmt, ap);
2778   va_end(ap);
2779 }
2780
2781 /*
2782  * Report additional information for an error in command-line arguments.
2783  */
2784 void
2785 cmdarg_err_cont(const char *fmt, ...)
2786 {
2787   va_list ap;
2788
2789   va_start(ap, fmt);
2790   vfprintf(stderr, fmt, ap);
2791   fprintf(stderr, "\n");
2792   va_end(ap);
2793 }
2794
2795
2796 /*
2797  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
2798  *
2799  * Local variables:
2800  * c-basic-offset: 2
2801  * tab-width: 8
2802  * indent-tabs-mode: nil
2803  * End:
2804  *
2805  * vi: set shiftwidth=2 tabstop=8 expandtab:
2806  * :indentSize=2:tabSize=8:noTabs=true:
2807  */