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