tshark.c

   1 /* tshark.c
   2  *
   3  * $Id$
   4  *
   5  * Wireshark - Network traffic analyzer
   6  * By Gerald Combs <gerald@wireshark.org>
   7  * Copyright 1998 Gerald Combs
   8  *
   9  * Text-mode variant, by Gilbert Ramirez <gram@alumni.rice.edu>
  10  * and Guy Harris <guy@alum.mit.edu>.
  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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <stdlib.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <ctype.h>
  35 #include <locale.h>
  36 #include <limits.h>
  37
  38 #ifdef HAVE_UNISTD_H
  39 #include <unistd.h>
  40 #endif
  41
  42 #include <errno.h>
  43
  44 #ifdef HAVE_FCNTL_H
  45 #include <fcntl.h>
  46 #endif
  47
  48 #include <signal.h>
  49
  50 #ifdef HAVE_SYS_STAT_H
  51 # include <sys/stat.h>
  52 #endif
  53
  54 #ifdef NEED_STRERROR_H
  55 #include "strerror.h"
  56 #endif
  57
  58 #ifdef NEED_GETOPT_H
  59 #include "getopt.h"
  60 #endif
  61
  62 #include <glib.h>
  63 #include <epan/epan.h>
  64 #include <epan/filesystem.h>
  65 #include <epan/privileges.h>
  66 #include <wiretap/file_util.h>
  67
  68 #include "globals.h"
  69 #include <epan/timestamp.h>
  70 #include <epan/packet.h>
  71 #include "file.h"
  72 #include "disabled_protos.h"
  73 #include <epan/prefs.h>
  74 #include <epan/column.h>
  75 #include "print.h"
  76 #include <epan/addr_resolv.h>
  77 #include "util.h"
  78 #include "clopts_common.h"
  79 #include "cmdarg_err.h"
  80 #include "version_info.h"
  81 #include <epan/conversation.h>
  82 #include <epan/plugins.h>
  83 #include "register.h"
  84 #include <epan/epan_dissect.h>
  85 #include <epan/tap.h>
  86 #include <epan/stat_cmd_args.h>
  87 #include <epan/timestamp.h>
  88 #include <epan/ex-opt.h>
  89
  90 #ifdef HAVE_LIBPCAP
  91 #include "capture_ui_utils.h"
  92 #include <pcap.h>
  93 #include "capture-pcap-util.h"
  94 #ifdef _WIN32
  95 #include "capture-wpcap.h"
  96 #include "capture_errs.h"
  97 #endif /* _WIN32 */
  98 #include "capture_sync.h"
  99 #endif /* HAVE_LIBPCAP */
 100 #include "epan/emem.h"
 101 #include "log.h"
 102 #include <epan/funnel.h>
 103
 104
 105 /*
 106  * This is the template for the decode as option; it is shared between the
 107  * various functions that output the usage for this parameter.
 108  */
 109 static const gchar decode_as_arg_template[] = "<layer_type>==<selector>,<decode_as_protocol>";
 110
 111 static nstime_t first_ts;
 112 static nstime_t prev_dis_ts;
 113 static nstime_t prev_cap_ts;
 114 static GString *comp_info_str, *runtime_info_str;
 115
 116 static gboolean print_packet_info;      /* TRUE if we're to print packet information */
 117 /*
 118  * The way the packet decode is to be written.
 119  */
 120 typedef enum {
 121         WRITE_TEXT,     /* summary or detail text */
 122         WRITE_XML,      /* PDML or PSML */
 123         WRITE_FIELDS    /* User defined list of fields */
 124         /* Add CSV and the like here */
 125 } output_action_e;
 126 static output_action_e output_action;
 127 static gboolean do_dissection;  /* TRUE if we have to dissect each packet */
 128 static gboolean verbose;
 129 static gboolean print_hex;
 130 static gboolean line_buffered;
 131 static guint32 cum_bytes = 0;
 132 static print_format_e print_format = PR_FMT_TEXT;
 133 static print_stream_t *print_stream;
 134
 135 static output_fields_t* output_fields  = NULL;
 136
 137 /*
 138  * Standard secondary message for unexpected errors.
 139  */
 140 static const char please_report[] =
 141     "Please report this to the Wireshark developers";
 142
 143 #ifdef HAVE_LIBPCAP
 144 /*
 145  * TRUE if we're to print packet counts to keep track of captured packets.
 146  */
 147 static gboolean print_packet_counts;
 148
 149
 150 static capture_options capture_opts;
 151
 152 #ifdef SIGINFO
 153 static gboolean infodelay;      /* if TRUE, don't print capture info in SIGINFO handler */
 154 static gboolean infoprint;      /* if TRUE, print capture info after clearing infodelay */
 155 #endif /* SIGINFO */
 156
 157 static int capture(void);
 158 static void report_counts(void);
 159 #ifdef _WIN32
 160 static BOOL WINAPI capture_cleanup(DWORD);
 161 #else /* _WIN32 */
 162 static void capture_cleanup(int);
 163 #ifdef SIGINFO
 164 static void report_counts_siginfo(int);
 165 #endif /* SIGINFO */
 166 #endif /* _WIN32 */
 167 #endif /* HAVE_LIBPCAP */
 168
 169 static int load_cap_file(capture_file *, char *, int, int, gint64);
 170 static gboolean process_packet(capture_file *cf, gint64 offset,
 171     const struct wtap_pkthdr *whdr, union wtap_pseudo_header *pseudo_header,
 172     const guchar *pd);
 173 static void show_capture_file_io_error(const char *, int, gboolean);
 174 static void show_print_file_io_error(int err);
 175 static gboolean write_preamble(capture_file *cf);
 176 static gboolean print_packet(capture_file *cf, epan_dissect_t *edt);
 177 static gboolean write_finale(void);
 178 static const char *cf_open_error_message(int err, gchar *err_info,
 179     gboolean for_writing, int file_type);
 180
 181 static void open_failure_message(const char *filename, int err,
 182     gboolean for_writing);
 183 static void failure_message(const char *msg_format, va_list ap);
 184 static void read_failure_message(const char *filename, int err);
 185
 186 capture_file cfile;
 187
 188 /*
 189  * Mark a particular frame.
 190  * Copied from file.c
 191  */
 192 void
 193 cf_mark_frame(capture_file *cf, frame_data *frame)
 194 {
 195   if (! frame->flags.marked) {
 196     frame->flags.marked = TRUE;
 197     if (cf->count > cf->marked_count)
 198       cf->marked_count++;
 199   }
 200 }
 201
 202 /*
 203  * Unmark a particular frame.
 204  * Copied from file.c
 205  */
 206 void
 207 cf_unmark_frame(capture_file *cf, frame_data *frame)
 208 {
 209   if (frame->flags.marked) {
 210     frame->flags.marked = FALSE;
 211     if (cf->marked_count > 0)
 212       cf->marked_count--;
 213   }
 214 }
 215
 216
 217 static void list_capture_types(void) {
 218     int i;
 219
 220     fprintf(stderr, "editcap: The available capture file types for \"F\":\n");
 221     for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
 222       if (wtap_dump_can_open(i))
 223         fprintf(stderr, "    %s - %s\n",
 224           wtap_file_type_short_string(i), wtap_file_type_string(i));
 225     }
 226 }
 227
 228 static void
 229 print_usage(gboolean print_ver)
 230 {
 231   FILE *output;
 232
 233   if (print_ver) {
 234     output = stdout;
 235     fprintf(output,
 236         "TShark " VERSION "%s\n"
 237         "Dump and analyze network traffic.\n"
 238         "See http://www.wireshark.org for more information.\n"
 239         "\n"
 240         "%s",
 241         wireshark_svnversion, get_copyright_info());
 242   } else {
 243     output = stderr;
 244   }
 245   fprintf(output, "\n");
 246   fprintf(output, "Usage: tshark [options] ...\n");
 247   fprintf(output, "\n");
 248
 249 #ifdef HAVE_LIBPCAP
 250   fprintf(output, "Capture interface:\n");
 251   fprintf(output, "  -i <interface>           name or idx of interface (def: first non-loopback)\n");
 252   fprintf(output, "  -f <capture filter>      packet filter in libpcap filter syntax\n");
 253   fprintf(output, "  -s <snaplen>             packet snapshot length (def: 65535)\n");
 254   fprintf(output, "  -p                       don't capture in promiscuous mode\n");
 255 #ifdef _WIN32
 256   fprintf(output, "  -B <buffer size>         size of kernel buffer (def: 1MB)\n");
 257 #endif
 258   fprintf(output, "  -y <link type>           link layer type (def: first appropriate)\n");
 259   fprintf(output, "  -D                       print list of interfaces and exit\n");
 260   fprintf(output, "  -L                       print list of link-layer types of iface and exit\n");
 261   fprintf(output, "\n");
 262   fprintf(output, "Capture stop conditions:\n");
 263   fprintf(output, "  -c <packet count>        stop after n packets (def: infinite)\n");
 264   fprintf(output, "  -a <autostop cond.> ...  duration:NUM - stop after NUM seconds\n");
 265   fprintf(output, "                           filesize:NUM - stop this file after NUM KB\n");
 266   fprintf(output, "                              files:NUM - stop after NUM files\n");
 267   /*fprintf(output, "\n");*/
 268   fprintf(output, "Capture output:\n");
 269   fprintf(output, "  -b <ringbuffer opt.> ... duration:NUM - switch to next file after NUM secs\n");
 270   fprintf(output, "                           filesize:NUM - switch to next file after NUM KB\n");
 271   fprintf(output, "                              files:NUM - ringbuffer: replace after NUM files\n");
 272 #endif  /* HAVE_LIBPCAP */
 273
 274   /*fprintf(output, "\n");*/
 275   fprintf(output, "Input file:\n");
 276   fprintf(output, "  -r <infile>              set the filename to read from (no pipes or stdin!)\n");
 277
 278   fprintf(output, "\n");
 279   fprintf(output, "Processing:\n");
 280   fprintf(output, "  -R <read filter>         packet filter in Wireshark display filter syntax\n");
 281   fprintf(output, "  -n                       disable all name resolutions (def: all enabled)\n");
 282   fprintf(output, "  -N <name resolve flags>  enable specific name resolution(s): \"mntC\"\n");
 283   fprintf(output, "  -d %s ...\n", decode_as_arg_template);
 284   fprintf(output, "                           \"Decode As\", see the man page for details\n");
 285   fprintf(output, "                           Example: tcp.port==8888,http\n");
 286
 287   /*fprintf(output, "\n");*/
 288   fprintf(output, "Output:\n");
 289   fprintf(output, "  -w <outfile|->           set the output filename (or '-' for stdout)\n");
 290   fprintf(output, "  -C <config profile>      start with specified configuration profile\n");
 291   fprintf(output, "  -F <output file type>    set the output file type, default is libpcap\n");
 292   fprintf(output, "                           an empty \"-F\" option will list the file types\n");
 293   fprintf(output, "  -V                       add output of packet tree        (Packet Details)\n");
 294   fprintf(output, "  -S                       display packets even when writing to a file\n");
 295   fprintf(output, "  -x                       add output of hex and ASCII dump (Packet Bytes)\n");
 296   fprintf(output, "  -T pdml|ps|psml|text|fields\n");
 297   fprintf(output, "                           format of text output (def: text)\n");
 298   fprintf(output, "  -e <field>               field to print if -Tfields selected (e.g. tcp.port);\n");
 299   fprintf(output, "                           this option can be repeated to print multiple fields\n");
 300   fprintf(output, "  -E<fieldsoption>=<value> set options for output when -Tfields selected:\n");
 301   fprintf(output, "     header=y|n            switch headers on and off\n");
 302   fprintf(output, "     separator=/t|/s|<char> select tab, space, printable character as separator\n");
 303   fprintf(output, "     quote=d|s|n           select double, single, no quotes for values\n");
 304   fprintf(output, "  -t ad|a|r|d|dd|e         output format of time stamps (def: r: rel. to first)\n");
 305   fprintf(output, "  -l                       flush standard output after each packet\n");
 306   fprintf(output, "  -q                       be more quiet on stdout (e.g. when using statistics)\n");
 307   fprintf(output, "  -X <key>:<value>         eXtension options, see the man page for details\n");
 308   fprintf(output, "  -z <statistics>          various statistics, see the man page for details\n");
 309
 310   fprintf(output, "\n");
 311   fprintf(output, "Miscellaneous:\n");
 312   fprintf(output, "  -h                       display this help and exit\n");
 313   fprintf(output, "  -v                       display version info and exit\n");
 314   fprintf(output, "  -o <name>:<value> ...    override preference setting\n");
 315 }
 316
 317 /*
 318  * For a dissector table, print on the stream described by output,
 319  * its short name (which is what's used in the "-d" option) and its
 320  * descriptive name.
 321  */
 322 static void
 323 display_dissector_table_names(const char *table_name, const char *ui_name,
 324                               gpointer output)
 325 {
 326   fprintf((FILE *)output, "\t%s (%s)\n", table_name, ui_name);
 327 }
 328
 329 /*
 330  * For a dissector handle, print on the stream described by output,
 331  * the filter name (which is what's used in the "-d" option) and the full
 332  * name for the protocol that corresponds to this handle.
 333  */
 334 static void
 335 display_dissector_names(const gchar *table _U_, gpointer handle, gpointer output)
 336 {
 337   int                proto_id;
 338   const gchar*       proto_filter_name;
 339   const gchar*       proto_ui_name;
 340
 341   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
 342
 343   if (proto_id != -1) {
 344     proto_filter_name = proto_get_protocol_filter_name(proto_id);
 345     proto_ui_name =  proto_get_protocol_name(proto_id);
 346     g_assert(proto_filter_name != NULL);
 347     g_assert(proto_ui_name != NULL);
 348
 349     fprintf((FILE *)output, "\t%s (%s)\n",
 350             proto_filter_name,
 351             proto_ui_name);
 352   }
 353 }
 354
 355 /*
 356  * The protocol_name_search structure is used by find_protocol_name_func()
 357  * to pass parameters and store results
 358  */
 359 struct protocol_name_search{
 360   gchar              *searched_name;  /* Protocol filter name we are looking for */
 361   dissector_handle_t  matched_handle; /* Handle for a dissector whose protocol has the specified filter name */
 362   guint               nb_match;       /* How many dissectors matched searched_name */
 363 };
 364 typedef struct protocol_name_search *protocol_name_search_t;
 365
 366 /*
 367  * This function parses all dissectors associated with a table to find the
 368  * one whose protocol has the specified filter name.  It is called
 369  * as a reference function in a call to dissector_table_foreach_handle.
 370  * The name we are looking for, as well as the results, are stored in the
 371  * protocol_name_search struct pointed to by user_data.
 372  * If called using dissector_table_foreach_handle, we actually parse the
 373  * whole list of dissectors.
 374  */
 375 static void
 376 find_protocol_name_func(const gchar *table _U_, gpointer handle, gpointer user_data)
 377
 378 {
 379   int                         proto_id;
 380   const gchar                *protocol_filter_name;
 381   protocol_name_search_t      search_info;
 382
 383   g_assert(handle);
 384
 385   search_info = (protocol_name_search_t)user_data;
 386
 387   proto_id = dissector_handle_get_protocol_index((dissector_handle_t)handle);
 388   if (proto_id != -1) {
 389     protocol_filter_name = proto_get_protocol_filter_name(proto_id);
 390     g_assert(protocol_filter_name != NULL);
 391     if (strcmp(protocol_filter_name, search_info->searched_name) == 0) {
 392       /* Found a match */
 393       if (search_info->nb_match == 0) {
 394         /* Record this handle only if this is the first match */
 395         search_info->matched_handle = (dissector_handle_t)handle; /* Record the handle for this matching dissector */
 396       }
 397       search_info->nb_match++;
 398     }
 399   }
 400 }
 401
 402 /*
 403  * Print all layer type names supported.
 404  * We send the output to the stream described by the handle output.
 405  */
 406
 407 static void
 408 fprint_all_layer_types(FILE *output)
 409
 410 {
 411   dissector_all_tables_foreach_table(display_dissector_table_names, (gpointer)output);
 412 }
 413
 414 /*
 415  * Print all protocol names supported for a specific layer type.
 416  * table_name contains the layer type name in which the search is performed.
 417  * We send the output to the stream described by the handle output.
 418  */
 419
 420 static void
 421 fprint_all_protocols_for_layer_types(FILE *output, gchar *table_name)
 422
 423 {
 424   dissector_table_foreach_handle(table_name,
 425                                  display_dissector_names,
 426                                  (gpointer)output);
 427 }
 428
 429 /*
 430  * The function below parses the command-line parameters for the decode as
 431  * feature (a string pointer by cl_param).
 432  * It checks the format of the command-line, searches for a matching table
 433  * and dissector.  If a table/dissector match is not found, we display a
 434  * summary of the available tables/dissectors (on stderr) and return FALSE.
 435  * If everything is fine, we get the "Decode as" preference activated,
 436  * then we return TRUE.
 437  */
 438 static gboolean
 439 add_decode_as(const gchar *cl_param)
 440 {
 441   gchar                        *table_name;
 442   guint32                       selector;
 443   gchar                        *decoded_param;
 444   gchar                        *remaining_param;
 445   gchar                        *selector_str;
 446   gchar                        *dissector_str;
 447   dissector_handle_t            dissector_matching;
 448   dissector_table_t             table_matching;
 449   ftenum_t                      dissector_table_selector_type;
 450   struct protocol_name_search   user_protocol_name;
 451
 452   /* The following code will allocate and copy the command-line options in a string pointed by decoded_param */
 453
 454   g_assert(cl_param);
 455   decoded_param = g_strdup(cl_param);
 456   g_assert(decoded_param);
 457
 458
 459   /* The lines below will parse this string (modifying it) to extract all
 460     necessary information.  Note that decoded_param is still needed since
 461     strings are not copied - we just save pointers. */
 462
 463   /* This section extracts a layer type (table_name) from decoded_param */
 464   table_name = decoded_param; /* Layer type string starts from beginning */
 465
 466   remaining_param = strchr(table_name, '=');
 467   if (remaining_param == NULL) {
 468     cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
 469     /* If the argument does not follow the template, carry on anyway to check
 470        if the table name is at least correct.  If remaining_param is NULL,
 471        we'll exit anyway further down */
 472   }
 473   else {
 474     *remaining_param = '\0'; /* Terminate the layer type string (table_name) where '=' was detected */
 475   }
 476
 477   /* Remove leading and trailing spaces from the table name */
 478   while ( table_name[0] == ' ' )
 479     table_name++;
 480   while ( table_name[strlen(table_name) - 1] == ' ' )
 481     table_name[strlen(table_name) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
 482
 483 /* The following part searches a table matching with the layer type specified */
 484   table_matching = NULL;
 485
 486 /* Look for the requested table */
 487   if ( !(*(table_name)) ) { /* Is the table name empty, if so, don't even search for anything, display a message */
 488     cmdarg_err("No layer type specified"); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
 489   }
 490   else {
 491     table_matching = find_dissector_table(table_name);
 492     if (!table_matching) {
 493       cmdarg_err("Unknown layer type -- %s", table_name); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
 494     }
 495   }
 496
 497   if (!table_matching) {
 498     /* Display a list of supported layer types to help the user, if the
 499        specified layer type was not found */
 500     cmdarg_err("Valid layer types are:");
 501     fprint_all_layer_types(stderr);
 502   }
 503   if (remaining_param == NULL || !table_matching) {
 504     /* Exit if the layer type was not found, or if no '=' separator was found
 505        (see above) */
 506     g_free(decoded_param);
 507     return FALSE;
 508   }
 509
 510   if (*(remaining_param + 1) != '=') { /* Check for "==" and not only '=' */
 511     cmdarg_err("WARNING: -d requires \"==\" instead of \"=\". Option will be treated as \"%s==%s\"", table_name, remaining_param + 1);
 512   }
 513   else {
 514     remaining_param++; /* Move to the second '=' */
 515     *remaining_param = '\0'; /* Remove the second '=' */
 516   }
 517   remaining_param++; /* Position after the layer type string */
 518
 519   /* This section extracts a selector value (selector_str) from decoded_param */
 520
 521   selector_str = remaining_param; /* Next part starts with the selector number */
 522
 523   remaining_param = strchr(selector_str, ',');
 524   if (remaining_param == NULL) {
 525     cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
 526     /* If the argument does not follow the template, carry on anyway to check
 527        if the selector value is at least correct.  If remaining_param is NULL,
 528        we'll exit anyway further down */
 529   }
 530   else {
 531     *remaining_param = '\0'; /* Terminate the selector number string (selector_str) where ',' was detected */
 532   }
 533
 534   dissector_table_selector_type = get_dissector_table_selector_type(table_name);
 535
 536   switch (dissector_table_selector_type) {
 537
 538   case FT_UINT8:
 539   case FT_UINT16:
 540   case FT_UINT24:
 541   case FT_UINT32:
 542     /* The selector for this table is an unsigned number.  Parse it as such.
 543        There's no need to remove leading and trailing spaces from the
 544        selector number string, because sscanf will do that for us. */
 545     if ( sscanf(selector_str, "%u", &selector) != 1 ) {
 546       cmdarg_err("Invalid selector number \"%s\"", selector_str);
 547       g_free(decoded_param);
 548       return FALSE;
 549     }
 550     break;
 551
 552   case FT_STRING:
 553   case FT_STRINGZ:
 554   case FT_EBCDIC:
 555     /* The selector for this table is a string. */
 556     break;
 557
 558   default:
 559     /* There are currently no dissector tables with any types other
 560        than the ones listed above. */
 561     g_assert_not_reached();
 562   }
 563
 564   if (remaining_param == NULL) {
 565     /* Exit if no ',' separator was found (see above) */
 566     cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
 567     fprint_all_protocols_for_layer_types(stderr, table_name);
 568     g_free(decoded_param);
 569     return FALSE;
 570   }
 571
 572   remaining_param++; /* Position after the selector number string */
 573
 574   /* This section extracts a protocol filter name (dissector_str) from decoded_param */
 575
 576   dissector_str = remaining_param; /* All the rest of the string is the dissector (decode as protocol) name */
 577
 578   /* Remove leading and trailing spaces from the dissector name */
 579   while ( dissector_str[0] == ' ' )
 580     dissector_str++;
 581   while ( dissector_str[strlen(dissector_str) - 1] == ' ' )
 582     dissector_str[strlen(dissector_str) - 1] = '\0'; /* Note: if empty string, while loop will eventually exit */
 583
 584   dissector_matching = NULL;
 585
 586   /* We now have a pointer to the handle for the requested table inside the variable table_matching */
 587   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 */
 588     cmdarg_err("No protocol name specified"); /* Note, we don't exit here, but dissector_matching will remain NULL, so we exit below */
 589   }
 590   else {
 591     user_protocol_name.nb_match = 0;
 592     user_protocol_name.searched_name = dissector_str;
 593     user_protocol_name.matched_handle = NULL;
 594
 595     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 */
 596
 597     if (user_protocol_name.nb_match != 0) {
 598       dissector_matching = user_protocol_name.matched_handle;
 599       if (user_protocol_name.nb_match > 1) {
 600         cmdarg_err("WARNING: Protocol \"%s\" matched %u dissectors, first one will be used", dissector_str, user_protocol_name.nb_match);
 601       }
 602     }
 603     else {
 604       /* OK, check whether the problem is that there isn't any such
 605          protocol, or that there is but it's not specified as a protocol
 606          that's valid for that dissector table.
 607          Note, we don't exit here, but dissector_matching will remain NULL,
 608          so we exit below */
 609       if (proto_get_id_by_filter_name(dissector_str) == -1) {
 610         /* No such protocol */
 611         cmdarg_err("Unknown protocol -- \"%s\"", dissector_str);
 612       } else {
 613         cmdarg_err("Protocol \"%s\" isn't valid for layer type \"%s\"",
 614                 dissector_str, table_name);
 615       }
 616     }
 617   }
 618
 619   if (!dissector_matching) {
 620     cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
 621     fprint_all_protocols_for_layer_types(stderr, table_name);
 622     g_free(decoded_param);
 623     return FALSE;
 624   }
 625
 626 /* This is the end of the code that parses the command-line options.
 627    All information is now stored in the variables:
 628    table_name
 629    selector
 630    dissector_matching
 631    The above variables that are strings are still pointing to areas within
 632    decoded_parm.  decoded_parm thus still needs to be kept allocated in
 633    until we stop needing these variables
 634    decoded_param will be deallocated at each exit point of this function */
 635
 636
 637   /* We now have a pointer to the handle for the requested dissector
 638      (requested protocol) inside the variable dissector_matching */
 639   switch (dissector_table_selector_type) {
 640
 641   case FT_UINT8:
 642   case FT_UINT16:
 643   case FT_UINT24:
 644   case FT_UINT32:
 645     /* The selector for this table is an unsigned number. */
 646     dissector_change(table_name, selector, dissector_matching);
 647     break;
 648
 649   case FT_STRING:
 650   case FT_STRINGZ:
 651   case FT_EBCDIC:
 652     /* The selector for this table is a string. */
 653     dissector_change_string(table_name, selector_str, dissector_matching);
 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   g_free(decoded_param); /* "Decode As" rule has been succesfully added */
 662   return TRUE;
 663 }
 664
 665 static void
 666 log_func_ignore (const gchar *log_domain _U_, GLogLevelFlags log_level _U_,
 667     const gchar *message _U_, gpointer user_data _U_)
 668 {
 669 }
 670
 671 static char *
 672 output_file_description(const char *fname)
 673 {
 674   char *save_file_string;
 675
 676   /* Get a string that describes what we're writing to */
 677   if (strcmp(fname, "-") == 0) {
 678     /* We're writing to the standard output */
 679     save_file_string = g_strdup("standard output");
 680   } else {
 681     /* We're writing to a file with the name in save_file */
 682     save_file_string = g_strdup_printf("file \"%s\"", fname);
 683   }
 684   return save_file_string;
 685 }
 686
 687 static void
 688 print_current_user(void) {
 689   gchar *cur_user, *cur_group;
 690   if (started_with_special_privs()) {
 691     cur_user = get_cur_username();
 692     cur_group = get_cur_groupname();
 693     fprintf(stderr, "Running as user \"%s\" and group \"%s\".",
 694       cur_user, cur_group);
 695     g_free(cur_user);
 696     g_free(cur_group);
 697     if (running_with_special_privs()) {
 698       fprintf(stderr, " This could be dangerous.");
 699     }
 700     fprintf(stderr, "\n");
 701   }
 702 }
 703
 704 static void
 705 check_capture_privs(void) {
 706 #ifdef _WIN32
 707   load_wpcap();
 708   /* Warn the user if npf.sys isn't loaded. */
 709   if (!npf_sys_is_running() && get_os_major_version() >= 6) {
 710     fprintf(stderr, "The NPF driver isn't running.  You may have trouble "
 711       "capturing or\nlisting interfaces.\n");
 712   }
 713 #endif
 714 }
 715
 716
 717
 718 int
 719 main(int argc, char *argv[])
 720 {
 721   char                *init_progfile_dir_error;
 722   int                  opt, i;
 723   extern char         *optarg;
 724   gboolean             arg_error = FALSE;
 725
 726 #ifdef _WIN32
 727   WSADATA               wsaData;
 728 #endif  /* _WIN32 */
 729
 730   char                *gpf_path, *pf_path;
 731   char                *gdp_path, *dp_path;
 732   int                  gpf_open_errno, gpf_read_errno;
 733   int                  pf_open_errno, pf_read_errno;
 734   int                  gdp_open_errno, gdp_read_errno;
 735   int                  dp_open_errno, dp_read_errno;
 736   int                  err;
 737 #ifdef HAVE_LIBPCAP
 738   gboolean             list_link_layer_types = FALSE;
 739   gboolean             start_capture = FALSE;
 740   int                  status;
 741 #else
 742   gboolean             capture_option_specified = FALSE;
 743 #endif
 744   gboolean             quiet = FALSE;
 745   int                  out_file_type = WTAP_FILE_PCAP;
 746   gchar               *cf_name = NULL, *rfilter = NULL;
 747 #ifdef HAVE_PCAP_OPEN_DEAD
 748   struct bpf_program   fcode;
 749 #endif
 750   dfilter_t           *rfcode = NULL;
 751   e_prefs             *prefs;
 752   char                 badopt;
 753   GLogLevelFlags       log_flags;
 754   int                  optind_initial;
 755
 756 #define OPTSTRING_INIT "a:b:c:C:d:De:E:f:F:G:hi:lLnN:o:pqr:R:s:St:T:vVw:xX:y:z:"
 757 #ifdef HAVE_LIBPCAP
 758 #ifdef _WIN32
 759 #define OPTSTRING_WIN32 "B:"
 760 #else
 761 #define OPTSTRING_WIN32 ""
 762 #endif  /* _WIN32 */
 763 #else
 764 #define OPTSTRING_WIN32 ""
 765 #endif  /* HAVE_LIBPCAP */
 766
 767   static const char    optstring[] = OPTSTRING_INIT OPTSTRING_WIN32;
 768
 769   /*
 770    * Get credential information for later use.
 771    */
 772   get_credential_info();
 773
 774   /*
 775    * Attempt to get the pathname of the executable file.
 776    */
 777   init_progfile_dir_error = init_progfile_dir(argv[0]);
 778   if (init_progfile_dir_error != NULL) {
 779     fprintf(stderr, "tshark: Can't get pathname of tshark program: %s.\n",
 780             init_progfile_dir_error);
 781   }
 782
 783   /*
 784    * In order to have the -X opts assigned before the wslua machine starts
 785    * we need to call getopts before epan_init() gets called.
 786    */
 787   opterr = 0;
 788   optind_initial = optind;
 789
 790   while ((opt = getopt(argc, argv, optstring)) != -1) {
 791           switch (opt) {
 792                   case 'C':        /* Configuration Profile */
 793                           if (profile_exists (optarg)) {
 794                                   set_profile_name (optarg);
 795                           } else {
 796                                   cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
 797                                   exit(1);
 798                           }
 799                           break;
 800                   case 'X':
 801                           ex_opt_add(optarg);
 802                           break;
 803                   default:
 804                           break;
 805           }
 806   }
 807
 808   optind = optind_initial;
 809   opterr = 1;
 810
 811   /* nothing more than the standard GLib handler, but without a warning */
 812   log_flags =
 813                     G_LOG_LEVEL_WARNING|
 814                     G_LOG_LEVEL_MESSAGE|
 815                     G_LOG_LEVEL_INFO|
 816                     G_LOG_LEVEL_DEBUG;
 817
 818   g_log_set_handler(NULL,
 819                     log_flags,
 820                     log_func_ignore, NULL /* user_data */);
 821   g_log_set_handler(LOG_DOMAIN_CAPTURE,
 822                     log_flags,
 823                     log_func_ignore, NULL /* user_data */);
 824
 825   initialize_funnel_ops();
 826
 827 #ifdef HAVE_LIBPCAP
 828   capture_opts_init(&capture_opts, NULL /* cfile */);
 829 #endif
 830
 831   timestamp_set_type(TS_RELATIVE);
 832   timestamp_set_precision(TS_PREC_AUTO);
 833
 834   /* Register all dissectors; we must do this before checking for the
 835      "-G" flag, as the "-G" flag dumps information registered by the
 836      dissectors, and we must do it before we read the preferences, in
 837      case any dissectors register preferences. */
 838   epan_init(register_all_protocols, register_all_protocol_handoffs, NULL, NULL,
 839             failure_message, open_failure_message, read_failure_message);
 840
 841   /* Register all tap listeners; we do this before we parse the arguments,
 842      as the "-z" argument can specify a registered tap. */
 843
 844   /* we register the plugin taps before the other taps because
 845      stats_tree taps plugins will be registered as tap listeners
 846      by stats_tree_stat.c and need to registered before that */
 847 #ifdef HAVE_PLUGINS
 848   register_all_plugin_tap_listeners();
 849 #endif
 850   register_all_tap_listeners();
 851
 852   /* Now register the preferences for any non-dissector modules.
 853      We must do that before we read the preferences as well. */
 854   prefs_register_modules();
 855
 856   /* If invoked with the "-G" flag, we dump out information based on
 857      the argument to the "-G" flag; if no argument is specified,
 858      for backwards compatibility we dump out a glossary of display
 859      filter symbols.
 860
 861      XXX - we do this here, for now, to support "-G" with no arguments.
 862      If none of our build or other processes uses "-G" with no arguments,
 863      we can just process it with the other arguments. */
 864   if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
 865     if (argc == 2)
 866       proto_registrar_dump_fields(1);
 867     else {
 868       if (strcmp(argv[2], "fields") == 0)
 869         proto_registrar_dump_fields(1);
 870       else if (strcmp(argv[2], "fields2") == 0)
 871         proto_registrar_dump_fields(2);
 872       else if (strcmp(argv[2], "fields3") == 0)
 873         proto_registrar_dump_fields(3);
 874       else if (strcmp(argv[2], "protocols") == 0)
 875         proto_registrar_dump_protocols();
 876       else if (strcmp(argv[2], "values") == 0)
 877         proto_registrar_dump_values();
 878       else if (strcmp(argv[2], "decodes") == 0)
 879         dissector_dump_decodes();
 880       else if (strcmp(argv[2], "defaultprefs") == 0)
 881         write_prefs(NULL);
 882       else if (strcmp(argv[2], "currentprefs") == 0) {
 883         read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
 884             &pf_open_errno, &pf_read_errno, &pf_path);
 885         write_prefs(NULL);
 886       } else {
 887         cmdarg_err("Invalid \"%s\" option for -G flag", argv[2]);
 888         exit(1);
 889       }
 890     }
 891     exit(0);
 892   }
 893
 894   /* Set the C-language locale to the native environment. */
 895   setlocale(LC_ALL, "");
 896
 897   prefs = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
 898                      &pf_open_errno, &pf_read_errno, &pf_path);
 899   if (gpf_path != NULL) {
 900     if (gpf_open_errno != 0) {
 901       cmdarg_err("Can't open global preferences file \"%s\": %s.",
 902               pf_path, strerror(gpf_open_errno));
 903     }
 904     if (gpf_read_errno != 0) {
 905       cmdarg_err("I/O error reading global preferences file \"%s\": %s.",
 906               pf_path, strerror(gpf_read_errno));
 907     }
 908   }
 909   if (pf_path != NULL) {
 910     if (pf_open_errno != 0) {
 911       cmdarg_err("Can't open your preferences file \"%s\": %s.", pf_path,
 912               strerror(pf_open_errno));
 913     }
 914     if (pf_read_errno != 0) {
 915       cmdarg_err("I/O error reading your preferences file \"%s\": %s.",
 916               pf_path, strerror(pf_read_errno));
 917     }
 918     g_free(pf_path);
 919     pf_path = NULL;
 920   }
 921
 922   /* Set the name resolution code's flags from the preferences. */
 923   g_resolv_flags = prefs->name_resolve;
 924
 925   /* Read the disabled protocols file. */
 926   read_disabled_protos_list(&gdp_path, &gdp_open_errno, &gdp_read_errno,
 927                             &dp_path, &dp_open_errno, &dp_read_errno);
 928   if (gdp_path != NULL) {
 929     if (gdp_open_errno != 0) {
 930       cmdarg_err("Could not open global disabled protocols file\n\"%s\": %s.",
 931                  gdp_path, strerror(gdp_open_errno));
 932     }
 933     if (gdp_read_errno != 0) {
 934       cmdarg_err("I/O error reading global disabled protocols file\n\"%s\": %s.",
 935                  gdp_path, strerror(gdp_read_errno));
 936     }
 937     g_free(gdp_path);
 938   }
 939   if (dp_path != NULL) {
 940     if (dp_open_errno != 0) {
 941       cmdarg_err(
 942         "Could not open your disabled protocols file\n\"%s\": %s.", dp_path,
 943         strerror(dp_open_errno));
 944     }
 945     if (dp_read_errno != 0) {
 946       cmdarg_err(
 947         "I/O error reading your disabled protocols file\n\"%s\": %s.", dp_path,
 948         strerror(dp_read_errno));
 949     }
 950     g_free(dp_path);
 951   }
 952
 953   check_capture_privs();
 954
 955   init_cap_file(&cfile);
 956
 957   /* Assemble the compile-time version information string */
 958   comp_info_str = g_string_new("Compiled ");
 959   get_compiled_version_info(comp_info_str, get_epan_compiled_version_info);
 960
 961   /* Assemble the run-time version information string */
 962   runtime_info_str = g_string_new("Running ");
 963   get_runtime_version_info(runtime_info_str, NULL);
 964
 965   /* Print format defaults to this. */
 966   print_format = PR_FMT_TEXT;
 967
 968   output_fields = output_fields_new();
 969
 970   /* Now get our args */
 971   while ((opt = getopt(argc, argv, optstring)) != -1) {
 972     switch (opt) {
 973       case 'a':        /* autostop criteria */
 974       case 'b':        /* Ringbuffer option */
 975       case 'c':        /* Capture x packets */
 976       case 'f':        /* capture filter */
 977       case 'i':        /* Use interface x */
 978       case 'p':        /* Don't capture in promiscuous mode */
 979       case 's':        /* Set the snapshot (capture) length */
 980       case 'w':        /* Write to capture file x */
 981       case 'y':        /* Set the pcap data link type */
 982 #ifdef _WIN32
 983       case 'B':        /* Buffer size */
 984 #endif /* _WIN32 */
 985 #ifdef HAVE_LIBPCAP
 986         status = capture_opts_add_opt(&capture_opts, opt, optarg, &start_capture);
 987         if(status != 0) {
 988             exit(status);
 989         }
 990 #else
 991         capture_option_specified = TRUE;
 992         arg_error = TRUE;
 993 #endif
 994         break;
 995       case 'C':
 996         /* Configuration profile settings were already processed just ignore them this time*/
 997         break;
 998       case 'd':        /* Decode as rule */
 999         if (!add_decode_as(optarg))
1000           exit(1);
1001         break;
1002       case 'D':        /* Print a list of capture devices and exit */
1003 #ifdef HAVE_LIBPCAP
1004         status = capture_opts_list_interfaces(FALSE);
1005         exit(status);
1006 #else
1007         capture_option_specified = TRUE;
1008         arg_error = TRUE;
1009 #endif
1010         break;
1011       case 'e':
1012         /* Field entry */
1013         output_fields_add(output_fields, optarg);
1014         break;
1015       case 'E':
1016         /* Field option */
1017         if(!output_fields_set_option(output_fields, optarg)) {
1018           cmdarg_err("\"%s\" is not a valid field output option=value pair.", optarg);
1019           output_fields_list_options(stderr);
1020           exit(1);
1021         }
1022         break;
1023       case 'F':
1024         out_file_type = wtap_short_string_to_file_type(optarg);
1025         if (out_file_type < 0) {
1026           cmdarg_err("\"%s\" isn't a valid capture file type", optarg);
1027           list_capture_types();
1028           exit(1);
1029         }
1030         break;
1031       case 'h':        /* Print help and exit */
1032         print_usage(TRUE);
1033         exit(0);
1034         break;
1035       case 'l':        /* "Line-buffer" standard output */
1036         /* This isn't line-buffering, strictly speaking, it's just
1037            flushing the standard output after the information for
1038            each packet is printed; however, that should be good
1039            enough for all the purposes to which "-l" is put (and
1040            is probably actually better for "-V", as it does fewer
1041            writes).
1042
1043            See the comment in "process_packet()" for an explanation of
1044            why we do that, and why we don't just use "setvbuf()" to
1045            make the standard output line-buffered (short version: in
1046            Windows, "line-buffered" is the same as "fully-buffered",
1047            and the output buffer is only flushed when it fills up). */
1048         line_buffered = TRUE;
1049         break;
1050       case 'L':        /* Print list of link-layer types and exit */
1051 #ifdef HAVE_LIBPCAP
1052         list_link_layer_types = TRUE;
1053 #else
1054         capture_option_specified = TRUE;
1055         arg_error = TRUE;
1056 #endif
1057         break;
1058       case 'n':        /* No name resolution */
1059         g_resolv_flags = RESOLV_NONE;
1060         break;
1061       case 'N':        /* Select what types of addresses/port #s to resolve */
1062         if (g_resolv_flags == RESOLV_ALL)
1063           g_resolv_flags = RESOLV_NONE;
1064         badopt = string_to_name_resolve(optarg, &g_resolv_flags);
1065         if (badopt != '\0') {
1066           cmdarg_err("-N specifies unknown resolving option '%c';",
1067                      badopt);
1068           cmdarg_err_cont( "           Valid options are 'm', 'n', 't', and 'C'");
1069           exit(1);
1070         }
1071         break;
1072       case 'o':        /* Override preference from command line */
1073         switch (prefs_set_pref(optarg)) {
1074
1075         case PREFS_SET_OK:
1076           break;
1077
1078         case PREFS_SET_SYNTAX_ERR:
1079           cmdarg_err("Invalid -o flag \"%s\"", optarg);
1080           exit(1);
1081           break;
1082
1083         case PREFS_SET_NO_SUCH_PREF:
1084         case PREFS_SET_OBSOLETE:
1085           cmdarg_err("-o flag \"%s\" specifies unknown preference", optarg);
1086           exit(1);
1087           break;
1088         }
1089         break;
1090       case 'q':        /* Quiet */
1091         quiet = TRUE;
1092         break;
1093       case 'r':        /* Read capture file x */
1094         cf_name = g_strdup(optarg);
1095         break;
1096       case 'R':        /* Read file filter */
1097         rfilter = optarg;
1098         break;
1099       case 'S':        /* show packets in real time */
1100         print_packet_info = TRUE;
1101         break;
1102       case 't':        /* Time stamp type */
1103         if (strcmp(optarg, "r") == 0)
1104           timestamp_set_type(TS_RELATIVE);
1105         else if (strcmp(optarg, "a") == 0)
1106           timestamp_set_type(TS_ABSOLUTE);
1107         else if (strcmp(optarg, "ad") == 0)
1108           timestamp_set_type(TS_ABSOLUTE_WITH_DATE);
1109         else if (strcmp(optarg, "d") == 0)
1110           timestamp_set_type(TS_DELTA);
1111         else if (strcmp(optarg, "dd") == 0)
1112           timestamp_set_type(TS_DELTA_DIS);
1113         else if (strcmp(optarg, "e") == 0)
1114           timestamp_set_type(TS_EPOCH);
1115         else {
1116           cmdarg_err("Invalid time stamp type \"%s\"",
1117             optarg);
1118           cmdarg_err_cont("It must be \"r\" for relative, \"a\" for absolute,");
1119           cmdarg_err_cont("\"ad\" for absolute with date, or \"d\" for delta.");
1120           exit(1);
1121         }
1122         break;
1123       case 'T':        /* printing Type */
1124         if (strcmp(optarg, "text") == 0) {
1125           output_action = WRITE_TEXT;
1126           print_format = PR_FMT_TEXT;
1127         } else if (strcmp(optarg, "ps") == 0) {
1128           output_action = WRITE_TEXT;
1129           print_format = PR_FMT_PS;
1130         } else if (strcmp(optarg, "pdml") == 0) {
1131           output_action = WRITE_XML;
1132           verbose = TRUE;
1133         } else if (strcmp(optarg, "psml") == 0) {
1134           output_action = WRITE_XML;
1135           verbose = FALSE;
1136         } else if(strcmp(optarg, "fields") == 0) {
1137           output_action = WRITE_FIELDS;
1138           verbose = TRUE; /* Need full tree info */
1139         } else {
1140           cmdarg_err("Invalid -T parameter.");
1141           cmdarg_err_cont("It must be \"ps\", \"text\", \"pdml\", \"psml\" or \"fields\".");
1142           exit(1);
1143         }
1144         break;
1145       case 'v':        /* Show version and exit */
1146         printf("TShark " VERSION "%s\n"
1147                "\n"
1148                "%s"
1149                "\n"
1150                "%s"
1151                "\n"
1152                "%s",
1153                wireshark_svnversion, get_copyright_info(), comp_info_str->str,
1154                runtime_info_str->str);
1155         exit(0);
1156         break;
1157       case 'V':        /* Verbose */
1158         verbose = TRUE;
1159         break;
1160       case 'x':        /* Print packet data in hex (and ASCII) */
1161           print_hex = TRUE;
1162           break;
1163       case 'X':
1164           break;
1165       case 'z':
1166         /* We won't call the init function for the stat this soon
1167            as it would disallow MATE's fields (which are registered
1168            by the preferences set callback) from being used as
1169            part of a tap filter.  Instead, we just add the argument
1170            to a list of stat arguments. */
1171         if (!process_stat_cmd_arg(optarg)) {
1172           cmdarg_err("invalid -z argument.");
1173           cmdarg_err_cont("  -z argument must be one of :");
1174           list_stat_cmd_args();
1175           exit(1);
1176         }
1177         break;
1178       default:
1179       case '?':        /* Bad flag - print usage message */
1180         switch(optopt) {
1181         case 'F':
1182           list_capture_types();
1183           break;
1184         default:
1185           print_usage(TRUE);
1186         }
1187         exit(1);
1188         break;
1189     }
1190   }
1191
1192   /* If we specified output fields, but not the output field type... */
1193   if(WRITE_FIELDS != output_action && 0 != output_fields_num_fields(output_fields)) {
1194         cmdarg_err("Output fields were specified with \"-e\", "
1195             "but \"-Tfields\" was not specified.");
1196         exit(1);
1197   } else if(WRITE_FIELDS == output_action && 0 == output_fields_num_fields(output_fields)) {
1198         cmdarg_err("\"-Tfields\" was specified, but no fields were "
1199                     "specified with \"-e\".");
1200
1201         exit(1);
1202   }
1203
1204   /* If no capture filter or read filter has been specified, and there are
1205      still command-line arguments, treat them as the tokens of a capture
1206      filter (if no "-r" flag was specified) or a read filter (if a "-r"
1207      flag was specified. */
1208   if (optind < argc) {
1209     if (cf_name != NULL) {
1210       if (rfilter != NULL) {
1211         cmdarg_err("Read filters were specified both with \"-R\" "
1212             "and with additional command-line arguments");
1213         exit(1);
1214       }
1215       rfilter = get_args_as_string(argc, argv, optind);
1216     } else {
1217 #ifdef HAVE_LIBPCAP
1218       if (capture_opts.has_cfilter) {
1219         cmdarg_err("Capture filters were specified both with \"-f\""
1220             " and with additional command-line arguments");
1221         exit(1);
1222       }
1223       capture_opts.has_cfilter = TRUE;
1224       capture_opts.cfilter = get_args_as_string(argc, argv, optind);
1225 #else
1226       capture_option_specified = TRUE;
1227 #endif
1228     }
1229   }
1230
1231 #ifdef HAVE_LIBPCAP
1232   if (!capture_opts.saving_to_file) {
1233     /* We're not saving the capture to a file; if "-q" wasn't specified,
1234        we should print packet information */
1235     if (!quiet)
1236       print_packet_info = TRUE;
1237   } else {
1238     /* We're saving to a file; if we're writing to the standard output.
1239        and we'll also be writing dissected packets to the standard
1240        output, reject the request.  At best, we could redirect that
1241        to the standard error; we *can't* write both to the standard
1242        output and have either of them be useful. */
1243     if (strcmp(capture_opts.save_file, "-") == 0 && print_packet_info) {
1244       cmdarg_err("You can't write both raw packet data and dissected packets"
1245           " to the standard output.");
1246       exit(1);
1247     }
1248   }
1249 #else
1250   /* We're not saving the capture to a file; if "-q" wasn't specified,
1251      we should print packet information */
1252   if (!quiet)
1253     print_packet_info = TRUE;
1254 #endif
1255
1256 #ifndef HAVE_LIBPCAP
1257   if (capture_option_specified)
1258     cmdarg_err("This version of TShark was not built with support for capturing packets.");
1259 #endif
1260   if (arg_error) {
1261     print_usage(FALSE);
1262     exit(1);
1263   }
1264
1265   /* We don't support capture filters when reading from a capture file
1266      (the BPF compiler doesn't support all link-layer types that we
1267      support in capture files we read). */
1268 #ifdef HAVE_LIBPCAP
1269   if (cf_name != NULL) {
1270     if (capture_opts.has_cfilter) {
1271       cmdarg_err("Only read filters, not capture filters, "
1272           "can be specified when reading a capture file.");
1273       exit(1);
1274     }
1275   }
1276 #endif
1277
1278   if (print_hex) {
1279     if (output_action != WRITE_TEXT) {
1280       cmdarg_err("Raw packet hex data can only be printed as text or PostScript");
1281       exit(1);
1282     }
1283   }
1284
1285 #ifdef HAVE_LIBPCAP
1286   if (list_link_layer_types) {
1287     /* We're supposed to list the link-layer types for an interface;
1288        did the user also specify a capture file to be read? */
1289     if (cf_name) {
1290       /* Yes - that's bogus. */
1291       cmdarg_err("You can't specify -L and a capture file to be read.");
1292       exit(1);
1293     }
1294     /* No - did they specify a ring buffer option? */
1295     if (capture_opts.multi_files_on) {
1296       cmdarg_err("Ring buffer requested, but a capture isn't being done.");
1297       exit(1);
1298     }
1299   } else {
1300     if (cf_name) {
1301       /*
1302        * "-r" was specified, so we're reading a capture file.
1303        * Capture options don't apply here.
1304        */
1305       if (capture_opts.multi_files_on) {
1306         cmdarg_err("Multiple capture files requested, but "
1307                    "a capture isn't being done.");
1308         exit(1);
1309       }
1310       if (capture_opts.has_file_duration) {
1311         cmdarg_err("Switching capture files after a time interval was specified, but "
1312                    "a capture isn't being done.");
1313         exit(1);
1314       }
1315       if (capture_opts.has_ring_num_files) {
1316         cmdarg_err("A ring buffer of capture files was specified, but "
1317           "a capture isn't being done.");
1318         exit(1);
1319       }
1320       if (capture_opts.has_autostop_files) {
1321         cmdarg_err("A maximum number of capture files was specified, but "
1322           "a capture isn't being done.");
1323         exit(1);
1324       }
1325
1326       /* Note: TShark now allows the restriction of a _read_ file by packet count
1327        * and byte count as well as a write file. Other autostop options remain valid
1328        * only for a write file.
1329        */
1330       if (capture_opts.has_autostop_duration) {
1331         cmdarg_err("A maximum capture time was specified, but "
1332           "a capture isn't being done.");
1333         exit(1);
1334       }
1335     } else {
1336       /*
1337        * "-r" wasn't specified, so we're doing a live capture.
1338        */
1339       if (capture_opts.saving_to_file) {
1340         /* They specified a "-w" flag, so we'll be saving to a capture file. */
1341
1342         /* When capturing, we only support writing libpcap format. */
1343         if (out_file_type != WTAP_FILE_PCAP) {
1344           cmdarg_err("Live captures can only be saved in libpcap format.");
1345           exit(1);
1346         }
1347         if (capture_opts.multi_files_on) {
1348           /* Multiple-file mode doesn't work under certain conditions:
1349              a) it doesn't work if you're writing to the standard output;
1350              b) it doesn't work if you're writing to a pipe;
1351           */
1352           if (strcmp(capture_opts.save_file, "-") == 0) {
1353             cmdarg_err("Multiple capture files requested, but "
1354               "the capture is being written to the standard output.");
1355             exit(1);
1356           }
1357           if (capture_opts.output_to_pipe) {
1358             cmdarg_err("Multiple capture files requested, but "
1359               "the capture file is a pipe.");
1360             exit(1);
1361           }
1362           if (!capture_opts.has_autostop_filesize &&
1363               !capture_opts.has_file_duration) {
1364             cmdarg_err("Multiple capture files requested, but "
1365               "no maximum capture file size or duration was specified.");
1366             exit(1);
1367           }
1368         }
1369       } else {
1370         /* They didn't specify a "-w" flag, so we won't be saving to a
1371            capture file.  Check for options that only make sense if
1372            we're saving to a file. */
1373         if (capture_opts.has_autostop_filesize) {
1374           cmdarg_err("Maximum capture file size specified, but "
1375            "capture isn't being saved to a file.");
1376           exit(1);
1377         }
1378         if (capture_opts.multi_files_on) {
1379           cmdarg_err("Multiple capture files requested, but "
1380             "the capture isn't being saved to a file.");
1381           exit(1);
1382         }
1383       }
1384     }
1385   }
1386 #endif
1387
1388 #ifdef _WIN32
1389   /* Start windows sockets */
1390   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
1391 #endif /* _WIN32 */
1392
1393   /* Notify all registered modules that have had any of their preferences
1394      changed either from one of the preferences file or from the command
1395      line that their preferences have changed. */
1396   prefs_apply_all();
1397
1398   /* At this point MATE will have registered its field array so we can
1399      have a tap filter with one of MATE's late-registered fields as part
1400      of the filter.  We can now process all the "-z" arguments. */
1401   start_requested_stats();
1402
1403   /* disabled protocols as per configuration file */
1404   if (gdp_path == NULL && dp_path == NULL) {
1405     set_disabled_protos_list();
1406   }
1407
1408   /* Build the column format array */
1409   col_setup(&cfile.cinfo, prefs->num_cols);
1410   for (i = 0; i < cfile.cinfo.num_cols; i++) {
1411     cfile.cinfo.col_fmt[i] = get_column_format(i);
1412     cfile.cinfo.col_title[i] = g_strdup(get_column_title(i));
1413     cfile.cinfo.fmt_matx[i] = (gboolean *) g_malloc0(sizeof(gboolean) *
1414       NUM_COL_FMTS);
1415     get_column_format_matches(cfile.cinfo.fmt_matx[i], cfile.cinfo.col_fmt[i]);
1416     cfile.cinfo.col_data[i] = NULL;
1417     if (cfile.cinfo.col_fmt[i] == COL_INFO)
1418       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_INFO_LEN);
1419     else
1420       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
1421     cfile.cinfo.col_fence[i] = 0;
1422     cfile.cinfo.col_expr.col_expr[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
1423     cfile.cinfo.col_expr.col_expr_val[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
1424   }
1425
1426   for (i = 0; i < cfile.cinfo.num_cols; i++) {
1427       int j;
1428
1429       for (j = 0; j < NUM_COL_FMTS; j++) {
1430          if (!cfile.cinfo.fmt_matx[i][j])
1431              continue;
1432
1433          if (cfile.cinfo.col_first[j] == -1)
1434              cfile.cinfo.col_first[j] = i;
1435          cfile.cinfo.col_last[j] = i;
1436       }
1437   }
1438
1439 #ifdef HAVE_LIBPCAP
1440   capture_opts_trim_snaplen(&capture_opts, MIN_PACKET_SIZE);
1441   capture_opts_trim_ring_num_files(&capture_opts);
1442 #endif
1443
1444   if (rfilter != NULL) {
1445     if (!dfilter_compile(rfilter, &rfcode)) {
1446       cmdarg_err("%s", dfilter_error_msg);
1447       epan_cleanup();
1448 #ifdef HAVE_PCAP_OPEN_DEAD
1449       {
1450         pcap_t *pc;
1451
1452         pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
1453         if (pc != NULL) {
1454           if (pcap_compile(pc, &fcode, rfilter, 0, 0) != -1) {
1455             cmdarg_err_cont(
1456               "  Note: That display filter code looks like a valid capture filter;");
1457             cmdarg_err_cont(
1458               "        maybe you mixed them up?");
1459           }
1460           pcap_close(pc);
1461         }
1462       }
1463 #endif
1464       exit(2);
1465     }
1466   }
1467   cfile.rfcode = rfcode;
1468
1469   if (print_packet_info) {
1470     /* If we're printing as text or PostScript, we have
1471        to create a print stream. */
1472     if (output_action == WRITE_TEXT) {
1473       switch (print_format) {
1474
1475       case PR_FMT_TEXT:
1476         print_stream = print_stream_text_stdio_new(stdout);
1477         break;
1478
1479       case PR_FMT_PS:
1480         print_stream = print_stream_ps_stdio_new(stdout);
1481         break;
1482
1483       default:
1484         g_assert_not_reached();
1485       }
1486     }
1487   }
1488
1489   /* We have to dissect each packet if:
1490
1491         we're printing information about each packet;
1492
1493         we're using a read filter on the packets;
1494
1495         we're using any taps. */
1496   do_dissection = print_packet_info || rfcode || have_tap_listeners();
1497
1498   if (cf_name) {
1499     /*
1500      * We're reading a capture file.
1501      */
1502
1503     /*
1504      * Immediately relinquish any special privileges we have; we must not
1505      * be allowed to read any capture files the user running TShark
1506      * can't open.
1507      */
1508     relinquish_special_privs_perm();
1509     print_current_user();
1510
1511     if (cf_open(&cfile, cf_name, FALSE, &err) != CF_OK) {
1512       epan_cleanup();
1513       exit(2);
1514     }
1515
1516     /* Set timestamp precision; there should arguably be a command-line
1517        option to let the user set this. */
1518     switch(wtap_file_tsprecision(cfile.wth)) {
1519     case(WTAP_FILE_TSPREC_SEC):
1520       timestamp_set_precision(TS_PREC_AUTO_SEC);
1521       break;
1522     case(WTAP_FILE_TSPREC_DSEC):
1523       timestamp_set_precision(TS_PREC_AUTO_DSEC);
1524       break;
1525     case(WTAP_FILE_TSPREC_CSEC):
1526       timestamp_set_precision(TS_PREC_AUTO_CSEC);
1527       break;
1528     case(WTAP_FILE_TSPREC_MSEC):
1529       timestamp_set_precision(TS_PREC_AUTO_MSEC);
1530       break;
1531     case(WTAP_FILE_TSPREC_USEC):
1532       timestamp_set_precision(TS_PREC_AUTO_USEC);
1533       break;
1534     case(WTAP_FILE_TSPREC_NSEC):
1535       timestamp_set_precision(TS_PREC_AUTO_NSEC);
1536       break;
1537     default:
1538       g_assert_not_reached();
1539     }
1540
1541     /* Process the packets in the file */
1542 #ifdef HAVE_LIBPCAP
1543     err = load_cap_file(&cfile, capture_opts.save_file, out_file_type,
1544         capture_opts.has_autostop_packets ? capture_opts.autostop_packets : 0,
1545         capture_opts.has_autostop_filesize ? capture_opts.autostop_filesize : 0);
1546 #else
1547     err = load_cap_file(&cfile, NULL, out_file_type, 0, 0);
1548 #endif
1549     if (err != 0) {
1550       epan_cleanup();
1551       exit(2);
1552     }
1553     cf_name[0] = '\0';
1554   } else {
1555     /* No capture file specified, so we're supposed to do a live capture
1556        (or get a list of link-layer types for a live capture device);
1557        do we have support for live captures? */
1558 #ifdef HAVE_LIBPCAP
1559
1560 #ifdef _WIN32
1561     if (!has_wpcap) {
1562       char *detailed_err;
1563
1564       cmdarg_err("WinPcap couldn't be found.");
1565       detailed_err = cant_load_winpcap_err("TShark");
1566       cmdarg_err_cont("%s", detailed_err);
1567       g_free(detailed_err);
1568       exit(2);
1569     }
1570 #endif
1571
1572     /* trim the interface name and exit if that failed */
1573     if (!capture_opts_trim_iface(&capture_opts,
1574         (prefs->capture_device) ? get_if_name(prefs->capture_device) : NULL)) {
1575         exit(2);
1576     }
1577
1578     /* if requested, list the link layer types and exit */
1579     if (list_link_layer_types) {
1580         status = capture_opts_list_link_layer_types(&capture_opts, FALSE);
1581         exit(status);
1582     }
1583
1584     if (print_packet_info) {
1585       if (!write_preamble(NULL)) {
1586         err = errno;
1587         show_print_file_io_error(err);
1588         return err;
1589       }
1590     } else if (!quiet) {
1591       /*
1592        * We're not printing information for each packet, and the user
1593        * didn't ask us not to print a count of packets as they arrive,
1594        * so print that count so the user knows that packets are arriving.
1595        *
1596        * XXX - what if the user wants to do a live capture, doesn't want
1597        * to save it to a file, doesn't want information printed for each
1598        * packet, does want some "-z" statistic, and wants packet counts
1599        * so they know whether they're seeing any packets?
1600        */
1601       print_packet_counts = TRUE;
1602     }
1603
1604     /* For now, assume libpcap gives microsecond precision. */
1605     timestamp_set_precision(TS_PREC_AUTO_USEC);
1606
1607     capture();
1608
1609     if (print_packet_info) {
1610       if (!write_finale()) {
1611         err = errno;
1612         show_print_file_io_error(err);
1613       }
1614     }
1615 #else
1616     /* No - complain. */
1617     cmdarg_err("This version of TShark was not built with support for capturing packets.");
1618     exit(2);
1619 #endif
1620   }
1621
1622   draw_tap_listeners(TRUE);
1623   funnel_dump_all_text_windows();
1624   epan_cleanup();
1625
1626   output_fields_free(output_fields);
1627   output_fields = NULL;
1628
1629   return 0;
1630 }
1631
1632 /*#define USE_BROKEN_G_MAIN_LOOP*/
1633
1634 #ifdef USE_BROKEN_G_MAIN_LOOP
1635   GMainLoop *loop;
1636 #else
1637   gboolean loop_running = FALSE;
1638 #endif
1639   guint32 packet_count = 0;
1640
1641
1642 /* XXX - move to the right position / file */
1643 /* read from a pipe (callback) */
1644 typedef gboolean (*pipe_input_cb_t) (gint source, gpointer user_data);
1645
1646 typedef struct pipe_input_tag {
1647     gint                source;
1648     gpointer            user_data;
1649     int                 *child_process;
1650     pipe_input_cb_t     input_cb;
1651     guint               pipe_input_id;
1652 #ifdef _WIN32
1653     GStaticMutex                callback_running;
1654 #endif
1655 } pipe_input_t;
1656
1657 static pipe_input_t pipe_input;
1658
1659 #ifdef _WIN32
1660 /* The timer has expired, see if there's stuff to read from the pipe,
1661    if so, do the callback */
1662 static gint
1663 pipe_timer_cb(gpointer data)
1664 {
1665   HANDLE handle;
1666   DWORD avail = 0;
1667   gboolean result, result1;
1668   DWORD childstatus;
1669   pipe_input_t *pipe_input = data;
1670   gint iterations = 0;
1671
1672
1673   g_static_mutex_lock (&pipe_input->callback_running);
1674
1675   /* try to read data from the pipe only 5 times, to avoid blocking */
1676   while(iterations < 5) {
1677           /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: new iteration");*/
1678
1679           /* Oddly enough although Named pipes don't work on win9x,
1680                  PeekNamedPipe does !!! */
1681           handle = (HANDLE) _get_osfhandle (pipe_input->source);
1682           result = PeekNamedPipe(handle, NULL, 0, NULL, &avail, NULL);
1683
1684           /* Get the child process exit status */
1685           result1 = GetExitCodeProcess((HANDLE)*(pipe_input->child_process),
1686                                                                    &childstatus);
1687
1688           /* If the Peek returned an error, or there are bytes to be read
1689                  or the childwatcher thread has terminated then call the normal
1690                  callback */
1691           if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
1692
1693                 /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: data avail");*/
1694
1695                 /* And call the real handler */
1696                 if (!pipe_input->input_cb(pipe_input->source, pipe_input->user_data)) {
1697                         g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
1698                         /* pipe closed, return false so that the timer is stopped */
1699                         g_static_mutex_unlock (&pipe_input->callback_running);
1700                         return FALSE;
1701                 }
1702           }
1703           else {
1704                 /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: no data avail");*/
1705                 /* No data, stop now */
1706                 break;
1707           }
1708
1709           iterations++;
1710   }
1711
1712         /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: finished with iterations: %u, new timer", iterations);*/
1713
1714         g_static_mutex_unlock (&pipe_input->callback_running);
1715
1716         /* we didn't stopped the timer, so let it run */
1717         return TRUE;
1718 }
1719 #endif
1720
1721
1722 void
1723 pipe_input_set_handler(gint source, gpointer user_data, int *child_process, pipe_input_cb_t input_cb)
1724 {
1725
1726     pipe_input.source                   = source;
1727     pipe_input.child_process            = child_process;
1728     pipe_input.user_data                = user_data;
1729     pipe_input.input_cb                 = input_cb;
1730
1731 #ifdef _WIN32
1732     g_static_mutex_init(&pipe_input.callback_running);
1733     /* Tricky to use pipes in win9x, as no concept of wait.  NT can
1734        do this but that doesn't cover all win32 platforms.  GTK can do
1735        this but doesn't seem to work over processes.  Attempt to do
1736        something similar here, start a timer and check for data on every
1737        timeout. */
1738         /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
1739     pipe_input.pipe_input_id = g_timeout_add(200, pipe_timer_cb, &pipe_input);
1740 #endif
1741 }
1742
1743
1744 #ifdef HAVE_LIBPCAP
1745 static int
1746 capture(void)
1747 {
1748   gboolean ret;
1749 #ifdef USE_TSHARK_SELECT
1750   fd_set readfds;
1751 #endif
1752 #ifndef _WIN32
1753   struct sigaction action, oldaction;
1754 #endif
1755
1756   /*
1757    * XXX - dropping privileges is still required, until code cleanup is done
1758    *
1759    * remove all dependencies to pcap specific code and using only dumpcap is almost done.
1760    * when it's done, we don't need special privileges to run tshark at all,
1761    * therefore we don't need to drop these privileges
1762    * The only thing we might want to keep is a warning if tshark is run as root,
1763    * as it's no longer necessary and potentially dangerous.
1764    *
1765    * THE FOLLOWING IS THE FORMER COMMENT WHICH IS NO LONGER REALLY VALID:
1766    * We've opened the capture device, so we shouldn't need any special
1767    * privileges any more; relinquish those privileges.
1768    *
1769    * XXX - if we have saved set-user-ID support, we should give up those
1770    * privileges immediately, and then reclaim them long enough to get
1771    * a list of network interfaces and to open one, and then give them
1772    * up again, so that stuff we do while processing the argument list,
1773    * reading the user's preferences, loading and starting plugins
1774    * (especially *user* plugins), etc. is done with the user's privileges,
1775    * not special privileges.
1776    */
1777   relinquish_special_privs_perm();
1778   print_current_user();
1779
1780   /* Initialize all data structures used for dissection. */
1781   init_dissection();
1782
1783 #ifdef _WIN32
1784   /* Catch a CTRL+C event and, if we get it, clean up and exit. */
1785   SetConsoleCtrlHandler(capture_cleanup, TRUE);
1786 #else /* _WIN32 */
1787   /* Catch SIGINT and SIGTERM and, if we get either of them, clean up
1788      and exit. */
1789   action.sa_handler = capture_cleanup;
1790   action.sa_flags = 0;
1791   sigemptyset(&action.sa_mask);
1792   sigaction(SIGTERM, &action, NULL);
1793   sigaction(SIGINT, &action, NULL);
1794   sigaction(SIGHUP, NULL, &oldaction);
1795   if (oldaction.sa_handler == SIG_DFL)
1796     sigaction(SIGHUP, &action, NULL);
1797
1798 #ifdef SIGINFO
1799   /* Catch SIGINFO and, if we get it and we're capturing to a file in
1800      quiet mode, report the number of packets we've captured. */
1801   action.sa_handler = report_counts_siginfo;
1802   action.sa_flags = 0;
1803   sigemptyset(&action.sa_mask);
1804   sigaction(SIGINFO, &action, NULL);
1805 #endif /* SIGINFO */
1806 #endif /* _WIN32 */
1807
1808   capture_opts.state = CAPTURE_PREPARING;
1809
1810   /* Let the user know what interface was chosen. */
1811   capture_opts.iface_descr = get_interface_descriptive_name(capture_opts.iface);
1812   fprintf(stderr, "Capturing on %s\n", capture_opts.iface_descr);
1813
1814   ret = sync_pipe_start(&capture_opts);
1815
1816   if (!ret)
1817     return FALSE;
1818
1819     /* the actual capture loop
1820      *
1821      * XXX - glib doesn't seem to provide any event based loop handling.
1822      *
1823      * XXX - for whatever reason,
1824      * calling g_main_loop_new() ends up in 100% cpu load.
1825      *
1826      * But that doesn't matter: in UNIX we can use select() to find an input
1827      * source with something to do.
1828      *
1829      * But that doesn't matter because we're in a CLI (that doesn't need to
1830      * update a GUI or something at the same time) so it's OK if we block
1831      * trying to read from the pipe.
1832      *
1833      * So all the stuff in USE_TSHARK_SELECT could be removed unless I'm
1834      * wrong (but I leave it there in case I am...).
1835      */
1836
1837 #ifdef USE_TSHARK_SELECT
1838   FD_ZERO(&readfds);
1839   FD_SET(pipe_input.source, &readfds);
1840 #endif
1841
1842   loop_running = TRUE;
1843
1844   while (loop_running)
1845   {
1846 #ifdef USE_TSHARK_SELECT
1847     ret = select(pipe_input.source+1, &readfds, NULL, NULL, NULL);
1848
1849     if (ret == -1)
1850     {
1851       perror("select()");
1852       return TRUE;
1853     } else if (ret == 1) {
1854 #endif
1855       /* Call the real handler */
1856       if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
1857         g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
1858         return FALSE;
1859       }
1860 #ifdef USE_TSHARK_SELECT
1861     }
1862 #endif
1863   }
1864
1865   return TRUE;
1866 }
1867
1868
1869 /* XXX - move the call to main_window_update() out of capture_sync.c */
1870 /* dummy for capture_sync.c to make linker happy */
1871 void main_window_update(void)
1872 {
1873 }
1874
1875 /* XXX - move the call to simple_dialog() out of capture_sync.c */
1876 #include "simple_dialog.h"
1877
1878 /* capture_sync.c want's to tell us an error */
1879 gpointer simple_dialog(ESD_TYPE_E type _U_, gint btn_mask _U_,
1880                                            const gchar *msg_format, ...)
1881 {
1882         va_list ap;
1883
1884         /* XXX - do we need to display buttons and alike? */
1885         va_start(ap, msg_format);
1886         fprintf(stderr, "tshark: ");
1887         vfprintf(stderr, msg_format, ap);
1888         fprintf(stderr, "\n");
1889         va_end(ap);
1890
1891         return NULL;
1892 }
1893
1894
1895 /* capture child detected an error */
1896 void
1897 capture_input_error_message(capture_options *capture_opts _U_, char *error_msg, char *secondary_error_msg)
1898 {
1899         cmdarg_err("%s", error_msg);
1900         cmdarg_err_cont("%s", secondary_error_msg);
1901 }
1902
1903
1904 /* capture child detected an capture filter related error */
1905 void
1906 capture_input_cfilter_error_message(capture_options *capture_opts, char *error_message)
1907 {
1908     dfilter_t   *rfcode = NULL;
1909
1910
1911     if (dfilter_compile(capture_opts->cfilter, &rfcode) && rfcode != NULL) {
1912       cmdarg_err(
1913         "Invalid capture filter: \"%s\"!\n"
1914         "\n"
1915         "That string looks like a valid display filter; however, it isn't a valid\n"
1916         "capture filter (%s).\n"
1917         "\n"
1918         "Note that display filters and capture filters don't have the same syntax,\n"
1919         "so you can't use most display filter expressions as capture filters.\n"
1920         "\n"
1921         "See the User's Guide for a description of the capture filter syntax.",
1922         capture_opts->cfilter, error_message);
1923       dfilter_free(rfcode);
1924     } else {
1925       cmdarg_err(
1926         "Invalid capture filter: \"%s\"!\n"
1927         "\n"
1928         "That string isn't a valid capture filter (%s).\n"
1929         "See the User's Guide for a description of the capture filter syntax.",
1930         capture_opts->cfilter, error_message);
1931     }
1932 }
1933
1934
1935 /* capture child tells us we have a new (or the first) capture file */
1936 gboolean
1937 capture_input_new_file(capture_options *capture_opts, gchar *new_file)
1938 {
1939   gboolean is_tempfile;
1940   int  err;
1941
1942
1943   if(capture_opts->state == CAPTURE_PREPARING) {
1944     g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started!");
1945   }
1946   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
1947
1948   g_assert(capture_opts->state == CAPTURE_PREPARING || capture_opts->state == CAPTURE_RUNNING);
1949
1950   capture_opts->cf = &cfile;
1951
1952   /* free the old filename */
1953   if(capture_opts->save_file != NULL) {
1954     /* we start a new capture file, close the old one (if we had one before) */
1955     if( ((capture_file *) capture_opts->cf)->state != FILE_CLOSED) {
1956                 if(capture_opts->cf != NULL && ((capture_file *) capture_opts->cf)->wth != NULL) {
1957                         wtap_close(((capture_file *) capture_opts->cf)->wth);
1958                 }
1959     }
1960     g_free(capture_opts->save_file);
1961     is_tempfile = FALSE;
1962   } else {
1963     /* we didn't had a save_file before, must be a tempfile */
1964     is_tempfile = TRUE;
1965   }
1966
1967   /* save the new filename */
1968   capture_opts->save_file = g_strdup(new_file);
1969
1970   /* if we are in real-time mode, open the new file now */
1971   if(do_dissection) {
1972     /* Attempt to open the capture file and set up to read from it. */
1973     switch(cf_open(capture_opts->cf, capture_opts->save_file, is_tempfile, &err)) {
1974     case CF_OK:
1975       break;
1976     case CF_ERROR:
1977       /* Don't unlink (delete) the save file - leave it around,
1978          for debugging purposes. */
1979       g_free(capture_opts->save_file);
1980       capture_opts->save_file = NULL;
1981       return FALSE;
1982       break;
1983     }
1984   }
1985
1986   capture_opts->state = CAPTURE_RUNNING;
1987
1988   return TRUE;
1989 }
1990
1991
1992 /* capture child tells us we have new packets to read */
1993 void
1994 capture_input_new_packets(capture_options *capture_opts, int to_read)
1995 {
1996   gboolean     ret;
1997   int          err;
1998   gchar        *err_info;
1999   gint64       data_offset;
2000   capture_file *cf = capture_opts->cf;
2001
2002
2003 #ifdef SIGINFO
2004   /*
2005    * Prevent a SIGINFO handler from writing to stdout while we're
2006    * doing so; instead, have it just set a flag telling us to print
2007    * that information when we're done.
2008    */
2009   infodelay = TRUE;
2010 #endif /* SIGINFO */
2011
2012   if(do_dissection) {
2013     while (to_read-- && cf->wth) {
2014       ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
2015       if(ret == FALSE) {
2016         /* read from file failed, tell the capture child to stop */
2017         sync_pipe_stop(capture_opts);
2018         wtap_close(cf->wth);
2019         cf->wth = NULL;
2020       } else {
2021         ret = process_packet(cf, data_offset, wtap_phdr(cf->wth),
2022                              wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth));
2023       }
2024       if (ret != FALSE) {
2025         /* packet sucessfully read and gone through the "Read Filter" */
2026         packet_count++;
2027       }
2028     }
2029   } else {
2030     /*
2031      * Dumpcap's doing all the work; we're not doing any dissection.
2032      * Count all the packets it wrote.
2033      */
2034     packet_count += to_read;
2035   }
2036
2037   if (print_packet_counts) {
2038       /* We're printing packet counts. */
2039       if (packet_count != 0) {
2040         fprintf(stderr, "\r%u ", packet_count);
2041         /* stderr could be line buffered */
2042         fflush(stderr);
2043       }
2044   }
2045
2046 #ifdef SIGINFO
2047   /*
2048    * Allow SIGINFO handlers to write.
2049    */
2050   infodelay = FALSE;
2051
2052   /*
2053    * If a SIGINFO handler asked us to write out capture counts, do so.
2054    */
2055   if (infoprint)
2056     report_counts();
2057 #endif /* SIGINFO */
2058 }
2059
2060 static void
2061 report_counts(void)
2062 {
2063   if (!print_packet_counts) {
2064     /* Report the count only if we aren't printing a packet count
2065        as packets arrive. */
2066     fprintf(stderr, "%u packet%s captured\n", packet_count,
2067             plurality(packet_count, "", "s"));
2068   }
2069 #ifdef SIGINFO
2070   infoprint = FALSE; /* we just reported it */
2071 #endif /* SIGINFO */
2072 }
2073
2074 #ifdef SIGINFO
2075 static void
2076 report_counts_siginfo(int signum _U_)
2077 {
2078   int sav_errno = errno;
2079   /* If we've been told to delay printing, just set a flag asking
2080      that we print counts (if we're supposed to), otherwise print
2081      the count of packets captured (if we're supposed to). */
2082   if (infodelay)
2083     infoprint = TRUE;
2084   else
2085     report_counts();
2086   errno = sav_errno;
2087 }
2088 #endif /* SIGINFO */
2089
2090
2091 /* capture child detected any packet drops? */
2092 void
2093 capture_input_drops(capture_options *capture_opts _U_, int dropped)
2094 {
2095         if (print_packet_counts) {
2096         /* We're printing packet counts to stderr.
2097            Send a newline so that we move to the line after the packet count. */
2098           fprintf(stderr, "\n");
2099         }
2100
2101         if(dropped != 0) {
2102                 /* We're printing packet counts to stderr.
2103                    Send a newline so that we move to the line after the packet count. */
2104                   fprintf(stderr, "%u packet%s dropped\n", dropped, plurality(dropped, "", "s"));
2105         }
2106 }
2107
2108
2109 /* capture child closed its side of the pipe, do the required cleanup */
2110 void
2111 capture_input_closed(capture_options *capture_opts)
2112 {
2113   report_counts();
2114
2115   if(capture_opts->cf != NULL && ((capture_file *) capture_opts->cf)->wth != NULL) {
2116     wtap_close(((capture_file *) capture_opts->cf)->wth);
2117   }
2118 #ifdef USE_BROKEN_G_MAIN_LOOP
2119   /*g_main_loop_quit(loop);*/
2120   g_main_quit(loop);
2121 #else
2122   loop_running = FALSE;
2123 #endif
2124 }
2125
2126
2127
2128
2129 #ifdef _WIN32
2130 static BOOL WINAPI
2131 capture_cleanup(DWORD ctrltype _U_)
2132 {
2133   /* CTRL_C_EVENT is sort of like SIGINT, CTRL_BREAK_EVENT is unique to
2134      Windows, CTRL_CLOSE_EVENT is sort of like SIGHUP, CTRL_LOGOFF_EVENT
2135      is also sort of like SIGHUP, and CTRL_SHUTDOWN_EVENT is sort of
2136      like SIGTERM at least when the machine's shutting down.
2137
2138      For now, we handle them all as indications that we should clean up
2139      and quit, just as we handle SIGINT, SIGHUP, and SIGTERM in that
2140      way on UNIX.
2141
2142      However, as handlers run in a new thread, we can't just longjmp
2143      out; we have to set "ld.go" to FALSE, and must return TRUE so that
2144      no other handler - such as one that would terminate the process -
2145      gets called.
2146
2147      XXX - for some reason, typing ^C to TShark, if you run this in
2148      a Cygwin console window in at least some versions of Cygwin,
2149      causes TShark to terminate immediately; this routine gets
2150      called, but the main loop doesn't get a chance to run and
2151      exit cleanly, at least if this is compiled with Microsoft Visual
2152      C++ (i.e., it's a property of the Cygwin console window or Bash;
2153      it happens if TShark is not built with Cygwin - for all I know,
2154      building it with Cygwin may make the problem go away). */
2155
2156   /* tell the capture child to stop */
2157   sync_pipe_stop(&capture_opts);
2158
2159   /* don't stop our own loop already here, otherwise status messages and
2160    * cleanup wouldn't be done properly. The child will indicate the stop of
2161    * everything by calling capture_input_closed() later */
2162
2163   return TRUE;
2164 }
2165 #else
2166 static void
2167 capture_cleanup(int signum _U_)
2168 {
2169   /* tell the capture child to stop */
2170   sync_pipe_stop(&capture_opts);
2171 }
2172 #endif /* _WIN32 */
2173 #endif /* HAVE_LIBPCAP */
2174
2175 static int
2176 load_cap_file(capture_file *cf, char *save_file, int out_file_type,
2177     int max_packet_count, gint64 max_byte_count)
2178 {
2179   gint         linktype;
2180   int          snapshot_length;
2181   wtap_dumper *pdh;
2182   int          err;
2183   gchar        *err_info;
2184   gint64       data_offset;
2185   char         *save_file_string = NULL;
2186
2187   linktype = wtap_file_encap(cf->wth);
2188   if (save_file != NULL) {
2189     /* Get a string that describes what we're writing to */
2190     save_file_string = output_file_description(save_file);
2191
2192     /* Set up to write to the capture file. */
2193     snapshot_length = wtap_snapshot_length(cf->wth);
2194     if (snapshot_length == 0) {
2195       /* Snapshot length of input file not known. */
2196       snapshot_length = WTAP_MAX_PACKET_SIZE;
2197     }
2198     pdh = wtap_dump_open(save_file, out_file_type, linktype, snapshot_length,
2199                          FALSE /* compressed */, &err);
2200
2201     if (pdh == NULL) {
2202       /* We couldn't set up to write to the capture file. */
2203       switch (err) {
2204
2205       case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
2206         cmdarg_err("Capture files can't be written in that format.");
2207         break;
2208
2209       case WTAP_ERR_UNSUPPORTED_ENCAP:
2210       case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
2211         cmdarg_err("The capture file being read can't be written in "
2212           "that format.");
2213         break;
2214
2215       case WTAP_ERR_CANT_OPEN:
2216         cmdarg_err("The %s couldn't be created for some "
2217           "unknown reason.", save_file_string);
2218         break;
2219
2220       case WTAP_ERR_SHORT_WRITE:
2221         cmdarg_err("A full header couldn't be written to the %s.",
2222                    save_file_string);
2223         break;
2224
2225       default:
2226         cmdarg_err("The %s could not be created: %s.", save_file_string,
2227                    wtap_strerror(err));
2228         break;
2229       }
2230       goto out;
2231     }
2232   } else {
2233     if (print_packet_info) {
2234       if (!write_preamble(cf)) {
2235         err = errno;
2236         show_print_file_io_error(err);
2237         goto out;
2238       }
2239     }
2240     pdh = NULL;
2241   }
2242   while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
2243     if (process_packet(cf, data_offset, wtap_phdr(cf->wth),
2244                        wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth))) {
2245       /* Either there's no read filtering or this packet passed the
2246          filter, so, if we're writing to a capture file, write
2247          this packet out. */
2248       if (pdh != NULL) {
2249         if (!wtap_dump(pdh, wtap_phdr(cf->wth),
2250                        wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
2251                        &err)) {
2252           /* Error writing to a capture file */
2253           show_capture_file_io_error(save_file, err, FALSE);
2254           wtap_dump_close(pdh, &err);
2255           exit(2);
2256         }
2257       }
2258       /* Stop reading if we have the maximum number of packets;
2259        * When the -c option has not been used, max_packet_count
2260        * starts at 0, which practically means, never stop reading.
2261        * (unless we roll over max_packet_count ?)
2262        */
2263       if( (--max_packet_count == 0) || (max_byte_count != 0 && data_offset >= max_byte_count)) {
2264         err = 0; /* This is not an error */
2265         break;
2266       }
2267     }
2268   }
2269   if (err != 0) {
2270     /* Print a message noting that the read failed somewhere along the line. */
2271     switch (err) {
2272
2273     case WTAP_ERR_UNSUPPORTED_ENCAP:
2274       cmdarg_err("\"%s\" has a packet with a network type that TShark doesn't support.\n(%s)",
2275                  cf->filename, err_info);
2276       break;
2277
2278     case WTAP_ERR_CANT_READ:
2279       cmdarg_err("An attempt to read from \"%s\" failed for some unknown reason.",
2280                  cf->filename);
2281       break;
2282
2283     case WTAP_ERR_SHORT_READ:
2284       cmdarg_err("\"%s\" appears to have been cut short in the middle of a packet.",
2285                  cf->filename);
2286       break;
2287
2288     case WTAP_ERR_BAD_RECORD:
2289       cmdarg_err("\"%s\" appears to be damaged or corrupt.\n(%s)",
2290                  cf->filename, err_info);
2291       break;
2292
2293     default:
2294       cmdarg_err("An error occurred while reading \"%s\": %s.",
2295                  cf->filename, wtap_strerror(err));
2296       break;
2297     }
2298     if (save_file != NULL) {
2299       /* Now close the capture file. */
2300       if (!wtap_dump_close(pdh, &err))
2301         show_capture_file_io_error(save_file, err, TRUE);
2302     }
2303   } else {
2304     if (save_file != NULL) {
2305       /* Now close the capture file. */
2306       if (!wtap_dump_close(pdh, &err))
2307         show_capture_file_io_error(save_file, err, TRUE);
2308     } else {
2309       if (print_packet_info) {
2310         if (!write_finale()) {
2311           err = errno;
2312           show_print_file_io_error(err);
2313         }
2314       }
2315     }
2316   }
2317
2318 out:
2319   wtap_close(cf->wth);
2320   cf->wth = NULL;
2321
2322   if (save_file_string != NULL)
2323     g_free(save_file_string);
2324
2325   return err;
2326 }
2327
2328 static void
2329 fill_in_fdata(frame_data *fdata, capture_file *cf,
2330               const struct wtap_pkthdr *phdr, gint64 offset)
2331 {
2332   fdata->next = NULL;
2333   fdata->prev = NULL;
2334   fdata->pfd = NULL;
2335   fdata->num = cf->count;
2336   fdata->pkt_len = phdr->len;
2337   cum_bytes += phdr->len;
2338   fdata->cum_bytes  = cum_bytes;
2339   fdata->cap_len = phdr->caplen;
2340   fdata->file_off = offset;
2341   fdata->lnk_t = phdr->pkt_encap;
2342   fdata->abs_ts.secs = phdr->ts.secs;
2343   fdata->abs_ts.nsecs = phdr->ts.nsecs;
2344   fdata->flags.passed_dfilter = 0;
2345   fdata->flags.encoding = CHAR_ASCII;
2346   fdata->flags.visited = 0;
2347   fdata->flags.marked = 0;
2348   fdata->flags.ref_time = 0;
2349   fdata->color_filter = NULL;
2350
2351   /* If we don't have the time stamp of the first packet in the
2352      capture, it's because this is the first packet.  Save the time
2353      stamp of this packet as the time stamp of the first packet. */
2354   if (nstime_is_unset(&first_ts)) {
2355     first_ts = fdata->abs_ts;
2356   }
2357
2358   /* If we don't have the time stamp of the previous captured packet,
2359      it's because this is the first packet.  Save the time
2360      stamp of this packet as the time stamp of the previous captured
2361      packet. */
2362   if (nstime_is_unset(&prev_cap_ts)) {
2363     prev_cap_ts = fdata->abs_ts;
2364   }
2365
2366   /* Get the time elapsed between the first packet and this packet. */
2367   nstime_delta(&fdata->rel_ts, &fdata->abs_ts, &first_ts);
2368
2369   /* If it's greater than the current elapsed time, set the elapsed time
2370      to it (we check for "greater than" so as not to be confused by
2371      time moving backwards). */
2372   if ((gint32)cf->elapsed_time.secs < fdata->rel_ts.secs
2373         || ((gint32)cf->elapsed_time.secs == fdata->rel_ts.secs && (gint32)cf->elapsed_time.nsecs < fdata->rel_ts.nsecs)) {
2374     cf->elapsed_time = fdata->rel_ts;
2375   }
2376
2377   /* Get the time elapsed between the previous displayed packet and
2378      this packet. */
2379   if (nstime_is_unset(&prev_dis_ts))
2380     nstime_set_zero(&fdata->del_dis_ts);
2381   else
2382     nstime_delta(&fdata->del_dis_ts, &fdata->abs_ts, &prev_dis_ts);
2383
2384   /* Get the time elapsed between the previous captured packet and
2385      this packet. */
2386   nstime_delta(&fdata->del_cap_ts, &fdata->abs_ts, &prev_cap_ts);
2387   prev_cap_ts = fdata->abs_ts;
2388 }
2389
2390 /* Free up all data attached to a "frame_data" structure. */
2391 static void
2392 clear_fdata(frame_data *fdata)
2393 {
2394   if (fdata->pfd)
2395     g_slist_free(fdata->pfd);
2396 }
2397
2398 static gboolean
2399 process_packet(capture_file *cf, gint64 offset, const struct wtap_pkthdr *whdr,
2400                union wtap_pseudo_header *pseudo_header, const guchar *pd)
2401 {
2402   frame_data fdata;
2403   gboolean create_proto_tree;
2404   epan_dissect_t *edt;
2405   gboolean passed;
2406
2407   /* Count this packet. */
2408   cf->count++;
2409
2410   /* If we're going to print packet information, or we're going to
2411      run a read filter, or we're going to process taps, set up to
2412      do a dissection and do so. */
2413   if (do_dissection) {
2414     fill_in_fdata(&fdata, cf, whdr, offset);
2415
2416     if (print_packet_info) {
2417       /* Grab any resolved addresses */
2418
2419       if (g_resolv_flags) {
2420         host_name_lookup_process(NULL);
2421       }
2422     }
2423
2424     passed = TRUE;
2425     if (cf->rfcode || verbose || num_tap_filters!=0)
2426       create_proto_tree = TRUE;
2427     else
2428       create_proto_tree = FALSE;
2429     /* The protocol tree will be "visible", i.e., printed, only if we're
2430        printing packet details, which is true if we're printing stuff
2431        ("print_packet_info" is true) and we're in verbose mode ("verbose"
2432        is true). */
2433     edt = epan_dissect_new(create_proto_tree, print_packet_info && verbose);
2434
2435     /* If we're running a read filter, prime the epan_dissect_t with that
2436        filter. */
2437     if (cf->rfcode)
2438       epan_dissect_prime_dfilter(edt, cf->rfcode);
2439
2440     tap_queue_init(edt);
2441
2442     /* We only need the columns if we're printing packet info but we're
2443        *not* verbose; in verbose mode, we print the protocol tree, not
2444        the protocol summary. */
2445     epan_dissect_run(edt, pseudo_header, pd, &fdata,
2446                      (print_packet_info && !verbose) ? &cf->cinfo : NULL);
2447
2448     tap_push_tapped_queue(edt);
2449
2450     /* Run the read filter if we have one. */
2451     if (cf->rfcode)
2452       passed = dfilter_apply_edt(cf->rfcode, edt);
2453     else
2454       passed = TRUE;
2455   } else {
2456     /* We're not running a display filter and we're not printing any
2457        packet information, so we don't need to do a dissection, and all
2458        packets are processed. */
2459     edt = NULL;
2460     passed = TRUE;
2461   }
2462
2463   if (passed) {
2464     /* Keep the time of the current packet if the packet passed
2465        the read filter so that the delta time since last displayed
2466        packet can be calculated */
2467     prev_dis_ts = fdata.abs_ts;
2468
2469     /* Process this packet. */
2470     if (print_packet_info) {
2471       /* We're printing packet information; print the information for
2472          this packet. */
2473       print_packet(cf, edt);
2474
2475       /* The ANSI C standard does not appear to *require* that a line-buffered
2476          stream be flushed to the host environment whenever a newline is
2477          written, it just says that, on such a stream, characters "are
2478          intended to be transmitted to or from the host environment as a
2479          block when a new-line character is encountered".
2480
2481          The Visual C++ 6.0 C implementation doesn't do what is intended;
2482          even if you set a stream to be line-buffered, it still doesn't
2483          flush the buffer at the end of every line.
2484
2485          So, if the "-l" flag was specified, we flush the standard output
2486          at the end of a packet.  This will do the right thing if we're
2487          printing packet summary lines, and, as we print the entire protocol
2488          tree for a single packet without waiting for anything to happen,
2489          it should be as good as line-buffered mode if we're printing
2490          protocol trees.  (The whole reason for the "-l" flag in either
2491          tcpdump or TShark is to allow the output of a live capture to
2492          be piped to a program or script and to have that script see the
2493          information for the packet as soon as it's printed, rather than
2494          having to wait until a standard I/O buffer fills up. */
2495       if (line_buffered)
2496         fflush(stdout);
2497
2498       if (ferror(stdout)) {
2499         show_print_file_io_error(errno);
2500         exit(2);
2501       }
2502     }
2503   }
2504
2505   if (do_dissection) {
2506     epan_dissect_free(edt);
2507     clear_fdata(&fdata);
2508   }
2509   return passed;
2510 }
2511
2512 static void
2513 show_capture_file_io_error(const char *fname, int err, gboolean is_close)
2514 {
2515   char *save_file_string;
2516
2517   save_file_string = output_file_description(fname);
2518
2519   switch (err) {
2520
2521   case ENOSPC:
2522     cmdarg_err("Not all the packets could be written to the %s because there is "
2523                "no space left on the file system.",
2524                save_file_string);
2525     break;
2526
2527 #ifdef EDQUOT
2528   case EDQUOT:
2529     cmdarg_err("Not all the packets could be written to the %s because you are "
2530                "too close to, or over your disk quota.",
2531                save_file_string);
2532   break;
2533 #endif
2534
2535   case WTAP_ERR_CANT_CLOSE:
2536     cmdarg_err("The %s couldn't be closed for some unknown reason.",
2537                save_file_string);
2538     break;
2539
2540   case WTAP_ERR_SHORT_WRITE:
2541     cmdarg_err("Not all the packets could be written to the %s.",
2542                save_file_string);
2543     break;
2544
2545   default:
2546     if (is_close) {
2547       cmdarg_err("The %s could not be closed: %s.", save_file_string,
2548                  wtap_strerror(err));
2549     } else {
2550       cmdarg_err("An error occurred while writing to the %s: %s.",
2551                  save_file_string, wtap_strerror(err));
2552     }
2553     break;
2554   }
2555   g_free(save_file_string);
2556 }
2557
2558 static gboolean
2559 write_preamble(capture_file *cf)
2560 {
2561   switch (output_action) {
2562
2563   case WRITE_TEXT:
2564     return print_preamble(print_stream, cf ? cf->filename : NULL);
2565
2566   case WRITE_XML:
2567     if (verbose)
2568       write_pdml_preamble(stdout);
2569     else
2570       write_psml_preamble(stdout);
2571     return !ferror(stdout);
2572
2573   case WRITE_FIELDS:
2574     write_fields_preamble(output_fields, stdout);
2575     return !ferror(stdout);
2576
2577   default:
2578     g_assert_not_reached();
2579     return FALSE;
2580   }
2581 }
2582
2583 static char *
2584 get_line_buf(size_t len)
2585 {
2586   static char *line_bufp = NULL;
2587   static size_t line_buf_len = 256;
2588   size_t new_line_buf_len;
2589
2590   for (new_line_buf_len = line_buf_len; len > new_line_buf_len;
2591        new_line_buf_len *= 2)
2592     ;
2593   if (line_bufp == NULL) {
2594     line_buf_len = new_line_buf_len;
2595     line_bufp = g_malloc(line_buf_len + 1);
2596   } else {
2597     if (new_line_buf_len > line_buf_len) {
2598       line_buf_len = new_line_buf_len;
2599       line_bufp = g_realloc(line_bufp, line_buf_len + 1);
2600     }
2601   }
2602   return line_bufp;
2603 }
2604
2605 static gboolean
2606 print_columns(capture_file *cf)
2607 {
2608   char *line_bufp;
2609   int i;
2610   size_t buf_offset;
2611   size_t column_len;
2612
2613   line_bufp = get_line_buf(256);
2614   buf_offset = 0;
2615   *line_bufp = '\0';
2616   for (i = 0; i < cf->cinfo.num_cols; i++) {
2617     switch (cf->cinfo.col_fmt[i]) {
2618     case COL_NUMBER:
2619 #ifdef HAVE_LIBPCAP
2620       /*
2621        * Don't print this if we're doing a live capture from a network
2622        * interface - if we're doing a live capture, you won't be
2623        * able to look at the capture in the future (it's not being
2624        * saved anywhere), so the frame numbers are unlikely to be
2625        * useful.
2626        *
2627        * (XXX - it might be nice to be able to save and print at
2628        * the same time, sort of like an "Update list of packets
2629        * in real time" capture in Wireshark.)
2630        */
2631       if (capture_opts.iface != NULL)
2632         continue;
2633 #endif
2634       column_len = strlen(cf->cinfo.col_data[i]);
2635       if (column_len < 3)
2636         column_len = 3;
2637       line_bufp = get_line_buf(buf_offset + column_len);
2638       sprintf(line_bufp + buf_offset, "%3s", cf->cinfo.col_data[i]);
2639       break;
2640
2641     case COL_CLS_TIME:
2642     case COL_REL_TIME:
2643     case COL_ABS_TIME:
2644     case COL_ABS_DATE_TIME: /* XXX - wider */
2645       column_len = strlen(cf->cinfo.col_data[i]);
2646       if (column_len < 10)
2647         column_len = 10;
2648       line_bufp = get_line_buf(buf_offset + column_len);
2649       sprintf(line_bufp + buf_offset, "%10s", cf->cinfo.col_data[i]);
2650       break;
2651
2652     case COL_DEF_SRC:
2653     case COL_RES_SRC:
2654     case COL_UNRES_SRC:
2655     case COL_DEF_DL_SRC:
2656     case COL_RES_DL_SRC:
2657     case COL_UNRES_DL_SRC:
2658     case COL_DEF_NET_SRC:
2659     case COL_RES_NET_SRC:
2660     case COL_UNRES_NET_SRC:
2661       column_len = strlen(cf->cinfo.col_data[i]);
2662       if (column_len < 12)
2663         column_len = 12;
2664       line_bufp = get_line_buf(buf_offset + column_len);
2665       sprintf(line_bufp + buf_offset, "%12s", cf->cinfo.col_data[i]);
2666       break;
2667
2668     case COL_DEF_DST:
2669     case COL_RES_DST:
2670     case COL_UNRES_DST:
2671     case COL_DEF_DL_DST:
2672     case COL_RES_DL_DST:
2673     case COL_UNRES_DL_DST:
2674     case COL_DEF_NET_DST:
2675     case COL_RES_NET_DST:
2676     case COL_UNRES_NET_DST:
2677       column_len = strlen(cf->cinfo.col_data[i]);
2678       if (column_len < 12)
2679         column_len = 12;
2680       line_bufp = get_line_buf(buf_offset + column_len);
2681       sprintf(line_bufp + buf_offset, "%-12s", cf->cinfo.col_data[i]);
2682       break;
2683
2684     default:
2685       column_len = strlen(cf->cinfo.col_data[i]);
2686       line_bufp = get_line_buf(buf_offset + column_len);
2687       strcat(line_bufp + buf_offset, cf->cinfo.col_data[i]);
2688       break;
2689     }
2690     buf_offset += column_len;
2691     if (i != cf->cinfo.num_cols - 1) {
2692       /*
2693        * This isn't the last column, so we need to print a
2694        * separator between this column and the next.
2695        *
2696        * If we printed a network source and are printing a
2697        * network destination of the same type next, separate
2698        * them with "->"; if we printed a network destination
2699        * and are printing a network source of the same type
2700        * next, separate them with "<-"; otherwise separate them
2701        * with a space.
2702        *
2703        * We add enough space to the buffer for " <- " or " -> ",
2704        * even if we're only adding " ".
2705        */
2706       line_bufp = get_line_buf(buf_offset + 4);
2707       switch (cf->cinfo.col_fmt[i]) {
2708
2709       case COL_DEF_SRC:
2710       case COL_RES_SRC:
2711       case COL_UNRES_SRC:
2712         switch (cf->cinfo.col_fmt[i + 1]) {
2713
2714         case COL_DEF_DST:
2715         case COL_RES_DST:
2716         case COL_UNRES_DST:
2717           strcat(line_bufp + buf_offset, " -> ");
2718           buf_offset += 4;
2719           break;
2720
2721         default:
2722           strcat(line_bufp + buf_offset, " ");
2723           buf_offset += 1;
2724           break;
2725         }
2726         break;
2727
2728       case COL_DEF_DL_SRC:
2729       case COL_RES_DL_SRC:
2730       case COL_UNRES_DL_SRC:
2731         switch (cf->cinfo.col_fmt[i + 1]) {
2732
2733         case COL_DEF_DL_DST:
2734         case COL_RES_DL_DST:
2735         case COL_UNRES_DL_DST:
2736           strcat(line_bufp + buf_offset, " -> ");
2737           buf_offset += 4;
2738           break;
2739
2740         default:
2741           strcat(line_bufp + buf_offset, " ");
2742           buf_offset += 1;
2743           break;
2744         }
2745         break;
2746
2747       case COL_DEF_NET_SRC:
2748       case COL_RES_NET_SRC:
2749       case COL_UNRES_NET_SRC:
2750         switch (cf->cinfo.col_fmt[i + 1]) {
2751
2752         case COL_DEF_NET_DST:
2753         case COL_RES_NET_DST:
2754         case COL_UNRES_NET_DST:
2755           strcat(line_bufp + buf_offset, " -> ");
2756           buf_offset += 4;
2757           break;
2758
2759         default:
2760           strcat(line_bufp + buf_offset, " ");
2761           buf_offset += 1;
2762           break;
2763         }
2764         break;
2765
2766       case COL_DEF_DST:
2767       case COL_RES_DST:
2768       case COL_UNRES_DST:
2769         switch (cf->cinfo.col_fmt[i + 1]) {
2770
2771         case COL_DEF_SRC:
2772         case COL_RES_SRC:
2773         case COL_UNRES_SRC:
2774           strcat(line_bufp + buf_offset, " <- ");
2775           buf_offset += 4;
2776           break;
2777
2778         default:
2779           strcat(line_bufp + buf_offset, " ");
2780           buf_offset += 1;
2781           break;
2782         }
2783         break;
2784
2785       case COL_DEF_DL_DST:
2786       case COL_RES_DL_DST:
2787       case COL_UNRES_DL_DST:
2788         switch (cf->cinfo.col_fmt[i + 1]) {
2789
2790         case COL_DEF_DL_SRC:
2791         case COL_RES_DL_SRC:
2792         case COL_UNRES_DL_SRC:
2793           strcat(line_bufp + buf_offset, " <- ");
2794           buf_offset += 4;
2795           break;
2796
2797         default:
2798           strcat(line_bufp + buf_offset, " ");
2799           buf_offset += 1;
2800           break;
2801         }
2802         break;
2803
2804       case COL_DEF_NET_DST:
2805       case COL_RES_NET_DST:
2806       case COL_UNRES_NET_DST:
2807         switch (cf->cinfo.col_fmt[i + 1]) {
2808
2809         case COL_DEF_NET_SRC:
2810         case COL_RES_NET_SRC:
2811         case COL_UNRES_NET_SRC:
2812           strcat(line_bufp + buf_offset, " <- ");
2813           buf_offset += 4;
2814           break;
2815
2816         default:
2817           strcat(line_bufp + buf_offset, " ");
2818           buf_offset += 1;
2819           break;
2820         }
2821         break;
2822
2823       default:
2824         strcat(line_bufp + buf_offset, " ");
2825         buf_offset += 1;
2826         break;
2827       }
2828     }
2829   }
2830   return print_line(print_stream, 0, line_bufp);
2831 }
2832
2833 static gboolean
2834 print_packet(capture_file *cf, epan_dissect_t *edt)
2835 {
2836   print_args_t  print_args;
2837
2838   if (verbose) {
2839     /* Print the information in the protocol tree. */
2840     switch (output_action) {
2841
2842     case WRITE_TEXT:
2843       print_args.to_file = TRUE;
2844       print_args.format = print_format;
2845       print_args.print_summary = !verbose;
2846       print_args.print_hex = verbose && print_hex;
2847       print_args.print_formfeed = FALSE;
2848       print_args.print_dissections = verbose ? print_dissections_expanded : print_dissections_none;
2849
2850       /* init the packet range */
2851       packet_range_init(&print_args.range);
2852
2853       if (!proto_tree_print(&print_args, edt, print_stream))
2854         return FALSE;
2855       if (!print_hex) {
2856         /* "print_hex_data()" will put out a leading blank line, as well
2857          as a trailing one; print one here, to separate the packets,
2858          only if "print_hex_data()" won't be called. */
2859         if (!print_line(print_stream, 0, ""))
2860           return FALSE;
2861       }
2862       break;
2863
2864     case WRITE_XML:
2865       proto_tree_write_pdml(edt, stdout);
2866       printf("\n");
2867       return !ferror(stdout);
2868     case WRITE_FIELDS:
2869       proto_tree_write_fields(output_fields, edt, stdout);
2870       printf("\n");
2871       return !ferror(stdout);
2872     }
2873   } else {
2874     /* Just fill in the columns. */
2875     epan_dissect_fill_in_columns(edt);
2876
2877     /* Now print them. */
2878     switch (output_action) {
2879
2880     case WRITE_TEXT:
2881         if (!print_columns(cf))
2882           return FALSE;
2883         break;
2884
2885     case WRITE_XML:
2886         proto_tree_write_psml(edt, stdout);
2887         return !ferror(stdout);
2888     case WRITE_FIELDS: /*No non-verbose "fields" format */
2889         g_assert_not_reached();
2890         break;
2891     }
2892   }
2893   if (print_hex) {
2894     if (!print_hex_data(print_stream, edt))
2895       return FALSE;
2896     if (!print_line(print_stream, 0, ""))
2897       return FALSE;
2898   }
2899   return TRUE;
2900 }
2901
2902 static gboolean
2903 write_finale(void)
2904 {
2905   switch (output_action) {
2906
2907   case WRITE_TEXT:
2908     return print_finale(print_stream);
2909
2910   case WRITE_XML:
2911     if (verbose)
2912       write_pdml_finale(stdout);
2913     else
2914       write_psml_finale(stdout);
2915     return !ferror(stdout);
2916
2917   case WRITE_FIELDS:
2918     write_fields_finale(output_fields, stdout);
2919     return !ferror(stdout);
2920
2921   default:
2922     g_assert_not_reached();
2923     return FALSE;
2924   }
2925 }
2926
2927 static void
2928 show_print_file_io_error(int err)
2929 {
2930   switch (err) {
2931
2932   case ENOSPC:
2933     cmdarg_err("Not all the packets could be printed because there is "
2934 "no space left on the file system.");
2935     break;
2936
2937 #ifdef EDQUOT
2938   case EDQUOT:
2939     cmdarg_err("Not all the packets could be printed because you are "
2940 "too close to, or over your disk quota.");
2941   break;
2942 #endif
2943
2944   default:
2945     cmdarg_err("An error occurred while printing packets: %s.",
2946       strerror(err));
2947     break;
2948   }
2949 }
2950
2951 static const char *
2952 cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
2953                       int file_type)
2954 {
2955   const char *errmsg;
2956   static char errmsg_errno[1024+1];
2957
2958   if (err < 0) {
2959     /* Wiretap error. */
2960     switch (err) {
2961
2962     case WTAP_ERR_NOT_REGULAR_FILE:
2963       errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
2964       break;
2965
2966     case WTAP_ERR_FILE_UNKNOWN_FORMAT:
2967       /* Seen only when opening a capture file for reading. */
2968       errmsg = "The file \"%s\" isn't a capture file in a format TShark understands.";
2969       break;
2970
2971     case WTAP_ERR_UNSUPPORTED:
2972       /* Seen only when opening a capture file for reading. */
2973       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2974                "The file \"%%s\" isn't a capture file in a format TShark understands.\n"
2975                "(%s)", err_info);
2976       g_free(err_info);
2977       errmsg = errmsg_errno;
2978       break;
2979
2980     case WTAP_ERR_CANT_WRITE_TO_PIPE:
2981       /* Seen only when opening a capture file for writing. */
2982       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2983                  "The file \"%%s\" is a pipe, and %s capture files can't be "
2984                  "written to a pipe.", wtap_file_type_string(file_type));
2985       errmsg = errmsg_errno;
2986       break;
2987
2988     case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
2989       /* Seen only when opening a capture file for writing. */
2990       errmsg = "TShark doesn't support writing capture files in that format.";
2991       break;
2992
2993     case WTAP_ERR_UNSUPPORTED_ENCAP:
2994       if (for_writing)
2995         errmsg = "TShark can't save this capture in that format.";
2996       else {
2997         g_snprintf(errmsg_errno, sizeof(errmsg_errno),
2998                  "The file \"%%s\" is a capture for a network type that TShark doesn't support.\n"
2999                  "(%s)", err_info);
3000         g_free(err_info);
3001         errmsg = errmsg_errno;
3002       }
3003       break;
3004
3005     case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
3006       if (for_writing)
3007         errmsg = "TShark can't save this capture in that format.";
3008       else
3009         errmsg = "The file \"%s\" is a capture for a network type that TShark doesn't support.";
3010       break;
3011
3012     case WTAP_ERR_BAD_RECORD:
3013       /* Seen only when opening a capture file for reading. */
3014       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3015                "The file \"%%s\" appears to be damaged or corrupt.\n"
3016                "(%s)", err_info);
3017       g_free(err_info);
3018       errmsg = errmsg_errno;
3019       break;
3020
3021     case WTAP_ERR_CANT_OPEN:
3022       if (for_writing)
3023         errmsg = "The file \"%s\" could not be created for some unknown reason.";
3024       else
3025         errmsg = "The file \"%s\" could not be opened for some unknown reason.";
3026       break;
3027
3028     case WTAP_ERR_SHORT_READ:
3029       errmsg = "The file \"%s\" appears to have been cut short"
3030                " in the middle of a packet or other data.";
3031       break;
3032
3033     case WTAP_ERR_SHORT_WRITE:
3034       errmsg = "A full header couldn't be written to the file \"%s\".";
3035       break;
3036
3037     default:
3038       g_snprintf(errmsg_errno, sizeof(errmsg_errno),
3039                  "The file \"%%s\" could not be %s: %s.",
3040                  for_writing ? "created" : "opened",
3041                  wtap_strerror(err));
3042       errmsg = errmsg_errno;
3043       break;
3044     }
3045   } else
3046     errmsg = file_open_error_message(err, for_writing);
3047   return errmsg;
3048 }
3049
3050 /*
3051  * Open/create errors are reported with an console message in TShark.
3052  */
3053 static void
3054 open_failure_message(const char *filename, int err, gboolean for_writing)
3055 {
3056   fprintf(stderr, "tshark: ");
3057   fprintf(stderr, file_open_error_message(err, for_writing), filename);
3058   fprintf(stderr, "\n");
3059 }
3060
3061 cf_status_t
3062 cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
3063 {
3064   wtap       *wth;
3065   gchar       *err_info;
3066   char        err_msg[2048+1];
3067
3068   wth = wtap_open_offline(fname, err, &err_info, FALSE);
3069   if (wth == NULL)
3070     goto fail;
3071
3072   /* The open succeeded.  Fill in the information for this file. */
3073
3074   /* Initialize all data structures used for dissection. */
3075   init_dissection();
3076
3077   cf->wth = wth;
3078   cf->f_datalen = 0; /* not used, but set it anyway */
3079
3080   /* Set the file name because we need it to set the follow stream filter.
3081      XXX - is that still true?  We need it for other reasons, though,
3082      in any case. */
3083   cf->filename = g_strdup(fname);
3084
3085   /* Indicate whether it's a permanent or temporary file. */
3086   cf->is_tempfile = is_tempfile;
3087
3088   /* If it's a temporary capture buffer file, mark it as not saved. */
3089   cf->user_saved = !is_tempfile;
3090
3091   cf->cd_t      = wtap_file_type(cf->wth);
3092   cf->count     = 0;
3093   cf->drops_known = FALSE;
3094   cf->drops     = 0;
3095   cf->snap      = wtap_snapshot_length(cf->wth);
3096   if (cf->snap == 0) {
3097     /* Snapshot length not known. */
3098     cf->has_snap = FALSE;
3099     cf->snap = WTAP_MAX_PACKET_SIZE;
3100   } else
3101     cf->has_snap = TRUE;
3102   nstime_set_zero(&cf->elapsed_time);
3103   nstime_set_unset(&first_ts);
3104   nstime_set_unset(&prev_dis_ts);
3105   nstime_set_unset(&prev_cap_ts);
3106
3107   return CF_OK;
3108
3109 fail:
3110   g_snprintf(err_msg, sizeof err_msg,
3111              cf_open_error_message(*err, err_info, FALSE, cf->cd_t), fname);
3112   cmdarg_err("%s", err_msg);
3113   return CF_ERROR;
3114 }
3115
3116
3117 /*
3118  * General errors are reported with an console message in TShark.
3119  */
3120 static void
3121 failure_message(const char *msg_format, va_list ap)
3122 {
3123   fprintf(stderr, "tshark: ");
3124   vfprintf(stderr, msg_format, ap);
3125   fprintf(stderr, "\n");
3126 }
3127
3128 /*
3129  * Read errors are reported with an console message in TShark.
3130  */
3131 static void
3132 read_failure_message(const char *filename, int err)
3133 {
3134   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
3135           filename, strerror(err));
3136 }
3137
3138 /*
3139  * Report an error in command-line arguments.
3140  */
3141 void
3142 cmdarg_err(const char *fmt, ...)
3143 {
3144   va_list ap;
3145
3146   va_start(ap, fmt);
3147   fprintf(stderr, "tshark: ");
3148   vfprintf(stderr, fmt, ap);
3149   fprintf(stderr, "\n");
3150   va_end(ap);
3151 }
3152
3153 /*
3154  * Report additional information for an error in command-line arguments.
3155  */
3156 void
3157 cmdarg_err_cont(const char *fmt, ...)
3158 {
3159   va_list ap;
3160
3161   va_start(ap, fmt);
3162   vfprintf(stderr, fmt, ap);
3163   fprintf(stderr, "\n");
3164   va_end(ap);
3165 }
3166
3167