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