tfshark.c

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