#include <signal.h>
-#ifdef HAVE_LIBPCAP
-#include <pcap.h>
-#include <setjmp.h>
-#endif
-
#ifdef HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
-#ifdef NEED_SNPRINTF_H
-# include "snprintf.h"
-#endif
-
#ifdef NEED_STRERROR_H
#include "strerror.h"
#endif
#include "getopt.h"
#endif
-#include "svnversion.h"
-
#include <glib.h>
#include <epan/epan.h>
#include <epan/filesystem.h>
+#include <wiretap/file_util.h>
#include "globals.h"
#include <epan/timestamp.h>
#include <epan/addr_resolv.h>
#include "util.h"
#include "clopts_common.h"
+#include "cmdarg_err.h"
#include "version_info.h"
#include <epan/conversation.h>
#include <epan/plugins.h>
#include "capture_ui_utils.h"
#include <epan/epan_dissect.h>
#include <epan/tap.h>
+#include <epan/stat_cmd_args.h>
#include <epan/timestamp.h>
#ifdef HAVE_LIBPCAP
#include <pcap.h>
-#include "pcap-util.h"
+#include <setjmp.h>
+#include "capture-pcap-util.h"
#include <wiretap/wtap-capture.h>
-#include <wiretap/libpcap.h>
#ifdef _WIN32
#include "capture-wpcap.h"
-#endif
+#include "capture_errs.h"
+#endif /* _WIN32 */
#include "capture.h"
-#endif
-
+#include "capture_loop.h"
+#endif /* HAVE_LIBPCAP */
+#include "epan/emem.h"
+#include "log.h"
/*
* This is the template for the decode as option; it is shared between the
*/
static const gchar decode_as_arg_template[] = "<layer_type>==<selector>,<decode_as_protocol>";
-static guint32 firstsec, firstusec;
-static guint32 prevsec, prevusec;
+static nstime_t first_ts;
+static nstime_t prev_ts;
static GString *comp_info_str, *runtime_info_str;
static gboolean print_packet_info; /* TRUE if we're to print packet information */
*/
static gboolean print_packet_counts;
-typedef struct _loop_data {
- gboolean go; /* TRUE as long as we're supposed to keep capturing */
- gint linktype;
- gboolean from_pipe; /* TRUE if we are capturing data from a pipe */
- pcap_t *pch;
- char *save_file; /* Name of file to which we're writing */
- wtap_dumper *pdh;
- jmp_buf stopenv;
- gboolean output_to_pipe;
- int packet_count;
-#ifndef _WIN32
- gboolean modified; /* TRUE if data in the pipe uses modified pcap headers */
- gboolean byte_swapped; /* TRUE if data in the pipe is byte swapped */
- unsigned int bytes_to_read, bytes_read; /* Used by pipe_dispatch */
- enum {
- STATE_EXPECT_REC_HDR, STATE_READ_REC_HDR,
- STATE_EXPECT_DATA, STATE_READ_DATA
- } pipe_state;
- enum { PIPOK, PIPEOF, PIPERR, PIPNEXIST } pipe_err;
-#endif
-} loop_data;
static loop_data ld;
static int capture(char *, int);
-static void capture_pcap_cb(guchar *, const struct pcap_pkthdr *,
- const guchar *);
+static void capture_pcap_cb(u_char *, const struct pcap_pkthdr *,
+ const u_char *);
static void report_counts(void);
#ifdef _WIN32
static BOOL WINAPI capture_cleanup(DWORD);
static gboolean write_preamble(capture_file *cf);
static gboolean print_packet(capture_file *cf, epan_dissect_t *edt);
static gboolean write_finale(void);
-static char *cf_open_error_message(int err, gchar *err_info,
+static const char *cf_open_error_message(int err, gchar *err_info,
gboolean for_writing, int file_type);
-#ifdef HAVE_LIBPCAP
-#ifndef _WIN32
-static void adjust_header(loop_data *, struct pcap_hdr *, struct pcaprec_hdr *);
-static int pipe_open_live(char *, struct pcap_hdr *, loop_data *, char *, int);
-static int pipe_dispatch(int, loop_data *, struct pcap_hdr *, \
- struct pcaprec_modified_hdr *, guchar *, char *, int);
-#endif /* _WIN32 */
-#endif
static void open_failure_message(const char *filename, int err,
gboolean for_writing);
if (print_ver) {
output = stdout;
- fprintf(output, "This is GNU t" PACKAGE " " VERSION
-#ifdef SVNVERSION
- " (" SVNVERSION ")"
-#endif
- "\n (C) 1998-2004 Gerald Combs <gerald@ethereal.com>"
- "\n%s\n%s\n",
+ fprintf(output, "This is t" PACKAGE " " VERSION "%s\n"
+ "\n"
+ "%s"
+ "\n"
+ "%s"
+ "\n"
+ "%s",
- comp_info_str->str, runtime_info_str->str);
+ svnversion, get_copyright_info(), comp_info_str->str,
+ runtime_info_str->str);
} else {
output = stderr;
}
#ifdef HAVE_LIBPCAP
fprintf(output, "\nt%s [ -vh ] [ -DlLnpqSVx ] [ -a <capture autostop condition> ] ...\n",
PACKAGE);
- fprintf(output, "\t[ -b <number of ring buffer files>[:<duration>] ] [ -c <count> ]\n");
+ fprintf(output, "\t[ -b <capture ring buffer option> ] ...\n");
+#ifdef _WIN32
+ fprintf(output, "\t[ -B <capture buffer size> ]\n");
+#endif
+ fprintf(output, "\t[ -c <capture packet count> ]\n");
fprintf(output, "\t[ -d %s ] ...\n", decode_as_arg_template);
- fprintf(output, "\t[ -f <capture filter> ] [ -F <output file type> ] [ -i <interface> ]\n");
- fprintf(output, "\t[ -N <resolving> ] [ -o <preference setting> ] ... [ -r <infile> ]\n");
- fprintf(output, "\t[ -R <read filter> ] [ -s <snaplen> ] [ -t <time stamp format> ]\n");
- fprintf(output, "\t[ -T pdml|ps|psml|text ] [ -w <savefile> ] [ -y <link type> ]\n");
- fprintf(output, "\t[ -z <statistics string> ]\n");
+ fprintf(output, "\t[ -f <capture filter> ] [ -F <output file type> ]\n");
+ fprintf(output, "\t[ -i <capture interface> ] [ -N <name resolving flags> ]\n");
+ fprintf(output, "\t[ -o <preference setting> ] ... [ -r <infile> ]\n");
+ fprintf(output, "\t[ -R <read (display) filter> ] [ -s <capture snaplen> ]\n");
+ fprintf(output, "\t[ -t <time stamp format> ] [ -T pdml|ps|psml|text ]\n");
+ fprintf(output, "\t[ -w <savefile> ] [ -y <capture link type> ] [ -z <statistics> ]\n");
#else
fprintf(output, "\nt%s [ -vh ] [ -lnVx ]\n", PACKAGE);
fprintf(output, "\t[ -d %s ] ...\n", decode_as_arg_template);
- fprintf(output, "\t[ -F <output file type> ] [ -N <resolving> ]\n");
- fprintf(output, "\t[ -o <preference setting> ] ... [ -r <infile> ] [ -R <read filter> ]\n");
- fprintf(output, "\t[ -t <time stamp format> ] [ -T pdml|ps|psml|text ] [ -w <savefile> ]\n");
- fprintf(output, "\t[ -z <statistics string> ]\n");
+ fprintf(output, "\t[ -F <output file type> ] [ -N <name resolving flags> ]\n");
+ fprintf(output, "\t[ -o <preference setting> ] ... [ -r <infile> ]\n");
+ fprintf(output, "\t[ -R <read (display) filter> ] \t[ -t <time stamp format> ]\n");
+ fprintf(output, "\t[ -T pdml|ps|psml|text ] [ -w <savefile> ] [ -z <statistics ]\n");
#endif
fprintf(output, "Valid file type arguments to the \"-F\" flag:\n");
for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
* descriptive name.
*/
static void
-display_dissector_table_names(char *table_name, char *ui_name, gpointer output)
+display_dissector_table_names(char *table_name, const char *ui_name,
+ gpointer output)
{
fprintf((FILE *)output, "\t%s (%s)\n", table_name, ui_name);
}
* name for the protocol that corresponds to this handle.
*/
static void
-display_dissector_names(gchar *table _U_, gpointer handle, gpointer output)
+display_dissector_names(const gchar *table _U_, gpointer handle, gpointer output)
{
int proto_id;
const gchar* proto_filter_name;
* whole list of dissectors.
*/
static void
-find_protocol_name_func(gchar *table _U_, gpointer handle, gpointer user_data)
+find_protocol_name_func(const gchar *table _U_, gpointer handle, gpointer user_data)
{
int proto_id;
remaining_param = strchr(table_name, '=');
if (remaining_param == NULL) {
- fprintf(stderr, "tethereal: Parameter \"%s\" doesn't follow the template \"%s\"\n", cl_param, decode_as_arg_template);
+ cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
/* If the argument does not follow the template, carry on anyway to check
if the table name is at least correct. If remaining_param is NULL,
we'll exit anyway further down */
/* Look for the requested table */
if ( !(*(table_name)) ) { /* Is the table name empty, if so, don't even search for anything, display a message */
- fprintf(stderr, "tethereal: No layer type specified\n"); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
+ cmdarg_err("No layer type specified"); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
}
else {
table_matching = find_dissector_table(table_name);
if (!table_matching) {
- fprintf(stderr, "tethereal: Unknown layer type -- %s\n", table_name); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
+ cmdarg_err("Unknown layer type -- %s", table_name); /* Note, we don't exit here, but table_matching will remain NULL, so we exit below */
}
}
if (!table_matching) {
/* Display a list of supported layer types to help the user, if the
specified layer type was not found */
- fprintf(stderr, "tethereal: Valid layer types are:\n");
+ cmdarg_err("Valid layer types are:");
fprint_all_layer_types(stderr);
}
if (remaining_param == NULL || !table_matching) {
}
if (*(remaining_param + 1) != '=') { /* Check for "==" and not only '=' */
- fprintf(stderr, "tethereal: WARNING: -d requires \"==\" instead of \"=\". Option will be treated as \"%s==%s\"\n", table_name, remaining_param + 1);
+ cmdarg_err("WARNING: -d requires \"==\" instead of \"=\". Option will be treated as \"%s==%s\"", table_name, remaining_param + 1);
}
else {
remaining_param++; /* Move to the second '=' */
remaining_param = strchr(selector_str, ',');
if (remaining_param == NULL) {
- fprintf(stderr, "tethereal: Parameter \"%s\" doesn't follow the template \"%s\"\n", cl_param, decode_as_arg_template);
+ cmdarg_err("Parameter \"%s\" doesn't follow the template \"%s\"", cl_param, decode_as_arg_template);
/* If the argument does not follow the template, carry on anyway to check
if the selector value is at least correct. If remaining_param is NULL,
we'll exit anyway further down */
There's no need to remove leading and trailing spaces from the
selector number string, because sscanf will do that for us. */
if ( sscanf(selector_str, "%u", &selector) != 1 ) {
- fprintf(stderr, "tethereal: Invalid selector number \"%s\"\n", selector_str);
+ cmdarg_err("Invalid selector number \"%s\"", selector_str);
g_free(decoded_param);
return FALSE;
}
if (remaining_param == NULL) {
/* Exit if no ',' separator was found (see above) */
- fprintf(stderr, "tethereal: Valid protocols for layer type \"%s\" are:\n", table_name);
+ cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
fprint_all_protocols_for_layer_types(stderr, table_name);
g_free(decoded_param);
return FALSE;
/* We now have a pointer to the handle for the requested table inside the variable table_matching */
if ( ! (*dissector_str) ) { /* Is the dissector name empty, if so, don't even search for a matching dissector and display all dissectors found for the selected table */
- fprintf(stderr, "tethereal: No protocol name specified\n"); /* Note, we don't exit here, but dissector_matching will remain NULL, so we exit below */
+ cmdarg_err("No protocol name specified"); /* Note, we don't exit here, but dissector_matching will remain NULL, so we exit below */
}
else {
user_protocol_name.nb_match = 0;
if (user_protocol_name.nb_match != 0) {
dissector_matching = user_protocol_name.matched_handle;
if (user_protocol_name.nb_match > 1) {
- fprintf(stderr, "tethereal: WARNING: Protocol \"%s\" matched %u dissectors, first one will be used\n", dissector_str, user_protocol_name.nb_match);
+ cmdarg_err("WARNING: Protocol \"%s\" matched %u dissectors, first one will be used", dissector_str, user_protocol_name.nb_match);
}
}
else {
so we exit below */
if (proto_get_id_by_filter_name(dissector_str) == -1) {
/* No such protocol */
- fprintf(stderr, "tethereal: Unknown protocol -- \"%s\"\n", dissector_str);
+ cmdarg_err("Unknown protocol -- \"%s\"", dissector_str);
} else {
- fprintf(stderr, "tethereal: Protocol \"%s\" isn't valid for layer type \"%s\"\n",
+ cmdarg_err("Protocol \"%s\" isn't valid for layer type \"%s\"",
dissector_str, table_name);
}
}
}
if (!dissector_matching) {
- fprintf(stderr, "tethereal: Valid protocols for layer type \"%s\" are:\n", table_name);
+ cmdarg_err("Valid protocols for layer type \"%s\" are:", table_name);
fprint_all_protocols_for_layer_types(stderr, table_name);
g_free(decoded_param);
return FALSE;
return TRUE;
}
+static void
+log_func_ignore (const gchar *log_domain _U_, GLogLevelFlags log_level _U_,
+ const gchar *message _U_, gpointer user_data _U_)
+{
+}
+
int
main(int argc, char *argv[])
{
int err;
#ifdef HAVE_LIBPCAP
gboolean capture_filter_specified = FALSE;
- GList *if_list, *if_entry;
- if_info_t *if_info;
- long adapter_index;
- char *p;
- gchar err_str[PCAP_ERRBUF_SIZE];
- gchar *cant_get_if_list_errstr;
gboolean list_link_layer_types = FALSE;
+ gboolean start_capture = FALSE;
#else
gboolean capture_option_specified = FALSE;
#endif
gchar *save_file = NULL;
int out_file_type = WTAP_FILE_PCAP;
gchar *cf_name = NULL, *rfilter = NULL;
-#ifdef HAVE_LIBPCAP
- gboolean start_capture = FALSE;
- gchar *if_text;
- GList *lt_list, *lt_entry;
- data_link_info_t *data_link_info;
-#endif
#ifdef HAVE_PCAP_OPEN_DEAD
struct bpf_program fcode;
#endif
dfilter_t *rfcode = NULL;
e_prefs *prefs;
char badopt;
+ GLogLevelFlags log_flags;
+
+#define OPTSTRING_INIT "a:b:c:d:Df:F:hi:lLnN:o:pqr:R:s:St:T:vVw:xy:z:"
+#ifdef HAVE_LIBPCAP
+#ifdef _WIN32
+#define OPTSTRING_WIN32 "B:"
+#else
+#define OPTSTRING_WIN32 ""
+#endif /* _WIN32 */
+#else
+#define OPTSTRING_WIN32 ""
+#endif /* HAVE_LIBPCAP */
+
+ static const char optstring[] = OPTSTRING_INIT OPTSTRING_WIN32;
+
+ /* nothing more than the standard GLib handler, but without a warning */
+ log_flags =
+ G_LOG_LEVEL_ERROR|
+ G_LOG_LEVEL_CRITICAL|
+ G_LOG_LEVEL_WARNING|
+ G_LOG_LEVEL_MESSAGE|
+ G_LOG_LEVEL_INFO|
+ G_LOG_LEVEL_DEBUG|
+ G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
+
+ g_log_set_handler(NULL,
+ log_flags,
+ log_func_ignore, NULL /* user_data */);
+ g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
+ log_flags,
+ log_func_ignore, NULL /* user_data */);
+
+ /* initialize memory allocation subsystem */
+ ep_init_chunk();
+ se_init_chunk();
#ifdef HAVE_LIBPCAP
capture_opts_init(&capture_opts, NULL /* cfile */);
#endif
- set_timestamp_setting(TS_RELATIVE);
+ timestamp_set_type(TS_RELATIVE);
+ timestamp_set_precision(TS_PREC_AUTO);
/* Register all dissectors; we must do this before checking for the
"-G" flag, as the "-G" flag dumps information registered by the
/* we register the plugin taps before the other taps because
stats_tree taps plugins will be registered as tap listeners
by stats_tree_stat.c and need to registered before that */
+#ifdef HAVE_PLUGINS
register_all_plugin_tap_listeners();
+#endif
register_all_tap_listeners();
/* Now register the preferences for any non-dissector modules.
for backwards compatibility we dump out a glossary of display
filter symbols.
- We do this here to mirror what happens in the GTK+ version, although
- it's not necessary here. */
- handle_dashG_option(argc, argv, "tethereal");
+ XXX - we do this here, for now, to support "-G" with no arguments.
+ If none of our build or other processes uses "-G" with no arguments,
+ we can just process it with the other arguments. */
+ if (argc >= 2 && strcmp(argv[1], "-G") == 0) {
+ if (argc == 2)
+ proto_registrar_dump_fields(1);
+ else {
+ if (strcmp(argv[2], "fields") == 0)
+ proto_registrar_dump_fields(1);
+ else if (strcmp(argv[2], "fields2") == 0)
+ proto_registrar_dump_fields(2);
+ else if (strcmp(argv[2], "fields3") == 0)
+ proto_registrar_dump_fields(3);
+ else if (strcmp(argv[2], "protocols") == 0)
+ proto_registrar_dump_protocols();
+ else if (strcmp(argv[2], "values") == 0)
+ proto_registrar_dump_values();
+ else if (strcmp(argv[2], "decodes") == 0)
+ dissector_dump_decodes();
+ else if (strcmp(argv[2], "defaultprefs") == 0)
+ write_prefs(NULL);
+ else if (strcmp(argv[2], "currentprefs") == 0) {
+ read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path,
+ &pf_open_errno, &pf_read_errno, &pf_path);
+ write_prefs(NULL);
+ } else {
+ cmdarg_err("Invalid \"%s\" option for -G flag", argv[2]);
+ exit(1);
+ }
+ }
+ exit(0);
+ }
/* Set the C-language locale to the native environment. */
setlocale(LC_ALL, "");
&pf_open_errno, &pf_read_errno, &pf_path);
if (gpf_path != NULL) {
if (gpf_open_errno != 0) {
- fprintf(stderr, "Can't open global preferences file \"%s\": %s.\n",
+ cmdarg_err("Can't open global preferences file \"%s\": %s.",
pf_path, strerror(gpf_open_errno));
}
if (gpf_read_errno != 0) {
- fprintf(stderr, "I/O error reading global preferences file \"%s\": %s.\n",
+ cmdarg_err("I/O error reading global preferences file \"%s\": %s.",
pf_path, strerror(gpf_read_errno));
}
}
if (pf_path != NULL) {
if (pf_open_errno != 0) {
- fprintf(stderr, "Can't open your preferences file \"%s\": %s.\n", pf_path,
+ cmdarg_err("Can't open your preferences file \"%s\": %s.", pf_path,
strerror(pf_open_errno));
}
if (pf_read_errno != 0) {
- fprintf(stderr, "I/O error reading your preferences file \"%s\": %s.\n",
+ cmdarg_err("I/O error reading your preferences file \"%s\": %s.",
pf_path, strerror(pf_read_errno));
}
g_free(pf_path);
&dp_path, &dp_open_errno, &dp_read_errno);
if (gdp_path != NULL) {
if (gdp_open_errno != 0) {
- fprintf(stderr,
- "Could not open global disabled protocols file\n\"%s\": %s.\n",
+ cmdarg_err(
+ "Could not open global disabled protocols file\n\"%s\": %s.",
gdp_path, strerror(gdp_open_errno));
}
if (gdp_read_errno != 0) {
- fprintf(stderr,
- "I/O error reading global disabled protocols file\n\"%s\": %s.\n",
+ cmdarg_err(
+ "I/O error reading global disabled protocols file\n\"%s\": %s.",
gdp_path, strerror(gdp_read_errno));
}
g_free(gdp_path);
}
if (dp_path != NULL) {
if (dp_open_errno != 0) {
- fprintf(stderr,
- "Could not open your disabled protocols file\n\"%s\": %s.\n", dp_path,
+ cmdarg_err(
+ "Could not open your disabled protocols file\n\"%s\": %s.", dp_path,
strerror(dp_open_errno));
}
if (dp_read_errno != 0) {
- fprintf(stderr,
- "I/O error reading your disabled protocols file\n\"%s\": %s.\n", dp_path,
+ cmdarg_err(
+ "I/O error reading your disabled protocols file\n\"%s\": %s.", dp_path,
strerror(dp_read_errno));
}
g_free(dp_path);
print_format = PR_FMT_TEXT;
/* Now get our args */
- while ((opt = getopt(argc, argv, "a:b:c:d:Df:F:hi:lLnN:o:pqr:R:s:St:T:vw:Vxy:z:")) != -1) {
+ while ((opt = getopt(argc, argv, optstring)) != -1) {
switch (opt) {
case 'a': /* autostop criteria */
case 'b': /* Ringbuffer option */
case 'c': /* Capture xxx packets */
case 'f': /* capture filter */
+ case 'i': /* Use interface xxx */
case 'p': /* Don't capture in promiscuous mode */
case 's': /* Set the snapshot (capture) length */
case 'y': /* Set the pcap data link type */
+#ifdef _WIN32
+ case 'B': /* Buffer size */
+#endif /* _WIN32 */
#ifdef HAVE_LIBPCAP
- capture_opts_add_opt(&capture_opts, "tethereal", opt, optarg, &start_capture);
+ capture_opts_add_opt(&capture_opts, opt, optarg, &start_capture);
#else
capture_option_specified = TRUE;
arg_error = TRUE;
if (!add_decode_as(optarg))
exit(1);
break;
- case 'D': /* Print a list of capture devices */
+ case 'D': /* Print a list of capture devices and exit */
#ifdef HAVE_LIBPCAP
- if_list = get_interface_list(&err, err_str);
- if (if_list == NULL) {
- switch (err) {
-
- case CANT_GET_INTERFACE_LIST:
- cant_get_if_list_errstr =
- cant_get_if_list_error_message(err_str);
- fprintf(stderr, "tethereal: %s\n", cant_get_if_list_errstr);
- g_free(cant_get_if_list_errstr);
- break;
-
- case NO_INTERFACES_FOUND:
- fprintf(stderr, "tethereal: There are no interfaces on which a capture can be done\n");
- break;
- }
- exit(2);
- }
- i = 1; /* Interface id number */
- for (if_entry = g_list_first(if_list); if_entry != NULL;
- if_entry = g_list_next(if_entry)) {
- if_info = if_entry->data;
- printf("%d. %s", i++, if_info->name);
- if (if_info->description != NULL)
- printf(" (%s)", if_info->description);
- printf("\n");
- }
- free_interface_list(if_list);
+ capture_opts_list_interfaces();
exit(0);
#else
capture_option_specified = TRUE;
case 'F':
out_file_type = wtap_short_string_to_file_type(optarg);
if (out_file_type < 0) {
- fprintf(stderr, "tethereal: \"%s\" isn't a valid capture file type\n",
+ cmdarg_err("\"%s\" isn't a valid capture file type",
optarg);
exit(1);
}
print_usage(TRUE);
exit(0);
break;
- case 'i': /* Use interface xxx */
-#ifdef HAVE_LIBPCAP
- /*
- * If the argument is a number, treat it as an index into the list
- * of adapters, as printed by "tethereal -D".
- *
- * This should be OK on UNIX systems, as interfaces shouldn't have
- * names that begin with digits. It can be useful on Windows, where
- * more than one interface can have the same name.
- */
- adapter_index = strtol(optarg, &p, 10);
- if (p != NULL && *p == '\0') {
- if (adapter_index < 0) {
- fprintf(stderr,
- "tethereal: The specified adapter index is a negative number\n");
- exit(1);
- }
- if (adapter_index > INT_MAX) {
- fprintf(stderr,
- "tethereal: The specified adapter index is too large (greater than %d)\n",
- INT_MAX);
- exit(1);
- }
- if (adapter_index == 0) {
- fprintf(stderr, "tethereal: there is no interface with that adapter index\n");
- exit(1);
- }
- if_list = get_interface_list(&err, err_str);
- if (if_list == NULL) {
- switch (err) {
-
- case CANT_GET_INTERFACE_LIST:
- cant_get_if_list_errstr =
- cant_get_if_list_error_message(err_str);
- fprintf(stderr, "tethereal: %s\n", cant_get_if_list_errstr);
- g_free(cant_get_if_list_errstr);
- break;
-
- case NO_INTERFACES_FOUND:
- fprintf(stderr, "tethereal: There are no interfaces on which a capture can be done\n");
- break;
- }
- exit(2);
- }
- if_info = g_list_nth_data(if_list, adapter_index - 1);
- if (if_info == NULL) {
- fprintf(stderr, "tethereal: there is no interface with that adapter index\n");
- exit(1);
- }
- capture_opts.iface = g_strdup(if_info->name);
- free_interface_list(if_list);
- } else
- capture_opts.iface = g_strdup(optarg);
-#else
- capture_option_specified = TRUE;
- arg_error = TRUE;
-#endif
- break;
case 'l': /* "Line-buffer" standard output */
/* This isn't line-buffering, strictly speaking, it's just
flushing the standard output after the information for
g_resolv_flags = RESOLV_NONE;
badopt = string_to_name_resolve(optarg, &g_resolv_flags);
if (badopt != '\0') {
- fprintf(stderr, "tethereal: -N specifies unknown resolving option '%c'; valid options are 'm', 'n', and 't'\n",
+ cmdarg_err("-N specifies unknown resolving option '%c'; valid options are 'm', 'n', and 't'",
badopt);
exit(1);
}
switch (prefs_set_pref(optarg)) {
case PREFS_SET_SYNTAX_ERR:
- fprintf(stderr, "tethereal: Invalid -o flag \"%s\"\n", optarg);
+ cmdarg_err("Invalid -o flag \"%s\"", optarg);
exit(1);
break;
case PREFS_SET_NO_SUCH_PREF:
case PREFS_SET_OBSOLETE:
- fprintf(stderr, "tethereal: -o flag \"%s\" specifies unknown preference\n",
+ cmdarg_err("-o flag \"%s\" specifies unknown preference",
optarg);
exit(1);
break;
break;
case 't': /* Time stamp type */
if (strcmp(optarg, "r") == 0)
- set_timestamp_setting(TS_RELATIVE);
+ timestamp_set_type(TS_RELATIVE);
else if (strcmp(optarg, "a") == 0)
- set_timestamp_setting(TS_ABSOLUTE);
+ timestamp_set_type(TS_ABSOLUTE);
else if (strcmp(optarg, "ad") == 0)
- set_timestamp_setting(TS_ABSOLUTE_WITH_DATE);
+ timestamp_set_type(TS_ABSOLUTE_WITH_DATE);
else if (strcmp(optarg, "d") == 0)
- set_timestamp_setting(TS_DELTA);
+ timestamp_set_type(TS_DELTA);
else {
- fprintf(stderr, "tethereal: Invalid time stamp type \"%s\"\n",
+ cmdarg_err("Invalid time stamp type \"%s\"",
optarg);
- fprintf(stderr, "It must be \"r\" for relative, \"a\" for absolute,\n");
- fprintf(stderr, "\"ad\" for absolute with date, or \"d\" for delta.\n");
+ cmdarg_err_cont("It must be \"r\" for relative, \"a\" for absolute,");
+ cmdarg_err_cont("\"ad\" for absolute with date, or \"d\" for delta.");
exit(1);
}
break;
output_action = WRITE_XML;
verbose = FALSE;
} else {
- fprintf(stderr, "tethereal: Invalid -T parameter.\n");
- fprintf(stderr, "It must be \"ps\", \"text\", \"pdml\", or \"psml\".\n");
+ cmdarg_err("Invalid -T parameter.");
+ cmdarg_err_cont("It must be \"ps\", \"text\", \"pdml\", or \"psml\".");
exit(1);
}
break;
case 'v': /* Show version and exit */
- printf("t" PACKAGE " " VERSION
-#ifdef SVNVERSION
- " (" SVNVERSION ")"
-#endif
- "\n%s\n%s\n",
- comp_info_str->str, runtime_info_str->str);
+ printf("t" PACKAGE " " VERSION "%s\n"
+ "\n"
+ "%s"
+ "\n"
+ "%s"
+ "\n"
+ "%s",
+ svnversion, get_copyright_info(), comp_info_str->str,
+ runtime_info_str->str);
exit(0);
break;
case 'w': /* Write to capture file xxx */
print_hex = TRUE;
break;
case 'z':
- /* We won't call the init function for the tap this soon
+ /* We won't call the init function for the stat this soon
as it would disallow MATE's fields (which are registered
by the preferences set callback) from being used as
part of a tap filter. Instead, we just add the argument
- to a list of tap arguments. */
- if (!process_tap_cmd_arg(optarg)) {
- fprintf(stderr,"tethereal: invalid -z argument.\n");
- fprintf(stderr," -z argument must be one of :\n");
- list_tap_cmd_args();
+ to a list of stat arguments. */
+ if (!process_stat_cmd_arg(optarg)) {
+ cmdarg_err("invalid -z argument.");
+ cmdarg_err_cont(" -z argument must be one of :");
+ list_stat_cmd_args();
exit(1);
}
break;
if (optind < argc) {
if (cf_name != NULL) {
if (rfilter != NULL) {
- fprintf(stderr,
-"tethereal: Read filters were specified both with \"-R\" and with additional command-line arguments\n");
+ cmdarg_err("Read filters were specified both with \"-R\" "
+ "and with additional command-line arguments");
exit(2);
}
rfilter = get_args_as_string(argc, argv, optind);
} else {
#ifdef HAVE_LIBPCAP
if (capture_filter_specified) {
- fprintf(stderr,
-"tethereal: Capture filters were specified both with \"-f\" and with additional command-line arguments\n");
+ cmdarg_err("Capture filters were specified both with \"-f\""
+ " and with additional command-line arguments");
exit(2);
}
capture_opts.cfilter = get_args_as_string(argc, argv, optind);
break;
default: /* couldn't stat it */
- fprintf(stderr,
- "tethereal: Error testing whether capture file is a pipe: %s\n",
+ cmdarg_err("Error testing whether capture file is a pipe: %s",
strerror(errno));
exit(2);
}
#ifndef HAVE_LIBPCAP
if (capture_option_specified)
- fprintf(stderr, "This version of Tethereal was not built with support for capturing packets.\n");
+ cmdarg_err("This version of Tethereal was not built with support for capturing packets.");
#endif
if (arg_error) {
print_usage(FALSE);
#ifdef HAVE_LIBPCAP
if (cf_name != NULL) {
if (capture_filter_specified) {
- fprintf(stderr,
-"tethereal: Only read filters, not capture filters, can be specified when reading a capture file.\n");
+ cmdarg_err("Only read filters, not capture filters, "
+ "can be specified when reading a capture file.");
exit(2);
}
}
if (print_hex) {
if (output_action != WRITE_TEXT) {
- fprintf(stderr, "tethereal: Raw packet hex data can only be printed as text or PostScript\n");
+ cmdarg_err("Raw packet hex data can only be printed as text or PostScript");
exit(1);
}
}
did the user also specify a capture file to be read? */
if (cf_name) {
/* Yes - that's bogus. */
- fprintf(stderr, "tethereal: You can't specify -L and a capture file to be read.\n");
+ cmdarg_err("You can't specify -L and a capture file to be read.");
exit(1);
}
/* No - did they specify a ring buffer option? */
if (capture_opts.multi_files_on) {
- fprintf(stderr, "tethereal: Ring buffer requested, but a capture isn't being done.\n");
+ cmdarg_err("Ring buffer requested, but a capture isn't being done.");
exit(1);
}
} else {
/* If they didn't specify a "-w" flag, but specified a maximum capture
file size, tell them that this doesn't work, and exit. */
if (capture_opts.has_autostop_filesize && save_file == NULL) {
- fprintf(stderr, "tethereal: Maximum capture file size specified, but "
- "capture isn't being saved to a file.\n");
+ cmdarg_err("Maximum capture file size specified, but "
+ "capture isn't being saved to a file.");
exit(1);
}
file size is set to "infinite";
d) file must not be a pipe. */
if (save_file == NULL) {
- fprintf(stderr, "tethereal: Ring buffer requested, but "
- "capture isn't being saved to a file.\n");
+ cmdarg_err("Ring buffer requested, but capture isn't being saved to a file.");
exit(1);
}
if (out_file_type != WTAP_FILE_PCAP) {
- fprintf(stderr, "tethereal: Ring buffer requested, but "
- "capture isn't being saved in libpcap format.\n");
+ cmdarg_err("Ring buffer requested, but "
+ "capture isn't being saved in libpcap format.");
exit(2);
}
if (!capture_opts.has_autostop_filesize) {
- fprintf(stderr, "tethereal: Ring buffer requested, but "
- "no maximum capture file size was specified.\n");
+ cmdarg_err("Ring buffer requested, but "
+ "no maximum capture file size was specified.");
exit(2);
}
if (ld.output_to_pipe) {
- fprintf(stderr, "tethereal: Ring buffer requested, but "
- "capture file is a pipe.\n");
+ cmdarg_err("Ring buffer requested, but capture file is a pipe.");
exit(2);
}
}
prefs_apply_all();
/* At this point MATE will have registered its field array so we can
- have a filter with one of MATE's late-registered fields as part
- of the tap's filter. We can now process all the "-z" arguments. */
- start_requested_taps();
+ have a tap filter with one of MATE's late-registered fields as part
+ of the filter. We can now process all the "-z" arguments. */
+ start_requested_stats();
/* disabled protocols as per configuration file */
if (gdp_path == NULL && dp_path == NULL) {
}
#ifdef HAVE_LIBPCAP
- if (capture_opts.snaplen < 1)
- capture_opts.snaplen = WTAP_MAX_PACKET_SIZE;
- else if (capture_opts.snaplen < MIN_PACKET_SIZE)
- capture_opts.snaplen = MIN_PACKET_SIZE;
-
- /* Check the value range of the ring_num_files parameter */
- if (capture_opts.ring_num_files > RINGBUFFER_MAX_NUM_FILES)
- capture_opts.ring_num_files = RINGBUFFER_MAX_NUM_FILES;
-#if RINGBUFFER_MIN_NUM_FILES > 0
- else if (capture_opts.ring_num_files < RINGBUFFER_MIN_NUM_FILES)
- capture_opts.ring_num_files = RINGBUFFER_MIN_NUM_FILES;
-#endif
+ capture_opts_trim_snaplen(&capture_opts, MIN_PACKET_SIZE);
+ capture_opts_trim_ring_num_files(&capture_opts);
#endif
if (rfilter != NULL) {
if (!dfilter_compile(rfilter, &rfcode)) {
- fprintf(stderr, "tethereal: %s\n", dfilter_error_msg);
+ cmdarg_err("%s", dfilter_error_msg);
epan_cleanup();
#ifdef HAVE_PCAP_OPEN_DEAD
{
pc = pcap_open_dead(DLT_EN10MB, MIN_PACKET_SIZE);
if (pc != NULL) {
if (pcap_compile(pc, &fcode, rfilter, 0, 0) != -1) {
- fprintf(stderr,
- " Note: That display filter code looks like a valid capture filter;\n"
- " maybe you mixed them up?\n");
+ cmdarg_err_cont(
+ " Note: That display filter code looks like a valid capture filter;");
+ cmdarg_err_cont(
+ " maybe you mixed them up?");
}
pcap_close(pc);
}
epan_cleanup();
exit(2);
}
+
+ /* Set timestamp precision; there should arguably be a command-line
+ option to let the user set this. */
+ switch(wtap_file_tsprecision(cfile.wth)) {
+ case(WTAP_FILE_TSPREC_SEC):
+ timestamp_set_precision(TS_PREC_AUTO_SEC);
+ break;
+ case(WTAP_FILE_TSPREC_DSEC):
+ timestamp_set_precision(TS_PREC_AUTO_DSEC);
+ break;
+ case(WTAP_FILE_TSPREC_CSEC):
+ timestamp_set_precision(TS_PREC_AUTO_CSEC);
+ break;
+ case(WTAP_FILE_TSPREC_MSEC):
+ timestamp_set_precision(TS_PREC_AUTO_MSEC);
+ break;
+ case(WTAP_FILE_TSPREC_USEC):
+ timestamp_set_precision(TS_PREC_AUTO_USEC);
+ break;
+ case(WTAP_FILE_TSPREC_NSEC):
+ timestamp_set_precision(TS_PREC_AUTO_NSEC);
+ break;
+ default:
+ g_assert_not_reached();
+ }
+
+ /* Process the packets in the file */
err = load_cap_file(&cfile, save_file, out_file_type);
if (err != 0) {
epan_cleanup();
#ifdef _WIN32
if (!has_wpcap) {
- fprintf(stderr, "tethereal: Could not load wpcap.dll.\n");
- exit(2);
+ char *detailed_err;
+
+ cmdarg_err("WinPcap couldn't be found.");
+ detailed_err = cant_load_winpcap_err("Tethereal");
+ cmdarg_err_cont("%s", detailed_err);
+ g_free(detailed_err);
+ exit(2);
}
#endif
- /* Yes; did the user specify an interface to use? */
- if (capture_opts.iface == NULL) {
- /* No - is a default specified in the preferences file? */
- if (prefs->capture_device != NULL) {
- /* Yes - use it. */
- if_text = strrchr(prefs->capture_device, ' ');
- if (if_text == NULL) {
- capture_opts.iface = g_strdup(prefs->capture_device);
- } else {
- capture_opts.iface = g_strdup(if_text + 1); /* Skip over space */
- }
- } else {
- /* No - pick the first one from the list of interfaces. */
- if_list = get_interface_list(&err, err_str);
- if (if_list == NULL) {
- switch (err) {
-
- case CANT_GET_INTERFACE_LIST:
- cant_get_if_list_errstr =
- cant_get_if_list_error_message(err_str);
- fprintf(stderr, "tethereal: %s\n", cant_get_if_list_errstr);
- g_free(cant_get_if_list_errstr);
- break;
-
- case NO_INTERFACES_FOUND:
- fprintf(stderr, "tethereal: There are no interfaces on which a capture can be done\n");
- break;
- }
- exit(2);
- }
- if_info = if_list->data; /* first interface */
- capture_opts.iface = g_strdup(if_info->name);
- free_interface_list(if_list);
- }
+ /* trim the interface name and exit if that failed */
+ if (!capture_opts_trim_iface(&capture_opts,
+ (prefs->capture_device) ? get_if_name(prefs->capture_device) : NULL)) {
+ exit(2);
}
+ /* if requested, list the link layer types and exit */
if (list_link_layer_types) {
- /* We were asked to list the link-layer types for an interface.
- Get the list of link-layer types for the capture device. */
- lt_list = get_pcap_linktype_list(capture_opts.iface, err_str);
- if (lt_list == NULL) {
- if (err_str[0] != '\0') {
- fprintf(stderr, "tethereal: The list of data link types for the capture device could not be obtained (%s).\n"
- "Please check to make sure you have sufficient permissions, and that\n"
- "you have the proper interface or pipe specified.\n", err_str);
- } else
- fprintf(stderr, "tethereal: The capture device has no data link types.\n");
- exit(2);
- }
- fprintf(stderr, "Data link types (use option -y to set):\n");
- for (lt_entry = lt_list; lt_entry != NULL;
- lt_entry = g_list_next(lt_entry)) {
- data_link_info = lt_entry->data;
- fprintf(stderr, " %s", data_link_info->name);
- if (data_link_info->description != NULL)
- fprintf(stderr, " (%s)", data_link_info->description);
- else
- fprintf(stderr, " (not supported)");
- putchar('\n');
- }
- free_pcap_linktype_list(lt_list);
- exit(0);
+ capture_opts_list_link_layer_types(&capture_opts);
+ exit(0);
}
if (!quiet) {
print_packet_counts = TRUE;
}
+ /* For now, assume libpcap gives microsecond precision. */
+ timestamp_set_precision(TS_PREC_AUTO_USEC);
+
capture(save_file, out_file_type);
if (capture_opts.multi_files_on) {
}
#else
/* No - complain. */
- fprintf(stderr, "This version of Tethereal was not built with support for capturing packets.\n");
+ cmdarg_err("This version of Tethereal was not built with support for capturing packets.");
exit(2);
#endif
}
/* Do the low-level work of a capture.
Returns TRUE if it succeeds, FALSE otherwise. */
-static condition *volatile cnd_ring_timeout = NULL; /* this must be visible in process_packet */
+static condition *volatile cnd_file_duration = NULL; /* this must be visible in process_packet */
static int
capture(char *save_file, int out_file_type)
{
- int pcap_encap;
- int file_snaplen;
- gchar open_err_str[PCAP_ERRBUF_SIZE];
- gchar lookup_net_err_str[PCAP_ERRBUF_SIZE];
- bpf_u_int32 netnum, netmask;
- struct bpf_program fcode;
- const char *set_linktype_err_str;
int err = 0;
int volatile volatile_err = 0;
int volatile inpkts = 0;
int pcap_cnt;
char errmsg[1024+1];
- condition *volatile cnd_stop_capturesize = NULL;
- condition *volatile cnd_stop_timeout = NULL;
+ condition *volatile cnd_autostop_size = NULL;
+ condition *volatile cnd_autostop_duration = NULL;
char *descr;
#ifndef _WIN32
void (*oldhandler)(int);
- static const char ppamsg[] = "can't find PPA for ";
- char *libpcap_warn;
- volatile int pipe_fd = -1;
- struct pcap_hdr hdr;
- struct pcaprec_modified_hdr rechdr;
guchar pcap_data[WTAP_MAX_PACKET_SIZE];
#endif
struct pcap_stat stats;
- gboolean write_err;
- gboolean dump_ok;
- dfilter_t *rfcode = NULL;
+ gboolean write_ok;
+ gboolean close_ok;
int save_file_fd;
/* Initialize all data structures used for dissection. */
init_dissection();
- ld.linktype = WTAP_ENCAP_UNKNOWN;
- ld.pdh = NULL;
-
- /* Open the network interface to capture from it.
- Some versions of libpcap may put warnings into the error buffer
- if they succeed; to tell if that's happened, we have to clear
- the error buffer, and check if it's still a null string. */
- open_err_str[0] = '\0';
- ld.pch = pcap_open_live(capture_opts.iface, capture_opts.snaplen,
- capture_opts.promisc_mode, 1000, open_err_str);
-
- if (ld.pch != NULL) {
- /* setting the data link type only works on real interfaces */
- if (capture_opts.linktype != -1) {
- set_linktype_err_str = set_pcap_linktype(ld.pch, capture_opts.iface,
- capture_opts.linktype);
- if (set_linktype_err_str != NULL) {
- snprintf(errmsg, sizeof errmsg, "Unable to set data link type (%s).",
- set_linktype_err_str);
- goto error;
- }
- }
- } else {
- /* We couldn't open "cfile.iface" as a network device. */
-#ifdef _WIN32
- /* On Windows, we don't support capturing on pipes, so we give up. */
+ ld.wtap_linktype = WTAP_ENCAP_UNKNOWN;
+ ld.wtap_pdh = NULL;
+ ld.packet_cb = capture_pcap_cb;
- /* On Win32 OSes, the capture devices are probably available to all
- users; don't warn about permissions problems.
- Do, however, warn that WAN devices aren't supported. */
- snprintf(errmsg, sizeof errmsg,
- "The capture session could not be initiated (%s).\n"
- "Please check that you have the proper interface specified.\n"
- "\n"
- "Note that the WinPcap 2.x version of the driver Ethereal uses for packet\n"
- "capture on Windows doesn't support capturing on PPP/WAN interfaces in\n"
- "Windows NT/2000/XP/2003 Server, and that the WinPcap 3.0 and later versions\n"
- "don't support capturing on PPP/WAN interfaces at all.\n",
- open_err_str);
+ /* open the "input file" from network interface or capture pipe */
+ if (!capture_loop_open_input(&capture_opts, &ld, errmsg, sizeof(errmsg)))
+ {
goto error;
-#else
- /* try to open cfile.iface as a pipe */
- pipe_fd = pipe_open_live(capture_opts.iface, &hdr, &ld, errmsg,
- sizeof errmsg);
-
- if (pipe_fd == -1) {
-
- if (ld.pipe_err == PIPNEXIST) {
- /* Pipe doesn't exist, so output message for interface */
-
- /* If we got a "can't find PPA for XXX" message, warn the user (who
- is running Tethereal on HP-UX) that they don't have a version
- of libpcap that properly handles HP-UX (libpcap 0.6.x and later
- versions, which properly handle HP-UX, say "can't find /dev/dlpi
- PPA for XXX" rather than "can't find PPA for XXX"). */
- if (strncmp(open_err_str, ppamsg, sizeof ppamsg - 1) == 0)
- libpcap_warn =
- "\n\n"
- "You are running Tethereal with a version of the libpcap library\n"
- "that doesn't handle HP-UX network devices well; this means that\n"
- "Tethereal may not be able to capture packets.\n"
- "\n"
- "To fix this, you should install libpcap 0.6.2, or a later version\n"
- "of libpcap, rather than libpcap 0.4 or 0.5.x. It is available in\n"
- "packaged binary form from the Software Porting And Archive Centre\n"
- "for HP-UX; the Centre is at http://hpux.connect.org.uk/ - the page\n"
- "at the URL lists a number of mirror sites.";
- else
- libpcap_warn = "";
- snprintf(errmsg, sizeof errmsg,
- "The capture session could not be initiated (%s).\n"
- "Please check to make sure you have sufficient permissions, and that\n"
- "you have the proper interface or pipe specified.%s", open_err_str,
- libpcap_warn);
- }
- /*
- * Else pipe (or file) does exist and pipe_open_live() has
- * filled in errmsg
- */
- goto error;
- } else
- /* pipe_open_live() succeeded; don't want
- error message from pcap_open_live() */
- open_err_str[0] = '\0';
-#endif
}
#ifndef _WIN32
setgid(getgid());
#endif
- if (capture_opts.cfilter && !ld.from_pipe) {
- /* A capture filter was specified; set it up. */
- if (pcap_lookupnet(capture_opts.iface, &netnum, &netmask, lookup_net_err_str) < 0) {
- /*
- * Well, we can't get the netmask for this interface; it's used
- * only for filters that check for broadcast IP addresses, so
- * we just warn the user, and punt and use 0.
- */
- fprintf(stderr,
- "Warning: Couldn't obtain netmask info (%s).\n", lookup_net_err_str);
- netmask = 0;
- }
- if (pcap_compile(ld.pch, &fcode, capture_opts.cfilter, 1, netmask) < 0) {
- if (dfilter_compile(capture_opts.cfilter, &rfcode)) {
- snprintf(errmsg, sizeof errmsg,
- "Unable to parse capture filter string (%s).\n"
- " Interestingly enough, this looks like a valid display filter\n"
- " Are you sure you didn't mix them up?",
- pcap_geterr(ld.pch));
- } else {
- snprintf(errmsg, sizeof errmsg,
- "Unable to parse capture filter string (%s).",
- pcap_geterr(ld.pch));
- }
- goto error;
- }
- if (pcap_setfilter(ld.pch, &fcode) < 0) {
- snprintf(errmsg, sizeof errmsg, "Can't install filter (%s).",
- pcap_geterr(ld.pch));
-#ifdef HAVE_PCAP_FREECODE
- pcap_freecode(&fcode);
-#endif
- goto error;
- }
-#ifdef HAVE_PCAP_FREECODE
- pcap_freecode(&fcode);
-#endif
+ capture_opts.save_file = save_file;
+
+ /* open the output file (temporary/specified name/ringbuffer) */
+ if (!capture_loop_open_output(&capture_opts, &save_file_fd, errmsg, sizeof(errmsg))) {
+ goto error;
}
- /* Set up to write to the capture file. */
-#ifndef _WIN32
- if (ld.from_pipe) {
- pcap_encap = hdr.network;
- file_snaplen = hdr.snaplen;
- } else
-#endif
+ /* init the input filter from the network interface (capture pipe will do nothing) */
+ if(!capture_loop_init_filter(ld.pcap_h, ld.from_cap_pipe,
+ capture_opts.iface, capture_opts.cfilter, errmsg, sizeof errmsg))
{
- pcap_encap = get_pcap_linktype(ld.pch, capture_opts.iface);
- file_snaplen = pcap_snapshot(ld.pch);
- }
- ld.linktype = wtap_pcap_encap_to_wtap_encap(pcap_encap);
- if (save_file != NULL) {
- /* Set up to write to the capture file. */
- if (ld.linktype == WTAP_ENCAP_UNKNOWN) {
- strcpy(errmsg, "The network you're capturing from is of a type"
- " that Tethereal doesn't support.");
goto error;
- }
- ld.save_file = save_file;
- if (capture_opts.multi_files_on) {
- save_file_fd = ringbuf_init(save_file,
- capture_opts.ring_num_files);
- if (save_file_fd != -1) {
- ld.pdh = ringbuf_init_wtap_dump_fdopen(out_file_type, ld.linktype,
- file_snaplen, &err);
- } else {
- err = errno; /* "ringbuf_init()" failed */
- ld.pdh = NULL;
- }
- } else {
- ld.pdh = wtap_dump_open(save_file, out_file_type,
- ld.linktype, file_snaplen, &err);
- }
+ }
- if (ld.pdh == NULL) {
- snprintf(errmsg, sizeof errmsg,
- cf_open_error_message(err, NULL, TRUE, out_file_type),
- *save_file == '\0' ? "stdout" : save_file);
+ /* open the wiretap part of the output file (the output file is already open) */
+ if(!capture_loop_init_wiretap_output(&capture_opts, save_file_fd, &ld, errmsg, sizeof errmsg))
+ {
goto error;
- }
}
- /* Does "open_err_str" contain a non-empty string? If so, "pcap_open_live()"
- returned a warning; print it, but keep capturing. */
- if (open_err_str[0] != '\0')
- fprintf(stderr, "tethereal: WARNING: %s.\n", open_err_str);
#ifdef _WIN32
/* Catch a CTRL+C event and, if we get it, clean up and exit. */
init_capture_stop_conditions();
/* create stop conditions */
if (capture_opts.has_autostop_filesize)
- cnd_stop_capturesize = cnd_new((const char*)CND_CLASS_CAPTURESIZE,
- (long)capture_opts.autostop_filesize * 1000);
+ cnd_autostop_size = cnd_new((const char*)CND_CLASS_CAPTURESIZE,
+ (long)capture_opts.autostop_filesize * 1024);
if (capture_opts.has_autostop_duration)
- cnd_stop_timeout = cnd_new((const char*)CND_CLASS_TIMEOUT,
+ cnd_autostop_duration = cnd_new((const char*)CND_CLASS_TIMEOUT,
(gint32)capture_opts.autostop_duration);
if (capture_opts.multi_files_on && capture_opts.has_file_duration)
- cnd_ring_timeout = cnd_new(CND_CLASS_TIMEOUT,
+ cnd_file_duration = cnd_new(CND_CLASS_TIMEOUT,
capture_opts.file_duration);
if (!setjmp(ld.stopenv)) {
ld.packet_count = 0;
} else
ld.go = FALSE;
+
while (ld.go) {
/* We need to be careful with automatic variables defined in the
outer scope which are changed inside the loop. Most compilers
int loop_err = 0;
int packet_count_prev = 0;
- if (cnd_stop_capturesize == NULL && cnd_stop_timeout == NULL) {
+ if (cnd_autostop_size == NULL && cnd_autostop_duration == NULL) {
/* We're not stopping at a particular capture file size, and we're
not stopping after some particular amount of time has expired,
so either we have no stop condition or the only stop condition
pcap_cnt = 1;
}
#ifndef _WIN32
- if (ld.from_pipe) {
- inpkts = pipe_dispatch(pipe_fd, &ld, &hdr, &rechdr, pcap_data,
+ if (ld.from_cap_pipe) {
+ inpkts = cap_pipe_dispatch(ld.cap_pipe_fd, &ld, &ld.cap_pipe_hdr, &ld.cap_pipe_rechdr, pcap_data,
errmsg, sizeof errmsg);
} else
#endif
- inpkts = pcap_dispatch(ld.pch, pcap_cnt, capture_pcap_cb, (guchar *) &ld);
+ inpkts = pcap_dispatch(ld.pcap_h, pcap_cnt, capture_pcap_cb, (u_char *) &ld);
if (inpkts < 0) {
/* Error from "pcap_dispatch()", or error or "no more packets" from
- "pipe_dispatch(). */
+ "cap_pipe_dispatch(). */
ld.go = FALSE;
- } else if (cnd_stop_timeout != NULL && cnd_eval(cnd_stop_timeout)) {
+ } else if (cnd_autostop_duration != NULL && cnd_eval(cnd_autostop_duration)) {
/* The specified capture time has elapsed; stop the capture. */
ld.go = FALSE;
} else if (inpkts > 0) {
passed both any capture filter in effect and any read filter
in effect. */
ld.go = FALSE;
- } else if (cnd_stop_capturesize != NULL &&
- cnd_eval(cnd_stop_capturesize,
- (guint32)wtap_get_bytes_dumped(ld.pdh))) {
+ } else if (cnd_autostop_size != NULL &&
+ cnd_eval(cnd_autostop_size,
+ (guint32)wtap_get_bytes_dumped(ld.wtap_pdh))) {
/* We're saving the capture to a file, and the capture file reached
its maximum size. */
if (capture_opts.multi_files_on) {
/* Switch to the next ringbuffer file */
- if (ringbuf_switch_file(&ld.pdh, &save_file, &save_file_fd, &loop_err)) {
+ if (ringbuf_switch_file(&ld.wtap_pdh, &save_file, &save_file_fd, &loop_err)) {
/* File switch succeeded: reset the condition */
- cnd_reset(cnd_stop_capturesize);
- if (cnd_ring_timeout) {
- cnd_reset(cnd_ring_timeout);
+ cnd_reset(cnd_autostop_size);
+ if (cnd_file_duration) {
+ cnd_reset(cnd_file_duration);
}
} else {
/* File switch failed: stop here */
}
if (ld.output_to_pipe) {
if (ld.packet_count > packet_count_prev) {
- if (fflush(wtap_dump_file(ld.pdh))) {
- volatile_err = errno;
- ld.go = FALSE;
- }
+ wtap_dump_flush(ld.wtap_pdh);
packet_count_prev = ld.packet_count;
}
}
} /* while (ld.go) */
/* delete stop conditions */
- if (cnd_stop_capturesize != NULL)
- cnd_delete(cnd_stop_capturesize);
- if (cnd_stop_timeout != NULL)
- cnd_delete(cnd_stop_timeout);
- if (cnd_ring_timeout != NULL)
- cnd_delete(cnd_ring_timeout);
+ if (cnd_autostop_size != NULL)
+ cnd_delete(cnd_autostop_size);
+ if (cnd_autostop_duration != NULL)
+ cnd_delete(cnd_autostop_duration);
+ if (cnd_file_duration != NULL)
+ cnd_delete(cnd_file_duration);
if (print_packet_counts) {
/* We're printing packet counts to stderr.
/* If we got an error while capturing, report it. */
if (inpkts < 0) {
#ifndef _WIN32
- if (ld.from_pipe) {
- if (ld.pipe_err == PIPERR) {
- fprintf(stderr, "tethereal: Error while capturing packets: %s\n",
+ if (ld.from_cap_pipe) {
+ if (ld.cap_pipe_err == PIPERR) {
+ cmdarg_err("Error while capturing packets: %s",
errmsg);
}
} else
#endif
{
- fprintf(stderr, "tethereal: Error while capturing packets: %s\n",
- pcap_geterr(ld.pch));
+ cmdarg_err("Error while capturing packets: %s",
+ pcap_geterr(ld.pcap_h));
}
}
if (volatile_err == 0)
- write_err = FALSE;
+ write_ok = TRUE;
else {
show_capture_file_io_error(save_file, volatile_err, FALSE);
- write_err = TRUE;
+ write_ok = FALSE;
}
if (save_file != NULL) {
/* We're saving to a file or files; close all files. */
- if (capture_opts.multi_files_on) {
- dump_ok = ringbuf_wtap_dump_close(&save_file, &err);
- } else {
- dump_ok = wtap_dump_close(ld.pdh, &err);
- }
+ close_ok = capture_loop_close_output(&capture_opts, &ld, &err);
+
/* If we've displayed a message about a write error, there's no point
in displaying another message about an error on close. */
- if (!dump_ok && !write_err)
+ if (!close_ok && write_ok)
show_capture_file_io_error(save_file, err, TRUE);
}
#ifndef _WIN32
- if (ld.from_pipe && pipe_fd >= 0)
- close(pipe_fd);
+ if (ld.from_cap_pipe && ld.cap_pipe_fd >= 0)
+ eth_close(ld.cap_pipe_fd);
else
#endif
{
/* Get the capture statistics, and, if any packets were dropped, report
that. */
- if (pcap_stats(ld.pch, &stats) >= 0) {
+ if (pcap_stats(ld.pcap_h, &stats) >= 0) {
if (stats.ps_drop != 0) {
fprintf(stderr, "%u packets dropped\n", stats.ps_drop);
}
} else {
- fprintf(stderr, "tethereal: Can't get packet-drop statistics: %s\n",
- pcap_geterr(ld.pch));
+ cmdarg_err("Can't get packet-drop statistics: %s",
+ pcap_geterr(ld.pcap_h));
}
- pcap_close(ld.pch);
+ pcap_close(ld.pcap_h);
}
/* Report the number of captured packets if not reported during capture
}
g_free(save_file);
save_file = NULL;
- fprintf(stderr, "tethereal: %s\n", errmsg);
+ cmdarg_err("%s", errmsg);
#ifndef _WIN32
- if (ld.from_pipe) {
- if (pipe_fd >= 0)
- close(pipe_fd);
+ if (ld.from_cap_pipe) {
+ if (ld.cap_pipe_fd >= 0)
+ eth_close(ld.cap_pipe_fd);
} else
#endif
{
- if (ld.pch != NULL)
- pcap_close(ld.pch);
+ if (ld.pcap_h != NULL)
+ pcap_close(ld.pcap_h);
}
return FALSE;
}
static void
-capture_pcap_cb(guchar *user, const struct pcap_pkthdr *phdr,
- const guchar *pd)
+capture_pcap_cb(u_char *user, const struct pcap_pkthdr *phdr,
+ const u_char *pd)
{
struct wtap_pkthdr whdr;
union wtap_pseudo_header pseudo_header;
- loop_data *ldat = (loop_data *) user;
+ loop_data *ld = (loop_data *) user;
int loop_err;
int err;
int save_file_fd;
/* Convert from libpcap to Wiretap format.
If that fails, ignore the packet (wtap_process_pcap_packet has
written an error message). */
- pd = wtap_process_pcap_packet(ldat->linktype, phdr, pd, &pseudo_header,
+ pd = wtap_process_pcap_packet(ld->wtap_linktype, phdr, pd, &pseudo_header,
&whdr, &err);
if (pd == NULL)
return;
* the first packet of a new series of events as the last
* [or only] packet in the file, switch before writing!
*/
- if (cnd_ring_timeout != NULL && cnd_eval(cnd_ring_timeout)) {
+ if (cnd_file_duration != NULL && cnd_eval(cnd_file_duration)) {
/* time elapsed for this ring file, switch to the next */
- if (ringbuf_switch_file(&ldat->pdh, &ldat->save_file, &save_file_fd, &loop_err)) {
+ if (ringbuf_switch_file(&ld->wtap_pdh, &ld->save_file, &save_file_fd, &loop_err)) {
/* File switch succeeded: reset the condition */
- cnd_reset(cnd_ring_timeout);
+ cnd_reset(cnd_file_duration);
} else {
/* File switch failed: stop here */
/* XXX - we should do something with "loop_err" */
- ldat->go = FALSE;
+ ld->go = FALSE;
}
}
- if (!process_packet(&cfile, ldat->pdh, 0, &whdr, &pseudo_header, pd, &err)) {
+ if (!process_packet(&cfile, ld->wtap_pdh, 0, &whdr, &pseudo_header, pd, &err)) {
/* Error writing to a capture file */
if (print_packet_counts) {
/* We're printing counts of packets captured; move to the line after
the count. */
fprintf(stderr, "\n");
}
- show_capture_file_io_error(ldat->save_file, err, FALSE);
- pcap_close(ldat->pch);
- wtap_dump_close(ldat->pdh, &err);
+ show_capture_file_io_error(ld->save_file, err, FALSE);
+ pcap_close(ld->pcap_h);
+ wtap_dump_close(ld->wtap_pdh, &err);
exit(2);
}
snapshot_length = WTAP_MAX_PACKET_SIZE;
}
pdh = wtap_dump_open(save_file, out_file_type,
- linktype, snapshot_length, &err);
+ linktype, snapshot_length, FALSE /* compressed */, &err);
if (pdh == NULL) {
/* We couldn't set up to write to the capture file. */
switch (err) {
case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
- fprintf(stderr,
- "tethereal: Capture files can't be written in that format.\n");
+ cmdarg_err("Capture files can't be written in that format.");
break;
case WTAP_ERR_UNSUPPORTED_ENCAP:
case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
- fprintf(stderr,
- "tethereal: The capture file being read can't be written in "
- "that format.\n");
+ cmdarg_err("The capture file being read can't be written in "
+ "that format.");
break;
case WTAP_ERR_CANT_OPEN:
- fprintf(stderr,
- "tethereal: The file \"%s\" couldn't be created for some "
- "unknown reason.\n",
+ cmdarg_err("The file \"%s\" couldn't be created for some "
+ "unknown reason.",
*save_file == '\0' ? "stdout" : save_file);
break;
case WTAP_ERR_SHORT_WRITE:
- fprintf(stderr,
- "tethereal: A full header couldn't be written to the file \"%s\".\n",
+ cmdarg_err("A full header couldn't be written to the file \"%s\".",
*save_file == '\0' ? "stdout" : save_file);
break;
default:
- fprintf(stderr,
- "tethereal: The file \"%s\" could not be created: %s\n.",
+ cmdarg_err("The file \"%s\" could not be created: %s.",
*save_file == '\0' ? "stdout" : save_file,
wtap_strerror(err));
break;
switch (err) {
case WTAP_ERR_UNSUPPORTED_ENCAP:
- fprintf(stderr,
-"tethereal: \"%s\" has a packet with a network type that Tethereal doesn't support.\n(%s)\n",
+ cmdarg_err("\"%s\" has a packet with a network type that Tethereal doesn't support.\n(%s)",
cf->filename, err_info);
break;
case WTAP_ERR_CANT_READ:
- fprintf(stderr,
-"tethereal: An attempt to read from \"%s\" failed for some unknown reason.\n",
+ cmdarg_err("An attempt to read from \"%s\" failed for some unknown reason.",
cf->filename);
break;
case WTAP_ERR_SHORT_READ:
- fprintf(stderr,
-"tethereal: \"%s\" appears to have been cut short in the middle of a packet.\n",
+ cmdarg_err("\"%s\" appears to have been cut short in the middle of a packet.",
cf->filename);
break;
case WTAP_ERR_BAD_RECORD:
- fprintf(stderr,
-"tethereal: \"%s\" appears to be damaged or corrupt.\n(%s)\n",
+ cmdarg_err("\"%s\" appears to be damaged or corrupt.\n(%s)",
cf->filename, err_info);
break;
default:
- fprintf(stderr,
-"tethereal: An error occurred while reading \"%s\": %s.\n",
+ cmdarg_err("An error occurred while reading \"%s\": %s.",
cf->filename, wtap_strerror(err));
break;
}
fdata->cap_len = phdr->caplen;
fdata->file_off = offset;
fdata->lnk_t = phdr->pkt_encap;
- fdata->abs_secs = phdr->ts.tv_sec;
- fdata->abs_usecs = phdr->ts.tv_usec;
+ fdata->abs_ts = *((nstime_t *) &phdr->ts);
fdata->flags.passed_dfilter = 0;
fdata->flags.encoding = CHAR_ASCII;
fdata->flags.visited = 0;
/* If we don't have the time stamp of the first packet in the
capture, it's because this is the first packet. Save the time
stamp of this packet as the time stamp of the first packet. */
- if (!firstsec && !firstusec) {
- firstsec = fdata->abs_secs;
- firstusec = fdata->abs_usecs;
+ if (nstime_is_zero(&first_ts)) {
+ first_ts = fdata->abs_ts;
}
/* If we don't have the time stamp of the previous displayed packet,
it's because this is the first displayed packet. Save the time
stamp of this packet as the time stamp of the previous displayed
packet. */
- if (!prevsec && !prevusec) {
- prevsec = fdata->abs_secs;
- prevusec = fdata->abs_usecs;
+ if (nstime_is_zero(&prev_ts)) {
+ prev_ts = fdata->abs_ts;
}
/* Get the time elapsed between the first packet and this packet. */
- compute_timestamp_diff(&fdata->rel_secs, &fdata->rel_usecs,
- fdata->abs_secs, fdata->abs_usecs, firstsec, firstusec);
+ nstime_delta(&fdata->rel_ts, &fdata->abs_ts, &first_ts);
/* If it's greater than the current elapsed time, set the elapsed time
to it (we check for "greater than" so as not to be confused by
time moving backwards). */
- if ((gint32)cf->esec < fdata->rel_secs
- || ((gint32)cf->esec == fdata->rel_secs && (gint32)cf->eusec < fdata->rel_usecs)) {
- cf->esec = fdata->rel_secs;
- cf->eusec = fdata->rel_usecs;
+ if ((gint32)cf->elapsed_time.secs < fdata->rel_ts.secs
+ || ((gint32)cf->elapsed_time.secs == fdata->rel_ts.secs && (gint32)cf->elapsed_time.nsecs < fdata->rel_ts.nsecs)) {
+ cf->elapsed_time = fdata->rel_ts;
}
/* Get the time elapsed between the previous displayed packet and
this packet. */
- compute_timestamp_diff(&fdata->del_secs, &fdata->del_usecs,
- fdata->abs_secs, fdata->abs_usecs, prevsec, prevusec);
- prevsec = fdata->abs_secs;
- prevusec = fdata->abs_usecs;
+ nstime_delta(&fdata->del_ts, &fdata->abs_ts, &prev_ts);
+ prev_ts = fdata->abs_ts;
}
/* Free up all data attached to a "frame_data" structure. */
switch (err) {
case ENOSPC:
- fprintf(stderr,
-"tethereal: Not all the packets could be written to \"%s\" because there is "
-"no space left on the file system.\n",
+ cmdarg_err("Not all the packets could be written to \"%s\" because there is "
+"no space left on the file system.",
fname);
break;
#ifdef EDQUOT
case EDQUOT:
- fprintf(stderr,
-"tethereal: Not all the packets could be written to \"%s\" because you are "
-"too close to, or over your disk quota.\n",
+ cmdarg_err("Not all the packets could be written to \"%s\" because you are "
+"too close to, or over your disk quota.",
fname);
break;
#endif
case WTAP_ERR_CANT_CLOSE:
- fprintf(stderr,
-"tethereal: \"%s\" couldn't be closed for some unknown reason.\n",
+ cmdarg_err("\"%s\" couldn't be closed for some unknown reason.",
fname);
break;
case WTAP_ERR_SHORT_WRITE:
- fprintf(stderr,
-"tethereal: Not all the packets could be written to \"%s\".\n",
+ cmdarg_err("Not all the packets could be written to \"%s\".",
fname);
break;
default:
if (is_close) {
- fprintf(stderr,
-"tethereal: \"%s\" could not be closed: %s.\n",
+ cmdarg_err("\"%s\" could not be closed: %s.",
fname, wtap_strerror(err));
} else {
- fprintf(stderr,
-"tethereal: An error occurred while writing to \"%s\": %s.\n",
+ cmdarg_err("An error occurred while writing to \"%s\": %s.",
fname, wtap_strerror(err));
}
break;
switch (err) {
case ENOSPC:
- fprintf(stderr,
-"tethereal: Not all the packets could be printed because there is "
-"no space left on the file system.\n");
+ cmdarg_err("Not all the packets could be printed because there is "
+"no space left on the file system.");
break;
#ifdef EDQUOT
case EDQUOT:
- fprintf(stderr,
-"tethereal: Not all the packets could be printed because you are "
-"too close to, or over your disk quota.\n");
+ cmdarg_err("Not all the packets could be printed because you are "
+"too close to, or over your disk quota.");
break;
#endif
default:
- fprintf(stderr,
-"tethereal: An error occurred while printing packets: %s.\n",
+ cmdarg_err("An error occurred while printing packets: %s.",
strerror(err));
break;
}
}
-static char *
+static const char *
cf_open_error_message(int err, gchar *err_info, gboolean for_writing,
int file_type)
{
- char *errmsg;
+ const char *errmsg;
static char errmsg_errno[1024+1];
if (err < 0) {
case WTAP_ERR_UNSUPPORTED:
/* Seen only when opening a capture file for reading. */
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"The file \"%%s\" isn't a capture file in a format Tethereal understands.\n"
"(%s)", err_info);
g_free(err_info);
case WTAP_ERR_CANT_WRITE_TO_PIPE:
/* Seen only when opening a capture file for writing. */
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"The file \"%%s\" is a pipe, and %s capture files can't be "
"written to a pipe.", wtap_file_type_string(file_type));
errmsg = errmsg_errno;
if (for_writing)
errmsg = "Tethereal can't save this capture in that format.";
else {
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"The file \"%%s\" is a capture for a network type that Tethereal doesn't support.\n"
"(%s)", err_info);
g_free(err_info);
case WTAP_ERR_BAD_RECORD:
/* Seen only when opening a capture file for reading. */
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"The file \"%%s\" appears to be damaged or corrupt.\n"
"(%s)", err_info);
g_free(err_info);
break;
default:
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"The file \"%%s\" could not be %s: %s.",
for_writing ? "created" : "opened",
wtap_strerror(err));
init_dissection();
cf->wth = wth;
- cf->filed = -1; /* not used, but set it anyway */
- cf->f_len = 0; /* not used, but set it anyway */
+ cf->f_datalen = 0; /* not used, but set it anyway */
/* Set the file name because we need it to set the follow stream filter.
XXX - is that still true? We need it for other reasons, though,
cf->count = 0;
cf->drops_known = FALSE;
cf->drops = 0;
- cf->esec = 0;
- cf->eusec = 0;
cf->snap = wtap_snapshot_length(cf->wth);
if (cf->snap == 0) {
/* Snapshot length not known. */
cf->snap = WTAP_MAX_PACKET_SIZE;
} else
cf->has_snap = TRUE;
- firstsec = 0, firstusec = 0;
- prevsec = 0, prevusec = 0;
+ nstime_set_zero(&cf->elapsed_time);
+ nstime_set_zero(&first_ts);
+ nstime_set_zero(&prev_ts);
return CF_OK;
fail:
- snprintf(err_msg, sizeof err_msg,
+ g_snprintf(err_msg, sizeof err_msg,
cf_open_error_message(*err, err_info, FALSE, 0), fname);
- fprintf(stderr, "tethereal: %s\n", err_msg);
+ cmdarg_err("%s", err_msg);
return CF_ERROR;
}
-#ifdef HAVE_LIBPCAP
-#ifndef _WIN32
-/* Take care of byte order in the libpcap headers read from pipes.
- * (function taken from wiretap/libpcap.c) */
+
+/*
+ * General errors are reported with an console message in Tethereal.
+ */
static void
-adjust_header(loop_data *ldat, struct pcap_hdr *hdr, struct pcaprec_hdr *rechdr)
+failure_message(const char *msg_format, va_list ap)
{
- if (ldat->byte_swapped) {
- /* Byte-swap the record header fields. */
- rechdr->ts_sec = BSWAP32(rechdr->ts_sec);
- rechdr->ts_usec = BSWAP32(rechdr->ts_usec);
- rechdr->incl_len = BSWAP32(rechdr->incl_len);
- rechdr->orig_len = BSWAP32(rechdr->orig_len);
- }
-
- /* In file format version 2.3, the "incl_len" and "orig_len" fields were
- swapped, in order to match the BPF header layout.
-
- Unfortunately, some files were, according to a comment in the "libpcap"
- source, written with version 2.3 in their headers but without the
- interchanged fields, so if "incl_len" is greater than "orig_len" - which
- would make no sense - we assume that we need to swap them. */
- if (hdr->version_major == 2 &&
- (hdr->version_minor < 3 ||
- (hdr->version_minor == 3 && rechdr->incl_len > rechdr->orig_len))) {
- guint32 temp;
-
- temp = rechdr->orig_len;
- rechdr->orig_len = rechdr->incl_len;
- rechdr->incl_len = temp;
- }
+ fprintf(stderr, "tethereal: ");
+ vfprintf(stderr, msg_format, ap);
+ fprintf(stderr, "\n");
}
-/* Mimic pcap_open_live() for pipe captures
- * We check if "pipename" is "-" (stdin) or a FIFO, open it, and read the
- * header.
- * N.B. : we can't read the libpcap formats used in RedHat 6.1 or SuSE 6.3
- * because we can't seek on pipes (see wiretap/libpcap.c for details) */
-static int
-pipe_open_live(char *pipename, struct pcap_hdr *hdr, loop_data *ldat,
- char *errmsg, int errmsgl)
+/*
+ * Read errors are reported with an console message in Tethereal.
+ */
+static void
+read_failure_message(const char *filename, int err)
{
- struct stat pipe_stat;
- int fd;
- guint32 magic;
- int b;
- unsigned int bytes_read;
+ cmdarg_err("An error occurred while reading from the file \"%s\": %s.",
+ filename, strerror(err));
+}
- /*
- * XXX Tethereal blocks until we return
- */
- if (strcmp(pipename, "-") == 0)
- fd = 0; /* read from stdin */
- else {
- if (stat(pipename, &pipe_stat) < 0) {
- if (errno == ENOENT || errno == ENOTDIR)
- ldat->pipe_err = PIPNEXIST;
- else {
- snprintf(errmsg, errmsgl,
- "The capture session could not be initiated "
- "due to error on pipe: %s", strerror(errno));
- ldat->pipe_err = PIPERR;
- }
- return -1;
- }
- if (! S_ISFIFO(pipe_stat.st_mode)) {
- if (S_ISCHR(pipe_stat.st_mode)) {
- /*
- * Assume the user specified an interface on a system where
- * interfaces are in /dev. Pretend we haven't seen it.
- */
- ldat->pipe_err = PIPNEXIST;
- } else {
- snprintf(errmsg, errmsgl,
- "The capture session could not be initiated because\n"
- "\"%s\" is neither an interface nor a pipe", pipename);
- ldat->pipe_err = PIPERR;
- }
- return -1;
- }
- fd = open(pipename, O_RDONLY);
- if (fd == -1) {
- snprintf(errmsg, errmsgl,
- "The capture session could not be initiated "
- "due to error on pipe open: %s", strerror(errno));
- ldat->pipe_err = PIPERR;
- return -1;
- }
- }
+/*
+ * Report an error in command-line arguments.
+ */
+void
+cmdarg_err(const char *fmt, ...)
+{
+ va_list ap;
- ldat->from_pipe = TRUE;
+ va_start(ap, fmt);
+ fprintf(stderr, "tethereal: ");
+ vfprintf(stderr, fmt, ap);
+ fprintf(stderr, "\n");
+ va_end(ap);
+}
- /* read the pcap header */
- bytes_read = 0;
- while (bytes_read < sizeof magic) {
- b = read(fd, ((char *)&magic)+bytes_read, sizeof magic-bytes_read);
- if (b <= 0) {
- if (b == 0)
- snprintf(errmsg, errmsgl, "End of file on pipe during open");
- else
- snprintf(errmsg, errmsgl, "Error on pipe during open: %s",
- strerror(errno));
- goto error;
- }
- bytes_read += b;
- }
+/*
+ * Report additional information for an error in command-line arguments.
+ */
+void
+cmdarg_err_cont(const char *fmt, ...)
+{
+ va_list ap;
- switch (magic) {
- case PCAP_MAGIC:
- /* Host that wrote it has our byte order, and was running
- a program using either standard or ss990417 libpcap. */
- ldat->byte_swapped = FALSE;
- ldat->modified = FALSE;
- break;
- case PCAP_MODIFIED_MAGIC:
- /* Host that wrote it has our byte order, but was running
- a program using either ss990915 or ss991029 libpcap. */
- ldat->byte_swapped = FALSE;
- ldat->modified = TRUE;
- break;
- case PCAP_SWAPPED_MAGIC:
- /* Host that wrote it has a byte order opposite to ours,
- and was running a program using either standard or
- ss990417 libpcap. */
- ldat->byte_swapped = TRUE;
- ldat->modified = FALSE;
- break;
- case PCAP_SWAPPED_MODIFIED_MAGIC:
- /* Host that wrote it out has a byte order opposite to
- ours, and was running a program using either ss990915
- or ss991029 libpcap. */
- ldat->byte_swapped = TRUE;
- ldat->modified = TRUE;
- break;
- default:
- /* Not a "libpcap" type we know about. */
- snprintf(errmsg, errmsgl, "Unrecognized libpcap format");
- goto error;
- }
+ va_start(ap, fmt);
+ vfprintf(stderr, fmt, ap);
+ fprintf(stderr, "\n");
+ va_end(ap);
+}
- /* Read the rest of the header */
- bytes_read = 0;
- while (bytes_read < sizeof(struct pcap_hdr)) {
- b = read(fd, ((char *)hdr)+bytes_read,
- sizeof(struct pcap_hdr) - bytes_read);
- if (b <= 0) {
- if (b == 0)
- snprintf(errmsg, errmsgl, "End of file on pipe during open");
- else
- snprintf(errmsg, errmsgl, "Error on pipe during open: %s",
- strerror(errno));
- goto error;
- }
- bytes_read += b;
- }
- if (ldat->byte_swapped) {
- /* Byte-swap the header fields about which we care. */
- hdr->version_major = BSWAP16(hdr->version_major);
- hdr->version_minor = BSWAP16(hdr->version_minor);
- hdr->snaplen = BSWAP32(hdr->snaplen);
- hdr->network = BSWAP32(hdr->network);
- }
+/****************************************************************************************************************/
+/* sync pipe "dummies", needed for capture_loop.c */
- if (hdr->version_major < 2) {
- snprintf(errmsg, errmsgl, "Unable to read old libpcap format");
- goto error;
- }
+#ifdef HAVE_LIBPCAP
- ldat->pipe_state = STATE_EXPECT_REC_HDR;
- ldat->pipe_err = PIPOK;
- return fd;
+/** the child has opened a new capture file, notify the parent */
+void
+sync_pipe_filename_to_parent(const char *filename)
+{
+ /* shouldn't happen */
+ g_assert(0);
+}
-error:
- ldat->pipe_err = PIPERR;
- close(fd);
- return -1;
+/** the child captured some new packets, notify the parent */
+void
+sync_pipe_packet_count_to_parent(int packet_count)
+{
+ /* shouldn't happen */
+ g_assert(0);
+}
+/** the child stopped capturing, notify the parent */
+void
+sync_pipe_drops_to_parent(int drops)
+{
+ /* shouldn't happen */
+ g_assert(0);
}
-/* We read one record from the pipe, take care of byte order in the record
- * header, write the record in the capture file, and update capture statistics. */
-static int
-pipe_dispatch(int fd, loop_data *ldat, struct pcap_hdr *hdr,
- struct pcaprec_modified_hdr *rechdr, guchar *data,
- char *errmsg, int errmsgl)
+/** the child encountered an error, notify the parent */
+void
+sync_pipe_errmsg_to_parent(const char *errmsg)
{
- struct pcap_pkthdr phdr;
- int b;
- enum { PD_REC_HDR_READ, PD_DATA_READ, PD_PIPE_EOF, PD_PIPE_ERR,
- PD_ERR } result;
-
- switch (ldat->pipe_state) {
-
- case STATE_EXPECT_REC_HDR:
- ldat->bytes_to_read = ldat->modified ?
- sizeof(struct pcaprec_modified_hdr) : sizeof(struct pcaprec_hdr);
- ldat->bytes_read = 0;
- ldat->pipe_state = STATE_READ_REC_HDR;
- /* Fall through */
-
- case STATE_READ_REC_HDR:
- b = read(fd, ((char *)rechdr)+ldat->bytes_read,
- ldat->bytes_to_read - ldat->bytes_read);
- if (b <= 0) {
- if (b == 0)
- result = PD_PIPE_EOF;
- else
- result = PD_PIPE_ERR;
- break;
- }
- if ((ldat->bytes_read += b) < ldat->bytes_to_read)
- return 0;
- result = PD_REC_HDR_READ;
- break;
+ cmdarg_err(errmsg);
+}
- case STATE_EXPECT_DATA:
- ldat->bytes_read = 0;
- ldat->pipe_state = STATE_READ_DATA;
- /* Fall through */
+#endif /* HAVE_LIBPCAP */
- case STATE_READ_DATA:
- b = read(fd, data+ldat->bytes_read, rechdr->hdr.incl_len - ldat->bytes_read);
- if (b <= 0) {
- if (b == 0)
- result = PD_PIPE_EOF;
- else
- result = PD_PIPE_ERR;
- break;
- }
- if ((ldat->bytes_read += b) < rechdr->hdr.incl_len)
- return 0;
- result = PD_DATA_READ;
- break;
- default:
- snprintf(errmsg, errmsgl, "pipe_dispatch: invalid state");
- result = PD_ERR;
+/****************************************************************************************************************/
+/* simple_dialog "dummies", needed for capture_loop.c */
- } /* switch (ldat->pipe_state) */
- /*
- * We've now read as much data as we were expecting, so process it.
- */
- switch (result) {
-
- case PD_REC_HDR_READ:
- /* We've read the header. Take care of byte order. */
- adjust_header(ldat, hdr, &rechdr->hdr);
- if (rechdr->hdr.incl_len > WTAP_MAX_PACKET_SIZE) {
- snprintf(errmsg, errmsgl, "Frame %u too long (%d bytes)",
- ldat->packet_count+1, rechdr->hdr.incl_len);
- break;
- }
- ldat->pipe_state = STATE_EXPECT_DATA;
- return 0;
-
- case PD_DATA_READ:
- /* Fill in a "struct pcap_pkthdr", and process the packet. */
- phdr.ts.tv_sec = rechdr->hdr.ts_sec;
- phdr.ts.tv_usec = rechdr->hdr.ts_usec;
- phdr.caplen = rechdr->hdr.incl_len;
- phdr.len = rechdr->hdr.orig_len;
-
- capture_pcap_cb((guchar *)ldat, &phdr, data);
-
- ldat->pipe_state = STATE_EXPECT_REC_HDR;
- return 1;
-
- case PD_PIPE_EOF:
- ldat->pipe_err = PIPEOF;
- return -1;
-
- case PD_PIPE_ERR:
- snprintf(errmsg, errmsgl, "Error reading from pipe: %s",
- strerror(errno));
- /* Fall through */
- case PD_ERR:
- break;
- }
+#ifdef HAVE_LIBPCAP
- ldat->pipe_err = PIPERR;
- /* Return here rather than inside the switch to prevent GCC warning */
- return -1;
+char *simple_dialog_primary_start(void)
+{
+ return "";
}
-#endif /* _WIN32 */
-#endif /* HAVE_LIBPCAP */
-/*
- * General errors are reported with an console message in Tethereal.
- */
-static void
-failure_message(const char *msg_format, va_list ap)
+char *simple_dialog_primary_end(void)
{
- fprintf(stderr, "tethereal: ");
- vfprintf(stderr, msg_format, ap);
- fprintf(stderr, "\n");
+ return "";
}
-/*
- * Read errors are reported with an console message in Tethereal.
- */
-static void
-read_failure_message(const char *filename, int err)
+
+/* XXX - do we need to convert the string for the console? */
+char *
+simple_dialog_format_message(const char *msg)
{
- fprintf(stderr, "tethereal: An error occurred while reading from the file \"%s\": %s.\n",
- filename, strerror(err));
+ char *str;
+
+
+ if (msg) {
+#if GTK_MAJOR_VERSION < 2
+ str = g_strdup(msg);
+#else
+ str = xml_escape(msg);
+#endif
+ } else {
+ str = NULL;
+ }
+ return str;
}
+
+#endif /* HAVE_LIBPCAP */
+
+
git.samba.org / obnox / wireshark / wip.git / blobdiff