* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
-/* With MSVC and a libethereal.dll this file needs to import some variables
- in a special way. Therefore _NEED_VAR_IMPORT_ is defined. */
-#define _NEED_VAR_IMPORT_
-
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <errno.h>
#include <signal.h>
-#ifdef HAVE_SYS_STAT_H
-#include <sys/stat.h>
-#endif
-
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
-#ifdef NEED_SNPRINTF_H
-# include "snprintf.h"
-#endif
-
#ifdef NEED_STRERROR_H
#include "strerror.h"
#endif
#include "packet-range.h"
#include "print.h"
#include "file.h"
-#include "menu.h"
+#include "fileset.h"
#include "util.h"
#include "merge.h"
#include "alert_box.h"
#include "simple_dialog.h"
#include "progress_dlg.h"
#include "ui_util.h"
-#include "statusbar.h"
#include <epan/prefs.h>
#include <epan/dfilter/dfilter.h>
#include <epan/conversation.h>
#include <epan/epan_dissect.h>
#include <epan/tap.h>
+#include "stat_menu.h"
#include "tap_dfilter_dlg.h"
#include <epan/dissectors/packet-data.h>
+#include <epan/timestamp.h>
+
/* Win32 needs the O_BINARY flag for open() */
#ifndef O_BINARY
gboolean auto_scroll_live;
#endif
-static guint32 firstsec, firstusec;
-static guint32 prevsec, prevusec;
+static nstime_t first_ts;
+static nstime_t prev_ts;
static guint32 cum_bytes = 0;
+static void cf_reset_state(capture_file *cf);
+
static void read_packet(capture_file *cf, long offset);
static void rescan_packets(capture_file *cf, const char *action, const char *action_item,
static void cf_open_failure_alert_box(const char *filename, int err,
gchar *err_info, gboolean for_writing,
int file_type);
-static char *file_rename_error_message(int err);
+static const char *file_rename_error_message(int err);
static void cf_write_failure_alert_box(const char *filename, int err);
static void cf_close_failure_alert_box(const char *filename, int err);
static gboolean copy_binary_file(const char *from_filename, const char *to_filename);
#define FRAME_DATA_CHUNK_SIZE 1024
+/* one callback for now, we could have a list later */
+static cf_callback_t cf_cb = NULL;
+static gpointer cf_cb_user_data = NULL;
+
+void
+cf_callback_invoke(int event, gpointer data)
+{
+ g_assert(cf_cb != NULL);
+ cf_cb(event, data, cf_cb_user_data);
+}
+
+
+void
+cf_callback_add(cf_callback_t func, gpointer user_data)
+{
+ /* More than one callback listener is currently not implemented,
+ but should be easy to do. */
+ g_assert(cf_cb == NULL);
+ cf_cb = func;
+ cf_cb_user_data = user_data;
+}
+
+void
+cf_callback_remove(cf_callback_t func _U_)
+{
+ g_assert(cf_cb != NULL);
+ cf_cb = NULL;
+ cf_cb_user_data = NULL;
+}
+
+void
+cf_timestamp_auto_precision(capture_file *cf)
+{
+ int prec = timestamp_get_precision();
+
+
+ /* don't try to get the file's precision if none is opened */
+ if(cf->state == FILE_CLOSED) {
+ return;
+ }
+
+ /* if we are in auto mode, set precision of current file */
+ if(prec == TS_PREC_AUTO ||
+ prec == TS_PREC_AUTO_SEC ||
+ prec == TS_PREC_AUTO_DSEC ||
+ prec == TS_PREC_AUTO_CSEC ||
+ prec == TS_PREC_AUTO_MSEC ||
+ prec == TS_PREC_AUTO_USEC ||
+ prec == TS_PREC_AUTO_NSEC)
+ {
+ switch(wtap_file_tsprecision(cf->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();
+ }
+ }
+}
+
+
cf_status_t
cf_open(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
{
wtap *wth;
gchar *err_info;
- int fd;
- struct stat cf_stat;
wth = wtap_open_offline(fname, err, &err_info, TRUE);
if (wth == NULL)
goto fail;
- /* Find the size of the file. */
- fd = wtap_fd(wth);
- if (fstat(fd, &cf_stat) < 0) {
- *err = errno;
- wtap_close(wth);
- goto fail;
- }
-
/* The open succeeded. Close whatever capture file we had open,
and fill in the information for this file. */
- cf_close(cf);
+ cf_reset_state(cf);
/* Initialize all data structures used for dissection. */
init_dissection();
cf->state = FILE_READ_IN_PROGRESS;
cf->wth = wth;
- cf->filed = fd;
- cf->f_len = cf_stat.st_size;
+ cf->f_datalen = 0;
/* 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,
/* If it's a temporary capture buffer file, mark it as not saved. */
cf->user_saved = !is_tempfile;
- cf->cd_t = wtap_file_type(cf->wth);
+ cf->cd_t = wtap_file_type(cf->wth);
cf->count = 0;
cf->displayed_count = 0;
cf->marked_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);
cf->plist_chunk = g_mem_chunk_new("frame_data_chunk",
sizeof(frame_data),
G_ALLOC_AND_FREE);
g_assert(cf->plist_chunk);
+ /* change the time formats now, as we might have a new precision */
+ cf_change_time_formats(cf);
+
+ fileset_file_opened(fname);
+
return CF_OK;
fail:
return CF_ERROR;
}
-/* Reset everything to a pristine state */
-void
-cf_close(capture_file *cf)
+
+/*
+ * Reset the state for the currently closed file, but don't do the
+ * UI callbacks; this is for use in "cf_open()", where we don't
+ * want the UI to go from "file open" to "file closed" back to
+ * "file open", we want it to go from "old file open" to "new file
+ * open and being read".
+ */
+static void
+cf_reset_state(capture_file *cf)
{
/* Die if we're in the middle of reading a file. */
g_assert(cf->state != FILE_READ_IN_PROGRESS);
- /* Destroy all windows, which refer to the
- capture file we're closing. */
- destroy_cfile_wins();
-
if (cf->wth) {
wtap_close(cf->wth);
cf->wth = NULL;
packet_list_clear();
packet_list_thaw();
- cf->f_len = 0;
+ cf->f_datalen = 0;
cf->count = 0;
- cf->esec = 0;
- cf->eusec = 0;
-
- /* Clear any file-related status bar messages.
- XXX - should be "clear *ALL* file-related status bar messages;
- will there ever be more than one on the stack? */
- statusbar_pop_file_msg();
-
- /* Restore the standard title bar message. */
- set_main_window_name("The Ethereal Network Analyzer");
-
- /* Disable all menu items that make sense only if you have a capture. */
- set_menus_for_capture_file(FALSE);
- set_menus_for_unsaved_capture_file(FALSE);
- set_menus_for_captured_packets(FALSE);
- set_menus_for_selected_packet(cf);
- set_menus_for_capture_in_progress(FALSE);
- set_menus_for_selected_tree_row(cf);
+ nstime_set_zero(&cf->elapsed_time);
reset_tap_listeners();
/* We have no file open. */
cf->state = FILE_CLOSED;
+
+ fileset_file_closed();
}
-/* Set the file name in the status line, in the name for the main window,
- and in the name for the main window's icon. */
-static void
-set_display_filename(capture_file *cf)
+/* Reset everything to a pristine state */
+void
+cf_close(capture_file *cf)
{
- const gchar *name_ptr;
- size_t msg_len;
- static const gchar done_fmt_nodrops[] = " File: %s %s %02u:%02u:%02u";
- static const gchar done_fmt_drops[] = " File: %s %s %02u:%02u:%02u Drops: %u";
- gchar *done_msg;
- gchar *win_name_fmt = "%s - Ethereal";
- gchar *win_name;
- gchar *size_str;
-
- name_ptr = cf_get_display_name(cf);
-
- if (!cf->is_tempfile) {
- /* Add this filename to the list of recent files in the "Recent Files" submenu */
- add_menu_recent_capture_file(cf->filename);
- }
-
- if (cf->f_len/1024/1024 > 10) {
- size_str = g_strdup_printf("%ld MB", cf->f_len/1024/1024);
- } else if (cf->f_len/1024 > 10) {
- size_str = g_strdup_printf("%ld KB", cf->f_len/1024);
- } else {
- size_str = g_strdup_printf("%ld bytes", cf->f_len);
- }
+ cf_reset_state(cf);
- if (cf->drops_known) {
- done_msg = g_strdup_printf(done_fmt_drops, name_ptr, size_str,
- cf->esec/3600, cf->esec%3600/60, cf->esec%60, cf->drops);
- } else {
- done_msg = g_strdup_printf(done_fmt_nodrops, name_ptr, size_str,
- cf->esec/3600, cf->esec%3600/60, cf->esec%60);
- }
- statusbar_push_file_msg(done_msg);
- g_free(done_msg);
+ cleanup_dissection();
- msg_len = strlen(name_ptr) + strlen(win_name_fmt) + 1;
- win_name = g_malloc(msg_len);
- snprintf(win_name, msg_len, win_name_fmt, name_ptr);
- set_main_window_name(win_name);
- g_free(win_name);
+ cf_callback_invoke(cf_cb_file_closed, cf);
}
cf_read_status_t
int err;
gchar *err_info;
const gchar *name_ptr;
- gchar *load_msg, *load_fmt = "%s";
- char *errmsg;
+ const char *errmsg;
char errmsg_errno[1024+1];
gchar err_str[2048+1];
long data_offset;
progdlg_t *progbar = NULL;
gboolean stop_flag;
- /*
- * XXX - should be "off_t", but Wiretap would need more work to handle
- * the full size of "off_t" on platforms where it's more than a "long"
- * as well.
- */
- long file_pos;
+ gint64 size, file_pos;
float prog_val;
- int fd;
- struct stat cf_stat;
GTimeVal start_time;
gchar status_str[100];
- int progbar_nextstep;
- int progbar_quantum;
+ gint64 progbar_nextstep;
+ gint64 progbar_quantum;
cum_bytes=0;
+
reset_tap_listeners();
tap_dfilter_dlg_update();
- name_ptr = get_basename(cf->filename);
- load_msg = g_strdup_printf(" Loading: %s", name_ptr);
- statusbar_push_file_msg(load_msg);
- g_free(load_msg);
+ cf_callback_invoke(cf_cb_file_read_start, cf);
- load_msg = g_strdup_printf(load_fmt, name_ptr);
+ name_ptr = get_basename(cf->filename);
+
+ /* Find the size of the file. */
+ size = wtap_file_size(cf->wth, NULL);
/* Update the progress bar when it gets to this value. */
progbar_nextstep = 0;
/* When we reach the value that triggers a progress bar update,
bump that value by this amount. */
- progbar_quantum = cf->f_len/N_PROGBAR_UPDATES;
+ if (size >= 0)
+ progbar_quantum = size/N_PROGBAR_UPDATES;
+ else
+ progbar_quantum = 0;
packet_list_freeze();
g_get_current_time(&start_time);
while ((wtap_read(cf->wth, &err, &err_info, &data_offset))) {
- /* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
- when we update it, we have to run the GTK+ main loop to get it
- to repaint what's pending, and doing so may involve an "ioctl()"
- to see if there's any pending input from an X server, and doing
- that for every packet can be costly, especially on a big file. */
- if (data_offset >= progbar_nextstep) {
- file_pos = lseek(cf->filed, 0, SEEK_CUR);
- prog_val = (gfloat) file_pos / (gfloat) cf->f_len;
- if (prog_val > 1.0) {
- /* The file probably grew while we were reading it.
- Update "cf->f_len", and try again. */
- fd = wtap_fd(cf->wth);
- if (fstat(fd, &cf_stat) >= 0) {
- cf->f_len = cf_stat.st_size;
- prog_val = (gfloat) file_pos / (gfloat) cf->f_len;
+ if (size >= 0) {
+ /* Update the progress bar, but do it only N_PROGBAR_UPDATES times;
+ when we update it, we have to run the GTK+ main loop to get it
+ to repaint what's pending, and doing so may involve an "ioctl()"
+ to see if there's any pending input from an X server, and doing
+ that for every packet can be costly, especially on a big file. */
+ if (data_offset >= progbar_nextstep) {
+ file_pos = wtap_read_so_far(cf->wth, NULL);
+ prog_val = (gfloat) file_pos / (gfloat) size;
+ if (prog_val > 1.0) {
+ /* The file probably grew while we were reading it.
+ Update file size, and try again. */
+ size = wtap_file_size(cf->wth, NULL);
+ if (size >= 0)
+ prog_val = (gfloat) file_pos / (gfloat) size;
+ /* If it's still > 1, either "wtap_file_size()" failed (in which
+ case there's not much we can do about it), or the file
+ *shrank* (in which case there's not much we can do about
+ it); just clip the progress value at 1.0. */
+ if (prog_val > 1.0)
+ prog_val = 1.0;
}
- /* If it's still > 1, either the "fstat()" failed (in which
- case there's not much we can do about it), or the file
- *shrank* (in which case there's not much we can do about
- it); just clip the progress value at 1.0. */
- if (prog_val > 1.0)
- prog_val = 1.0;
- }
- if (progbar == NULL) {
- /* Create the progress bar if necessary */
- progbar = delayed_create_progress_dlg("Loading", load_msg,
- &stop_flag, &start_time, prog_val);
- if (progbar != NULL)
- g_free(load_msg);
- }
- if (progbar != NULL) {
- g_snprintf(status_str, sizeof(status_str),
- "%luKB of %luKB", file_pos / 1024, cf->f_len / 1024);
- update_progress_dlg(progbar, prog_val, status_str);
- }
- progbar_nextstep += progbar_quantum;
+ if (progbar == NULL) {
+ /* Create the progress bar if necessary */
+ progbar = delayed_create_progress_dlg("Loading", name_ptr,
+ &stop_flag, &start_time, prog_val);
+ }
+ if (progbar != NULL) {
+ g_snprintf(status_str, sizeof(status_str),
+ "%" PRId64 "KB of %" PRId64 "KB",
+ file_pos / 1024, size / 1024);
+ update_progress_dlg(progbar, prog_val, status_str);
+ }
+ progbar_nextstep += progbar_quantum;
+ }
}
if (stop_flag) {
}
/* We're done reading the file; destroy the progress bar if it was created. */
- if (progbar == NULL)
- g_free(load_msg);
- else
+ if (progbar != NULL)
destroy_progress_dlg(progbar);
/* We're done reading sequentially through the file. */
cf->current_frame = cf->first_displayed;
packet_list_thaw();
- statusbar_pop_file_msg();
- set_display_filename(cf);
-
- /* Enable menu items that make sense if you have a capture file you've
- finished reading. */
- set_menus_for_capture_file(TRUE);
- set_menus_for_unsaved_capture_file(!cf->user_saved);
-
- /* Enable menu items that make sense if you have some captured packets. */
- set_menus_for_captured_packets(TRUE);
+ cf_callback_invoke(cf_cb_file_read_finished, cf);
/* If we have any displayed packets to select, select the first of those
packets by making the first row the selected row. */
switch (err) {
case WTAP_ERR_UNSUPPORTED_ENCAP:
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"The capture file has a packet with a network type that Ethereal doesn't support.\n(%s)",
err_info);
g_free(err_info);
break;
case WTAP_ERR_BAD_RECORD:
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"The capture file 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),
"An error occurred while reading the"
" capture file: %s.", wtap_strerror(err));
errmsg = errmsg_errno;
break;
}
- snprintf(err_str, sizeof err_str, errmsg);
+ g_snprintf(err_str, sizeof err_str, errmsg);
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, err_str);
return CF_READ_ERROR;
} else
cf_status_t
cf_start_tail(capture_file *cf, const char *fname, gboolean is_tempfile, int *err)
{
- gchar *capture_msg;
cf_status_t cf_status;
cf_status = cf_open(cf, fname, is_tempfile, err);
- if (cf_status == CF_OK) {
- /* Disable menu items that make no sense if you're currently running
- a capture. */
- set_menus_for_capture_in_progress(TRUE);
-
- /* Enable menu items that make sense if you have some captured
- packets (yes, I know, we don't have any *yet*). */
- set_menus_for_captured_packets(TRUE);
-
- capture_msg = g_strdup_printf(" %s: <live capture in progress>", cf->iface);
-
- statusbar_push_file_msg(capture_msg);
-
- g_free(capture_msg);
-
- }
return cf_status;
}
{
gchar *err_info;
long data_offset;
- int fd;
- struct stat cf_stat;
+
+ if(cf->wth == NULL) {
+ cf_close(cf);
+ return CF_READ_ERROR;
+ }
packet_list_freeze();
/* We're done reading sequentially through the file. */
cf->state = FILE_READ_DONE;
- /* we have to update the f_len field */
- /* Find the size of the file. */
- fd = wtap_fd(cf->wth);
- if (fstat(fd, &cf_stat) >= 0) {
- cf->f_len = cf_stat.st_size;
- }
-
/* We're done reading sequentially through the file; close the
sequential I/O side, to free up memory it requires. */
wtap_sequential_close(cf->wth);
WTAP_ENCAP_PER_PACKET). */
cf->lnk_t = wtap_file_encap(cf->wth);
- /* Pop the "<live capture in progress>" message off the status bar. */
- statusbar_pop_file_msg();
-
- set_display_filename(cf);
-
- /* Enable menu items that make sense if you're not currently running
- a capture. */
- set_menus_for_capture_in_progress(FALSE);
-
- /* Enable menu items that make sense if you have a capture file
- you've finished reading. */
- set_menus_for_capture_file(TRUE);
- set_menus_for_unsaved_capture_file(!cf->user_saved);
-
if (*err != 0) {
/* We got an error reading the capture file.
XXX - pop up a dialog box? */
/* Get the last component of the file name, and use that. */
if (cf->filename){
displayname = get_basename(cf->filename);
-
- /* Add this filename to the list of recent files in the "Recent Files" submenu */
- add_menu_recent_capture_file(cf->filename);
} else {
displayname="(No file)";
}
return cf->count;
}
-/* XXX - use a macro instead? */
-/* XXX - move iface this to capture_opts? */
-gchar *
-cf_get_iface(capture_file *cf)
-{
- return cf->iface;
-}
-
/* XXX - use a macro instead? */
gboolean
cf_is_tempfile(capture_file *cf)
return cf->is_tempfile;
}
+void cf_set_tempfile(capture_file *cf, gboolean is_tempfile)
+{
+ cf->is_tempfile = is_tempfile;
+}
+
+
/* XXX - use a macro instead? */
void cf_set_drops_known(capture_file *cf, gboolean drops_known)
{
cf->drops = drops;
}
-void cf_set_rfcode(capture_file *cf, dfilter_t *rfcode)
+/* XXX - use a macro instead? */
+gboolean cf_get_drops_known(capture_file *cf)
{
- cf->rfcode = rfcode;
+ return cf->drops_known;
}
-gchar *cf_get_cfilter(capture_file *cf)
+/* XXX - use a macro instead? */
+guint32 cf_get_drops(capture_file *cf)
{
- return cf->cfilter;
+ return cf->drops;
}
-typedef struct {
- color_filter_t *colorf;
- epan_dissect_t *edt;
-} apply_color_filter_args;
-
-/*
- * If no color filter has been applied, apply this one.
- * (The "if no color filter has been applied" is to handle the case where
- * more than one color filter matches the packet.)
- */
-static void
-apply_color_filter(gpointer filter_arg, gpointer argp)
+void cf_set_rfcode(capture_file *cf, dfilter_t *rfcode)
{
- color_filter_t *colorf = filter_arg;
- apply_color_filter_args *args = argp;
-
- if (colorf->c_colorfilter != NULL && args->colorf == NULL) {
- if (dfilter_apply_edt(colorf->c_colorfilter, args->edt))
- args->colorf = colorf;
- }
+ cf->rfcode = rfcode;
}
static int
union wtap_pseudo_header *pseudo_header, const guchar *buf,
gboolean refilter)
{
- apply_color_filter_args args;
gint row;
gboolean create_proto_tree = FALSE;
epan_dissect_t *edt;
/* just add some value here until we know if it is being displayed or not */
fdata->cum_bytes = cum_bytes + fdata->pkt_len;
- /* We don't yet have a color filter to apply. */
- args.colorf = NULL;
-
/* 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 this frames is marked as a reference time frame, reset
firstsec and firstusec to this frame */
if(fdata->flags.ref_time){
- firstsec = fdata->abs_secs;
- firstusec = fdata->abs_usecs;
+ 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);
+ nstime_delta(&fdata->del_ts, &fdata->abs_ts, &prev_ts);
/* If either
allocate a protocol tree root node, so that we'll construct
a protocol tree against which a filter expression can be
evaluated. */
- if ((cf->dfcode != NULL && refilter) || filter_list != NULL
+ if ((cf->dfcode != NULL && refilter) || color_filters_used()
|| num_tap_filters != 0)
create_proto_tree = TRUE;
if (cf->dfcode != NULL && refilter) {
epan_dissect_prime_dfilter(edt, cf->dfcode);
}
- if (filter_list) {
- filter_list_prime_edt(edt);
+ if (color_filters_used()) {
+ color_filters_prime_edt(edt);
}
tap_queue_init(edt);
epan_dissect_run(edt, pseudo_header, buf, fdata, &cf->cinfo);
If we don't have a display filter, set "passed_dfilter" to 1. */
if (cf->dfcode != NULL) {
if (refilter) {
- if (cf->dfcode != NULL)
- fdata->flags.passed_dfilter = dfilter_apply_edt(cf->dfcode, edt) ? 1 : 0;
- else
- fdata->flags.passed_dfilter = 1;
+ fdata->flags.passed_dfilter = dfilter_apply_edt(cf->dfcode, edt) ? 1 : 0;
}
} else
fdata->flags.passed_dfilter = 1;
- /* If we have color filters, and the frame is to be displayed, apply
- the color filters. */
- if (fdata->flags.passed_dfilter) {
- if (filter_list != NULL) {
- args.edt = edt;
- g_slist_foreach(filter_list, apply_color_filter, &args);
- }
- }
-
-
if( (fdata->flags.passed_dfilter)
|| (edt->pi.fd->flags.ref_time) ){
/* This frame either passed the display filter list or is marked as
row = packet_list_append(cf->cinfo.col_data, fdata);
- /* If the packet matches a color filter,
- * store matching color_filter_t object in frame data. */
- if (filter_list != NULL && (args.colorf != NULL)) {
- /* add the matching colorfilter to the frame data */
- fdata->color_filter = args.colorf;
- /* If packet is marked, use colors from preferences */
- if (fdata->flags.marked) {
- packet_list_set_colors(row, &prefs.gui_marked_fg, &prefs.gui_marked_bg);
- } else /* if (filter_list != NULL && (args.colorf != NULL)) */ {
- packet_list_set_colors(row, &(args.colorf->fg_color),
- &(args.colorf->bg_color));
- }
- } else {
- /* No color filter match */
- fdata->color_filter = NULL;
+ /* colorize packet: if packet is marked, use preferences,
+ otherwise try to apply color filters */
if (fdata->flags.marked) {
+ fdata->color_filter = NULL;
packet_list_set_colors(row, &prefs.gui_marked_fg, &prefs.gui_marked_bg);
+ } else {
+ fdata->color_filter = color_filters_colorize_packet(row, edt);
}
- }
/* Set the time of the previous displayed frame to the time of this
frame. */
- prevsec = fdata->abs_secs;
- prevusec = fdata->abs_usecs;
+ prev_ts = fdata->abs_ts;
cf->displayed_count++;
} else {
/* Allocate the next list entry, and add it to the list. */
fdata = g_mem_chunk_alloc(cf->plist_chunk);
+ fdata->num = 0;
fdata->next = NULL;
fdata->prev = NULL;
fdata->pfd = NULL;
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->flags.encoding = CHAR_ASCII;
fdata->flags.visited = 0;
fdata->flags.marked = 0;
fdata->flags.ref_time = 0;
+ fdata->abs_ts = *((nstime_t *) &phdr->ts);
+
passed = TRUE;
if (cf->rfcode) {
edt = epan_dissect_new(TRUE, FALSE);
cf->plist_end = fdata;
cf->count++;
+ cf->f_datalen = offset + phdr->caplen;
fdata->num = cf->count;
add_packet_to_packet_list(fdata, cf, pseudo_header, buf, TRUE);
} else {
}
cf_status_t
-cf_merge_files(const char *out_filename, int out_fd, int in_file_count,
+cf_merge_files(char **out_filenamep, int in_file_count,
char *const *in_filenames, int file_type, gboolean do_append)
{
merge_in_file_t *in_files;
wtap *wth;
+ char *out_filename;
+ char tmpname[128+1];
+ int out_fd;
wtap_dumper *pdh;
int open_err, read_err, write_err, close_err;
gchar *err_info;
int i;
char errmsg_errno[1024+1];
gchar err_str[2048+1];
- char *errmsg;
+ const char *errmsg;
gboolean got_read_error = FALSE, got_write_error = FALSE;
long data_offset;
progdlg_t *progbar = NULL;
gboolean stop_flag;
- /*
- * XXX - should be "off_t", but Wiretap would need more work to handle
- * the full size of "off_t" on platforms where it's more than a "long"
- * as well.
- */
- long f_len, file_pos;
- float prog_val;
- GTimeVal start_time;
- gchar status_str[100];
- int progbar_nextstep;
- int progbar_quantum;
+ gint64 f_len, file_pos;
+ float prog_val;
+ GTimeVal start_time;
+ gchar status_str[100];
+ gint64 progbar_nextstep;
+ gint64 progbar_quantum;
/* open the input files */
if (!merge_open_in_files(in_file_count, in_filenames, &in_files,
return CF_ERROR;
}
+ if (*out_filenamep != NULL) {
+ out_filename = *out_filenamep;
+ out_fd = open(out_filename, O_CREAT|O_TRUNC|O_BINARY, 0600);
+ if (out_fd == -1)
+ open_err = errno;
+ } else {
+ out_fd = create_tempfile(tmpname, sizeof tmpname, "ether");
+ if (out_fd == -1)
+ open_err = errno;
+ out_filename = g_strdup(tmpname);
+ *out_filenamep = out_filename;
+ }
+ if (out_fd == -1) {
+ err_info = NULL;
+ merge_close_in_files(in_file_count, in_files);
+ free(in_files);
+ cf_open_failure_alert_box(out_filename, open_err, NULL, TRUE, file_type);
+ return CF_ERROR;
+ }
+
pdh = wtap_dump_fdopen(out_fd, file_type,
merge_select_frame_type(in_file_count, in_files),
- merge_max_snapshot_length(in_file_count, in_files), &open_err);
+ merge_max_snapshot_length(in_file_count, in_files),
+ FALSE /* compressed */, &open_err);
if (pdh == NULL) {
+ close(out_fd);
merge_close_in_files(in_file_count, in_files);
free(in_files);
cf_open_failure_alert_box(out_filename, open_err, err_info, TRUE,
/* Get the sum of the seek positions in all of the files. */
file_pos = 0;
for (i = 0; i < in_file_count; i++)
- file_pos += lseek(wtap_fd(in_files[i].wth), 0, SEEK_CUR);
+ file_pos += wtap_read_so_far(in_files[i].wth, NULL);
prog_val = (gfloat) file_pos / (gfloat) f_len;
if (prog_val > 1.0) {
/* Some file probably grew while we were reading it.
}
if (progbar != NULL) {
g_snprintf(status_str, sizeof(status_str),
- "%luKB of %luKB", file_pos / 1024, f_len / 1024);
+ "%" PRId64 "KB of %" PRId64 "KB",
+ file_pos / 1024, f_len / 1024);
update_progress_dlg(progbar, prog_val, status_str);
}
progbar_nextstep += progbar_quantum;
switch (read_err) {
case WTAP_ERR_UNSUPPORTED_ENCAP:
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"The capture file %%s has a packet with a network type that Ethereal doesn't support.\n(%s)",
err_info);
g_free(err_info);
break;
case WTAP_ERR_BAD_RECORD:
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"The capture 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),
"An error occurred while reading the"
" capture file %%s: %s.", wtap_strerror(read_err));
errmsg = errmsg_errno;
break;
}
- snprintf(err_str, sizeof err_str, errmsg, in_files[i].filename);
+ g_snprintf(err_str, sizeof err_str, errmsg, in_files[i].filename);
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, err_str);
}
}
cf_status_t
cf_filter_packets(capture_file *cf, gchar *dftext, gboolean force)
{
- dfilter_t *dfcode;
- char *filter_new = dftext ? dftext : "";
- char *filter_old = cf->dfilter ? cf->dfilter : "";
+ dfilter_t *dfcode;
+ const char *filter_new = dftext ? dftext : "";
+ const char *filter_old = cf->dfilter ? cf->dfilter : "";
/* if new filter equals old one, do nothing unless told to do so */
if (!force && strcmp(filter_new, filter_old) == 0) {
/* Iterate through the list of frames. Call a routine for each frame
to check whether it should be displayed and, if so, add it to
the display list. */
- firstsec = 0;
- firstusec = 0;
- prevsec = 0;
- prevusec = 0;
+ nstime_set_zero(&first_ts);
+ nstime_set_zero(&prev_ts);
/* Update the progress bar when it gets to this value. */
progbar_nextstep = 0;
PSP_FAILED
} psp_return_t;
-psp_return_t
+static psp_return_t
process_specified_packets(capture_file *cf, packet_range_t *range,
const char *string1, const char *string2,
gboolean (*callback)(capture_file *, frame_data *,
static gboolean
retap_packet(capture_file *cf _U_, frame_data *fdata,
union wtap_pseudo_header *pseudo_header, const guint8 *pd,
- void *argsp _U_)
+ void *argsp)
{
+ column_info *cinfo = argsp;
epan_dissect_t *edt;
/* If we have tap listeners, allocate a protocol tree root node, so that
be evaluated. */
edt = epan_dissect_new(num_tap_filters != 0, FALSE);
tap_queue_init(edt);
- epan_dissect_run(edt, pseudo_header, pd, fdata, NULL);
+ epan_dissect_run(edt, pseudo_header, pd, fdata, cinfo);
tap_push_tapped_queue(edt);
epan_dissect_free(edt);
}
cf_read_status_t
-cf_retap_packets(capture_file *cf)
+cf_retap_packets(capture_file *cf, gboolean do_columns)
{
packet_range_t range;
packet_range_process_init(&range);
switch (process_specified_packets(cf, &range, "Refiltering statistics on",
"all packets", retap_packet,
- NULL)) {
+ do_columns ? &cf->cinfo : NULL)) {
case PSP_FINISHED:
/* Completed successfully. */
return CF_OK;
* We generate bookmarks, if the output format supports them.
* The name is "__frameN__".
*/
- sprintf(bookmark_name, "__frame%u__", fdata->num);
+ g_snprintf(bookmark_name, sizeof bookmark_name, "__frame%u__", fdata->num);
if (args->print_args->print_summary) {
if (args->print_header_line) {
* Generate a bookmark, using "Frame N" as the title, as we're not
* printing the summary line.
*/
- sprintf(bookmark_title, "Frame %u", fdata->num);
+ g_snprintf(bookmark_title, sizeof bookmark_title, "Frame %u", fdata->num);
if (!print_bookmark(args->print_args->stream, bookmark_name,
bookmark_title))
goto fail;
/* Fill in the column information, but don't create the protocol tree. */
edt = epan_dissect_new(FALSE, FALSE);
epan_dissect_run(edt, pseudo_header, pd, fdata, &cf->cinfo);
+ epan_dissect_fill_in_columns(edt);
/* Write out the information in that tree. */
proto_tree_write_psml(edt, fh);
return CF_PRINT_OK;
}
+static gboolean
+write_csv_packet(capture_file *cf, frame_data *fdata,
+ union wtap_pseudo_header *pseudo_header, const guint8 *pd,
+ void *argsp)
+{
+ FILE *fh = argsp;
+ epan_dissect_t *edt;
+
+ /* Fill in the column information, but don't create the protocol tree. */
+ edt = epan_dissect_new(FALSE, FALSE);
+ epan_dissect_run(edt, pseudo_header, pd, fdata, &cf->cinfo);
+ epan_dissect_fill_in_columns(edt);
+
+ /* Write out the information in that tree. */
+ proto_tree_write_csv(edt, fh);
+
+ epan_dissect_free(edt);
+
+ return !ferror(fh);
+}
+
+cf_print_status_t
+cf_write_csv_packets(capture_file *cf, print_args_t *print_args)
+{
+ FILE *fh;
+ psp_return_t ret;
+
+ fh = fopen(print_args->file, "w");
+ if (fh == NULL)
+ return CF_PRINT_OPEN_ERROR; /* attempt to open destination failed */
+
+ write_csv_preamble(fh);
+ if (ferror(fh)) {
+ fclose(fh);
+ return CF_PRINT_WRITE_ERROR;
+ }
+
+ /* Iterate through the list of packets, printing the packets we were
+ told to print. */
+ ret = process_specified_packets(cf, &print_args->range, "Writing CSV",
+ "selected packets", write_csv_packet,
+ fh);
+
+ switch (ret) {
+
+ case PSP_FINISHED:
+ /* Completed successfully. */
+ break;
+
+ case PSP_STOPPED:
+ /* Well, the user decided to abort the printing. */
+ break;
+
+ case PSP_FAILED:
+ /* Error while printing. */
+ fclose(fh);
+ return CF_PRINT_WRITE_ERROR;
+ }
+
+ write_csv_finale(fh);
+ if (ferror(fh)) {
+ fclose(fh);
+ return CF_PRINT_WRITE_ERROR;
+ }
+
+ /* XXX - check for an error */
+ fclose(fh);
+
+ return CF_PRINT_OK;
+}
+
/* Scan through the packet list and change all columns that use the
"command-line-specified" time stamp format to use the current
value of that format. */
int first, last;
gboolean sorted_by_frame_column;
+
+ /* adjust timestamp precision if auto is selected */
+ cf_timestamp_auto_precision(cf);
+
/* Are there any columns with time stamps in the "command-line-specified"
format?
if (fdata == NULL) {
/* we didn't find a packet with that packet number */
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
- "There is no packet with that packet number.");
+ "There is no packet with the packet number %u.", fnumber);
return FALSE; /* we failed to go to that packet */
}
if (!fdata->flags.passed_dfilter) {
/* that packet currently isn't displayed */
/* XXX - add it to the set of displayed packets? */
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
- "That packet isn't currently being displayed.");
+ "The packet number %u isn't currently being displayed.", fnumber);
return FALSE; /* we failed to go to that packet */
}
epan_dissect_run(cf->edt, &cf->pseudo_header, cf->pd, cf->current_frame,
NULL);
- /* Display the GUI protocol tree and hex dump.
- XXX - why do we dump core if we call "proto_tree_draw()"
- before calling "add_byte_views()"? */
- add_main_byte_views(cf->edt);
- main_proto_tree_draw(cf->edt->tree);
-
- /* A packet is selected. */
- set_menus_for_selected_packet(cf);
+ cf_callback_invoke(cf_cb_packet_selected, cf);
}
/* Unselect the selected packet, if any. */
cf->edt = NULL;
}
- /* Clear out the display of that packet. */
- clear_tree_and_hex_views();
-
/* No packet is selected. */
cf->current_frame = NULL;
- set_menus_for_selected_packet(cf);
+
+ cf_callback_invoke(cf_cb_packet_unselected, cf);
/* No protocol tree means no selected field. */
cf_unselect_field(cf);
void
cf_unselect_field(capture_file *cf)
{
- statusbar_pop_field_msg();
cf->finfo_selected = NULL;
- set_menus_for_selected_tree_row(cf);
+
+ cf_callback_invoke(cf_cb_field_unselected, cf);
}
/*
int err;
/* init the wtap header for saving */
- hdr.ts.tv_sec = fdata->abs_secs;
- hdr.ts.tv_usec = fdata->abs_usecs;
+ hdr.ts = *(struct wtap_nstime *) &fdata->abs_ts;
hdr.caplen = fdata->cap_len;
hdr.len = fdata->pkt_len;
hdr.pkt_encap = fdata->lnk_t;
}
cf_status_t
-cf_save(capture_file *cf, const char *fname, packet_range_t *range, guint save_format)
+cf_save(capture_file *cf, const char *fname, packet_range_t *range, guint save_format, gboolean compressed)
{
gchar *from_filename;
- const gchar *name_ptr;
- gchar *save_msg, *save_fmt = " Saving: %s...";
- size_t msg_len;
int err;
gboolean do_copy;
wtap_dumper *pdh;
- struct stat infile, outfile;
save_callback_args_t callback_args;
- name_ptr = get_basename(fname);
- msg_len = strlen(name_ptr) + strlen(save_fmt) + 2;
- save_msg = g_malloc(msg_len);
- snprintf(save_msg, msg_len, save_fmt, name_ptr);
- statusbar_push_file_msg(save_msg);
- g_free(save_msg);
+ cf_callback_invoke(cf_cb_file_safe_started, (gpointer) fname);
- /*
- * Check that the from file is not the same as to file
- * We do it here so we catch all cases ...
- * Unfortunately, the file requester gives us an absolute file
- * name and the read file name may be relative (if supplied on
- * the command line). From Joerg Mayer.
- *
- * This is a bit tricky on win32. The st_ino field is documented as:
- * "The inode, and therefore st_ino, has no meaning in the FAT, ..."
- * but it *is* set to zero if stat() returns without an error,
- * so this is working, but maybe not quite the way expected. ULFL
- */
- infile.st_ino = 1; /* These prevent us from getting equality */
- outfile.st_ino = 2; /* If one or other of the files is not accessible */
- stat(cf->filename, &infile);
- stat(fname, &outfile);
- if (infile.st_ino == outfile.st_ino) {
+ /* don't write over an existing file. */
+ /* this should've been already checked by our caller, just to be sure... */
+ if (file_exists(fname)) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"%sCapture file: \"%s\" already exists!%s\n\n"
"Please choose a different filename.",
/* Either we're filtering packets, or we're saving in a different
format; we can't do that by copying or moving the capture file,
we have to do it by writing the packets out in Wiretap. */
- pdh = wtap_dump_open(fname, save_format, cf->lnk_t, cf->snap, &err);
+ pdh = wtap_dump_open(fname, save_format, cf->lnk_t, cf->snap,
+ compressed, &err);
if (pdh == NULL) {
cf_open_failure_alert_box(fname, err, NULL, TRUE, save_format);
goto fail;
}
}
- /* Pop the "Saving:" message off the status bar. */
- statusbar_pop_file_msg();
+ cf_callback_invoke(cf_cb_file_safe_finished, NULL);
if (packet_range_process_all(range)) {
/* We saved the entire capture, not just some packets from it.
correctly for the "no capture file open" state). */
break;
}
- set_menus_for_unsaved_capture_file(FALSE);
+ cf_callback_invoke(cf_cb_file_safe_reload_finished, NULL);
}
}
return CF_OK;
fail:
- /* Pop the "Saving:" message off the status bar. */
- statusbar_pop_file_msg();
+ cf_callback_invoke(cf_cb_file_safe_failed, NULL);
return CF_ERROR;
}
filename);
break;
+ case WTAP_ERR_COMPRESSION_NOT_SUPPORTED:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "Gzip compression not supported by this file type.");
+ break;
+
default:
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"The file \"%s\" could not be %s: %s.",
}
}
-static char *
+static const char *
file_rename_error_message(int err)
{
- char *errmsg;
+ const char *errmsg;
static char errmsg_errno[1024+1];
switch (err) {
break;
default:
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"The file \"%%s\" could not be moved: %s.",
wtap_strerror(err));
errmsg = errmsg_errno;
switch (err) {
case WTAP_ERR_UNSUPPORTED_ENCAP:
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"The file \"%%s\" has a packet with a network type that Ethereal doesn't support.\n(%s)",
err_info);
break;
case WTAP_ERR_BAD_RECORD:
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"An error occurred while reading from the file \"%%s\": %s.\n(%s)",
wtap_strerror(err), err_info);
break;
default:
- snprintf(errmsg_errno, sizeof(errmsg_errno),
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"An error occurred while reading from the file \"%%s\": %s.",
wtap_strerror(err));
break;
git.samba.org / obnox / wireshark / wip.git / blobdiff