rawshark.c

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