/*
* Alert box for a failed attempt to write to a file.
- * "err" is assumed to be a UNIX-style errno.
+ * "err" is assumed to be a UNIX-style errno if positive and a
+ * Wiretap error if negative.
*
* XXX - add explanatory secondary text for at least some of the errors;
* various HIGs suggest that you should, for example, suggest that the
void
write_failure_alert_box(const char *filename, int err)
{
- simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
- file_write_error_message(err), filename);
+ if (err < 0) {
+ switch (err) {
+
+ case WTAP_ERR_SHORT_WRITE:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "A full write couldn't be done to the file \"%s\".",
+ filename);
+ break;
+
+ default:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "An error occurred while writing to the file \"%s\": %s.",
+ filename, wtap_strerror(err));
+ break;
+ }
+ } else {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ file_write_error_message(err), filename);
+ }
}
/*
const struct wtap_pkthdr *phdr;
int err_type;
guint8 *buf;
+ guint32 read_count = 0;
int split_packet_count = 0;
int written_count = 0;
char *filename = NULL;
}
while (wtap_read(wth, &err, &err_info, &data_offset)) {
+ read_count++;
+
phdr = wtap_phdr(wth);
buf = wtap_buf_ptr(wth);
}
if (!wtap_dump(pdh, phdr, wtap_pseudoheader(wth), buf, &err)) {
- fprintf(stderr, "editcap: Error writing to %s: %s\n",
- filename, wtap_strerror(err));
+ switch (err) {
+
+ case WTAP_ERR_UNSUPPORTED_ENCAP:
+ /*
+ * This is a problem with the particular frame we're writing;
+ * note that, and give the frame number.
+ */
+ fprintf(stderr, "editcap: Frame %u of \"%s\" has a network type that can't be saved in a file with that format\n.",
+ read_count, argv[optind]);
+ break;
+
+ default:
+ fprintf(stderr, "editcap: Error writing to %s: %s\n",
+ filename, wtap_strerror(err));
+ break;
+ }
exit(2);
}
written_count++;
break;
#endif
- case WTAP_ERR_SHORT_WRITE:
- errmsg = "A full write couldn't be done to the file \"%s\".";
- break;
-
default:
g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"An error occurred while writing to the file \"%%s\": %s.",
gchar *err_info, gboolean for_writing,
int file_type);
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 void ref_time_packets(capture_file *cf);
/* Update the progress bar this many times when reading a file. */
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;
+ merge_in_file_t *in_files, *in_file;
char *out_filename;
char *tmpname;
int out_fd;
/* do the merge (or append) */
for (;;) {
if (do_append)
- wth = merge_append_read_packet(in_file_count, in_files, &read_err,
- &err_info);
+ in_file = merge_append_read_packet(in_file_count, in_files, &read_err,
+ &err_info);
else
- wth = merge_read_packet(in_file_count, in_files, &read_err,
- &err_info);
- if (wth == NULL) {
+ in_file = merge_read_packet(in_file_count, in_files, &read_err,
+ &err_info);
+ if (in_file == NULL) {
if (read_err != 0)
got_read_error = TRUE;
break;
break;
}
- if (!wtap_dump(pdh, wtap_phdr(wth), wtap_pseudoheader(wth),
- wtap_buf_ptr(wth), &write_err)) {
+ if (!wtap_dump(pdh, wtap_phdr(in_file->wth), wtap_pseudoheader(in_file->wth),
+ wtap_buf_ptr(in_file->wth), &write_err)) {
got_write_error = TRUE;
break;
}
*/
for (i = 0; i < in_file_count; i++) {
if (in_files[i].state == GOT_ERROR) {
- /* Put up a message box noting that a read failed somewhere along
- the line. */
- switch (read_err) {
-
- case WTAP_ERR_UNSUPPORTED_ENCAP:
- g_snprintf(errmsg_errno, sizeof(errmsg_errno),
- "The capture file %%s has a packet with a network type that Wireshark doesn't support.\n(%s)",
- err_info);
- g_free(err_info);
- errmsg = errmsg_errno;
- break;
+ /* Put up a message box noting that a read failed somewhere along
+ the line. */
+ switch (read_err) {
+
+ case WTAP_ERR_UNSUPPORTED_ENCAP:
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
+ "The capture file %%s has a packet with a network type that Wireshark doesn't support.\n(%s)",
+ err_info);
+ g_free(err_info);
+ errmsg = errmsg_errno;
+ break;
- case WTAP_ERR_CANT_READ:
- errmsg = "An attempt to read from the capture file %s failed for"
- " some unknown reason.";
- break;
+ case WTAP_ERR_CANT_READ:
+ errmsg = "An attempt to read from the capture file %s failed for"
+ " some unknown reason.";
+ break;
- case WTAP_ERR_SHORT_READ:
- errmsg = "The capture file %s appears to have been cut short"
- " in the middle of a packet.";
- break;
+ case WTAP_ERR_SHORT_READ:
+ errmsg = "The capture file %s appears to have been cut short"
+ " in the middle of a packet.";
+ break;
- case WTAP_ERR_BAD_RECORD:
- 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);
- errmsg = errmsg_errno;
- break;
+ case WTAP_ERR_BAD_RECORD:
+ 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);
+ errmsg = errmsg_errno;
+ break;
- case WTAP_ERR_DECOMPRESS:
- g_snprintf(errmsg_errno, sizeof(errmsg_errno),
- "The compressed capture file %%s appears to be damaged or corrupt.\n"
- "(%s)", err_info);
- g_free(err_info);
- errmsg = errmsg_errno;
- break;
+ case WTAP_ERR_DECOMPRESS:
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
+ "The compressed capture file %%s appears to be damaged or corrupt.\n"
+ "(%s)", err_info);
+ g_free(err_info);
+ errmsg = errmsg_errno;
+ break;
- default:
- 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;
- }
+ default:
+ 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;
+ }
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, errmsg, in_files[i].filename);
}
}
if (got_write_error) {
/* Put up an alert box for the write error. */
- cf_write_failure_alert_box(out_filename, write_err);
+ if (write_err < 0) {
+ /* Wiretap error. */
+ switch (write_err) {
+
+ case WTAP_ERR_UNSUPPORTED_ENCAP:
+ /*
+ * This is a problem with the particular frame we're writing;
+ * note that, and give the frame number.
+ */
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.",
+ in_file->packet_num, in_file->filename,
+ wtap_file_type_string(file_type));
+ break;
+
+ default:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "An error occurred while writing to the file \"%s\": %s.",
+ out_filename, wtap_strerror(write_err));
+ break;
+ }
+ } else {
+ /* OS error. */
+ write_failure_alert_box(out_filename, write_err);
+ }
}
if (got_read_error || got_write_error || stop_flag) {
typedef struct {
wtap_dumper *pdh;
const char *fname;
+ int file_type;
} save_callback_args_t;
/*
/* and save the packet */
if (!wtap_dump(args->pdh, &hdr, pseudo_header, pd, &err)) {
- cf_write_failure_alert_box(args->fname, err);
+ if (err < 0) {
+ /* Wiretap error. */
+ switch (err) {
+
+ case WTAP_ERR_UNSUPPORTED_ENCAP:
+ /*
+ * This is a problem with the particular frame we're writing;
+ * note that, and give the frame number.
+ */
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "Frame %u has a network type that can't be saved in a \"%s\" file.",
+ fdata->num, wtap_file_type_string(args->file_type));
+ break;
+
+ default:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "An error occurred while writing to the file \"%s\": %s.",
+ args->fname, wtap_strerror(err));
+ break;
+ }
+ } else {
+ /* OS error. */
+ write_failure_alert_box(args->fname, err);
+ }
return FALSE;
}
return TRUE;
if (do_copy) {
/* Copy the file, if we haven't moved it. */
if (!copy_file_binary_mode(from_filename, fname))
- goto fail;
+ goto fail;
}
} else {
/* Either we're filtering packets, or we're saving in a different
"range" since we initialized it. */
callback_args.pdh = pdh;
callback_args.fname = fname;
+ callback_args.file_type = save_format;
switch (process_specified_packets(cf, range, "Saving", "selected packets",
TRUE, save_packet, &callback_args)) {
return errmsg;
}
-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,
files[i].wth = wtap_open_offline(in_file_names[i], err, err_info, FALSE);
files[i].data_offset = 0;
files[i].state = PACKET_NOT_PRESENT;
+ files[i].packet_num = 0;
if (!files[i].wth) {
/* Close the files we've already opened. */
for (j = 0; j < i; j++)
/*
* Read the next packet, in chronological order, from the set of files
- * to be merged.
+ * to be merged. Return a pointer to the merge_in_file_t for the file
+ * from which the packet was read on success, or NULL on EOF or error.
+ * On EOF, *err is 0; on an error, it's an error code.
*/
-wtap *
-merge_read_packet(int in_file_count, merge_in_file_t in_files[], int *err,
- gchar **err_info)
+merge_in_file_t *
+merge_read_packet(int in_file_count, merge_in_file_t in_files[],
+ int *err, gchar **err_info)
{
int i;
int ei = -1;
/* We'll need to read another packet from this file. */
in_files[ei].state = PACKET_NOT_PRESENT;
- /* Return a pointer to the wtap structure for the file with that frame. */
- return in_files[ei].wth;
+ /* Count this packet. */
+ in_files[ei].packet_num++;
+
+ /* Return the ordinal of the file from which the packet was read. */
+ return &in_files[ei];
}
/*
* Read the next packet, in file sequence order, from the set of files
- * to be merged.
+ * to be merged. Return a pointer to the merge_in_file_t for the file
+ * from which the packet was read on success, or NULL on EOF or error.
+ * On EOF, *err is 0; on an error, it's an error code.
*/
-wtap *
+merge_in_file_t *
merge_append_read_packet(int in_file_count, merge_in_file_t in_files[],
int *err, gchar **err_info)
{
return NULL;
}
- /* Return a pointer to the wtap structure for the file with that frame. */
- return in_files[i].wth;
+ /* Return the ordinal of the file from which the packet was read. */
+ return &in_files[i];
}
wtap *wth;
gint64 data_offset;
in_file_state_e state;
+ guint32 packet_num; /* current packet number */
gint64 size; /* file size */
} merge_in_file_t;
* @param in_files input file array
* @param err wiretap error, if failed
* @param err_info wiretap error string, if failed
- * @return pointer to wtap for file from which that packet came, or NULL on
- * error or EOF
+ * @return pointer to merge_in_file_t for file from which that packet
+ * came, or NULL on error or EOF
*/
-extern wtap *
+extern merge_in_file_t *
merge_read_packet(int in_file_count, merge_in_file_t in_files[], int *err,
gchar **err_info);
* @param in_files input file array
* @param err wiretap error, if failed
* @param err_info wiretap error string, if failed
- * @return pointer to wtap for file from which that packet came, or NULL on
- * error or EOF
+ * @return pointer to merge_in_file_t for file from which that packet
+ * came, or NULL on error or EOF
*/
-extern wtap *
+extern merge_in_file_t *
merge_append_read_packet(int in_file_count, merge_in_file_t in_files[],
int *err, gchar **err_info);
#endif
int frame_type = -2;
int out_fd;
- merge_in_file_t *in_files = NULL;
+ merge_in_file_t *in_files = NULL, *in_file;
int i;
- wtap *wth;
struct wtap_pkthdr *phdr, snap_phdr;
wtap_dumper *pdh;
int open_err, read_err, write_err, close_err;
count = 1;
for (;;) {
if (do_append)
- wth = merge_append_read_packet(in_file_count, in_files, &read_err,
- &err_info);
+ in_file = merge_append_read_packet(in_file_count, in_files, &read_err,
+ &err_info);
else
- wth = merge_read_packet(in_file_count, in_files, &read_err,
- &err_info);
- if (wth == NULL) {
+ in_file = merge_read_packet(in_file_count, in_files, &read_err,
+ &err_info);
+ if (in_file == NULL) {
if (read_err != 0)
got_read_error = TRUE;
break;
/* We simply write it, perhaps after truncating it; we could do other
* things, like modify it. */
- phdr = wtap_phdr(wth);
+ phdr = wtap_phdr(in_file->wth);
if (snaplen != 0 && phdr->caplen > snaplen) {
snap_phdr = *phdr;
snap_phdr.caplen = snaplen;
phdr = &snap_phdr;
}
- if (!wtap_dump(pdh, phdr, wtap_pseudoheader(wth),
- wtap_buf_ptr(wth), &write_err)) {
+ if (!wtap_dump(pdh, phdr, wtap_pseudoheader(in_file->wth),
+ wtap_buf_ptr(in_file->wth), &write_err)) {
got_write_error = TRUE;
break;
}
}
if (got_write_error) {
- fprintf(stderr, "mergecap: Error writing to outfile: %s\n",
- wtap_strerror(write_err));
+ switch (write_err) {
+
+ case WTAP_ERR_UNSUPPORTED_ENCAP:
+ /*
+ * This is a problem with the particular frame we're writing;
+ * note that, and give the frame number.
+ */
+ fprintf(stderr, "mergecap: Frame %u of \"%s\" has a network type that can't be saved in a file with that format\n.",
+ in_file->packet_num, in_file->filename);
+ break;
+
+ default:
+ fprintf(stderr, "mergecap: Error writing to outfile: %s\n",
+ wtap_strerror(write_err));
+ break;
+ }
}
g_free(in_files);
gint linktype;
int snapshot_length;
wtap_dumper *pdh;
+ guint32 framenum;
int err;
gchar *err_info = NULL;
gint64 data_offset;
case WTAP_ERR_UNSUPPORTED_ENCAP:
case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
- cmdarg_err("The capture file being read can't be written in "
- "the format \"%s\".", wtap_encap_short_string(linktype));
+ cmdarg_err("The capture file being read can't be written as a "
+ "\"%s\" file.", wtap_file_type_short_string(out_file_type));
break;
case WTAP_ERR_CANT_OPEN:
tap_flags = union_of_tap_listener_flags();
if (perform_two_pass_analysis) {
- guint32 framenum;
frame_data *fdata;
int old_max_packet_count = max_packet_count;
wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
&err)) {
/* Error writing to a capture file */
- show_capture_file_io_error(save_file, err, FALSE);
+ switch (err) {
+
+ case WTAP_ERR_UNSUPPORTED_ENCAP:
+ /*
+ * This is a problem with the particular frame we're writing;
+ * note that, and give the frame number.
+ *
+ * XXX - framenum is not necessarily the frame number in
+ * the input file if there was a read filter.
+ */
+ fprintf(stderr,
+ "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
+ framenum, cf->filename,
+ wtap_file_type_short_string(out_file_type));
+ break;
+
+ default:
+ show_capture_file_io_error(save_file, err, FALSE);
+ break;
+ }
wtap_dump_close(pdh, &err);
exit(2);
}
}
}
else {
+ framenum = 0;
while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
+ framenum++;
+
if (process_packet(cf, data_offset, wtap_phdr(cf->wth),
wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
filtering_tap_listeners, tap_flags)) {
wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
&err)) {
/* Error writing to a capture file */
- show_capture_file_io_error(save_file, err, FALSE);
+ switch (err) {
+
+ case WTAP_ERR_UNSUPPORTED_ENCAP:
+ /*
+ * This is a problem with the particular frame we're writing;
+ * note that, and give the frame number.
+ */
+ fprintf(stderr,
+ "Frame %u of \"%s\" has a network type that can't be saved in a \"%s\" file.\n",
+ framenum, cf->filename,
+ wtap_file_type_short_string(out_file_type));
+ break;
+
+ default:
+ show_capture_file_io_error(save_file, err, FALSE);
+ break;
+ }
wtap_dump_close(pdh, &err);
exit(2);
}
case WTAP_ERR_CANT_WRITE_TO_PIPE:
/* Seen only when opening a capture file for writing. */
g_snprintf(errmsg_errno, sizeof(errmsg_errno),
- "The file \"%%s\" is a pipe, and %s capture files can't be "
- "written to a pipe.", wtap_file_type_string(file_type));
+ "The file \"%%s\" is a pipe, and \"%s\" capture files can't be "
+ "written to a pipe.", wtap_file_type_short_string(file_type));
errmsg = errmsg_errno;
break;
break;
case WTAP_ERR_UNSUPPORTED_ENCAP:
- if (for_writing)
- errmsg = "TShark can't save this capture in that format.";
- else {
+ if (for_writing) {
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
+ "TShark can't save this capture as a \"%s\" file.",
+ wtap_file_type_short_string(file_type));
+ } else {
g_snprintf(errmsg_errno, sizeof(errmsg_errno),
"The file \"%%s\" is a capture for a network type that TShark doesn't support.\n"
"(%s)", err_info);
g_free(err_info);
- errmsg = errmsg_errno;
}
+ errmsg = errmsg_errno;
break;
case WTAP_ERR_ENCAP_PER_PACKET_UNSUPPORTED:
- if (for_writing)
- errmsg = "TShark can't save this capture in that format.";
- else
+ if (for_writing) {
+ g_snprintf(errmsg_errno, sizeof(errmsg_errno),
+ "TShark can't save this capture as a \"%s\" file.",
+ wtap_file_type_short_string(file_type));
+ errmsg = errmsg_errno;
+ } else
errmsg = "The file \"%s\" is a capture for a network type that TShark doesn't support.";
break;
git.samba.org / metze / wireshark / wip.git / commitdiff