The two functions to start or stop tapping are
-register_tap_listener(char *tapname, void *tapdata, char *fstring,
- void (*reset)(void *tapdata), int (*packet)(void *tapdata,
- packet_info *pinfo, epan_dissect_t *edt, const void *<pointer>),
+register_tap_listener(const char *tapname, void *tapdata, const char *fstring,
+ guint flags,
+ void (*reset)(void *tapdata),
+ gboolean (*packet)(void *tapdata, packet_info *pinfo, epan_dissect_t *edt, const void *<pointer>),
void (*draw)(void *tapdata));
remove_tap_listener(void *tapdata);
to specify a filter string.
ONLY use a filter string if no other option exist.
+flags
+is a set of flags for the tap listener. The flags that can be set are:
+
+ TL_REQUIRES_PROTO_TREE
+
+ set if your tap listener "packet" routine requires a protocol
+ tree to be built. It will require a protocol tree to be
+ built if either
+
+ 1) it looks at the protocol tree in edt->tree
+
+ or
+
+ 2) the tap-specific data passed to it is constructed only if
+ the protocol tree is being built.
+
+ TL_REQUIRES_COLUMNS
+
+ set if your tap listener "packet" routine requires the column
+ strings to be constructed.
+
void (*reset)(void *tapdata)
This callback is called whenever Wireshark wants to inform your
listener that it is about to start [re]reading a capture file or a new capture
from an interface and that your application should reset any state it has
in the *tapdata instance.
-int (*packet)(void *tapdata, packet_info *pinfo, epan_dissect_t *edt, void *data)
+gboolean (*packet)(void *tapdata, packet_info *pinfo, epan_dissect_t *edt, void *data)
This callback is used whenever a new packet has arrived at the tap and that
it has passed the filter (if there were a filter).
The *data structure type is specific to each tap.
-This function returns an int and it should return
- 1, if the data in the packet caused state to be updated
- (and thus a redraw of the window would later be required)
- 0, if we don't need to redraw the window.
+This function returns an gboolean and it should return
+ TRUE, if the data in the packet caused state to be updated
+ (and thus a redraw of the window would later be required)
+ FALSE, if we don't need to redraw the window.
NOTE: that (*packet) should be as fast and efficient as possible. Use this
function ONLY to store data for later and do the CPU-intensive processing
or GUI updates down in (*draw) instead.
ntlmssp_handle = find_dissector("ntlmssp");
gssapi_handle = find_dissector("gssapi");
- stats_tree_register("http","http","HTTP/Packet Counter", http_stats_tree_packet, http_stats_tree_init, NULL );
- stats_tree_register("http","http_req","HTTP/Requests", http_req_stats_tree_packet, http_req_stats_tree_init, NULL );
- stats_tree_register("http","http_srv","HTTP/Load Distribution",http_reqs_stats_tree_packet,http_reqs_stats_tree_init, NULL );
+ stats_tree_register("http","http","HTTP/Packet Counter", 0, http_stats_tree_packet, http_stats_tree_init, NULL );
+ stats_tree_register("http","http_req","HTTP/Requests", 0, http_req_stats_tree_packet, http_req_stats_tree_init, NULL );
+ stats_tree_register("http","http_srv","HTTP/Load Distribution",0,http_reqs_stats_tree_packet,http_reqs_stats_tree_init, NULL );
}
/* Register the stats_tree */
stats_tree_register_with_group("isup", "isup_msg", "ISUP Messages",
- msg_stats_tree_packet, msg_stats_tree_init,
+ 0, msg_stats_tree_packet, msg_stats_tree_init,
NULL, REGISTER_STAT_GROUP_TELEPHONY);
}
}
- error_string=register_tap_listener("dcerpc", &lsa_policy_information_tap_installed, "lsa.policy_information and ( lsa.info.level or lsa.domain or nt.domain_sid )", NULL, lsa_policy_information, NULL);
+ error_string=register_tap_listener("dcerpc",
+ &lsa_policy_information_tap_installed,
+ "lsa.policy_information and ( lsa.info.level or lsa.domain or nt.domain_sid )",
+ TL_REQUIRES_PROTO_TREE, NULL, lsa_policy_information, NULL);
if(error_string){
/* error, we failed to attach to the tap. clean up */
}
lsa_policy_information_tap_installed=TRUE;
- error_string=register_tap_listener("dcerpc", &samr_query_dispinfo_tap_installed, "samr and samr.opnum==40 and ( samr.handle or samr.rid or samr.acct_name or samr.level )", NULL, samr_query_dispinfo, NULL);
+ error_string=register_tap_listener("dcerpc",
+ &samr_query_dispinfo_tap_installed,
+ "samr and samr.opnum==40 and ( samr.handle or samr.rid or samr.acct_name or samr.level )",
+ TL_REQUIRES_PROTO_TREE, NULL, samr_query_dispinfo, NULL);
if(error_string){
/* error, we failed to attach to the tap. clean up */
* security blob has been fully dissected and before
* we exit from this dissector.
*/
- error_string=register_tap_listener("ntlmssp", NULL, NULL, NULL, NULL, NULL);
+ error_string=register_tap_listener("ntlmssp", NULL, NULL,
+ 0, NULL, NULL, NULL);
if(!error_string){
ntlmssp_tap_id=find_tap_id("ntlmssp");
}
* security blob has been fully dissected and before
* we exit from this dissector.
*/
- error_string=register_tap_listener("ntlmssp", NULL, NULL, NULL, NULL, NULL);
+ error_string=register_tap_listener("ntlmssp", NULL, NULL,
+ 0, NULL, NULL, NULL);
if(!error_string){
ntlmssp_tap_id=find_tap_id("ntlmssp");
}
DISSECTOR_ASSERT(gsm_sms_handle);
/* Tapping setup */
- stats_tree_register_with_group("smpp","smpp_commands", st_str_smpp,
+ stats_tree_register_with_group("smpp","smpp_commands", st_str_smpp, 0,
smpp_stats_tree_per_packet, smpp_stats_tree_init,
NULL, REGISTER_STAT_GROUP_TELEPHONY);
}
dissector_add_handle("tcp.port", ucp_handle);
/* Tapping setup */
- stats_tree_register_with_group("ucp", "ucp_messages", st_str_ucp,
+ stats_tree_register_with_group("ucp", "ucp_messages", st_str_ucp, 0,
ucp_stats_tree_per_packet, ucp_stats_tree_init,
NULL, REGISTER_STAT_GROUP_TELEPHONY);
}
h248_param_ber_integer
h248_register_package
have_custom_cols
+have_filtering_tap_listeners
have_tap_listeners
heur_dissector_add
heur_dissector_delete
nstime_to_msec
nstime_to_sec
nt_cmd_vals DATA
-num_tap_filters DATA
num_tree_types DATA
offset_from_real_beginning
oid_add
uat_remove_record_idx
uat_save
uat_swap
+union_of_tap_listener_flags
UnregRejectReason_vals DATA
UnregRequestReason_vals DATA
uri_str_to_bytes
/* register a new stats_tree */
extern void
stats_tree_register_with_group(const char *tapname, const char *abbr, const char *name,
+ guint flags,
stat_tree_packet_cb packet, stat_tree_init_cb init,
stat_tree_cleanup_cb cleanup, register_stat_group_t stat_group)
{
cfg->tapname = g_strdup(tapname);
cfg->abbr = g_strdup(abbr);
cfg->name = name ? g_strdup(name) : g_strdup(abbr);
- cfg->stat_group = stat_group;
+ cfg->stat_group = stat_group;
cfg->packet = packet;
cfg->init = init;
cfg->cleanup = cleanup;
+
+ cfg->flags = flags;
/* these have to be filled in by implementations */
cfg->setup_node_pr = NULL;
/* register a new stats_tree with default group REGISTER_STAT_GROUP_UNSORTED */
extern void
stats_tree_register(const char *tapname, const char *abbr, const char *name,
+ guint flags,
stat_tree_packet_cb packet, stat_tree_init_cb init,
stat_tree_cleanup_cb cleanup)
{
- stats_tree_register_with_group(tapname, abbr, name,
+ stats_tree_register_with_group(tapname, abbr, name,
+ flags,
packet, init,
cleanup, REGISTER_STAT_GROUP_UNSORTED);
}
/* registers a new stats tree with default group REGISTER_STAT_GROUP_UNSORTED
* abbr: protocol abbr
* name: protocol display name
+ * flags: tap listener flags for per-packet callback
* packet: per packet callback
* init: tree initialization callback
* cleanup: cleanup callback
extern void stats_tree_register(const gchar *tapname,
const gchar *abbr,
const gchar *name,
+ guint flags,
stat_tree_packet_cb packet,
stat_tree_init_cb init,
stat_tree_cleanup_cb cleanup);
/* registers a new stats tree
* abbr: protocol abbr
* name: protocol display name
+ * flags: tap listener flags for per-packet callback
* packet: per packet callback
* init: tree initialization callback
* cleanup: cleanup callback
extern void stats_tree_register_with_group(const gchar *tapname,
const gchar *abbr,
const gchar *name,
+ guint flags,
stat_tree_packet_cb packet,
stat_tree_init_cb init,
stat_tree_cleanup_cb cleanup,
- register_stat_group_t stat_group);
+ register_stat_group_t stat_group);
extern int stats_tree_parent_id_by_name(stats_tree *st, const gchar *parent_name);
gchar* abbr;
gchar* name;
gchar* tapname;
- register_stat_group_t stat_group;
+ register_stat_group_t stat_group;
gboolean in_use;
stat_tree_packet_cb packet;
stat_tree_init_cb init;
stat_tree_cleanup_cb cleanup;
+
+ /* tap listener flags for the per-packet callback */
+ guint flags;
/*
* node presentation callbacks
#include <epan/tap.h>
static gboolean tapping_is_active=FALSE;
-int num_tap_filters=0;
typedef struct _tap_dissector_t {
struct _tap_dissector_t *next;
typedef struct _tap_listener_t {
struct _tap_listener_t *next;
int tap_id;
- int needs_redraw;
+ gboolean needs_redraw;
+ guint flags;
dfilter_t *code;
void *tapdata;
tap_reset_cb reset;
for(tl=(tap_listener_t *)tap_listener_queue;tl;tl=tl->next){
tp=&tap_packet_array[i];
if(tp->tap_id==tl->tap_id){
- int passed=TRUE;
+ gboolean passed=TRUE;
if(tl->code){
passed=dfilter_apply_edt(tl->code, edt);
}
if(tl->reset){
tl->reset(tl->tapdata);
}
- tl->needs_redraw=1;
+ tl->needs_redraw=TRUE;
}
}
tl->draw(tl->tapdata);
}
}
- tl->needs_redraw=0;
+ tl->needs_redraw=FALSE;
}
}
* message.
*/
GString *
-register_tap_listener(const char *tapname, void *tapdata, const char *fstring, tap_reset_cb reset, tap_packet_cb packet, tap_draw_cb draw)
+register_tap_listener(const char *tapname, void *tapdata, const char *fstring,
+ guint flags, tap_reset_cb reset, tap_packet_cb packet, tap_draw_cb draw)
{
tap_listener_t *tl;
int tap_id;
tl=g_malloc(sizeof(tap_listener_t));
tl->code=NULL;
- tl->needs_redraw=1;
+ tl->needs_redraw=TRUE;
+ tl->flags=flags;
if(fstring){
if(!dfilter_compile(fstring, &tl->code)){
error_string = g_string_new("");
fstring, dfilter_error_msg);
g_free(tl);
return error_string;
- } else {
- num_tap_filters++;
}
}
if(tl){
if(tl->code){
dfilter_free(tl->code);
- num_tap_filters--;
tl->code=NULL;
}
- tl->needs_redraw=1;
+ tl->needs_redraw=TRUE;
if(fstring){
if(!dfilter_compile(fstring, &tl->code)){
error_string = g_string_new("");
"Filter \"%s\" is invalid - %s",
fstring, dfilter_error_msg);
return error_string;
- } else {
- num_tap_filters++;
}
}
}
if(tl){
if(tl->code){
dfilter_free(tl->code);
- num_tap_filters--;
}
g_free(tl);
}
/*
* Return TRUE if we have tap listeners, FALSE otherwise.
- * Checking "num_tap_filters" isn't the right way to check whether we need
- * to do any dissection in order to run taps, as not all taps necessarily
- * have filters, and "num_tap_filters" is the number of tap filters, not
- * the number of tap listeners; it's only the right way to check whether
- * we need to build a protocol tree when doing dissection.
*/
gboolean
have_tap_listeners(void)
return FALSE;
}
+
+/*
+ * Return TRUE if we have any tap listeners with filters, FALSE otherwise.
+ */
+gboolean
+have_filtering_tap_listeners(void)
+{
+ tap_listener_t *tl;
+
+ for(tl=(tap_listener_t *)tap_listener_queue;tl;tl=tl->next){
+ if(tl->code)
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/*
+ * Get the union of all the flags for all the tap listeners; that gives
+ * an indication of whether the protocol tree, or the columns, are
+ * required by any taps.
+ */
+guint
+union_of_tap_listener_flags(void)
+{
+ tap_listener_t *tl;
+ guint flags = 0;
+
+ for(tl=(tap_listener_t *)tap_listener_queue;tl;tl=tl->next){
+ flags|=tl->flags;
+ }
+ return flags;
+}
#include "epan/epan.h"
-/* With MSVC and a libwireshark.dll, we need a
- * special declaration of num_tap_filters.
- */
-WS_VAR_IMPORT int num_tap_filters;
-
typedef void (*tap_reset_cb)(void *tapdata);
-typedef int (*tap_packet_cb)(void *tapdata, packet_info *pinfo, epan_dissect_t *edt, const void *data);
+typedef gboolean (*tap_packet_cb)(void *tapdata, packet_info *pinfo, epan_dissect_t *edt, const void *data);
typedef void (*tap_draw_cb)(void *tapdata);
+/*
+ * Flags to indicate what a tap listener's packet routine requires.
+ */
+#define TL_REQUIRES_PROTO_TREE 0x00000001 /* full protocol tree */
+#define TL_REQUIRES_COLUMNS 0x00000002 /* columns */
extern void tap_init(void);
extern int register_tap(const char *name);
extern void reset_tap_listeners(void);
extern void draw_tap_listeners(gboolean draw_all);
extern GString *register_tap_listener(const char *tapname, void *tapdata,
- const char *fstring, tap_reset_cb tap_reset, tap_packet_cb tap_packet,
- tap_draw_cb tap_draw);
+ const char *fstring, guint flags, tap_reset_cb tap_reset,
+ tap_packet_cb tap_packet, tap_draw_cb tap_draw);
extern GString *set_tap_dfilter(void *tapdata, const char *fstring);
extern void remove_tap_listener(void *tapdata);
extern gboolean have_tap_listeners(void);
extern gboolean have_tap_listener(int tap_id);
+extern gboolean have_filtering_tap_listeners(void);
+extern guint union_of_tap_listener_flags(void);
extern const void *fetch_tapped_data(int tap_id, int idx);
#endif
if (fake_tap) {
/* a boring tap :-) */
GString* error = register_tap_listener("frame",
- &fake_tap,
- fake_tap_filter->str,
- NULL, NULL, NULL);
+ &fake_tap,
+ fake_tap_filter->str,
+ 0, /* XXX - do we need the protocol tree or columns? */
+ NULL, NULL, NULL);
if (error) {
report_failure("while registering lua_fake_tap:\n%s",error->str);
static gchar* last_error = NULL;
static int repeated = 0;
static int next = 2;
- const gchar* where = (lua_pinfo) ?
- ep_strdup_printf("Lua: on packet %i Error During execution of Listener Packet Callback",lua_pinfo->fd->num) :
- ep_strdup_printf("Lua: Error During execution of Listener Packet Callback") ;
-
+ const gchar* where = (lua_pinfo) ?
+
+ ep_strdup_printf("Lua: on packet %i Error During execution of Listener Packet Callback",lua_pinfo->fd->num) :
+ ep_strdup_printf("Lua: Error During execution of Listener Packet Callback") ;
+
/* show the error the 1st, 3rd, 5th, 9th, 17th, 33th... time it appears to avoid window flooding */
/* XXX the last series of identical errors won't be shown (the user however gets at least one message) */
int lua_tap_packet(void *tapdata, packet_info *pinfo, epan_dissect_t *edt, const void *data) {
Listener tap = tapdata;
int retval = 0;
-
+
if (tap->packet_ref == LUA_NOREF) return 0;
lua_settop(tap->L,0);
push_Pinfo(tap->L, pinfo);
push_Tvb(tap->L, edt->tvb);
- if (tap->extractor) {
- tap->extractor(tap->L,data);
- } else {
- lua_pushnil(tap->L);
- }
-
+ if (tap->extractor) {
+ tap->extractor(tap->L,data);
+ } else {
+ lua_pushnil(tap->L);
+ }
+
lua_pinfo = pinfo;
lua_tvb = edt->tvb;
lua_tree = g_malloc(sizeof(struct _wslua_treeitem));
- lua_tree->tree = edt->tree;
- lua_tree->item = NULL;
- lua_tree->expired = FALSE;
+ lua_tree->tree = edt->tree;
+ lua_tree->item = NULL;
+ lua_tree->expired = FALSE;
switch ( lua_pcall(tap->L,3,1,1) ) {
case 0:
- retval = luaL_optint(tap->L,-1,1);
+ retval = luaL_optint(tap->L,-1,1);
break;
case LUA_ERRRUN:
break;
}
WSLUA_CONSTRUCTOR Listener_new(lua_State* L) {
- /* Creates a new Listener listener */
+ /* Creates a new Listener listener */
#define WSLUA_OPTARG_Listener_new_TAP 1 /* The name of this tap */
#define WSLUA_OPTARG_Listener_new_FILTER 2 /* A filter that when matches the tap.packet function gets called (use nil to be called for every packet) */
const gchar* tap_type = luaL_optstring(L,WSLUA_OPTARG_Listener_new_TAP,"frame");
const gchar* filter = luaL_optstring(L,WSLUA_OPTARG_Listener_new_FILTER,NULL);
- Listener tap;
+ Listener tap;
GString* error;
tap = g_malloc(sizeof(struct _wslua_tap));
- tap->name = g_strdup(tap_type);
+ tap->name = g_strdup(tap_type);
tap->filter = filter ? g_strdup(filter) : NULL;
tap->extractor = wslua_get_tap_extractor(tap_type);
tap->L = L;
tap->draw_ref = LUA_NOREF;
tap->init_ref = LUA_NOREF;
- error = register_tap_listener(tap_type, tap, tap->filter, lua_tap_reset, lua_tap_packet, lua_tap_draw);
+ /*
+ * XXX - do all Lua taps require the protocol tree? If not, it might
+ * be useful to have a way to indicate whether any do.
+ *
+ * XXX - do any Lua taps require the columns? If so, we either need
+ * to request them for this tap, or do so if any Lua taps require them.
+ */
+ error = register_tap_listener(tap_type, tap, tap->filter, TL_REQUIRES_PROTO_TREE, lua_tap_reset, lua_tap_packet, lua_tap_draw);
if (error) {
g_free(tap->filter);
g_free(tap->name);
g_free(tap);
- /* WSLUA_ERROR(new_tap,"tap registration error"); */
+ /* WSLUA_ERROR(new_tap,"tap registration error"); */
luaL_error(L,"Error while registering tap:\n%s",error->str);
g_string_free(error,TRUE); /* XXX LEAK? */
}
}
WSLUA_METHOD Listener_remove(lua_State* L) {
- /* Removes a tap listener */
+ /* Removes a tap listener */
Listener tap = checkListener(L,1);
if (!tap) return 0;
static int Listener_newindex(lua_State* L) {
- /* WSLUA_ATTRIBUTE Listener_packet WO A function that will be called once every packet matches the Listener listener filter.
-
- function tap.packet(pinfo,tvb,userdata) ... end
- */
- /* WSLUA_ATTRIBUTE Listener_draw WO A function that will be called once every few seconds to redraw the gui objects
- in tshark this funtion is called oly at the very end of the capture file.
-
- function tap.draw(userdata) ... end
- */
- /* WSLUA_ATTRIBUTE Listener_reset WO A function that will be called at the end of the capture run.
-
- function tap.reset(userdata) ... end
- */
+ /* WSLUA_ATTRIBUTE Listener_packet WO A function that will be called once every packet matches the Listener listener filter.
+
+ function tap.packet(pinfo,tvb,userdata) ... end
+ */
+ /* WSLUA_ATTRIBUTE Listener_draw WO A function that will be called once every few seconds to redraw the gui objects
+ in tshark this funtion is called oly at the very end of the capture file.
+
+ function tap.draw(userdata) ... end
+ */
+ /* WSLUA_ATTRIBUTE Listener_reset WO A function that will be called at the end of the capture run.
+
+ function tap.reset(userdata) ... end
+ */
Listener tap = shiftListener(L,1);
const gchar* index = lua_shiftstring(L,1);
int* refp = NULL;
};
int Listener_register(lua_State* L) {
- wslua_set_tap_enums(L);
+ wslua_set_tap_enums(L);
WSLUA_REGISTER_CLASS(Listener);
- return 1;
+ return 1;
}
static void cf_reset_state(capture_file *cf);
-static int read_packet(capture_file *cf, dfilter_t *dfcode, gint64 offset);
+static int read_packet(capture_file *cf, dfilter_t *dfcode,
+ gboolean filtering_tap_listeners, guint tap_flags, gint64 offset);
static void rescan_packets(capture_file *cf, const char *action, const char *action_item,
gboolean refilter, gboolean redissect);
volatile gint64 progbar_nextstep;
volatile gint64 progbar_quantum;
dfilter_t *dfcode;
+ gboolean filtering_tap_listeners;
+ guint tap_flags;
#ifdef HAVE_LIBPCAP
volatile int displayed_once = 0;
#endif
dfilter_compile(cf->dfilter, &dfcode);
}
+ /* Do we have any tap listeners with filters? */
+ filtering_tap_listeners = have_filtering_tap_listeners();
+
+ /* Get the union of the flags for all tap listeners. */
+ tap_flags = union_of_tap_listener_flags();
+
cum_bytes=0;
reset_tap_listeners();
break;
}
TRY {
- read_packet(cf, dfcode, data_offset);
+ read_packet(cf, dfcode, filtering_tap_listeners, tap_flags, data_offset);
}
CATCH(OutOfMemoryError) {
gpointer dialog;
gchar *err_info;
volatile int newly_displayed_packets = 0;
dfilter_t *dfcode;
+ gboolean filtering_tap_listeners;
+ guint tap_flags;
/* Compile the current display filter.
* We assume this will not fail since cf->dfilter is only set in
dfilter_compile(cf->dfilter, &dfcode);
}
+ /* Do we have any tap listeners with filters? */
+ filtering_tap_listeners = have_filtering_tap_listeners();
+
+ /* Get the union of the flags for all tap listeners. */
+ tap_flags = union_of_tap_listener_flags();
+
*err = 0;
packet_list_check_end();
break;
}
TRY{
- if (read_packet(cf, dfcode, data_offset) != -1) {
+ if (read_packet(cf, dfcode, filtering_tap_listeners, tap_flags,
+ data_offset) != -1) {
newly_displayed_packets++;
}
}
gchar *err_info;
gint64 data_offset;
dfilter_t *dfcode;
+ gboolean filtering_tap_listeners;
+ guint tap_flags;
/* Compile the current display filter.
* We assume this will not fail since cf->dfilter is only set in
dfilter_compile(cf->dfilter, &dfcode);
}
+ /* Do we have any tap listeners with filters? */
+ filtering_tap_listeners = have_filtering_tap_listeners();
+
+ /* Get the union of the flags for all tap listeners. */
+ tap_flags = union_of_tap_listener_flags();
+
if(cf->wth == NULL) {
cf_close(cf);
return CF_READ_ERROR;
aren't any packets left to read) exit. */
break;
}
- read_packet(cf, dfcode, data_offset);
+ read_packet(cf, dfcode, filtering_tap_listeners, tap_flags, data_offset);
}
/* Cleanup and release all dfilter resources */
static int
add_packet_to_packet_list(frame_data *fdata, capture_file *cf,
- dfilter_t *dfcode,
+ dfilter_t *dfcode, gboolean filtering_tap_listeners,
+ guint tap_flags,
union wtap_pseudo_header *pseudo_header, const guchar *buf,
gboolean refilter)
{
we have a list of color filters;
- we have tap listeners;
+ we have tap listeners with filters;
+
+ we have tap listeners that require a protocol tree;
we have custom columns;
allocate a protocol tree root node, so that we'll construct
a protocol tree against which a filter expression can be
evaluated. */
- if ((dfcode != NULL && refilter) || color_filters_used()
- || num_tap_filters != 0 || have_custom_cols(&cf->cinfo))
+ if ((dfcode != NULL && refilter) || color_filters_used() ||
+ filtering_tap_listeners || (tap_flags & TL_REQUIRES_PROTO_TREE) ||
+ have_custom_cols(&cf->cinfo))
create_proto_tree = TRUE;
/* Dissect the frame. */
/* read in a new packet */
/* returns the row of the new packet in the packet list or -1 if not displayed */
static int
-read_packet(capture_file *cf, dfilter_t *dfcode, gint64 offset)
+read_packet(capture_file *cf, dfilter_t *dfcode,
+ gboolean filtering_tap_listeners, guint tap_flags, gint64 offset)
{
const struct wtap_pkthdr *phdr = wtap_phdr(cf->wth);
union wtap_pseudo_header *pseudo_header = wtap_pseudoheader(cf->wth);
cf->f_datalen = offset + phdr->caplen;
fdata->num = cf->count;
if (!cf->redissecting) {
- row = add_packet_to_packet_list(fdata, cf, dfcode, pseudo_header, buf, TRUE);
+ row = add_packet_to_packet_list(fdata, cf, dfcode,
+ filtering_tap_listeners, tap_flags,
+ pseudo_header, buf, TRUE);
}
} else {
/* XXX - if we didn't have read filters, or if we could avoid
int progbar_nextstep;
int progbar_quantum;
dfilter_t *dfcode;
+ gboolean filtering_tap_listeners;
+ guint tap_flags;
/* Compile the current display filter.
* We assume this will not fail since cf->dfilter is only set in
dfilter_compile(cf->dfilter, &dfcode);
}
+ /* Do we have any tap listeners with filters? */
+ filtering_tap_listeners = have_filtering_tap_listeners();
+
+ /* Get the union of the flags for all tap listeners. */
+ tap_flags = union_of_tap_listener_flags();
+
cum_bytes=0;
reset_tap_listeners();
/* Which frame, if any, is the currently selected frame?
preceding_row = prev_row;
preceding_frame = prev_frame;
}
- row = add_packet_to_packet_list(fdata, cf, dfcode, &cf->pseudo_header, cf->pd,
- refilter);
+ row = add_packet_to_packet_list(fdata, cf, dfcode, filtering_tap_listeners,
+ tap_flags, &cf->pseudo_header, cf->pd,
+ refilter);
/* If this frame is displayed, and this is the first frame we've
seen displayed after the selected frame, remember this frame -
return ret;
}
+typedef struct {
+ gboolean construct_protocol_tree;
+ column_info *cinfo;
+} retap_callback_args_t;
+
static gboolean
retap_packet(capture_file *cf _U_, frame_data *fdata,
union wtap_pseudo_header *pseudo_header, const guint8 *pd,
void *argsp)
{
- column_info *cinfo = argsp;
+ retap_callback_args_t *args = argsp;
epan_dissect_t *edt;
- /* If we have tap listeners, allocate a protocol tree root node, so that
- we'll construct a protocol tree against which a filter expression can
- be evaluated. */
- edt = epan_dissect_new(num_tap_filters != 0, FALSE);
+ edt = epan_dissect_new(args->construct_protocol_tree, FALSE);
tap_queue_init(edt);
- epan_dissect_run(edt, pseudo_header, pd, fdata, cinfo);
+ epan_dissect_run(edt, pseudo_header, pd, fdata, args->cinfo);
tap_push_tapped_queue(edt);
epan_dissect_free(edt);
}
cf_read_status_t
-cf_retap_packets(capture_file *cf, gboolean do_columns)
+cf_retap_packets(capture_file *cf)
{
packet_range_t range;
+ retap_callback_args_t callback_args;
+ gboolean filtering_tap_listeners;
+ guint tap_flags;
+
+ /* Do we have any tap listeners with filters? */
+ filtering_tap_listeners = have_filtering_tap_listeners();
+
+ tap_flags = union_of_tap_listener_flags();
+
+ /* If any tap listeners have filters, or require the protocol tree,
+ construct the protocol tree. */
+ callback_args.construct_protocol_tree = filtering_tap_listeners ||
+ (tap_flags & TL_REQUIRES_PROTO_TREE);
+
+ /* If any tap listeners require the columns, construct them. */
+ callback_args.cinfo = (tap_flags & TL_REQUIRES_COLUMNS) ? &cf->cinfo : NULL;
/* Reset the tap listeners. */
reset_tap_listeners();
re-running the taps. */
packet_range_init(&range);
packet_range_process_init(&range);
- switch (process_specified_packets(cf, &range, "Refiltering statistics on",
+ switch (process_specified_packets(cf, &range, "Recalculating statistics on",
"all packets", TRUE, retap_packet,
- do_columns ? &cf->cinfo : NULL)) {
+ &callback_args)) {
case PSP_FINISHED:
/* Completed successfully. */
return CF_READ_OK;
* Rescan all packets and just run taps - don't reconstruct the display.
*
* @param cf the capture file
- * @param do_columns TRUE if columns are to be generated, FALSE otherwise
* @return one of cf_read_status_t
*/
-cf_read_status_t cf_retap_packets(capture_file *cf, gboolean do_columns);
+cf_read_status_t cf_retap_packets(capture_file *cf);
/**
* The time format has changed, rescan all packets.
}
- error_string=register_tap_listener("afp", ss, filter, afpstat_reset, afpstat_packet, afpstat_draw);
+ error_string=register_tap_listener("afp", ss, filter, 0, afpstat_reset, afpstat_packet, afpstat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(ss->win);
window_present(ss->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(ss->win->window);
}
memset((void *) &ansi_a_stat, 0, sizeof(ansi_a_stat_t));
err_p =
- register_tap_listener("ansi_a", &ansi_a_stat, NULL,
+ register_tap_listener("ansi_a", &ansi_a_stat, NULL, 0,
ansi_a_stat_reset,
ansi_a_stat_packet,
ansi_a_stat_draw);
memset((void *) &ansi_a_stat, 0, sizeof(ansi_map_stat_t));
err_p =
- register_tap_listener("ansi_map", &ansi_a_stat, NULL,
+ register_tap_listener("ansi_map", &ansi_a_stat, NULL, 0,
ansi_map_stat_reset,
ansi_map_stat_packet,
ansi_map_stat_draw);
"bootp",
sp,
filter,
+ 0,
dhcpstat_reset,
dhcpstat_packet,
dhcpstat_draw);
window_present(sp->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(sp->win->window);
}
{
struct camelcounter_t *p_camelcounter;
const char *filter=NULL;
- const char *emptyfilter="";
GString *error_string;
GtkWidget *bbox;
GtkWidget *close_bt;
p_camelcounter->table = create_stat_table(p_camelcounter->scrolled_window, p_camelcounter->vbox, 2, titles);
- if (filter) {
- error_string=register_tap_listener("CAMEL", p_camelcounter, filter,
+ error_string=register_tap_listener("CAMEL", p_camelcounter, filter, 0,
gtk_camelcounter_reset,
gtk_camelcounter_packet,
gtk_camelcounter_draw);
- } else {
- error_string=register_tap_listener("CAMEL", p_camelcounter, emptyfilter,
- gtk_camelcounter_reset,
- gtk_camelcounter_packet,
- gtk_camelcounter_draw);
- }
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
gtk_widget_show_all(p_camelcounter->win);
window_present(p_camelcounter->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(p_camelcounter->win->window);
}
{
struct camelsrt_t * p_camelsrt;
const char *filter=NULL;
- const char *emptyfilter="";
GtkWidget *cmd_label;
GtkWidget *main_label;
val_to_str(i,camelSRTtype_naming,"Unknown"));
}
- if (filter) {
- error_string=register_tap_listener("CAMEL",
- p_camelsrt,
- filter,
- camelsrt_reset,
- camelsrt_packet,
- camelsrt_draw);
- } else {
- error_string=register_tap_listener("CAMEL",
- p_camelsrt,
- emptyfilter,
- camelsrt_reset,
- camelsrt_packet,
- camelsrt_draw);
- }
+ error_string=register_tap_listener("CAMEL",
+ p_camelsrt,
+ filter,
+ 0,
+ camelsrt_reset,
+ camelsrt_packet,
+ camelsrt_draw);
- if(error_string){
- simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
- g_string_free(error_string, TRUE);
+ if(error_string){
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
+ g_string_free(error_string, TRUE);
g_free(p_camelsrt);
return;
}
gtk_widget_show_all(p_camelsrt->win);
window_present(p_camelsrt->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(p_camelsrt->win->window);
}
/* create a Hash to count the packets with the same ip.id */
cs->packet_tree=se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "Packet_info_tree");
- error_string=register_tap_listener("ip", cs, filter, comparestat_reset, comparestat_packet, comparestat_draw);
+ error_string=register_tap_listener("ip", cs, filter, 0, comparestat_reset, comparestat_packet, comparestat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(cs->win);
window_present(cs->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
}
static GtkWidget *dlg=NULL;
ct_create_popup_menu(conversations);
/* register the tap and rerun the taps on the packet list */
- error_string=register_tap_listener(tap_name, conversations, filter, reset_ct_table_data_cb, packet_func, draw_ct_table_data_cb);
+ error_string=register_tap_listener(tap_name, conversations, filter, 0, reset_ct_table_data_cb, packet_func, draw_ct_table_data_cb);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(conversations->win);
window_present(conversations->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(conversations->win->window);
/* Keep clist frozen to cause modifications to the clist (inserts, appends, others that are extremely slow
reset_ct_table_data(conversations);
}
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
if (conversations) {
gdk_window_raise(conversations->win->window);
}
gtk_widget_show_all(win);
window_present(win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(win->window);
/* after retapping, redraw table */
}
- error_string=register_tap_listener("dcerpc", rs, filter, dcerpcstat_reset, dcerpcstat_packet, dcerpcstat_draw);
+ error_string=register_tap_listener("dcerpc", rs, filter, 0, dcerpcstat_reset, dcerpcstat_packet, dcerpcstat_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
gtk_widget_show_all(rs->win);
window_present(rs->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(rs->win->window);
}
init_srt_table(&diameter->diameter_srt_table, 1, vbox, NULL);
init_srt_table_row(&diameter->diameter_srt_table, 0, "Unknown");
- error_string=register_tap_listener("diameter", diameter, filter, diameterstat_reset, diameterstat_packet, diameterstat_draw);
+ error_string=register_tap_listener("diameter", diameter, filter, 0, diameterstat_reset, diameterstat_packet, diameterstat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(diameter->win);
window_present(diameter->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(diameter->win->window);
}
/* Add tap listener functions for expert details, From expert_dlg.c*/
error_string=register_tap_listener("expert", etd, NULL /* fstring */,
+ 0,
expert_dlg_reset,
expert_dlg_packet,
expert_dlg_draw);
/* Register the tap listener */
- error_string=register_tap_listener("expert", ss, filter, error_reset, error_packet, NULL);
+ error_string=register_tap_listener("expert", ss, filter, 0, error_reset, error_packet, NULL);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
* assumes we didn't change anything that would cause any packets to
* dissect differently, and thus doesn't redo the packet display.
*/
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
/* This will bring up the progress bar
* Put our window back in front
}*/
error_string=register_tap_listener("expert", etd, NULL /* fstring */,
+ 0,
expert_dlg_reset,
expert_dlg_packet,
expert_dlg_draw);
gtk_widget_show_all(etd->win);
window_present(etd->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
/* This will bring up the progress bar
* Put our window back in front
object_list = g_malloc0(sizeof(export_object_list_t));
/* Data will be gathered via a tap callback */
- error_msg = register_tap_listener(tapname, object_list, NULL,
+ error_msg = register_tap_listener(tapname, object_list, NULL, 0,
eo_reset,
tap_packet,
eo_draw);
gtk_widget_show_all(object_list->dlg);
window_present(object_list->dlg);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
}
}
- error_string=register_tap_listener("fc", fc, filter, fcstat_reset, fcstat_packet, fcstat_draw);
+ error_string=register_tap_listener("fc", fc, filter, 0, fcstat_reset, fcstat_packet, fcstat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(fc->win);
window_present(fc->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(fc->win->window);
}
{
/* don't register tap listener, if we have it already */
register_tap_listener("frame", &tap_identifier, NULL,
+ TL_REQUIRES_COLUMNS,
flow_graph_reset,
flow_graph_frame_packet,
flow_graph_packet_draw
have_frame_tap_listener=TRUE;
}
- cf_retap_packets(&cfile, TRUE);
+ cf_retap_packets(&cfile);
}
else if (type_of_flow == TCP){
/* Register the tap listener */
{
/* don't register tap listener, if we have it already */
register_tap_listener("tcp", &tap_identifier, NULL,
+ 0,
flow_graph_reset,
flow_graph_tcp_packet,
flow_graph_packet_draw
have_tcp_tap_listener=TRUE;
}
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
}
if (graph_analysis_data->dlg.window != NULL){ /* if we still have a window */
}
/* data will be passed via tap callback*/
- msg = register_tap_listener("ssl", follow_info, follow_filter,
+ msg = register_tap_listener("ssl", follow_info, follow_filter, 0,
NULL, ssl_queue_packet_data, NULL);
if (msg)
{
/* data will be passed via tap callback*/
msg = register_tap_listener("udp_follow", follow_info, follow_filter,
- NULL, udp_queue_packet_data, NULL);
+ 0, NULL, udp_queue_packet_data, NULL);
if (msg) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"Can't register udp_follow tap: %s\n",
}
static void funnel_retap_packets(void) {
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
}
static gboolean funnel_open_file(const char* fname, const char* filter, const char** err_str) {
static void our_menu_callback(void* unused _U_, gpointer data) {
menu_cb_t* mcb = data;
mcb->callback(mcb->callback_data);
- if (mcb->retap) cf_retap_packets(&cfile, FALSE);
+ if (mcb->retap) cf_retap_packets(&cfile);
}
static void register_menu_cb(const char *name,
memset((void *) &gsm_a_stat, 0, sizeof(gsm_a_stat_t));
err_p =
- register_tap_listener("gsm_a", &gsm_a_stat, NULL,
+ register_tap_listener("gsm_a", &gsm_a_stat, NULL, 0,
gsm_a_stat_reset,
gsm_a_stat_packet,
gsm_a_stat_draw);
memset((void *) &gsm_map_stat, 0, sizeof(gsm_map_stat_t));
err_p =
- register_tap_listener("gsm_map", &gsm_map_stat, NULL,
+ register_tap_listener("gsm_map", &gsm_map_stat, NULL, 0,
gsm_map_stat_reset,
gsm_map_stat_packet,
gsm_map_stat_draw);
init_srt_table_row(>p->gtp_srt_table, 2, "Update PDP context");
init_srt_table_row(>p->gtp_srt_table, 3, "Delete PDP context");
- error_string=register_tap_listener("gtp", gtp, filter, gtpstat_reset, gtpstat_packet, gtpstat_draw);
+ error_string=register_tap_listener("gtp", gtp, filter, 0, gtpstat_reset, gtpstat_packet, gtpstat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(gtp->win);
window_present(gtp->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(gtp->win->window);
}
gtk_h225counter_init(const char *optarg, void *userdata _U_)
{
h225counter_t *hs;
- const char *filter=NULL;
GString *error_string;
GtkWidget *bbox;
GtkWidget *close_bt;
+ hs=g_malloc(sizeof(h225counter_t));
+
if(strncmp(optarg,"h225,counter,",13) == 0){
- filter=optarg+13;
+ hs->filter=g_strdup(optarg+13);
} else {
- filter="";
+ hs->filter=NULL;
}
- hs=g_malloc(sizeof(h225counter_t));
- hs->filter=g_strdup(filter);
-
h225counter_reset(hs);
hs->win=window_new(GTK_WINDOW_TOPLEVEL, "Wireshark: H.225 counters");
hs->vbox=gtk_vbox_new(FALSE, 3);
gtk_container_set_border_width(GTK_CONTAINER(hs->vbox), 12);
- init_main_stat_window(hs->win, hs->vbox, "H.225 Message and Message Reason Counter", filter);
+ init_main_stat_window(hs->win, hs->vbox, "H.225 Message and Message Reason Counter", hs->filter);
/* init a scrolled window*/
hs->scrolled_window = scrolled_window_new(NULL, NULL);
hs->table = create_stat_table(hs->scrolled_window, hs->vbox, 2, titles);
- error_string=register_tap_listener("h225", hs, filter, h225counter_reset, h225counter_packet, h225counter_draw);
+ error_string=register_tap_listener("h225", hs, hs->filter, 0, h225counter_reset, h225counter_packet, h225counter_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(hs->win);
window_present(hs->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(hs->win->window);
}
gtk_h225rassrt_init(const char *optarg, void *userdata _U_)
{
h225rassrt_t *hs;
- const char *filter=NULL;
GString *error_string;
GtkWidget *bbox;
GtkWidget *close_bt;
+ hs=g_malloc(sizeof(h225rassrt_t));
+
if(strncmp(optarg,"h225,srt,",9) == 0){
- filter=optarg+9;
+ hs->filter=g_strdup(optarg+9);
} else {
- filter="";
+ hs->filter=NULL;
}
- hs=g_malloc(sizeof(h225rassrt_t));
- hs->filter=g_strdup(filter);
-
h225rassrt_reset(hs);
hs->win=window_new(GTK_WINDOW_TOPLEVEL, "h225-ras-srt");
hs->vbox=gtk_vbox_new(FALSE, 3);
gtk_container_set_border_width(GTK_CONTAINER(hs->vbox), 12);
- init_main_stat_window(hs->win, hs->vbox, "H.225 RAS Service Response Time", filter);
+ init_main_stat_window(hs->win, hs->vbox, "H.225 RAS Service Response Time", hs->filter);
/* init a scrolled window*/
hs->scrolled_window = scrolled_window_new(NULL, NULL);
hs->table = create_stat_table(hs->scrolled_window, hs->vbox, 11, titles);
- error_string=register_tap_listener("h225", hs, filter, h225rassrt_reset, h225rassrt_packet, h225rassrt_draw);
+ error_string=register_tap_listener("h225", hs, hs->filter, 0, h225rassrt_reset, h225rassrt_packet, h225rassrt_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(hs->win);
window_present(hs->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(hs->win->window);
}
hostlist_create_popup_menu(hosttable);
/* register the tap and rerun the taps on the packet list */
- error_string=register_tap_listener(tap_name, hosttable, filter, reset_hostlist_table_data_cb, packet_func, draw_hostlist_table_data_cb);
+ error_string=register_tap_listener(tap_name, hosttable, filter, 0, reset_hostlist_table_data_cb, packet_func, draw_hostlist_table_data_cb);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(hosttable->win);
window_present(hosttable->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(hosttable->win->window);
/* Keep clist frozen to cause modifications to the clist (inserts, appends, others that are extremely slow
reset_hostlist_table_data(hosttable);
}
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
if (hosttable) {
gdk_window_raise(hosttable->win->window);
}
gtk_widget_show_all(win);
window_present(win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(win->window);
/* after retapping, redraw table */
}
enable_graph(dgg);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
dialog_graph_redraw(dgg->ud);
return 0;
val=(long)g_object_get_data(G_OBJECT(item), "tick_interval");
user_data->dlg.dialog_graph.interval=val;
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
dialog_graph_redraw(user_data);
}
unprotect_thread_critical_region();
/* register tap listener */
- error_string = register_tap_listener("IAX2", user_data, NULL,
+ error_string = register_tap_listener("IAX2", user_data, NULL, 0,
iax2_reset, iax2_packet, iax2_draw);
if (error_string != NULL) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
}
/* retap all packets */
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
/* draw statistics info */
draw_stat(user_data);
}
}
return register_tap_listener("frame", gio, real_filter[0]?real_filter:NULL,
+ TL_REQUIRES_PROTO_TREE,
gtk_iostat_reset, gtk_iostat_packet, gtk_iostat_draw);
}
/* build the GUI */
init_io_stat_window(io);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(io->window->window);
io_stat_redraw(io);
}
val=(long)g_object_get_data(G_OBJECT(item), "tick_interval");
io->interval=val;
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(io->window->window);
io_stat_redraw(io);
}
io_stat_reset(gio->io);
enable_graph(gio, filter, field);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(gio->io->window->window);
io_stat_redraw(gio->io);
init_srt_table_row(&ldap->ldap_srt_table, 23, "Extended");
- error_string=register_tap_listener("ldap", ldap, filter, ldapstat_reset, ldapstat_packet, ldapstat_draw);
+ error_string=register_tap_listener("ldap", ldap, filter, 0, ldapstat_reset, ldapstat_packet, ldapstat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(ldap->win);
window_present(ldap->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(ldap->win->window);
}
/* Register the tap listener */
/**********************************************/
- error_string = register_tap_listener("mac-lte", hs, NULL,
+ error_string = register_tap_listener("mac-lte", hs, NULL, 0,
mac_lte_stat_reset,
mac_lte_stat_packet,
mac_lte_stat_draw);
window_present(mac_lte_stat_dlg_w);
/* Retap */
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(mac_lte_stat_dlg_w->window);
}
if (!the_tapinfo_struct.is_registered)
register_tap_listener_mcast_stream();
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
if (!was_registered)
remove_tap_listener_mcast_stream();
GString *error_string;
if (!the_tapinfo_struct.is_registered) {
error_string = register_tap_listener("udp", &the_tapinfo_struct,
- NULL, mcaststream_reset_cb, mcaststream_packet,
+ NULL, 0, mcaststream_reset_cb, mcaststream_packet,
mcaststream_draw);
if (error_string != NULL) {
/* Clean up memory used by stream tap */
mcaststream_reset((mcaststream_tapinfo_t*) mcaststream_get_info());
/* retap all packets */
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
}
gtk_megacostat_init(const char *optarg, void *userdata _U_)
{
megacostat_t *ms;
- const char *filter=NULL;
GString *error_string;
GtkWidget *bt_close;
GtkWidget *bbox;
return;
}
+ ms=g_malloc(sizeof(megacostat_t));
+
if(strncmp(optarg,"megaco,srt,",11) == 0){
- filter=optarg+11;
+ ms->filter=g_strdup(optarg+11);
} else {
- filter="";
+ ms->filter=NULL;
}
- ms=g_malloc(sizeof(megacostat_t));
- ms->filter=g_strdup(filter);
-
megacostat_reset(ms);
ms->win=window_new(GTK_WINDOW_TOPLEVEL, "MEGACO SRT");
ms->vbox=gtk_vbox_new(FALSE, 3);
- init_main_stat_window(ms->win, ms->vbox, "MEGACO Service Response Time (SRT) Statistics", filter);
+ init_main_stat_window(ms->win, ms->vbox, "MEGACO Service Response Time (SRT) Statistics", ms->filter);
/* init a scrolled window*/
ms->scrolled_window = scrolled_window_new(NULL, NULL);
ms->table = create_stat_table(ms->scrolled_window, ms->vbox, 7, titles);
- error_string=register_tap_listener("megaco", ms, filter, megacostat_reset, megacostat_packet, megacostat_draw);
+ error_string=register_tap_listener("megaco", ms, ms->filter, 0, megacostat_reset, megacostat_packet, megacostat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(ms->win);
window_present(ms->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(ms->win->window);
}
gtk_mgcpstat_init(const char *optarg, void *userdata _U_)
{
mgcpstat_t *ms;
- const char *filter=NULL;
GString *error_string;
GtkWidget *bt_close;
GtkWidget *bbox;
+ ms=g_malloc(sizeof(mgcpstat_t));
+
if(strncmp(optarg,"mgcp,srt,",9) == 0){
- filter=optarg+9;
+ ms->filter=g_strdup(optarg+9);
} else {
- filter="";
+ ms->filter=NULL;
}
- ms=g_malloc(sizeof(mgcpstat_t));
- ms->filter=g_strdup(filter);
-
mgcpstat_reset(ms);
ms->win=window_new(GTK_WINDOW_TOPLEVEL, "MGCP SRT");
ms->vbox=gtk_vbox_new(FALSE, 3);
- init_main_stat_window(ms->win, ms->vbox, "MGCP Service Response Time (SRT) Statistics", filter);
+ init_main_stat_window(ms->win, ms->vbox, "MGCP Service Response Time (SRT) Statistics", ms->filter);
/* init a scrolled window*/
ms->scrolled_window = scrolled_window_new(NULL, NULL);
ms->table = create_stat_table(ms->scrolled_window, ms->vbox, 7, titles);
- error_string=register_tap_listener("mgcp", ms, filter, mgcpstat_reset, mgcpstat_packet, mgcpstat_draw);
+ error_string=register_tap_listener("mgcp", ms, ms->filter, 0, mgcpstat_reset, mgcpstat_packet, mgcpstat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(ms->win);
window_present(ms->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(ms->win->window);
}
memset((void *) &mtp3_stat, 0, sizeof(mtp3_stat_t));
err_p =
- register_tap_listener("mtp3", &mtp3_stat, NULL,
+ register_tap_listener("mtp3", &mtp3_stat, NULL, 0,
mtp3_stat_reset,
mtp3_stat_packet,
mtp3_stat_draw);
init_srt_table(&ss->nmas_srt_table, 256, temp_page, "nmas.subverb");
/* Register the tap listener */
- error_string=register_tap_listener("ncp_srt", ss, filter, ncpstat_reset, ncpstat_packet, ncpstat_draw);
+ error_string=register_tap_listener("ncp_srt", ss, filter, 0, ncpstat_reset, ncpstat_packet, ncpstat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_radiusstat_init(const char *optarg, void *userdata _U_)
{
radiusstat_t *rs;
- const char *filter=NULL;
GString *error_string;
GtkWidget *bt_close;
GtkWidget *bbox;
+ rs=g_malloc(sizeof(radiusstat_t));
+
if(strncmp(optarg,"radius,srt,",11) == 0){
- filter=optarg+11;
+ rs->filter=g_strdup(optarg+11);
} else {
- filter="";
+ rs->filter=NULL;
}
- rs=g_malloc(sizeof(radiusstat_t));
- rs->filter=g_strdup(filter);
-
radiusstat_reset(rs);
rs->win=window_new(GTK_WINDOW_TOPLEVEL, "RADIUS SRT");
rs->vbox=gtk_vbox_new(FALSE, 3);
- init_main_stat_window(rs->win, rs->vbox, "RADIUS Service Response Time (SRT) Statistics", filter);
+ init_main_stat_window(rs->win, rs->vbox, "RADIUS Service Response Time (SRT) Statistics", rs->filter);
/* init a scrolled window*/
rs->scrolled_window = scrolled_window_new(NULL, NULL);
rs->table = create_stat_table(rs->scrolled_window, rs->vbox, NUM_COLUMNS, titles);
- error_string=register_tap_listener("radius", rs, filter, radiusstat_reset, radiusstat_packet, radiusstat_draw);
+ error_string=register_tap_listener("radius", rs, rs->filter, 0, radiusstat_reset, radiusstat_packet, radiusstat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(rs->win);
window_present(rs->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(rs->win->window);
}
gtk_table_attach_defaults(GTK_TABLE(table), tmp, 5,6,0,1);
gtk_label_set_justify(GTK_LABEL(tmp), GTK_JUSTIFY_RIGHT);
- error_string=register_tap_listener("rpc", win, NULL, rpcprogs_reset, rpcprogs_packet, rpcprogs_draw);
+ error_string=register_tap_listener("rpc", win, NULL, 0, rpcprogs_reset, rpcprogs_packet, rpcprogs_draw);
if(error_string){
fprintf(stderr, "wireshark: Couldn't register rpc,programs tap: %s\n",
error_string->str);
gtk_widget_show_all(win);
window_present(win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(win->window);
}
}
- error_string=register_tap_listener("rpc", rs, filter, rpcstat_reset, rpcstat_packet, rpcstat_draw);
+ error_string=register_tap_listener("rpc", rs, filter, 0, rpcstat_reset, rpcstat_packet, rpcstat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(rs->win);
window_present(rs->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(rs->win->window);
}
return 0;
}
- enable_graph(dgg);
- cf_retap_packets(&cfile, FALSE);
+ enable_graph(dgg);
+ cf_retap_packets(&cfile);
dialog_graph_redraw(dgg->ud);
return 0;
val=(long)g_object_get_data(G_OBJECT(item), "tick_interval");
user_data->dlg.dialog_graph.interval=val;
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
dialog_graph_redraw(user_data);
}
unprotect_thread_critical_region();
/* register tap listener */
- error_string = register_tap_listener("rtp", user_data, NULL,
+ error_string = register_tap_listener("rtp", user_data, NULL, 0,
rtp_reset, rtp_packet, rtp_draw);
if (error_string != NULL) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
}
/* retap all packets */
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
/* draw statistics info */
draw_stat(user_data);
register_tap_listener_rtp_stream();
the_tapinfo_struct.mode = TAP_ANALYSE;
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
if (!was_registered)
remove_tap_listener_rtp_stream();
the_tapinfo_struct.mode = TAP_SAVE;
the_tapinfo_struct.filter_stream_fwd = stream;
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
the_tapinfo_struct.mode = TAP_ANALYSE;
if (!was_registered)
the_tapinfo_struct.mode = TAP_MARK;
the_tapinfo_struct.filter_stream_fwd = stream_fwd;
the_tapinfo_struct.filter_stream_rev = stream_rev;
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
the_tapinfo_struct.mode = TAP_ANALYSE;
if (!was_registered)
if (!the_tapinfo_struct.is_registered) {
error_string = register_tap_listener("rtp", &the_tapinfo_struct,
- NULL, rtpstream_reset_cb, rtpstream_packet,
+ NULL, 0, rtpstream_reset_cb, rtpstream_packet,
rtpstream_draw);
if (error_string != NULL) {
}
- error_string=register_tap_listener("scsi", rs, filter, scsistat_reset, scsistat_packet, scsistat_draw);
+ error_string=register_tap_listener("scsi", rs, filter, 0, scsistat_reset, scsistat_packet, scsistat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(rs->win);
window_present(rs->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(rs->win->window);
}
u_data->analyse_nb = NULL;
u_data->window = NULL;
u_data->num_children = 0;
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
sctp_analyse_cb(u_data, TRUE);
sctp_set_filter(NULL, u_data);
}
u_data->window = NULL;
u_data->num_children = 0;
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
sctp_analyse_cb(u_data, FALSE);
}
sctpstat_init(const char *optarg, void *userdata _U_)
{
sctpstat_t *hs;
- const char *filter=NULL;
GString *error_string;
GtkWidget *bbox;
GtkWidget *close_bt;
+ hs=g_malloc(sizeof(sctpstat_t));
if(strncmp(optarg,"sctp,stat,",10) == 0){
- filter=optarg+10;
+ hs->filter=g_strdup(optarg+10);
} else {
- filter="";
+ hs->filter=NULL;
}
-
- hs=g_malloc(sizeof(sctpstat_t));
- hs->filter=g_strdup(filter);
hs->ep_list = NULL;
hs->number_of_packets = 0;
sctpstat_reset(hs);
hs->vbox=gtk_vbox_new(FALSE, 3);
gtk_container_set_border_width(GTK_CONTAINER(hs->vbox), 12);
- init_main_stat_window(hs->win, hs->vbox, "SCTP Chunk Counter", filter);
+ init_main_stat_window(hs->win, hs->vbox, "SCTP Chunk Counter", hs->filter);
/* init a scrolled window*/
hs->scrolled_window = scrolled_window_new(NULL, NULL);
hs->table = create_stat_table(hs->scrolled_window, hs->vbox, 15, titles);
- error_string=register_tap_listener("sctp", hs, filter,
+ error_string=register_tap_listener("sctp", hs, hs->filter, 0,
sctpstat_reset,
sctpstat_packet,
sctpstat_draw);
gtk_widget_show_all(hs->win);
window_present(hs->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
}
void
g_signal_connect(bt_close, "clicked", G_CALLBACK(sctp_chunk_stat_on_close), u_data);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
}
if (!sctp_tapinfo_struct.is_registered)
{
- if ((error_string = register_tap_listener("sctp", &sctp_tapinfo_struct, NULL, reset, packet, sctp_update))) {
+ if ((error_string = register_tap_listener("sctp", &sctp_tapinfo_struct, NULL, 0, reset, packet, sctp_update))) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
return;
g_signal_connect(bt_analyse, "clicked", G_CALLBACK(sctp_stat_on_analyse), NULL);
sctp_stat_dlg = sctp_stat_dlg_w;
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(sctp_stat_dlg_w->window);
}
error_string = register_tap_listener("sip",
sp,
filter,
+ 0,
sipstat_reset,
sipstat_packet,
sipstat_draw);
window_present(sp->win);
sip_init_hash(sp);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(sp->win->window);
}
}
- error_string=register_tap_listener("smb2", ss, filter, smb2stat_reset, smb2stat_packet, smb2stat_draw);
+ error_string=register_tap_listener("smb2", ss, filter, 0, smb2stat_reset, smb2stat_packet, smb2stat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(ss->win);
window_present(ss->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(ss->win->window);
}
}
- error_string=register_tap_listener("smb", ss, filter, smbstat_reset, smbstat_packet, smbstat_draw);
+ error_string=register_tap_listener("smb", ss, filter, 0, smbstat_reset, smbstat_packet, smbstat_draw);
if(error_string){
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free(error_string, TRUE);
gtk_widget_show_all(ss->win);
window_present(ss->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(ss->win->window);
}
error_string = register_tap_listener( cfg->tapname,
st,
st->filter,
+ cfg->flags,
reset_tap,
stats_tree_packet,
draw_gtk_tree);
gtk_widget_show_all(st->pr->win);
window_present(st->pr->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(st->pr->win->window);
}
ts.current=¤t;
ts.g=g;
ts.last=NULL;
- error_string=register_tap_listener("tcp", &ts, "tcp", NULL, tapall_tcpip_packet, NULL);
+ error_string=register_tap_listener("tcp", &ts, "tcp", 0, NULL, tapall_tcpip_packet, NULL);
if(error_string){
fprintf(stderr, "wireshark: Couldn't register tcp_graph tap: %s\n",
error_string->str);
g_string_free(error_string, TRUE);
exit(1);
}
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
remove_tap_listener(&ts);
}
}
- error_string=register_tap_listener("tcp", &th, NULL, NULL, tap_tcpip_packet, NULL);
+ error_string=register_tap_listener("tcp", &th, NULL, 0, NULL, tap_tcpip_packet, NULL);
if(error_string){
fprintf(stderr, "wireshark: Couldn't register tcp_graph tap: %s\n",
error_string->str);
{
error_string = register_tap_listener("rtpevent", &(the_tapinfo_rtp_struct.rtp_event_dummy),
NULL,
+ 0,
NULL,
rtp_event_packet,
NULL
{
/* don't register tap listener, if we have it already */
error_string = register_tap_listener("rtp", &(the_tapinfo_rtp_struct.rtp_dummy), NULL,
+ 0,
voip_rtp_reset,
RTP_packet,
RTP_packet_draw
{
/* don't register tap listener, if we have it already */
error_string = register_tap_listener("t38", &(the_tapinfo_struct.t38_dummy), NULL,
+ 0,
voip_calls_dlg_reset,
T38_packet,
voip_calls_dlg_draw
{
/* don't register tap listener, if we have it already */
error_string = register_tap_listener("sip", &(the_tapinfo_struct.sip_dummy), NULL,
+ 0,
voip_calls_dlg_reset,
SIPcalls_packet,
voip_calls_dlg_draw
{
error_string = register_tap_listener("isup", &(the_tapinfo_struct.isup_dummy),
NULL,
+ 0,
voip_calls_dlg_reset,
isup_calls_packet,
voip_calls_dlg_draw
{
error_string = register_tap_listener("mtp3", &(the_tapinfo_struct.mtp3_dummy),
NULL,
+ 0,
voip_calls_dlg_reset,
mtp3_calls_packet,
voip_calls_dlg_draw
if(have_m3ua_tap_listener==FALSE)
{
error_string = register_tap_listener("m3ua", &(the_tapinfo_struct.mtp3_dummy),
- NULL,
- voip_calls_dlg_reset,
- mtp3_calls_packet,
- voip_calls_dlg_draw
- );
+ NULL,
+ 0,
+ voip_calls_dlg_reset,
+ mtp3_calls_packet,
+ voip_calls_dlg_draw
+ );
if (error_string != NULL) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
{
error_string = register_tap_listener("q931", &(the_tapinfo_struct.q931_dummy),
NULL,
+ 0,
voip_calls_dlg_reset,
q931_calls_packet,
voip_calls_dlg_draw
{
/* don't register tap listener, if we have it already */
error_string = register_tap_listener("h225", &(the_tapinfo_struct.h225_dummy), NULL,
+ 0,
voip_calls_dlg_reset,
H225calls_packet,
voip_calls_dlg_draw
{
/* don't register tap listener, if we have it already */
error_string = register_tap_listener("h245dg", &(the_tapinfo_struct.h245dg_dummy), NULL,
+ 0,
voip_calls_dlg_reset,
H245dgcalls_packet,
voip_calls_dlg_draw
{
/* don't register tap listener, if we have it already */
error_string = register_tap_listener("sdp", &(the_tapinfo_struct.sdp_dummy), NULL,
+ 0,
voip_calls_dlg_reset,
SDPcalls_packet,
voip_calls_dlg_draw
/* don't register tap listener, if we have it already */
/* we send an empty filter, to force a non null "tree" in the mgcp dissector */
error_string = register_tap_listener("mgcp", &(the_tapinfo_struct.mgcp_dummy), g_strdup(""),
+ 0,
voip_calls_dlg_reset,
MGCPcalls_packet,
voip_calls_dlg_draw
{
/* don't register tap listener, if we have it already */
error_string = register_tap_listener("actrace", &(the_tapinfo_struct.actrace_dummy), NULL,
+ 0,
voip_calls_dlg_reset,
ACTRACEcalls_packet,
voip_calls_dlg_draw
if(have_megaco_tap_listener==FALSE)
{
error_string = register_tap_listener("megaco", &(the_tapinfo_struct.megaco_dummy),
- NULL,
- voip_calls_dlg_reset,
- h248_calls_packet,
- voip_calls_dlg_draw);
+ NULL,
+ 0,
+ voip_calls_dlg_reset,
+ h248_calls_packet,
+ voip_calls_dlg_draw);
if (error_string != NULL) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
if(have_h248_tap_listener==FALSE)
{
error_string = register_tap_listener("h248", &(the_tapinfo_struct.h248_dummy),
- NULL,
- voip_calls_dlg_reset,
- h248_calls_packet,
- voip_calls_dlg_draw);
+ NULL,
+ 0,
+ voip_calls_dlg_reset,
+ h248_calls_packet,
+ voip_calls_dlg_draw);
if (error_string != NULL) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
if(have_sccp_tap_listener==FALSE)
{
error_string = register_tap_listener("sccp", &(the_tapinfo_struct.sccp_dummy),
- NULL,
- voip_calls_dlg_reset,
- sccp_calls_packet,
- voip_calls_dlg_draw);
+ NULL,
+ 0,
+ voip_calls_dlg_reset,
+ sccp_calls_packet,
+ voip_calls_dlg_draw);
if (error_string != NULL) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
if(have_sua_tap_listener==FALSE)
{
error_string = register_tap_listener("sua", &(the_tapinfo_struct.sua_dummy),
- NULL,
- voip_calls_dlg_reset,
- sua_calls_packet,
- voip_calls_dlg_draw);
+ NULL,
+ 0,
+ voip_calls_dlg_reset,
+ sua_calls_packet,
+ voip_calls_dlg_draw);
if (error_string != NULL) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
error_string = register_tap_listener("unistim", &(the_tapinfo_struct.unistim_dummy),
NULL,
+ 0,
voip_calls_dlg_reset,
unistim_calls_packet,
voip_calls_dlg_draw
/* don't register tap listener, if we have it already */
/* we send an empty filter, to force a non null "tree" in the SKINNY dissector */
error_string = register_tap_listener("skinny", &(the_tapinfo_struct.skinny_dummy), g_strdup(""),
+ 0,
voip_calls_dlg_reset,
skinny_calls_packet,
voip_calls_dlg_draw
/* don't register tap listener, if we have it already */
/* we send an empty filter, to force a non null "tree" in the IAX2 dissector */
error_string = register_tap_listener("IAX2", &(the_tapinfo_struct.iax2_dummy), g_strdup(""),
+ 0,
voip_calls_dlg_reset,
iax2_calls_packet,
voip_calls_dlg_draw
{
error_string = register_tap_listener("voip", &(the_tapinfo_struct.voip_dummy),
NULL,
+ 0,
voip_calls_dlg_reset,
VoIPcalls_packet,
voip_calls_dlg_draw
{
error_string = register_tap_listener("prot_", &(the_tapinfo_struct.prot__dummy),
NULL,
+ 0,
voip_calls_dlg_reset,
prot__calls_packet,
voip_calls_dlg_draw
gtk_clist_append(GTK_CLIST(clist), data);
/* Scan for VoIP calls calls (redissect all packets) */
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(voip_calls_dlg->window);
/* Tap listener will be removed and cleaned up in voip_calls_on_destroy */
}
hs->use_dfilter = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (widget));
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(wlanstat_dlg_w->window);
}
wlan_create_popup_menu(hs);
wlan_details_create_popup_menu(hs);
- error_string=register_tap_listener ("wlan", hs, NULL, wlanstat_reset,
- wlanstat_packet, wlanstat_draw);
+ error_string=register_tap_listener ("wlan", hs, NULL, 0,
+ wlanstat_reset, wlanstat_packet,
+ wlanstat_draw);
if (error_string) {
simple_dialog (ESD_TYPE_ERROR, ESD_BTN_OK, "%s", error_string->str);
g_string_free (error_string, TRUE);
gtk_widget_show_all (wlanstat_dlg_w);
window_present (wlanstat_dlg_w);
- cf_retap_packets (&cfile, FALSE);
+ cf_retap_packets (&cfile);
gdk_window_raise(wlanstat_dlg_w->window);
}
"wsp",
sp,
filter,
+ 0,
wspstat_reset,
wspstat_packet,
wspstat_draw);
gtk_widget_show_all(sp->win);
window_present(sp->win);
- cf_retap_packets(&cfile, FALSE);
+ cf_retap_packets(&cfile);
gdk_window_raise(sp->win->window);
}
register_init_routine(initialize_mate_runtime);
tap_error = register_tap_listener("frame", &mate_tap_data,
- (char*) mc->tap_filter,
- (tap_reset_cb) NULL,
- mate_packet,
- (tap_draw_cb) NULL);
+ (char*) mc->tap_filter,
+ 0,
+ (tap_reset_cb) NULL,
+ mate_packet,
+ (tap_draw_cb) NULL);
if ( tap_error ) {
g_warning("mate: couldn't (re)register tap: %s",tap_error->str);
/* register all pinfo trees */
void register_pinfo_stat_trees(void) {
- stats_tree_register("ip","ip_hosts",st_str_ip, ip_hosts_stats_tree_packet, ip_hosts_stats_tree_init, NULL );
- stats_tree_register("ip","ptype",st_str_ptype, ptype_stats_tree_packet, ptype_stats_tree_init, NULL );
- stats_tree_register_with_group("frame","plen",st_str_plen, plen_stats_tree_packet, plen_stats_tree_init, NULL, REGISTER_STAT_GROUP_GENERIC );
- stats_tree_register("ip","dests",st_str_dsts, dsts_stats_tree_packet, dsts_stats_tree_init, NULL );
+ stats_tree_register("ip","ip_hosts",st_str_ip, 0, ip_hosts_stats_tree_packet, ip_hosts_stats_tree_init, NULL );
+ stats_tree_register("ip","ptype",st_str_ptype, 0, ptype_stats_tree_packet, ptype_stats_tree_init, NULL );
+ stats_tree_register_with_group("frame","plen",st_str_plen, 0, plen_stats_tree_packet, plen_stats_tree_init, NULL, REGISTER_STAT_GROUP_GENERIC );
+ stats_tree_register("ip","dests",st_str_dsts, 0, dsts_stats_tree_packet, dsts_stats_tree_init, NULL );
}
rs->filter=field;
rs->cmd_line_index = g_cmd_line_index++;
- error_string=register_tap_listener("frame", rs, rs->filter, NULL, protocolinfo_packet, NULL);
+ error_string=register_tap_listener("frame", rs, rs->filter, TL_REQUIRES_PROTO_TREE, NULL, protocolinfo_packet, NULL);
if(error_string){
/* error, we failed to attach to the tap. complain and clean up */
fprintf(stderr, "rawshark: Couldn't register field extraction tap: %s\n",
ss->proc[i].tot.nsecs=0;
}
- error_string=register_tap_listener("afp", ss, filter, NULL, afpstat_packet, afpstat_draw);
+ error_string=register_tap_listener("afp", ss, filter, 0, NULL, afpstat_packet, afpstat_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
g_free(ss->filter);
memset(stat_p, 0, sizeof(ansi_a_stat_t));
err_p =
- register_tap_listener("ansi_a", stat_p, NULL,
+ register_tap_listener("ansi_a", stat_p, NULL, 0,
NULL,
ansi_a_stat_packet,
ansi_a_stat_draw);
"bootp",
sp,
filter,
+ 0,
dhcpstat_reset,
dhcpstat_packet,
dhcpstat_draw);
static void camelcounter_init(const char *optarg, void* userdata _U_)
{
struct camelcounter_t *p_camelcounter;
- const char *filter=NULL;
- const char *emptyfilter="";
GString *error_string;
- if(!strncmp(optarg,"camel,counter,",13)){
- filter=optarg+13;
- } else {
- filter=NULL;
- }
-
p_camelcounter = g_malloc(sizeof(struct camelcounter_t));
- if(filter){
- p_camelcounter->filter=g_strdup(filter);
+ if(!strncmp(optarg,"camel,counter,",13)){
+ p_camelcounter->filter=g_strdup(optarg+13);
} else {
p_camelcounter->filter=NULL;
}
camelcounter_reset(p_camelcounter);
- if (filter) {
- error_string=register_tap_listener("CAMEL",
- p_camelcounter,
- filter,
- NULL,
- camelcounter_packet,
- camelcounter_draw);
- } else {
- error_string=register_tap_listener("CAMEL",
- p_camelcounter,
- emptyfilter,
- NULL,
- camelcounter_packet,
- camelcounter_draw);
- }
+ error_string=register_tap_listener("CAMEL",
+ p_camelcounter,
+ p_camelcounter->filter,
+ 0,
+ NULL,
+ camelcounter_packet,
+ camelcounter_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
static void camelsrt_init(const char *optarg, void* userdata _U_)
{
struct camelsrt_t *p_camelsrt;
- const char *filter=NULL;
- const char *emptyfilter="";
-
GString *error_string;
- if(!strncmp(optarg,"camel,srt,",9)){
- filter=optarg+9;
- } else {
- filter=NULL;
- }
-
p_camelsrt = g_malloc(sizeof(struct camelsrt_t));
- if(filter){
- p_camelsrt->filter=g_strdup(filter);
+ if(!strncmp(optarg,"camel,srt,",9)){
+ p_camelsrt->filter=g_strdup(optarg+9);
} else {
p_camelsrt->filter=NULL;
}
camelsrt_reset(p_camelsrt);
- if (filter) {
- error_string=register_tap_listener("CAMEL",
- p_camelsrt,
- filter,
- NULL,
- camelsrt_packet,
- camelsrt_draw);
- } else {
- error_string=register_tap_listener("CAMEL",
- p_camelsrt,
- emptyfilter,
- NULL,
- camelsrt_packet,
- camelsrt_draw);
- }
+ error_string=register_tap_listener("CAMEL",
+ p_camelsrt,
+ p_camelsrt->filter,
+ 0,
+ NULL,
+ camelsrt_packet,
+ camelsrt_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
/* create a Hash to count the packets with the same ip.id */
cs->packet_tree=se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "Packet_info_tree");
- error_string=register_tap_listener("ip", cs, filter, comparestat_reset, comparestat_packet, comparestat_draw);
+ error_string=register_tap_listener("ip", cs, filter, 0, comparestat_reset, comparestat_packet, comparestat_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
g_free(cs->filter);
rs->procedures[i].tot.nsecs=0;
}
- error_string=register_tap_listener("dcerpc", rs, filter, NULL, dcerpcstat_packet, dcerpcstat_draw);
+ error_string=register_tap_listener("dcerpc", rs, filter, 0, NULL, dcerpcstat_packet, dcerpcstat_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
g_free(rs->procedures);
memset(stat_p, 0, sizeof(gsm_a_stat_t));
err_p =
- register_tap_listener("gsm_a", stat_p, NULL,
+ register_tap_listener("gsm_a", stat_p, NULL, 0,
NULL,
gsm_a_stat_packet,
gsm_a_stat_draw);
h225counter_init(const char *optarg, void* userdata _U_)
{
h225counter_t *hs;
- const char *filter=NULL;
GString *error_string;
+ hs = g_malloc(sizeof(h225counter_t));
if(!strncmp(optarg,"h225,counter,",13)){
- filter=optarg+13;
+ hs->filter=g_strdup(optarg+13);
} else {
- filter="";
+ hs->filter=NULL;
}
- hs = g_malloc(sizeof(h225counter_t));
- hs->filter=g_strdup(filter);
-
h225counter_reset(hs);
- error_string=register_tap_listener("h225", hs, filter, NULL, h225counter_packet, h225counter_draw);
+ error_string=register_tap_listener("h225", hs, hs->filter, 0, NULL, h225counter_packet, h225counter_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
g_free(hs->filter);
h225rassrt_init(const char *optarg, void* userdata _U_)
{
h225rassrt_t *hs;
- const char *filter=NULL;
GString *error_string;
+ hs = g_malloc(sizeof(h225rassrt_t));
if(!strncmp(optarg,"h225,srt,",9)){
- filter=optarg+9;
+ hs->filter=g_strdup(optarg+9);
} else {
- filter="";
+ hs->filter=NULL;
}
- hs = g_malloc(sizeof(h225rassrt_t));
- hs->filter=g_strdup(filter);
-
h225rassrt_reset(hs);
- error_string=register_tap_listener("h225", hs, filter, NULL, h225rassrt_packet, h225rassrt_draw);
+ error_string=register_tap_listener("h225", hs, hs->filter, 0, NULL, h225rassrt_packet, h225rassrt_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
g_free(hs->filter);
"http",
sp,
filter,
+ 0,
httpstat_reset,
httpstat_packet,
httpstat_draw);
static int
-iostat_packet(void *arg, packet_info *pinfo, epan_dissect_t *edt _U_, const void *dummy _U_)
+iostat_packet(void *arg, packet_info *pinfo, epan_dissect_t *edt, const void *dummy _U_)
{
io_stat_item_t *mit = arg;
io_stat_item_t *it;
io->filters[i]=filter;
flt=filter;
- if(!filter){
- filter="";
- }
field=NULL;
hfi=NULL;
for(j=0; calc_type_table[j].func_name; j++){
namelen=strlen(calc_type_table[j].func_name);
- if(strncmp(filter, calc_type_table[j].func_name, namelen) == 0
+ if(filter
+ && strncmp(filter, calc_type_table[j].func_name, namelen) == 0
&& *(filter+namelen)=='('){
io->items[i].calc_type=calc_type_table[j].calc_type;
CALC_TYPE_AVG 5
*/
- error_string=register_tap_listener("frame", &io->items[i], flt, NULL, iostat_packet, i?NULL:iostat_draw);
+ error_string=register_tap_listener("frame", &io->items[i], flt, TL_REQUIRES_PROTO_TREE, NULL, iostat_packet, i?NULL:iostat_draw);
if(error_string){
g_free(io->items);
g_free(io);
printf("================================================================================\n");
}
-void
+static void
iousers_init(const char *optarg, void* userdata _U_)
{
const char *filter=NULL;
iu->filter=NULL;
}
- error_string=register_tap_listener(tap_type, iu, filter, NULL, packet_func, iousers_draw);
+ error_string=register_tap_listener(tap_type, iu, filter, 0, NULL, packet_func, iousers_draw);
if(error_string){
if(iu->items){
g_free(iu->items);
{
megacostat_t *ms;
int i;
- const char *filter=NULL;
GString *error_string;
pref_t *megaco_ctx_track,*h248_ctx_track;
exit(1);
}
+ ms=g_malloc(sizeof(megacostat_t));
if(!strncmp(optarg,"megaco,rtd,",11)){
- filter=optarg+11;
+ ms->filter=g_strdup(optarg+11);
} else {
- filter="";
+ ms->filter=NULL;
}
- ms=g_malloc(sizeof(megacostat_t));
- ms->filter=g_strdup(filter);
-
for(i=0;i<NUM_TIMESTATS;i++) {
ms->rtd[i].num=0;
ms->rtd[i].min_num=0;
ms->req_dup_num=0;
ms->rsp_dup_num=0;
- error_string=register_tap_listener("megaco", ms, filter, NULL, megacostat_packet, megacostat_draw);
+ error_string=register_tap_listener("megaco", ms, ms->filter, 0, NULL, megacostat_packet, megacostat_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
g_free(ms->filter);
{
mgcpstat_t *ms;
int i;
- const char *filter=NULL;
GString *error_string;
+ ms=g_malloc(sizeof(mgcpstat_t));
if(!strncmp(optarg,"mgcp,rtd,",9)){
- filter=optarg+9;
+ ms->filter=g_strdup(optarg+9);
} else {
- filter="";
+ ms->filter=NULL;
}
- ms=g_malloc(sizeof(mgcpstat_t));
- ms->filter=g_strdup(filter);
-
for(i=0;i<NUM_TIMESTATS;i++) {
ms->rtd[i].num=0;
ms->rtd[i].min_num=0;
ms->req_dup_num=0;
ms->rsp_dup_num=0;
- error_string=register_tap_listener("mgcp", ms, filter, NULL, mgcpstat_packet, mgcpstat_draw);
+ error_string=register_tap_listener("mgcp", ms, ms->filter, 0, NULL, mgcpstat_packet, mgcpstat_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
g_free(ms->filter);
rs->filter=NULL;
}
- error_string=register_tap_listener("frame", rs, rs->filter, NULL, protocolinfo_packet, NULL);
+ error_string=register_tap_listener("frame", rs, rs->filter, TL_REQUIRES_PROTO_TREE, NULL, protocolinfo_packet, NULL);
if(error_string){
/* error, we failed to attach to the tap. complain and clean up */
fprintf(stderr, "tshark: Couldn't register proto,colinfo tap: %s\n",
const char *filter=NULL;
GString *error_string;
- if(!strcmp("io,phs",optarg)){
- filter="frame";
+ if(strcmp("io,phs",optarg)==0){
+ /* No arguments */
} else if(sscanf(optarg,"io,phs,%n",&pos)==0){
if(pos){
filter=optarg+pos;
- } else {
- /* We must use a filter to guarantee that edt->tree
- will be populated. "frame" matches everything so
- that one is used instead of no filter.
- */
- filter="frame";
}
} else {
fprintf(stderr, "tshark: invalid \"-z io,phs[,<filter>]\" argument\n");
rs->filter=NULL;
}
- error_string=register_tap_listener("frame", rs, filter, NULL, protohierstat_packet, protohierstat_draw);
+ error_string=register_tap_listener("frame", rs, filter, TL_REQUIRES_PROTO_TREE, NULL, protohierstat_packet, protohierstat_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
g_free(rs->filter);
{
radiusstat_t *rs;
int i;
- const char *filter=NULL;
GString *error_string;
+ rs=g_malloc(sizeof(radiusstat_t));
if(!strncmp(optarg,"radius,rtd,",11)){
- filter=optarg+11;
+ rs->filter=g_strdup(optarg+11);
} else {
- filter="";
+ rs->filter=NULL;
}
- rs=g_malloc(sizeof(radiusstat_t));
- rs->filter=g_strdup(filter);
-
for(i=0;i<NUM_TIMESTATS;i++) {
rs->rtd[i].num=0;
rs->rtd[i].min_num=0;
rs->req_dup_num=0;
rs->rsp_dup_num=0;
- error_string=register_tap_listener("radius", rs, filter, NULL, radiusstat_packet, radiusstat_draw);
+ error_string=register_tap_listener("radius", rs, rs->filter, 0, NULL, radiusstat_packet, radiusstat_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
g_free(rs->filter);
}
already_enabled=1;
- error_string=register_tap_listener("rpc", NULL, NULL, NULL, rpcprogs_packet, rpcprogs_draw);
+ error_string=register_tap_listener("rpc", NULL, NULL, 0, NULL, rpcprogs_packet, rpcprogs_draw);
if(error_string){
fprintf(stderr,"tshark: Couldn't register rpc,programs tap: %s\n",
error_string->str);
*
*/
- error_string=register_tap_listener("rpc", rs, filter, rpcstat_reset, rpcstat_packet, rpcstat_draw);
+ error_string=register_tap_listener("rpc", rs, filter, 0, rpcstat_reset, rpcstat_packet, rpcstat_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
g_free(rs->procedures);
GString *err_p;
err_p =
- register_tap_listener("rtp", &the_tapinfo_struct, NULL,
+ register_tap_listener("rtp", &the_tapinfo_struct, NULL, 0,
rtpstream_reset_cb,
rtpstream_packet,
rtp_streams_stat_draw);
sctpstat_init(const char *optarg, void* userdata _U_)
{
sctpstat_t *hs;
- const char *filter=NULL;
GString *error_string;
+ hs = g_malloc(sizeof(sctpstat_t));
if(!strncmp(optarg,"sctp,stat,",11)){
- filter=optarg+11;
+ hs->filter=g_strdup(optarg+11);
} else {
- filter="";
+ hs->filter=NULL;
}
-
- hs = g_malloc(sizeof(sctpstat_t));
- hs->filter=g_strdup(filter);
hs->ep_list = NULL;
hs->number_of_packets = 0;
sctpstat_reset(hs);
- error_string=register_tap_listener("sctp", hs, filter, NULL, sctpstat_packet, sctpstat_draw);
+ error_string=register_tap_listener("sctp", hs, hs->filter, 0, NULL, sctpstat_packet, sctpstat_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
g_free(hs->filter);
"sip",
sp,
filter,
+ 0,
sipstat_reset,
sipstat_packet,
sipstat_draw);
}
- error_string=register_tap_listener("smb", NULL, NULL, NULL, smbsids_packet, smbsids_draw);
+ error_string=register_tap_listener("smb", NULL, NULL, 0, NULL, smbsids_packet, smbsids_draw);
if(error_string){
fprintf(stderr, "tshark: Couldn't register smb,sids tap:%s\n",
error_string->str);
ss->nt_trans[i].tot.nsecs=0;
}
- error_string=register_tap_listener("smb", ss, filter, NULL, smbstat_packet, smbstat_draw);
+ error_string=register_tap_listener("smb", ss, filter, 0, NULL, smbstat_packet, smbstat_draw);
if(error_string){
/* error, we failed to attach to the tap. clean up */
g_free(ss->filter);
error_string = register_tap_listener(st->cfg->tapname,
st,
st->filter,
+ st->cfg->flags,
stats_tree_reset,
stats_tree_packet,
draw_stats_tree);
"wsp",
sp,
filter,
+ 0,
wspstat_reset,
wspstat_packet,
wspstat_draw);
static int load_cap_file(capture_file *, char *, int, int, gint64);
static gboolean process_packet(capture_file *cf, gint64 offset,
const struct wtap_pkthdr *whdr, union wtap_pseudo_header *pseudo_header,
- const guchar *pd);
+ const guchar *pd, gboolean filtering_tap_listeners, guint tap_flags);
static void show_capture_file_io_error(const char *, int, gboolean);
static void show_print_file_io_error(int err);
static gboolean write_preamble(capture_file *cf);
gchar *err_info;
gint64 data_offset;
capture_file *cf = capture_opts->cf;
-
+ gboolean filtering_tap_listeners;
+ guint tap_flags;
#ifdef SIGINFO
/*
infodelay = TRUE;
#endif /* SIGINFO */
+ /* Do we have any tap listeners with filters? */
+ filtering_tap_listeners = have_filtering_tap_listeners();
+
+ /* Get the union of the flags for all tap listeners. */
+ tap_flags = union_of_tap_listener_flags();
+
if(do_dissection) {
while (to_read-- && cf->wth) {
ret = wtap_read(cf->wth, &err, &err_info, &data_offset);
cf->wth = NULL;
} else {
ret = process_packet(cf, data_offset, wtap_phdr(cf->wth),
- wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth));
+ wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
+ filtering_tap_listeners, tap_flags);
}
if (ret != FALSE) {
/* packet sucessfully read and gone through the "Read Filter" */
gchar *err_info;
gint64 data_offset;
char *save_file_string = NULL;
+ gboolean filtering_tap_listeners;
+ guint tap_flags;
linktype = wtap_file_encap(cf->wth);
if (save_file != NULL) {
}
pdh = NULL;
}
+
+ /* Do we have any tap listeners with filters? */
+ filtering_tap_listeners = have_filtering_tap_listeners();
+
+ /* Get the union of the flags for all tap listeners. */
+ tap_flags = union_of_tap_listener_flags();
+
while (wtap_read(cf->wth, &err, &err_info, &data_offset)) {
if (process_packet(cf, data_offset, wtap_phdr(cf->wth),
- wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth))) {
+ wtap_pseudoheader(cf->wth), wtap_buf_ptr(cf->wth),
+ filtering_tap_listeners, tap_flags)) {
/* Either there's no read filtering or this packet passed the
filter, so, if we're writing to a capture file, write
this packet out. */
static gboolean
process_packet(capture_file *cf, gint64 offset, const struct wtap_pkthdr *whdr,
- union wtap_pseudo_header *pseudo_header, const guchar *pd)
+ union wtap_pseudo_header *pseudo_header, const guchar *pd,
+ gboolean filtering_tap_listeners, guint tap_flags)
{
frame_data fdata;
gboolean create_proto_tree;
+ column_info *cinfo;
epan_dissect_t *edt;
gboolean passed;
}
passed = TRUE;
- if (cf->rfcode || verbose || num_tap_filters!=0 || have_custom_cols(&cf->cinfo))
+ if (cf->rfcode || verbose || filtering_tap_listeners ||
+ (tap_flags & TL_REQUIRES_PROTO_TREE) || have_custom_cols(&cf->cinfo))
create_proto_tree = TRUE;
else
create_proto_tree = FALSE;
tap_queue_init(edt);
- /* We only need the columns if we're printing packet info but we're
- *not* verbose; in verbose mode, we print the protocol tree, not
- the protocol summary. */
- epan_dissect_run(edt, pseudo_header, pd, &fdata,
- (print_packet_info && !verbose) ? &cf->cinfo : NULL);
+ /* We only need the columns if either
+
+ 1) some tap needs the columns
+
+ or
+
+ 2) we're printing packet info but we're *not* verbose; in verbose
+ mode, we print the protocol tree, not the protocol summary. */
+ if ((tap_flags & TL_REQUIRES_COLUMNS) || (print_packet_info && !verbose))
+ cinfo = &cf->cinfo;
+ else
+ cinfo = NULL;
+ epan_dissect_run(edt, pseudo_header, pd, &fdata, cinfo);
tap_push_tapped_queue(edt);
git.samba.org / obnox / wireshark / wip.git / commitdiff