rawshark.c

   1 /* rawshark.c
   2  *
   3  * $Id$
   4  *
   5  * Wireshark - Network traffic analyzer
   6  * By Gerald Combs <gerald@wireshark.org>
   7  * Copyright 1998 Gerald Combs
   8  *
   9  * Rawshark - Raw field extractor by Gerald Combs <gerald@wireshark.org>
  10  * and Loris Degioanni <loris.degioanni@cacetech.com>
  11  * Based on TShark, by Gilbert Ramirez <gram@alumni.rice.edu> and Guy Harris
  12  * <guy@alum.mit.edu>.
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  27  */
  28
  29 /*
  30  * Rawshark does the following:
  31  * - Opens a specified file or named pipe
  32  * - Applies a specfied DLT or "decode as" encapsulation
  33  * - Reads frames prepended with a libpcap packet header.
  34  * - Prints a status line, followed by  fields from a specified list.
  35  */
  36
  37 #ifdef HAVE_CONFIG_H
  38 # include "config.h"
  39 #endif
  40
  41 #include <stdlib.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include <ctype.h>
  45 #include <locale.h>
  46 #include <limits.h>
  47
  48 #ifdef HAVE_UNISTD_H
  49 #include <unistd.h>
  50 #endif
  51
  52 #include <errno.h>
  53
  54 #ifdef HAVE_FCNTL_H
  55 #include <fcntl.h>
  56 #endif
  57
  58 #include <signal.h>
  59
  60 #ifdef HAVE_SYS_STAT_H
  61 # include <sys/stat.h>
  62 #endif
  63
  64 #ifdef NEED_STRERROR_H
  65 #include "strerror.h"
  66 #endif
  67
  68 #ifdef NEED_GETOPT_H
  69 #include "getopt.h"
  70 #endif
  71
  72 #include <glib.h>
  73 #include <epan/epan.h>
  74 #include <epan/filesystem.h>
  75 #include <epan/privileges.h>
  76 #include <wiretap/file_util.h>
  77
  78 #include "globals.h"
  79 #include <epan/packet.h>
  80 #include "file.h"
  81 #include "disabled_protos.h"
  82 #include <epan/prefs.h>
  83 #include <epan/column.h>
  84 #include "print.h"
  85 #include <epan/addr_resolv.h>
  86 #include "util.h"
  87 #include "clopts_common.h"
  88 #include "cmdarg_err.h"
  89 #include "version_info.h"
  90 #include <epan/conversation.h>
  91 #include <epan/plugins.h>
  92 #include "register.h"
  93 #include "conditions.h"
  94 #include "capture_stop_conditions.h"
  95 #include "capture_ui_utils.h"
  96 #include <epan/epan_dissect.h>
  97 #include <epan/stat_cmd_args.h>
  98 #include <epan/timestamp.h>
  99 #include <epan/unicode-utils.h>
 100 #include "epan/column-utils.h"
 101 #include "epan/proto.h"
 102 #include <epan/tap.h>
 103
 104 #include <wtap.h>
 105 #include <libpcap.h>
 106
 107 #ifdef HAVE_LIBPCAP
 108 #include <pcap.h>
 109 #include <setjmp.h>
 110 #include "capture-pcap-util.h"
 111 #include "pcapio.h"
 112 #ifdef _WIN32
 113 #include "capture-wpcap.h"
 114 #include "capture_errs.h"
 115 #endif /* _WIN32 */
 116 #endif /* HAVE_LIBPCAP */
 117 #include "epan/emem.h"
 118 #include "log.h"
 119
 120 /*
 121  * This is the template for the decode as option; it is shared between the
 122  * various functions that output the usage for this parameter.
 123  */
 124 static const gchar decode_as_arg_template[] = "<layer_type>==<selector>,<decode_as_protocol>";
 125
 126 static nstime_t first_ts;
 127 static nstime_t prev_dis_ts;
 128 static nstime_t prev_cap_ts;
 129 static GString *comp_info_str, *runtime_info_str;
 130
 131 /*
 132  * The way the packet decode is to be written.
 133  */
 134 typedef enum {
 135         WRITE_TEXT,     /* summary or detail text */
 136         WRITE_XML       /* PDML or PSML */
 137         /* Add CSV and the like here */
 138 } output_action_e;
 139 static gboolean line_buffered;
 140 static guint32 cum_bytes = 0;
 141 static print_format_e print_format = PR_FMT_TEXT;
 142
 143 /*
 144  * Standard secondary message for unexpected errors.
 145  */
 146 static const char please_report[] =
 147     "Please report this to the Wireshark developers";
 148
 149 cf_status_t raw_cf_open(capture_file *cf, const char *fname);
 150 static int load_cap_file(capture_file *cf);
 151 static gboolean process_packet(capture_file *cf, gint64 offset,
 152     const struct wtap_pkthdr *whdr, const guchar *pd);
 153 static void show_print_file_io_error(int err);
 154
 155 static void open_failure_message(const char *filename, int err,
 156     gboolean for_writing);
 157 static void failure_message(const char *msg_format, va_list ap);
 158 static void read_failure_message(const char *filename, int err);
 159 static void protocolinfo_init(char *field);
 160 static gboolean parse_field_string_format(char *format);
 161
 162 typedef enum {
 163         SF_NONE,        /* No format (placeholder) */
 164         SF_NAME,        /* %D Field name / description */
 165         SF_NUMVAL,      /* %N Numeric value */
 166         SF_STRVAL       /* %S String value */
 167 } string_fmt_e;
 168
 169 typedef struct string_fmt_s {
 170         gchar *plain;
 171         string_fmt_e format;    /* Valid if plain is NULL */
 172 } string_fmt_t;
 173
 174 capture_file cfile;
 175 int n_rfilters;
 176 int n_rfcodes;
 177 dfilter_t *rfcodes[64];
 178 int n_rfieldfilters;
 179 dfilter_t *rfieldfcodes[64];
 180 int fd;
 181 int encap;
 182 GPtrArray *string_fmts;
 183
 184 static void
 185 print_usage(gboolean print_ver)
 186 {
 187   FILE *output;
 188
 189   if (print_ver) {
 190     output = stdout;
 191     fprintf(output,
 192         "Rawshark " VERSION "%s\n"
 193         "Dump and analyze network traffic.\n"
 194         "See http://www.wireshark.org for more information.\n"
 195         "\n"
 196         "%s",
 197         wireshark_svnversion, get_copyright_info());
 198   } else {
 199     output = stderr;
 200   }
 201   fprintf(output, "\n");
 202   fprintf(output, "Usage: rawshark [options] ...\n");
 203   fprintf(output, "\n");
 204
 205   fprintf(output, "Input file:\n");
 206   fprintf(output, "  -r <infile>              set the pipe or file name to read from\n");
 207
 208   fprintf(output, "\n");
 209   fprintf(output, "Processing:\n");
 210   fprintf(output, "  -R <read filter>         packet filter in Wireshark display filter syntax\n");
 211   fprintf(output, "  -F <field>               field to display\n");
 212   fprintf(output, "  -n                       disable all name resolution (def: all enabled)\n");
 213   fprintf(output, "  -N <name resolve flags>  enable specific name resolution(s): \"mntC\"\n");
 214   fprintf(output, "  -d <encap:dlt>|<proto:protoname>\n");
 215   fprintf(output, "                           packet encapsulation or protocol\n");
 216
 217   /*fprintf(output, "\n");*/
 218   fprintf(output, "Output:\n");
 219   fprintf(output, "  -S                       format string for fields (%%D - name, %%S - stringval, %%N numval\n");
 220   fprintf(output, "  -t ad|a|r|d|dd|e         output format of time stamps (def: r: rel. to first)\n");
 221   fprintf(output, "  -l                       flush output after each packet\n");
 222
 223   fprintf(output, "\n");
 224   fprintf(output, "Miscellaneous:\n");
 225   fprintf(output, "  -h                       display this help and exit\n");
 226   fprintf(output, "  -v                       display version info and exit\n");
 227   fprintf(output, "  -o <name>:<value> ...    override preference setting\n");
 228 }
 229
 230 static void
 231 log_func_ignore (const gchar *log_domain _U_, GLogLevelFlags log_level _U_,
 232     const gchar *message _U_, gpointer user_data _U_)
 233 {
 234 }
 235
 236 /**
 237  * Open a pipe for raw input.  This is a stripped-down version of
 238  * pcap_loop.c:cap_pipe_open_live().
 239  * We check if "pipe_name" is "-" (stdin) or a FIFO, and open it.
 240  * @param pipe_name The name of the pipe or FIFO.
 241  * @return A POSIX file descriptor on success, or -1 on failure.
 242  */
 243 static int
 244 raw_pipe_open(const char *pipe_name)
 245 {
 246 #ifndef _WIN32
 247   struct stat pipe_stat;
 248 #else
 249   char *pncopy, *pos;
 250   wchar_t *err_str;
 251   HANDLE hPipe = NULL;
 252 #endif
 253   int          rfd;
 254
 255   g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "open_raw_pipe: %s", pipe_name);
 256
 257   /*
 258    * XXX Rawshark blocks until we return
 259    */
 260   if (strcmp(pipe_name, "-") == 0) {
 261     rfd = 0; /* read from stdin */
 262 #ifdef _WIN32
 263     /*
 264      * This is needed to set the stdin pipe into binary mode, otherwise
 265      * CR/LF are mangled...
 266      */
 267     _setmode(0, _O_BINARY);
 268 #endif  /* _WIN32 */
 269   } else {
 270 #ifndef _WIN32
 271     if (eth_stat(pipe_name, &pipe_stat) < 0) {
 272       g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
 273         "The capture session could not be initiated "
 274         "due to error on pipe: %s", strerror(errno));
 275       return -1;
 276     }
 277     if (! S_ISFIFO(pipe_stat.st_mode)) {
 278       if (S_ISCHR(pipe_stat.st_mode)) {
 279         /*
 280          * Assume the user specified an interface on a system where
 281          * interfaces are in /dev.  Pretend we haven't seen it.
 282          */
 283       } else
 284       {
 285         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
 286             "The capture session could not be initiated because\n"
 287             "\"%s\" is neither an interface nor a pipe", pipe_name);
 288       }
 289       return -1;
 290     }
 291     rfd = eth_open(pipe_name, O_RDONLY | O_NONBLOCK, 0000 /* no creation so don't matter */);
 292     if (rfd == -1) {
 293         g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
 294           "The capture session could not be initiated "
 295           "due to error on pipe open: %s", strerror(errno));
 296       return -1;
 297     }
 298 #else /* _WIN32 */
 299 #define PIPE_STR "\\pipe\\"
 300     /* Under Windows, named pipes _must_ have the form
 301      * "\\<server>\pipe\<pipe_name>".  <server> may be "." for localhost.
 302      */
 303     pncopy = g_strdup(pipe_name);
 304     if (strstr(pncopy, "\\\\") == pncopy) {
 305       pos = strchr(pncopy + 3, '\\');
 306       if (pos && g_ascii_strncasecmp(pos, PIPE_STR, strlen(PIPE_STR)) != 0)
 307         pos = NULL;
 308     }
 309
 310     g_free(pncopy);
 311
 312     if (!pos) {
 313       g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
 314           "The capture session could not be initiated because\n"
 315           "\"%s\" is neither an interface nor a pipe", pipe_name);
 316       return -1;
 317     }
 318
 319     /* Wait for the pipe to appear */
 320     while (1) {
 321       hPipe = CreateFile(utf_8to16(pipe_name), GENERIC_READ, 0, NULL,
 322           OPEN_EXISTING, 0, NULL);
 323
 324       if (hPipe != INVALID_HANDLE_VALUE)
 325         break;
 326
 327       if (GetLastError() != ERROR_PIPE_BUSY) {
 328         FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
 329           NULL, GetLastError(), 0, (LPTSTR) &err_str, 0, NULL);
 330           g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
 331             "The capture session on \"%s\" could not be initiated "
 332             "due to error on pipe open: pipe busy: %s (error %d)",
 333             pipe_name, utf_16to8(err_str), GetLastError());
 334         LocalFree(err_str);
 335         return -1;
 336       }
 337
 338       if (!WaitNamedPipe(utf_8to16(pipe_name), 30 * 1000)) {
 339         FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
 340           NULL, GetLastError(), 0, (LPTSTR) &err_str, 0, NULL);
 341           g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
 342             "The capture session could not be initiated "
 343             "due to error on pipe open: %s (error %d)",
 344             utf_16to8(err_str), GetLastError());
 345         LocalFree(err_str);
 346         return -1;
 347       }
 348     }
 349
 350     rfd = _open_osfhandle((long) hPipe, _O_RDONLY);
 351     if (rfd == -1) {
 352       g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
 353           "The capture session could not be initiated "
 354           "due to error on pipe open: %s", strerror(errno));
 355       return -1;
 356     }
 357 #endif /* _WIN32 */
 358   }
 359
 360   return rfd;
 361 }
 362
 363 /**
 364  * Parse a link-type argument of the form "encap:<pcap dlt>" or
 365  * "proto:<proto name>".  "Pcap dlt" must be a name conforming to
 366  * pcap_datalink_name_to_val() or an integer.  "Proto name" must be
 367  * a protocol name, e.g. "http".
 368  */
 369 static gboolean
 370 set_link_type(const char *lt_arg) {
 371   char *spec_ptr = strchr(lt_arg, ':');
 372   int dlt_val;
 373   dissector_handle_t dhandle;
 374   GString *pref_str;
 375
 376   if (!spec_ptr)
 377     return FALSE;
 378
 379   spec_ptr++;
 380
 381   if (strncmp(lt_arg, "encap:", strlen("encap:")) == 0) {
 382 #ifdef HAVE_PCAP_DATALINK_NAME_TO_VAL
 383     dlt_val = linktype_name_to_val(spec_ptr);
 384     if (dlt_val >= 0) {
 385       encap = dlt_val;
 386       return TRUE;
 387     }
 388 #endif
 389     dlt_val = strtol(spec_ptr, NULL, 10);
 390     if (errno != EINVAL && dlt_val >= 0) {
 391       encap = wtap_pcap_encap_to_wtap_encap(dlt_val);
 392       if (encap == WTAP_ENCAP_UNKNOWN) {
 393         return FALSE;
 394       }
 395       return TRUE;
 396     }
 397   } else if (strncmp(lt_arg, "proto:", strlen("proto:")) == 0) {
 398     dhandle = find_dissector(spec_ptr);
 399     if (dhandle) {
 400       encap = WTAP_ENCAP_USER0;
 401       pref_str = g_string_new("uat:user_dlts:");
 402       /* This must match the format used in the user_dlts file */
 403       g_string_sprintfa(pref_str,
 404                         "\"User 0 (DLT=147)\",\"%s\",\"0\",\"\",\"0\",\"\"",
 405                         spec_ptr);
 406       if (prefs_set_pref(pref_str->str) != PREFS_SET_OK) {
 407         g_string_free(pref_str, TRUE);
 408         return FALSE;
 409       }
 410       g_string_free(pref_str, TRUE);
 411       return TRUE;
 412     }
 413   }
 414   return FALSE;
 415 }
 416
 417 int
 418 main(int argc, char *argv[])
 419 {
 420   char                *init_progfile_dir_error;
 421   int                  opt, i;
 422   extern char         *optarg;
 423   gboolean             arg_error = FALSE;
 424
 425 #ifdef _WIN32
 426   WSADATA               wsaData;
 427 #endif  /* _WIN32 */
 428
 429   char                *gpf_path, *pf_path;
 430   char                *gdp_path, *dp_path;
 431   int                  gpf_open_errno, gpf_read_errno;
 432   int                  pf_open_errno, pf_read_errno;
 433   int                  gdp_open_errno, gdp_read_errno;
 434   int                  dp_open_errno, dp_read_errno;
 435   int                  err;
 436   gchar               *pipe_name = NULL;
 437   gchar               *rfilters[64];
 438   e_prefs             *prefs;
 439   char                 badopt;
 440   GLogLevelFlags       log_flags;
 441   GPtrArray           *disp_fields = g_ptr_array_new();
 442   guint                fc;
 443
 444   #define OPTSTRING_INIT "d:F:hlnN:o:r:R:S:t:v"
 445
 446   static const char    optstring[] = OPTSTRING_INIT;
 447
 448   /*
 449    * Get credential information for later use.
 450    */
 451   get_credential_info();
 452
 453   /*
 454    * Clear the filters arrays
 455    */
 456   memset(rfilters, 0, sizeof(rfilters));
 457   memset(rfcodes, 0, sizeof(rfcodes));
 458   n_rfilters = 0;
 459   n_rfcodes = 0;
 460
 461   /*
 462    * Initialize our string format
 463    */
 464   string_fmts = g_ptr_array_new();
 465
 466   /*
 467    * Attempt to get the pathname of the executable file.
 468    */
 469   init_progfile_dir_error = init_progfile_dir(argv[0]);
 470   if (init_progfile_dir_error != NULL) {
 471     fprintf(stderr, "rawshark: Can't get pathname of rawshark program: %s.\n",
 472             init_progfile_dir_error);
 473   }
 474
 475   /*
 476    * Get credential information for later use.
 477    */
 478   get_credential_info();
 479
 480   /* nothing more than the standard GLib handler, but without a warning */
 481   log_flags =
 482                     G_LOG_LEVEL_WARNING |
 483                     G_LOG_LEVEL_MESSAGE |
 484                     G_LOG_LEVEL_INFO |
 485                     G_LOG_LEVEL_DEBUG;
 486
 487   g_log_set_handler(NULL,
 488                     log_flags,
 489                     log_func_ignore, NULL /* user_data */);
 490   g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
 491                     log_flags,
 492                     log_func_ignore, NULL /* user_data */);
 493
 494   timestamp_set_type(TS_RELATIVE);
 495   timestamp_set_precision(TS_PREC_AUTO);
 496
 497   /* Register all dissectors; we must do this before checking for the
 498      "-G" flag, as the "-G" flag dumps information registered by the
 499      dissectors, and we must do it before we read the preferences, in
 500      case any dissectors register preferences. */
 501   epan_init(register_all_protocols, register_all_protocol_handoffs, NULL, NULL,
 502             failure_message, open_failure_message, read_failure_message);
 503
 504   /* Now register the preferences for any non-dissector modules.
 505      We must do that before we read the preferences as well. */
 506   prefs_register_modules();
 507
 508   /* Set the C-language locale to the native environment. */
 509   setlocale(LC_ALL, "");
 510
 511   prefs = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
 512                      &pf_open_errno, &pf_read_errno, &pf_path);
 513   if (gpf_path != NULL) {
 514     if (gpf_open_errno != 0) {
 515       cmdarg_err("Can't open global preferences file \"%s\": %s.",
 516               pf_path, strerror(gpf_open_errno));
 517     }
 518     if (gpf_read_errno != 0) {
 519       cmdarg_err("I/O error reading global preferences file \"%s\": %s.",
 520               pf_path, strerror(gpf_read_errno));
 521     }
 522   }
 523   if (pf_path != NULL) {
 524     if (pf_open_errno != 0) {
 525       cmdarg_err("Can't open your preferences file \"%s\": %s.", pf_path,
 526               strerror(pf_open_errno));
 527     }
 528     if (pf_read_errno != 0) {
 529       cmdarg_err("I/O error reading your preferences file \"%s\": %s.",
 530               pf_path, strerror(pf_read_errno));
 531     }
 532     g_free(pf_path);
 533     pf_path = NULL;
 534   }
 535
 536   /* Set the name resolution code's flags from the preferences. */
 537   g_resolv_flags = prefs->name_resolve;
 538
 539   /* Read the disabled protocols file. */
 540   read_disabled_protos_list(&gdp_path, &gdp_open_errno, &gdp_read_errno,
 541                             &dp_path, &dp_open_errno, &dp_read_errno);
 542   if (gdp_path != NULL) {
 543     if (gdp_open_errno != 0) {
 544       cmdarg_err("Could not open global disabled protocols file\n\"%s\": %s.",
 545                  gdp_path, strerror(gdp_open_errno));
 546     }
 547     if (gdp_read_errno != 0) {
 548       cmdarg_err("I/O error reading global disabled protocols file\n\"%s\": %s.",
 549                  gdp_path, strerror(gdp_read_errno));
 550     }
 551     g_free(gdp_path);
 552   }
 553   if (dp_path != NULL) {
 554     if (dp_open_errno != 0) {
 555       cmdarg_err(
 556         "Could not open your disabled protocols file\n\"%s\": %s.", dp_path,
 557         strerror(dp_open_errno));
 558     }
 559     if (dp_read_errno != 0) {
 560       cmdarg_err(
 561         "I/O error reading your disabled protocols file\n\"%s\": %s.", dp_path,
 562         strerror(dp_read_errno));
 563     }
 564     g_free(dp_path);
 565   }
 566
 567 #ifdef _WIN32
 568   /* Load Wpcap, if possible */
 569   load_wpcap();
 570 #endif
 571
 572   init_cap_file(&cfile);
 573
 574   /* Assemble the compile-time version information string */
 575   comp_info_str = g_string_new("Compiled ");
 576   get_compiled_version_info(comp_info_str, get_epan_compiled_version_info);
 577
 578   /* Assemble the run-time version information string */
 579   runtime_info_str = g_string_new("Running ");
 580   get_runtime_version_info(runtime_info_str, NULL);
 581
 582   /* Print format defaults to this. */
 583   print_format = PR_FMT_TEXT;
 584
 585   /* Initialize our encapsulation type */
 586   encap = WTAP_ENCAP_UNKNOWN;
 587
 588   /* Now get our args */
 589   /* XXX - We should probably have an option to dump libpcap link types */
 590   while ((opt = getopt(argc, argv, optstring)) != -1) {
 591     switch (opt) {
 592       case 'd':        /* Payload type */
 593         if (!set_link_type(optarg)) {
 594           cmdarg_err("Invalid link type or protocol \"%s\"", optarg);
 595           exit(1);
 596         }
 597         break;
 598       case 'F':        /* Read field to display */
 599         g_ptr_array_add(disp_fields, g_strdup(optarg));
 600         break;
 601       case 'h':        /* Print help and exit */
 602         print_usage(TRUE);
 603         exit(0);
 604         break;
 605       case 'l':        /* "Line-buffer" standard output */
 606         /* This isn't line-buffering, strictly speaking, it's just
 607            flushing the standard output after the information for
 608            each packet is printed; however, that should be good
 609            enough for all the purposes to which "-l" is put (and
 610            is probably actually better for "-V", as it does fewer
 611            writes).
 612
 613            See the comment in "process_packet()" for an explanation of
 614            why we do that, and why we don't just use "setvbuf()" to
 615            make the standard output line-buffered (short version: in
 616            Windows, "line-buffered" is the same as "fully-buffered",
 617            and the output buffer is only flushed when it fills up). */
 618         line_buffered = TRUE;
 619         break;
 620       case 'n':        /* No name resolution */
 621         g_resolv_flags = RESOLV_NONE;
 622         break;
 623       case 'N':        /* Select what types of addresses/port #s to resolve */
 624         if (g_resolv_flags == RESOLV_ALL)
 625           g_resolv_flags = RESOLV_NONE;
 626         badopt = string_to_name_resolve(optarg, &g_resolv_flags);
 627         if (badopt != '\0') {
 628           cmdarg_err("-N specifies unknown resolving option '%c'; valid options are 'm', 'n', and 't'",
 629                      badopt);
 630           exit(1);
 631         }
 632         break;
 633       case 'o':        /* Override preference from command line */
 634         switch (prefs_set_pref(optarg)) {
 635
 636         case PREFS_SET_OK:
 637           break;
 638
 639         case PREFS_SET_SYNTAX_ERR:
 640           cmdarg_err("Invalid -o flag \"%s\"", optarg);
 641           exit(1);
 642           break;
 643
 644         case PREFS_SET_NO_SUCH_PREF:
 645         case PREFS_SET_OBSOLETE:
 646           cmdarg_err("-o flag \"%s\" specifies unknown preference", optarg);
 647           exit(1);
 648           break;
 649         }
 650         break;
 651       case 'r':        /* Read capture file xxx */
 652         pipe_name = g_strdup(optarg);
 653         break;
 654       case 'R':        /* Read file filter */
 655         if(n_rfilters < (int) sizeof(rfilters) / (int) sizeof(rfilters[0])) {
 656           rfilters[n_rfilters++] = optarg;
 657         }
 658         else {
 659           cmdarg_err("Too many display filters");
 660           exit(1);
 661         }
 662         break;
 663       case 'S':        /* Print string representations */
 664         if (!parse_field_string_format(optarg)) {
 665           cmdarg_err("Invalid field string format");
 666           exit(1);
 667         }
 668         break;
 669       case 't':        /* Time stamp type */
 670         if (strcmp(optarg, "r") == 0)
 671           timestamp_set_type(TS_RELATIVE);
 672         else if (strcmp(optarg, "a") == 0)
 673           timestamp_set_type(TS_ABSOLUTE);
 674         else if (strcmp(optarg, "ad") == 0)
 675           timestamp_set_type(TS_ABSOLUTE_WITH_DATE);
 676         else if (strcmp(optarg, "d") == 0)
 677           timestamp_set_type(TS_DELTA);
 678         else if (strcmp(optarg, "dd") == 0)
 679           timestamp_set_type(TS_DELTA_DIS);
 680         else if (strcmp(optarg, "e") == 0)
 681           timestamp_set_type(TS_EPOCH);
 682         else {
 683           cmdarg_err("Invalid time stamp type \"%s\"",
 684             optarg);
 685           cmdarg_err_cont("It must be \"r\" for relative, \"a\" for absolute,");
 686           cmdarg_err_cont("\"ad\" for absolute with date, or \"d\" for delta.");
 687           exit(1);
 688         }
 689         break;
 690       case 'v':        /* Show version and exit */
 691         printf("Rawshark " VERSION "%s\n"
 692                "\n"
 693                "%s"
 694                "\n"
 695                "%s"
 696                "\n"
 697                "%s",
 698                wireshark_svnversion, get_copyright_info(), comp_info_str->str,
 699                runtime_info_str->str);
 700         exit(0);
 701         break;
 702
 703       default:
 704       case '?':        /* Bad flag - print usage message */
 705         print_usage(TRUE);
 706         exit(1);
 707         break;
 708     }
 709   }
 710
 711   /* Initialize our display fields */
 712   for (fc = 0; fc < disp_fields->len; fc++) {
 713         protocolinfo_init(g_ptr_array_index(disp_fields, fc));
 714   }
 715   g_ptr_array_free(disp_fields, TRUE);
 716   printf("\n");
 717   fflush(stdout);
 718
 719   /* If no capture filter or read filter has been specified, and there are
 720      still command-line arguments, treat them as the tokens of a capture
 721      filter (if no "-r" flag was specified) or a read filter (if a "-r"
 722      flag was specified. */
 723   if (optind < argc) {
 724     if (pipe_name != NULL) {
 725       if (n_rfilters != 0) {
 726         cmdarg_err("Read filters were specified both with \"-R\" "
 727             "and with additional command-line arguments");
 728         exit(1);
 729       }
 730       rfilters[n_rfilters] = get_args_as_string(argc, argv, optind);
 731     }
 732   }
 733
 734   /* Make sure we got a dissector handle for our payload. */
 735   if (encap == WTAP_ENCAP_UNKNOWN) {
 736     cmdarg_err("No valid payload dissector specified.");
 737     exit(1);
 738   }
 739
 740   if (arg_error) {
 741     print_usage(FALSE);
 742     exit(1);
 743   }
 744
 745
 746 #ifdef _WIN32
 747   /* Start windows sockets */
 748   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
 749 #endif /* _WIN32 */
 750
 751   /* Notify all registered modules that have had any of their preferences
 752      changed either from one of the preferences file or from the command
 753      line that their preferences have changed. */
 754   prefs_apply_all();
 755
 756   /* At this point MATE will have registered its field array so we can
 757      have a tap filter with one of MATE's late-registered fields as part
 758      of the filter.  We can now process all the "-z" arguments. */
 759   start_requested_stats();
 760
 761   /* disabled protocols as per configuration file */
 762   if (gdp_path == NULL && dp_path == NULL) {
 763     set_disabled_protos_list();
 764   }
 765
 766   /* Build the column format array */
 767   col_setup(&cfile.cinfo, prefs->num_cols);
 768   for (i = 0; i < cfile.cinfo.num_cols; i++) {
 769     cfile.cinfo.col_fmt[i] = get_column_format(i);
 770     cfile.cinfo.col_title[i] = g_strdup(get_column_title(i));
 771     cfile.cinfo.fmt_matx[i] = (gboolean *) g_malloc0(sizeof(gboolean) *
 772       NUM_COL_FMTS);
 773     get_column_format_matches(cfile.cinfo.fmt_matx[i], cfile.cinfo.col_fmt[i]);
 774     cfile.cinfo.col_data[i] = NULL;
 775     if (cfile.cinfo.col_fmt[i] == COL_INFO)
 776       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_INFO_LEN);
 777     else
 778       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
 779     cfile.cinfo.col_fence[i] = 0;
 780     cfile.cinfo.col_expr.col_expr[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
 781     cfile.cinfo.col_expr.col_expr_val[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
 782   }
 783
 784   for (i = 0; i < cfile.cinfo.num_cols; i++) {
 785       int j;
 786
 787       for (j = 0; j < NUM_COL_FMTS; j++) {
 788          if (!cfile.cinfo.fmt_matx[i][j])
 789              continue;
 790
 791          if (cfile.cinfo.col_first[j] == -1)
 792              cfile.cinfo.col_first[j] = i;
 793          cfile.cinfo.col_last[j] = i;
 794       }
 795   }
 796
 797   if (n_rfilters != 0) {
 798     for (i = 0; i < n_rfilters; i++) {
 799       if (!dfilter_compile(rfilters[i], &rfcodes[n_rfcodes])) {
 800         cmdarg_err("%s", dfilter_error_msg);
 801         epan_cleanup();
 802         exit(2);
 803       }
 804           n_rfcodes++;
 805     }
 806   }
 807
 808   if (pipe_name) {
 809     /*
 810      * We're reading a pipe (or capture file).
 811      */
 812
 813     /*
 814      * Immediately relinquish any special privileges we have; we must not
 815      * be allowed to read any capture files the user running Rawshark
 816      * can't open.
 817      */
 818     relinquish_special_privs_perm();
 819
 820     if (raw_cf_open(&cfile, pipe_name) != CF_OK) {
 821       epan_cleanup();
 822       exit(2);
 823     }
 824
 825     /* Set timestamp precision; there should arguably be a command-line
 826        option to let the user set this. */
 827 #if 0
 828     switch(wtap_file_tsprecision(cfile.wth)) {
 829     case(WTAP_FILE_TSPREC_SEC):
 830       timestamp_set_precision(TS_PREC_AUTO_SEC);
 831       break;
 832     case(WTAP_FILE_TSPREC_DSEC):
 833       timestamp_set_precision(TS_PREC_AUTO_DSEC);
 834       break;
 835     case(WTAP_FILE_TSPREC_CSEC):
 836       timestamp_set_precision(TS_PREC_AUTO_CSEC);
 837       break;
 838     case(WTAP_FILE_TSPREC_MSEC):
 839       timestamp_set_precision(TS_PREC_AUTO_MSEC);
 840       break;
 841     case(WTAP_FILE_TSPREC_USEC):
 842       timestamp_set_precision(TS_PREC_AUTO_USEC);
 843       break;
 844     case(WTAP_FILE_TSPREC_NSEC):
 845       timestamp_set_precision(TS_PREC_AUTO_NSEC);
 846       break;
 847     default:
 848       g_assert_not_reached();
 849     }
 850 #else
 851     timestamp_set_precision(TS_PREC_AUTO_USEC);
 852 #endif
 853
 854     /* Process the packets in the file */
 855     err = load_cap_file(&cfile);
 856
 857     if (err != 0) {
 858       epan_cleanup();
 859       exit(2);
 860     }
 861   } else {
 862     /* If you want to capture live packets, use TShark. */
 863     cmdarg_err("Input file or pipe name not specified.");
 864     exit(2);
 865   }
 866
 867   epan_cleanup();
 868
 869   return 0;
 870 }
 871
 872 /**
 873  * Read data from a raw pipe.  The "raw" data consists of a libpcap
 874  * packet header followed by the payload.
 875  * @param fd [IN] A POSIX file descriptor.  Because that's _exactly_ the sort
 876  *           of thing you want to use in Windows.
 877  * @param phdr [OUT] Packet header information.
 878  * @param err [OUT] Error indicator.  Uses wiretap values.
 879  * @param err_info [OUT] Error message.
 880  * @param data_offset [OUT] data offset in the pipe.
 881  * @return TRUE on success, FALSE on failure.
 882  */
 883 static gboolean
 884 raw_pipe_read(struct wtap_pkthdr *phdr, guchar * pd, int *err, gchar **err_info, gint64 *data_offset) {
 885   struct pcap_pkthdr hdr;
 886   int bytes_read = 0;
 887   int bytes_needed = sizeof(struct pcap_pkthdr);
 888   gchar err_str[1024+1];
 889
 890   /* Copied from capture_loop.c */
 891   while (bytes_needed > 0) {
 892     bytes_read = read(fd, &hdr, bytes_needed);
 893     if (bytes_read == 0) {
 894       *err = 0;
 895       return FALSE;
 896     } else if (bytes_read < 0) {
 897       *err = WTAP_ERR_CANT_READ;
 898       *err_info = "Error reading header from pipe";
 899       return FALSE;
 900     }
 901     bytes_needed -= bytes_read;
 902     *data_offset += bytes_read;
 903   }
 904
 905   bytes_read = 0;
 906   phdr->ts.secs = hdr.ts.tv_sec;
 907   phdr->ts.nsecs = hdr.ts.tv_usec * 1000;
 908   phdr->caplen = bytes_needed = hdr.caplen;
 909   phdr->len = hdr.len;
 910   phdr->pkt_encap = encap;
 911
 912 #if 0
 913   printf("tv_sec: %d (%04x)\n", hdr.ts.tv_sec, hdr.ts.tv_sec);
 914   printf("tv_usec: %d (%04x)\n", hdr.ts.tv_usec, hdr.ts.tv_usec);
 915   printf("caplen: %d (%04x)\n", hdr.caplen, hdr.caplen);
 916   printf("len: %d (%04x)\n", hdr.len, hdr.len);
 917 #endif
 918   if (bytes_needed > WTAP_MAX_PACKET_SIZE) {
 919     *err = WTAP_ERR_BAD_RECORD;
 920     g_snprintf(err_str, 1024, "Bad packet length: %d (%04x)", bytes_needed, bytes_needed);
 921     *err_info = err_str;
 922     return FALSE;
 923   }
 924
 925   while (bytes_needed > 0) {
 926     bytes_read = read(fd, pd, bytes_needed);
 927     if (bytes_read == 0) {
 928       *err = WTAP_ERR_SHORT_READ;
 929       *err_info = "Got zero bytes reading data from pipe";
 930       return FALSE;
 931     } else if (bytes_read < 0) {
 932       *err = WTAP_ERR_CANT_READ;
 933       *err_info = "Error reading data from pipe";
 934       return FALSE;
 935     }
 936     bytes_needed -= bytes_read;
 937     *data_offset += bytes_read;
 938   }
 939   return TRUE;
 940 }
 941
 942 static int
 943 load_cap_file(capture_file *cf)
 944 {
 945   int          err;
 946   gchar        *err_info;
 947   gint64       data_offset = 0;
 948   char         *save_file_string = NULL;
 949   struct wtap_pkthdr  phdr;
 950   guchar       pd[WTAP_MAX_PACKET_SIZE];
 951
 952   while (raw_pipe_read(&phdr, pd, &err, &err_info, &data_offset)) {
 953     process_packet(cf, data_offset, &phdr, pd);
 954   }
 955
 956   if (err != 0) {
 957     /* Print a message noting that the read failed somewhere along the line. */
 958     switch (err) {
 959
 960     case WTAP_ERR_UNSUPPORTED_ENCAP:
 961       cmdarg_err("\"%s\" has a packet with a network type that Rawshark doesn't support.\n(%s)",
 962                  cf->filename, err_info);
 963       break;
 964
 965     case WTAP_ERR_CANT_READ:
 966       cmdarg_err("An attempt to read from \"%s\" failed for some unknown reason.",
 967                  cf->filename);
 968       break;
 969
 970     case WTAP_ERR_SHORT_READ:
 971       cmdarg_err("\"%s\" appears to have been cut short in the middle of a packet.",
 972                  cf->filename);
 973       break;
 974
 975     case WTAP_ERR_BAD_RECORD:
 976       cmdarg_err("\"%s\" appears to be damaged or corrupt.\n(%s)",
 977                  cf->filename, err_info);
 978       break;
 979
 980     default:
 981       cmdarg_err("An error occurred while reading \"%s\": %s.",
 982                  cf->filename, wtap_strerror(err));
 983       break;
 984     }
 985   }
 986
 987   if (save_file_string != NULL)
 988     g_free(save_file_string);
 989
 990   return err;
 991 }
 992
 993 static void
 994 fill_in_fdata(frame_data *fdata, capture_file *cf,
 995               const struct wtap_pkthdr *phdr, gint64 offset)
 996 {
 997   fdata->next = NULL;
 998   fdata->prev = NULL;
 999   fdata->pfd = NULL;
1000   fdata->num = cf->count;
1001   fdata->pkt_len = phdr->len;
1002   cum_bytes += phdr->len;
1003   fdata->cum_bytes  = cum_bytes;
1004   fdata->cap_len = phdr->caplen;
1005   fdata->file_off = offset;
1006   fdata->lnk_t = phdr->pkt_encap;
1007   fdata->abs_ts.secs = phdr->ts.secs;
1008   fdata->abs_ts.nsecs = phdr->ts.nsecs;
1009   fdata->flags.passed_dfilter = 0;
1010   fdata->flags.encoding = CHAR_ASCII;
1011   fdata->flags.visited = 0;
1012   fdata->flags.marked = 0;
1013   fdata->flags.ref_time = 0;
1014   fdata->color_filter = NULL;
1015
1016   /* If we don't have the time stamp of the first packet in the
1017      capture, it's because this is the first packet.  Save the time
1018      stamp of this packet as the time stamp of the first packet. */
1019   if (nstime_is_unset(&first_ts)) {
1020     first_ts = fdata->abs_ts;
1021   }
1022
1023   /* If we don't have the time stamp of the previous captured packet,
1024      it's because this is the first packet.  Save the time
1025      stamp of this packet as the time stamp of the previous captured
1026      packet. */
1027   if (nstime_is_unset(&prev_cap_ts)) {
1028     prev_cap_ts = fdata->abs_ts;
1029   }
1030
1031   /* Get the time elapsed between the first packet and this packet. */
1032   nstime_delta(&fdata->rel_ts, &fdata->abs_ts, &first_ts);
1033
1034   /* If it's greater than the current elapsed time, set the elapsed time
1035      to it (we check for "greater than" so as not to be confused by
1036      time moving backwards). */
1037   if ((gint32)cf->elapsed_time.secs < fdata->rel_ts.secs
1038         || ((gint32)cf->elapsed_time.secs == fdata->rel_ts.secs && (gint32)cf->elapsed_time.nsecs < fdata->rel_ts.nsecs)) {
1039     cf->elapsed_time = fdata->rel_ts;
1040   }
1041
1042   /* If we don't have the time stamp of the previous displayed packet,
1043      it's because this is the first packet that's being displayed.  Save the time
1044      stamp of this packet as the time stamp of the previous displayed
1045      packet. */
1046   if (nstime_is_unset(&prev_dis_ts))
1047     prev_dis_ts = fdata->abs_ts;
1048
1049   /* Get the time elapsed between the previous displayed packet and
1050      this packet. */
1051   nstime_delta(&fdata->del_dis_ts, &fdata->abs_ts, &prev_dis_ts);
1052
1053   /* Get the time elapsed between the previous captured packet and
1054      this packet. */
1055   nstime_delta(&fdata->del_cap_ts, &fdata->abs_ts, &prev_cap_ts);
1056   prev_cap_ts = fdata->abs_ts;
1057 }
1058
1059 /* Free up all data attached to a "frame_data" structure. */
1060 static void
1061 clear_fdata(frame_data *fdata)
1062 {
1063   if (fdata->pfd)
1064     g_slist_free(fdata->pfd);
1065 }
1066
1067 static gboolean
1068 process_packet(capture_file *cf, gint64 offset, const struct wtap_pkthdr *whdr,
1069                const guchar *pd)
1070 {
1071   frame_data fdata;
1072   gboolean create_proto_tree;
1073   epan_dissect_t *edt;
1074   gboolean passed;
1075   union wtap_pseudo_header pseudo_header;
1076   int i;
1077
1078   if(whdr->len == 0)
1079   {
1080           /* The user sends an empty packet when he wants to get output from us even if we don't currently have
1081              packets to process. We spit out a line with the timestamp and the text "void"
1082           */
1083           printf("%lu %lu %lu void -\n", (unsigned long int)cf->count,
1084                   (unsigned long int)whdr->ts.secs,
1085                   (unsigned long int)whdr->ts.nsecs);
1086
1087           fflush(stdout);
1088
1089           return FALSE;
1090   }
1091
1092   memset(&pseudo_header, 0, sizeof(pseudo_header));
1093
1094   /* Count this packet. */
1095   cf->count++;
1096
1097   /* If we're going to print packet information, or we're going to
1098      run a read filter, or we're going to process taps, set up to
1099      do a dissection and do so. */
1100   fill_in_fdata(&fdata, cf, whdr, offset);
1101
1102   passed = TRUE;
1103   create_proto_tree = TRUE;
1104
1105   /* The protocol tree will be "visible", i.e., printed, only if we're
1106      printing packet details, which is true if we're in verbose mode ("verbose"
1107      is true). */
1108   edt = epan_dissect_new(create_proto_tree, FALSE);
1109
1110   /* If we're running a read filter, prime the epan_dissect_t with that
1111      filter. */
1112   if (n_rfilters > 0) {
1113     for(i = 0; i < n_rfcodes; i++) {
1114       epan_dissect_prime_dfilter(edt, rfcodes[i]);
1115     }
1116   }
1117
1118   tap_queue_init(edt);
1119
1120   printf("%lu", (unsigned long int)cf->count);
1121
1122   /* We only need the columns if we're printing packet info but we're
1123      *not* verbose; in verbose mode, we print the protocol tree, not
1124      the protocol summary. */
1125   epan_dissect_run(edt, &pseudo_header, pd, &fdata, &cf->cinfo);
1126
1127   tap_push_tapped_queue(edt);
1128
1129   for(i = 0; i < n_rfilters; i++) {
1130     /* Run the read filter if we have one. */
1131     if (rfcodes[i])
1132       passed = dfilter_apply_edt(rfcodes[i], edt);
1133     else
1134       passed = TRUE;
1135
1136     /* Print a one-line summary */
1137     printf(" %u", passed ? 1 : 0);
1138   }
1139
1140   printf(" -\n");
1141
1142   /* The ANSI C standard does not appear to *require* that a line-buffered
1143      stream be flushed to the host environment whenever a newline is
1144      written, it just says that, on such a stream, characters "are
1145      intended to be transmitted to or from the host environment as a
1146      block when a new-line character is encountered".
1147
1148      The Visual C++ 6.0 C implementation doesn't do what is intended;
1149      even if you set a stream to be line-buffered, it still doesn't
1150      flush the buffer at the end of every line.
1151
1152      So, if the "-l" flag was specified, we flush the standard output
1153      at the end of a packet.  This will do the right thing if we're
1154      printing packet summary lines, and, as we print the entire protocol
1155      tree for a single packet without waiting for anything to happen,
1156      it should be as good as line-buffered mode if we're printing
1157      protocol trees.  (The whole reason for the "-l" flag in either
1158      tcpdump or Rawshark is to allow the output of a live capture to
1159      be piped to a program or script and to have that script see the
1160      information for the packet as soon as it's printed, rather than
1161      having to wait until a standard I/O buffer fills up. */
1162   if (line_buffered)
1163     fflush(stdout);
1164
1165   if (ferror(stdout)) {
1166     show_print_file_io_error(errno);
1167     exit(2);
1168   }
1169
1170   epan_dissect_free(edt);
1171   clear_fdata(&fdata);
1172
1173   return passed;
1174 }
1175
1176 /****************************************************************************************
1177  * FIELD EXTRACTION ROUTINES
1178  ****************************************************************************************/
1179 typedef struct _pci_t {
1180         char *filter;
1181         int hf_index;
1182         int cmd_line_index;
1183 } pci_t;
1184
1185 char* ftenum_to_string(header_field_info *hfi)
1186 {
1187         if (!hfi) {
1188                 return "n.a.";
1189         }
1190
1191         if (string_fmts->len > 0 && hfi->strings) {
1192                 return "FT_STRING";
1193         }
1194
1195         switch(hfi->type) {
1196                 case FT_NONE:
1197                         return "FT_NONE";
1198                 case FT_PROTOCOL:
1199                         return "FT_PROTOCOL";
1200                 case FT_BOOLEAN:
1201                         return "FT_BOOLEAN";
1202                 case FT_UINT8:
1203                         return "FT_UINT8";
1204                 case FT_UINT16:
1205                         return "FT_UINT16";
1206                 case FT_UINT24:
1207                         return "FT_UINT24";
1208                 case FT_UINT32:
1209                         return "FT_UINT32";
1210                 case FT_UINT64:
1211                         return "FT_UINT64";
1212                 case FT_INT8:
1213                         return "FT_INT8";
1214                 case FT_INT16:
1215                         return "FT_INT16";
1216                 case FT_INT24:
1217                         return "FT_INT24";
1218                 case FT_INT32:
1219                         return "FT_INT32";
1220                 case FT_INT64:
1221                         return "FT_INT64";
1222                 case FT_FLOAT:
1223                         return "FT_FLOAT";
1224                 case FT_DOUBLE:
1225                         return "FT_DOUBLE";
1226                 case FT_ABSOLUTE_TIME:
1227                         return "FT_ABSOLUTE_TIME";
1228                 case FT_RELATIVE_TIME:
1229                         return "FT_RELATIVE_TIME";
1230                 case FT_STRING:
1231                         return "FT_STRING";
1232                 case FT_STRINGZ:
1233                         return "FT_STRINGZ";
1234                 case FT_UINT_STRING:
1235                         return "FT_UINT_STRING";
1236                 case FT_ETHER:
1237                         return "FT_ETHER";
1238                 case FT_BYTES:
1239                         return "FT_BYTES";
1240                 case FT_UINT_BYTES:
1241                         return "FT_UINT_BYTES";
1242                 case FT_IPv4:
1243                         return "FT_IPv4";
1244                 case FT_IPv6:
1245                         return "FT_IPv6";
1246                 case FT_IPXNET:
1247                         return "FT_IPXNET";
1248                 case FT_FRAMENUM:
1249                         return "FT_FRAMENUM";
1250                 case FT_PCRE:
1251                         return "FT_PCRE";
1252                 case FT_GUID:
1253                         return "FT_GUID";
1254                 case FT_OID:
1255                         return "FT_OID";
1256                 case FT_NUM_TYPES:
1257                         return "FT_NUM_TYPES";
1258                 default:
1259                         return "n.a.";
1260         };
1261 }
1262
1263 char* base_display_e_to_string(base_display_e bd)
1264 {
1265         switch(bd) {
1266         case BASE_NONE:
1267                         return "BASE_NONE";
1268         case BASE_DEC:
1269                         return "BASE_DEC";
1270         case BASE_HEX:
1271                         return "BASE_HEX";
1272         case BASE_OCT:
1273                         return "BASE_OCT";
1274         case BASE_DEC_HEX:
1275                         return "BASE_DEC_HEX";
1276         case BASE_HEX_DEC:
1277                         return "BASE_HEX_DEC";
1278         default:
1279                         return "n.a.";
1280         }
1281 }
1282
1283 /*
1284  * Copied from various parts of proto.c
1285  */
1286 #define FIELD_STR_INIT_LEN 256
1287 #define cVALS(x) (const value_string*)(x)
1288 static gboolean print_field_value(field_info *finfo, int cmd_line_index)
1289 {
1290         header_field_info       *hfinfo;
1291         static char                     *fs_buf = NULL;
1292         char                            *fs_ptr = fs_buf;
1293         static GString     *label_s = NULL;
1294         int                                     fs_buf_len = FIELD_STR_INIT_LEN, fs_len;
1295         guint              i;
1296         string_fmt_t       *sf;
1297         guint32            uvalue;
1298         gint32             svalue;
1299         const true_false_string *tfstring = &tfs_true_false;
1300
1301         hfinfo = finfo->hfinfo;
1302
1303         if (!fs_buf) {
1304                 fs_buf = g_malloc(fs_buf_len + 1);
1305                 fs_ptr = fs_buf;
1306         }
1307
1308         if (!label_s) {
1309                 label_s = g_string_new("");
1310         }
1311
1312         if(finfo->value.ftype->val_to_string_repr)
1313         {
1314                 /*
1315                  * this field has an associated value,
1316                  * e.g: ip.hdr_len
1317                  */
1318                 fs_len = fvalue_string_repr_len(&finfo->value, FTREPR_DFILTER);
1319                 while (fs_buf_len < fs_len) {
1320                         fs_buf_len *= 2;
1321                         fs_buf = g_realloc(fs_buf, fs_buf_len + 1);
1322                         fs_ptr = fs_buf;
1323                 }
1324                 fvalue_to_string_repr(&finfo->value,
1325                         FTREPR_DFILTER,
1326                         fs_buf);
1327
1328                 /* String types are quoted. Remove them. */
1329                 if ((finfo->value.ftype->ftype == FT_STRING || finfo->value.ftype->ftype == FT_STRINGZ) && fs_len > 2) {
1330                         fs_buf[fs_len - 1] = '\0';
1331                         fs_ptr++;
1332                 }
1333         }
1334
1335         if (string_fmts->len > 0 && finfo->hfinfo->strings) {
1336                 g_string_truncate(label_s, 0);
1337                 for (i = 0; i < string_fmts->len; i++) {
1338                         sf = g_ptr_array_index(string_fmts, i);
1339                         if (sf->plain) {
1340                                 g_string_append(label_s, sf->plain);
1341                         } else {
1342                                 switch (sf->format) {
1343                                         case SF_NAME:
1344                                                 g_string_append(label_s, hfinfo->name);
1345                                                 break;
1346                                         case SF_NUMVAL:
1347                                                 g_string_append(label_s, fs_ptr);
1348                                                 break;
1349                                         case SF_STRVAL:
1350                                                 switch(hfinfo->type) {
1351                                                         case FT_BOOLEAN:
1352                                                                 uvalue = fvalue_get_uinteger(&finfo->value);
1353                                                                 tfstring = (const struct true_false_string*) hfinfo->strings;
1354                                                                 g_string_append(label_s, uvalue ? tfstring->true_string : tfstring->false_string);
1355                                                                 break;
1356                                                         case FT_INT8:
1357                                                         case FT_INT16:
1358                                                         case FT_INT24:
1359                                                         case FT_INT32:
1360                                                                 DISSECTOR_ASSERT(!hfinfo->bitmask);
1361                                                                 svalue = fvalue_get_sinteger(&finfo->value);
1362                                                                 if (hfinfo->display & BASE_RANGE_STRING) {
1363                                                                   g_string_append(label_s, rval_to_str(svalue, hfinfo->strings, "Unknown"));
1364                                                                 } else {
1365                                                                   g_string_append(label_s, val_to_str(svalue, cVALS(hfinfo->strings), "Unknown"));
1366                                                                 }
1367                                                         case FT_UINT8:
1368                                                         case FT_UINT16:
1369                                                         case FT_UINT24:
1370                                                         case FT_UINT32:
1371                                                                 uvalue = fvalue_get_uinteger(&finfo->value);
1372                                                                 if (!hfinfo->bitmask && hfinfo->display & BASE_RANGE_STRING) {
1373                                                                   g_string_append(label_s, rval_to_str(uvalue, hfinfo->strings, "Unknown"));
1374                                                                 } else {
1375                                                                   g_string_append(label_s, val_to_str(uvalue, cVALS(hfinfo->strings), "Unknown"));
1376                                                                 }
1377                                                                 break;
1378                                                         default:
1379                                                                 break;
1380                                                 }
1381                                                 break;
1382                                         default:
1383                                                 break;
1384                                 }
1385                         }
1386                 }
1387                 printf(" %u=\"%s\"", cmd_line_index, label_s->str);
1388                 return TRUE;
1389         }
1390
1391         if(finfo->value.ftype->val_to_string_repr)
1392         {
1393                 printf(" %u=\"%s\"", cmd_line_index, fs_ptr);
1394                 return TRUE;
1395         }
1396
1397         /*
1398          * This field doesn't have an associated value,
1399          * e.g. http
1400          * We return n.a.
1401          */
1402         printf(" %u=\"n.a.\"", cmd_line_index);
1403         return TRUE;
1404 }
1405
1406 static int
1407 protocolinfo_packet(void *prs, packet_info *pinfo _U_, epan_dissect_t *edt, const void *dummy _U_)
1408 {
1409         pci_t *rs=prs;
1410         GPtrArray *gp;
1411         guint i;
1412
1413         gp=proto_get_finfo_ptr_array(edt->tree, rs->hf_index);
1414         if(!gp){
1415                 printf(" n.a.");
1416                 return 0;
1417         }
1418
1419         /*
1420          * Print each occurrence of the field
1421          */
1422         for (i = 0; i < gp->len; i++) {
1423                 print_field_value(gp->pdata[i], rs->cmd_line_index);
1424         }
1425
1426         return 0;
1427 }
1428
1429 int g_cmd_line_index = 0;
1430
1431 /*
1432  * field must be persistent - we don't g_strdup() it below
1433  */
1434 static void
1435 protocolinfo_init(char *field)
1436 {
1437         pci_t *rs;
1438         header_field_info *hfi;
1439         GString *error_string;
1440
1441         hfi=proto_registrar_get_byname(field);
1442         if(!hfi){
1443                 fprintf(stderr, "rawshark: Field \"%s\" doesn't exist.\n", field);
1444                 exit(1);
1445         }
1446
1447         printf("%u %s %s - ",
1448                 g_cmd_line_index,
1449                 ftenum_to_string(hfi),
1450                 base_display_e_to_string(hfi->display));
1451
1452         rs=g_malloc(sizeof(pci_t));
1453         rs->hf_index=hfi->id;
1454         rs->filter=field;
1455         rs->cmd_line_index = g_cmd_line_index++;
1456
1457         error_string=register_tap_listener("frame", rs, rs->filter, NULL, protocolinfo_packet, NULL);
1458         if(error_string){
1459                 /* error, we failed to attach to the tap. complain and clean up */
1460                 fprintf(stderr, "rawshark: Couldn't register field extraction tap: %s\n",
1461                     error_string->str);
1462                 g_string_free(error_string, TRUE);
1463                 if(rs->filter){
1464                         g_free(rs->filter);
1465                 }
1466                 g_free(rs);
1467
1468                 exit(1);
1469         }
1470 }
1471
1472 /*
1473  * Given a format string, split it into a GPtrArray of string_fmt_t structs
1474  * and fill in string_fmt_parts.
1475  */
1476
1477 static void
1478 add_string_fmt(string_fmt_e format, gchar *plain) {
1479         string_fmt_t *sf = g_malloc(sizeof(string_fmt_t));
1480
1481         sf->format = format;
1482         sf->plain = g_strdup(plain);
1483
1484         g_ptr_array_add(string_fmts, sf);
1485 }
1486
1487 static gboolean
1488 parse_field_string_format(gchar *format) {
1489         GString *plain_s = g_string_new("");
1490         int len;
1491         int pos = 0;
1492
1493         if (!format) {
1494                 return FALSE;
1495         }
1496
1497         len = strlen(format);
1498         g_ptr_array_set_size(string_fmts, 0);
1499
1500         while (pos < len) {
1501                 if (format[pos] == '%') {
1502                         if (pos >= len) { /* There should always be a following character */
1503                                 return FALSE;
1504                         }
1505                         pos++;
1506                         if (plain_s->len > 0) {
1507                                 add_string_fmt(SF_NONE, plain_s->str);
1508                                 g_string_truncate(plain_s, 0);
1509                         }
1510                         switch (format[pos]) {
1511                                 case 'D':
1512                                         add_string_fmt(SF_NAME, NULL);
1513                                         break;
1514                                 case 'N':
1515                                         add_string_fmt(SF_NUMVAL, NULL);
1516                                         break;
1517                                 case 'S':
1518                                         add_string_fmt(SF_STRVAL, NULL);
1519                                         break;
1520                                 case '%':
1521                                         g_string_append_c(plain_s, '%');
1522                                         break;
1523                                 default: /* Invalid format */
1524                                         return FALSE;
1525                         }
1526                 } else {
1527                         g_string_append_c(plain_s, format[pos]);
1528                 }
1529                 pos++;
1530         }
1531
1532         if (plain_s->len > 0) {
1533                 add_string_fmt(SF_NONE, plain_s->str);
1534         }
1535         g_string_free(plain_s, TRUE);
1536
1537         return TRUE;
1538 }
1539 /****************************************************************************************
1540  * END OF FIELD EXTRACTION ROUTINES
1541  ****************************************************************************************/
1542
1543 static void
1544 show_print_file_io_error(int err)
1545 {
1546   switch (err) {
1547
1548   case ENOSPC:
1549     cmdarg_err("Not all the packets could be printed because there is "
1550 "no space left on the file system.");
1551     break;
1552
1553 #ifdef EDQUOT
1554   case EDQUOT:
1555     cmdarg_err("Not all the packets could be printed because you are "
1556 "too close to, or over your disk quota.");
1557   break;
1558 #endif
1559
1560   default:
1561     cmdarg_err("An error occurred while printing packets: %s.",
1562       strerror(err));
1563     break;
1564   }
1565 }
1566
1567 /*
1568  * Open/create errors are reported with an console message in Rawshark.
1569  */
1570 static void
1571 open_failure_message(const char *filename, int err, gboolean for_writing)
1572 {
1573   fprintf(stderr, "rawshark: ");
1574   fprintf(stderr, file_open_error_message(err, for_writing), filename);
1575   fprintf(stderr, "\n");
1576 }
1577
1578 cf_status_t
1579 raw_cf_open(capture_file *cf, const char *fname)
1580 {
1581   if ((fd = raw_pipe_open(fname)) < 0)
1582     return CF_ERROR;
1583
1584   /* The open succeeded.  Fill in the information for this file. */
1585
1586   /* Initialize all data structures used for dissection. */
1587   init_dissection();
1588
1589   cf->wth = NULL;
1590   cf->f_datalen = 0; /* not used, but set it anyway */
1591
1592   /* Set the file name because we need it to set the follow stream filter.
1593      XXX - is that still true?  We need it for other reasons, though,
1594      in any case. */
1595   cf->filename = g_strdup(fname);
1596
1597   /* Indicate whether it's a permanent or temporary file. */
1598   cf->is_tempfile = FALSE;
1599
1600   /* If it's a temporary capture buffer file, mark it as not saved. */
1601   cf->user_saved = FALSE;
1602
1603   cf->cd_t      = WTAP_FILE_UNKNOWN;
1604   cf->count     = 0;
1605   cf->drops_known = FALSE;
1606   cf->drops     = 0;
1607   cf->has_snap = FALSE;
1608   cf->snap = WTAP_MAX_PACKET_SIZE;
1609   nstime_set_zero(&cf->elapsed_time);
1610   nstime_set_unset(&first_ts);
1611   nstime_set_unset(&prev_dis_ts);
1612   nstime_set_unset(&prev_cap_ts);
1613
1614   return CF_OK;
1615 }
1616
1617
1618 /*
1619  * General errors are reported with an console message in Rawshark.
1620  */
1621 static void
1622 failure_message(const char *msg_format, va_list ap)
1623 {
1624   fprintf(stderr, "rawshark: ");
1625   vfprintf(stderr, msg_format, ap);
1626   fprintf(stderr, "\n");
1627 }
1628
1629 /*
1630  * Read errors are reported with an console message in Rawshark.
1631  */
1632 static void
1633 read_failure_message(const char *filename, int err)
1634 {
1635   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
1636           filename, strerror(err));
1637 }
1638
1639 /*
1640  * Report an error in command-line arguments.
1641  */
1642 void
1643 cmdarg_err(const char *fmt, ...)
1644 {
1645   va_list ap;
1646
1647   va_start(ap, fmt);
1648   fprintf(stderr, "rawshark: ");
1649   vfprintf(stderr, fmt, ap);
1650   fprintf(stderr, "\n");
1651   va_end(ap);
1652 }
1653
1654 /*
1655  * Report additional information for an error in command-line arguments.
1656  */
1657 void
1658 cmdarg_err_cont(const char *fmt, ...)
1659 {
1660   va_list ap;
1661
1662   va_start(ap, fmt);
1663   vfprintf(stderr, fmt, ap);
1664   fprintf(stderr, "\n");
1665   va_end(ap);
1666 }
1667
1668
1669 /****************************************************************************************************************/
1670 /* other "dummies" */
1671 void
1672 cf_mark_frame(capture_file *cf _U_, frame_data *frame _U_)
1673 {
1674     /* shouldn't happen */
1675     g_assert_not_reached();
1676 }
1677
1678 /*
1679  * Editor modelines
1680  *
1681  * Local Variables:
1682  * c-basic-offset: 4
1683  * tab-width: 4
1684  * indent-tabs-mode: tabs
1685  * End:
1686  *
1687  * ex: set shiftwidth=4 tabstop=4 noexpandtab
1688  * :indentSize=4:tabSize=4:noTabs=false:
1689  */