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