rawshark.c

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