/* file.c
* File I/O routines
*
- * $Id: file.c,v 1.323 2003/11/15 10:06:44 ulfl Exp $
+ * $Id: file.c,v 1.368 2004/02/28 22:04:28 ulfl Exp $
*
* Ethereal - Network traffic analyzer
* By Gerald Combs <gerald@ethereal.com>
#include "color.h"
#include "column.h"
#include <epan/packet.h>
+#include "range.h"
#include "print.h"
#include "file.h"
#include "menu.h"
#include "util.h"
+#include "alert_box.h"
#include "simple_dialog.h"
#include "progress_dlg.h"
#include "ui_util.h"
#include "globals.h"
#include <epan/epan_dissect.h>
#include "tap.h"
+#include "tap_dfilter_dlg.h"
#include "packet-data.h"
#ifdef HAVE_LIBPCAP
static guint32 firstsec, firstusec;
static guint32 prevsec, prevusec;
-static guint32 cul_bytes = 0;
+static guint32 cum_bytes = 0;
static void read_packet(capture_file *cf, long offset);
static gboolean match_protocol_tree(capture_file *cf, frame_data *fdata,
void *criterion);
-static void match_subtree_text(GNode *node, gpointer data);
+static void match_subtree_text(proto_node *node, gpointer data);
static gboolean match_summary_line(capture_file *cf, frame_data *fdata,
void *criterion);
static gboolean match_ascii_and_unicode(capture_file *cf, frame_data *fdata,
gboolean (*match_function)(capture_file *, frame_data *, void *),
void *criterion);
-static void freeze_plist(capture_file *cf);
-static void thaw_plist(capture_file *cf);
-
+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 char *file_close_error_message(int err);
-static gboolean copy_binary_file(char *from_filename, char *to_filename);
+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(char *from_filename, char *to_filename);
/* Update the progress bar this many times when reading a file. */
#define N_PROGBAR_UPDATES 100
XXX - is this the right number? */
#define FRAME_DATA_CHUNK_SIZE 1024
-
typedef struct {
int level;
FILE *fh;
gint format; /* text or PostScript */
} print_data;
-
int
cf_open(char *fname, gboolean is_tempfile, capture_file *cf)
{
wtap *wth;
int err;
+ gchar *err_info;
int fd;
struct stat cf_stat;
- wth = wtap_open_offline(fname, &err, TRUE);
+ wth = wtap_open_offline(fname, &err, &err_info, TRUE);
if (wth == NULL)
goto fail;
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->snap = WTAP_MAX_PACKET_SIZE;
} else
cf->has_snap = TRUE;
- cf->progbar_quantum = 0;
- cf->progbar_nextstep = 0;
firstsec = 0, firstusec = 0;
prevsec = 0, prevusec = 0;
return (0);
fail:
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_open_error_message(err, FALSE, 0), fname);
+ cf_open_failure_alert_box(fname, err, err_info, FALSE, 0);
return (err);
}
/* Die if we're in the middle of reading a file. */
g_assert(cf->state != FILE_READ_IN_PROGRESS);
- /* Destroy all popup packet windows, as they refer to packets in the
+ /* Destroy all windows, which refer to the
capture file we're closing. */
- destroy_packet_wins();
+ destroy_cfile_wins();
if (cf->wth) {
wtap_close(cf->wth);
packet_list_clear();
packet_list_thaw();
+ cf->f_len = 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? */
{
gchar *name_ptr;
size_t msg_len;
- static const gchar done_fmt_nodrops[] = " File: %s";
- static const gchar done_fmt_drops[] = " File: %s Drops: %u";
+ 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);
+ }
+
if (cf->drops_known) {
- msg_len = strlen(name_ptr) + strlen(done_fmt_drops) + 64;
- done_msg = g_malloc(msg_len);
- snprintf(done_msg, msg_len, done_fmt_drops, name_ptr, cf->drops);
+ 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 {
- msg_len = strlen(name_ptr) + strlen(done_fmt_nodrops);
- done_msg = g_malloc(msg_len);
- snprintf(done_msg, msg_len, done_fmt_nodrops, name_ptr);
+ 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);
}
read_status_t
-cf_read(capture_file *cf, int *err)
+cf_read(capture_file *cf)
{
+ int err;
+ gchar *err_info;
gchar *name_ptr, *load_msg, *load_fmt = "%s";
- size_t msg_len;
char *errmsg;
char errmsg_errno[1024+1];
gchar err_str[2048+1];
struct stat cf_stat;
GTimeVal start_time;
gchar status_str[100];
+ int progbar_nextstep;
+ int progbar_quantum;
- cul_bytes=0;
+ cum_bytes=0;
reset_tap_listeners();
+ tap_dfilter_dlg_update();
name_ptr = get_basename(cf->filename);
- msg_len = strlen(name_ptr) + strlen(load_fmt) + 2;
- load_msg = g_malloc(msg_len);
- snprintf(load_msg, msg_len, load_fmt, name_ptr);
+ load_msg = g_strdup_printf(" Loading: %s", name_ptr);
statusbar_push_file_msg(load_msg);
+ g_free(load_msg);
+
+ load_msg = g_strdup_printf(load_fmt, name_ptr);
/* Update the progress bar when it gets to this value. */
- cf->progbar_nextstep = 0;
+ progbar_nextstep = 0;
/* When we reach the value that triggers a progress bar update,
bump that value by this amount. */
- cf->progbar_quantum = cf->f_len/N_PROGBAR_UPDATES;
+ progbar_quantum = cf->f_len/N_PROGBAR_UPDATES;
#ifndef O_BINARY
#define O_BINARY 0
#endif
- freeze_plist(cf);
+ packet_list_freeze();
stop_flag = FALSE;
g_get_current_time(&start_time);
- while ((wtap_read(cf->wth, err, &data_offset))) {
+ 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 >= cf->progbar_nextstep) {
+ 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) {
}
if (progbar == NULL) {
/* Create the progress bar if necessary */
- progbar = delayed_create_progress_dlg("Loading", load_msg, "Stop",
+ progbar = delayed_create_progress_dlg("Loading", load_msg,
&stop_flag, &start_time, prog_val);
if (progbar != NULL)
g_free(load_msg);
"%luKB of %luKB", file_pos / 1024, cf->f_len / 1024);
update_progress_dlg(progbar, prog_val, status_str);
}
- cf->progbar_nextstep += cf->progbar_quantum;
+ progbar_nextstep += progbar_quantum;
}
if (stop_flag) {
cf->lnk_t = wtap_file_encap(cf->wth);
cf->current_frame = cf->first_displayed;
- thaw_plist(cf);
+ packet_list_thaw();
statusbar_pop_file_msg();
set_display_filename(cf);
if (cf->first_displayed != NULL)
packet_list_select_row(0);
- if (*err != 0) {
+ if (err != 0) {
/* Put up a message box noting that the read failed somewhere along
the line. Don't throw out the stuff we managed to read, though,
if any. */
- switch (*err) {
+ switch (err) {
case WTAP_ERR_UNSUPPORTED_ENCAP:
errmsg = "The capture file is for a network type that Ethereal doesn't support.";
break;
case WTAP_ERR_BAD_RECORD:
- errmsg = "The capture file appears to be damaged or corrupt.";
+ snprintf(errmsg_errno, sizeof(errmsg_errno),
+ "The capture file appears to be damaged or corrupt.\n(%s)",
+ err_info);
+ errmsg = errmsg_errno;
break;
default:
snprintf(errmsg_errno, sizeof(errmsg_errno),
"An error occurred while reading the"
- " capture file: %s.", wtap_strerror(*err));
+ " capture file: %s.", wtap_strerror(err));
errmsg = errmsg_errno;
break;
}
snprintf(err_str, sizeof err_str, errmsg);
- simple_dialog(ESD_TYPE_CRIT, NULL, err_str);
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, err_str);
return (READ_ERROR);
} else
return (READ_SUCCESS);
cf_start_tail(char *fname, gboolean is_tempfile, capture_file *cf)
{
int err;
- int i;
err = cf_open(fname, is_tempfile, cf);
if (err == 0) {
packets (yes, I know, we don't have any *yet*). */
set_menus_for_captured_packets(TRUE);
- for (i = 0; i < cf->cinfo.num_cols; i++) {
- if (get_column_resize_type(cf->cinfo.col_fmt[i]) == RESIZE_LIVE)
- packet_list_set_column_auto_resize(i, TRUE);
- else {
- packet_list_set_column_auto_resize(i, FALSE);
- packet_list_set_column_width(i, cf->cinfo.col_width[i]);
- packet_list_set_column_resizeable(i, TRUE);
- }
- }
-
statusbar_push_file_msg(" <live capture in progress>");
}
return err;
cf_continue_tail(capture_file *cf, int to_read, int *err)
{
long data_offset = 0;
+ gchar *err_info;
*err = 0;
packet_list_freeze();
- while (to_read != 0 && (wtap_read(cf->wth, err, &data_offset))) {
+ while (to_read != 0 && (wtap_read(cf->wth, err, &err_info, &data_offset))) {
if (cf->state == FILE_READ_ABORTED) {
/* Well, the user decided to exit Ethereal. Break out of the
loop, and let the code below (which is called even if there
read_status_t
cf_finish_tail(capture_file *cf, int *err)
{
+ gchar *err_info;
long data_offset;
+ int fd;
+ struct stat cf_stat;
packet_list_freeze();
- while ((wtap_read(cf->wth, err, &data_offset))) {
+ while ((wtap_read(cf->wth, err, &err_info, &data_offset))) {
if (cf->state == FILE_READ_ABORTED) {
/* Well, the user decided to abort the read. Break out of the
loop, and let the code below (which is called even if there
return READ_ABORTED;
}
- thaw_plist(cf);
+ packet_list_thaw();
if (auto_scroll_live && cf->plist_end != NULL)
/* XXX - this cheats and looks inside the packet list to find the final
row number. */
/* 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);
/* We got an error reading the capture file.
XXX - pop up a dialog box? */
return (READ_ERROR);
- } else
+ } else {
return (READ_SUCCESS);
+ }
}
#endif /* HAVE_LIBPCAP */
/* 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>";
+ displayname="(No file)";
}
} else {
/* The file we read is a temporary file from a live capture;
we don't mention its name. */
- displayname = "<capture>";
+ displayname = "(Untitled)";
}
return displayname;
}
epan_dissect_t *edt;
/* just add some value here until we know if it is being displayed or not */
- fdata->cul_bytes = cul_bytes + fdata->pkt_len;
+ fdata->cum_bytes = cum_bytes + fdata->pkt_len;
/* We don't yet have a color filter to apply. */
args.colorf = NULL;
even if they dont pass the display filter */
/* if this was a TIME REF frame we should reset the cul bytes field */
if(edt->pi.fd->flags.ref_time){
- cul_bytes = fdata->pkt_len;
- fdata->cul_bytes = cul_bytes;
+ cum_bytes = fdata->pkt_len;
+ fdata->cum_bytes = cum_bytes;
}
- /* increase cul_bytes with this packets length */
- cul_bytes += fdata->pkt_len;
+ /* increase cum_bytes with this packets length */
+ cum_bytes += fdata->pkt_len;
epan_dissect_fill_in_columns(edt);
row = packet_list_append(cf->cinfo.col_data, fdata);
- 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);
+ /* 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;
+ if (fdata->flags.marked) {
+ packet_list_set_colors(row, &prefs.gui_marked_fg, &prefs.gui_marked_bg);
+ }
}
/* Set the time of the previous displayed frame to the time of this
frame. */
prevsec = fdata->abs_secs;
prevusec = fdata->abs_usecs;
+
+ cf->displayed_count++;
} else {
/* This frame didn't pass the display filter, so it's not being added
to the clist, and thus has no row. */
}
}
-int
-filter_packets(capture_file *cf, gchar *dftext)
+gboolean
+filter_packets(capture_file *cf, gchar *dftext, gboolean force)
{
dfilter_t *dfcode;
+ char *filter_new = dftext ? dftext : "";
+ 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) {
+ return TRUE;
+ }
if (dftext == NULL) {
/* The new filter is an empty filter (i.e., display all packets). */
dftext = g_strdup(dftext);
if (!dfilter_compile(dftext, &dfcode)) {
/* The attempt failed; report an error. */
- simple_dialog(ESD_TYPE_CRIT, NULL, dfilter_error_msg);
- return 0;
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "%s%s%s\n"
+ "\n"
+ "The display filter \"%s\" is not a valid display filter.\n"
+ "See the help for a description of the display filter syntax.",
+ simple_dialog_primary_start(), dfilter_error_msg,
+ simple_dialog_primary_end(), dftext);
+ g_free(dftext);
+ return FALSE;
}
/* Was it empty? */
} else {
rescan_packets(cf, "Filtering", dftext, TRUE, FALSE);
}
- return 1;
+ return TRUE;
}
void
colorize_packets(capture_file *cf)
{
- rescan_packets(cf, "Colorizing", "all frames", FALSE, FALSE);
+ rescan_packets(cf, "Colorizing", "all packets", FALSE, FALSE);
}
void
reftime_packets(capture_file *cf)
{
- rescan_packets(cf, "Updating Reftime", "all frames", FALSE, FALSE);
+ rescan_packets(cf, "Updating Reftime", "all packets", FALSE, FALSE);
}
void
redissect_packets(capture_file *cf)
{
- rescan_packets(cf, "Reprocessing", "all frames", TRUE, TRUE);
+ rescan_packets(cf, "Reprocessing", "all packets", TRUE, TRUE);
}
/* Rescan the list of packets, reconstructing the CList.
gboolean stop_flag;
int count;
int err;
+ gchar *err_info;
frame_data *selected_frame, *preceding_frame, *following_frame, *prev_frame;
int selected_row, prev_row, preceding_row, following_row;
gboolean selected_frame_seen;
float prog_val;
GTimeVal start_time;
gchar status_str[100];
+ int progbar_nextstep;
+ int progbar_quantum;
- cul_bytes=0;
+ cum_bytes=0;
reset_tap_listeners();
/* Which frame, if any, is the currently selected frame?
XXX - should the selected frame or the focus frame be the "current"
cf->first_displayed = NULL;
cf->last_displayed = NULL;
+ /* We currently don't display any packets */
+ cf->displayed_count = 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. */
prevusec = 0;
/* Update the progress bar when it gets to this value. */
- cf->progbar_nextstep = 0;
+ progbar_nextstep = 0;
/* When we reach the value that triggers a progress bar update,
bump that value by this amount. */
- cf->progbar_quantum = cf->count/N_PROGBAR_UPDATES;
+ progbar_quantum = cf->count/N_PROGBAR_UPDATES;
/* Count of packets at which we've looked. */
count = 0;
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 (count >= cf->progbar_nextstep) {
+ if (count >= progbar_nextstep) {
/* let's not divide by zero. I should never be started
* with count == 0, so let's assert that
*/
if (progbar == NULL)
/* Create the progress bar if necessary */
- progbar = delayed_create_progress_dlg(action, action_item, "Stop", &stop_flag,
+ progbar = delayed_create_progress_dlg(action, action_item, &stop_flag,
&start_time, prog_val);
if (progbar != NULL) {
update_progress_dlg(progbar, prog_val, status_str);
}
- cf->progbar_nextstep += cf->progbar_quantum;
+ progbar_nextstep += progbar_quantum;
}
if (stop_flag) {
}
if (!wtap_seek_read (cf->wth, fdata->file_off, &cf->pseudo_header,
- cf->pd, fdata->cap_len, &err)) {
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_read_error_message(err), cf->filename);
+ cf->pd, fdata->cap_len, &err, &err_info)) {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ cf_read_error_message(err, err_info), cf->filename);
break;
}
}
}
+typedef enum {
+ PSP_FINISHED,
+ PSP_STOPPED,
+ PSP_FAILED
+} psp_return_t;
+
+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 *,
+ union wtap_pseudo_header *, const guint8 *, void *),
+ void *callback_args)
+{
+ frame_data *fdata;
+ int err;
+ gchar *err_info;
+ union wtap_pseudo_header pseudo_header;
+ guint8 pd[WTAP_MAX_PACKET_SIZE+1];
+ psp_return_t ret = PSP_FINISHED;
+
+ progdlg_t *progbar = NULL;
+ int progbar_count;
+ float progbar_val;
+ gboolean progbar_stop_flag;
+ GTimeVal progbar_start_time;
+ gchar progbar_status_str[100];
+ int progbar_nextstep;
+ int progbar_quantum;
+ range_process_e process_this;
+
+ /* 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->count/N_PROGBAR_UPDATES;
+ /* Count of packets at which we've looked. */
+ progbar_count = 0;
+
+ progbar_stop_flag = FALSE;
+ g_get_current_time(&progbar_start_time);
+
+ packet_range_process_init(range);
+
+ /* Iterate through the list of packets, printing the packets that
+ were selected by the current display filter. */
+ for (fdata = cf->plist; fdata != NULL; fdata = fdata->next) {
+ /* 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 (progbar_count >= progbar_nextstep) {
+ /* let's not divide by zero. I should never be started
+ * with count == 0, so let's assert that
+ */
+ g_assert(cf->count > 0);
+ progbar_val = (gfloat) progbar_count / cf->count;
+
+ if (progbar == NULL)
+ /* Create the progress bar if necessary */
+ progbar = delayed_create_progress_dlg(string1, string2,
+ &progbar_stop_flag,
+ &progbar_start_time,
+ progbar_val);
+
+ if (progbar != NULL) {
+ g_snprintf(progbar_status_str, sizeof(progbar_status_str),
+ "%4u of %u packets", progbar_count, cf->count);
+ update_progress_dlg(progbar, progbar_val, progbar_status_str);
+ }
+
+ progbar_nextstep += progbar_quantum;
+ }
+
+ if (progbar_stop_flag) {
+ /* Well, the user decided to abort the operation. Just stop,
+ and arrange to return TRUE to our caller, so they know it
+ was stopped explicitly. */
+ ret = PSP_STOPPED;
+ break;
+ }
+
+ progbar_count++;
+
+ /* do we have to process this packet? */
+ process_this = packet_range_process_packet(range, fdata);
+ if (process_this == range_process_next) {
+ /* this packet uninteresting, continue with next one */
+ continue;
+ } else if (process_this == range_processing_finished) {
+ /* all interesting packets processed, stop the loop */
+ break;
+ }
+
+ /* Get the packet */
+ if (!wtap_seek_read(cf->wth, fdata->file_off, &pseudo_header,
+ pd, fdata->cap_len, &err, &err_info)) {
+ /* Attempt to get the packet failed. */
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ cf_read_error_message(err, err_info), cf->filename);
+ ret = PSP_FAILED;
+ break;
+ }
+ if (!callback(cf, fdata, &pseudo_header, pd, callback_args)) {
+ /* Callback failed. We assume it reported the error appropriately. */
+ ret = PSP_FAILED;
+ break;
+ }
+ }
+
+ /* We're done printing the packets; destroy the progress bar if
+ it was created. */
+ if (progbar != NULL)
+ destroy_progress_dlg(progbar);
+
+ return ret;
+}
+
+static gboolean
+retap_packet(capture_file *cf _U_, frame_data *fdata,
+ union wtap_pseudo_header *pseudo_header, const guint8 *pd,
+ void *argsp _U_)
+{
+ epan_dissect_t *edt;
+
+ /* If we have tap listeners, allocate a protocol tree root node, so that
+ we'll construct a protocol tree against which a filter expression can
+ be evaluated. */
+ edt = epan_dissect_new(num_tap_filters != 0, FALSE);
+ tap_queue_init(edt);
+ epan_dissect_run(edt, pseudo_header, pd, fdata, NULL);
+ tap_push_tapped_queue(edt);
+ epan_dissect_free(edt);
+
+ return TRUE;
+}
+
int
+retap_packets(capture_file *cf)
+{
+ packet_range_t range;
+
+ /* Reset the tap listeners. */
+ reset_tap_listeners();
+
+ /* Iterate through the list of packets, dissecting all packets and
+ re-running the taps. */
+ packet_range_init(&range);
+ packet_range_process_init(&range);
+ switch (process_specified_packets(cf, &range, "Refiltering statistics on",
+ "all packets", retap_packet,
+ NULL)) {
+ case PSP_FINISHED:
+ /* Completed successfully. */
+ break;
+
+ case PSP_STOPPED:
+ /* Well, the user decided to abort the refiltering.
+ Return FALSE so our caller knows they did that. */
+ return FALSE;
+
+ case PSP_FAILED:
+ /* Error while retapping. */
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+typedef struct {
+ print_args_t *print_args;
+ FILE *print_fh;
+ gboolean print_separator;
+ char *line_buf;
+ int line_buf_len;
+ gint *col_widths;
+} print_callback_args_t;
+
+static gboolean
+print_packet(capture_file *cf, frame_data *fdata,
+ union wtap_pseudo_header *pseudo_header, const guint8 *pd,
+ void *argsp)
+{
+ print_callback_args_t *args = argsp;
+ epan_dissect_t *edt;
+ int i;
+ char *cp;
+ int line_len;
+ int column_len;
+ int cp_off;
+
+ if (args->print_args->print_summary) {
+ /* Fill in the column information, but don't bother creating
+ the logical protocol tree. */
+ edt = epan_dissect_new(FALSE, FALSE);
+ epan_dissect_run(edt, pseudo_header, pd, fdata, &cf->cinfo);
+ epan_dissect_fill_in_columns(edt);
+ cp = &args->line_buf[0];
+ line_len = 0;
+ for (i = 0; i < cf->cinfo.num_cols; i++) {
+ /* Find the length of the string for this column. */
+ column_len = strlen(cf->cinfo.col_data[i]);
+ if (args->col_widths[i] > column_len)
+ column_len = args->col_widths[i];
+
+ /* Make sure there's room in the line buffer for the column; if not,
+ double its length. */
+ line_len += column_len + 1; /* "+1" for space */
+ if (line_len > args->line_buf_len) {
+ cp_off = cp - args->line_buf;
+ args->line_buf_len = 2 * line_len;
+ args->line_buf = g_realloc(args->line_buf, args->line_buf_len + 1);
+ cp = args->line_buf + cp_off;
+ }
+
+ /* Right-justify the packet number column. */
+ if (cf->cinfo.col_fmt[i] == COL_NUMBER)
+ sprintf(cp, "%*s", args->col_widths[i], cf->cinfo.col_data[i]);
+ else
+ sprintf(cp, "%-*s", args->col_widths[i], cf->cinfo.col_data[i]);
+ cp += column_len;
+ if (i != cf->cinfo.num_cols - 1)
+ *cp++ = ' ';
+ }
+ *cp = '\0';
+ print_line(args->print_fh, 0, args->print_args->format, args->line_buf);
+ } else {
+ if (args->print_separator)
+ print_line(args->print_fh, 0, args->print_args->format, "");
+
+ /* Create the logical protocol tree, complete with the display
+ representation of the items; we don't need the columns here,
+ however. */
+ edt = epan_dissect_new(TRUE, TRUE);
+ epan_dissect_run(edt, pseudo_header, pd, fdata, NULL);
+
+ /* Print the information in that tree. */
+ proto_tree_print(args->print_args, edt, args->print_fh);
+
+ if (args->print_args->print_hex) {
+ /* Print the full packet data as hex. */
+ print_hex_data(args->print_fh, args->print_args->format, edt);
+ }
+
+ /* Print a blank line if we print anything after this. */
+ args->print_separator = TRUE;
+ } /* if (print_summary) */
+ epan_dissect_free(edt);
+
+ return !ferror(args->print_fh);
+}
+
+pp_return_t
print_packets(capture_file *cf, print_args_t *print_args)
{
int i;
- frame_data *fdata;
- progdlg_t *progbar = NULL;
- gboolean stop_flag;
- int count;
- int err;
- gint *col_widths = NULL;
+ print_callback_args_t callback_args;
gint data_width;
- gboolean print_separator;
- char *line_buf = NULL;
- int line_buf_len = 256;
char *cp;
int cp_off;
int column_len;
int line_len;
- epan_dissect_t *edt = NULL;
- float prog_val;
- GTimeVal start_time;
- gchar status_str[100];
+ psp_return_t ret;
- cf->print_fh = open_print_dest(print_args->to_file, print_args->dest);
- if (cf->print_fh == NULL)
- return FALSE; /* attempt to open destination failed */
+ callback_args.print_fh = open_print_dest(print_args->to_file,
+ print_args->dest);
+ if (callback_args.print_fh == NULL)
+ return PP_OPEN_ERROR; /* attempt to open destination failed */
- print_preamble(cf->print_fh, print_args->format);
+ print_preamble(callback_args.print_fh, print_args->format);
+ if (ferror(callback_args.print_fh)) {
+ close_print_dest(print_args->to_file, callback_args.print_fh);
+ return PP_WRITE_ERROR;
+ }
+ callback_args.print_args = print_args;
+ callback_args.print_separator = FALSE;
+ callback_args.line_buf = NULL;
+ callback_args.line_buf_len = 256;
+ callback_args.col_widths = NULL;
if (print_args->print_summary) {
/* We're printing packet summaries. Allocate the line buffer at
its initial length. */
- line_buf = g_malloc(line_buf_len + 1);
+ callback_args.line_buf = g_malloc(callback_args.line_buf_len + 1);
/* Find the widths for each of the columns - maximum of the
width of the title and the width of the data - and print
the column titles. */
- col_widths = (gint *) g_malloc(sizeof(gint) * cf->cinfo.num_cols);
- cp = &line_buf[0];
+ callback_args.col_widths = (gint *) g_malloc(sizeof(gint) * cf->cinfo.num_cols);
+ cp = &callback_args.line_buf[0];
line_len = 0;
for (i = 0; i < cf->cinfo.num_cols; i++) {
/* Don't pad the last column. */
if (i == cf->cinfo.num_cols - 1)
- col_widths[i] = 0;
+ callback_args.col_widths[i] = 0;
else {
- col_widths[i] = strlen(cf->cinfo.col_title[i]);
+ callback_args.col_widths[i] = strlen(cf->cinfo.col_title[i]);
data_width = get_column_char_width(get_column_format(i));
- if (data_width > col_widths[i])
- col_widths[i] = data_width;
+ if (data_width > callback_args.col_widths[i])
+ callback_args.col_widths[i] = data_width;
}
/* Find the length of the string for this column. */
column_len = strlen(cf->cinfo.col_title[i]);
- if (col_widths[i] > column_len)
- column_len = col_widths[i];
+ if (callback_args.col_widths[i] > column_len)
+ column_len = callback_args.col_widths[i];
/* Make sure there's room in the line buffer for the column; if not,
double its length. */
line_len += column_len + 1; /* "+1" for space */
- if (line_len > line_buf_len) {
- cp_off = cp - line_buf;
- line_buf_len = 2 * line_len;
- line_buf = g_realloc(line_buf, line_buf_len + 1);
- cp = line_buf + cp_off;
+ if (line_len > callback_args.line_buf_len) {
+ cp_off = cp - callback_args.line_buf;
+ callback_args.line_buf_len = 2 * line_len;
+ callback_args.line_buf = g_realloc(callback_args.line_buf,
+ callback_args.line_buf_len + 1);
+ cp = callback_args.line_buf + cp_off;
}
/* Right-justify the packet number column. */
if (cf->cinfo.col_fmt[i] == COL_NUMBER)
- sprintf(cp, "%*s", col_widths[i], cf->cinfo.col_title[i]);
+ sprintf(cp, "%*s", callback_args.col_widths[i], cf->cinfo.col_title[i]);
else
- sprintf(cp, "%-*s", col_widths[i], cf->cinfo.col_title[i]);
+ sprintf(cp, "%-*s", callback_args.col_widths[i], cf->cinfo.col_title[i]);
cp += column_len;
if (i != cf->cinfo.num_cols - 1)
*cp++ = ' ';
}
*cp = '\0';
- print_line(cf->print_fh, 0, print_args->format, line_buf);
- }
+ print_line(callback_args.print_fh, 0, print_args->format,
+ callback_args.line_buf);
+ } /* if (print_summary) */
- print_separator = FALSE;
+ /* Iterate through the list of packets, printing the packets we were
+ told to print. */
+ ret = process_specified_packets(cf, &print_args->range, "Printing",
+ "selected packets", print_packet,
+ &callback_args);
- /* Update the progress bar when it gets to this value. */
- cf->progbar_nextstep = 0;
- /* When we reach the value that triggers a progress bar update,
- bump that value by this amount. */
- cf->progbar_quantum = cf->count/N_PROGBAR_UPDATES;
- /* Count of packets at which we've looked. */
- count = 0;
-
- stop_flag = FALSE;
- g_get_current_time(&start_time);
-
- /* Iterate through the list of packets, printing the packets that
- were selected by the current display filter. */
- for (fdata = cf->plist; fdata != NULL; fdata = fdata->next) {
- /* 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 (count >= cf->progbar_nextstep) {
- /* let's not divide by zero. I should never be started
- * with count == 0, so let's assert that
- */
- g_assert(cf->count > 0);
- prog_val = (gfloat) count / cf->count;
-
- if (progbar == NULL)
- /* Create the progress bar if necessary */
- progbar = delayed_create_progress_dlg("Printing", "selected frames", "Stop", &stop_flag,
- &start_time, prog_val);
-
- if (progbar != NULL) {
- g_snprintf(status_str, sizeof(status_str),
- "%4u of %u frames", count, cf->count);
- update_progress_dlg(progbar, prog_val, status_str);
- }
-
- cf->progbar_nextstep += cf->progbar_quantum;
- }
-
- if (stop_flag) {
- /* Well, the user decided to abort the printing. Just stop.
+ if (callback_args.col_widths != NULL)
+ g_free(callback_args.col_widths);
+ if (callback_args.line_buf != NULL)
+ g_free(callback_args.line_buf);
- XXX - note that what got generated before they did that
- will get printed, as we're piping to a print program; we'd
- have to write to a file and then hand that to the print
- program to make it actually not print anything. */
- break;
- }
+ switch (ret) {
- count++;
- /* Check to see if we are suppressing unmarked packets, if so,
- * suppress them and then proceed to check for visibility.
- */
- if (((print_args->print_only_marked && fdata->flags.marked ) ||
- !(print_args->print_only_marked)) && fdata->flags.passed_dfilter) {
- if (!wtap_seek_read (cf->wth, fdata->file_off, &cf->pseudo_header,
- cf->pd, fdata->cap_len, &err)) {
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_read_error_message(err), cf->filename);
- break;
- }
- if (print_args->print_summary) {
- /* Fill in the column information, but don't bother creating
- the logical protocol tree. */
- edt = epan_dissect_new(FALSE, FALSE);
- epan_dissect_run(edt, &cf->pseudo_header, cf->pd, fdata, &cf->cinfo);
- epan_dissect_fill_in_columns(edt);
- cp = &line_buf[0];
- line_len = 0;
- for (i = 0; i < cf->cinfo.num_cols; i++) {
- /* Find the length of the string for this column. */
- column_len = strlen(cf->cinfo.col_data[i]);
- if (col_widths[i] > column_len)
- column_len = col_widths[i];
-
- /* Make sure there's room in the line buffer for the column; if not,
- double its length. */
- line_len += column_len + 1; /* "+1" for space */
- if (line_len > line_buf_len) {
- cp_off = cp - line_buf;
- line_buf_len = 2 * line_len;
- line_buf = g_realloc(line_buf, line_buf_len + 1);
- cp = line_buf + cp_off;
- }
-
- /* Right-justify the packet number column. */
- if (cf->cinfo.col_fmt[i] == COL_NUMBER)
- sprintf(cp, "%*s", col_widths[i], cf->cinfo.col_data[i]);
- else
- sprintf(cp, "%-*s", col_widths[i], cf->cinfo.col_data[i]);
- cp += column_len;
- if (i != cf->cinfo.num_cols - 1)
- *cp++ = ' ';
- }
- *cp = '\0';
- print_line(cf->print_fh, 0, print_args->format, line_buf);
- } else {
- if (print_separator)
- print_line(cf->print_fh, 0, print_args->format, "");
+ case PSP_FINISHED:
+ /* Completed successfully. */
+ break;
- /* Create the logical protocol tree, complete with the display
- representation of the items; we don't need the columns here,
- however. */
- edt = epan_dissect_new(TRUE, TRUE);
- epan_dissect_run(edt, &cf->pseudo_header, cf->pd, fdata, NULL);
+ case PSP_STOPPED:
+ /* Well, the user decided to abort the printing.
- /* Print the information in that tree. */
- proto_tree_print(print_args, edt, cf->print_fh);
+ XXX - note that what got generated before they did that
+ will get printed if we're piping to a print program; we'd
+ have to write to a file and then hand that to the print
+ program to make it actually not print anything. */
+ break;
- if (print_args->print_hex) {
- /* Print the full packet data as hex. */
- print_hex_data(cf->print_fh, print_args->format, edt);
- }
+ case PSP_FAILED:
+ /* Error while printing.
- /* Print a blank line if we print anything after this. */
- print_separator = TRUE;
- }
- epan_dissect_free(edt);
- }
+ XXX - note that what got generated before they did that
+ will get printed if we're piping to a print program; we'd
+ have to write to a file and then hand that to the print
+ program to make it actually not print anything. */
+ close_print_dest(print_args->to_file, callback_args.print_fh);
+ return PP_WRITE_ERROR;
}
- /* We're done printing the packets; destroy the progress bar if
- it was created. */
- if (progbar != NULL)
- destroy_progress_dlg(progbar);
-
- if (col_widths != NULL)
- g_free(col_widths);
- if (line_buf != NULL)
- g_free(line_buf);
-
- print_finale(cf->print_fh, print_args->format);
-
- close_print_dest(print_args->to_file, cf->print_fh);
+ print_finale(callback_args.print_fh, print_args->format);
+ if (ferror(callback_args.print_fh)) {
+ close_print_dest(print_args->to_file, callback_args.print_fh);
+ return PP_WRITE_ERROR;
+ }
- cf->print_fh = NULL;
+ close_print_dest(print_args->to_file, callback_args.print_fh);
- return TRUE;
+ return PP_OK;
}
/* Scan through the packet list and change all columns that use the
float prog_val;
GTimeVal start_time;
gchar status_str[100];
+ int progbar_nextstep;
+ int progbar_quantum;
+ int first, last;
+ gboolean sorted_by_frame_column;
/* Are there any columns with time stamps in the "command-line-specified"
format?
to do. */
return;
}
+ first = cf->cinfo.col_first[COL_CLS_TIME];
+ g_assert(first >= 0);
+ last = cf->cinfo.col_last[COL_CLS_TIME];
/* Freeze the packet list while we redo it, so we don't get any
screen updates while it happens. */
- freeze_plist(cf);
+ packet_list_freeze();
/* Update the progress bar when it gets to this value. */
- cf->progbar_nextstep = 0;
+ progbar_nextstep = 0;
/* When we reach the value that triggers a progress bar update,
bump that value by this amount. */
- cf->progbar_quantum = cf->count/N_PROGBAR_UPDATES;
+ progbar_quantum = cf->count/N_PROGBAR_UPDATES;
/* Count of packets at which we've looked. */
count = 0;
+ /* If the rows are currently sorted by the frame column then we know
+ * the row number of each packet: it's the row number of the previously
+ * displayed packet + 1.
+ *
+ * Otherwise, if the display is sorted by a different column then we have
+ * to use the O(N) packet_list_find_row_from_data() (thus making the job
+ * of changing the time display format O(N**2)).
+ *
+ * (XXX - In fact it's still O(N**2) because gtk_clist_set_text() takes
+ * the row number and walks that many elements down the clist to find
+ * the appropriate element.)
+ */
+ sorted_by_frame_column = FALSE;
+ for (i = 0; i < cf->cinfo.num_cols; i++) {
+ if (cf->cinfo.col_fmt[i] == COL_NUMBER)
+ {
+ sorted_by_frame_column = (i == packet_list_get_sort_column());
+ break;
+ }
+ }
+
stop_flag = FALSE;
g_get_current_time(&start_time);
is in a row of the summary list and, if so, whether there are
any columns that show the time in the "command-line-specified"
format and, if so, update that row. */
- for (fdata = cf->plist; fdata != NULL; fdata = fdata->next) {
+ for (fdata = cf->plist, row = -1; fdata != NULL; fdata = fdata->next) {
/* 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 (count >= cf->progbar_nextstep) {
+ if (count >= progbar_nextstep) {
/* let's not divide by zero. I should never be started
* with count == 0, so let's assert that
*/
if (progbar == NULL)
/* Create the progress bar if necessary */
- progbar = delayed_create_progress_dlg("Changing", "time display", "Stop",
+ progbar = delayed_create_progress_dlg("Changing", "time display",
&stop_flag, &start_time, prog_val);
if (progbar != NULL) {
g_snprintf(status_str, sizeof(status_str),
- "%4u of %u frames", count, cf->count);
+ "%4u of %u packets", count, cf->count);
update_progress_dlg(progbar, prog_val, status_str);
}
- cf->progbar_nextstep += cf->progbar_quantum;
+ progbar_nextstep += progbar_quantum;
}
if (stop_flag) {
count++;
/* Find what row this packet is in. */
- row = packet_list_find_row_from_data(fdata);
+ if (!sorted_by_frame_column) {
+ /* This function is O(N), so we try to avoid using it... */
+ row = packet_list_find_row_from_data(fdata);
+ } else {
+ /* ...which we do by maintaining a count of packets that are
+ being displayed (i.e., that have passed the display filter),
+ and using the current value of that count as the row number
+ (which is why we can only do it when the display is sorted
+ by the frame number). */
+ if (fdata->flags.passed_dfilter)
+ row++;
+ else
+ continue;
+ }
if (row != -1) {
/* This packet is in the summary list, on row "row". */
- for (i = 0; i < cf->cinfo.num_cols; i++) {
+ for (i = first; i <= last; i++) {
if (cf->cinfo.fmt_matx[i][COL_CLS_TIME]) {
/* This is one of the columns that shows the time in
"command-line-specified" format; update it. */
/* Set the column widths of those columns that show the time in
"command-line-specified" format. */
- for (i = 0; i < cf->cinfo.num_cols; i++) {
+ for (i = first; i <= last; i++) {
if (cf->cinfo.fmt_matx[i][COL_CLS_TIME]) {
packet_list_set_cls_time_width(i);
}
}
/* Unfreeze the packet list. */
- thaw_plist(cf);
+ packet_list_thaw();
}
typedef struct {
/* Iterate through all the nodes, seeing if they have text that matches. */
mdata->cf = cf;
mdata->frame_matched = FALSE;
- g_node_children_foreach((GNode*) edt->tree, G_TRAVERSE_ALL,
- match_subtree_text, mdata);
+ proto_tree_children_foreach(edt->tree, match_subtree_text, mdata);
epan_dissect_free(edt);
return mdata->frame_matched;
}
static void
-match_subtree_text(GNode *node, gpointer data)
+match_subtree_text(proto_node *node, gpointer data)
{
match_data *mdata = (match_data*) data;
const gchar *string = mdata->string;
return;
/* was a free format label produced? */
- if (fi->representation) {
- label_ptr = fi->representation;
+ if (fi->rep) {
+ label_ptr = fi->rep->representation;
} else {
/* no, make a generic label */
label_ptr = label_str;
}
/* Recurse into the subtree, if it exists */
- if (g_node_n_children(node) > 0)
- g_node_children_foreach(node, G_TRAVERSE_ALL, match_subtree_text, mdata);
+ if (node->first_child != NULL)
+ proto_tree_children_foreach(node, match_subtree_text, mdata);
}
gboolean
gboolean stop_flag;
int count;
int err;
+ gchar *err_info;
int row;
float prog_val;
GTimeVal start_time;
gchar status_str[100];
+ int progbar_nextstep;
+ int progbar_quantum;
start_fd = cf->current_frame;
if (start_fd != NULL) {
count = 0;
fdata = start_fd;
- cf->progbar_nextstep = 0;
+ progbar_nextstep = 0;
/* When we reach the value that triggers a progress bar update,
bump that value by this amount. */
- cf->progbar_quantum = cf->count/N_PROGBAR_UPDATES;
+ progbar_quantum = cf->count/N_PROGBAR_UPDATES;
stop_flag = FALSE;
g_get_current_time(&start_time);
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 (count >= cf->progbar_nextstep) {
+ if (count >= progbar_nextstep) {
/* let's not divide by zero. I should never be started
* with count == 0, so let's assert that
*/
/* Create the progress bar if necessary */
if (progbar == NULL)
- progbar = delayed_create_progress_dlg("Searching", cf->sfilter, "Cancel",
+ progbar = delayed_create_progress_dlg("Searching", cf->sfilter,
&stop_flag, &start_time, prog_val);
if (progbar != NULL) {
g_snprintf(status_str, sizeof(status_str),
- "%4u of %u frames", count, cf->count);
+ "%4u of %u packets", count, cf->count);
update_progress_dlg(progbar, prog_val, status_str);
}
- cf->progbar_nextstep += cf->progbar_quantum;
+ progbar_nextstep += progbar_quantum;
}
if (stop_flag) {
if (cf->sbackward) {
/* Go on to the previous frame. */
fdata = fdata->prev;
- if (fdata == NULL)
+ if (fdata == NULL) {
+ /*
+ * XXX - other apps have a bit more of a detailed message
+ * for this, and instead of offering "OK" and "Cancel",
+ * they offer things such as "Continue" and "Cancel";
+ * we need an API for popping up alert boxes with
+ * {Verb} and "Cancel".
+ */
+ simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
+ "%sBeginning of capture exceeded!%s\n\n"
+ "Search is continued from the end of the capture.",
+ simple_dialog_primary_start(), simple_dialog_primary_end());
fdata = cf->plist_end; /* wrap around */
+ }
} else {
/* Go on to the next frame. */
fdata = fdata->next;
- if (fdata == NULL)
+ if (fdata == NULL) {
+ simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
+ "%sEnd of capture exceeded!%s\n\n"
+ "Search is continued from the start of the capture.",
+ simple_dialog_primary_start(), simple_dialog_primary_end());
fdata = cf->plist; /* wrap around */
+ }
}
count++;
if (fdata->flags.passed_dfilter) {
/* Yes. Load its data. */
if (!wtap_seek_read(cf->wth, fdata->file_off, &cf->pseudo_header,
- cf->pd, fdata->cap_len, &err)) {
+ cf->pd, fdata->cap_len, &err, &err_info)) {
/* Read error. Report the error, and go back to the frame
where we started. */
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_read_error_message(err), cf->filename);
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ cf_read_error_message(err, err_info), cf->filename);
new_fd = start_fd;
break;
}
;
if (fdata == NULL) {
- /* we didn't find a frame with that frame number */
- simple_dialog(ESD_TYPE_CRIT, NULL,
- "There is no frame with that frame number.");
- return FALSE; /* we failed to go to that frame */
+ /* 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.");
+ return FALSE; /* we failed to go to that packet */
}
if (!fdata->flags.passed_dfilter) {
- /* that frame currently isn't displayed */
- /* XXX - add it to the set of displayed frames? */
- simple_dialog(ESD_TYPE_CRIT, NULL,
- "That frame is not currently being displayed.");
- return FALSE; /* we failed to go to that frame */
+ /* 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 is not currently being displayed.");
+ return FALSE; /* we failed to go to that packet */
}
- /* We found that frame, and it's currently being displayed.
+ /* We found that packet, and it's currently being displayed.
Find what row it's in. */
row = packet_list_find_row_from_data(fdata);
g_assert(row != -1);
/* Select that row, make it the focus row, and make it visible. */
packet_list_set_selected_row(row);
- return TRUE; /* we got to that frame */
+ return TRUE; /* we got to that packet */
+}
+
+gboolean
+goto_top_frame(capture_file *cf)
+{
+ frame_data *fdata;
+ int row;
+ frame_data *lowest_fdata = NULL;
+
+ for (fdata = cf->plist; fdata != NULL; fdata = fdata->next) {
+ if (fdata->flags.passed_dfilter) {
+ lowest_fdata = fdata;
+ break;
+ }
+ }
+
+ if (lowest_fdata == NULL) {
+ return FALSE;
+ }
+
+ /* We found that packet, and it's currently being displayed.
+ Find what row it's in. */
+ row = packet_list_find_row_from_data(lowest_fdata);
+ g_assert(row != -1);
+
+ /* Select that row, make it the focus row, and make it visible. */
+ packet_list_set_selected_row(row);
+ return TRUE; /* we got to that packet */
+}
+
+gboolean
+goto_bottom_frame(capture_file *cf)
+{
+ frame_data *fdata;
+ int row;
+ frame_data *highest_fdata = NULL;
+
+ for (fdata = cf->plist; fdata != NULL; fdata = fdata->next) {
+ if (fdata->flags.passed_dfilter) {
+ highest_fdata = fdata;
+ }
+ }
+
+ if (highest_fdata == NULL) {
+ return FALSE;
+ }
+
+ /* We found that packet, and it's currently being displayed.
+ Find what row it's in. */
+ row = packet_list_find_row_from_data(highest_fdata);
+ g_assert(row != -1);
+
+ /* Select that row, make it the focus row, and make it visible. */
+ packet_list_set_selected_row(row);
+ return TRUE; /* we got to that packet */
}
/* Select the packet on a given row. */
{
frame_data *fdata;
int err;
+ gchar *err_info;
/* Get the frame data struct pointer for this frame */
fdata = (frame_data *)packet_list_get_row_data(row);
/* Get the data in that frame. */
if (!wtap_seek_read (cf->wth, fdata->file_off, &cf->pseudo_header,
- cf->pd, fdata->cap_len, &err)) {
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_read_error_message(err), cf->filename);
+ cf->pd, fdata->cap_len, &err, &err_info)) {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ cf_read_error_message(err, err_info), cf->filename);
return;
}
cf->marked_count--;
}
-static void
-freeze_plist(capture_file *cf)
-{
- int i;
-
- /* Make the column sizes static, so they don't adjust while
- we're reading the capture file (freezing the clist doesn't
- seem to suffice). */
- for (i = 0; i < cf->cinfo.num_cols; i++)
- packet_list_set_column_auto_resize(i, FALSE);
- packet_list_freeze();
-}
-
-static void
-thaw_plist(capture_file *cf)
-{
- int i;
-
- for (i = 0; i < cf->cinfo.num_cols; i++) {
- if (get_column_resize_type(cf->cinfo.col_fmt[i]) == RESIZE_MANUAL) {
- /* Set this column's width to the appropriate value. */
- packet_list_set_column_width(i, cf->cinfo.col_width[i]);
- } else {
- /* Make this column's size dynamic, so that it adjusts to the
- appropriate size. */
- packet_list_set_column_auto_resize(i, TRUE);
- }
- }
- packet_list_thaw();
-
- /* Hopefully, the columns have now gotten their appropriate sizes;
- make them resizeable - a column that auto-resizes cannot be
- resized by the user, and *vice versa*. */
- for (i = 0; i < cf->cinfo.num_cols; i++)
- packet_list_set_column_resizeable(i, TRUE);
-}
+typedef struct {
+ wtap_dumper *pdh;
+ const char *fname;
+} save_callback_args_t;
/*
* Save a capture to a file, in a particular format, saving either
* Returns TRUE if it succeeds, FALSE otherwise; if it fails, it pops
* up a message box for the failure.
*/
+static gboolean
+save_packet(capture_file *cf _U_, frame_data *fdata,
+ union wtap_pseudo_header *pseudo_header, const guint8 *pd,
+ void *argsp)
+{
+ save_callback_args_t *args = argsp;
+ struct wtap_pkthdr hdr;
+ int err;
+
+ /* init the wtap header for saving */
+ hdr.ts.tv_sec = fdata->abs_secs;
+ hdr.ts.tv_usec = fdata->abs_usecs;
+ hdr.caplen = fdata->cap_len;
+ hdr.len = fdata->pkt_len;
+ hdr.pkt_encap = fdata->lnk_t;
+
+ /* and save the packet */
+ if (!wtap_dump(args->pdh, &hdr, pseudo_header, pd, &err)) {
+ cf_write_failure_alert_box(args->fname, err);
+ return FALSE;
+ }
+ return TRUE;
+}
+
gboolean
-cf_save(char *fname, capture_file *cf, gboolean save_filtered,
- gboolean save_marked, guint save_format)
+cf_save(char *fname, capture_file *cf, packet_range_t *range, guint save_format)
{
gchar *from_filename;
gchar *name_ptr, *save_msg, *save_fmt = " Saving: %s...";
int err;
gboolean do_copy;
wtap_dumper *pdh;
- frame_data *fdata;
- struct wtap_pkthdr hdr;
- union wtap_pseudo_header pseudo_header;
- guint8 pd[65536];
struct stat infile, outfile;
+ save_callback_args_t callback_args;
name_ptr = get_basename(fname);
msg_len = strlen(name_ptr) + strlen(save_fmt) + 2;
* 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) {
- simple_dialog(ESD_TYPE_CRIT, NULL,
- "Can't save over current capture file: %s!",
- cf->filename);
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "%sCapture file: \"%s\" already exists!%s\n\n"
+ "Please choose a different filename.",
+ simple_dialog_primary_start(), fname, simple_dialog_primary_end());
goto fail;
}
- if (!save_filtered && !save_marked && save_format == cf->cd_t) {
+ packet_range_process_init(range);
+
+ /* Used to be :
+ * if (!save_filtered && !save_marked && !save_manual_range &&
+ * !save_marked_range && !save_curr && save_format == cf->cd_t) {
+ */
+
+ if (packet_range_process_all(range) && save_format == cf->cd_t) {
/* We're not filtering packets, and we're saving it in the format
it's already in, so we can just move or copy the raw data. */
be if we didn't have permission to remove the file from
the temporary directory, and that might be fixable - but
is it worth requiring the user to go off and fix it?) */
- simple_dialog(ESD_TYPE_CRIT, NULL,
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
file_rename_error_message(errno), fname);
goto fail;
}
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);
if (pdh == NULL) {
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_open_error_message(err, TRUE, save_format), fname);
+ cf_open_failure_alert_box(fname, err, NULL, TRUE, save_format);
goto fail;
}
- /* XXX - have a way to save only the packets currently selected by
- the display filter or the marked ones.
+ /* XXX - we let the user save a subset of the packets.
If we do that, should we make that file the current file? If so,
it means we can no longer get at the other packets. What does
NetMon do? */
- for (fdata = cf->plist; fdata != NULL; fdata = fdata->next) {
- /* XXX - do a progress bar */
- if ((!save_filtered && !save_marked) ||
- (save_filtered && fdata->flags.passed_dfilter && !save_marked) ||
- (save_marked && fdata->flags.marked && !save_filtered) ||
- (save_filtered && save_marked && fdata->flags.passed_dfilter &&
- fdata->flags.marked)) {
- /* Either :
- - we're saving all frames, or
- - we're saving filtered frames and this one passed the display filter or
- - we're saving marked frames (and it has been marked) or
- - we're saving filtered _and_ marked frames,
- save it. */
- hdr.ts.tv_sec = fdata->abs_secs;
- hdr.ts.tv_usec = fdata->abs_usecs;
- hdr.caplen = fdata->cap_len;
- hdr.len = fdata->pkt_len;
- hdr.pkt_encap = fdata->lnk_t;
- if (!wtap_seek_read(cf->wth, fdata->file_off, &pseudo_header,
- pd, fdata->cap_len, &err)) {
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_read_error_message(err), cf->filename);
- wtap_dump_close(pdh, &err);
- goto fail;
- }
- if (!wtap_dump(pdh, &hdr, &pseudo_header, pd, &err)) {
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_write_error_message(err), fname);
- wtap_dump_close(pdh, &err);
- goto fail;
- }
- }
+ /* Iterate through the list of packets, processing the packets we were
+ told to process.
+
+ XXX - we've already called "packet_range_process_init(range)", but
+ "process_specified_packets()" will do it again. Fortunately,
+ that's harmless in this case, as we haven't done anything to
+ "range" since we initialized it. */
+ callback_args.pdh = pdh;
+ callback_args.fname = fname;
+ switch (process_specified_packets(cf, range, "Saving",
+ "selected packets", save_packet,
+ &callback_args)) {
+
+ case PSP_FINISHED:
+ /* Completed successfully. */
+ break;
+
+ case PSP_STOPPED:
+ /* The user decided to abort the saving.
+ XXX - remove the output file? */
+ break;
+
+ case PSP_FAILED:
+ /* Error while saving. */
+ wtap_dump_close(pdh, &err);
+ goto fail;
}
if (!wtap_dump_close(pdh, &err)) {
- simple_dialog(ESD_TYPE_WARN, NULL,
- file_close_error_message(err), fname);
+ cf_close_failure_alert_box(fname, err);
goto fail;
}
}
/* Pop the "Saving:" message off the status bar. */
statusbar_pop_file_msg();
- if (!save_filtered && !save_marked) {
+
+ if (packet_range_process_all(range)) {
/* We saved the entire capture, not just some packets from it.
Open and read the file we saved it to.
if ((err = cf_open(fname, FALSE, cf)) == 0) {
/* XXX - report errors if this fails?
What should we return if it fails or is aborted? */
- switch (cf_read(cf, &err)) {
+ switch (cf_read(cf)) {
case READ_SUCCESS:
case READ_ERROR:
return FALSE;
}
-char *
-file_open_error_message(int err, gboolean for_writing, int file_type)
+static void
+cf_open_failure_alert_box(const char *filename, int err, gchar *err_info,
+ gboolean for_writing, int file_type)
{
- char *errmsg;
- static char errmsg_errno[1024+1];
-
- switch (err) {
-
- case WTAP_ERR_NOT_REGULAR_FILE:
- errmsg = "The file \"%s\" is a \"special file\" or socket or other non-regular file.";
- break;
-
- case WTAP_ERR_RANDOM_OPEN_PIPE:
- /* Seen only when opening a capture file for reading. */
- errmsg = "The file \"%s\" is a pipe or FIFO; Ethereal cannot read pipe or FIFO files.";
- break;
+ if (err < 0) {
+ /* Wiretap error. */
+ switch (err) {
+
+ case WTAP_ERR_NOT_REGULAR_FILE:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" is a \"special file\" or socket or other non-regular file.",
+ filename);
+ break;
- case WTAP_ERR_FILE_UNKNOWN_FORMAT:
- case WTAP_ERR_UNSUPPORTED:
- /* Seen only when opening a capture file for reading. */
- errmsg = "The file \"%s\" is not a capture file in a format Ethereal understands.";
- break;
+ case WTAP_ERR_RANDOM_OPEN_PIPE:
+ /* Seen only when opening a capture file for reading. */
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" is a pipe or FIFO; Ethereal cannot read pipe or FIFO files.",
+ filename);
+ break;
- case WTAP_ERR_CANT_WRITE_TO_PIPE:
- /* Seen only when opening a capture file for writing. */
- snprintf(errmsg_errno, sizeof(errmsg_errno),
- "The file \"%%s\" is a pipe, and %s capture files cannot be "
- "written to a pipe.", wtap_file_type_string(file_type));
- errmsg = errmsg_errno;
- break;
+ case WTAP_ERR_FILE_UNKNOWN_FORMAT:
+ /* Seen only when opening a capture file for reading. */
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" is not a capture file in a format Ethereal understands.",
+ filename);
+ break;
- case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
- /* Seen only when opening a capture file for writing. */
- errmsg = "Ethereal does not support writing capture files in that format.";
- break;
+ case WTAP_ERR_UNSUPPORTED:
+ /* Seen only when opening a capture file for reading. */
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" is not a capture file in a format Ethereal understands.\n"
+ "(%s)",
+ filename, err_info);
+ g_free(err_info);
+ break;
- case WTAP_ERR_UNSUPPORTED_ENCAP:
- case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
- if (for_writing)
- errmsg = "Ethereal cannot save this capture in that format.";
- else
- errmsg = "The file \"%s\" is a capture for a network type that Ethereal doesn't support.";
- break;
+ case WTAP_ERR_CANT_WRITE_TO_PIPE:
+ /* Seen only when opening a capture file for writing. */
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" is a pipe, and %s capture files cannot be "
+ "written to a pipe.",
+ filename, wtap_file_type_string(file_type));
+ break;
- case WTAP_ERR_BAD_RECORD:
- errmsg = "The file \"%s\" appears to be damaged or corrupt.";
- break;
+ case WTAP_ERR_UNSUPPORTED_FILE_TYPE:
+ /* Seen only when opening a capture file for writing. */
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "Ethereal does not support writing capture files in that format.");
+ break;
- case WTAP_ERR_CANT_OPEN:
- if (for_writing)
- errmsg = "The file \"%s\" could not be created for some unknown reason.";
- else
- errmsg = "The file \"%s\" could not be opened for some unknown reason.";
- break;
+ case WTAP_ERR_UNSUPPORTED_ENCAP:
+ if (for_writing) {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "Ethereal cannot save this capture in that format.");
+ } else {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" is a capture for a network type that Ethereal doesn't support.\n"
+ "(%s)",
+ filename, err_info);
+ g_free(err_info);
+ }
+ break;
- case WTAP_ERR_SHORT_READ:
- errmsg = "The file \"%s\" appears to have been cut short"
- " in the middle of a packet or other data.";
- break;
+ case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
+ if (for_writing) {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "Ethereal cannot save this capture in that format.");
+ } else {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" is a capture for a network type that Ethereal doesn't support.",
+ filename);
+ }
+ break;
- case WTAP_ERR_SHORT_WRITE:
- errmsg = "A full header couldn't be written to the file \"%s\".";
- break;
+ case WTAP_ERR_BAD_RECORD:
+ /* Seen only when opening a capture file for reading. */
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" appears to be damaged or corrupt.\n"
+ "(%s)",
+ filename, err_info);
+ g_free(err_info);
+ break;
- case ENOENT:
- if (for_writing)
- errmsg = "The path to the file \"%s\" does not exist.";
- else
- errmsg = "The file \"%s\" does not exist.";
- break;
+ case WTAP_ERR_CANT_OPEN:
+ if (for_writing) {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" could not be created for some unknown reason.",
+ filename);
+ } else {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" could not be opened for some unknown reason.",
+ filename);
+ }
+ break;
- case EACCES:
- if (for_writing)
- errmsg = "You do not have permission to create or write to the file \"%s\".";
- else
- errmsg = "You do not have permission to read the file \"%s\".";
- break;
+ case WTAP_ERR_SHORT_READ:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" appears to have been cut short"
+ " in the middle of a packet or other data.",
+ filename);
+ break;
- case EISDIR:
- errmsg = "\"%s\" is a directory (folder), not a file.";
- break;
+ case WTAP_ERR_SHORT_WRITE:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "A full header couldn't be written to the file \"%s\".",
+ filename);
+ break;
- default:
- snprintf(errmsg_errno, sizeof(errmsg_errno),
- "The file \"%%s\" could not be %s: %s.",
- for_writing ? "created" : "opened",
- wtap_strerror(err));
- errmsg = errmsg_errno;
- break;
+ default:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" could not be %s: %s.",
+ filename,
+ for_writing ? "created" : "opened",
+ wtap_strerror(err));
+ break;
+ }
+ } else {
+ /* OS error. */
+ open_failure_alert_box(filename, err, for_writing);
}
- return errmsg;
}
static char *
}
char *
-file_read_error_message(int err)
-{
- static char errmsg_errno[1024+1];
-
- snprintf(errmsg_errno, sizeof(errmsg_errno),
- "An error occurred while reading from the file \"%%s\": %s.",
- wtap_strerror(err));
- return errmsg_errno;
-}
-
-char *
-file_write_error_message(int err)
+cf_read_error_message(int err, gchar *err_info)
{
- char *errmsg;
static char errmsg_errno[1024+1];
switch (err) {
- case ENOSPC:
- errmsg = "The file \"%s\" could not be saved because there is no space left on the file system.";
+ case WTAP_ERR_UNSUPPORTED:
+ case WTAP_ERR_UNSUPPORTED_ENCAP:
+ case WTAP_ERR_BAD_RECORD:
+ snprintf(errmsg_errno, sizeof(errmsg_errno),
+ "An error occurred while reading from the file \"%%s\": %s.\n(%s)",
+ wtap_strerror(err), err_info);
break;
-#ifdef EDQUOT
- case EDQUOT:
- errmsg = "The file \"%s\" could not be saved because you are too close to, or over, your disk quota.";
- break;
-#endif
-
default:
snprintf(errmsg_errno, sizeof(errmsg_errno),
- "An error occurred while writing to the file \"%%s\": %s.",
- wtap_strerror(err));
- errmsg = errmsg_errno;
+ "An error occurred while reading from the file \"%%s\": %s.",
+ wtap_strerror(err));
break;
}
- return errmsg;
+ return errmsg_errno;
+}
+
+static void
+cf_write_failure_alert_box(const char *filename, int err)
+{
+ if (err < 0) {
+ /* Wiretap error. */
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "An error occurred while writing to the file \"%s\": %s.",
+ filename, wtap_strerror(err));
+ } else {
+ /* OS error. */
+ write_failure_alert_box(filename, err);
+ }
}
/* Check for write errors - if the file is being written to an NFS server,
a write error may not show up until the file is closed, as NFS clients
might not send writes to the server until the "write()" call finishes,
so that the write may fail on the server but the "write()" may succeed. */
-static char *
-file_close_error_message(int err)
+static void
+cf_close_failure_alert_box(const char *filename, int err)
{
- char *errmsg;
- static char errmsg_errno[1024+1];
-
- switch (err) {
-
- case WTAP_ERR_CANT_CLOSE:
- errmsg = "The file \"%s\" couldn't be closed for some unknown reason.";
- break;
-
- case WTAP_ERR_SHORT_WRITE:
- errmsg = "Not all the packets could be written to the file \"%s\".";
- break;
-
- case ENOSPC:
- errmsg = "The file \"%s\" could not be saved because there is no space left on the file system.";
- break;
+ if (err < 0) {
+ /* Wiretap error. */
+ switch (err) {
+
+ case WTAP_ERR_CANT_CLOSE:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "The file \"%s\" couldn't be closed for some unknown reason.",
+ filename);
+ break;
-#ifdef EDQUOT
- case EDQUOT:
- errmsg = "The file \"%s\" could not be saved because you are too close to, or over, your disk quota.";
- break;
-#endif
+ case WTAP_ERR_SHORT_WRITE:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "Not all the packets could be written to the file \"%s\".",
+ filename);
+ break;
- default:
- snprintf(errmsg_errno, sizeof(errmsg_errno),
- "An error occurred while closing the file \"%%s\": %s.",
- wtap_strerror(err));
- errmsg = errmsg_errno;
- break;
+ default:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "An error occurred while closing the file \"%s\": %s.",
+ filename, wtap_strerror(err));
+ break;
+ }
+ } else {
+ /* OS error.
+ We assume that a close error from the OS is really a write error. */
+ write_failure_alert_box(filename, err);
}
- return errmsg;
}
/* Copy the raw bytes of the file. */
from_fd = open(from_filename, O_RDONLY | O_BINARY);
if (from_fd < 0) {
- err = errno;
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_open_error_message(err, TRUE, 0), from_filename);
+ open_failure_alert_box(from_filename, errno, FALSE);
goto done;
}
to be open in binary mode. */
to_fd = open(to_filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0644);
if (to_fd < 0) {
- err = errno;
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_open_error_message(err, TRUE, 0), to_filename);
+ open_failure_alert_box(to_filename, errno, TRUE);
close(from_fd);
goto done;
}
err = errno;
else
err = WTAP_ERR_SHORT_WRITE;
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_write_error_message(err), to_filename);
+ write_failure_alert_box(to_filename, err);
close(from_fd);
close(to_fd);
goto done;
}
if (nread < 0) {
err = errno;
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_read_error_message(err), from_filename);
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "An error occurred while reading from the file \"%s\": %s.",
+ from_filename, strerror(err));
close(from_fd);
close(to_fd);
goto done;
}
close(from_fd);
if (close(to_fd) < 0) {
- err = errno;
- simple_dialog(ESD_TYPE_CRIT, NULL,
- file_close_error_message(err), to_filename);
+ write_failure_alert_box(to_filename, errno);
goto done;
}
git.samba.org / metze / wireshark / wip.git / blobdiff