tshark.c

   1 /* tshark.c
   2  *
   3  * Text-mode variant of Wireshark, along the lines of tcpdump and snoop,
   4  * by Gilbert Ramirez <gram@alumni.rice.edu> and Guy Harris <guy@alum.mit.edu>.
   5  *
   6  * $Id$
   7  *
   8  * Wireshark - Network traffic analyzer
   9  * By Gerald Combs <gerald@wireshark.org>
  10  * Copyright 1998 Gerald Combs
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26
  27 #include "config.h"
  28
  29 #include <stdlib.h>
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33 #include <locale.h>
  34 #include <limits.h>
  35
  36 #ifdef HAVE_UNISTD_H
  37 #include <unistd.h>
  38 #endif
  39
  40 #include <errno.h>
  41
  42 #ifdef HAVE_FCNTL_H
  43 #include <fcntl.h>
  44 #endif
  45
  46 #include <signal.h>
  47
  48 #ifdef HAVE_SYS_STAT_H
  49 # include <sys/stat.h>
  50 #endif
  51
  52 #ifndef HAVE_GETOPT
  53 #include "wsutil/wsgetopt.h"
  54 #endif
  55
  56 #include <glib.h>
  57 #include <epan/epan.h>
  58 #include <epan/filesystem.h>
  59 #include <wsutil/privileges.h>
  60 #include <wsutil/file_util.h>
  61
  62 #include "globals.h"
  63 #include <epan/timestamp.h>
  64 #include <epan/packet.h>
  65 #include "file.h"
  66 #include "disabled_protos.h"
  67 #include <epan/prefs.h>
  68 #include <epan/column.h>
  69 #include "print.h"
  70 #include <epan/addr_resolv.h>
  71 #include "ui/util.h"
  72 #include "clopts_common.h"
  73 #include "console_io.h"
  74 #include "cmdarg_err.h"
  75 #include "version_info.h"
  76 #include <epan/plugins.h>
  77 #include "register.h"
  78 #include <epan/epan_dissect.h>
  79 #include <epan/tap.h>
  80 #include <epan/stat_cmd_args.h>
  81 #include <epan/timestamp.h>
  82 #include <epan/ex-opt.h>
  83
  84 #ifdef HAVE_LIBPCAP
  85 #include "capture_ui_utils.h"
  86 #include "capture_ifinfo.h"
  87 #include "capture-pcap-util.h"
  88 #ifdef _WIN32
  89 #include "capture-wpcap.h"
  90 #include <wsutil/unicode-utils.h>
  91 #endif /* _WIN32 */
  92 #include "capture_sync.h"
  93 #endif /* HAVE_LIBPCAP */
  94 #include "log.h"
  95 #include <epan/funnel.h>
  96 #include "capture_opts.h"
  97
  98 /*
  99  * This is the template for the decode as option; it is shared between the
 100  * various functions that output the usage for this parameter.
 101  */
 102 static const gchar decode_as_arg_template[] = "<layer_type>==<selector>,<decode_as_protocol>";
 103
 104 static guint32 cum_bytes;
 105 static nstime_t first_ts;
 106 static frame_data *prev_dis;
 107 static frame_data prev_dis_frame;
 108 static frame_data *prev_cap;
 109 static frame_data prev_cap_frame;
 110
 111 static const char* prev_display_dissector_name = NULL;
 112
 113 static gboolean perform_two_pass_analysis;
 114
 115 /*
 116  * The way the packet decode is to be written.
 117  */
 118 typedef enum {
 119   WRITE_TEXT,   /* summary or detail text */
 120   WRITE_XML,    /* PDML or PSML */
 121   WRITE_FIELDS  /* User defined list of fields */
 122   /* Add CSV and the like here */
 123 } output_action_e;
 124
 125 static output_action_e output_action;
 126 static gboolean do_dissection;     /* TRUE if we have to dissect each packet */
 127 static gboolean print_packet_info; /* TRUE if we're to print packet information */
 128 static gint print_summary = -1;    /* TRUE if we're to print packet summary information */
 129 static gboolean print_details;     /* TRUE if we're to print packet details information */
 130 static gboolean print_hex;         /* TRUE if we're to print hex/ascci information */
 131 static gboolean line_buffered;
 132
 133 static print_format_e print_format = PR_FMT_TEXT;
 134 static print_stream_t *print_stream;
 135
 136 static output_fields_t* output_fields  = NULL;
 137
 138 /* The line separator used between packets, changeable via the -S option */
 139 static char *separator = "";
 140
 141 #ifdef HAVE_LIBPCAP
 142 /*
 143  * TRUE if we're to print packet counts to keep track of captured packets.
 144  */
 145 static gboolean print_packet_counts = TRUE;
 146
 147 static capture_options global_capture_opts;
 148
 149 #ifdef SIGINFO
 150 static gboolean infodelay;      /* if TRUE, don't print capture info in SIGINFO handler */
 151 static gboolean infoprint;      /* if TRUE, print capture info after clearing infodelay */
 152 #endif /* SIGINFO */
 153
 154 static gboolean capture(void);
 155 static void report_counts(void);
 156 #ifdef _WIN32
 157 static BOOL WINAPI capture_cleanup(DWORD);
 158 #else /* _WIN32 */
 159 static void capture_cleanup(int);
 160 #ifdef SIGINFO
 161 static void report_counts_siginfo(int);
 162 #endif /* SIGINFO */
 163 #endif /* _WIN32 */
 164 #endif /* HAVE_LIBPCAP */
 165
 166 static int load_cap_file(capture_file *, char *, int, gboolean, int, gint64);
 167 static gboolean process_packet(capture_file *cf, gint64 offset,
 168     struct wtap_pkthdr *whdr,
 169     const guchar *pd, gboolean filtering_tap_listeners, guint tap_flags);
 170 static void show_capture_file_io_error(const char *, int, gboolean);
 171 static void show_print_file_io_error(int err);
 172 static gboolean write_preamble(capture_file *cf);
 173 static gboolean print_packet(capture_file *cf, epan_dissect_t *edt);
 174 static gboolean write_finale(void);
 175 static const char *cf_open_error_message(int err, gchar *err_info,
 176     gboolean for_writing, int file_type);
 177
 178 static void open_failure_message(const char *filename, int err,
 179     gboolean for_writing);
 180 static void failure_message(const char *msg_format, va_list ap);
 181 static void read_failure_message(const char *filename, int err);
 182 static void write_failure_message(const char *filename, int err);
 183
 184 capture_file cfile;
 185
 186 struct string_elem {
 187   const char *sstr;   /* The short string */
 188   const char *lstr;   /* The long string */
 189 };
 190
 191 static gint
 192 string_compare(gconstpointer a, gconstpointer b)
 193 {
 194   return strcmp(((const struct string_elem *)a)->sstr,
 195                 ((const struct string_elem *)b)->sstr);
 196 }
 197
 198 static void
 199 string_elem_print(gpointer data, gpointer not_used _U_)
 200 {
 201   fprintf(stderr, "    %s - %s\n",
 202           ((struct string_elem *)data)->sstr,
 203           ((struct string_elem *)data)->lstr);
 204 }
 205
 206 static void
 207 list_capture_types(void) {
 208   int                 i;
 209   struct string_elem *captypes;
 210   GSList             *list = NULL;
 211
 212   captypes = g_malloc(sizeof(struct string_elem) * WTAP_NUM_FILE_TYPES);
 213
 214   fprintf(stderr, "tshark: The available capture file types for the \"-F\" flag are:\n");
 215   for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
 216     if (wtap_dump_can_open(i)) {
 217       captypes[i].sstr = wtap_file_type_short_string(i);
 218       captypes[i].lstr = wtap_file_type_string(i);
 219       list = g_slist_insert_sorted(list, &captypes[i], string_compare);
 220     }
 221   }
 222   g_slist_foreach(list, string_elem_print, NULL);
 223   g_slist_free(list);
 224   g_free(captypes);
 225 }
 226
 227 static void
 228 print_usage(gboolean print_ver)
 229 {
 230   FILE *output;
 231
 232   if (print_ver) {
 233     output = stdout;
 234     fprintf(output,
 235         "TShark " VERSION "%s\n"
 236         "Dump and analyze network traffic.\n"
 237         "See http://www.wireshark.org for more information.\n"
 238         "\n"
 239         "%s",
 240          wireshark_svnversion, get_copyright_info());
 241   } else {
 242     output = stderr;
 243   }
 244   fprintf(output, "\n");
 245   fprintf(output, "Usage: tshark [options] ...\n");
 246   fprintf(output, "\n");
 247
 248 #ifdef HAVE_LIBPCAP
 249   fprintf(output, "Capture interface:\n");
 250   fprintf(output, "  -i <interface>           name or idx of interface (def: first non-loopback)\n");
 251   fprintf(output, "  -f <capture filter>      packet filter in libpcap filter syntax\n");
 252   fprintf(output, "  -s <snaplen>             packet snapshot length (def: 65535)\n");
 253   fprintf(output, "  -p                       don't capture in promiscuous mode\n");
 254 #ifdef HAVE_PCAP_CREATE
 255   fprintf(output, "  -I                       capture in monitor mode, if available\n");
 256 #endif
 257 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
 258   fprintf(output, "  -B <buffer size>         size of kernel buffer (def: 1MB)\n");
 259 #endif
 260   fprintf(output, "  -y <link type>           link layer type (def: first appropriate)\n");
 261   fprintf(output, "  -D                       print list of interfaces and exit\n");
 262   fprintf(output, "  -L                       print list of link-layer types of iface and exit\n");
 263   fprintf(output, "\n");
 264   fprintf(output, "Capture stop conditions:\n");
 265   fprintf(output, "  -c <packet count>        stop after n packets (def: infinite)\n");
 266   fprintf(output, "  -a <autostop cond.> ...  duration:NUM - stop after NUM seconds\n");
 267   fprintf(output, "                           filesize:NUM - stop this file after NUM KB\n");
 268   fprintf(output, "                              files:NUM - stop after NUM files\n");
 269   /*fprintf(output, "\n");*/
 270   fprintf(output, "Capture output:\n");
 271   fprintf(output, "  -b <ringbuffer opt.> ... duration:NUM - switch to next file after NUM secs\n");
 272   fprintf(output, "                           filesize:NUM - switch to next file after NUM KB\n");
 273   fprintf(output, "                              files:NUM - ringbuffer: replace after NUM files\n");
 274 #endif  /* HAVE_LIBPCAP */
 275 #ifdef HAVE_PCAP_REMOTE
 276   fprintf(output, "RPCAP options:\n");
 277   fprintf(output, "  -A <user>:<password>     use RPCAP password authentication\n");
 278 #endif
 279   /*fprintf(output, "\n");*/
 280   fprintf(output, "Input file:\n");
 281   fprintf(output, "  -r <infile>              set the filename to read from (no pipes or stdin!)\n");
 282
 283   fprintf(output, "\n");
 284   fprintf(output, "Processing:\n");
 285   fprintf(output, "  -2                       perform a two-pass analysis\n");
 286   fprintf(output, "  -R <read filter>         packet filter in Wireshark display filter syntax\n");
 287   fprintf(output, "  -n                       disable all name resolutions (def: all enabled)\n");
 288   fprintf(output, "  -N <name resolve flags>  enable specific name resolution(s): \"mntC\"\n");
 289   fprintf(output, "  -d %s ...\n", decode_as_arg_template);
 290   fprintf(output, "                           \"Decode As\", see the man page for details\n");
 291   fprintf(output, "                           Example: tcp.port==8888,http\n");
 292   fprintf(output, "  -H <hosts file>          read a list of entries from a hosts file, which will\n");
 293   fprintf(output, "                           then be written to a capture file. (Implies -W n)\n");
 294
 295   /*fprintf(output, "\n");*/
 296   fprintf(output, "Output:\n");
 297   fprintf(output, "  -w <outfile|->           write packets to a pcap-format file named \"outfile\"\n");
 298   fprintf(output, "                           (or to the standard output for \"-\")\n");
 299   fprintf(output, "  -C <config profile>      start with specified configuration profile\n");
 300   fprintf(output, "  -F <output file type>    set the output file type, default is pcapng\n");
 301   fprintf(output, "                           an empty \"-F\" option will list the file types\n");
 302   fprintf(output, "  -V                       add output of packet tree        (Packet Details)\n");
 303   fprintf(output, "  -O <protocols>           Only show packet details of these protocols, comma\n");
 304   fprintf(output, "                           separated\n");
 305   fprintf(output, "  -P                       print packet summary even when writing to a file\n");
 306   fprintf(output, "  -S <separator>           the line separator to print between packets\n");
 307   fprintf(output, "  -x                       add output of hex and ASCII dump (Packet Bytes)\n");
 308   fprintf(output, "  -T pdml|ps|psml|text|fields\n");
 309   fprintf(output, "                           format of text output (def: text)\n");
 310   fprintf(output, "  -e <field>               field to print if -Tfields selected (e.g. tcp.port, col.Info);\n");
 311   fprintf(output, "                           this option can be repeated to print multiple fields\n");
 312   fprintf(output, "  -E<fieldsoption>=<value> set options for output when -Tfields selected:\n");
 313   fprintf(output, "     header=y|n            switch headers on and off\n");
 314   fprintf(output, "     separator=/t|/s|<char> select tab, space, printable character as separator\n");
 315   fprintf(output, "     occurrence=f|l|a      print first, last or all occurrences of each field\n");
 316   fprintf(output, "     aggregator=,|/s|<char> select comma, space, printable character as\n");
 317   fprintf(output, "                           aggregator\n");
 318   fprintf(output, "     quote=d|s|n           select double, single, no quotes for values\n");
 319   fprintf(output, "  -t ad|a|r|d|dd|e         output format of time stamps (def: r: rel. to first)\n");
 320   fprintf(output, "  -u s|hms                 output format of seconds (def: s: seconds)\n");
 321   fprintf(output, "  -l                       flush standard output after each packet\n");
 322   fprintf(output, "  -q                       be more quiet on stdout (e.g. when using statistics)\n");
 323   fprintf(output, "  -g                       enable group read access on the output file(s)\n");
 324   fprintf(output, "  -W n                     Save extra information in the file, if supported.\n");
 325   fprintf(output, "                           n = write network address resolution information\n");
 326   fprintf(output, "  -X <key>:<value>         eXtension options, see the man page for details\n");
 327   fprintf(output, "  -z <statistics>          various statistics, see the man page for details\n");
 328
 329   fprintf(output, "\n");
 330   fprintf(output, "Miscellaneous:\n");
 331   fprintf(output, "  -h                       display this help and exit\n");
 332   fprintf(output, "  -v                       display version info and exit\n");
 333   fprintf(output, "  -o <name>:<value> ...    override preference setting\n");
 334   fprintf(output, "  -K <keytab>              keytab file to use for kerberos decryption\n");
 335   fprintf(output, "  -G [report]              dump one of several available reports and exit\n");
 336   fprintf(output, "                           default report=\"fields\"\n");
 337   fprintf(output, "                           use \"-G ?\" for more help\n");
 338 }
 339
 340 static void
 341 glossary_option_help(void)
 342 {
 343   FILE *output;
 344
 345   output = stdout;
 346
 347   fprintf(output, "TShark " VERSION "%s\n", wireshark_svnversion);
 348
 349   fprintf(output, "\n");
 350   fprintf(output, "Usage: tshark -G [report]\n");
 351   fprintf(output, "\n");
 352   fprintf(output, "Glossary table reports:\n");
 353   fprintf(output, "  -G [fields]              dump glossary in original format and exit\n");
 354   fprintf(output, "  -G fields2               dump glossary in format 2 and exit\n");
 355   fprintf(output, "  -G fields3               dump glossary in format 3 and exit\n");
 356   fprintf(output, "  -G protocols             dump protocols in registration database and exit\n");
 357   fprintf(output, "  -G values                dump value, range, true/false strings and exit\n");
 358   fprintf(output, "  -G ftypes                dump field type basic and descriptive names\n");
 359   fprintf(output, "  -G decodes               dump \"layer type\"/\"decode as\" associations and exit\n");
 360   fprintf(output, "  -G heuristic-decodes     dump heuristic dissector tables\n");
 361   fprintf(output, "\n");
 362   fprintf(output, "Preference reports:\n");
 363   fprintf(output, "  -G defaultprefs          dump default preferences and exit\n");
 364   fprintf(output, "  -G currentprefs          dump current preferences and exit\n");
 365   fprintf(output, "\n");
 366
 367 }
 368
 369 /*
 370  * For a dissector table, print on the stream described by output,
 371  * its short name (which is what's used in the "-d" option) and its
 372  * descriptive name.
 373  */
 374 static void
 375 display_dissector_table_names(const char *table_name, const char *ui_name,
 376                               gpointer output)
 377 {
 378   if ((prev_display_dissector_name == NULL) ||
 379       (strcmp(prev_display_dissector_name, table_name) != 0)) {
 380      fprintf((FILE *)output, "\t%s (%s)\n", table_name, ui_name);
 381      prev_display_dissector_name = table_name;
 382   }
 383 }
 384
 385 /*
 386  * For a dissector handle, print on the stream described by output,
 387  * the filter name (which is what's used in the "-d" option) and the full
 388  * name for the protocol that corresponds to this handle.
 389  */
 390 static void
 391 display_dissector_names(const gchar *table _U_, gpointer handle, gpointer output)
 392 {
 393   int          proto_id;
 394   const gchar *proto_filter_name;
 395   const gchar *proto_ui_name;
 396
 397   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
 398
 399   if (proto_id != -1) {
 400     proto_filter_name = proto_get_protocol_filter_name(proto_id);
 401     proto_ui_name =  proto_get_protocol_name(proto_id);
 402     g_assert(proto_filter_name != NULL);
 403     g_assert(proto_ui_name != NULL);
 404
 405     if ((prev_display_dissector_name == NULL) ||
 406         (strcmp(prev_display_dissector_name, proto_filter_name) != 0)) {
 407       fprintf((FILE *)output, "\t%s (%s)\n",
 408               proto_filter_name,
 409               proto_ui_name);
 410        prev_display_dissector_name = proto_filter_name;
 411     }
 412   }
 413 }
 414
 415 /*
 416  * The protocol_name_search structure is used by find_protocol_name_func()
 417  * to pass parameters and store results
 418  */
 419 struct protocol_name_search{
 420   gchar              *searched_name;  /* Protocol filter name we are looking for */
 421   dissector_handle_t  matched_handle; /* Handle for a dissector whose protocol has the specified filter name */
 422   guint               nb_match;       /* How many dissectors matched searched_name */
 423 };
 424 typedef struct protocol_name_search *protocol_name_search_t;
 425
 426 /*
 427  * This function parses all dissectors associated with a table to find the
 428  * one whose protocol has the specified filter name.  It is called
 429  * as a reference function in a call to dissector_table_foreach_handle.
 430  * The name we are looking for, as well as the results, are stored in the
 431  * protocol_name_search struct pointed to by user_data.
 432  * If called using dissector_table_foreach_handle, we actually parse the
 433  * whole list of dissectors.
 434  */
 435 static void
 436 find_protocol_name_func(const gchar *table _U_, gpointer handle, gpointer user_data)
 437
 438 {
 439   int                     proto_id;
 440   const gchar            *protocol_filter_name;
 441   protocol_name_search_t  search_info;
 442
 443   g_assert(handle);
 444
 445   search_info = (protocol_name_search_t)user_data;
 446
 447   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
 448   if (proto_id != -1) {
 449     protocol_filter_name = proto_get_protocol_filter_name(proto_id);
 450     g_assert(protocol_filter_name != NULL);
 451     if (strcmp(protocol_filter_name, search_info->searched_name) == 0) {
 452       /* Found a match */
 453       if (search_info->nb_match == 0) {
 454         /* Record this handle only if this is the first match */
 455         search_info->matched_handle = (dissector_handle_t)handle; /* Record the handle for this matching dissector */
 456       }
 457       search_info->nb_match++;
 458     }
 459   }
 460 }
 461
 462 /*
 463  * Allow dissector key names to be sorted alphabetically
 464  */
 465
 466 static gint
 467 compare_dissector_key_name(gconstpointer dissector_a, gconstpointer dissector_b)
 468 {
 469   return strcmp((const char*)dissector_a, (const char*)dissector_b);
 470 }
 471
 472 /*
 473  * Print all layer type names supported.
 474  * We send the output to the stream described by the handle output.
 475  */
 476
 477 static void
 478 fprint_all_layer_types(FILE *output)
 479
 480 {
 481   prev_display_dissector_name = NULL;
 482   dissector_all_tables_foreach_table(display_dissector_table_names, (gpointer)output, (GCompareFunc)compare_dissector_key_name);
 483 }
 484
 485 /*
 486  * Print all protocol names supported for a specific layer type.
 487  * table_name contains the layer type name in which the search is performed.
 488  * We send the output to the stream described by the handle output.
 489  */
 490
 491 static void
 492 fprint_all_protocols_for_layer_types(FILE *output, gchar *table_name)
 493
 494 {
 495   prev_display_dissector_name = NULL;
 496   dissector_table_foreach_handle(table_name,
 497                                  display_dissector_names,
 498                                  (gpointer)output);
 499 }
 500
 501 /*
 502  * The function below parses the command-line parameters for the decode as
 503  * feature (a string pointer by cl_param).
 504  * It checks the format of the command-line, searches for a matching table
 505  * and dissector.  If a table/dissector match is not found, we display a
 506  * summary of the available tables/dissectors (on stderr) and return FALSE.
 507  * If everything is fine, we get the "Decode as" preference activated,
 508  * then we return TRUE.
 509  */
 510 static gboolean
 511 add_decode_as(const gchar *cl_param)
 512 {
 513   gchar                        *table_name;
 514   guint32                       selector, selector2;
 515   gchar                        *decoded_param;
 516   gchar                        *remaining_param;
 517   gchar                        *selector_str;
 518   gchar                        *dissector_str;
 519   dissector_handle_t            dissector_matching;
 520   dissector_table_t             table_matching;
 521   ftenum_t                      dissector_table_selector_type;
 522   struct protocol_name_search   user_protocol_name;
 523   guint64                       i;
 524   char                          op;
 525
 526   /* The following code will allocate and copy the command-line options in a string pointed by decoded_param */
 527
 528   g_assert(cl_param);
 529   decoded_param = g_strdup(cl_param);
 530   g_assert(decoded_param);
 531
 532
 533   /* The lines below will parse this string (modifying it) to extract all
 534     necessary information.  Note that decoded_param is still needed since
 535     strings are not copied - we just save pointers. */
 536
 537   /* This section extracts a layer type (table_name) from decoded_param */
 538   table_name = decoded_param; /* Layer type string starts from beginning */
 539
 540   remaining_param = strchr(table_name, '=');
 541   if (remaining_param == NULL) {
 542     cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
 543     /* If the argument does not follow the template, carry on anyway to check
 544        if the table name is at least correct.  If remaining_param is NULL,
 545        we'll exit anyway further down */
 546   }
 547   else {
 548     *remaining_param = '\0'; /* Terminate the layer type string (table_name) where '=' was detected */
 549   }
 550
 551   /* Remove leading and trailing spaces from the table name */
 552   while ( table_name[0] == ' ' )
 553     table_name++;
 554   while ( table_name[strlen(table_name) - 1] == ' ' )
 555     table_name[strlen(table_name) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
 556
 557 /* The following part searches a table matching with the layer type specified */
 558   table_matching = NULL;
 559
 560 /* Look for the requested table */
 561   if ( !(*(table_name)) ) { /* Is the table name empty, if so, don't even search for anything, display a message */
 562     cmdarg_err("No layer type specified"); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
 563   }
 564   else {
 565     table_matching = find_dissector_table(table_name);
 566     if (!table_matching) {
 567       cmdarg_err("Unknown layer type -- %s", table_name); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
 568     }
 569   }
 570
 571   if (!table_matching) {
 572     /* Display a list of supported layer types to help the user, if the
 573        specified layer type was not found */
 574     cmdarg_err("Valid layer types are:");
 575     fprint_all_layer_types(stderr);
 576   }
 577   if (remaining_param == NULL || !table_matching) {
 578     /* Exit if the layer type was not found, or if no '=' separator was found
 579        (see above) */
 580     g_free(decoded_param);
 581     return FALSE;
 582   }
 583
 584   if (*(remaining_param + 1) != '=') { /* Check for "==" and not only '=' */
 585     cmdarg_err("WARNING: -d requires \"==\" instead of \"=\". Option will be treated as \"%s==%s\"", table_name, remaining_param + 1);
 586   }
 587   else {
 588     remaining_param++; /* Move to the second '=' */
 589     *remaining_param = '\0'; /* Remove the second '=' */
 590   }
 591   remaining_param++; /* Position after the layer type string */
 592
 593   /* This section extracts a selector value (selector_str) from decoded_param */
 594
 595   selector_str = remaining_param; /* Next part starts with the selector number */
 596
 597   remaining_param = strchr(selector_str, ',');
 598   if (remaining_param == NULL) {
 599     cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
 600     /* If the argument does not follow the template, carry on anyway to check
 601        if the selector value is at least correct.  If remaining_param is NULL,
 602        we'll exit anyway further down */
 603   }
 604   else {
 605     *remaining_param = '\0'; /* Terminate the selector number string (selector_str) where ',' was detected */
 606   }
 607
 608   dissector_table_selector_type = get_dissector_table_selector_type(table_name);
 609
 610   switch (dissector_table_selector_type) {
 611
 612   case FT_UINT8:
 613   case FT_UINT16:
 614   case FT_UINT24:
 615   case FT_UINT32:
 616     /* The selector for this table is an unsigned number.  Parse it as such.
 617        There's no need to remove leading and trailing spaces from the
 618        selector number string, because sscanf will do that for us. */
 619     switch (sscanf(selector_str, "%u%c%u", &selector, &op, &selector2)) {
 620       case 1:
 621         op = '\0';
 622         break;
 623       case 3:
 624         if (op != ':' && op != '-') {
 625             cmdarg_err("Invalid selector numeric range \"%s\"", selector_str);
 626             g_free(decoded_param);
 627             return FALSE;
 628         }
 629         if (op == ':') {
 630             if ((selector2 == 0) || ((guint64)selector + selector2 - 1) > G_MAXUINT32) {
 631                 cmdarg_err("Invalid selector numeric range \"%s\"", selector_str);
 632                 g_free(decoded_param);
 633                 return FALSE;
 634             }
 635         }
 636         else if (selector2 < selector) {
 637             /* We could swap them for the user, but maybe it's better to call
 638              * this out as an error in case it's not what was intended? */
 639             cmdarg_err("Invalid selector numeric range \"%s\"", selector_str);
 640             g_free(decoded_param);
 641             return FALSE;
 642         }
 643         break;
 644       default:
 645         cmdarg_err("Invalid selector number \"%s\"", selector_str);
 646         g_free(decoded_param);
 647         return FALSE;
 648     }
 649     break;
 650
 651   case FT_STRING:
 652   case FT_STRINGZ:
 653     /* The selector for this table is a string. */
 654     break;
 655
 656   default:
 657     /* There are currently no dissector tables with any types other
 658        than the ones listed above. */
 659     g_assert_not_reached();
 660   }
 661
 662   if (remaining_param == NULL) {
 663     /* Exit if no ',' separator was found (see above) */
 664     cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
 665     fprint_all_protocols_for_layer_types(stderr, table_name);
 666     g_free(decoded_param);
 667     return FALSE;
 668   }
 669
 670   remaining_param++; /* Position after the selector number string */
 671
 672   /* This section extracts a protocol filter name (dissector_str) from decoded_param */
 673
 674   dissector_str = remaining_param; /* All the rest of the string is the dissector (decode as protocol) name */
 675
 676   /* Remove leading and trailing spaces from the dissector name */
 677   while ( dissector_str[0] == ' ' )
 678     dissector_str++;
 679   while ( dissector_str[strlen(dissector_str) - 1] == ' ' )
 680     dissector_str[strlen(dissector_str) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
 681
 682   dissector_matching = NULL;
 683
 684   /* We now have a pointer to the handle for the requested table inside the variable table_matching */
 685   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 */
 686     cmdarg_err("No protocol name specified"); /* Note, we don't exit here, but dissector_matching will remain NULL, so we exit below */
 687   }
 688   else {
 689     user_protocol_name.nb_match = 0;
 690     user_protocol_name.searched_name = dissector_str;
 691     user_protocol_name.matched_handle = NULL;
 692
 693     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 */
 694
 695     if (user_protocol_name.nb_match != 0) {
 696       dissector_matching = user_protocol_name.matched_handle;
 697       if (user_protocol_name.nb_match > 1) {
 698         cmdarg_err("WARNING: Protocol \"%s\" matched %u dissectors, first one will be used", dissector_str, user_protocol_name.nb_match);
 699       }
 700     }
 701     else {
 702       /* OK, check whether the problem is that there isn't any such
 703          protocol, or that there is but it's not specified as a protocol
 704          that's valid for that dissector table.
 705          Note, we don't exit here, but dissector_matching will remain NULL,
 706          so we exit below */
 707       if (proto_get_id_by_filter_name(dissector_str) == -1) {
 708         /* No such protocol */
 709         cmdarg_err("Unknown protocol -- \"%s\"", dissector_str);
 710       } else {
 711         cmdarg_err("Protocol \"%s\" isn't valid for layer type \"%s\"",
 712                    dissector_str, table_name);
 713       }
 714     }
 715   }
 716
 717   if (!dissector_matching) {
 718     cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
 719     fprint_all_protocols_for_layer_types(stderr, table_name);
 720     g_free(decoded_param);
 721     return FALSE;
 722   }
 723
 724 /* This is the end of the code that parses the command-line options.
 725    All information is now stored in the variables:
 726    table_name
 727    selector
 728    dissector_matching
 729    The above variables that are strings are still pointing to areas within
 730    decoded_parm.  decoded_parm thus still needs to be kept allocated in
 731    until we stop needing these variables
 732    decoded_param will be deallocated at each exit point of this function */
 733
 734
 735   /* We now have a pointer to the handle for the requested dissector
 736      (requested protocol) inside the variable dissector_matching */
 737   switch (dissector_table_selector_type) {
 738
 739   case FT_UINT8:
 740   case FT_UINT16:
 741   case FT_UINT24:
 742   case FT_UINT32:
 743     /* The selector for this table is an unsigned number. */
 744     if (op == '\0') {
 745       dissector_change_uint(table_name, selector, dissector_matching);
 746     } else if (op == ':') {
 747       for (i = selector; i < (guint64)selector + selector2; i++) {
 748         dissector_change_uint(table_name, (guint32)i, dissector_matching);
 749       }
 750     } else { /* op == '-' */
 751       for (i = selector; i <= selector2; i++) {
 752         dissector_change_uint(table_name, (guint32)i, dissector_matching);
 753       }
 754     }
 755     break;
 756
 757   case FT_STRING:
 758   case FT_STRINGZ:
 759     /* The selector for this table is a string. */
 760     dissector_change_string(table_name, selector_str, dissector_matching);
 761     break;
 762
 763   default:
 764     /* There are currently no dissector tables with any types other
 765        than the ones listed above. */
 766     g_assert_not_reached();
 767   }
 768   g_free(decoded_param); /* "Decode As" rule has been successfully added */
 769   return TRUE;
 770 }
 771
 772 static void
 773 tshark_log_handler (const gchar *log_domain, GLogLevelFlags log_level,
 774     const gchar *message, gpointer user_data)
 775 {
 776   /* ignore log message, if log_level isn't interesting based
 777      upon the console log preferences.
 778      If the preferences haven't been loaded loaded yet, display the
 779      message anyway.
 780
 781      The default console_log_level preference value is such that only
 782        ERROR, CRITICAL and WARNING level messages are processed;
 783        MESSAGE, INFO and DEBUG level messages are ignored.
 784
 785      XXX: Aug 07, 2009: Prior tshark g_log code was hardwired to process only
 786            ERROR and CRITICAL level messages so the current code is a behavioral
 787            change.  The current behavior is the same as in Wireshark.
 788   */
 789   if ((log_level & G_LOG_LEVEL_MASK & prefs.console_log_level) == 0 &&
 790      prefs.console_log_level != 0) {
 791     return;
 792   }
 793
 794   g_log_default_handler(log_domain, log_level, message, user_data);
 795
 796 }
 797
 798 static char *
 799 output_file_description(const char *fname)
 800 {
 801   char *save_file_string;
 802
 803   /* Get a string that describes what we're writing to */
 804   if (strcmp(fname, "-") == 0) {
 805     /* We're writing to the standard output */
 806     save_file_string = g_strdup("standard output");
 807   } else {
 808     /* We're writing to a file with the name in save_file */
 809     save_file_string = g_strdup_printf("file \"%s\"", fname);
 810   }
 811   return save_file_string;
 812 }
 813
 814 static void
 815 print_current_user(void) {
 816   gchar *cur_user, *cur_group;
 817
 818   if (started_with_special_privs()) {
 819     cur_user = get_cur_username();
 820     cur_group = get_cur_groupname();
 821     fprintf(stderr, "Running as user \"%s\" and group \"%s\".",
 822       cur_user, cur_group);
 823     g_free(cur_user);
 824     g_free(cur_group);
 825     if (running_with_special_privs()) {
 826       fprintf(stderr, " This could be dangerous.");
 827     }
 828     fprintf(stderr, "\n");
 829   }
 830 }
 831
 832 static void
 833 check_capture_privs(void) {
 834 #ifdef _WIN32
 835   load_wpcap();
 836   /* Warn the user if npf.sys isn't loaded. */
 837   if (!npf_sys_is_running() && get_os_major_version() >= 6) {
 838     fprintf(stderr, "The NPF driver isn't running.  You may have trouble "
 839       "capturing or\nlisting interfaces.\n");
 840   }
 841 #endif
 842 }
 843
 844 static void
 845 show_version(GString *comp_info_str, GString *runtime_info_str)
 846 {
 847   printf("TShark " VERSION "%s\n"
 848          "\n"
 849          "%s"
 850          "\n"
 851          "%s"
 852          "\n"
 853          "%s",
 854          wireshark_svnversion, get_copyright_info(), comp_info_str->str,
 855          runtime_info_str->str);
 856 }
 857
 858 int
 859 main(int argc, char *argv[])
 860 {
 861   char                *init_progfile_dir_error;
 862   int                  opt;
 863   gboolean             arg_error = FALSE;
 864
 865 #ifdef _WIN32
 866   WSADATA              wsaData;
 867 #endif  /* _WIN32 */
 868
 869   char                *gpf_path, *pf_path;
 870   char                *gdp_path, *dp_path;
 871   int                  gpf_open_errno, gpf_read_errno;
 872   int                  pf_open_errno, pf_read_errno;
 873   int                  gdp_open_errno, gdp_read_errno;
 874   int                  dp_open_errno, dp_read_errno;
 875   int                  err;
 876   volatile int         exit_status = 0;
 877 #ifdef HAVE_LIBPCAP
 878   gboolean             list_link_layer_types = FALSE;
 879   gboolean             start_capture = FALSE;
 880   int                  status;
 881   GList               *if_list;
 882   gchar               *err_str;
 883 #else
 884   gboolean             capture_option_specified = FALSE;
 885 #endif
 886   gboolean             quiet = FALSE;
 887 #ifdef PCAP_NG_DEFAULT
 888   volatile int         out_file_type = WTAP_FILE_PCAPNG;
 889 #else
 890   volatile int         out_file_type = WTAP_FILE_PCAP;
 891 #endif
 892   volatile gboolean    out_file_name_res = FALSE;
 893   gchar               *volatile cf_name = NULL;
 894   gchar               *rfilter = NULL;
 895 #ifdef HAVE_PCAP_OPEN_DEAD
 896   struct bpf_program   fcode;
 897 #endif
 898   dfilter_t           *rfcode = NULL;
 899   e_prefs             *prefs_p;
 900   char                 badopt;
 901   GLogLevelFlags       log_flags;
 902   int                  optind_initial;
 903   gchar               *output_only = NULL;
 904
 905 #ifdef HAVE_PCAP_REMOTE
 906 #define OPTSTRING_A "A:"
 907 #else
 908 #define OPTSTRING_A ""
 909 #endif
 910 #ifdef HAVE_LIBPCAP
 911 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
 912 #define OPTSTRING_B "B:"
 913 #else
 914 #define OPTSTRING_B ""
 915 #endif  /* _WIN32 or HAVE_PCAP_CREATE */
 916 #else /* HAVE_LIBPCAP */
 917 #define OPTSTRING_B ""
 918 #endif  /* HAVE_LIBPCAP */
 919
 920 #ifdef HAVE_PCAP_CREATE
 921 #define OPTSTRING_I "I"
 922 #else
 923 #define OPTSTRING_I ""
 924 #endif
 925
 926 #define OPTSTRING "2a:" OPTSTRING_A "b:" OPTSTRING_B "c:C:d:De:E:f:F:G:hH:i:" OPTSTRING_I "K:lLnN:o:O:pPqr:R:s:S:t:T:u:vVw:W:xX:y:z:"
 927
 928   static const char    optstring[] = OPTSTRING;
 929
 930 #ifdef _WIN32
 931   arg_list_utf_16to8(argc, argv);
 932 #if !GLIB_CHECK_VERSION(2,31,0)
 933   g_thread_init(NULL);
 934 #endif
 935 #endif /* _WIN32 */
 936
 937   /*
 938    * Get credential information for later use.
 939    */
 940   init_process_policies();
 941
 942   /*
 943    * Attempt to get the pathname of the executable file.
 944    */
 945   init_progfile_dir_error = init_progfile_dir(argv[0], main);
 946   if (init_progfile_dir_error != NULL) {
 947     fprintf(stderr, "tshark: Can't get pathname of tshark program: %s.\n",
 948             init_progfile_dir_error);
 949   }
 950
 951   /*
 952    * In order to have the -X opts assigned before the wslua machine starts
 953    * we need to call getopts before epan_init() gets called.
 954    */
 955   opterr = 0;
 956   optind_initial = optind;
 957
 958   while ((opt = getopt(argc, argv, optstring)) != -1) {
 959     switch (opt) {
 960     case 'C':        /* Configuration Profile */
 961       if (profile_exists (optarg, FALSE)) {
 962         set_profile_name (optarg);
 963       } else {
 964         cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
 965         return 1;
 966       }
 967       break;
 968     case 'P':        /* Print packet summary info even when writing to a file */
 969       print_packet_info = TRUE;
 970       print_summary = TRUE;
 971       break;
 972     case 'O':        /* Only output these protocols */
 973       output_only = g_strdup(optarg);
 974       /* FALLTHROUGH */
 975     case 'V':        /* Verbose */
 976       print_details = TRUE;
 977       print_packet_info = TRUE;
 978       break;
 979     case 'x':        /* Print packet data in hex (and ASCII) */
 980       print_hex = TRUE;
 981       /*  The user asked for hex output, so let's ensure they get it,
 982        *  even if they're writing to a file.
 983        */
 984       print_packet_info = TRUE;
 985       break;
 986     case 'X':
 987       ex_opt_add(optarg);
 988       break;
 989     default:
 990       break;
 991     }
 992   }
 993
 994   /*
 995    * Print packet summary information is the default, unless either -V or -x
 996    * were specified and -P was not.  Note that this is new behavior, which
 997    * allows for the possibility of printing only hex/ascii output without
 998    * necessarily requiring that either the summary or details be printed too.
 999    */
1000   if (print_summary == -1)
1001     print_summary = (print_details || print_hex) ? FALSE : TRUE;
1002
1003   optind = optind_initial;
1004   opterr = 1;
1005
1006
1007
1008 /** Send All g_log messages to our own handler **/
1009
1010   log_flags =
1011                     G_LOG_LEVEL_ERROR|
1012                     G_LOG_LEVEL_CRITICAL|
1013                     G_LOG_LEVEL_WARNING|
1014                     G_LOG_LEVEL_MESSAGE|
1015                     G_LOG_LEVEL_INFO|
1016                     G_LOG_LEVEL_DEBUG|
1017                     G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
1018
1019   g_log_set_handler(NULL,
1020                     log_flags,
1021                     tshark_log_handler, NULL /* user_data */);
1022   g_log_set_handler(LOG_DOMAIN_MAIN,
1023                     log_flags,
1024                     tshark_log_handler, NULL /* user_data */);
1025
1026 #ifdef HAVE_LIBPCAP
1027   g_log_set_handler(LOG_DOMAIN_CAPTURE,
1028                     log_flags,
1029                     tshark_log_handler, NULL /* user_data */);
1030   g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
1031                     log_flags,
1032                     tshark_log_handler, NULL /* user_data */);
1033 #endif
1034
1035   initialize_funnel_ops();
1036
1037 #ifdef HAVE_LIBPCAP
1038   capture_opts_init(&global_capture_opts, &cfile);
1039 #endif
1040
1041   timestamp_set_type(TS_RELATIVE);
1042   timestamp_set_precision(TS_PREC_AUTO);
1043   timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
1044
1045   /* Register all dissectors; we must do this before checking for the
1046      "-G" flag, as the "-G" flag dumps information registered by the
1047      dissectors, and we must do it before we read the preferences, in
1048      case any dissectors register preferences. */
1049   epan_init(register_all_protocols, register_all_protocol_handoffs, NULL, NULL,
1050             failure_message, open_failure_message, read_failure_message,
1051             write_failure_message);
1052
1053   /* Register all tap listeners; we do this before we parse the arguments,
1054      as the "-z" argument can specify a registered tap. */
1055
1056   /* we register the plugin taps before the other taps because
1057      stats_tree taps plugins will be registered as tap listeners
1058      by stats_tree_stat.c and need to registered before that */
1059 #ifdef HAVE_PLUGINS
1060   register_all_plugin_tap_listeners();
1061 #endif
1062   register_all_tap_listeners();
1063
1064   /* If invoked with the "-G" flag, we dump out information based on
1065      the argument to the "-G" flag; if no argument is specified,
1066      for backwards compatibility we dump out a glossary of display
1067      filter symbols.
1068
1069      XXX - we do this here, for now, to support "-G" with no arguments.
1070      If none of our build or other processes uses "-G" with no arguments,
1071      we can just process it with the other arguments. */
1072   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
1073     proto_initialize_all_prefixes();
1074
1075     if (argc == 2)
1076       proto_registrar_dump_fields(1);
1077     else {
1078       if (strcmp(argv[2], "fields") == 0)
1079         proto_registrar_dump_fields(1);
1080       else if (strcmp(argv[2], "fields2") == 0)
1081         proto_registrar_dump_fields(2);
1082       else if (strcmp(argv[2], "fields3") == 0)
1083         proto_registrar_dump_fields(3);
1084       else if (strcmp(argv[2], "protocols") == 0)
1085         proto_registrar_dump_protocols();
1086       else if (strcmp(argv[2], "values") == 0)
1087         proto_registrar_dump_values();
1088       else if (strcmp(argv[2], "ftypes") == 0)
1089         proto_registrar_dump_ftypes();
1090       else if (strcmp(argv[2], "decodes") == 0)
1091         dissector_dump_decodes();
1092       else if (strcmp(argv[2], "heuristic-decodes") == 0)
1093         dissector_dump_heur_decodes();
1094       else if (strcmp(argv[2], "defaultprefs") == 0)
1095         write_prefs(NULL);
1096       else if (strcmp(argv[2], "plugins") == 0)
1097         plugins_dump_all();
1098       else if (strcmp(argv[2], "?") == 0)
1099         glossary_option_help();
1100       else if (strcmp(argv[2], "-?") == 0)
1101         glossary_option_help();
1102       else if (strcmp(argv[2], "currentprefs") == 0) {
1103         read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
1104             &pf_open_errno, &pf_read_errno, &pf_path);
1105         write_prefs(NULL);
1106       } else {
1107         cmdarg_err("Invalid \"%s\" option for -G flag, enter -G ? for more help.", argv[2]);
1108         return 1;
1109       }
1110     }
1111     return 0;
1112   }
1113
1114   /* Set the C-language locale to the native environment. */
1115   setlocale(LC_ALL, "");
1116
1117   prefs_p = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
1118                      &pf_open_errno, &pf_read_errno, &pf_path);
1119   if (gpf_path != NULL) {
1120     if (gpf_open_errno != 0) {
1121       cmdarg_err("Can't open global preferences file \"%s\": %s.",
1122               pf_path, g_strerror(gpf_open_errno));
1123     }
1124     if (gpf_read_errno != 0) {
1125       cmdarg_err("I/O error reading global preferences file \"%s\": %s.",
1126               pf_path, g_strerror(gpf_read_errno));
1127     }
1128   }
1129   if (pf_path != NULL) {
1130     if (pf_open_errno != 0) {
1131       cmdarg_err("Can't open your preferences file \"%s\": %s.", pf_path,
1132               g_strerror(pf_open_errno));
1133     }
1134     if (pf_read_errno != 0) {
1135       cmdarg_err("I/O error reading your preferences file \"%s\": %s.",
1136               pf_path, g_strerror(pf_read_errno));
1137     }
1138     g_free(pf_path);
1139     pf_path = NULL;
1140   }
1141
1142   /* Read the disabled protocols file. */
1143   read_disabled_protos_list(&gdp_path, &gdp_open_errno, &gdp_read_errno,
1144                             &dp_path, &dp_open_errno, &dp_read_errno);
1145   if (gdp_path != NULL) {
1146     if (gdp_open_errno != 0) {
1147       cmdarg_err("Could not open global disabled protocols file\n\"%s\": %s.",
1148                  gdp_path, g_strerror(gdp_open_errno));
1149     }
1150     if (gdp_read_errno != 0) {
1151       cmdarg_err("I/O error reading global disabled protocols file\n\"%s\": %s.",
1152                  gdp_path, g_strerror(gdp_read_errno));
1153     }
1154     g_free(gdp_path);
1155   }
1156   if (dp_path != NULL) {
1157     if (dp_open_errno != 0) {
1158       cmdarg_err(
1159         "Could not open your disabled protocols file\n\"%s\": %s.", dp_path,
1160         g_strerror(dp_open_errno));
1161     }
1162     if (dp_read_errno != 0) {
1163       cmdarg_err(
1164         "I/O error reading your disabled protocols file\n\"%s\": %s.", dp_path,
1165         g_strerror(dp_read_errno));
1166     }
1167     g_free(dp_path);
1168   }
1169
1170   check_capture_privs();
1171
1172   cap_file_init(&cfile);
1173
1174   /* Print format defaults to this. */
1175   print_format = PR_FMT_TEXT;
1176
1177   output_fields = output_fields_new();
1178
1179   /* Now get our args */
1180   while ((opt = getopt(argc, argv, optstring)) != -1) {
1181     switch (opt) {
1182     case '2':        /* Perform two pass analysis */
1183       perform_two_pass_analysis = TRUE;
1184       break;
1185     case 'a':        /* autostop criteria */
1186     case 'b':        /* Ringbuffer option */
1187     case 'c':        /* Capture x packets */
1188     case 'f':        /* capture filter */
1189     case 'g':        /* enable group read accesson file(s) */
1190     case 'i':        /* Use interface x */
1191     case 'p':        /* Don't capture in promiscuous mode */
1192 #ifdef HAVE_PCAP_REMOTE
1193     case 'A':        /* Authentication */
1194 #endif
1195 #ifdef HAVE_PCAP_CREATE
1196     case 'I':        /* Capture in monitor mode, if available */
1197 #endif
1198     case 's':        /* Set the snapshot (capture) length */
1199     case 'w':        /* Write to capture file x */
1200     case 'y':        /* Set the pcap data link type */
1201 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
1202     case 'B':        /* Buffer size */
1203 #endif /* _WIN32 or HAVE_PCAP_CREATE */
1204 #ifdef HAVE_LIBPCAP
1205       status = capture_opts_add_opt(&global_capture_opts, opt, optarg, &start_capture);
1206       if (status != 0) {
1207         return status;
1208       }
1209 #else
1210       capture_option_specified = TRUE;
1211       arg_error = TRUE;
1212 #endif
1213       break;
1214     case 'C':
1215       /* Configuration profile settings were already processed just ignore them this time*/
1216       break;
1217     case 'd':        /* Decode as rule */
1218       if (!add_decode_as(optarg))
1219         return 1;
1220       break;
1221 #if defined(HAVE_HEIMDAL_KERBEROS) || defined(HAVE_MIT_KERBEROS)
1222     case 'K':        /* Kerberos keytab file */
1223       read_keytab_file(optarg);
1224       break;
1225 #endif
1226     case 'D':        /* Print a list of capture devices and exit */
1227 #ifdef HAVE_LIBPCAP
1228       if_list = capture_interface_list(&err, &err_str);
1229       if (if_list == NULL) {
1230         switch (err) {
1231         case CANT_GET_INTERFACE_LIST:
1232         case DONT_HAVE_PCAP:
1233           cmdarg_err("%s", err_str);
1234           g_free(err_str);
1235           break;
1236
1237         case NO_INTERFACES_FOUND:
1238           cmdarg_err("There are no interfaces on which a capture can be done");
1239           break;
1240         }
1241         return 2;
1242       }
1243       capture_opts_print_interfaces(if_list);
1244       free_interface_list(if_list);
1245       return 0;
1246 #else
1247       capture_option_specified = TRUE;
1248       arg_error = TRUE;
1249 #endif
1250       break;
1251     case 'e':
1252       /* Field entry */
1253       output_fields_add(output_fields, optarg);
1254       break;
1255     case 'E':
1256       /* Field option */
1257       if (!output_fields_set_option(output_fields, optarg)) {
1258         cmdarg_err("\"%s\" is not a valid field output option=value pair.", optarg);
1259         output_fields_list_options(stderr);
1260         return 1;
1261       }
1262       break;
1263     case 'F':
1264       out_file_type = wtap_short_string_to_file_type(optarg);
1265       if (out_file_type < 0) {
1266         cmdarg_err("\"%s\" isn't a valid capture file type", optarg);
1267         list_capture_types();
1268         return 1;
1269       }
1270       break;
1271     case 'W':        /* Select extra information to save in our capture file */
1272       /* This is patterned after the -N flag which may not be the best idea. */
1273       if (strchr(optarg, 'n')) {
1274         out_file_name_res = TRUE;
1275       } else {
1276         cmdarg_err("Invalid -W argument \"%s\"", optarg);
1277         return 1;
1278       }
1279       break;
1280     case 'H':        /* Read address to name mappings from a hosts file */
1281       if (! add_hosts_file(optarg))
1282       {
1283         cmdarg_err("Can't read host entries from \"%s\"", optarg);
1284         return 1;
1285       }
1286       out_file_name_res = TRUE;
1287       break;
1288
1289     case 'h':        /* Print help and exit */
1290       print_usage(TRUE);
1291       return 0;
1292       break;
1293     case 'l':        /* "Line-buffer" standard output */
1294       /* This isn't line-buffering, strictly speaking, it's just
1295          flushing the standard output after the information for
1296          each packet is printed; however, that should be good
1297          enough for all the purposes to which "-l" is put (and
1298          is probably actually better for "-V", as it does fewer
1299          writes).
1300
1301          See the comment in "process_packet()" for an explanation of
1302          why we do that, and why we don't just use "setvbuf()" to
1303          make the standard output line-buffered (short version: in
1304          Windows, "line-buffered" is the same as "fully-buffered",
1305          and the output buffer is only flushed when it fills up). */
1306       line_buffered = TRUE;
1307       break;
1308     case 'L':        /* Print list of link-layer types and exit */
1309 #ifdef HAVE_LIBPCAP
1310       list_link_layer_types = TRUE;
1311 #else
1312       capture_option_specified = TRUE;
1313       arg_error = TRUE;
1314 #endif
1315       break;
1316     case 'n':        /* No name resolution */
1317       gbl_resolv_flags.mac_name = FALSE;
1318       gbl_resolv_flags.network_name = FALSE;
1319       gbl_resolv_flags.transport_name = FALSE;
1320       gbl_resolv_flags.concurrent_dns = FALSE;
1321       break;
1322     case 'N':        /* Select what types of addresses/port #s to resolve */
1323       badopt = string_to_name_resolve(optarg, &gbl_resolv_flags);
1324       if (badopt != '\0') {
1325         cmdarg_err("-N specifies unknown resolving option '%c';",
1326                    badopt);
1327         cmdarg_err_cont( "           Valid options are 'm', 'n', 't', and 'C'");
1328         return 1;
1329       }
1330       break;
1331     case 'o':        /* Override preference from command line */
1332       switch (prefs_set_pref(optarg)) {
1333
1334       case PREFS_SET_OK:
1335         break;
1336
1337       case PREFS_SET_SYNTAX_ERR:
1338         cmdarg_err("Invalid -o flag \"%s\"", optarg);
1339         return 1;
1340         break;
1341
1342       case PREFS_SET_NO_SUCH_PREF:
1343       case PREFS_SET_OBSOLETE:
1344         cmdarg_err("-o flag \"%s\" specifies unknown preference", optarg);
1345         return 1;
1346         break;
1347       }
1348       break;
1349     case 'q':        /* Quiet */
1350       quiet = TRUE;
1351       break;
1352     case 'r':        /* Read capture file x */
1353       cf_name = g_strdup(optarg);
1354       break;
1355     case 'R':        /* Read file filter */
1356       rfilter = optarg;
1357       break;
1358     case 'P':
1359         /* already processed; just ignore it now */
1360         break;
1361     case 'S':        /* Set the line Separator to be printed between packets */
1362       separator = strdup(optarg);
1363       break;
1364     case 't':        /* Time stamp type */
1365       if (strcmp(optarg, "r") == 0)
1366         timestamp_set_type(TS_RELATIVE);
1367       else if (strcmp(optarg, "a") == 0)
1368         timestamp_set_type(TS_ABSOLUTE);
1369       else if (strcmp(optarg, "ad") == 0)
1370         timestamp_set_type(TS_ABSOLUTE_WITH_DATE);
1371       else if (strcmp(optarg, "d") == 0)
1372         timestamp_set_type(TS_DELTA);
1373       else if (strcmp(optarg, "dd") == 0)
1374         timestamp_set_type(TS_DELTA_DIS);
1375       else if (strcmp(optarg, "e") == 0)
1376         timestamp_set_type(TS_EPOCH);
1377       else if (strcmp(optarg, "u") == 0)
1378         timestamp_set_type(TS_UTC);
1379       else if (strcmp(optarg, "ud") == 0)
1380         timestamp_set_type(TS_UTC_WITH_DATE);
1381       else {
1382         cmdarg_err("Invalid time stamp type \"%s\"",
1383                    optarg);
1384         cmdarg_err_cont("It must be \"r\" for relative, \"a\" for absolute,");
1385         cmdarg_err_cont("\"ad\" for absolute with date, or \"d\" for delta.");
1386         return 1;
1387       }
1388       break;
1389     case 'T':        /* printing Type */
1390       if (strcmp(optarg, "text") == 0) {
1391         output_action = WRITE_TEXT;
1392         print_format = PR_FMT_TEXT;
1393       } else if (strcmp(optarg, "ps") == 0) {
1394         output_action = WRITE_TEXT;
1395         print_format = PR_FMT_PS;
1396       } else if (strcmp(optarg, "pdml") == 0) {
1397         output_action = WRITE_XML;
1398         print_details = TRUE;   /* Need details */
1399         print_summary = FALSE;  /* Don't allow summary */
1400       } else if (strcmp(optarg, "psml") == 0) {
1401         output_action = WRITE_XML;
1402         print_details = FALSE;  /* Don't allow details */
1403         print_summary = TRUE;   /* Need summary */
1404       } else if (strcmp(optarg, "fields") == 0) {
1405         output_action = WRITE_FIELDS;
1406         print_details = TRUE;   /* Need full tree info */
1407         print_summary = FALSE;  /* Don't allow summary */
1408       } else {
1409         cmdarg_err("Invalid -T parameter.");
1410         cmdarg_err_cont("It must be \"ps\", \"text\", \"pdml\", \"psml\" or \"fields\".");
1411         return 1;
1412       }
1413       break;
1414     case 'u':        /* Seconds type */
1415       if (strcmp(optarg, "s") == 0)
1416         timestamp_set_seconds_type(TS_SECONDS_DEFAULT);
1417       else if (strcmp(optarg, "hms") == 0)
1418         timestamp_set_seconds_type(TS_SECONDS_HOUR_MIN_SEC);
1419       else {
1420         cmdarg_err("Invalid seconds type \"%s\"", optarg);
1421         cmdarg_err_cont("It must be \"s\" for seconds or \"hms\" for hours, minutes and seconds.");
1422         return 1;
1423       }
1424       break;
1425     case 'v':         /* Show version and exit */
1426     {
1427       GString             *comp_info_str;
1428       GString             *runtime_info_str;
1429       /* Assemble the compile-time version information string */
1430       comp_info_str = g_string_new("Compiled ");
1431       get_compiled_version_info(comp_info_str, NULL, epan_get_compiled_version_info);
1432
1433       /* Assemble the run-time version information string */
1434       runtime_info_str = g_string_new("Running ");
1435       get_runtime_version_info(runtime_info_str, NULL);
1436       show_version(comp_info_str, runtime_info_str);
1437       g_string_free(comp_info_str, TRUE);
1438       g_string_free(runtime_info_str, TRUE);
1439       return 0;
1440     }
1441     case 'O':        /* Only output these protocols */
1442       /* already processed; just ignore it now */
1443       break;
1444     case 'V':        /* Verbose */
1445       /* already processed; just ignore it now */
1446       break;
1447     case 'x':        /* Print packet data in hex (and ASCII) */
1448       /* already processed; just ignore it now */
1449       break;
1450     case 'X':
1451       break;
1452     case 'z':
1453       /* We won't call the init function for the stat this soon
1454          as it would disallow MATE's fields (which are registered
1455          by the preferences set callback) from being used as
1456          part of a tap filter.  Instead, we just add the argument
1457          to a list of stat arguments. */
1458       if (!process_stat_cmd_arg(optarg)) {
1459         cmdarg_err("Invalid -z argument \"%s\".", optarg);
1460         cmdarg_err_cont("  -z argument must be one of :");
1461         list_stat_cmd_args();
1462         return 1;
1463       }
1464       break;
1465     default:
1466     case '?':        /* Bad flag - print usage message */
1467       switch(optopt) {
1468       case 'F':
1469         list_capture_types();
1470         break;
1471       default:
1472         print_usage(TRUE);
1473       }
1474       return 1;
1475       break;
1476     }
1477   }
1478
1479   /* If we specified output fields, but not the output field type... */
1480   if (WRITE_FIELDS != output_action && 0 != output_fields_num_fields(output_fields)) {
1481         cmdarg_err("Output fields were specified with \"-e\", "
1482             "but \"-Tfields\" was not specified.");
1483         return 1;
1484   } else if (WRITE_FIELDS == output_action && 0 == output_fields_num_fields(output_fields)) {
1485         cmdarg_err("\"-Tfields\" was specified, but no fields were "
1486                     "specified with \"-e\".");
1487
1488         return 1;
1489   }
1490
1491   /* If no capture filter or read filter has been specified, and there are
1492      still command-line arguments, treat them as the tokens of a capture
1493      filter (if no "-r" flag was specified) or a read filter (if a "-r"
1494      flag was specified. */
1495   if (optind < argc) {
1496     if (cf_name != NULL) {
1497       if (rfilter != NULL) {
1498         cmdarg_err("Read filters were specified both with \"-R\" "
1499             "and with additional command-line arguments.");
1500         return 1;
1501       }
1502       rfilter = get_args_as_string(argc, argv, optind);
1503     } else {
1504 #ifdef HAVE_LIBPCAP
1505       guint i;
1506
1507       if (global_capture_opts.default_options.cfilter) {
1508         cmdarg_err("A default capture filter was specified both with \"-f\""
1509             " and with additional command-line arguments.");
1510         return 1;
1511       }
1512       for (i = 0; i < global_capture_opts.ifaces->len; i++) {
1513         interface_options interface_opts;
1514         interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
1515         if (interface_opts.cfilter == NULL) {
1516           interface_opts.cfilter = get_args_as_string(argc, argv, optind);
1517           global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
1518           g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
1519         } else {
1520           cmdarg_err("A capture filter was specified both with \"-f\""
1521               " and with additional command-line arguments.");
1522           return 1;
1523         }
1524       }
1525       global_capture_opts.default_options.cfilter = get_args_as_string(argc, argv, optind);
1526 #else
1527       capture_option_specified = TRUE;
1528 #endif
1529     }
1530   }
1531
1532 #ifdef HAVE_LIBPCAP
1533   if (!global_capture_opts.saving_to_file) {
1534     /* We're not saving the capture to a file; if "-q" wasn't specified,
1535        we should print packet information */
1536     if (!quiet)
1537       print_packet_info = TRUE;
1538   } else {
1539     /* We're saving to a file; if we're writing to the standard output.
1540        and we'll also be writing dissected packets to the standard
1541        output, reject the request.  At best, we could redirect that
1542        to the standard error; we *can't* write both to the standard
1543        output and have either of them be useful. */
1544     if (strcmp(global_capture_opts.save_file, "-") == 0 && print_packet_info) {
1545       cmdarg_err("You can't write both raw packet data and dissected packets"
1546           " to the standard output.");
1547       return 1;
1548     }
1549   }
1550 #else
1551   /* We're not saving the capture to a file; if "-q" wasn't specified,
1552      we should print packet information */
1553   if (!quiet)
1554     print_packet_info = TRUE;
1555 #endif
1556
1557 #ifndef HAVE_LIBPCAP
1558   if (capture_option_specified)
1559     cmdarg_err("This version of TShark was not built with support for capturing packets.");
1560 #endif
1561   if (arg_error) {
1562     print_usage(FALSE);
1563     return 1;
1564   }
1565
1566   /* We don't support capture filters when reading from a capture file
1567      (the BPF compiler doesn't support all link-layer types that we
1568      support in capture files we read). */
1569 #ifdef HAVE_LIBPCAP
1570   if (cf_name != NULL) {
1571     if (global_capture_opts.default_options.cfilter) {
1572       cmdarg_err("Only read filters, not capture filters, "
1573           "can be specified when reading a capture file.");
1574       return 1;
1575     }
1576   }
1577 #endif
1578
1579   if (print_hex) {
1580     if (output_action != WRITE_TEXT) {
1581       cmdarg_err("Raw packet hex data can only be printed as text or PostScript");
1582       return 1;
1583     }
1584   }
1585
1586   if (output_only != NULL) {
1587     char *ps;
1588
1589     if (!print_details) {
1590       cmdarg_err("-O requires -V");
1591       return 1;
1592     }
1593
1594     output_only_tables = g_hash_table_new (g_str_hash, g_str_equal);
1595     for (ps = strtok (output_only, ","); ps; ps = strtok (NULL, ",")) {
1596       g_hash_table_insert(output_only_tables, (gpointer)ps, (gpointer)ps);
1597     }
1598   }
1599
1600 #ifdef HAVE_LIBPCAP
1601   if (list_link_layer_types) {
1602     /* We're supposed to list the link-layer types for an interface;
1603        did the user also specify a capture file to be read? */
1604     if (cf_name) {
1605       /* Yes - that's bogus. */
1606       cmdarg_err("You can't specify -L and a capture file to be read.");
1607       return 1;
1608     }
1609     /* No - did they specify a ring buffer option? */
1610     if (global_capture_opts.multi_files_on) {
1611       cmdarg_err("Ring buffer requested, but a capture isn't being done.");
1612       return 1;
1613     }
1614   } else {
1615     if (cf_name) {
1616       /*
1617        * "-r" was specified, so we're reading a capture file.
1618        * Capture options don't apply here.
1619        */
1620       if (global_capture_opts.multi_files_on) {
1621         cmdarg_err("Multiple capture files requested, but "
1622                    "a capture isn't being done.");
1623         return 1;
1624       }
1625       if (global_capture_opts.has_file_duration) {
1626         cmdarg_err("Switching capture files after a time interval was specified, but "
1627                    "a capture isn't being done.");
1628         return 1;
1629       }
1630       if (global_capture_opts.has_ring_num_files) {
1631         cmdarg_err("A ring buffer of capture files was specified, but "
1632           "a capture isn't being done.");
1633         return 1;
1634       }
1635       if (global_capture_opts.has_autostop_files) {
1636         cmdarg_err("A maximum number of capture files was specified, but "
1637           "a capture isn't being done.");
1638         return 1;
1639       }
1640
1641       /* Note: TShark now allows the restriction of a _read_ file by packet count
1642        * and byte count as well as a write file. Other autostop options remain valid
1643        * only for a write file.
1644        */
1645       if (global_capture_opts.has_autostop_duration) {
1646         cmdarg_err("A maximum capture time was specified, but "
1647           "a capture isn't being done.");
1648         return 1;
1649       }
1650     } else {
1651       /*
1652        * "-r" wasn't specified, so we're doing a live capture.
1653        */
1654       if (global_capture_opts.saving_to_file) {
1655         /* They specified a "-w" flag, so we'll be saving to a capture file. */
1656
1657         /* When capturing, we only support writing pcap or pcap-ng format. */
1658         if (out_file_type != WTAP_FILE_PCAP && out_file_type != WTAP_FILE_PCAPNG) {
1659           cmdarg_err("Live captures can only be saved in libpcap format.");
1660           return 1;
1661         }
1662         if (global_capture_opts.multi_files_on) {
1663           /* Multiple-file mode doesn't work under certain conditions:
1664              a) it doesn't work if you're writing to the standard output;
1665              b) it doesn't work if you're writing to a pipe;
1666           */
1667           if (strcmp(global_capture_opts.save_file, "-") == 0) {
1668             cmdarg_err("Multiple capture files requested, but "
1669               "the capture is being written to the standard output.");
1670             return 1;
1671           }
1672           if (global_capture_opts.output_to_pipe) {
1673             cmdarg_err("Multiple capture files requested, but "
1674               "the capture file is a pipe.");
1675             return 1;
1676           }
1677           if (!global_capture_opts.has_autostop_filesize &&
1678               !global_capture_opts.has_file_duration) {
1679             cmdarg_err("Multiple capture files requested, but "
1680               "no maximum capture file size or duration was specified.");
1681             return 1;
1682           }
1683         }
1684         /* Currently, we don't support read filters when capturing
1685            and saving the packets. */
1686         if (rfilter != NULL) {
1687           cmdarg_err("Read filters aren't supported when capturing and saving the captured packets.");
1688           return 1;
1689         }
1690       } else {
1691         /* They didn't specify a "-w" flag, so we won't be saving to a
1692            capture file.  Check for options that only make sense if
1693            we're saving to a file. */
1694         if (global_capture_opts.has_autostop_filesize) {
1695           cmdarg_err("Maximum capture file size specified, but "
1696            "capture isn't being saved to a file.");
1697           return 1;
1698         }
1699         if (global_capture_opts.multi_files_on) {
1700           cmdarg_err("Multiple capture files requested, but "
1701             "the capture isn't being saved to a file.");
1702           return 1;
1703         }
1704       }
1705     }
1706   }
1707 #endif
1708
1709 #ifdef _WIN32
1710   /* Start windows sockets */
1711   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
1712 #endif /* _WIN32 */
1713
1714   /* Notify all registered modules that have had any of their preferences
1715      changed either from one of the preferences file or from the command
1716      line that their preferences have changed. */
1717   prefs_apply_all();
1718
1719   /* At this point MATE will have registered its field array so we can
1720      have a tap filter with one of MATE's late-registered fields as part
1721      of the filter.  We can now process all the "-z" arguments. */
1722   start_requested_stats();
1723
1724 #ifdef HAVE_LIBPCAP
1725   /* We currently don't support taps, or printing dissected packets,
1726      if we're writing to a pipe. */
1727   if (global_capture_opts.saving_to_file &&
1728       global_capture_opts.output_to_pipe) {
1729     if (tap_listeners_require_dissection()) {
1730       cmdarg_err("Taps aren't supported when saving to a pipe.");
1731       return 1;
1732     }
1733     if (print_packet_info) {
1734       cmdarg_err("Printing dissected packets isn't supported when saving to a pipe.");
1735       return 1;
1736     }
1737   }
1738 #endif
1739
1740   /* disabled protocols as per configuration file */
1741   if (gdp_path == NULL && dp_path == NULL) {
1742     set_disabled_protos_list();
1743   }
1744
1745   /* Build the column format array */
1746   build_column_format_array(&cfile.cinfo, prefs_p->num_cols, TRUE);
1747
1748 #ifdef HAVE_LIBPCAP
1749   capture_opts_trim_snaplen(&global_capture_opts, MIN_PACKET_SIZE);
1750   capture_opts_trim_ring_num_files(&global_capture_opts);
1751 #endif
1752
1753   if (rfilter != NULL) {
1754     if (!dfilter_compile(rfilter, &rfcode)) {
1755       cmdarg_err("%s", dfilter_error_msg);
1756       epan_cleanup();
1757 #ifdef HAVE_PCAP_OPEN_DEAD
1758       {
1759         pcap_t *pc;
1760
1761         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1762         if (pc != NULL) {
1763           if (pcap_compile(pc, &fcode, rfilter, 0, 0) != -1) {
1764             cmdarg_err_cont(
1765               "  Note: That display filter code looks like a valid capture filter;");
1766             cmdarg_err_cont(
1767               "        maybe you mixed them up?");
1768           }
1769           pcap_close(pc);
1770         }
1771       }
1772 #endif
1773       return 2;
1774     }
1775   }
1776   cfile.rfcode = rfcode;
1777
1778   if (print_packet_info) {
1779     /* If we're printing as text or PostScript, we have
1780        to create a print stream. */
1781     if (output_action == WRITE_TEXT) {
1782       switch (print_format) {
1783
1784       case PR_FMT_TEXT:
1785         print_stream = print_stream_text_stdio_new(stdout);
1786         break;
1787
1788       case PR_FMT_PS:
1789         print_stream = print_stream_ps_stdio_new(stdout);
1790         break;
1791
1792       default:
1793         g_assert_not_reached();
1794       }
1795     }
1796   }
1797
1798   /* We have to dissect each packet if:
1799
1800         we're printing information about each packet;
1801
1802         we're using a read filter on the packets;
1803
1804         we're using any taps that need dissection. */
1805   do_dissection = print_packet_info || rfcode || tap_listeners_require_dissection();
1806
1807   if (cf_name) {
1808     /*
1809      * We're reading a capture file.
1810      */
1811
1812     /*
1813      * Immediately relinquish any special privileges we have; we must not
1814      * be allowed to read any capture files the user running TShark
1815      * can't open.
1816      */
1817     relinquish_special_privs_perm();
1818     print_current_user();
1819
1820     if (cf_open(&cfile, cf_name, FALSE, &err) != CF_OK) {
1821       epan_cleanup();
1822       return 2;
1823     }
1824
1825     /* Set timestamp precision; there should arguably be a command-line
1826        option to let the user set this. */
1827     switch(wtap_file_tsprecision(cfile.wth)) {
1828     case(WTAP_FILE_TSPREC_SEC):
1829       timestamp_set_precision(TS_PREC_AUTO_SEC);
1830       break;
1831     case(WTAP_FILE_TSPREC_DSEC):
1832       timestamp_set_precision(TS_PREC_AUTO_DSEC);
1833       break;
1834     case(WTAP_FILE_TSPREC_CSEC):
1835       timestamp_set_precision(TS_PREC_AUTO_CSEC);
1836       break;
1837     case(WTAP_FILE_TSPREC_MSEC):
1838       timestamp_set_precision(TS_PREC_AUTO_MSEC);
1839       break;
1840     case(WTAP_FILE_TSPREC_USEC):
1841       timestamp_set_precision(TS_PREC_AUTO_USEC);
1842       break;
1843     case(WTAP_FILE_TSPREC_NSEC):
1844       timestamp_set_precision(TS_PREC_AUTO_NSEC);
1845       break;
1846     default:
1847       g_assert_not_reached();
1848     }
1849
1850     /* Process the packets in the file */
1851     TRY {
1852 #ifdef HAVE_LIBPCAP
1853       err = load_cap_file(&cfile, global_capture_opts.save_file, out_file_type, out_file_name_res,
1854           global_capture_opts.has_autostop_packets ? global_capture_opts.autostop_packets : 0,
1855           global_capture_opts.has_autostop_filesize ? global_capture_opts.autostop_filesize : 0);
1856 #else
1857       err = load_cap_file(&cfile, NULL, out_file_type, out_file_name_res, 0, 0);
1858 #endif
1859     }
1860     CATCH(OutOfMemoryError) {
1861       fprintf(stderr,
1862               "Out Of Memory!\n"
1863               "\n"
1864               "Sorry, but TShark has to terminate now!\n"
1865               "\n"
1866               "Some infos / workarounds can be found at:\n"
1867               "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
1868       err = ENOMEM;
1869     }
1870     ENDTRY;
1871     if (err != 0) {
1872       /* We still dump out the results of taps, etc., as we might have
1873          read some packets; however, we exit with an error status. */
1874       exit_status = 2;
1875     }
1876   } else {
1877     /* No capture file specified, so we're supposed to do a live capture
1878        (or get a list of link-layer types for a live capture device);
1879        do we have support for live captures? */
1880 #ifdef HAVE_LIBPCAP
1881     /* trim the interface name and exit if that failed */
1882     exit_status = capture_opts_trim_iface(&global_capture_opts,
1883         ((prefs_p->capture_device) && (*prefs_p->capture_device != '\0')) ? get_if_name(prefs_p->capture_device) : NULL);
1884     if (exit_status != 0)
1885         return exit_status;
1886
1887     /* if requested, list the link layer types and exit */
1888     if (list_link_layer_types) {
1889         guint i;
1890
1891         /* Get the list of link-layer types for the capture devices. */
1892         for (i = 0; i < global_capture_opts.ifaces->len; i++) {
1893           interface_options  interface_opts;
1894           if_capabilities_t *caps;
1895
1896           interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
1897           caps = capture_get_if_capabilities(interface_opts.name, interface_opts.monitor_mode, &err_str);
1898           if (caps == NULL) {
1899             cmdarg_err("%s", err_str);
1900             g_free(err_str);
1901             return 2;
1902           }
1903           if (caps->data_link_types == NULL) {
1904             cmdarg_err("The capture device \"%s\" has no data link types.", interface_opts.name);
1905             return 2;
1906           }
1907           capture_opts_print_if_capabilities(caps, interface_opts.name, interface_opts.monitor_mode);
1908           free_if_capabilities(caps);
1909         }
1910         return 0;
1911     }
1912
1913     if (print_packet_info) {
1914       if (!write_preamble(NULL)) {
1915         show_print_file_io_error(errno);
1916         return 2;
1917       }
1918     } else if (!quiet) {
1919       /*
1920        * We're not printing information for each packet, and the user
1921        * didn't ask us not to print a count of packets as they arrive,
1922        * so print that count so the user knows that packets are arriving.
1923        *
1924        * XXX - what if the user wants to do a live capture, doesn't want
1925        * to save it to a file, doesn't want information printed for each
1926        * packet, does want some "-z" statistic, and wants packet counts
1927        * so they know whether they're seeing any packets?
1928        */
1929       print_packet_counts = TRUE;
1930     }
1931
1932     /* For now, assume libpcap gives microsecond precision. */
1933     timestamp_set_precision(TS_PREC_AUTO_USEC);
1934
1935     /*
1936      * XXX - this returns FALSE if an error occurred, but it also
1937      * returns FALSE if the capture stops because a time limit
1938      * was reached (and possibly other limits), so we can't assume
1939      * it means an error.
1940      *
1941      * The capture code is a bit twisty, so it doesn't appear to
1942      * be an easy fix.  We just ignore the return value for now.
1943      * Instead, pass on the exit status from the capture child.
1944      */
1945     capture();
1946     exit_status = global_capture_opts.fork_child_status;
1947
1948     if (print_packet_info) {
1949       if (!write_finale()) {
1950         err = errno;
1951         show_print_file_io_error(err);
1952       }
1953     }
1954 #else
1955     /* No - complain. */
1956     cmdarg_err("This version of TShark was not built with support for capturing packets.");
1957     return 2;
1958 #endif
1959   }
1960
1961   g_free(cf_name);
1962
1963   if (cfile.frames != NULL) {
1964     free_frame_data_sequence(cfile.frames);
1965     cfile.frames = NULL;
1966   }
1967
1968   draw_tap_listeners(TRUE);
1969   funnel_dump_all_text_windows();
1970   epan_cleanup();
1971
1972   output_fields_free(output_fields);
1973   output_fields = NULL;
1974
1975   return exit_status;
1976 }
1977
1978 /*#define USE_BROKEN_G_MAIN_LOOP*/
1979
1980 #ifdef USE_BROKEN_G_MAIN_LOOP
1981   GMainLoop *loop;
1982 #else
1983   gboolean loop_running = FALSE;
1984 #endif
1985   guint32 packet_count = 0;
1986
1987
1988 /* XXX - move to the right position / file */
1989 /* read from a pipe (callback) */
1990 typedef gboolean (*pipe_input_cb_t) (gint source, gpointer user_data);
1991
1992 typedef struct pipe_input_tag {
1993   gint             source;
1994   gpointer         user_data;
1995   int             *child_process;
1996   pipe_input_cb_t  input_cb;
1997   guint            pipe_input_id;
1998 #ifdef _WIN32
1999   GMutex          *callback_running;
2000 #endif
2001 } pipe_input_t;
2002
2003 static pipe_input_t pipe_input;
2004
2005 #ifdef _WIN32
2006 /* The timer has expired, see if there's stuff to read from the pipe,
2007    if so, do the callback */
2008 static gint
2009 pipe_timer_cb(gpointer data)
2010 {
2011   HANDLE        handle;
2012   DWORD         avail        = 0;
2013   gboolean      result;
2014   DWORD         childstatus;
2015   pipe_input_t *pipe_input_p = data;
2016   gint          iterations   = 0;
2017
2018   g_mutex_lock (pipe_input_p->callback_running);
2019
2020   /* try to read data from the pipe only 5 times, to avoid blocking */
2021   while(iterations < 5) {
2022     /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: new iteration");*/
2023
2024     /* Oddly enough although Named pipes don't work on win9x,
2025        PeekNamedPipe does !!! */
2026     handle = (HANDLE) _get_osfhandle (pipe_input_p->source);
2027     result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
2028
2029     /* Get the child process exit status */
2030     GetExitCodeProcess((HANDLE)*(pipe_input_p->child_process),
2031                        &childstatus);
2032
2033     /* If the Peek returned an error, or there are bytes to be read
2034        or the childwatcher thread has terminated then call the normal
2035        callback */
2036     if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
2037
2038       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: data avail");*/
2039
2040       /* And call the real handler */
2041       if (!pipe_input_p->input_cb(pipe_input_p->source, pipe_input_p->user_data)) {
2042         g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
2043         /* pipe closed, return false so that the timer is stopped */
2044         g_mutex_unlock (pipe_input_p->callback_running);
2045         return FALSE;
2046       }
2047     }
2048     else {
2049       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: no data avail");*/
2050       /* No data, stop now */
2051       break;
2052     }
2053
2054     iterations++;
2055   }
2056
2057   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: finished with iterations: %u, new timer", iterations);*/
2058
2059   g_mutex_unlock (pipe_input_p->callback_running);
2060
2061   /* we didn't stopped the timer, so let it run */
2062   return TRUE;
2063 }
2064 #endif
2065
2066
2067 void
2068 pipe_input_set_handler(gint source, gpointer user_data, int *child_process, pipe_input_cb_t input_cb)
2069 {
2070
2071   pipe_input.source         = source;
2072   pipe_input.child_process  = child_process;
2073   pipe_input.user_data      = user_data;
2074   pipe_input.input_cb       = input_cb;
2075
2076 #ifdef _WIN32
2077 #if GLIB_CHECK_VERSION(2,31,0)
2078   pipe_input.callback_running = g_malloc(sizeof(GMutex));
2079   g_mutex_init(pipe_input.callback_running);
2080 #else
2081   pipe_input.callback_running = g_mutex_new();
2082 #endif
2083   /* Tricky to use pipes in win9x, as no concept of wait.  NT can
2084      do this but that doesn't cover all win32 platforms.  GTK can do
2085      this but doesn't seem to work over processes.  Attempt to do
2086      something similar here, start a timer and check for data on every
2087      timeout. */
2088   /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
2089   pipe_input.pipe_input_id = g_timeout_add(200, pipe_timer_cb, &pipe_input);
2090 #endif
2091 }
2092
2093
2094 #ifdef HAVE_LIBPCAP
2095 static gboolean
2096 capture(void)
2097 {
2098   gboolean          ret;
2099   guint             i;
2100   GString          *str = g_string_new("");
2101 #ifdef USE_TSHARK_SELECT
2102   fd_set            readfds;
2103 #endif
2104 #ifndef _WIN32
2105   struct sigaction  action, oldaction;
2106 #endif
2107
2108   /*
2109    * XXX - dropping privileges is still required, until code cleanup is done
2110    *
2111    * remove all dependencies to pcap specific code and using only dumpcap is almost done.
2112    * when it's done, we don't need special privileges to run tshark at all,
2113    * therefore we don't need to drop these privileges
2114    * The only thing we might want to keep is a warning if tshark is run as root,
2115    * as it's no longer necessary and potentially dangerous.
2116    *
2117    * THE FOLLOWING IS THE FORMER COMMENT WHICH IS NO LONGER REALLY VALID:
2118    * We've opened the capture device, so we shouldn't need any special
2119    * privileges any more; relinquish those privileges.
2120    *
2121    * XXX - if we have saved set-user-ID support, we should give up those
2122    * privileges immediately, and then reclaim them long enough to get
2123    * a list of network interfaces and to open one, and then give them
2124    * up again, so that stuff we do while processing the argument list,
2125    * reading the user's preferences, loading and starting plugins
2126    * (especially *user* plugins), etc. is done with the user's privileges,
2127    * not special privileges.
2128    */
2129   relinquish_special_privs_perm();
2130   print_current_user();
2131
2132   /* Cleanup all data structures used for dissection. */
2133   cleanup_dissection();
2134   /* Initialize all data structures used for dissection. */
2135   init_dissection();
2136
2137 #ifdef _WIN32
2138   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
2139   SetConsoleCtrlHandler(capture_cleanup, TRUE);
2140 #else /* _WIN32 */
2141   /* Catch SIGINT and SIGTERM and, if we get either of them,
2142      clean up and exit.  If SIGHUP isn't being ignored, catch
2143      it too and, if we get it, clean up and exit.
2144
2145      We restart any read that was in progress, so that it doesn't
2146      disrupt reading from the sync pipe.  The signal handler tells
2147      the capture child to finish; it will report that it finished,
2148      or will exit abnormally, so  we'll stop reading from the sync
2149      pipe, pick up the exit status, and quit. */
2150   memset(&action, 0, sizeof(action));
2151   action.sa_handler = capture_cleanup;
2152   action.sa_flags = SA_RESTART;
2153   sigemptyset(&action.sa_mask);
2154   sigaction(SIGTERM, &action, NULL);
2155   sigaction(SIGINT, &action, NULL);
2156   sigaction(SIGHUP, NULL, &oldaction);
2157   if (oldaction.sa_handler == SIG_DFL)
2158     sigaction(SIGHUP, &action, NULL);
2159
2160 #ifdef SIGINFO
2161   /* Catch SIGINFO and, if we get it and we're capturing to a file in
2162      quiet mode, report the number of packets we've captured.
2163
2164      Again, restart any read that was in progress, so that it doesn't
2165      disrupt reading from the sync pipe. */
2166   action.sa_handler = report_counts_siginfo;
2167   action.sa_flags = SA_RESTART;
2168   sigemptyset(&action.sa_mask);
2169   sigaction(SIGINFO, &action, NULL);
2170 #endif /* SIGINFO */
2171 #endif /* _WIN32 */
2172
2173   global_capture_opts.state = CAPTURE_PREPARING;
2174
2175   /* Let the user know which interfaces were chosen. */
2176   for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2177     interface_options interface_opts;
2178
2179     interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2180     interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
2181     global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
2182     g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
2183   }
2184 #ifdef _WIN32
2185   if (global_capture_opts.ifaces->len < 2) {
2186 #else
2187   if (global_capture_opts.ifaces->len < 4) {
2188 #endif
2189     for (i = 0; i < global_capture_opts.ifaces->len; i++) {
2190       interface_options interface_opts;
2191
2192       interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
2193       if (i > 0) {
2194           if (global_capture_opts.ifaces->len > 2) {
2195               g_string_append_printf(str, ",");
2196           }
2197           g_string_append_printf(str, " ");
2198           if (i == global_capture_opts.ifaces->len - 1) {
2199               g_string_append_printf(str, "and ");
2200           }
2201       }
2202       g_string_append_printf(str, "'%s'", interface_opts.descr);
2203     }
2204   } else {
2205     g_string_append_printf(str, "%u interfaces", global_capture_opts.ifaces->len);
2206   }
2207   fprintf(stderr, "Capturing on %s\n", str->str);
2208   fflush(stderr);
2209   g_string_free(str, TRUE);
2210
2211   ret = sync_pipe_start(&global_capture_opts);
2212
2213   if (!ret)
2214     return FALSE;
2215
2216   /* the actual capture loop
2217    *
2218    * XXX - glib doesn't seem to provide any event based loop handling.
2219    *
2220    * XXX - for whatever reason,
2221    * calling g_main_loop_new() ends up in 100% cpu load.
2222    *
2223    * But that doesn't matter: in UNIX we can use select() to find an input
2224    * source with something to do.
2225    *
2226    * But that doesn't matter because we're in a CLI (that doesn't need to
2227    * update a GUI or something at the same time) so it's OK if we block
2228    * trying to read from the pipe.
2229    *
2230    * So all the stuff in USE_TSHARK_SELECT could be removed unless I'm
2231    * wrong (but I leave it there in case I am...).
2232    */
2233
2234 #ifdef USE_TSHARK_SELECT
2235   FD_ZERO(&readfds);
2236   FD_SET(pipe_input.source, &readfds);
2237 #endif
2238
2239   loop_running = TRUE;
2240
2241   TRY
2242   {
2243     while (loop_running)
2244     {
2245 #ifdef USE_TSHARK_SELECT
2246       ret = select(pipe_input.source+1, &readfds, NULL, NULL, NULL);
2247
2248       if (ret == -1)
2249       {
2250         perror("select()");
2251         return TRUE;
2252       } else if (ret == 1) {
2253 #endif
2254         /* Call the real handler */
2255         if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
2256           g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
2257           return FALSE;
2258         }
2259 #ifdef USE_TSHARK_SELECT
2260       }
2261 #endif
2262     }
2263   }
2264   CATCH(OutOfMemoryError) {
2265     fprintf(stderr,
2266             "Out Of Memory!\n"
2267             "\n"
2268             "Sorry, but TShark has to terminate now!\n"
2269             "\n"
2270             "Some infos / workarounds can be found at:\n"
2271             "http://wiki.wireshark.org/KnownBugs/OutOfMemory\n");
2272     exit(1);
2273   }
2274   ENDTRY;
2275   return TRUE;
2276 }
2277
2278
2279 /* XXX - move the call to main_window_update() out of capture_sync.c */
2280 /* dummy for capture_sync.c to make linker happy */
2281 void main_window_update(void)
2282 {
2283 }
2284
2285 /* capture child detected an error */
2286 void
2287 capture_input_error_message(capture_options *capture_opts _U_, char *error_msg, char *secondary_error_msg)
2288 {
2289   cmdarg_err("%s", error_msg);
2290   cmdarg_err_cont("%s", secondary_error_msg);
2291 }
2292
2293
2294 /* capture child detected an capture filter related error */
2295 void
2296 capture_input_cfilter_error_message(capture_options *capture_opts, guint i, char *error_message)
2297 {
2298   dfilter_t         *rfcode = NULL;
2299   interface_options  interface_opts;
2300
2301   g_assert(i < capture_opts->ifaces->len);
2302   interface_opts = g_array_index(capture_opts->ifaces, interface_options, i);
2303
2304   if (dfilter_compile(interface_opts.cfilter, &rfcode) && rfcode != NULL) {
2305     cmdarg_err(
2306       "Invalid capture filter \"%s\" for interface %s!\n"
2307       "\n"
2308       "That string looks like a valid display filter; however, it isn't a valid\n"
2309       "capture filter (%s).\n"
2310       "\n"
2311       "Note that display filters and capture filters don't have the same syntax,\n"
2312       "so you can't use most display filter expressions as capture filters.\n"
2313       "\n"
2314       "See the User's Guide for a description of the capture filter syntax.",
2315       interface_opts.cfilter, interface_opts.descr, error_message);
2316     dfilter_free(rfcode);
2317   } else {
2318     cmdarg_err(
2319       "Invalid capture filter \"%s\" for interface %s!\n"
2320       "\n"
2321       "That string isn't a valid capture filter (%s).\n"
2322       "See the User's Guide for a description of the capture filter syntax.",
2323       interface_opts.cfilter, interface_opts.descr, error_message);
2324   }
2325 }
2326
2327
2328 /* capture child tells us we have a new (or the first) capture file */
2329 gboolean
2330 capture_input_new_file(capture_options *capture_opts, gchar *new_file)
2331 {
2332   gboolean is_tempfile;
2333   int      err;
2334
2335   if (capture_opts->state == CAPTURE_PREPARING) {
2336     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!");
2337   }
2338   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
2339
2340   g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING);
2341
2342   /* free the old filename */
2343   if (capture_opts->save_file != NULL) {
2344
2345     /* we start a new capture file, close the old one (if we had one before) */
2346     if ( ((capture_file *) capture_opts->cf)->state != FILE_CLOSED) {
2347       if ( ((capture_file *) capture_opts->cf)->wth != NULL) {
2348         wtap_close(((capture_file *) capture_opts->cf)->wth);
2349       }
2350       ((capture_file *) capture_opts->cf)->state = FILE_CLOSED;
2351     }
2352
2353     g_free(capture_opts->save_file);
2354     is_tempfile = FALSE;
2355   } else {
2356     /* we didn't had a save_file before, must be a tempfile */
2357     is_tempfile = TRUE;
2358   }
2359
2360   /* save the new filename */
2361   capture_opts->save_file = g_strdup(new_file);
2362
2363   /* if we are in real-time mode, open the new file now */
2364   if (do_dissection) {
2365     /* Attempt to open the capture file and set up to read from it. */
2366     switch(cf_open(capture_opts->cf, capture_opts->save_file, is_tempfile, &err)) {
2367     case CF_OK:
2368       break;
2369     case CF_ERROR:
2370       /* Don't unlink (delete) the save file - leave it around,
2371          for debugging purposes. */
2372       g_free(capture_opts->save_file);
2373       capture_opts->save_file = NULL;
2374       return FALSE;
2375     }
2376   }
2377
2378   capture_opts->state = CAPTURE_RUNNING;
2379
2380   return TRUE;
2381 }
2382
2383
2384 /* capture child tells us we have new packets to read */
2385 void
2386 capture_input_new_packets(capture_options *capture_opts, int to_read)
2387 {
2388   gboolean      ret;
2389   int           err;
2390   gchar        *err_info;
2391   gint64        data_offset;
2392   capture_file *cf = capture_opts->cf;
2393   gboolean      filtering_tap_listeners;
2394   guint         tap_flags;
2395
2396 #ifdef SIGINFO
2397   /*
2398    * Prevent a SIGINFO handler from writing to the standard error while
2399    * we're doing so or writing to the standard output; instead, have it
2400    * just set a flag telling us to print that information when we're done.
2401    */
2402   infodelay = TRUE;
2403 #endif /* SIGINFO */
2404
2405   /* Do we have any tap listeners with filters? */
2406   filtering_tap_listeners = have_filtering_tap_listeners();
2407
2408   /* Get the union of the flags for all tap listeners. */
2409   tap_flags = union_of_tap_listener_flags();
2410
2411   if (do_dissection) {
2412     while (to_read-- && cf->wth) {
2413       wtap_cleareof(cf->wth);
2414       ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
2415       if (ret == FALSE) {
2416         /* read from file failed, tell the capture child to stop */
2417         sync_pipe_stop(capture_opts);
2418         wtap_close(cf->wth);
2419         cf->wth = NULL;
2420       } else {
2421         ret = process_packet(cf, data_offset, wtap_phdr(cf->wth),
2422                              wtap_buf_ptr(cf->wth),
2423                              filtering_tap_listeners, tap_flags);
2424       }
2425       if (ret != FALSE) {
2426         /* packet successfully read and gone through the "Read Filter" */
2427         packet_count++;
2428       }
2429     }
2430   } else {
2431     /*
2432      * Dumpcap's doing all the work; we're not doing any dissection.
2433      * Count all the packets it wrote.
2434      */
2435     packet_count += to_read;
2436   }
2437
2438   if (print_packet_counts) {
2439       /* We're printing packet counts. */
2440       if (packet_count != 0) {
2441         fprintf(stderr, "\r%u ", packet_count);
2442         /* stderr could be line buffered */
2443         fflush(stderr);
2444       }
2445   }
2446
2447 #ifdef SIGINFO
2448   /*
2449    * Allow SIGINFO handlers to write.
2450    */
2451   infodelay = FALSE;
2452
2453   /*
2454    * If a SIGINFO handler asked us to write out capture counts, do so.
2455    */
2456   if (infoprint)
2457     report_counts();
2458 #endif /* SIGINFO */
2459 }
2460
2461 static void
2462 report_counts(void)
2463 {
2464   if (!print_packet_counts) {
2465     /* Report the count only if we aren't printing a packet count
2466        as packets arrive. */
2467     fprintf(stderr, "%u packet%s captured\n", packet_count,
2468             plurality(packet_count, "", "s"));
2469   }
2470 #ifdef SIGINFO
2471   infoprint = FALSE; /* we just reported it */
2472 #endif /* SIGINFO */
2473 }
2474
2475 #ifdef SIGINFO
2476 static void
2477 report_counts_siginfo(int signum _U_)
2478 {
2479   int sav_errno = errno;
2480   /* If we've been told to delay printing, just set a flag asking
2481      that we print counts (if we're supposed to), otherwise print
2482      the count of packets captured (if we're supposed to). */
2483   if (infodelay)
2484     infoprint = TRUE;
2485   else
2486     report_counts();
2487   errno = sav_errno;
2488 }
2489 #endif /* SIGINFO */
2490
2491
2492 /* capture child detected any packet drops? */
2493 void
2494 capture_input_drops(capture_options *capture_opts _U_, guint32 dropped)
2495 {
2496   if (print_packet_counts) {
2497     /* We're printing packet counts to stderr.
2498        Send a newline so that we move to the line after the packet count. */
2499     fprintf(stderr, "\n");
2500   }
2501
2502   if (dropped != 0) {
2503     /* We're printing packet counts to stderr.
2504        Send a newline so that we move to the line after the packet count. */
2505     fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2506   }
2507 }
2508
2509
2510 /*
2511  * Capture child closed its side of the pipe, report any error and
2512  * do the required cleanup.
2513  */
2514 void
2515 capture_input_closed(capture_options *capture_opts, gchar *msg)
2516 {
2517   capture_file *cf = (capture_file *) capture_opts->cf;
2518
2519   if (msg != NULL)
2520     fprintf(stderr, "tshark: %s\n", msg);
2521
2522   report_counts();
2523
2524   if (cf != NULL && cf->wth != NULL) {
2525     wtap_close(cf->wth);
2526     if (cf->is_tempfile) {
2527       ws_unlink(cf->filename);
2528     }
2529   }
2530 #ifdef USE_BROKEN_G_MAIN_LOOP
2531   /*g_main_loop_quit(loop);*/
2532   g_main_quit(loop);
2533 #else
2534   loop_running = FALSE;
2535 #endif
2536 }
2537
2538
2539
2540
2541 #ifdef _WIN32
2542 static BOOL WINAPI
2543 capture_cleanup(DWORD ctrltype _U_)
2544 {
2545   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2546      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2547      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2548      like SIGTERM at least when the machine's shutting down.
2549
2550      For now, we handle them all as indications that we should clean up
2551      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2552      way on UNIX.
2553
2554      We must return TRUE so that no other handler - such as one that would
2555      terminate the process - gets called.
2556
2557      XXX - for some reason, typing ^C to TShark, if you run this in
2558      a Cygwin console window in at least some versions of Cygwin,
2559      causes TShark to terminate immediately; this routine gets
2560      called, but the main loop doesn't get a chance to run and
2561      exit cleanly, at least if this is compiled with Microsoft Visual
2562      C++ (i.e., it's a property of the Cygwin console window or Bash;
2563      it happens if TShark is not built with Cygwin - for all I know,
2564      building it with Cygwin may make the problem go away). */
2565
2566   /* tell the capture child to stop */
2567   sync_pipe_stop(&global_capture_opts);
2568
2569   /* don't stop our own loop already here, otherwise status messages and
2570    * cleanup wouldn't be done properly. The child will indicate the stop of
2571    * everything by calling capture_input_closed() later */
2572
2573   return TRUE;
2574 }
2575 #else
2576 static void
2577 capture_cleanup(int signum _U_)
2578 {
2579   /* tell the capture child to stop */
2580   sync_pipe_stop(&global_capture_opts);
2581
2582   /* don't stop our own loop already here, otherwise status messages and
2583    * cleanup wouldn't be done properly. The child will indicate the stop of
2584    * everything by calling capture_input_closed() later */
2585 }
2586 #endif /* _WIN32 */
2587 #endif /* HAVE_LIBPCAP */
2588
2589 static gboolean
2590 process_packet_first_pass(capture_file *cf,
2591                gint64 offset, struct wtap_pkthdr *whdr,
2592                const guchar *pd)
2593 {
2594   frame_data     fdlocal;
2595   guint32        framenum;
2596   gboolean       create_proto_tree = FALSE;
2597   epan_dissect_t edt;
2598   gboolean       passed;
2599
2600   /* The frame number of this packet is one more than the count of
2601      frames in this packet. */
2602   framenum = cf->count + 1;
2603
2604   /* If we're not running a display filter and we're not printing any
2605      packet information, we don't need to do a dissection. This means
2606      that all packets can be marked as 'passed'. */
2607   passed = TRUE;
2608
2609   frame_data_init(&fdlocal, framenum, whdr, offset, cum_bytes);
2610
2611   /* If we're going to print packet information, or we're going to
2612      run a read filter, or we're going to process taps, set up to
2613      do a dissection and do so. */
2614   if (do_dissection) {
2615     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2616         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2617       /* Grab any resolved addresses */
2618       host_name_lookup_process();
2619
2620     /* If we're going to be applying a read filter, we'll need to
2621        create a protocol tree against which to apply the filter. */
2622     if (cf->rfcode)
2623       create_proto_tree = TRUE;
2624
2625     /* We're not going to display the protocol tree on this pass,
2626        so it's not going to be "visible". */
2627     epan_dissect_init(&edt, create_proto_tree, FALSE);
2628
2629     /* If we're running a read filter, prime the epan_dissect_t with that
2630        filter. */
2631     if (cf->rfcode)
2632       epan_dissect_prime_dfilter(&edt, cf->rfcode);
2633
2634     frame_data_set_before_dissect(&fdlocal, &cf->elapsed_time,
2635                                   &first_ts, prev_dis, prev_cap);
2636
2637     epan_dissect_run(&edt, whdr, pd, &fdlocal, NULL);
2638
2639     /* Run the read filter if we have one. */
2640     if (cf->rfcode)
2641       passed = dfilter_apply_edt(cf->rfcode, &edt);
2642   }
2643
2644   if (passed) {
2645     frame_data_set_after_dissect(&fdlocal, &cum_bytes);
2646     prev_dis_frame = fdlocal;
2647     prev_dis = &prev_dis_frame;
2648     frame_data_sequence_add(cf->frames, &fdlocal);
2649     cf->count++;
2650   }
2651
2652   prev_cap_frame = fdlocal;
2653   prev_cap = &prev_cap_frame;
2654
2655   if (do_dissection)
2656     epan_dissect_cleanup(&edt);
2657
2658   return passed;
2659 }
2660
2661 static gboolean
2662 process_packet_second_pass(capture_file *cf, frame_data *fdata,
2663                struct wtap_pkthdr *phdr, const guchar *pd,
2664                gboolean filtering_tap_listeners, guint tap_flags)
2665 {
2666   gboolean        create_proto_tree;
2667   column_info    *cinfo;
2668   epan_dissect_t  edt;
2669   gboolean        passed;
2670
2671   /* If we're not running a display filter and we're not printing any
2672      packet information, we don't need to do a dissection. This means
2673      that all packets can be marked as 'passed'. */
2674   passed = TRUE;
2675
2676   /* If we're going to print packet information, or we're going to
2677      run a read filter, or we're going to process taps, set up to
2678      do a dissection and do so. */
2679   if (do_dissection) {
2680     if (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
2681         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns)
2682       /* Grab any resolved addresses */
2683       host_name_lookup_process();
2684
2685     if (cf->rfcode || print_details || filtering_tap_listeners ||
2686         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
2687       create_proto_tree = TRUE;
2688     else
2689       create_proto_tree = FALSE;
2690
2691     /* The protocol tree will be "visible", i.e., printed, only if we're
2692        printing packet details, which is true if we're printing stuff
2693        ("print_packet_info" is true) and we're in verbose mode
2694        ("packet_details" is true). */
2695     epan_dissect_init(&edt, create_proto_tree, print_packet_info && print_details);
2696
2697     /* If we're running a read filter, prime the epan_dissect_t with that
2698        filter. */
2699     if (cf->rfcode)
2700       epan_dissect_prime_dfilter(&edt, cf->rfcode);
2701
2702     col_custom_prime_edt(&edt, &cf->cinfo);
2703
2704     /* We only need the columns if either
2705          1) some tap needs the columns
2706        or
2707          2) we're printing packet info but we're *not* verbose; in verbose
2708             mode, we print the protocol tree, not the protocol summary.
2709      */
2710     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary))
2711       cinfo = &cf->cinfo;
2712     else
2713       cinfo = NULL;
2714
2715     epan_dissect_run_with_taps(&edt, phdr, pd, fdata, cinfo);
2716
2717     /* Run the read filter if we have one. */
2718     if (cf->rfcode)
2719       passed = dfilter_apply_edt(cf->rfcode, &edt);
2720   }
2721
2722   if (passed) {
2723     /* Process this packet. */
2724     if (print_packet_info) {
2725       /* We're printing packet information; print the information for
2726          this packet. */
2727       if (do_dissection)
2728         print_packet(cf, &edt);
2729       else
2730         print_packet(cf, NULL);
2731
2732       /* The ANSI C standard does not appear to *require* that a line-buffered
2733          stream be flushed to the host environment whenever a newline is
2734          written, it just says that, on such a stream, characters "are
2735          intended to be transmitted to or from the host environment as a
2736          block when a new-line character is encountered".
2737
2738          The Visual C++ 6.0 C implementation doesn't do what is intended;
2739          even if you set a stream to be line-buffered, it still doesn't
2740          flush the buffer at the end of every line.
2741
2742          So, if the "-l" flag was specified, we flush the standard output
2743          at the end of a packet.  This will do the right thing if we're
2744          printing packet summary lines, and, as we print the entire protocol
2745          tree for a single packet without waiting for anything to happen,
2746          it should be as good as line-buffered mode if we're printing
2747          protocol trees.  (The whole reason for the "-l" flag in either
2748          tcpdump or TShark is to allow the output of a live capture to
2749          be piped to a program or script and to have that script see the
2750          information for the packet as soon as it's printed, rather than
2751          having to wait until a standard I/O buffer fills up. */
2752       if (line_buffered)
2753         fflush(stdout);
2754
2755       if (ferror(stdout)) {
2756         show_print_file_io_error(errno);
2757         exit(2);
2758       }
2759     }
2760   }
2761
2762   if (do_dissection) {
2763     epan_dissect_cleanup(&edt);
2764   }
2765   return passed;
2766 }
2767
2768 static int
2769 load_cap_file(capture_file *cf, char *save_file, int out_file_type,
2770     gboolean out_file_name_res, int max_packet_count, gint64 max_byte_count)
2771 {
2772   gint         linktype;
2773   int          snapshot_length;
2774   wtap_dumper *pdh;
2775   guint32      framenum;
2776   int          err;
2777   gchar       *err_info = NULL;
2778   gint64       data_offset;
2779   char        *save_file_string = NULL;
2780   gboolean     filtering_tap_listeners;
2781   guint        tap_flags;
2782   wtapng_section_t            *shb_hdr;
2783   wtapng_iface_descriptions_t *idb_inf;
2784   char         appname[100];
2785
2786   shb_hdr = wtap_file_get_shb_info(cf->wth);
2787   idb_inf = wtap_file_get_idb_info(cf->wth);
2788 #ifdef PCAP_NG_DEFAULT
2789   if (idb_inf->number_of_interfaces > 0) {
2790     linktype = WTAP_ENCAP_PER_PACKET;
2791   } else {
2792     linktype = wtap_file_encap(cf->wth);
2793   }
2794 #else
2795   linktype = wtap_file_encap(cf->wth);
2796 #endif
2797   if (save_file != NULL) {
2798     /* Get a string that describes what we're writing to */
2799     save_file_string = output_file_description(save_file);
2800
2801     /* Set up to write to the capture file. */
2802     snapshot_length = wtap_snapshot_length(cf->wth);
2803     if (snapshot_length == 0) {
2804       /* Snapshot length of input file not known. */
2805       snapshot_length = WTAP_MAX_PACKET_SIZE;
2806     }
2807     /* If we don't have an application name add Tshark */
2808     if (shb_hdr->shb_user_appl == NULL) {
2809         g_snprintf(appname, sizeof(appname), "TShark " VERSION "%s", wireshark_svnversion);
2810         shb_hdr->shb_user_appl = appname;
2811     }
2812
2813     pdh = wtap_dump_open_ng(save_file, out_file_type, linktype, snapshot_length,
2814         FALSE /* compressed */, shb_hdr, idb_inf, &err);
2815
2816     g_free(idb_inf);
2817     idb_inf = NULL;
2818
2819     if (pdh == NULL) {
2820       /* We couldn't set up to write to the capture file. */
2821       switch (err) {
2822
2823       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
2824         cmdarg_err("Capture files can't be written in that format.");
2825         break;
2826
2827       case WTAP_ERR_UNSUPPORTED_ENCAP:
2828       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
2829         cmdarg_err("The capture file being read can't be written as a "
2830           "\"%s\" file.", wtap_file_type_short_string(out_file_type));
2831         break;
2832
2833       case WTAP_ERR_CANT_OPEN:
2834         cmdarg_err("The %s couldn't be created for some "
2835           "unknown reason.", save_file_string);
2836         break;
2837
2838       case WTAP_ERR_SHORT_WRITE:
2839         cmdarg_err("A full header couldn't be written to the %s.",
2840                    save_file_string);
2841         break;
2842
2843       default:
2844         cmdarg_err("The %s could not be created: %s.", save_file_string,
2845                    wtap_strerror(err));
2846         break;
2847       }
2848       goto out;
2849     }
2850   } else {
2851     if (print_packet_info) {
2852       if (!write_preamble(cf)) {
2853         err = errno;
2854         show_print_file_io_error(err);
2855         goto out;
2856       }
2857     }
2858     pdh = NULL;
2859   }
2860
2861   if (pdh && out_file_name_res) {
2862     if (!wtap_dump_set_addrinfo_list(pdh, get_addrinfo_list())) {
2863       cmdarg_err("The file format \"%s\" doesn't support name resolution information.",
2864                  wtap_file_type_short_string(out_file_type));
2865     }
2866   }
2867
2868   /* Do we have any tap listeners with filters? */
2869   filtering_tap_listeners = have_filtering_tap_listeners();
2870
2871   /* Get the union of the flags for all tap listeners. */
2872   tap_flags = union_of_tap_listener_flags();
2873
2874   if (perform_two_pass_analysis) {
2875     frame_data *fdata;
2876     int old_max_packet_count = max_packet_count;
2877
2878     /* Allocate a frame_data_sequence for all the frames. */
2879     cf->frames = new_frame_data_sequence();
2880
2881     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
2882       if (process_packet_first_pass(cf, data_offset, wtap_phdr(cf->wth),
2883                          wtap_buf_ptr(cf->wth))) {
2884         /* Stop reading if we have the maximum number of packets;
2885          * When the -c option has not been used, max_packet_count
2886          * starts at 0, which practically means, never stop reading.
2887          * (unless we roll over max_packet_count ?)
2888          */
2889         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
2890           err = 0; /* This is not an error */
2891           break;
2892         }
2893       }
2894     }
2895
2896     /* Close the sequential I/O side, to free up memory it requires. */
2897     wtap_sequential_close(cf->wth);
2898
2899     /* Allow the protocol dissectors to free up memory that they
2900      * don't need after the sequential run-through of the packets. */
2901     postseq_cleanup_all_protocols();
2902
2903     max_packet_count = old_max_packet_count;
2904
2905     for (framenum = 1; err == 0 && framenum <= cf->count; framenum++) {
2906       fdata = frame_data_sequence_find(cf->frames, framenum);
2907       if (wtap_seek_read(cf->wth, fdata->file_off, &cf->phdr,
2908           cf->pd, fdata->cap_len, &err, &err_info)) {
2909         if (process_packet_second_pass(cf, fdata,
2910                            &cf->phdr, cf->pd,
2911                            filtering_tap_listeners, tap_flags)) {
2912           /* Either there's no read filtering or this packet passed the
2913              filter, so, if we're writing to a capture file, write
2914              this packet out. */
2915           if (pdh != NULL) {
2916             if (!wtap_dump(pdh, &cf->phdr, wtap_buf_ptr(cf->wth), &err)) {
2917               /* Error writing to a capture file */
2918               switch (err) {
2919
2920               case WTAP_ERR_UNSUPPORTED_ENCAP:
2921                 /*
2922                  * This is a problem with the particular frame we're writing;
2923                  * note that, and give the frame number.
2924                  *
2925                  * XXX - framenum is not necessarily the frame number in
2926                  * the input file if there was a read filter.
2927                  */
2928                 fprintf(stderr,
2929                         "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
2930                         framenum, cf->filename,
2931                         wtap_file_type_short_string(out_file_type));
2932                 break;
2933
2934               default:
2935                 show_capture_file_io_error(save_file, err, FALSE);
2936                 break;
2937               }
2938               wtap_dump_close(pdh, &err);
2939               g_free(shb_hdr);
2940               exit(2);
2941             }
2942           }
2943           /* Stop reading if we have the maximum number of packets;
2944            * When the -c option has not been used, max_packet_count
2945            * starts at 0, which practically means, never stop reading.
2946            * (unless we roll over max_packet_count ?)
2947            */
2948           if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
2949             err = 0; /* This is not an error */
2950             break;
2951           }
2952         }
2953       }
2954     }
2955   }
2956   else {
2957     framenum = 0;
2958     while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
2959       framenum++;
2960
2961       if (process_packet(cf, data_offset, wtap_phdr(cf->wth),
2962                          wtap_buf_ptr(cf->wth),
2963                          filtering_tap_listeners, tap_flags)) {
2964         /* Either there's no read filtering or this packet passed the
2965            filter, so, if we're writing to a capture file, write
2966            this packet out. */
2967         if (pdh != NULL) {
2968           if (!wtap_dump(pdh, wtap_phdr(cf->wth), wtap_buf_ptr(cf->wth), &err)) {
2969             /* Error writing to a capture file */
2970             switch (err) {
2971
2972             case WTAP_ERR_UNSUPPORTED_ENCAP:
2973               /*
2974                * This is a problem with the particular frame we're writing;
2975                * note that, and give the frame number.
2976                */
2977               fprintf(stderr,
2978                       "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
2979                       framenum, cf->filename,
2980                       wtap_file_type_short_string(out_file_type));
2981               break;
2982
2983             default:
2984               show_capture_file_io_error(save_file, err, FALSE);
2985               break;
2986             }
2987             wtap_dump_close(pdh, &err);
2988             g_free(shb_hdr);
2989             exit(2);
2990           }
2991         }
2992         /* Stop reading if we have the maximum number of packets;
2993          * When the -c option has not been used, max_packet_count
2994          * starts at 0, which practically means, never stop reading.
2995          * (unless we roll over max_packet_count ?)
2996          */
2997         if ( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
2998           err = 0; /* This is not an error */
2999           break;
3000         }
3001       }
3002     }
3003   }
3004
3005   if (err != 0) {
3006     /*
3007      * Print a message noting that the read failed somewhere along the line.
3008      *
3009      * If we're printing packet data, and the standard output and error are
3010      * going to the same place, flush the standard output, so everything
3011      * buffered up is written, and then print a newline to the standard error
3012      * before printing the error message, to separate it from the packet
3013      * data.  (Alas, that only works on UN*X; st_dev is meaningless, and
3014      * the _fstat() documentation at Microsoft doesn't indicate whether
3015      * st_ino is even supported.)
3016      */
3017 #ifndef _WIN32
3018     if (print_packet_info) {
3019       struct stat stat_stdout, stat_stderr;
3020
3021       if (fstat(1, &stat_stdout) == 0 && fstat(2, &stat_stderr) == 0) {
3022         if (stat_stdout.st_dev == stat_stderr.st_dev &&
3023             stat_stdout.st_ino == stat_stderr.st_ino) {
3024           fflush(stdout);
3025           fprintf(stderr, "\n");
3026         }
3027       }
3028     }
3029 #endif
3030     switch (err) {
3031
3032     case WTAP_ERR_UNSUPPORTED:
3033       cmdarg_err("The file \"%s\" contains record data that TShark doesn't support.\n(%s)",
3034                  cf->filename, err_info);
3035       g_free(err_info);
3036       break;
3037
3038     case WTAP_ERR_UNSUPPORTED_ENCAP:
3039       cmdarg_err("The file \"%s\" has a packet with a network type that TShark doesn't support.\n(%s)",
3040                  cf->filename, err_info);
3041       g_free(err_info);
3042       break;
3043
3044     case WTAP_ERR_CANT_READ:
3045       cmdarg_err("An attempt to read from the file \"%s\" failed for some unknown reason.",
3046                  cf->filename);
3047       break;
3048
3049     case WTAP_ERR_SHORT_READ:
3050       cmdarg_err("The file \"%s\" appears to have been cut short in the middle of a packet.",
3051                  cf->filename);
3052       break;
3053
3054     case WTAP_ERR_BAD_FILE:
3055       cmdarg_err("The file \"%s\" appears to be damaged or corrupt.\n(%s)",
3056                  cf->filename, err_info);
3057       g_free(err_info);
3058       break;
3059
3060     case WTAP_ERR_DECOMPRESS:
3061       cmdarg_err("The compressed file \"%s\" appears to be damaged or corrupt.\n"
3062                  "(%s)", cf->filename, err_info);
3063       break;
3064
3065     default:
3066       cmdarg_err("An error occurred while reading the file \"%s\": %s.",
3067                  cf->filename, wtap_strerror(err));
3068       break;
3069     }
3070     if (save_file != NULL) {
3071       /* Now close the capture file. */
3072       if (!wtap_dump_close(pdh, &err))
3073         show_capture_file_io_error(save_file, err, TRUE);
3074     }
3075   } else {
3076     if (save_file != NULL) {
3077       /* Now close the capture file. */
3078       if (!wtap_dump_close(pdh, &err))
3079         show_capture_file_io_error(save_file, err, TRUE);
3080     } else {
3081       if (print_packet_info) {
3082         if (!write_finale()) {
3083           err = errno;
3084           show_print_file_io_error(err);
3085         }
3086       }
3087     }
3088   }
3089
3090 out:
3091   wtap_close(cf->wth);
3092   cf->wth = NULL;
3093
3094   g_free(save_file_string);
3095   g_free(shb_hdr);
3096
3097   return err;
3098 }
3099
3100 static gboolean
3101 process_packet(capture_file *cf, gint64 offset, struct wtap_pkthdr *whdr,
3102                const guchar *pd,
3103                gboolean filtering_tap_listeners, guint tap_flags)
3104 {
3105   frame_data      fdata;
3106   gboolean        create_proto_tree;
3107   column_info    *cinfo;
3108   epan_dissect_t  edt;
3109   gboolean        passed;
3110
3111   /* Count this packet. */
3112   cf->count++;
3113
3114   /* If we're not running a display filter and we're not printing any
3115      packet information, we don't need to do a dissection. This means
3116      that all packets can be marked as 'passed'. */
3117   passed = TRUE;
3118
3119   frame_data_init(&fdata, cf->count, whdr, offset, cum_bytes);
3120
3121   /* If we're going to print packet information, or we're going to
3122      run a read filter, or we're going to process taps, set up to
3123      do a dissection and do so. */
3124   if (do_dissection) {
3125     if (print_packet_info && (gbl_resolv_flags.mac_name || gbl_resolv_flags.network_name ||
3126         gbl_resolv_flags.transport_name || gbl_resolv_flags.concurrent_dns))
3127       /* Grab any resolved addresses */
3128       host_name_lookup_process();
3129
3130     if (cf->rfcode || print_details || filtering_tap_listeners ||
3131         (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
3132       create_proto_tree = TRUE;
3133     else
3134       create_proto_tree = FALSE;
3135
3136     /* The protocol tree will be "visible", i.e., printed, only if we're
3137        printing packet details, which is true if we're printing stuff
3138        ("print_packet_info" is true) and we're in verbose mode
3139        ("packet_details" is true). */
3140     epan_dissect_init(&edt, create_proto_tree, print_packet_info && print_details);
3141
3142     /* If we're running a read filter, prime the epan_dissect_t with that
3143        filter. */
3144     if (cf->rfcode)
3145       epan_dissect_prime_dfilter(&edt, cf->rfcode);
3146
3147     col_custom_prime_edt(&edt, &cf->cinfo);
3148
3149     /* We only need the columns if either
3150          1) some tap needs the columns
3151        or
3152          2) we're printing packet info but we're *not* verbose; in verbose
3153             mode, we print the protocol tree, not the protocol summary.
3154        or
3155          3) there is a column mapped as an individual field */
3156     if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && print_summary) || output_fields_has_cols(output_fields))
3157       cinfo = &cf->cinfo;
3158     else
3159       cinfo = NULL;
3160
3161     frame_data_set_before_dissect(&fdata, &cf->elapsed_time,
3162                                   &first_ts, prev_dis, prev_cap);
3163
3164     epan_dissect_run_with_taps(&edt, whdr, pd, &fdata, cinfo);
3165
3166     /* Run the read filter if we have one. */
3167     if (cf->rfcode)
3168       passed = dfilter_apply_edt(cf->rfcode, &edt);
3169   }
3170
3171   if (passed) {
3172     frame_data_set_after_dissect(&fdata, &cum_bytes);
3173     prev_dis_frame = fdata;
3174     prev_dis = &prev_dis_frame;
3175
3176     /* Process this packet. */
3177     if (print_packet_info) {
3178       /* We're printing packet information; print the information for
3179          this packet. */
3180       if (do_dissection)
3181         print_packet(cf, &edt);
3182       else
3183         print_packet(cf, NULL);
3184
3185       /* The ANSI C standard does not appear to *require* that a line-buffered
3186          stream be flushed to the host environment whenever a newline is
3187          written, it just says that, on such a stream, characters "are
3188          intended to be transmitted to or from the host environment as a
3189          block when a new-line character is encountered".
3190
3191          The Visual C++ 6.0 C implementation doesn't do what is intended;
3192          even if you set a stream to be line-buffered, it still doesn't
3193          flush the buffer at the end of every line.
3194
3195          So, if the "-l" flag was specified, we flush the standard output
3196          at the end of a packet.  This will do the right thing if we're
3197          printing packet summary lines, and, as we print the entire protocol
3198          tree for a single packet without waiting for anything to happen,
3199          it should be as good as line-buffered mode if we're printing
3200          protocol trees.  (The whole reason for the "-l" flag in either
3201          tcpdump or TShark is to allow the output of a live capture to
3202          be piped to a program or script and to have that script see the
3203          information for the packet as soon as it's printed, rather than
3204          having to wait until a standard I/O buffer fills up. */
3205       if (line_buffered)
3206         fflush(stdout);
3207
3208       if (ferror(stdout)) {
3209         show_print_file_io_error(errno);
3210         exit(2);
3211       }
3212     }
3213   }
3214
3215   prev_cap_frame = fdata;
3216   prev_cap = &prev_cap_frame;
3217
3218   if (do_dissection) {
3219     epan_dissect_cleanup(&edt);
3220     frame_data_cleanup(&fdata);
3221   }
3222   return passed;
3223 }
3224
3225 static gboolean
3226 write_preamble(capture_file *cf)
3227 {
3228   switch (output_action) {
3229
3230   case WRITE_TEXT:
3231     return print_preamble(print_stream, cf ? cf->filename : NULL);
3232
3233   case WRITE_XML:
3234     if (print_details)
3235       write_pdml_preamble(stdout, cf ? cf->filename : NULL);
3236     else
3237       write_psml_preamble(stdout);
3238     return !ferror(stdout);
3239
3240   case WRITE_FIELDS:
3241     write_fields_preamble(output_fields, stdout);
3242     return !ferror(stdout);
3243
3244   default:
3245     g_assert_not_reached();
3246     return FALSE;
3247   }
3248 }
3249
3250 static char *
3251 get_line_buf(size_t len)
3252 {
3253   static char   *line_bufp    = NULL;
3254   static size_t  line_buf_len = 256;
3255   size_t         new_line_buf_len;
3256
3257   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
3258        new_line_buf_len *= 2)
3259     ;
3260   if (line_bufp == NULL) {
3261     line_buf_len = new_line_buf_len;
3262     line_bufp = g_malloc(line_buf_len + 1);
3263   } else {
3264     if (new_line_buf_len > line_buf_len) {
3265       line_buf_len = new_line_buf_len;
3266       line_bufp = g_realloc(line_bufp, line_buf_len + 1);
3267     }
3268   }
3269   return line_bufp;
3270 }
3271
3272 static gboolean
3273 print_columns(capture_file *cf)
3274 {
3275   char   *line_bufp;
3276   int     i;
3277   size_t  buf_offset;
3278   size_t  column_len;
3279
3280   line_bufp = get_line_buf(256);
3281   buf_offset = 0;
3282   *line_bufp = '\0';
3283   for (i = 0; i < cf->cinfo.num_cols; i++) {
3284     /* Skip columns not marked as visible. */
3285     if (!get_column_visible(i))
3286       continue;
3287     switch (cf->cinfo.col_fmt[i]) {
3288     case COL_NUMBER:
3289 #ifdef HAVE_LIBPCAP
3290       /*
3291        * Don't print this if we're doing a live capture from a network
3292        * interface - if we're doing a live capture, you won't be
3293        * able to look at the capture in the future (it's not being
3294        * saved anywhere), so the frame numbers are unlikely to be
3295        * useful.
3296        *
3297        * (XXX - it might be nice to be able to save and print at
3298        * the same time, sort of like an "Update list of packets
3299        * in real time" capture in Wireshark.)
3300        */
3301       if (global_capture_opts.ifaces->len > 0)
3302         continue;
3303 #endif
3304       column_len = strlen(cf->cinfo.col_data[i]);
3305       if (column_len < 3)
3306         column_len = 3;
3307       line_bufp = get_line_buf(buf_offset + column_len);
3308       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%3s", cf->cinfo.col_data[i]);
3309       break;
3310
3311     case COL_CLS_TIME:
3312     case COL_REL_TIME:
3313     case COL_ABS_TIME:
3314     case COL_ABS_DATE_TIME:
3315     case COL_UTC_TIME:
3316     case COL_UTC_DATE_TIME: /* XXX - wider */
3317       column_len = strlen(cf->cinfo.col_data[i]);
3318       if (column_len < 10)
3319         column_len = 10;
3320       line_bufp = get_line_buf(buf_offset + column_len);
3321       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%10s", cf->cinfo.col_data[i]);
3322       break;
3323
3324     case COL_DEF_SRC:
3325     case COL_RES_SRC:
3326     case COL_UNRES_SRC:
3327     case COL_DEF_DL_SRC:
3328     case COL_RES_DL_SRC:
3329     case COL_UNRES_DL_SRC:
3330     case COL_DEF_NET_SRC:
3331     case COL_RES_NET_SRC:
3332     case COL_UNRES_NET_SRC:
3333       column_len = strlen(cf->cinfo.col_data[i]);
3334       if (column_len < 12)
3335         column_len = 12;
3336       line_bufp = get_line_buf(buf_offset + column_len);
3337       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%12s", cf->cinfo.col_data[i]);
3338       break;
3339
3340     case COL_DEF_DST:
3341     case COL_RES_DST:
3342     case COL_UNRES_DST:
3343     case COL_DEF_DL_DST:
3344     case COL_RES_DL_DST:
3345     case COL_UNRES_DL_DST:
3346     case COL_DEF_NET_DST:
3347     case COL_RES_NET_DST:
3348     case COL_UNRES_NET_DST:
3349       column_len = strlen(cf->cinfo.col_data[i]);
3350       if (column_len < 12)
3351         column_len = 12;
3352       line_bufp = get_line_buf(buf_offset + column_len);
3353       g_snprintf(line_bufp + buf_offset, (int)column_len + 1, "%-12s", cf->cinfo.col_data[i]);
3354       break;
3355
3356     default:
3357       column_len = strlen(cf->cinfo.col_data[i]);
3358       line_bufp = get_line_buf(buf_offset + column_len);
3359       g_strlcat(line_bufp + buf_offset, cf->cinfo.col_data[i], column_len + 1);
3360       break;
3361     }
3362     buf_offset += column_len;
3363     if (i != cf->cinfo.num_cols - 1) {
3364       /*
3365        * This isn't the last column, so we need to print a
3366        * separator between this column and the next.
3367        *
3368        * If we printed a network source and are printing a
3369        * network destination of the same type next, separate
3370        * them with " -> "; if we printed a network destination
3371        * and are printing a network source of the same type
3372        * next, separate them with " <- "; otherwise separate them
3373        * with a space.
3374        *
3375        * We add enough space to the buffer for " <- " or " -> ",
3376        * even if we're only adding " ".
3377        */
3378       line_bufp = get_line_buf(buf_offset + 4);
3379       switch (cf->cinfo.col_fmt[i]) {
3380
3381       case COL_DEF_SRC:
3382       case COL_RES_SRC:
3383       case COL_UNRES_SRC:
3384         switch (cf->cinfo.col_fmt[i + 1]) {
3385
3386         case COL_DEF_DST:
3387         case COL_RES_DST:
3388         case COL_UNRES_DST:
3389           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3390           buf_offset += 4;
3391           break;
3392
3393         default:
3394           g_strlcat(line_bufp + buf_offset, " ", 5);
3395           buf_offset += 1;
3396           break;
3397         }
3398         break;
3399
3400       case COL_DEF_DL_SRC:
3401       case COL_RES_DL_SRC:
3402       case COL_UNRES_DL_SRC:
3403         switch (cf->cinfo.col_fmt[i + 1]) {
3404
3405         case COL_DEF_DL_DST:
3406         case COL_RES_DL_DST:
3407         case COL_UNRES_DL_DST:
3408           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3409           buf_offset += 4;
3410           break;
3411
3412         default:
3413           g_strlcat(line_bufp + buf_offset, " ", 5);
3414           buf_offset += 1;
3415           break;
3416         }
3417         break;
3418
3419       case COL_DEF_NET_SRC:
3420       case COL_RES_NET_SRC:
3421       case COL_UNRES_NET_SRC:
3422         switch (cf->cinfo.col_fmt[i + 1]) {
3423
3424         case COL_DEF_NET_DST:
3425         case COL_RES_NET_DST:
3426         case COL_UNRES_NET_DST:
3427           g_strlcat(line_bufp + buf_offset, " -> ", 5);
3428           buf_offset += 4;
3429           break;
3430
3431         default:
3432           g_strlcat(line_bufp + buf_offset, " ", 5);
3433           buf_offset += 1;
3434           break;
3435         }
3436         break;
3437
3438       case COL_DEF_DST:
3439       case COL_RES_DST:
3440       case COL_UNRES_DST:
3441         switch (cf->cinfo.col_fmt[i + 1]) {
3442
3443         case COL_DEF_SRC:
3444         case COL_RES_SRC:
3445         case COL_UNRES_SRC:
3446           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3447           buf_offset += 4;
3448           break;
3449
3450         default:
3451           g_strlcat(line_bufp + buf_offset, " ", 5);
3452           buf_offset += 1;
3453           break;
3454         }
3455         break;
3456
3457       case COL_DEF_DL_DST:
3458       case COL_RES_DL_DST:
3459       case COL_UNRES_DL_DST:
3460         switch (cf->cinfo.col_fmt[i + 1]) {
3461
3462         case COL_DEF_DL_SRC:
3463         case COL_RES_DL_SRC:
3464         case COL_UNRES_DL_SRC:
3465           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3466           buf_offset += 4;
3467           break;
3468
3469         default:
3470           g_strlcat(line_bufp + buf_offset, " ", 5);
3471           buf_offset += 1;
3472           break;
3473         }
3474         break;
3475
3476       case COL_DEF_NET_DST:
3477       case COL_RES_NET_DST:
3478       case COL_UNRES_NET_DST:
3479         switch (cf->cinfo.col_fmt[i + 1]) {
3480
3481         case COL_DEF_NET_SRC:
3482         case COL_RES_NET_SRC:
3483         case COL_UNRES_NET_SRC:
3484           g_strlcat(line_bufp + buf_offset, " <- ", 5);
3485           buf_offset += 4;
3486           break;
3487
3488         default:
3489           g_strlcat(line_bufp + buf_offset, " ", 5);
3490           buf_offset += 1;
3491           break;
3492         }
3493         break;
3494
3495       default:
3496         g_strlcat(line_bufp + buf_offset, " ", 5);
3497         buf_offset += 1;
3498         break;
3499       }
3500     }
3501   }
3502   return print_line(print_stream, 0, line_bufp);
3503 }
3504
3505 static gboolean
3506 print_packet(capture_file *cf, epan_dissect_t *edt)
3507 {
3508   print_args_t print_args;
3509
3510   if (print_summary || output_fields_has_cols(output_fields)) {
3511     /* Just fill in the columns. */
3512     epan_dissect_fill_in_columns(edt, FALSE, TRUE);
3513
3514     if (print_summary) {
3515       /* Now print them. */
3516       switch (output_action) {
3517
3518       case WRITE_TEXT:
3519         if (!print_columns(cf))
3520           return FALSE;
3521         break;
3522
3523       case WRITE_XML:
3524         proto_tree_write_psml(edt, stdout);
3525         return !ferror(stdout);
3526       case WRITE_FIELDS: /*No non-verbose "fields" format */
3527         g_assert_not_reached();
3528         break;
3529       }
3530     }
3531   }
3532   if (print_details) {
3533     /* Print the information in the protocol tree. */
3534     switch (output_action) {
3535
3536     case WRITE_TEXT:
3537       /* Only initialize the fields that are actually used in proto_tree_print.
3538        * This is particularly important for .range, as that's heap memory which
3539        * we would otherwise have to g_free().
3540       print_args.to_file = TRUE;
3541       print_args.format = print_format;
3542       print_args.print_summary = print_summary;
3543       print_args.print_formfeed = FALSE;
3544       packet_range_init(&print_args.range, &cfile);
3545       */
3546       print_args.print_hex = print_hex;
3547       print_args.print_dissections = print_details ? print_dissections_expanded : print_dissections_none;
3548
3549       if (!proto_tree_print(&print_args, edt, print_stream))
3550         return FALSE;
3551       if (!print_hex) {
3552         if (!print_line(print_stream, 0, separator))
3553           return FALSE;
3554       }
3555       break;
3556
3557     case WRITE_XML:
3558       proto_tree_write_pdml(edt, stdout);
3559       printf("\n");
3560       return !ferror(stdout);
3561     case WRITE_FIELDS:
3562       proto_tree_write_fields(output_fields, edt, &cf->cinfo, stdout);
3563       printf("\n");
3564       return !ferror(stdout);
3565     }
3566   }
3567   if (print_hex) {
3568     if (print_summary || print_details) {
3569       if (!print_line(print_stream, 0, ""))
3570         return FALSE;
3571     }
3572     if (!print_hex_data(print_stream, edt))
3573       return FALSE;
3574     if (!print_line(print_stream, 0, separator))
3575       return FALSE;
3576   }
3577   return TRUE;
3578 }
3579
3580 static gboolean
3581 write_finale(void)
3582 {
3583   switch (output_action) {
3584
3585   case WRITE_TEXT:
3586     return print_finale(print_stream);
3587
3588   case WRITE_XML:
3589     if (print_details)
3590       write_pdml_finale(stdout);
3591     else
3592       write_psml_finale(stdout);
3593     return !ferror(stdout);
3594
3595   case WRITE_FIELDS:
3596     write_fields_finale(output_fields, stdout);
3597     return !ferror(stdout);
3598
3599   default:
3600     g_assert_not_reached();
3601     return FALSE;
3602   }
3603 }
3604
3605 cf_status_t
3606 cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
3607 {
3608   wtap  *wth;
3609   gchar *err_info;
3610   char   err_msg[2048+1];
3611
3612   wth = wtap_open_offline(fname, err, &err_info, perform_two_pass_analysis);
3613   if (wth == NULL)
3614     goto fail;
3615
3616   /* The open succeeded.  Fill in the information for this file. */
3617
3618   /* Cleanup all data structures used for dissection. */
3619   cleanup_dissection();
3620   /* Initialize all data structures used for dissection. */
3621   init_dissection();
3622
3623   cf->wth = wth;
3624   cf->f_datalen = 0; /* not used, but set it anyway */
3625
3626   /* Set the file name because we need it to set the follow stream filter.
3627      XXX - is that still true?  We need it for other reasons, though,
3628      in any case. */
3629   cf->filename = g_strdup(fname);
3630
3631   /* Indicate whether it's a permanent or temporary file. */
3632   cf->is_tempfile = is_tempfile;
3633
3634   /* No user changes yet. */
3635   cf->unsaved_changes = FALSE;
3636
3637   cf->cd_t      = wtap_file_type(cf->wth);
3638   cf->count     = 0;
3639   cf->drops_known = FALSE;
3640   cf->drops     = 0;
3641   cf->snap      = wtap_snapshot_length(cf->wth);
3642   if (cf->snap == 0) {
3643     /* Snapshot length not known. */
3644     cf->has_snap = FALSE;
3645     cf->snap = WTAP_MAX_PACKET_SIZE;
3646   } else
3647     cf->has_snap = TRUE;
3648   nstime_set_zero(&cf->elapsed_time);
3649   nstime_set_unset(&first_ts);
3650   prev_dis = NULL;
3651   prev_cap = NULL;
3652
3653   cf->state = FILE_READ_IN_PROGRESS;
3654
3655   wtap_set_cb_new_ipv4(cf->wth, add_ipv4_name);
3656   wtap_set_cb_new_ipv6(cf->wth, (wtap_new_ipv6_callback_t) add_ipv6_name);
3657
3658   return CF_OK;
3659
3660 fail:
3661   g_snprintf(err_msg, sizeof err_msg,
3662              cf_open_error_message(*err, err_info, FALSE, cf->cd_t), fname);
3663   cmdarg_err("%s", err_msg);
3664   return CF_ERROR;
3665 }
3666
3667 static void
3668 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
3669 {
3670   char *save_file_string;
3671
3672   save_file_string = output_file_description(fname);
3673
3674   switch (err) {
3675
3676   case ENOSPC:
3677     cmdarg_err("Not all the packets could be written to the %s because there is "
3678                "no space left on the file system.",
3679                save_file_string);
3680     break;
3681
3682 #ifdef EDQUOT
3683   case EDQUOT:
3684     cmdarg_err("Not all the packets could be written to the %s because you are "
3685                "too close to, or over your disk quota.",
3686                save_file_string);
3687   break;
3688 #endif
3689
3690   case WTAP_ERR_CANT_CLOSE:
3691     cmdarg_err("The %s couldn't be closed for some unknown reason.",
3692                save_file_string);
3693     break;
3694
3695   case WTAP_ERR_SHORT_WRITE:
3696     cmdarg_err("Not all the packets could be written to the %s.",
3697                save_file_string);
3698     break;
3699
3700   default:
3701     if (is_close) {
3702       cmdarg_err("The %s could not be closed: %s.", save_file_string,
3703                  wtap_strerror(err));
3704     } else {
3705       cmdarg_err("An error occurred while writing to the %s: %s.",
3706                  save_file_string, wtap_strerror(err));
3707     }
3708     break;
3709   }
3710   g_free(save_file_string);
3711 }
3712
3713 static void
3714 show_print_file_io_error(int err)
3715 {
3716   switch (err) {
3717
3718   case ENOSPC:
3719     cmdarg_err("Not all the packets could be printed because there is "
3720 "no space left on the file system.");
3721     break;
3722
3723 #ifdef EDQUOT
3724   case EDQUOT:
3725     cmdarg_err("Not all the packets could be printed because you are "
3726 "too close to, or over your disk quota.");
3727   break;
3728 #endif
3729
3730   default:
3731     cmdarg_err("An error occurred while printing packets: %s.",
3732       g_strerror(err));
3733     break;
3734   }
3735 }
3736
3737 static const char *
3738 cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
3739                       int file_type)
3740 {
3741   const char *errmsg;
3742   static char errmsg_errno[1024+1];
3743
3744   if (err < 0) {
3745     /* Wiretap error. */
3746     switch (err) {
3747
3748     case WTAP_ERR_NOT_REGULAR_FILE:
3749       errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
3750       break;
3751
3752     case WTAP_ERR_RANDOM_OPEN_PIPE:
3753       /* Seen only when opening a capture file for reading. */
3754       errmsg = "The file \"%s\" is a pipe or FIFO; TShark can't read pipe or FIFO files in two-pass mode.";
3755       break;
3756
3757     case WTAP_ERR_FILE_UNKNOWN_FORMAT:
3758       /* Seen only when opening a capture file for reading. */
3759       errmsg = "The file \"%s\" isn't a capture file in a format TShark understands.";
3760       break;
3761
3762     case WTAP_ERR_UNSUPPORTED:
3763       /* Seen only when opening a capture file for reading. */
3764       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3765                "The file \"%%s\" isn't a capture file in a format TShark understands.\n"
3766                "(%s)", err_info);
3767       g_free(err_info);
3768       errmsg = errmsg_errno;
3769       break;
3770
3771     case WTAP_ERR_CANT_WRITE_TO_PIPE:
3772       /* Seen only when opening a capture file for writing. */
3773       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3774                  "The file \"%%s\" is a pipe, and \"%s\" capture files can't be "
3775                  "written to a pipe.", wtap_file_type_short_string(file_type));
3776       errmsg = errmsg_errno;
3777       break;
3778
3779     case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
3780       /* Seen only when opening a capture file for writing. */
3781       errmsg = "TShark doesn't support writing capture files in that format.";
3782       break;
3783
3784     case WTAP_ERR_UNSUPPORTED_ENCAP:
3785       if (for_writing) {
3786         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3787                    "TShark can't save this capture as a \"%s\" file.",
3788                    wtap_file_type_short_string(file_type));
3789       } else {
3790         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3791                  "The file \"%%s\" is a capture for a network type that TShark doesn't support.\n"
3792                  "(%s)", err_info);
3793         g_free(err_info);
3794       }
3795       errmsg = errmsg_errno;
3796       break;
3797
3798     case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
3799       if (for_writing) {
3800         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3801                    "TShark can't save this capture as a \"%s\" file.",
3802                    wtap_file_type_short_string(file_type));
3803         errmsg = errmsg_errno;
3804       } else
3805         errmsg = "The file \"%s\" is a capture for a network type that TShark doesn't support.";
3806       break;
3807
3808     case WTAP_ERR_BAD_FILE:
3809       /* Seen only when opening a capture file for reading. */
3810       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3811                "The file \"%%s\" appears to be damaged or corrupt.\n"
3812                "(%s)", err_info);
3813       g_free(err_info);
3814       errmsg = errmsg_errno;
3815       break;
3816
3817     case WTAP_ERR_CANT_OPEN:
3818       if (for_writing)
3819         errmsg = "The file \"%s\" could not be created for some unknown reason.";
3820       else
3821         errmsg = "The file \"%s\" could not be opened for some unknown reason.";
3822       break;
3823
3824     case WTAP_ERR_SHORT_READ:
3825       errmsg = "The file \"%s\" appears to have been cut short"
3826                " in the middle of a packet or other data.";
3827       break;
3828
3829     case WTAP_ERR_SHORT_WRITE:
3830       errmsg = "A full header couldn't be written to the file \"%s\".";
3831       break;
3832
3833     case WTAP_ERR_COMPRESSION_NOT_SUPPORTED:
3834       errmsg = "This file type cannot be written as a compressed file.";
3835       break;
3836
3837     case WTAP_ERR_DECOMPRESS:
3838       /* Seen only when opening a capture file for reading. */
3839       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3840                  "The compressed file \"%%s\" appears to be damaged or corrupt.\n"
3841                  "(%s)", err_info);
3842       g_free(err_info);
3843       errmsg = errmsg_errno;
3844       break;
3845
3846     default:
3847       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3848                  "The file \"%%s\" could not be %s: %s.",
3849                  for_writing ? "created" : "opened",
3850                  wtap_strerror(err));
3851       errmsg = errmsg_errno;
3852       break;
3853     }
3854   } else
3855     errmsg = file_open_error_message(err, for_writing);
3856   return errmsg;
3857 }
3858
3859 /*
3860  * Open/create errors are reported with an console message in TShark.
3861  */
3862 static void
3863 open_failure_message(const char *filename, int err, gboolean for_writing)
3864 {
3865   fprintf(stderr, "tshark: ");
3866   fprintf(stderr, file_open_error_message(err, for_writing), filename);
3867   fprintf(stderr, "\n");
3868 }
3869
3870
3871 /*
3872  * General errors are reported with an console message in TShark.
3873  */
3874 static void
3875 failure_message(const char *msg_format, va_list ap)
3876 {
3877   fprintf(stderr, "tshark: ");
3878   vfprintf(stderr, msg_format, ap);
3879   fprintf(stderr, "\n");
3880 }
3881
3882 /*
3883  * Read errors are reported with an console message in TShark.
3884  */
3885 static void
3886 read_failure_message(const char *filename, int err)
3887 {
3888   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
3889           filename, g_strerror(err));
3890 }
3891
3892 /*
3893  * Write errors are reported with an console message in TShark.
3894  */
3895 static void
3896 write_failure_message(const char *filename, int err)
3897 {
3898   cmdarg_err("An error occurred while writing to the file \"%s\": %s.",
3899           filename, g_strerror(err));
3900 }
3901
3902 /*
3903  * Print to the standard error.  This is a command-line tool, so there's
3904  * no need to pop up a console.
3905  */
3906 void
3907 vfprintf_stderr(const char *fmt, va_list ap)
3908 {
3909   vfprintf(stderr, fmt, ap);
3910 }
3911
3912 void
3913 fprintf_stderr(const char *fmt, ...)
3914 {
3915   va_list ap;
3916
3917   va_start(ap, fmt);
3918   vfprintf_stderr(fmt, ap);
3919   va_end(ap);
3920 }
3921
3922 /*
3923  * Report an error in command-line arguments.
3924  */
3925 void
3926 cmdarg_err(const char *fmt, ...)
3927 {
3928   va_list ap;
3929
3930   va_start(ap, fmt);
3931   failure_message(fmt, ap);
3932   va_end(ap);
3933 }
3934
3935 /*
3936  * Report additional information for an error in command-line arguments.
3937  */
3938 void
3939 cmdarg_err_cont(const char *fmt, ...)
3940 {
3941   va_list ap;
3942
3943   va_start(ap, fmt);
3944   vfprintf(stderr, fmt, ap);
3945   fprintf(stderr, "\n");
3946   va_end(ap);
3947 }
3948
3949
3950 /*
3951  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
3952  *
3953  * Local variables:
3954  * c-basic-offset: 2
3955  * tab-width: 8
3956  * indent-tabs-mode: nil
3957  * End:
3958  *
3959  * vi: set shiftwidth=2 tabstop=8 expandtab:
3960  * :indentSize=2:tabSize=8:noTabs=true:
3961  */