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