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