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 nstime_t first_ts;
 125 static nstime_t prev_dis_ts;
 126 static nstime_t prev_cap_ts;
 127 static GString *comp_info_str, *runtime_info_str;
 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 static gboolean line_buffered;
 138 static guint32 cum_bytes = 0;
 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, "  -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             write_failure_message);
 498
 499   /* Now register the preferences for any non-dissector modules.
 500      We must do that before we read the preferences as well. */
 501   prefs_register_modules();
 502
 503   /* Set the C-language locale to the native environment. */
 504   setlocale(LC_ALL, "");
 505
 506   prefs = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
 507                      &pf_open_errno, &pf_read_errno, &pf_path);
 508   if (gpf_path != NULL) {
 509     if (gpf_open_errno != 0) {
 510       cmdarg_err("Can't open global preferences file \"%s\": %s.",
 511               pf_path, strerror(gpf_open_errno));
 512     }
 513     if (gpf_read_errno != 0) {
 514       cmdarg_err("I/O error reading global preferences file \"%s\": %s.",
 515               pf_path, strerror(gpf_read_errno));
 516     }
 517   }
 518   if (pf_path != NULL) {
 519     if (pf_open_errno != 0) {
 520       cmdarg_err("Can't open your preferences file \"%s\": %s.", pf_path,
 521               strerror(pf_open_errno));
 522     }
 523     if (pf_read_errno != 0) {
 524       cmdarg_err("I/O error reading your preferences file \"%s\": %s.",
 525               pf_path, strerror(pf_read_errno));
 526     }
 527     g_free(pf_path);
 528     pf_path = NULL;
 529   }
 530
 531   /* Set the name resolution code's flags from the preferences. */
 532   g_resolv_flags = prefs->name_resolve;
 533
 534   /* Read the disabled protocols file. */
 535   read_disabled_protos_list(&gdp_path, &gdp_open_errno, &gdp_read_errno,
 536                             &dp_path, &dp_open_errno, &dp_read_errno);
 537   if (gdp_path != NULL) {
 538     if (gdp_open_errno != 0) {
 539       cmdarg_err("Could not open global disabled protocols file\n\"%s\": %s.",
 540                  gdp_path, strerror(gdp_open_errno));
 541     }
 542     if (gdp_read_errno != 0) {
 543       cmdarg_err("I/O error reading global disabled protocols file\n\"%s\": %s.",
 544                  gdp_path, strerror(gdp_read_errno));
 545     }
 546     g_free(gdp_path);
 547   }
 548   if (dp_path != NULL) {
 549     if (dp_open_errno != 0) {
 550       cmdarg_err(
 551         "Could not open your disabled protocols file\n\"%s\": %s.", dp_path,
 552         strerror(dp_open_errno));
 553     }
 554     if (dp_read_errno != 0) {
 555       cmdarg_err(
 556         "I/O error reading your disabled protocols file\n\"%s\": %s.", dp_path,
 557         strerror(dp_read_errno));
 558     }
 559     g_free(dp_path);
 560   }
 561
 562 #ifdef _WIN32
 563   /* Load Wpcap, if possible */
 564   load_wpcap();
 565 #endif
 566
 567   init_cap_file(&cfile);
 568
 569   /* Assemble the compile-time version information string */
 570   comp_info_str = g_string_new("Compiled ");
 571   get_compiled_version_info(comp_info_str, get_epan_compiled_version_info);
 572
 573   /* Assemble the run-time version information string */
 574   runtime_info_str = g_string_new("Running ");
 575   get_runtime_version_info(runtime_info_str, NULL);
 576
 577   /* Print format defaults to this. */
 578   print_format = PR_FMT_TEXT;
 579
 580   /* Initialize our encapsulation type */
 581   encap = WTAP_ENCAP_UNKNOWN;
 582
 583   /* Now get our args */
 584   /* XXX - We should probably have an option to dump libpcap link types */
 585   while ((opt = getopt(argc, argv, optstring)) != -1) {
 586     switch (opt) {
 587       case 'd':        /* Payload type */
 588         if (!set_link_type(optarg)) {
 589           cmdarg_err("Invalid link type or protocol \"%s\"", optarg);
 590           exit(1);
 591         }
 592         break;
 593       case 'F':        /* Read field to display */
 594         g_ptr_array_add(disp_fields, g_strdup(optarg));
 595         break;
 596       case 'h':        /* Print help and exit */
 597         print_usage(TRUE);
 598         exit(0);
 599         break;
 600       case 'l':        /* "Line-buffer" standard output */
 601         /* This isn't line-buffering, strictly speaking, it's just
 602            flushing the standard output after the information for
 603            each packet is printed; however, that should be good
 604            enough for all the purposes to which "-l" is put (and
 605            is probably actually better for "-V", as it does fewer
 606            writes).
 607
 608            See the comment in "process_packet()" for an explanation of
 609            why we do that, and why we don't just use "setvbuf()" to
 610            make the standard output line-buffered (short version: in
 611            Windows, "line-buffered" is the same as "fully-buffered",
 612            and the output buffer is only flushed when it fills up). */
 613         line_buffered = TRUE;
 614         break;
 615       case 'n':        /* No name resolution */
 616         g_resolv_flags = RESOLV_NONE;
 617         break;
 618       case 'N':        /* Select what types of addresses/port #s to resolve */
 619         if (g_resolv_flags == RESOLV_ALL)
 620           g_resolv_flags = RESOLV_NONE;
 621         badopt = string_to_name_resolve(optarg, &g_resolv_flags);
 622         if (badopt != '\0') {
 623           cmdarg_err("-N specifies unknown resolving option '%c'; valid options are 'm', 'n', and 't'",
 624                      badopt);
 625           exit(1);
 626         }
 627         break;
 628       case 'o':        /* Override preference from command line */
 629         switch (prefs_set_pref(optarg)) {
 630
 631         case PREFS_SET_OK:
 632           break;
 633
 634         case PREFS_SET_SYNTAX_ERR:
 635           cmdarg_err("Invalid -o flag \"%s\"", optarg);
 636           exit(1);
 637           break;
 638
 639         case PREFS_SET_NO_SUCH_PREF:
 640         case PREFS_SET_OBSOLETE:
 641           cmdarg_err("-o flag \"%s\" specifies unknown preference", optarg);
 642           exit(1);
 643           break;
 644         }
 645         break;
 646       case 'r':        /* Read capture file xxx */
 647         pipe_name = g_strdup(optarg);
 648         break;
 649       case 'R':        /* Read file filter */
 650         if(n_rfilters < (int) sizeof(rfilters) / (int) sizeof(rfilters[0])) {
 651           rfilters[n_rfilters++] = optarg;
 652         }
 653         else {
 654           cmdarg_err("Too many display filters");
 655           exit(1);
 656         }
 657         break;
 658       case 'S':        /* Print string representations */
 659         if (!parse_field_string_format(optarg)) {
 660           cmdarg_err("Invalid field string format");
 661           exit(1);
 662         }
 663         break;
 664       case 't':        /* Time stamp type */
 665         if (strcmp(optarg, "r") == 0)
 666           timestamp_set_type(TS_RELATIVE);
 667         else if (strcmp(optarg, "a") == 0)
 668           timestamp_set_type(TS_ABSOLUTE);
 669         else if (strcmp(optarg, "ad") == 0)
 670           timestamp_set_type(TS_ABSOLUTE_WITH_DATE);
 671         else if (strcmp(optarg, "d") == 0)
 672           timestamp_set_type(TS_DELTA);
 673         else if (strcmp(optarg, "dd") == 0)
 674           timestamp_set_type(TS_DELTA_DIS);
 675         else if (strcmp(optarg, "e") == 0)
 676           timestamp_set_type(TS_EPOCH);
 677         else {
 678           cmdarg_err("Invalid time stamp type \"%s\"",
 679             optarg);
 680           cmdarg_err_cont("It must be \"r\" for relative, \"a\" for absolute,");
 681           cmdarg_err_cont("\"ad\" for absolute with date, or \"d\" for delta.");
 682           exit(1);
 683         }
 684         break;
 685       case 'v':        /* Show version and exit */
 686         printf("Rawshark " VERSION "%s\n"
 687                "\n"
 688                "%s"
 689                "\n"
 690                "%s"
 691                "\n"
 692                "%s",
 693                wireshark_svnversion, get_copyright_info(), comp_info_str->str,
 694                runtime_info_str->str);
 695         exit(0);
 696         break;
 697
 698       default:
 699       case '?':        /* Bad flag - print usage message */
 700         print_usage(TRUE);
 701         exit(1);
 702         break;
 703     }
 704   }
 705
 706   /* Initialize our display fields */
 707   for (fc = 0; fc < disp_fields->len; fc++) {
 708         protocolinfo_init(g_ptr_array_index(disp_fields, fc));
 709   }
 710   g_ptr_array_free(disp_fields, TRUE);
 711   printf("\n");
 712   fflush(stdout);
 713
 714   /* If no capture filter or read filter has been specified, and there are
 715      still command-line arguments, treat them as the tokens of a capture
 716      filter (if no "-r" flag was specified) or a read filter (if a "-r"
 717      flag was specified. */
 718   if (optind < argc) {
 719     if (pipe_name != NULL) {
 720       if (n_rfilters != 0) {
 721         cmdarg_err("Read filters were specified both with \"-R\" "
 722             "and with additional command-line arguments");
 723         exit(1);
 724       }
 725       rfilters[n_rfilters] = get_args_as_string(argc, argv, optind);
 726     }
 727   }
 728
 729   /* Make sure we got a dissector handle for our payload. */
 730   if (encap == WTAP_ENCAP_UNKNOWN) {
 731     cmdarg_err("No valid payload dissector specified.");
 732     exit(1);
 733   }
 734
 735   if (arg_error) {
 736     print_usage(FALSE);
 737     exit(1);
 738   }
 739
 740
 741 #ifdef _WIN32
 742   /* Start windows sockets */
 743   WSAStartup( MAKEWORD( 1, 1 ), &wsaData );
 744 #endif /* _WIN32 */
 745
 746   /* Notify all registered modules that have had any of their preferences
 747      changed either from one of the preferences file or from the command
 748      line that their preferences have changed. */
 749   prefs_apply_all();
 750
 751   /* At this point MATE will have registered its field array so we can
 752      have a tap filter with one of MATE's late-registered fields as part
 753      of the filter.  We can now process all the "-z" arguments. */
 754   start_requested_stats();
 755
 756   /* disabled protocols as per configuration file */
 757   if (gdp_path == NULL && dp_path == NULL) {
 758     set_disabled_protos_list();
 759   }
 760
 761   /* Build the column format array */
 762   col_setup(&cfile.cinfo, prefs->num_cols);
 763   for (i = 0; i < cfile.cinfo.num_cols; i++) {
 764     cfile.cinfo.col_fmt[i] = get_column_format(i);
 765     cfile.cinfo.col_title[i] = g_strdup(get_column_title(i));
 766     cfile.cinfo.fmt_matx[i] = (gboolean *) g_malloc0(sizeof(gboolean) *
 767       NUM_COL_FMTS);
 768     get_column_format_matches(cfile.cinfo.fmt_matx[i], cfile.cinfo.col_fmt[i]);
 769     cfile.cinfo.col_data[i] = NULL;
 770     if (cfile.cinfo.col_fmt[i] == COL_INFO)
 771       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_INFO_LEN);
 772     else
 773       cfile.cinfo.col_buf[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
 774     cfile.cinfo.col_fence[i] = 0;
 775     cfile.cinfo.col_expr.col_expr[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
 776     cfile.cinfo.col_expr.col_expr_val[i] = (gchar *) g_malloc(sizeof(gchar) * COL_MAX_LEN);
 777   }
 778
 779   for (i = 0; i < cfile.cinfo.num_cols; i++) {
 780       int j;
 781
 782       for (j = 0; j < NUM_COL_FMTS; j++) {
 783          if (!cfile.cinfo.fmt_matx[i][j])
 784              continue;
 785
 786          if (cfile.cinfo.col_first[j] == -1)
 787              cfile.cinfo.col_first[j] = i;
 788          cfile.cinfo.col_last[j] = i;
 789       }
 790   }
 791
 792   if (n_rfilters != 0) {
 793     for (i = 0; i < n_rfilters; i++) {
 794       if (!dfilter_compile(rfilters[i], &rfcodes[n_rfcodes])) {
 795         cmdarg_err("%s", dfilter_error_msg);
 796         epan_cleanup();
 797         exit(2);
 798       }
 799       n_rfcodes++;
 800     }
 801   }
 802
 803   if (pipe_name) {
 804     /*
 805      * We're reading a pipe (or capture file).
 806      */
 807
 808     /*
 809      * Immediately relinquish any special privileges we have; we must not
 810      * be allowed to read any capture files the user running Rawshark
 811      * can't open.
 812      */
 813     relinquish_special_privs_perm();
 814
 815     if (raw_cf_open(&cfile, pipe_name) != CF_OK) {
 816       epan_cleanup();
 817       exit(2);
 818     }
 819
 820     /* Set timestamp precision; there should arguably be a command-line
 821        option to let the user set this. */
 822 #if 0
 823     switch(wtap_file_tsprecision(cfile.wth)) {
 824     case(WTAP_FILE_TSPREC_SEC):
 825       timestamp_set_precision(TS_PREC_AUTO_SEC);
 826       break;
 827     case(WTAP_FILE_TSPREC_DSEC):
 828       timestamp_set_precision(TS_PREC_AUTO_DSEC);
 829       break;
 830     case(WTAP_FILE_TSPREC_CSEC):
 831       timestamp_set_precision(TS_PREC_AUTO_CSEC);
 832       break;
 833     case(WTAP_FILE_TSPREC_MSEC):
 834       timestamp_set_precision(TS_PREC_AUTO_MSEC);
 835       break;
 836     case(WTAP_FILE_TSPREC_USEC):
 837       timestamp_set_precision(TS_PREC_AUTO_USEC);
 838       break;
 839     case(WTAP_FILE_TSPREC_NSEC):
 840       timestamp_set_precision(TS_PREC_AUTO_NSEC);
 841       break;
 842     default:
 843       g_assert_not_reached();
 844     }
 845 #else
 846     timestamp_set_precision(TS_PREC_AUTO_USEC);
 847 #endif
 848
 849     /* Process the packets in the file */
 850     err = load_cap_file(&cfile);
 851
 852     if (err != 0) {
 853       epan_cleanup();
 854       exit(2);
 855     }
 856   } else {
 857     /* If you want to capture live packets, use TShark. */
 858     cmdarg_err("Input file or pipe name not specified.");
 859     exit(2);
 860   }
 861
 862   epan_cleanup();
 863
 864   return 0;
 865 }
 866
 867 /**
 868  * Read data from a raw pipe.  The "raw" data consists of a libpcap
 869  * packet header followed by the payload.
 870  * @param fd [IN] A POSIX file descriptor.  Because that's _exactly_ the sort
 871  *           of thing you want to use in Windows.
 872  * @param phdr [OUT] Packet header information.
 873  * @param err [OUT] Error indicator.  Uses wiretap values.
 874  * @param err_info [OUT] Error message.
 875  * @param data_offset [OUT] data offset in the pipe.
 876  * @return TRUE on success, FALSE on failure.
 877  */
 878 static gboolean
 879 raw_pipe_read(struct wtap_pkthdr *phdr, guchar * pd, int *err, gchar **err_info, gint64 *data_offset) {
 880   struct pcap_pkthdr hdr;
 881   int bytes_read = 0;
 882   int bytes_needed = sizeof(struct pcap_pkthdr);
 883   static gchar err_str[100];
 884
 885   /* Copied from capture_loop.c */
 886   while (bytes_needed > 0) {
 887     bytes_read = read(fd, &hdr, bytes_needed);
 888     if (bytes_read == 0) {
 889       *err = 0;
 890       return FALSE;
 891     } else if (bytes_read < 0) {
 892       *err = WTAP_ERR_CANT_READ;
 893       *err_info = "Error reading header from pipe";
 894       return FALSE;
 895     }
 896     bytes_needed -= bytes_read;
 897     *data_offset += bytes_read;
 898   }
 899
 900   bytes_read = 0;
 901   phdr->ts.secs = hdr.ts.tv_sec;
 902   phdr->ts.nsecs = hdr.ts.tv_usec * 1000;
 903   phdr->caplen = bytes_needed = hdr.caplen;
 904   phdr->len = hdr.len;
 905   phdr->pkt_encap = encap;
 906
 907 #if 0
 908   printf("tv_sec: %d (%04x)\n", hdr.ts.tv_sec, hdr.ts.tv_sec);
 909   printf("tv_usec: %d (%04x)\n", hdr.ts.tv_usec, hdr.ts.tv_usec);
 910   printf("caplen: %d (%04x)\n", hdr.caplen, hdr.caplen);
 911   printf("len: %d (%04x)\n", hdr.len, hdr.len);
 912 #endif
 913   if (bytes_needed > WTAP_MAX_PACKET_SIZE) {
 914     *err = WTAP_ERR_BAD_RECORD;
 915     g_snprintf(err_str, 100, "Bad packet length: %d (%04x)", bytes_needed, bytes_needed);
 916     *err_info = err_str;
 917     return FALSE;
 918   }
 919
 920   while (bytes_needed > 0) {
 921     bytes_read = read(fd, pd, bytes_needed);
 922     if (bytes_read == 0) {
 923       *err = WTAP_ERR_SHORT_READ;
 924       *err_info = "Got zero bytes reading data from pipe";
 925       return FALSE;
 926     } else if (bytes_read < 0) {
 927       *err = WTAP_ERR_CANT_READ;
 928       *err_info = "Error reading data from pipe";
 929       return FALSE;
 930     }
 931     bytes_needed -= bytes_read;
 932     *data_offset += bytes_read;
 933   }
 934   return TRUE;
 935 }
 936
 937 static int
 938 load_cap_file(capture_file *cf)
 939 {
 940   int          err;
 941   gchar        *err_info;
 942   gint64       data_offset = 0;
 943   struct wtap_pkthdr  phdr;
 944   guchar       pd[WTAP_MAX_PACKET_SIZE];
 945
 946   while (raw_pipe_read(&phdr, pd, &err, &err_info, &data_offset)) {
 947     process_packet(cf, data_offset, &phdr, pd);
 948   }
 949
 950   if (err != 0) {
 951     /* Print a message noting that the read failed somewhere along the line. */
 952     switch (err) {
 953
 954     case WTAP_ERR_UNSUPPORTED_ENCAP:
 955       cmdarg_err("\"%s\" has a packet with a network type that Rawshark doesn't support.\n(%s)",
 956                  cf->filename, err_info);
 957       break;
 958
 959     case WTAP_ERR_CANT_READ:
 960       cmdarg_err("An attempt to read from \"%s\" failed for some unknown reason.",
 961                  cf->filename);
 962       break;
 963
 964     case WTAP_ERR_SHORT_READ:
 965       cmdarg_err("\"%s\" appears to have been cut short in the middle of a packet.",
 966                  cf->filename);
 967       break;
 968
 969     case WTAP_ERR_BAD_RECORD:
 970       cmdarg_err("\"%s\" appears to be damaged or corrupt.\n(%s)",
 971                  cf->filename, err_info);
 972       break;
 973
 974     default:
 975       cmdarg_err("An error occurred while reading \"%s\": %s.",
 976                  cf->filename, wtap_strerror(err));
 977       break;
 978     }
 979   }
 980
 981   return err;
 982 }
 983
 984 static void
 985 fill_in_fdata(frame_data *fdata, capture_file *cf,
 986               const struct wtap_pkthdr *phdr, gint64 offset)
 987 {
 988   fdata->next = NULL;
 989   fdata->prev = NULL;
 990   fdata->pfd = NULL;
 991   fdata->num = cf->count;
 992   fdata->pkt_len = phdr->len;
 993   cum_bytes += phdr->len;
 994   fdata->cum_bytes  = cum_bytes;
 995   fdata->cap_len = phdr->caplen;
 996   fdata->file_off = offset;
 997   fdata->lnk_t = phdr->pkt_encap;
 998   fdata->abs_ts.secs = phdr->ts.secs;
 999   fdata->abs_ts.nsecs = phdr->ts.nsecs;
1000   fdata->flags.passed_dfilter = 0;
1001   fdata->flags.encoding = CHAR_ASCII;
1002   fdata->flags.visited = 0;
1003   fdata->flags.marked = 0;
1004   fdata->flags.ref_time = 0;
1005   fdata->color_filter = NULL;
1006
1007   /* If we don't have the time stamp of the first packet in the
1008      capture, it's because this is the first packet.  Save the time
1009      stamp of this packet as the time stamp of the first packet. */
1010   if (nstime_is_unset(&first_ts)) {
1011     first_ts = fdata->abs_ts;
1012   }
1013
1014   /* If we don't have the time stamp of the previous captured packet,
1015      it's because this is the first packet.  Save the time
1016      stamp of this packet as the time stamp of the previous captured
1017      packet. */
1018   if (nstime_is_unset(&prev_cap_ts)) {
1019     prev_cap_ts = fdata->abs_ts;
1020   }
1021
1022   /* Get the time elapsed between the first packet and this packet. */
1023   nstime_delta(&fdata->rel_ts, &fdata->abs_ts, &first_ts);
1024
1025   /* If it's greater than the current elapsed time, set the elapsed time
1026      to it (we check for "greater than" so as not to be confused by
1027      time moving backwards). */
1028   if ((gint32)cf->elapsed_time.secs < fdata->rel_ts.secs
1029         || ((gint32)cf->elapsed_time.secs == fdata->rel_ts.secs && (gint32)cf->elapsed_time.nsecs < fdata->rel_ts.nsecs)) {
1030     cf->elapsed_time = fdata->rel_ts;
1031   }
1032
1033   /* If we don't have the time stamp of the previous displayed packet,
1034      it's because this is the first packet that's being displayed.  Save the time
1035      stamp of this packet as the time stamp of the previous displayed
1036      packet. */
1037   if (nstime_is_unset(&prev_dis_ts))
1038     prev_dis_ts = fdata->abs_ts;
1039
1040   /* Get the time elapsed between the previous displayed packet and
1041      this packet. */
1042   nstime_delta(&fdata->del_dis_ts, &fdata->abs_ts, &prev_dis_ts);
1043
1044   /* Get the time elapsed between the previous captured packet and
1045      this packet. */
1046   nstime_delta(&fdata->del_cap_ts, &fdata->abs_ts, &prev_cap_ts);
1047   prev_cap_ts = fdata->abs_ts;
1048 }
1049
1050 /* Free up all data attached to a "frame_data" structure. */
1051 static void
1052 clear_fdata(frame_data *fdata)
1053 {
1054   if (fdata->pfd)
1055     g_slist_free(fdata->pfd);
1056 }
1057
1058 static gboolean
1059 process_packet(capture_file *cf, gint64 offset, const struct wtap_pkthdr *whdr,
1060                const guchar *pd)
1061 {
1062   frame_data fdata;
1063   gboolean create_proto_tree;
1064   epan_dissect_t *edt;
1065   gboolean passed;
1066   union wtap_pseudo_header pseudo_header;
1067   int i;
1068
1069   if(whdr->len == 0)
1070   {
1071           /* The user sends an empty packet when he wants to get output from us even if we don't currently have
1072              packets to process. We spit out a line with the timestamp and the text "void"
1073           */
1074           printf("%lu %lu %lu void -\n", (unsigned long int)cf->count,
1075                   (unsigned long int)whdr->ts.secs,
1076                   (unsigned long int)whdr->ts.nsecs);
1077
1078           fflush(stdout);
1079
1080           return FALSE;
1081   }
1082
1083   memset(&pseudo_header, 0, sizeof(pseudo_header));
1084
1085   /* Count this packet. */
1086   cf->count++;
1087
1088   /* If we're going to print packet information, or we're going to
1089      run a read filter, or we're going to process taps, set up to
1090      do a dissection and do so. */
1091   fill_in_fdata(&fdata, cf, whdr, offset);
1092
1093   passed = TRUE;
1094   create_proto_tree = TRUE;
1095
1096   /* The protocol tree will be "visible", i.e., printed, only if we're
1097      printing packet details, which is true if we're in verbose mode ("verbose"
1098      is true). */
1099   edt = epan_dissect_new(create_proto_tree, FALSE);
1100
1101   /* If we're running a read filter, prime the epan_dissect_t with that
1102      filter. */
1103   if (n_rfilters > 0) {
1104     for(i = 0; i < n_rfcodes; i++) {
1105       epan_dissect_prime_dfilter(edt, rfcodes[i]);
1106     }
1107   }
1108
1109   tap_queue_init(edt);
1110
1111   printf("%lu", (unsigned long int)cf->count);
1112
1113   /* We only need the columns if we're printing packet info but we're
1114      *not* verbose; in verbose mode, we print the protocol tree, not
1115      the protocol summary. */
1116   epan_dissect_run(edt, &pseudo_header, pd, &fdata, &cf->cinfo);
1117
1118   tap_push_tapped_queue(edt);
1119
1120   for(i = 0; i < n_rfilters; i++) {
1121     /* Run the read filter if we have one. */
1122     if (rfcodes[i])
1123       passed = dfilter_apply_edt(rfcodes[i], edt);
1124     else
1125       passed = TRUE;
1126
1127     /* Print a one-line summary */
1128     printf(" %u", passed ? 1 : 0);
1129   }
1130
1131   printf(" -\n");
1132
1133   /* The ANSI C standard does not appear to *require* that a line-buffered
1134      stream be flushed to the host environment whenever a newline is
1135      written, it just says that, on such a stream, characters "are
1136      intended to be transmitted to or from the host environment as a
1137      block when a new-line character is encountered".
1138
1139      The Visual C++ 6.0 C implementation doesn't do what is intended;
1140      even if you set a stream to be line-buffered, it still doesn't
1141      flush the buffer at the end of every line.
1142
1143      So, if the "-l" flag was specified, we flush the standard output
1144      at the end of a packet.  This will do the right thing if we're
1145      printing packet summary lines, and, as we print the entire protocol
1146      tree for a single packet without waiting for anything to happen,
1147      it should be as good as line-buffered mode if we're printing
1148      protocol trees.  (The whole reason for the "-l" flag in either
1149      tcpdump or Rawshark is to allow the output of a live capture to
1150      be piped to a program or script and to have that script see the
1151      information for the packet as soon as it's printed, rather than
1152      having to wait until a standard I/O buffer fills up. */
1153   if (line_buffered)
1154     fflush(stdout);
1155
1156   if (ferror(stdout)) {
1157     show_print_file_io_error(errno);
1158     exit(2);
1159   }
1160
1161   epan_dissect_free(edt);
1162   clear_fdata(&fdata);
1163
1164   return passed;
1165 }
1166
1167 /****************************************************************************************
1168  * FIELD EXTRACTION ROUTINES
1169  ****************************************************************************************/
1170 typedef struct _pci_t {
1171         char *filter;
1172         int hf_index;
1173         int cmd_line_index;
1174 } pci_t;
1175
1176 char* ftenum_to_string(header_field_info *hfi)
1177 {
1178         if (!hfi) {
1179                 return "n.a.";
1180         }
1181
1182         if (string_fmts->len > 0 && hfi->strings) {
1183                 return "FT_STRING";
1184         }
1185
1186         switch(hfi->type) {
1187                 case FT_NONE:
1188                         return "FT_NONE";
1189                 case FT_PROTOCOL:
1190                         return "FT_PROTOCOL";
1191                 case FT_BOOLEAN:
1192                         return "FT_BOOLEAN";
1193                 case FT_UINT8:
1194                         return "FT_UINT8";
1195                 case FT_UINT16:
1196                         return "FT_UINT16";
1197                 case FT_UINT24:
1198                         return "FT_UINT24";
1199                 case FT_UINT32:
1200                         return "FT_UINT32";
1201                 case FT_UINT64:
1202                         return "FT_UINT64";
1203                 case FT_INT8:
1204                         return "FT_INT8";
1205                 case FT_INT16:
1206                         return "FT_INT16";
1207                 case FT_INT24:
1208                         return "FT_INT24";
1209                 case FT_INT32:
1210                         return "FT_INT32";
1211                 case FT_INT64:
1212                         return "FT_INT64";
1213                 case FT_FLOAT:
1214                         return "FT_FLOAT";
1215                 case FT_DOUBLE:
1216                         return "FT_DOUBLE";
1217                 case FT_ABSOLUTE_TIME:
1218                         return "FT_ABSOLUTE_TIME";
1219                 case FT_RELATIVE_TIME:
1220                         return "FT_RELATIVE_TIME";
1221                 case FT_STRING:
1222                         return "FT_STRING";
1223                 case FT_STRINGZ:
1224                         return "FT_STRINGZ";
1225                 case FT_UINT_STRING:
1226                         return "FT_UINT_STRING";
1227                 case FT_ETHER:
1228                         return "FT_ETHER";
1229                 case FT_BYTES:
1230                         return "FT_BYTES";
1231                 case FT_UINT_BYTES:
1232                         return "FT_UINT_BYTES";
1233                 case FT_IPv4:
1234                         return "FT_IPv4";
1235                 case FT_IPv6:
1236                         return "FT_IPv6";
1237                 case FT_IPXNET:
1238                         return "FT_IPXNET";
1239                 case FT_FRAMENUM:
1240                         return "FT_FRAMENUM";
1241                 case FT_PCRE:
1242                         return "FT_PCRE";
1243                 case FT_GUID:
1244                         return "FT_GUID";
1245                 case FT_OID:
1246                         return "FT_OID";
1247                 case FT_NUM_TYPES:
1248                         return "FT_NUM_TYPES";
1249                 default:
1250                         return "n.a.";
1251         };
1252 }
1253
1254 char* base_display_e_to_string(base_display_e bd)
1255 {
1256         switch(bd) {
1257         case BASE_NONE:
1258                         return "BASE_NONE";
1259         case BASE_DEC:
1260                         return "BASE_DEC";
1261         case BASE_HEX:
1262                         return "BASE_HEX";
1263         case BASE_OCT:
1264                         return "BASE_OCT";
1265         case BASE_DEC_HEX:
1266                         return "BASE_DEC_HEX";
1267         case BASE_HEX_DEC:
1268                         return "BASE_HEX_DEC";
1269         default:
1270                         return "n.a.";
1271         }
1272 }
1273
1274 /*
1275  * Copied from various parts of proto.c
1276  */
1277 #define FIELD_STR_INIT_LEN 256
1278 #define cVALS(x) (const value_string*)(x)
1279 static gboolean print_field_value(field_info *finfo, int cmd_line_index)
1280 {
1281         header_field_info       *hfinfo;
1282         static char                     *fs_buf = NULL;
1283         char                            *fs_ptr = fs_buf;
1284         static GString     *label_s = NULL;
1285         int                                     fs_buf_len = FIELD_STR_INIT_LEN, fs_len;
1286         guint              i;
1287         string_fmt_t       *sf;
1288         guint32            uvalue;
1289         gint32             svalue;
1290         const true_false_string *tfstring = &tfs_true_false;
1291
1292         hfinfo = finfo->hfinfo;
1293
1294         if (!fs_buf) {
1295                 fs_buf = g_malloc(fs_buf_len + 1);
1296                 fs_ptr = fs_buf;
1297         }
1298
1299         if (!label_s) {
1300                 label_s = g_string_new("");
1301         }
1302
1303         if(finfo->value.ftype->val_to_string_repr)
1304         {
1305                 /*
1306                  * this field has an associated value,
1307                  * e.g: ip.hdr_len
1308                  */
1309                 fs_len = fvalue_string_repr_len(&finfo->value, FTREPR_DFILTER);
1310                 while (fs_buf_len < fs_len) {
1311                         fs_buf_len *= 2;
1312                         fs_buf = g_realloc(fs_buf, fs_buf_len + 1);
1313                         fs_ptr = fs_buf;
1314                 }
1315                 fvalue_to_string_repr(&finfo->value,
1316                         FTREPR_DFILTER,
1317                         fs_buf);
1318
1319                 /* String types are quoted. Remove them. */
1320                 if ((finfo->value.ftype->ftype == FT_STRING || finfo->value.ftype->ftype == FT_STRINGZ) && fs_len > 2) {
1321                         fs_buf[fs_len - 1] = '\0';
1322                         fs_ptr++;
1323                 }
1324         }
1325
1326         if (string_fmts->len > 0 && finfo->hfinfo->strings) {
1327                 g_string_truncate(label_s, 0);
1328                 for (i = 0; i < string_fmts->len; i++) {
1329                         sf = g_ptr_array_index(string_fmts, i);
1330                         if (sf->plain) {
1331                                 g_string_append(label_s, sf->plain);
1332                         } else {
1333                                 switch (sf->format) {
1334                                         case SF_NAME:
1335                                                 g_string_append(label_s, hfinfo->name);
1336                                                 break;
1337                                         case SF_NUMVAL:
1338                                                 g_string_append(label_s, fs_ptr);
1339                                                 break;
1340                                         case SF_STRVAL:
1341                                                 switch(hfinfo->type) {
1342                                                         case FT_BOOLEAN:
1343                                                                 uvalue = fvalue_get_uinteger(&finfo->value);
1344                                                                 tfstring = (const struct true_false_string*) hfinfo->strings;
1345                                                                 g_string_append(label_s, uvalue ? tfstring->true_string : tfstring->false_string);
1346                                                                 break;
1347                                                         case FT_INT8:
1348                                                         case FT_INT16:
1349                                                         case FT_INT24:
1350                                                         case FT_INT32:
1351                                                                 DISSECTOR_ASSERT(!hfinfo->bitmask);
1352                                                                 svalue = fvalue_get_sinteger(&finfo->value);
1353                                                                 if (hfinfo->display & BASE_RANGE_STRING) {
1354                                                                   g_string_append(label_s, rval_to_str(svalue, hfinfo->strings, "Unknown"));
1355                                                                 } else {
1356                                                                   g_string_append(label_s, val_to_str(svalue, cVALS(hfinfo->strings), "Unknown"));
1357                                                                 }
1358                                                         case FT_UINT8:
1359                                                         case FT_UINT16:
1360                                                         case FT_UINT24:
1361                                                         case FT_UINT32:
1362                                                                 uvalue = fvalue_get_uinteger(&finfo->value);
1363                                                                 if (!hfinfo->bitmask && hfinfo->display & BASE_RANGE_STRING) {
1364                                                                   g_string_append(label_s, rval_to_str(uvalue, hfinfo->strings, "Unknown"));
1365                                                                 } else {
1366                                                                   g_string_append(label_s, val_to_str(uvalue, cVALS(hfinfo->strings), "Unknown"));
1367                                                                 }
1368                                                                 break;
1369                                                         default:
1370                                                                 break;
1371                                                 }
1372                                                 break;
1373                                         default:
1374                                                 break;
1375                                 }
1376                         }
1377                 }
1378                 printf(" %u=\"%s\"", cmd_line_index, label_s->str);
1379                 return TRUE;
1380         }
1381
1382         if(finfo->value.ftype->val_to_string_repr)
1383         {
1384                 printf(" %u=\"%s\"", cmd_line_index, fs_ptr);
1385                 return TRUE;
1386         }
1387
1388         /*
1389          * This field doesn't have an associated value,
1390          * e.g. http
1391          * We return n.a.
1392          */
1393         printf(" %u=\"n.a.\"", cmd_line_index);
1394         return TRUE;
1395 }
1396
1397 static int
1398 protocolinfo_packet(void *prs, packet_info *pinfo _U_, epan_dissect_t *edt, const void *dummy _U_)
1399 {
1400         pci_t *rs=prs;
1401         GPtrArray *gp;
1402         guint i;
1403
1404         gp=proto_get_finfo_ptr_array(edt->tree, rs->hf_index);
1405         if(!gp){
1406                 printf(" n.a.");
1407                 return 0;
1408         }
1409
1410         /*
1411          * Print each occurrence of the field
1412          */
1413         for (i = 0; i < gp->len; i++) {
1414                 print_field_value(gp->pdata[i], rs->cmd_line_index);
1415         }
1416
1417         return 0;
1418 }
1419
1420 int g_cmd_line_index = 0;
1421
1422 /*
1423  * field must be persistent - we don't g_strdup() it below
1424  */
1425 static void
1426 protocolinfo_init(char *field)
1427 {
1428         pci_t *rs;
1429         header_field_info *hfi;
1430         GString *error_string;
1431
1432         hfi=proto_registrar_get_byname(field);
1433         if(!hfi){
1434                 fprintf(stderr, "rawshark: Field \"%s\" doesn't exist.\n", field);
1435                 exit(1);
1436         }
1437
1438         printf("%u %s %s - ",
1439                 g_cmd_line_index,
1440                 ftenum_to_string(hfi),
1441                 base_display_e_to_string(hfi->display));
1442
1443         rs=g_malloc(sizeof(pci_t));
1444         rs->hf_index=hfi->id;
1445         rs->filter=field;
1446         rs->cmd_line_index = g_cmd_line_index++;
1447
1448         error_string=register_tap_listener("frame", rs, rs->filter, NULL, protocolinfo_packet, NULL);
1449         if(error_string){
1450                 /* error, we failed to attach to the tap. complain and clean up */
1451                 fprintf(stderr, "rawshark: Couldn't register field extraction tap: %s\n",
1452                     error_string->str);
1453                 g_string_free(error_string, TRUE);
1454                 if(rs->filter){
1455                         g_free(rs->filter);
1456                 }
1457                 g_free(rs);
1458
1459                 exit(1);
1460         }
1461 }
1462
1463 /*
1464  * Given a format string, split it into a GPtrArray of string_fmt_t structs
1465  * and fill in string_fmt_parts.
1466  */
1467
1468 static void
1469 add_string_fmt(string_fmt_e format, gchar *plain) {
1470         string_fmt_t *sf = g_malloc(sizeof(string_fmt_t));
1471
1472         sf->format = format;
1473         sf->plain = g_strdup(plain);
1474
1475         g_ptr_array_add(string_fmts, sf);
1476 }
1477
1478 static gboolean
1479 parse_field_string_format(gchar *format) {
1480         GString *plain_s = g_string_new("");
1481         int len;
1482         int pos = 0;
1483
1484         if (!format) {
1485                 return FALSE;
1486         }
1487
1488         len = strlen(format);
1489         g_ptr_array_set_size(string_fmts, 0);
1490
1491         while (pos < len) {
1492                 if (format[pos] == '%') {
1493                         if (pos >= len) { /* There should always be a following character */
1494                                 return FALSE;
1495                         }
1496                         pos++;
1497                         if (plain_s->len > 0) {
1498                                 add_string_fmt(SF_NONE, plain_s->str);
1499                                 g_string_truncate(plain_s, 0);
1500                         }
1501                         switch (format[pos]) {
1502                                 case 'D':
1503                                         add_string_fmt(SF_NAME, NULL);
1504                                         break;
1505                                 case 'N':
1506                                         add_string_fmt(SF_NUMVAL, NULL);
1507                                         break;
1508                                 case 'S':
1509                                         add_string_fmt(SF_STRVAL, NULL);
1510                                         break;
1511                                 case '%':
1512                                         g_string_append_c(plain_s, '%');
1513                                         break;
1514                                 default: /* Invalid format */
1515                                         return FALSE;
1516                         }
1517                 } else {
1518                         g_string_append_c(plain_s, format[pos]);
1519                 }
1520                 pos++;
1521         }
1522
1523         if (plain_s->len > 0) {
1524                 add_string_fmt(SF_NONE, plain_s->str);
1525         }
1526         g_string_free(plain_s, TRUE);
1527
1528         return TRUE;
1529 }
1530 /****************************************************************************************
1531  * END OF FIELD EXTRACTION ROUTINES
1532  ****************************************************************************************/
1533
1534 static void
1535 show_print_file_io_error(int err)
1536 {
1537   switch (err) {
1538
1539   case ENOSPC:
1540     cmdarg_err("Not all the packets could be printed because there is "
1541 "no space left on the file system.");
1542     break;
1543
1544 #ifdef EDQUOT
1545   case EDQUOT:
1546     cmdarg_err("Not all the packets could be printed because you are "
1547 "too close to, or over your disk quota.");
1548   break;
1549 #endif
1550
1551   default:
1552     cmdarg_err("An error occurred while printing packets: %s.",
1553       strerror(err));
1554     break;
1555   }
1556 }
1557
1558 /*
1559  * Open/create errors are reported with an console message in Rawshark.
1560  */
1561 static void
1562 open_failure_message(const char *filename, int err, gboolean for_writing)
1563 {
1564   fprintf(stderr, "rawshark: ");
1565   fprintf(stderr, file_open_error_message(err, for_writing), filename);
1566   fprintf(stderr, "\n");
1567 }
1568
1569 cf_status_t
1570 raw_cf_open(capture_file *cf, const char *fname)
1571 {
1572   if ((fd = raw_pipe_open(fname)) < 0)
1573     return CF_ERROR;
1574
1575   /* The open succeeded.  Fill in the information for this file. */
1576
1577   /* Initialize all data structures used for dissection. */
1578   init_dissection();
1579
1580   cf->wth = NULL;
1581   cf->f_datalen = 0; /* not used, but set it anyway */
1582
1583   /* Set the file name because we need it to set the follow stream filter.
1584      XXX - is that still true?  We need it for other reasons, though,
1585      in any case. */
1586   cf->filename = g_strdup(fname);
1587
1588   /* Indicate whether it's a permanent or temporary file. */
1589   cf->is_tempfile = FALSE;
1590
1591   /* If it's a temporary capture buffer file, mark it as not saved. */
1592   cf->user_saved = FALSE;
1593
1594   cf->cd_t      = WTAP_FILE_UNKNOWN;
1595   cf->count     = 0;
1596   cf->drops_known = FALSE;
1597   cf->drops     = 0;
1598   cf->has_snap = FALSE;
1599   cf->snap = WTAP_MAX_PACKET_SIZE;
1600   nstime_set_zero(&cf->elapsed_time);
1601   nstime_set_unset(&first_ts);
1602   nstime_set_unset(&prev_dis_ts);
1603   nstime_set_unset(&prev_cap_ts);
1604
1605   return CF_OK;
1606 }
1607
1608
1609 /*
1610  * General errors are reported with an console message in Rawshark.
1611  */
1612 static void
1613 failure_message(const char *msg_format, va_list ap)
1614 {
1615   fprintf(stderr, "rawshark: ");
1616   vfprintf(stderr, msg_format, ap);
1617   fprintf(stderr, "\n");
1618 }
1619
1620 /*
1621  * Read errors are reported with an console message in Rawshark.
1622  */
1623 static void
1624 read_failure_message(const char *filename, int err)
1625 {
1626   cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
1627           filename, strerror(err));
1628 }
1629
1630 /*
1631  * Write errors are reported with an console message in Rawshark.
1632  */
1633 static void
1634 write_failure_message(const char *filename, int err)
1635 {
1636   cmdarg_err("An error occurred while writing to the file \"%s\": %s.",
1637           filename, strerror(err));
1638 }
1639
1640 /*
1641  * Report an error in command-line arguments.
1642  */
1643 void
1644 cmdarg_err(const char *fmt, ...)
1645 {
1646   va_list ap;
1647
1648   va_start(ap, fmt);
1649   fprintf(stderr, "rawshark: ");
1650   vfprintf(stderr, fmt, ap);
1651   fprintf(stderr, "\n");
1652   va_end(ap);
1653 }
1654
1655 /*
1656  * Report additional information for an error in command-line arguments.
1657  */
1658 void
1659 cmdarg_err_cont(const char *fmt, ...)
1660 {
1661   va_list ap;
1662
1663   va_start(ap, fmt);
1664   vfprintf(stderr, fmt, ap);
1665   fprintf(stderr, "\n");
1666   va_end(ap);
1667 }
1668
1669
1670 /****************************************************************************************************************/
1671 /* other "dummies" */
1672 void
1673 cf_mark_frame(capture_file *cf _U_, frame_data *frame _U_)
1674 {
1675     /* shouldn't happen */
1676     g_assert_not_reached();
1677 }
1678
1679 /*
1680  * Editor modelines
1681  *
1682  * Local Variables:
1683  * c-basic-offset: 4
1684  * tab-width: 4
1685  * indent-tabs-mode: t
1686  * End:
1687  *
1688  * ex: set shiftwidth=4 tabstop=4 noexpandtab
1689  * :indentSize=4:tabSize=4:noTabs=false:
1690  */