2021-11-30 04:27:19 +00:00
|
|
|
/** @file
|
|
|
|
*
|
1998-09-16 02:39:15 +00:00
|
|
|
* Definitions for file structures and routines
|
|
|
|
*
|
2006-05-21 05:12:17 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
1998-09-16 02:39:15 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
2002-08-28 21:04:11 +00:00
|
|
|
*
|
2018-02-07 11:26:45 +00:00
|
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
1998-09-16 02:39:15 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __FILE_H__
|
|
|
|
#define __FILE_H__
|
|
|
|
|
2017-12-03 18:53:58 +00:00
|
|
|
#include <wiretap/wtap.h>
|
|
|
|
#include <epan/epan.h>
|
2013-07-12 03:50:50 +00:00
|
|
|
#include <epan/print.h>
|
2023-06-05 22:07:09 +00:00
|
|
|
#include <epan/fifo_string_cache.h>
|
2017-04-23 23:48:17 +00:00
|
|
|
#include <ui/packet_range.h>
|
1998-09-16 02:39:15 +00:00
|
|
|
|
2011-12-29 00:08:47 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
extern "C" {
|
|
|
|
#endif /* __cplusplus */
|
2005-02-05 13:44:27 +00:00
|
|
|
|
|
|
|
/** Return values from functions that only can succeed or fail. */
|
Add routines to Wiretap to allow a client of Wiretap to get:
a pointer to the "wtap_pkthdr" structure for an open capture
file;
a pointer to the "wtap_pseudo_header" union for an open capture
file;
a pointer to the packet buffer for an open capture file;
so that a program using "wtap_read()" in a loop can get at those items.
Keep, in a "capture_file" structure, an indicator of whether:
no file is open;
a file is open, and being read;
a file is open, and is being read, but the user tried to quit
out of reading the file (e.g., by doing "File/Quit");
a file is open, and has been completely read.
Abort if we try to close a capture that's being read if the user hasn't
tried to quit out of the read.
Have "File/Quit" check if a file is being read; if so, just set the
state indicator to "user tried to quit out of it", so that the code
reading the file can do what's appropriate to clean up, rather than
closing the file out from under that code and causing crashes.
Have "read_cap_file()" read the capture file with a loop using
"wtap_read()", rather than by using "wtap_loop()"; have it check after
reading each packet whether the user tried to abort the read and, if so,
close the capture and return an indication that the read was aborted by
the user. Otherwise, return an indication of whether the read
completely succeeded or failed in the middle (and, if it failed, return
the error code through a pointer).
Have "continue_tail_cap_file()" read the capture file with a loop using
"wtap_read()", rather than by using "wtap_loop()"; have it check after
reading each packet whether the user tried to abort the read and, if so,
quit the loop, and after the loop finishes (even if it read no packets),
return an indication that the read was aborted by the user if that
happened. Otherwise, return an indication of whether the read
completely succeeded or failed in the middle (and, if it failed, return
the error code through a pointer).
Have "finish_tail_cap_file()" read the capture file with a loop using
"wtap_read()", rather than by using "wtap_loop()"; have it check after
reading each packet whether the user tried to abort the read and, if so,
quit the loop, and after the loop finishes (even if it read no packets),
close the capture and return an indication that the read was aborted by
the user if that happened. Otherwise, return an indication of whether
the read completely succeeded or failed in the middle (and, if it
failed, return the error code through a pointer).
Have their callers check whether the read was aborted or not and, if it
was, bail out in the appropriate fashion (exit if it's reading a file
specified by "-r" on the command line; exit the main loop if it's
reading a file specified with File->Open; kill the capture child if it's
"continue_tail_cap_file()"; exit the main loop if it's
"finish_tail_cap_file()".
svn path=/trunk/; revision=2095
2000-06-27 07:13:42 +00:00
|
|
|
typedef enum {
|
2012-05-22 03:52:12 +00:00
|
|
|
CF_OK, /**< operation succeeded */
|
|
|
|
CF_ERROR /**< operation got an error (function may provide err with details) */
|
2005-02-05 12:50:47 +00:00
|
|
|
} cf_status_t;
|
|
|
|
|
2005-02-05 13:44:27 +00:00
|
|
|
/** Return values from functions that read capture files. */
|
2005-02-05 12:50:47 +00:00
|
|
|
typedef enum {
|
2014-10-12 18:56:12 +00:00
|
|
|
CF_READ_OK, /**< operation succeeded */
|
2012-05-22 03:52:12 +00:00
|
|
|
CF_READ_ERROR, /**< operation got an error (function may provide err with details) */
|
|
|
|
CF_READ_ABORTED /**< operation aborted by user */
|
2005-02-04 20:54:12 +00:00
|
|
|
} cf_read_status_t;
|
|
|
|
|
Distinguish between "failed" and "user stopped it" for "save as" and
"export specified packets". For "failed", let the user try again with a
different file, in case it failed due to, for example, running out of
space or quota (probably the most likely failure mode for writing, and
trying to a different volume might be the best workaround). For "user
stopped it", presumably they don't want to try again (the most likely
reason is "it was taking too damn long").
Put "Exporting to: ...", not "Saving: ..." in the statusbar if we're
doing "export specified packets".
In process_specified_packets(), allow a null range pointer to be
specified, meaning "save 'em all"; that avoids the possibly-expensive
(with a large capture) operation of initializing the range.
If a "safe save" atop an existing file fails or is stopped, get rid of
the temporary file we created.
svn path=/trunk/; revision=43095
2012-06-05 02:46:54 +00:00
|
|
|
/** Return values from functions that write out packets. */
|
|
|
|
typedef enum {
|
|
|
|
CF_WRITE_OK, /**< operation succeeded */
|
|
|
|
CF_WRITE_ERROR, /**< operation got an error (function may provide err with details) */
|
2013-01-02 01:35:08 +00:00
|
|
|
CF_WRITE_ABORTED /**< operation aborted by user */
|
Distinguish between "failed" and "user stopped it" for "save as" and
"export specified packets". For "failed", let the user try again with a
different file, in case it failed due to, for example, running out of
space or quota (probably the most likely failure mode for writing, and
trying to a different volume might be the best workaround). For "user
stopped it", presumably they don't want to try again (the most likely
reason is "it was taking too damn long").
Put "Exporting to: ...", not "Saving: ..." in the statusbar if we're
doing "export specified packets".
In process_specified_packets(), allow a null range pointer to be
specified, meaning "save 'em all"; that avoids the possibly-expensive
(with a large capture) operation of initializing the range.
If a "safe save" atop an existing file fails or is stopped, get rid of
the temporary file we created.
svn path=/trunk/; revision=43095
2012-06-05 02:46:54 +00:00
|
|
|
} cf_write_status_t;
|
|
|
|
|
2005-02-04 20:54:12 +00:00
|
|
|
/** Return values from functions that print sets of packets. */
|
|
|
|
typedef enum {
|
2014-10-12 18:56:12 +00:00
|
|
|
CF_PRINT_OK, /**< print operation succeeded */
|
|
|
|
CF_PRINT_OPEN_ERROR, /**< print operation failed while opening printer */
|
|
|
|
CF_PRINT_WRITE_ERROR /**< print operation failed while writing to the printer */
|
2005-02-04 20:54:12 +00:00
|
|
|
} cf_print_status_t;
|
2005-02-04 18:44:44 +00:00
|
|
|
|
2005-02-07 00:54:46 +00:00
|
|
|
typedef enum {
|
2012-09-26 23:33:11 +00:00
|
|
|
cf_cb_file_opened,
|
2005-09-20 08:42:35 +00:00
|
|
|
cf_cb_file_closing,
|
2005-02-07 00:54:46 +00:00
|
|
|
cf_cb_file_closed,
|
2009-12-14 22:05:29 +00:00
|
|
|
cf_cb_file_read_started,
|
2005-02-07 00:54:46 +00:00
|
|
|
cf_cb_file_read_finished,
|
2012-05-22 03:52:12 +00:00
|
|
|
cf_cb_file_reload_started,
|
|
|
|
cf_cb_file_reload_finished,
|
If we do a Save or Save As with a move, don't reread the capture file,
just tweak the elements in the capture_file structure as necessary and
poke the UI to update stuff such as the windows title.
If we do a Save or Save As with a copy, don't reread the capture file,
just close the old wtap, open a wtap for the copy, and tweak the
elements in the capture_file structure as necessary and poke the UI to
update stuff such as the windows title.
Otherwise, don't do a full read-and-dissect pass on the capture file,
just close the old wtap, open a wtap for the new file, tweak the
elements in the capture_file structure as necessary and poke the UI to
update stuff such as the windows title, and rescan the file to update
the packet offsets (and cause Wiretap to regenerate, for a gzipped file,
the information needed to support fast random access to the gzipped
file).
This should speed up Save and Save As a bit, as well as removing some
glitches in the UI (e.g., you won't see the packet list disappear and
reappear).
svn path=/trunk/; revision=43101
2012-06-05 06:52:18 +00:00
|
|
|
cf_cb_file_rescan_started,
|
|
|
|
cf_cb_file_rescan_finished,
|
2015-08-24 19:30:56 +00:00
|
|
|
cf_cb_file_retap_started,
|
|
|
|
cf_cb_file_retap_finished,
|
2017-01-21 00:05:56 +00:00
|
|
|
cf_cb_file_merge_started, /* Qt only */
|
|
|
|
cf_cb_file_merge_finished, /* Qt only */
|
2018-04-16 00:35:42 +00:00
|
|
|
cf_cb_file_fast_save_finished,
|
2009-12-14 22:05:29 +00:00
|
|
|
cf_cb_file_save_started,
|
|
|
|
cf_cb_file_save_finished,
|
Distinguish between "failed" and "user stopped it" for "save as" and
"export specified packets". For "failed", let the user try again with a
different file, in case it failed due to, for example, running out of
space or quota (probably the most likely failure mode for writing, and
trying to a different volume might be the best workaround). For "user
stopped it", presumably they don't want to try again (the most likely
reason is "it was taking too damn long").
Put "Exporting to: ...", not "Saving: ..." in the statusbar if we're
doing "export specified packets".
In process_specified_packets(), allow a null range pointer to be
specified, meaning "save 'em all"; that avoids the possibly-expensive
(with a large capture) operation of initializing the range.
If a "safe save" atop an existing file fails or is stopped, get rid of
the temporary file we created.
svn path=/trunk/; revision=43095
2012-06-05 02:46:54 +00:00
|
|
|
cf_cb_file_save_failed,
|
2018-04-18 19:58:14 +00:00
|
|
|
cf_cb_file_save_stopped
|
2005-02-07 00:54:46 +00:00
|
|
|
} cf_cbs;
|
|
|
|
|
|
|
|
typedef void (*cf_callback_t) (gint event, gpointer data, gpointer user_data);
|
|
|
|
|
2011-01-31 12:19:15 +00:00
|
|
|
typedef struct {
|
|
|
|
const char *string;
|
|
|
|
size_t string_len;
|
|
|
|
capture_file *cf;
|
|
|
|
gboolean frame_matched;
|
|
|
|
field_info *finfo;
|
|
|
|
} match_data;
|
|
|
|
|
2020-10-26 23:00:40 +00:00
|
|
|
/**
|
|
|
|
* Set maximum number of records per capture file.
|
|
|
|
*
|
|
|
|
* @param max_records maximum number of records to support.
|
|
|
|
*/
|
|
|
|
extern void
|
|
|
|
cf_set_max_records(guint max_records);
|
|
|
|
|
2014-09-09 20:42:58 +00:00
|
|
|
/**
|
|
|
|
* Add a capture file event callback.
|
|
|
|
*
|
|
|
|
* @param func The function to be called for each event.
|
|
|
|
* The function will be passed three parameters: The event type (event),
|
|
|
|
* event-dependent data (data), and user-supplied data (user_data).
|
|
|
|
* Event-dependent data may be a capture_file pointer, character pointer,
|
|
|
|
* or NULL.
|
|
|
|
* @param user_data User-supplied data to pass to the callback. May be NULL.
|
|
|
|
*/
|
|
|
|
|
2005-02-07 00:54:46 +00:00
|
|
|
extern void
|
|
|
|
cf_callback_add(cf_callback_t func, gpointer user_data);
|
|
|
|
|
2014-09-09 20:42:58 +00:00
|
|
|
/**
|
|
|
|
* Remove a capture file event callback.
|
|
|
|
*
|
|
|
|
* @param func The function to be removed.
|
|
|
|
* @param user_data User-supplied data. Must be the same value supplied to cf_callback_add.
|
|
|
|
*/
|
|
|
|
|
2005-02-07 00:54:46 +00:00
|
|
|
extern void
|
2014-09-09 20:42:58 +00:00
|
|
|
cf_callback_remove(cf_callback_t func, gpointer user_data);
|
2005-02-07 00:54:46 +00:00
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
|
|
|
* Open a capture file.
|
|
|
|
*
|
|
|
|
* @param cf the capture file to be opened
|
|
|
|
* @param fname the filename to be opened
|
2014-01-18 14:20:02 +00:00
|
|
|
* @param type WTAP_TYPE_AUTO for automatic or index to direct open routine
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param is_tempfile is this a temporary file?
|
2010-08-26 20:31:09 +00:00
|
|
|
* @param err error code
|
2005-02-05 12:50:47 +00:00
|
|
|
* @return one of cf_status_t
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2014-01-18 14:20:02 +00:00
|
|
|
cf_status_t cf_open(capture_file *cf, const char *fname, unsigned int type, gboolean is_tempfile, int *err);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Close a capture file.
|
|
|
|
*
|
|
|
|
* @param cf the capture file to be closed
|
|
|
|
*/
|
|
|
|
void cf_close(capture_file *cf);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Reload a capture file.
|
|
|
|
*
|
|
|
|
* @param cf the capture file to be reloaded
|
2021-10-03 19:16:16 +00:00
|
|
|
* @return one of cf_status_t
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2021-10-03 19:16:16 +00:00
|
|
|
cf_status_t cf_reload(capture_file *cf);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Read all packets of a capture file into the internal structures.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file to be read
|
2023-06-04 14:12:19 +00:00
|
|
|
* @param reloading reread asked for from cf_save_records()
|
2005-02-04 20:54:12 +00:00
|
|
|
* @return one of cf_read_status_t
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2023-06-04 14:12:19 +00:00
|
|
|
cf_read_status_t cf_read(capture_file *cf, gboolean reloading);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
/**
|
2014-05-24 18:28:30 +00:00
|
|
|
* Read the metadata and raw data for a record. It will pop
|
2014-05-23 10:50:02 +00:00
|
|
|
* up an alert box if there's an error.
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
*
|
2014-05-24 18:28:30 +00:00
|
|
|
* @param cf the capture file from which to read the record
|
|
|
|
* @param fdata the frame_data structure for the record in question
|
2018-02-09 00:19:12 +00:00
|
|
|
* @param rec pointer to a wtap_rec structure to contain the
|
2014-05-24 18:28:30 +00:00
|
|
|
* record's metadata
|
|
|
|
* @param buf a Buffer into which to read the record's raw data
|
2014-05-23 10:50:02 +00:00
|
|
|
* @return TRUE if the read succeeded, FALSE if there was an error
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
*/
|
2019-04-15 05:14:15 +00:00
|
|
|
gboolean cf_read_record(capture_file *cf, const frame_data *fdata,
|
2019-04-06 17:42:39 +00:00
|
|
|
wtap_rec *rec, Buffer *buf);
|
|
|
|
|
2020-02-15 19:14:34 +00:00
|
|
|
/** Same as cf_read_record() but does not pop alert box on error */
|
|
|
|
gboolean cf_read_record_no_alert(capture_file *cf, const frame_data *fdata,
|
|
|
|
wtap_rec *rec, Buffer *buf);
|
|
|
|
|
|
|
|
|
2019-04-06 17:42:39 +00:00
|
|
|
/**
|
2019-04-15 05:14:15 +00:00
|
|
|
* Read the metadata and raw data for the current record into a
|
|
|
|
* capture_file structure's rec and buf for the current record.
|
2019-04-06 17:42:39 +00:00
|
|
|
* It will pop up an alert box if there's an error.
|
|
|
|
*
|
|
|
|
* @param cf the capture file from which to read the record
|
|
|
|
* @return TRUE if the read succeeded, FALSE if there was an error
|
|
|
|
*/
|
2019-04-15 05:14:15 +00:00
|
|
|
gboolean cf_read_current_record(capture_file *cf);
|
From Jakub Zawadzki:
New functions: cf_read_frame_r, cf_read_frame
It's much easier to write:
cf_read_frame (cf, fdata, &err, &err_info)
Than:
wtap_seek_read (cf->wth, fdata->file_off, &cf->pseudo_header, cf->pd,
fdata->cap_len, &err, &err_info)
svn path=/trunk/; revision=32980
2010-05-26 19:11:23 +00:00
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
|
|
|
* Read packets from the "end" of a capture file.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file to be read from
|
|
|
|
* @param to_read the number of packets to read
|
2019-04-07 02:42:23 +00:00
|
|
|
* @param rec pointer to wtap_rec to use when reading
|
|
|
|
* @param buf pointer to Buffer to use when reading
|
2013-02-26 04:42:26 +00:00
|
|
|
* @param err the error code, if an error had occurred
|
2005-02-04 20:54:12 +00:00
|
|
|
* @return one of cf_read_status_t
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2019-04-07 02:42:23 +00:00
|
|
|
cf_read_status_t cf_continue_tail(capture_file *cf, volatile int to_read,
|
2023-06-05 22:07:09 +00:00
|
|
|
wtap_rec *rec, Buffer *buf, int *err,
|
|
|
|
fifo_string_cache_t *frame_dup_cache, GChecksum *frame_cksum);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
2010-05-27 23:55:04 +00:00
|
|
|
/**
|
|
|
|
* Fake reading packets from the "end" of a capture file.
|
|
|
|
*
|
|
|
|
* @param cf the capture file to be read from
|
|
|
|
*/
|
|
|
|
void cf_fake_continue_tail(capture_file *cf);
|
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
|
|
|
* Finish reading from "end" of a capture file.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file to be read from
|
2019-04-07 02:42:23 +00:00
|
|
|
* @param rec pointer to wtap_rec to use when reading
|
|
|
|
* @param buf pointer to Buffer to use when reading
|
2013-02-26 04:42:26 +00:00
|
|
|
* @param err the error code, if an error had occurred
|
2005-02-04 20:54:12 +00:00
|
|
|
* @return one of cf_read_status_t
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2019-04-07 02:42:23 +00:00
|
|
|
cf_read_status_t cf_finish_tail(capture_file *cf, wtap_rec *rec,
|
2023-06-05 22:07:09 +00:00
|
|
|
Buffer *buf, int *err,
|
|
|
|
fifo_string_cache_t *frame_dup_cache, GChecksum *frame_cksum);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
2007-03-14 19:30:19 +00:00
|
|
|
/**
|
2013-04-01 23:44:29 +00:00
|
|
|
* Determine whether this capture file (or a range of it) can be written
|
2012-06-25 18:37:52 +00:00
|
|
|
* in any format using Wiretap rather than by copying the raw data.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2007-03-14 19:30:19 +00:00
|
|
|
* @param cf the capture file to check
|
2013-04-01 23:44:29 +00:00
|
|
|
* @return TRUE if it can be written, FALSE if it can't
|
2007-03-14 19:30:19 +00:00
|
|
|
*/
|
2012-06-25 18:37:52 +00:00
|
|
|
gboolean cf_can_write_with_wiretap(capture_file *cf);
|
2007-03-14 19:30:19 +00:00
|
|
|
|
2013-04-01 23:44:29 +00:00
|
|
|
/**
|
|
|
|
* Determine whether this capture file can be saved with a "save" operation;
|
|
|
|
* if there's nothing unsaved, it can't.
|
|
|
|
*
|
|
|
|
* @param cf the capture file to check
|
|
|
|
* @return TRUE if it can be saved, FALSE if it can't
|
|
|
|
*/
|
|
|
|
gboolean cf_can_save(capture_file *cf);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determine whether this capture file can be saved with a "save as" operation.
|
|
|
|
*
|
|
|
|
* @param cf the capture file to check
|
|
|
|
* @return TRUE if it can be saved, FALSE if it can't
|
|
|
|
*/
|
|
|
|
gboolean cf_can_save_as(capture_file *cf);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Determine whether this capture file has unsaved data.
|
|
|
|
*
|
|
|
|
* @param cf the capture file to check
|
|
|
|
* @return TRUE if it has unsaved data, FALSE if it doesn't
|
|
|
|
*/
|
2013-04-02 20:35:46 +00:00
|
|
|
gboolean cf_has_unsaved_data(capture_file *cf);
|
2013-04-01 23:44:29 +00:00
|
|
|
|
We're an editor now, as we let you add, delete, and edit frame comments,
so "Save" should, for non-temporary files, mean "save the current state
of the capture file on top of the existing file" without prompting for a
file name.
That means we have to do a "safe save" - i.e, write the capture out to a
new file and, if that succeeds, rename the new file on top of the old
file - as the actual packet data to write out is in the file we're
overwriting, not in memory. (We'd want to do that anyway, of
course....)
Update some comments.
Clean up indentation slightly, and get rid of an unnecessary variable
(in all the cases where we use it, we assign it the same value, and that
value isn't modified out from under us before we use it).
Note that after a "Save", or a "Save As" that writes out all captured
packets, we shouldn't have to close the current file and open the new
file and reread it - we should be able to open the new file and update
the frame offsets in the frame_data structures.
Note that we need to do some a better job of reporting rename failures.
svn path=/trunk/; revision=42777
2012-05-22 10:36:40 +00:00
|
|
|
/**
|
"Save As" always saves everything and, when the save is done, makes the
new file the current file, as is the case in most if not all other GUI
applications.
A new "Export Specified Packets" menu option allows you to specify which
packets to write out, with the default being the displayed packets (and
those on which the displayed packets depend for, e.g. reassembly), and
never makes the resulting file the current file.
The two operations are conceptually distinct. Lumping them into one
menu item, with the default for "Save As" being "displayed packets only"
and thus making it behave like the latter operation, was causing some
confusion; see, for example, bug 6640.
Make the dialog popped up if you try to "Save As" or "Export Specified
Packets" on top of an existing file ask the "do you want to do this?"
question in the main part of the message, and note in the secondary text
that doing that will overwrite what's in the file; that matches what
TextEdit on OS X and the GNOME text editor say.
svn path=/trunk/; revision=42792
2012-05-22 22:17:57 +00:00
|
|
|
* Save all packets in a capture file to a new file, and, if that succeeds,
|
2012-05-24 02:16:53 +00:00
|
|
|
* make that file the current capture file. If there's already a file with
|
|
|
|
* that name, do a "safe save", writing to a temporary file in the same
|
|
|
|
* directory and, if the write succeeds, renaming the new file on top of the
|
|
|
|
* old file, so that if the write fails, the old file is still intact.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file to save to
|
|
|
|
* @param fname the filename to save to
|
|
|
|
* @param save_format the format of the file to save (libpcap, ...)
|
2018-11-16 04:06:36 +00:00
|
|
|
* @param compression_type type of compression to use when writing, if any
|
2013-04-26 18:28:21 +00:00
|
|
|
* @param discard_comments TRUE if we should discard comments if the save
|
2012-06-20 01:11:01 +00:00
|
|
|
* succeeds (because we saved in a format that doesn't support
|
|
|
|
* comments)
|
2012-05-25 21:25:55 +00:00
|
|
|
* @param dont_reopen TRUE if it shouldn't reopen and make that file the
|
|
|
|
* current capture file
|
Distinguish between "failed" and "user stopped it" for "save as" and
"export specified packets". For "failed", let the user try again with a
different file, in case it failed due to, for example, running out of
space or quota (probably the most likely failure mode for writing, and
trying to a different volume might be the best workaround). For "user
stopped it", presumably they don't want to try again (the most likely
reason is "it was taking too damn long").
Put "Exporting to: ...", not "Saving: ..." in the statusbar if we're
doing "export specified packets".
In process_specified_packets(), allow a null range pointer to be
specified, meaning "save 'em all"; that avoids the possibly-expensive
(with a large capture) operation of initializing the range.
If a "safe save" atop an existing file fails or is stopped, get rid of
the temporary file we created.
svn path=/trunk/; revision=43095
2012-06-05 02:46:54 +00:00
|
|
|
* @return one of cf_write_status_t
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2014-05-24 18:28:30 +00:00
|
|
|
cf_write_status_t cf_save_records(capture_file * cf, const char *fname,
|
2018-11-16 04:06:36 +00:00
|
|
|
guint save_format,
|
|
|
|
wtap_compression_type compression_type,
|
2012-06-20 01:11:01 +00:00
|
|
|
gboolean discard_comments,
|
Distinguish between "failed" and "user stopped it" for "save as" and
"export specified packets". For "failed", let the user try again with a
different file, in case it failed due to, for example, running out of
space or quota (probably the most likely failure mode for writing, and
trying to a different volume might be the best workaround). For "user
stopped it", presumably they don't want to try again (the most likely
reason is "it was taking too damn long").
Put "Exporting to: ...", not "Saving: ..." in the statusbar if we're
doing "export specified packets".
In process_specified_packets(), allow a null range pointer to be
specified, meaning "save 'em all"; that avoids the possibly-expensive
(with a large capture) operation of initializing the range.
If a "safe save" atop an existing file fails or is stopped, get rid of
the temporary file we created.
svn path=/trunk/; revision=43095
2012-06-05 02:46:54 +00:00
|
|
|
gboolean dont_reopen);
|
"Save As" always saves everything and, when the save is done, makes the
new file the current file, as is the case in most if not all other GUI
applications.
A new "Export Specified Packets" menu option allows you to specify which
packets to write out, with the default being the displayed packets (and
those on which the displayed packets depend for, e.g. reassembly), and
never makes the resulting file the current file.
The two operations are conceptually distinct. Lumping them into one
menu item, with the default for "Save As" being "displayed packets only"
and thus making it behave like the latter operation, was causing some
confusion; see, for example, bug 6640.
Make the dialog popped up if you try to "Save As" or "Export Specified
Packets" on top of an existing file ask the "do you want to do this?"
question in the main part of the message, and note in the secondary text
that doing that will overwrite what's in the file; that matches what
TextEdit on OS X and the GNOME text editor say.
svn path=/trunk/; revision=42792
2012-05-22 22:17:57 +00:00
|
|
|
|
|
|
|
/**
|
2012-05-24 02:16:53 +00:00
|
|
|
* Export some or all packets from a capture file to a new file. If there's
|
|
|
|
* already a file with that name, do a "safe save", writing to a temporary
|
|
|
|
* file in the same directory and, if the write succeeds, renaming the new
|
|
|
|
* file on top of the old file, so that if the write fails, the old file is
|
|
|
|
* still intact.
|
"Save As" always saves everything and, when the save is done, makes the
new file the current file, as is the case in most if not all other GUI
applications.
A new "Export Specified Packets" menu option allows you to specify which
packets to write out, with the default being the displayed packets (and
those on which the displayed packets depend for, e.g. reassembly), and
never makes the resulting file the current file.
The two operations are conceptually distinct. Lumping them into one
menu item, with the default for "Save As" being "displayed packets only"
and thus making it behave like the latter operation, was causing some
confusion; see, for example, bug 6640.
Make the dialog popped up if you try to "Save As" or "Export Specified
Packets" on top of an existing file ask the "do you want to do this?"
question in the main part of the message, and note in the secondary text
that doing that will overwrite what's in the file; that matches what
TextEdit on OS X and the GNOME text editor say.
svn path=/trunk/; revision=42792
2012-05-22 22:17:57 +00:00
|
|
|
*
|
|
|
|
* @param cf the capture file to write to
|
|
|
|
* @param fname the filename to write to
|
|
|
|
* @param range the range of packets to write
|
|
|
|
* @param save_format the format of the file to write (libpcap, ...)
|
2018-11-16 04:06:36 +00:00
|
|
|
* @param compression_type type of compression to use when writing, if any
|
Distinguish between "failed" and "user stopped it" for "save as" and
"export specified packets". For "failed", let the user try again with a
different file, in case it failed due to, for example, running out of
space or quota (probably the most likely failure mode for writing, and
trying to a different volume might be the best workaround). For "user
stopped it", presumably they don't want to try again (the most likely
reason is "it was taking too damn long").
Put "Exporting to: ...", not "Saving: ..." in the statusbar if we're
doing "export specified packets".
In process_specified_packets(), allow a null range pointer to be
specified, meaning "save 'em all"; that avoids the possibly-expensive
(with a large capture) operation of initializing the range.
If a "safe save" atop an existing file fails or is stopped, get rid of
the temporary file we created.
svn path=/trunk/; revision=43095
2012-06-05 02:46:54 +00:00
|
|
|
* @return one of cf_write_status_t
|
"Save As" always saves everything and, when the save is done, makes the
new file the current file, as is the case in most if not all other GUI
applications.
A new "Export Specified Packets" menu option allows you to specify which
packets to write out, with the default being the displayed packets (and
those on which the displayed packets depend for, e.g. reassembly), and
never makes the resulting file the current file.
The two operations are conceptually distinct. Lumping them into one
menu item, with the default for "Save As" being "displayed packets only"
and thus making it behave like the latter operation, was causing some
confusion; see, for example, bug 6640.
Make the dialog popped up if you try to "Save As" or "Export Specified
Packets" on top of an existing file ask the "do you want to do this?"
question in the main part of the message, and note in the secondary text
that doing that will overwrite what's in the file; that matches what
TextEdit on OS X and the GNOME text editor say.
svn path=/trunk/; revision=42792
2012-05-22 22:17:57 +00:00
|
|
|
*/
|
Distinguish between "failed" and "user stopped it" for "save as" and
"export specified packets". For "failed", let the user try again with a
different file, in case it failed due to, for example, running out of
space or quota (probably the most likely failure mode for writing, and
trying to a different volume might be the best workaround). For "user
stopped it", presumably they don't want to try again (the most likely
reason is "it was taking too damn long").
Put "Exporting to: ...", not "Saving: ..." in the statusbar if we're
doing "export specified packets".
In process_specified_packets(), allow a null range pointer to be
specified, meaning "save 'em all"; that avoids the possibly-expensive
(with a large capture) operation of initializing the range.
If a "safe save" atop an existing file fails or is stopped, get rid of
the temporary file we created.
svn path=/trunk/; revision=43095
2012-06-05 02:46:54 +00:00
|
|
|
cf_write_status_t cf_export_specified_packets(capture_file *cf,
|
|
|
|
const char *fname,
|
|
|
|
packet_range_t *range,
|
|
|
|
guint save_format,
|
2018-11-16 04:06:36 +00:00
|
|
|
wtap_compression_type compression_type);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a displayable name of the capture file.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
2012-06-03 22:03:05 +00:00
|
|
|
* @return the displayable name (must be g_free'd)
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2012-06-03 22:03:05 +00:00
|
|
|
gchar *cf_get_display_name(capture_file *cf);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
2018-07-06 09:06:56 +00:00
|
|
|
/**
|
|
|
|
* Get a name that can be used to generate a file name from the
|
|
|
|
* capture file name. It's based on the displayable name, so it's
|
|
|
|
* UTF-8; if it ends with a suffix that's used by a file type libwiretap
|
|
|
|
* can read, we strip that suffix off.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @return the base name (must be g_free'd)
|
|
|
|
*/
|
|
|
|
gchar *cf_get_basename(capture_file *cf);
|
|
|
|
|
2010-04-01 21:55:01 +00:00
|
|
|
/**
|
|
|
|
* Set the source of the capture data for temporary files, e.g.
|
|
|
|
* "Interface eth0" or "Pipe from Pong"
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param source the source description. this will be copied internally.
|
|
|
|
*/
|
|
|
|
void cf_set_tempfile_source(capture_file *cf, gchar *source);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the source of the capture data for temporary files. Guaranteed to
|
|
|
|
* return a non-null value. The returned value should not be freed.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
*/
|
|
|
|
const gchar *cf_get_tempfile_source(capture_file *cf);
|
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
|
|
|
* Get the number of packets in the capture file.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @return the number of packets in the capture file
|
|
|
|
*/
|
2006-01-22 16:26:41 +00:00
|
|
|
int cf_get_packet_count(capture_file *cf);
|
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
|
|
|
* Is this capture file a temporary file?
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @return TRUE if it's a temporary file, FALSE otherwise
|
|
|
|
*/
|
2005-02-04 01:29:29 +00:00
|
|
|
gboolean cf_is_tempfile(capture_file *cf);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
2005-03-28 14:39:31 +00:00
|
|
|
/**
|
|
|
|
* Set flag, that this file is a tempfile.
|
|
|
|
*/
|
|
|
|
void cf_set_tempfile(capture_file *cf, gboolean is_tempfile);
|
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
|
|
|
* Set flag, if the number of packet drops while capturing are known or not.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @param drops_known TRUE if the number of packet drops are known, FALSE otherwise
|
|
|
|
*/
|
2005-02-04 01:29:29 +00:00
|
|
|
void cf_set_drops_known(capture_file *cf, gboolean drops_known);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the number of packet drops while capturing.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
2013-02-26 04:42:26 +00:00
|
|
|
* @param drops the number of packet drops occurred while capturing
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2005-02-04 01:29:29 +00:00
|
|
|
void cf_set_drops(capture_file *cf, guint32 drops);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
2005-02-28 22:46:49 +00:00
|
|
|
/**
|
|
|
|
* Get flag state, if the number of packet drops while capturing are known or not.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-28 22:46:49 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @return TRUE if the number of packet drops are known, FALSE otherwise
|
|
|
|
*/
|
|
|
|
gboolean cf_get_drops_known(capture_file *cf);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the number of packet drops while capturing.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-28 22:46:49 +00:00
|
|
|
* @param cf the capture file
|
2013-02-26 04:42:26 +00:00
|
|
|
* @return the number of packet drops occurred while capturing
|
2005-02-28 22:46:49 +00:00
|
|
|
*/
|
|
|
|
guint32 cf_get_drops(capture_file *cf);
|
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
|
|
|
* Set the read filter.
|
|
|
|
* @todo this shouldn't be required, remove it somehow
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @param rfcode the readfilter
|
|
|
|
*/
|
2005-02-04 08:27:41 +00:00
|
|
|
void cf_set_rfcode(capture_file *cf, dfilter_t *rfcode);
|
1998-09-16 02:39:15 +00:00
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
|
|
|
* "Display Filter" packets in the capture file.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @param dfilter the display filter
|
|
|
|
* @param force TRUE if do in any case, FALSE only if dfilter changed
|
2005-02-05 12:50:47 +00:00
|
|
|
* @return one of cf_status_t
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2005-02-05 12:50:47 +00:00
|
|
|
cf_status_t cf_filter_packets(capture_file *cf, gchar *dfilter, gboolean force);
|
2004-10-27 23:28:37 +00:00
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
2021-08-28 05:53:51 +00:00
|
|
|
* Scan through all frame data and recalculate the ref time
|
|
|
|
* without rereading the file.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
*/
|
|
|
|
void cf_reftime_packets(capture_file *cf);
|
|
|
|
|
2009-08-30 10:35:48 +00:00
|
|
|
/**
|
2017-06-19 18:48:42 +00:00
|
|
|
* Return the time it took to load the file (in msec).
|
2009-08-30 10:35:48 +00:00
|
|
|
*/
|
2013-08-14 04:14:36 +00:00
|
|
|
gulong cf_get_computed_elapsed(capture_file *cf);
|
2009-08-30 10:35:48 +00:00
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
|
|
|
* "Something" has changed, rescan all packets.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
*/
|
|
|
|
void cf_redissect_packets(capture_file *cf);
|
|
|
|
|
|
|
|
/**
|
2005-02-04 20:54:12 +00:00
|
|
|
* Rescan all packets and just run taps - don't reconstruct the display.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
2005-02-05 12:50:47 +00:00
|
|
|
* @return one of cf_read_status_t
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2009-06-05 22:42:47 +00:00
|
|
|
cf_read_status_t cf_retap_packets(capture_file *cf);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
2017-04-23 23:48:17 +00:00
|
|
|
/* print_range, enum which frames should be printed */
|
|
|
|
typedef enum {
|
|
|
|
print_range_selected_only, /* selected frame(s) only (currently only one) */
|
|
|
|
print_range_marked_only, /* marked frames only */
|
|
|
|
print_range_all_displayed, /* all frames currently displayed */
|
|
|
|
print_range_all_captured /* all frames in capture */
|
|
|
|
} print_range_e;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
print_stream_t *stream; /* the stream to which we're printing */
|
|
|
|
print_format_e format; /* plain text or PostScript */
|
|
|
|
gboolean to_file; /* TRUE if we're printing to a file */
|
|
|
|
char *file; /* file output pathname */
|
|
|
|
char *cmd; /* print command string (not win32) */
|
|
|
|
packet_range_t range;
|
|
|
|
|
|
|
|
gboolean print_summary; /* TRUE if we should print summary line. */
|
|
|
|
gboolean print_col_headings; /* TRUE if we should print column headings */
|
|
|
|
print_dissections_e print_dissections;
|
|
|
|
gboolean print_hex; /* TRUE if we should print hex data;
|
|
|
|
* FALSE if we should print only if not dissected. */
|
2022-01-18 00:26:27 +00:00
|
|
|
guint hexdump_options; /* Hexdump options if print_hex is TRUE. */
|
2017-04-23 23:48:17 +00:00
|
|
|
gboolean print_formfeed; /* TRUE if a formfeed should be printed before
|
|
|
|
* each new packet */
|
|
|
|
} print_args_t;
|
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
|
|
|
* Print the capture file.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @param print_args the arguments what and how to print
|
2016-03-01 02:52:52 +00:00
|
|
|
* @param show_progress_bar TRUE if a progress bar is to be shown
|
2005-02-04 20:54:12 +00:00
|
|
|
* @return one of cf_print_status_t
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2016-03-01 02:52:52 +00:00
|
|
|
cf_print_status_t cf_print_packets(capture_file *cf, print_args_t *print_args,
|
|
|
|
gboolean show_progress_bar);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Print (export) the capture file into PDML format.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @param print_args the arguments what and how to export
|
2005-02-04 20:54:12 +00:00
|
|
|
* @return one of cf_print_status_t
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2005-02-04 20:54:12 +00:00
|
|
|
cf_print_status_t cf_write_pdml_packets(capture_file *cf, print_args_t *print_args);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Print (export) the capture file into PSML format.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @param print_args the arguments what and how to export
|
2005-02-04 20:54:12 +00:00
|
|
|
* @return one of cf_print_status_t
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2005-02-04 20:54:12 +00:00
|
|
|
cf_print_status_t cf_write_psml_packets(capture_file *cf, print_args_t *print_args);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
2005-03-11 20:56:31 +00:00
|
|
|
/**
|
|
|
|
* Print (export) the capture file into CSV format.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param print_args the arguments what and how to export
|
|
|
|
* @return one of cf_print_status_t
|
|
|
|
*/
|
|
|
|
cf_print_status_t cf_write_csv_packets(capture_file *cf, print_args_t *print_args);
|
|
|
|
|
2008-03-11 18:23:16 +00:00
|
|
|
/**
|
|
|
|
* Print (export) the capture file into C Arrays format.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param print_args the arguments what and how to export
|
|
|
|
* @return one of cf_print_status_t
|
|
|
|
*/
|
|
|
|
cf_print_status_t cf_write_carrays_packets(capture_file *cf, print_args_t *print_args);
|
2016-06-19 14:52:50 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Print (export) the capture file into JSON format.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param print_args the arguments what and how to export
|
|
|
|
* @return one of cf_print_status_t
|
|
|
|
*/
|
|
|
|
cf_print_status_t cf_write_json_packets(capture_file *cf, print_args_t *print_args);
|
2008-03-11 18:23:16 +00:00
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
* Find packet with a protocol tree item that contains a specified text string.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @param string the string to find
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
* @param dir direction in which to search
|
2005-02-04 18:44:44 +00:00
|
|
|
* @return TRUE if a packet was found, FALSE otherwise
|
|
|
|
*/
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
gboolean cf_find_packet_protocol_tree(capture_file *cf, const char *string,
|
|
|
|
search_direction dir);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
2011-01-31 12:19:15 +00:00
|
|
|
/**
|
2023-03-22 11:22:06 +00:00
|
|
|
* Find field with a label that contains the text string cfile->sfilter in
|
|
|
|
* a protocol tree.
|
2011-01-31 12:19:15 +00:00
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param tree the protocol tree
|
2023-03-22 11:22:06 +00:00
|
|
|
* @return The first field in the tree that matched the string if found, NULL otherwise
|
2011-01-31 12:19:15 +00:00
|
|
|
*/
|
2023-03-22 11:22:06 +00:00
|
|
|
extern field_info* cf_find_string_protocol_tree(capture_file *cf, proto_tree *tree);
|
2011-01-31 12:19:15 +00:00
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
* Find packet whose summary line contains a specified text string.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @param string the string to find
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
* @param dir direction in which to search
|
2005-02-04 18:44:44 +00:00
|
|
|
* @return TRUE if a packet was found, FALSE otherwise
|
|
|
|
*/
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
gboolean cf_find_packet_summary_line(capture_file *cf, const char *string,
|
|
|
|
search_direction dir);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
|
|
|
/**
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
* Find packet whose data contains a specified byte string.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @param string the string to find
|
|
|
|
* @param string_size the size of the string to find
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
* @param dir direction in which to search
|
2005-02-04 18:44:44 +00:00
|
|
|
* @return TRUE if a packet was found, FALSE otherwise
|
|
|
|
*/
|
|
|
|
gboolean cf_find_packet_data(capture_file *cf, const guint8 *string,
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
size_t string_size, search_direction dir);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Find packet that matches a compiled display filter.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param sfcode the display filter to match
|
|
|
|
* @param dir direction in which to search
|
|
|
|
* @return TRUE if a packet was found, FALSE otherwise
|
|
|
|
*/
|
|
|
|
gboolean cf_find_packet_dfilter(capture_file *cf, dfilter_t *sfcode,
|
|
|
|
search_direction dir);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Find packet that matches a display filter given as a text string.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param filter the display filter to match
|
|
|
|
* @param dir direction in which to search
|
|
|
|
* @return TRUE if a packet was found, FALSE otherwise
|
|
|
|
*/
|
|
|
|
gboolean
|
|
|
|
cf_find_packet_dfilter_string(capture_file *cf, const char *filter,
|
|
|
|
search_direction dir);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Find marked packet.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param dir direction in which to search
|
|
|
|
* @return TRUE if a packet was found, FALSE otherwise
|
|
|
|
*/
|
|
|
|
gboolean cf_find_packet_marked(capture_file *cf, search_direction dir);
|
Get rid of the EBCDIC stuff in the find dialog - it's not supported yet,
so we shouldn't torment the users by offering it.
Check the string type and convert it to an internal representation in
the GUI code; have the search code deal only with the internal
representation.
Save the case-sensitivity flag, and the indication of where string
searches look, along with other search parameters.
Upper-casify the string, for case-insensitive searches, in the GUI code;
don't save the upper-casified string, so it doesn't SHOUT at you when
you next pop up a "find" dialog.
Convert the hex value string to raw binary data in the GUI code, rather
than doing so in the search code. Check that it's a valid string.
Connect the signals to the radio buttons after the pointers have been
attached to various GUI items - the signal handlers expect some of those
pointers to be attached, and aren't happy if they're not.
Have "find_packet()" contain a framework for searching, but not contain
the matching code; instead, pass it a pointer to a matching routine and
an opaque pointer to be passed to the matching routine. Have all the
routines that do different types of searching have their own matching
routines, and use the common "find_packet()" code, rather than
duplicating that code.
Search for the Info column by column type, not by name (the user can
change the name).
When matching on the protocol tree, don't format the entire protocol
tree into a big buffer - just have a routine that matches the text
representation of a protocol tree item against a string, and, if it
finds a match, sets a "we found a match flag" and returns; have that
routine not bother doing any more work if that flag is set.
(Unfortunately, you can't abort "g_node_children_foreach()" in the
middle of a traversal.)
Free the generated display filter code after a find-by-display-filter
finishes.
svn path=/trunk/; revision=8306
2003-08-29 04:03:46 +00:00
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
* Find time-reference packet.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
* @param dir direction in which to search
|
2005-02-04 18:44:44 +00:00
|
|
|
* @return TRUE if a packet was found, FALSE otherwise
|
|
|
|
*/
|
Instead of using a Boolean for the search direction, use an enum, so
that you can tell from examination whether the search is forward or
backward.
Make the cf_find_packet routines take the direction as an explicit
argument, rather than, in the cases where you don't want to permanently
set the direction, saving the direction in the capture_file structure,
changing it, doing the search, and restoring the saved direction. Give
more information in the Doxygen comments for those routines.
Add a cf_find_packet_dfilter_string() routine, which takes a filter
string rather than a compiled filter as an argument. Replace
find_previous_next_frame_with_filter() with it.
Have cf_read_frame_r() and cf_read_frame() pop up the error dialog if
the read fails, rather than leaving that up to its caller. That lets us
eliminate cf_read_error_message(), by swallowing its code into
cf_read_frame_r(). Add Doxygen comments for cf_read_frame_r() and
cf_read_frame().
Don't have find_packet() read the packet before calling the callback
routine; leave that up to the callback routine.
Add cf_find_packet_marked(), to find the next or previous marked packet,
and cf_find_packet_time_reference(), to find the next or previous time
reference packet. Those routines do *not* need to read the packet data
to see if it matches; that lets them run much faster.
Clean up indentation.
svn path=/trunk/; revision=33791
2010-08-13 07:39:46 +00:00
|
|
|
gboolean cf_find_packet_time_reference(capture_file *cf, search_direction dir);
|
2004-01-20 18:47:25 +00:00
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
|
|
|
* GoTo Packet with the given row.
|
2010-05-27 23:55:04 +00:00
|
|
|
*
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param cf the capture file
|
|
|
|
* @param row the row to go to
|
|
|
|
* @return TRUE if this row exists, FALSE otherwise
|
|
|
|
*/
|
|
|
|
gboolean cf_goto_frame(capture_file *cf, guint row);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Go to frame specified by currently selected protocol tree field.
|
|
|
|
* (Go To Corresponding Packet)
|
|
|
|
* @todo this is ugly and should be improved!
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @return TRUE if this packet exists, FALSE otherwise
|
|
|
|
*/
|
|
|
|
gboolean cf_goto_framenum(capture_file *cf);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Select the packet in the given row.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
2022-06-28 12:56:06 +00:00
|
|
|
* @param frame the frame to be selected
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2022-06-28 12:56:06 +00:00
|
|
|
void cf_select_packet(capture_file *cf, frame_data *frame);
|
2005-02-04 18:44:44 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Unselect all packets, if any.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
*/
|
|
|
|
void cf_unselect_packet(capture_file *cf);
|
|
|
|
|
|
|
|
/**
|
2001-12-06 02:21:26 +00:00
|
|
|
* Mark a particular frame in a particular capture.
|
2005-02-04 18:44:44 +00:00
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param frame the frame to be marked
|
2001-12-06 02:21:26 +00:00
|
|
|
*/
|
2005-02-04 18:44:44 +00:00
|
|
|
void cf_mark_frame(capture_file *cf, frame_data *frame);
|
2001-12-06 02:21:26 +00:00
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
2001-12-06 02:21:26 +00:00
|
|
|
* Unmark a particular frame in a particular capture.
|
2005-02-04 18:44:44 +00:00
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param frame the frame to be unmarked
|
2001-12-06 02:21:26 +00:00
|
|
|
*/
|
2005-02-04 18:44:44 +00:00
|
|
|
void cf_unmark_frame(capture_file *cf, frame_data *frame);
|
2001-12-06 02:21:26 +00:00
|
|
|
|
2009-12-17 01:18:14 +00:00
|
|
|
/**
|
|
|
|
* Ignore a particular frame in a particular capture.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param frame the frame to be ignored
|
|
|
|
*/
|
|
|
|
void cf_ignore_frame(capture_file *cf, frame_data *frame);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Unignore a particular frame in a particular capture.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param frame the frame to be unignored
|
|
|
|
*/
|
|
|
|
void cf_unignore_frame(capture_file *cf, frame_data *frame);
|
|
|
|
|
2005-02-04 18:44:44 +00:00
|
|
|
/**
|
2016-12-04 01:57:34 +00:00
|
|
|
* Merge two or more capture files into a temporary file.
|
2005-02-04 18:44:44 +00:00
|
|
|
* @todo is this the right place for this function? It doesn't have to do a lot with capture_file.
|
|
|
|
*
|
2017-01-21 00:05:56 +00:00
|
|
|
* @param pd_window Window pointer suitable for use by delayed_create_progress_dlg.
|
2016-12-04 01:57:34 +00:00
|
|
|
* @param out_filenamep Points to a pointer that's set to point to the
|
|
|
|
* pathname of the temporary file; it's allocated with g_malloc()
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param in_file_count the number of input files to merge
|
2010-08-26 20:31:09 +00:00
|
|
|
* @param in_filenames array of input filenames
|
2005-02-04 18:44:44 +00:00
|
|
|
* @param file_type the output filetype
|
|
|
|
* @param do_append FALSE to merge chronologically, TRUE simply append
|
2005-02-05 14:33:03 +00:00
|
|
|
* @return one of cf_status_t
|
2005-02-04 18:44:44 +00:00
|
|
|
*/
|
2005-02-05 13:44:27 +00:00
|
|
|
cf_status_t
|
2022-02-09 14:32:28 +00:00
|
|
|
cf_merge_files_to_tempfile(gpointer pd_window, const char *temp_dir, char **out_filenamep,
|
2019-08-13 16:41:23 +00:00
|
|
|
int in_file_count, const char *const *in_filenames,
|
2017-01-21 00:05:56 +00:00
|
|
|
int file_type, gboolean do_append);
|
Improve the alert boxes put up for file open/read/write errors. (Some
influence came from
http://developer.apple.com/techpubs/mac/HIGuidelines/HIGuidelines-232.html
which has a section on dialog box and alert box messages. However,
we're largely dealing with technoids, not with The Rest Of Us, so I
didn't go as far as one perhaps should.)
Unfortunately, it looks like it's a bit more work to arrange that, if
you give a bad file name to the "-r" flag, the dialog box pop up only
*after* the main window pops up - it has the annoying habit of popping
up *before* the main window pops up, and sometimes getting *obscured* by
it, when I do that. The removal of the dialog box stuff from
"load_cap_file()" was intended to facilitate that work. (It might also
be nice if, when an open from the "File/Open" menu item fails, we keep
the file selection box open, and give the user a chance to correct
typos, choose another file name, etc.)
svn path=/trunk/; revision=310
1999-06-12 09:10:20 +00:00
|
|
|
|
2012-02-29 16:51:32 +00:00
|
|
|
/**
|
|
|
|
* Update(replace) the comment on a capture from the SHB data block
|
2017-07-17 03:37:32 +00:00
|
|
|
* XXX - should support multiple sections.
|
2012-02-29 16:51:32 +00:00
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param comment the string replacing the old comment
|
|
|
|
*/
|
2017-07-17 03:37:32 +00:00
|
|
|
void cf_update_section_comment(capture_file *cf, gchar *comment);
|
2012-02-29 16:51:32 +00:00
|
|
|
|
2017-07-17 03:49:01 +00:00
|
|
|
/*
|
2021-04-29 11:23:21 +00:00
|
|
|
* Get the packet block for a packet (record).
|
|
|
|
* If the block has been edited, it returns the result of the edit,
|
|
|
|
* otherwise it returns the block from the file.
|
2017-07-17 03:49:01 +00:00
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param fd the frame_data structure for the frame
|
2021-04-29 11:23:21 +00:00
|
|
|
* @returns A block (use wtap_block_unref to free) or NULL if there is none.
|
2017-07-17 03:49:01 +00:00
|
|
|
*/
|
2021-04-29 11:23:21 +00:00
|
|
|
wtap_block_t cf_get_packet_block(capture_file *cf, const frame_data *fd);
|
2013-08-01 20:59:38 +00:00
|
|
|
|
2012-06-20 01:11:01 +00:00
|
|
|
/**
|
2021-04-29 11:23:21 +00:00
|
|
|
* Update(replace) the block on a capture from a frame
|
2012-06-20 01:11:01 +00:00
|
|
|
*
|
|
|
|
* @param cf the capture file
|
2013-08-10 21:31:02 +00:00
|
|
|
* @param fd the frame_data structure for the frame
|
2021-04-29 11:23:21 +00:00
|
|
|
* @param new_block the block replacing the old block
|
Qt: Ensure that add frame comments trigger recoloring, count updates
Add functions to PacketListRecord to invalidate a single record's
colorization and column strings, used for a record is modified in a
way that needs to trigger redrawing, but we don't need to redraw
all packets.
Move the functionality for adding, deleting, and setting frame comments
into PacketListModel, operating on QModelIndexes (or on all physical
rows in the case of deleting all comments from a file.) Trigger
recolorization of any record with an updated comment.
Only set a block as modified when deleting comments if we actually
deleted comments. This avoids marking a file as modified if we
delete all comments from all frames, or all comments from selected
frames, when those comments do not actually have frames.
If cf_set_modified_block is used to modify a block that is already
modified, it can't update the comment count. In that case, return
false and have the callers update the comment count. (It already
has a return value, which is always true.) This avoids having the
GUI warning about saving into a format that doesn't support comments
when comments have been added and then removed.
Note that, unlike with time references and time shifts, there
are no fields (and hence no columns nor color filters) that depend
on whether other fields have comments. If for some reason some
were added, then the model data for all frames would have to be
updated instead. Since there aren't, we don't need to
redrawVisiblePackets, but we do need to drawCurrentPacket to ensure
the packet details are redissected.
Fix #12519
2023-02-09 12:21:55 +00:00
|
|
|
*
|
|
|
|
* @return TRUE if the block is modified for the first time. FALSE if
|
|
|
|
* the block was already modified before, in which case the caller is
|
|
|
|
* responsible for updating the comment count.
|
2012-06-20 01:11:01 +00:00
|
|
|
*/
|
2021-08-22 20:36:50 +00:00
|
|
|
gboolean cf_set_modified_block(capture_file *cf, frame_data *fd, const wtap_block_t new_block);
|
2012-02-29 16:51:32 +00:00
|
|
|
|
2012-06-20 04:44:14 +00:00
|
|
|
/**
|
2013-04-01 20:36:42 +00:00
|
|
|
* What types of comments does this file have?
|
2012-06-20 04:44:14 +00:00
|
|
|
*
|
|
|
|
* @param cf the capture file
|
2013-04-01 20:36:42 +00:00
|
|
|
* @return bitset of WTAP_COMMENT_ values
|
2012-06-20 04:44:14 +00:00
|
|
|
*/
|
2013-04-01 20:36:42 +00:00
|
|
|
guint32 cf_comment_types(capture_file *cf);
|
2012-06-20 04:44:14 +00:00
|
|
|
|
2016-07-18 23:04:22 +00:00
|
|
|
/**
|
|
|
|
* Add a resolved address to this file's list of resolved addresses.
|
|
|
|
*
|
|
|
|
* @param cf the capture file
|
|
|
|
* @param addr a string representing an IPv4 or IPv6 address
|
|
|
|
* @param name a string containing a name corresponding to that address
|
|
|
|
* @return TRUE if it succeeds, FALSE if not
|
|
|
|
*/
|
|
|
|
gboolean cf_add_ip_name_from_string(capture_file *cf, const char *addr, const char *name);
|
|
|
|
|
2011-12-29 00:08:47 +00:00
|
|
|
#ifdef __cplusplus
|
|
|
|
}
|
|
|
|
#endif /* __cplusplus */
|
|
|
|
|
2014-10-14 19:58:21 +00:00
|
|
|
#endif /* file.h */
|