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