tfshark.c

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