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