1999-11-06 06:28:07 +00:00
/* find_dlg.c
* Routines for " find frame " window
*
2004-07-18 00:24:25 +00:00
* $ Id $
1999-11-06 06:28:07 +00:00
*
* Ethereal - Network traffic analyzer
2002-01-21 07:37:49 +00:00
* By Gerald Combs < gerald @ ethereal . com >
1999-11-06 06:28:07 +00:00
* Copyright 1998 Gerald Combs
2002-08-28 21:04:11 +00:00
*
1999-11-06 06:28:07 +00:00
* This program is free software ; you can redistribute it and / or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation ; either version 2
* of the License , or ( at your option ) any later version .
2002-08-28 21:04:11 +00:00
*
1999-11-06 06:28:07 +00:00
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
2002-08-28 21:04:11 +00:00
*
1999-11-06 06:28:07 +00:00
* You should have received a copy of the GNU General Public License
* along with this program ; if not , write to the Free Software
* Foundation , Inc . , 59 Temple Place - Suite 330 , Boston , MA 02111 - 1307 , USA .
*/
# ifdef HAVE_CONFIG_H
# include "config.h"
# endif
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
# include <string.h>
# include <ctype.h>
1999-11-06 06:28:07 +00:00
# include <gtk/gtk.h>
2002-01-21 07:37:49 +00:00
# include <epan/proto.h>
# include <epan/dfilter/dfilter.h>
2004-08-13 02:39:49 +00:00
# include <epan/strutil.h>
1999-11-06 06:28:07 +00:00
# include "globals.h"
Split "filter_dialog_cb()" into "filter_dialog_cb()", which pops up a
"global" dialog box when "Edit:Filters" is selected, so that the list of
filters can be edited, and "filter_browse_cb()", which pops up a dialog
box associated with a "Filter:" button and a text entry widget attached
to that button, so that a filter can be selected or saved (although it
also supports the same editing that the "global" dialog box does).
Have "filter_dialog_cb()" connect the window in which the "Filter:"
button lives and the filter dialog box, so that:
if the window in which the "Filter:" button lives goes away, so
does the filter dialog box (as it no longer has a text widget
into which it can stuff the selected filter);
if the "Filter:" button is clicked when there's already a filter
dialog box open, we just reactivate that existing dialog box
rather than popping up a new one.
Also keep a pointer to the "global" filter dialog box, so that we also
arrange that there's only one of them (by reactivating the existing on
if "Edit:Filters" is selected when there's already a "global" filter
dialog box open).
Keep around pointers to the dialog boxes that contain the "Filter:"
buttons, so that we can arrange that there be only one of them (that was
a side-effect of an earlier attempt at fixing the problems described
above, but it's still useful for keeping multiple competing dialog boxes
from being open - there's more of that to be done).
Make the pointer to the "Open Capture File" dialog box widget static to
"file_dlg.c" - nobody outside of "file_dlg.c cares about it.
svn path=/trunk/; revision=1774
2000-04-01 12:03:42 +00:00
# include "ui_util.h"
1999-11-06 06:28:07 +00:00
# include "find_dlg.h"
2004-07-19 21:42:01 +00:00
# include "filter_dlg.h"
2004-02-11 00:55:28 +00:00
# include "alert_box.h"
2000-01-03 06:59:25 +00:00
# include "simple_dialog.h"
2000-05-02 08:04:31 +00:00
# include "dlg_utils.h"
2002-11-11 15:39:06 +00:00
# include "compat_macros.h"
2004-09-27 22:55:15 +00:00
# include <epan/prefs.h>
2003-07-22 23:08:48 +00:00
# include "prefs_dlg.h"
2003-08-11 22:41:10 +00:00
# include "keys.h"
2005-01-20 23:17:23 +00:00
# include "help_dlg.h"
1999-11-06 06:28:07 +00:00
/* Capture callback data keys */
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
# define E_FIND_FILT_KEY "find_filter_te"
# define E_FIND_BACKWARD_KEY "find_backward"
# define E_FIND_HEXDATA_KEY "find_hex"
2004-04-15 23:28:11 +00:00
# define E_FIND_STRINGDATA_KEY "find_string"
2003-07-22 23:08:48 +00:00
# define E_FIND_FILTERDATA_KEY "find_filter"
# define E_FIND_STRINGTYPE_KEY "find_string_type"
2004-02-28 22:07:33 +00:00
# define E_FIND_STRINGTYPE_LABEL_KEY "find_string_type_label"
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
# define E_CASE_SEARCH_KEY "case_insensitive_search"
# define E_SOURCE_HEX_KEY "hex_data_source"
# define E_SOURCE_DECODE_KEY "decode_data_source"
# define E_SOURCE_SUMMARY_KEY "summary_data_source"
# define E_FILT_TE_BUTTON_KEY "find_filter_button"
2003-08-05 00:01:27 +00:00
static gboolean case_type = TRUE ;
2003-08-11 22:41:10 +00:00
static gboolean summary_data = FALSE ;
static gboolean decode_data = FALSE ;
1999-11-06 06:28:07 +00:00
2004-02-28 04:18:47 +00:00
static void
find_filter_te_syntax_check_cb ( GtkWidget * w , gpointer parent_w ) ;
1999-11-06 06:28:07 +00:00
static void
find_frame_ok_cb ( GtkWidget * ok_bt , gpointer parent_w ) ;
static void
find_frame_close_cb ( GtkWidget * close_bt , gpointer parent_w ) ;
Split "filter_dialog_cb()" into "filter_dialog_cb()", which pops up a
"global" dialog box when "Edit:Filters" is selected, so that the list of
filters can be edited, and "filter_browse_cb()", which pops up a dialog
box associated with a "Filter:" button and a text entry widget attached
to that button, so that a filter can be selected or saved (although it
also supports the same editing that the "global" dialog box does).
Have "filter_dialog_cb()" connect the window in which the "Filter:"
button lives and the filter dialog box, so that:
if the window in which the "Filter:" button lives goes away, so
does the filter dialog box (as it no longer has a text widget
into which it can stuff the selected filter);
if the "Filter:" button is clicked when there's already a filter
dialog box open, we just reactivate that existing dialog box
rather than popping up a new one.
Also keep a pointer to the "global" filter dialog box, so that we also
arrange that there's only one of them (by reactivating the existing on
if "Edit:Filters" is selected when there's already a "global" filter
dialog box open).
Keep around pointers to the dialog boxes that contain the "Filter:"
buttons, so that we can arrange that there be only one of them (that was
a side-effect of an earlier attempt at fixing the problems described
above, but it's still useful for keeping multiple competing dialog boxes
from being open - there's more of that to be done).
Make the pointer to the "Open Capture File" dialog box widget static to
"file_dlg.c" - nobody outside of "file_dlg.c cares about it.
svn path=/trunk/; revision=1774
2000-04-01 12:03:42 +00:00
static void
find_frame_destroy_cb ( GtkWidget * win , gpointer user_data ) ;
2004-02-28 04:18:47 +00:00
static void
hex_selected_cb ( GtkWidget * button_rb _U_ , gpointer parent_w ) ;
2003-08-11 22:41:10 +00:00
static void
2004-04-15 23:28:11 +00:00
string_selected_cb ( GtkWidget * button_rb _U_ , gpointer parent_w ) ;
2003-08-11 22:41:10 +00:00
2003-08-28 23:25:55 +00:00
static void
filter_selected_cb ( GtkWidget * button_rb _U_ , gpointer parent_w ) ;
Split "filter_dialog_cb()" into "filter_dialog_cb()", which pops up a
"global" dialog box when "Edit:Filters" is selected, so that the list of
filters can be edited, and "filter_browse_cb()", which pops up a dialog
box associated with a "Filter:" button and a text entry widget attached
to that button, so that a filter can be selected or saved (although it
also supports the same editing that the "global" dialog box does).
Have "filter_dialog_cb()" connect the window in which the "Filter:"
button lives and the filter dialog box, so that:
if the window in which the "Filter:" button lives goes away, so
does the filter dialog box (as it no longer has a text widget
into which it can stuff the selected filter);
if the "Filter:" button is clicked when there's already a filter
dialog box open, we just reactivate that existing dialog box
rather than popping up a new one.
Also keep a pointer to the "global" filter dialog box, so that we also
arrange that there's only one of them (by reactivating the existing on
if "Edit:Filters" is selected when there's already a "global" filter
dialog box open).
Keep around pointers to the dialog boxes that contain the "Filter:"
buttons, so that we can arrange that there be only one of them (that was
a side-effect of an earlier attempt at fixing the problems described
above, but it's still useful for keeping multiple competing dialog boxes
from being open - there's more of that to be done).
Make the pointer to the "Open Capture File" dialog box widget static to
"file_dlg.c" - nobody outside of "file_dlg.c cares about it.
svn path=/trunk/; revision=1774
2000-04-01 12:03:42 +00:00
/*
2003-11-28 19:02:41 +00:00
* Keep a static pointer to the current " Find Packet " window , if any , so
* that if somebody tries to do " Find Packet " while there ' s already a
* " Find Packet " window up , we just pop up the existing one , rather than
Split "filter_dialog_cb()" into "filter_dialog_cb()", which pops up a
"global" dialog box when "Edit:Filters" is selected, so that the list of
filters can be edited, and "filter_browse_cb()", which pops up a dialog
box associated with a "Filter:" button and a text entry widget attached
to that button, so that a filter can be selected or saved (although it
also supports the same editing that the "global" dialog box does).
Have "filter_dialog_cb()" connect the window in which the "Filter:"
button lives and the filter dialog box, so that:
if the window in which the "Filter:" button lives goes away, so
does the filter dialog box (as it no longer has a text widget
into which it can stuff the selected filter);
if the "Filter:" button is clicked when there's already a filter
dialog box open, we just reactivate that existing dialog box
rather than popping up a new one.
Also keep a pointer to the "global" filter dialog box, so that we also
arrange that there's only one of them (by reactivating the existing on
if "Edit:Filters" is selected when there's already a "global" filter
dialog box open).
Keep around pointers to the dialog boxes that contain the "Filter:"
buttons, so that we can arrange that there be only one of them (that was
a side-effect of an earlier attempt at fixing the problems described
above, but it's still useful for keeping multiple competing dialog boxes
from being open - there's more of that to be done).
Make the pointer to the "Open Capture File" dialog box widget static to
"file_dlg.c" - nobody outside of "file_dlg.c cares about it.
svn path=/trunk/; revision=1774
2000-04-01 12:03:42 +00:00
* creating a new one .
*/
static GtkWidget * find_frame_w ;
2003-09-05 06:16:10 +00:00
static GtkWidget * filter_text_box ;
Split "filter_dialog_cb()" into "filter_dialog_cb()", which pops up a
"global" dialog box when "Edit:Filters" is selected, so that the list of
filters can be edited, and "filter_browse_cb()", which pops up a dialog
box associated with a "Filter:" button and a text entry widget attached
to that button, so that a filter can be selected or saved (although it
also supports the same editing that the "global" dialog box does).
Have "filter_dialog_cb()" connect the window in which the "Filter:"
button lives and the filter dialog box, so that:
if the window in which the "Filter:" button lives goes away, so
does the filter dialog box (as it no longer has a text widget
into which it can stuff the selected filter);
if the "Filter:" button is clicked when there's already a filter
dialog box open, we just reactivate that existing dialog box
rather than popping up a new one.
Also keep a pointer to the "global" filter dialog box, so that we also
arrange that there's only one of them (by reactivating the existing on
if "Edit:Filters" is selected when there's already a "global" filter
dialog box open).
Keep around pointers to the dialog boxes that contain the "Filter:"
buttons, so that we can arrange that there be only one of them (that was
a side-effect of an earlier attempt at fixing the problems described
above, but it's still useful for keeping multiple competing dialog boxes
from being open - there's more of that to be done).
Make the pointer to the "Open Capture File" dialog box widget static to
"file_dlg.c" - nobody outside of "file_dlg.c cares about it.
svn path=/trunk/; revision=1774
2000-04-01 12:03:42 +00:00
1999-11-06 06:28:07 +00:00
void
2002-03-05 11:56:00 +00:00
find_frame_cb ( GtkWidget * w _U_ , gpointer d _U_ )
1999-11-06 06:28:07 +00:00
{
2004-02-28 22:07:33 +00:00
GtkWidget * main_vb , * main_find_hb , * main_options_hb ,
2004-08-13 02:39:49 +00:00
2004-02-28 22:07:33 +00:00
* find_type_frame , * find_type_vb ,
2004-04-15 23:28:11 +00:00
* find_type_hb , * find_type_lb , * hex_rb , * string_rb , * filter_rb ,
2004-02-28 22:07:33 +00:00
* filter_hb , * filter_bt ,
* direction_frame , * direction_vb ,
* up_rb , * down_rb ,
* data_frame , * data_vb ,
* hex_data_rb , * decode_data_rb , * summary_data_rb ,
* string_opt_frame , * string_opt_vb ,
2004-08-13 02:39:49 +00:00
* case_cb , * combo_lb , * combo_cb ,
2004-02-28 22:07:33 +00:00
2005-01-20 23:17:23 +00:00
* bbox , * ok_bt , * cancel_bt , * help_bt ;
2003-08-28 23:25:55 +00:00
GtkTooltips * tooltips ;
2002-11-03 17:38:45 +00:00
# if GTK_MAJOR_VERSION < 2
2000-05-08 04:53:21 +00:00
GtkAccelGroup * accel_group ;
2002-11-03 17:38:45 +00:00
# endif
2003-07-22 23:08:48 +00:00
GList * glist = NULL ;
In the process of destroying a filter editing dialog box, we get a
selection change event on the list of filters. Unfortunately, this can
happen after some other widgets in that dialog box have already been
destroyed - including some of the widgets that such a selection change
event can change.
This sometimes happened when "filter_prefs_delete()" hadn't been called,
so the mechanism we had been using, with a Boolean datum attached to the
dialog box, set in "filter_prefs_delete()" before we actually destroy
the dialog box, wasn't sufficient to keep that from happening.
Attach to the top-level window data items containing pointers to the
widgets changed when a filter is selected from the list, give each of
those widgets their own destroy callbacks, clear the pointer attached to
the top-level widget when the widget is destroyed, and don't do anything
to the widget when a filter is selected from the list if the pointer for
that widget is null, as that means the widget's been destroyed and we
*can't* do anything to it.
Not all filter editing dialogs created on behalf of a "Filter:" button
next to a text entry box should, when you click "OK", activate the text
entry box; if the text entry box is part of a dialog box with multiple
widgets, the user might not have filled in all of the items in that
dialog box, so you shouldn't activate it for them. Add a mechanism by
which, when creating a filter editing dialog box, you can specify
whether the "OK" button should just fill in the text entry box or should
fill it in and also activate it.
svn path=/trunk/; revision=2922
2001-01-21 01:45:07 +00:00
/* No Apply button, but "OK" not only sets our text widget, it
activates it ( i . e . , it causes us to do the search ) . */
2001-01-21 02:27:24 +00:00
static construct_args_t args = {
" Ethereal: Search Filter " ,
FALSE ,
TRUE
} ;
1999-11-06 06:28:07 +00:00
Split "filter_dialog_cb()" into "filter_dialog_cb()", which pops up a
"global" dialog box when "Edit:Filters" is selected, so that the list of
filters can be edited, and "filter_browse_cb()", which pops up a dialog
box associated with a "Filter:" button and a text entry widget attached
to that button, so that a filter can be selected or saved (although it
also supports the same editing that the "global" dialog box does).
Have "filter_dialog_cb()" connect the window in which the "Filter:"
button lives and the filter dialog box, so that:
if the window in which the "Filter:" button lives goes away, so
does the filter dialog box (as it no longer has a text widget
into which it can stuff the selected filter);
if the "Filter:" button is clicked when there's already a filter
dialog box open, we just reactivate that existing dialog box
rather than popping up a new one.
Also keep a pointer to the "global" filter dialog box, so that we also
arrange that there's only one of them (by reactivating the existing on
if "Edit:Filters" is selected when there's already a "global" filter
dialog box open).
Keep around pointers to the dialog boxes that contain the "Filter:"
buttons, so that we can arrange that there be only one of them (that was
a side-effect of an earlier attempt at fixing the problems described
above, but it's still useful for keeping multiple competing dialog boxes
from being open - there's more of that to be done).
Make the pointer to the "Open Capture File" dialog box widget static to
"file_dlg.c" - nobody outside of "file_dlg.c cares about it.
svn path=/trunk/; revision=1774
2000-04-01 12:03:42 +00:00
if ( find_frame_w ! = NULL ) {
2003-11-28 19:02:41 +00:00
/* There's already a "Find Packet" dialog box; reactivate it. */
Split "filter_dialog_cb()" into "filter_dialog_cb()", which pops up a
"global" dialog box when "Edit:Filters" is selected, so that the list of
filters can be edited, and "filter_browse_cb()", which pops up a dialog
box associated with a "Filter:" button and a text entry widget attached
to that button, so that a filter can be selected or saved (although it
also supports the same editing that the "global" dialog box does).
Have "filter_dialog_cb()" connect the window in which the "Filter:"
button lives and the filter dialog box, so that:
if the window in which the "Filter:" button lives goes away, so
does the filter dialog box (as it no longer has a text widget
into which it can stuff the selected filter);
if the "Filter:" button is clicked when there's already a filter
dialog box open, we just reactivate that existing dialog box
rather than popping up a new one.
Also keep a pointer to the "global" filter dialog box, so that we also
arrange that there's only one of them (by reactivating the existing on
if "Edit:Filters" is selected when there's already a "global" filter
dialog box open).
Keep around pointers to the dialog boxes that contain the "Filter:"
buttons, so that we can arrange that there be only one of them (that was
a side-effect of an earlier attempt at fixing the problems described
above, but it's still useful for keeping multiple competing dialog boxes
from being open - there's more of that to be done).
Make the pointer to the "Open Capture File" dialog box widget static to
"file_dlg.c" - nobody outside of "file_dlg.c cares about it.
svn path=/trunk/; revision=1774
2000-04-01 12:03:42 +00:00
reactivate_window ( find_frame_w ) ;
return ;
}
2003-11-28 19:02:41 +00:00
find_frame_w = dlg_window_new ( " Ethereal: Find Packet " ) ;
2000-05-08 04:53:21 +00:00
2003-08-28 23:25:55 +00:00
tooltips = gtk_tooltips_new ( ) ;
2002-11-11 15:39:06 +00:00
# if GTK_MAJOR_VERSION < 2
2000-05-08 04:53:21 +00:00
/* Accelerator group for the accelerators (or, as they're called in
Windows and , I think , in Motif , " mnemonics " ; Alt + < key > is a mnemonic ,
Ctrl + < key > is an accelerator ) . */
accel_group = gtk_accel_group_new ( ) ;
gtk_window_add_accel_group ( GTK_WINDOW ( find_frame_w ) , accel_group ) ;
2002-11-03 17:38:45 +00:00
# endif
2002-08-28 21:04:11 +00:00
1999-11-06 06:28:07 +00:00
/* Container for each row of widgets */
main_vb = gtk_vbox_new ( FALSE , 3 ) ;
gtk_container_border_width ( GTK_CONTAINER ( main_vb ) , 5 ) ;
gtk_container_add ( GTK_CONTAINER ( find_frame_w ) , main_vb ) ;
gtk_widget_show ( main_vb ) ;
2002-08-28 21:04:11 +00:00
2004-02-28 22:07:33 +00:00
/* */
main_find_hb = gtk_hbox_new ( FALSE , 3 ) ;
gtk_container_add ( GTK_CONTAINER ( main_vb ) , main_find_hb ) ;
gtk_widget_show ( main_find_hb ) ;
2002-08-28 21:04:11 +00:00
1999-11-06 06:28:07 +00:00
2004-02-28 22:07:33 +00:00
/* find frame */
find_type_frame = gtk_frame_new ( " Find " ) ;
gtk_box_pack_start ( GTK_BOX ( main_find_hb ) , find_type_frame , TRUE , TRUE , 0 ) ;
gtk_widget_show ( find_type_frame ) ;
2003-08-28 23:25:55 +00:00
2004-02-28 22:07:33 +00:00
find_type_vb = gtk_vbox_new ( FALSE , 3 ) ;
gtk_container_border_width ( GTK_CONTAINER ( find_type_vb ) , 3 ) ;
gtk_container_add ( GTK_CONTAINER ( find_type_frame ) , find_type_vb ) ;
gtk_widget_show ( find_type_vb ) ;
1999-11-06 06:28:07 +00:00
2004-02-28 22:07:33 +00:00
/* find type row */
find_type_hb = gtk_hbox_new ( FALSE , 3 ) ;
gtk_container_add ( GTK_CONTAINER ( find_type_vb ) , find_type_hb ) ;
gtk_widget_show ( find_type_hb ) ;
2003-07-22 23:08:48 +00:00
2004-02-28 22:07:33 +00:00
find_type_lb = gtk_label_new ( " By: " ) ;
gtk_box_pack_start ( GTK_BOX ( find_type_hb ) , find_type_lb , FALSE , FALSE , 0 ) ;
gtk_widget_show ( find_type_lb ) ;
2003-08-28 23:25:55 +00:00
2003-07-22 23:08:48 +00:00
/* Filter */
2004-02-28 22:07:33 +00:00
filter_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC ( NULL ,
2004-05-26 02:33:37 +00:00
" _Display filter " , accel_group ) ;
2004-04-15 23:28:11 +00:00
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( filter_rb ) , ! cfile . hex & & ! cfile . string ) ;
2004-02-28 22:07:33 +00:00
gtk_box_pack_start ( GTK_BOX ( find_type_hb ) , filter_rb , FALSE , FALSE , 0 ) ;
2003-08-28 23:25:55 +00:00
gtk_tooltips_set_tip ( tooltips , filter_rb , ( " Search for data by display filter syntax. \n e.g. ip.addr==10.1.1.1 " ) , NULL ) ;
2003-07-22 23:08:48 +00:00
gtk_widget_show ( filter_rb ) ;
/* Hex */
2004-01-10 16:27:43 +00:00
hex_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC ( filter_rb ,
2004-02-28 22:07:33 +00:00
" _Hex value " , accel_group ) ;
2004-04-15 23:28:11 +00:00
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( hex_rb ) , cfile . hex ) ;
2004-02-28 22:07:33 +00:00
gtk_box_pack_start ( GTK_BOX ( find_type_hb ) , hex_rb , FALSE , FALSE , 0 ) ;
2003-08-28 23:25:55 +00:00
gtk_tooltips_set_tip ( tooltips , hex_rb , ( " Search for data by hex string. \n e.g. fffffda5 " ) , NULL ) ;
2003-07-22 23:08:48 +00:00
gtk_widget_show ( hex_rb ) ;
/* ASCII Search */
2004-04-15 23:28:11 +00:00
string_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC ( filter_rb ,
2003-07-22 23:08:48 +00:00
" _String " , accel_group ) ;
2004-04-15 23:28:11 +00:00
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( string_rb ) , cfile . string ) ;
gtk_box_pack_start ( GTK_BOX ( find_type_hb ) , string_rb , FALSE , FALSE , 0 ) ;
gtk_tooltips_set_tip ( tooltips , string_rb , ( " Search for data by string value. \n e.g. My String " ) , NULL ) ;
gtk_widget_show ( string_rb ) ;
2003-07-22 23:08:48 +00:00
2004-02-28 22:07:33 +00:00
/* Filter row */
filter_hb = gtk_hbox_new ( FALSE , 3 ) ;
2004-02-29 10:41:03 +00:00
gtk_box_pack_start ( GTK_BOX ( find_type_vb ) , filter_hb , FALSE , FALSE , 0 ) ;
2004-02-28 22:07:33 +00:00
gtk_widget_show ( filter_hb ) ;
2003-08-28 23:25:55 +00:00
2004-02-28 22:07:33 +00:00
filter_bt = BUTTON_NEW_FROM_STOCK ( ETHEREAL_STOCK_DISPLAY_FILTER_ENTRY ) ;
SIGNAL_CONNECT ( filter_bt , " clicked " , display_filter_construct_cb , & args ) ;
SIGNAL_CONNECT ( filter_bt , " destroy " , filter_button_destroy_cb , NULL ) ;
OBJECT_SET_DATA ( filter_bt , E_FILT_TE_BUTTON_KEY , filter_bt ) ;
gtk_box_pack_start ( GTK_BOX ( filter_hb ) , filter_bt , FALSE , TRUE , 0 ) ;
gtk_tooltips_set_tip ( tooltips , filter_bt , ( " Click on the filter button to select a display filter, \n or enter your search criteria into the text box " ) , NULL ) ;
gtk_widget_show ( filter_bt ) ;
2003-08-11 22:41:10 +00:00
2004-02-28 22:07:33 +00:00
filter_text_box = gtk_entry_new ( ) ;
if ( cfile . sfilter ) gtk_entry_set_text ( GTK_ENTRY ( filter_text_box ) , cfile . sfilter ) ;
OBJECT_SET_DATA ( filter_bt , E_FILT_TE_PTR_KEY , filter_text_box ) ;
OBJECT_SET_DATA ( find_frame_w , E_FILT_TE_PTR_KEY , filter_text_box ) ;
gtk_box_pack_start ( GTK_BOX ( filter_hb ) , filter_text_box , TRUE , TRUE , 0 ) ;
SIGNAL_CONNECT ( filter_text_box , " changed " , find_filter_te_syntax_check_cb , find_frame_w ) ;
gtk_widget_show ( filter_text_box ) ;
2003-08-11 22:41:10 +00:00
2004-02-28 22:07:33 +00:00
/* */
main_options_hb = gtk_hbox_new ( FALSE , 3 ) ;
gtk_container_add ( GTK_CONTAINER ( main_vb ) , main_options_hb ) ;
gtk_widget_show ( main_options_hb ) ;
2003-08-11 22:41:10 +00:00
2004-02-28 22:07:33 +00:00
/* search in frame */
data_frame = gtk_frame_new ( " Search In " ) ;
gtk_box_pack_start ( GTK_BOX ( main_options_hb ) , data_frame , TRUE , TRUE , 0 ) ;
gtk_widget_show ( data_frame ) ;
/* search in row */
data_vb = gtk_vbox_new ( TRUE , 0 ) ;
gtk_container_border_width ( GTK_CONTAINER ( data_vb ) , 3 ) ;
gtk_container_add ( GTK_CONTAINER ( data_frame ) , data_vb ) ;
gtk_widget_show ( data_vb ) ;
/* Packet list */
summary_data_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC ( NULL ,
" Packet list " , accel_group ) ;
2004-04-15 23:28:11 +00:00
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( summary_data_rb ) , summary_data ) ;
2004-02-28 22:07:33 +00:00
gtk_box_pack_start ( GTK_BOX ( data_vb ) , summary_data_rb , TRUE , TRUE , 0 ) ;
2003-08-28 23:25:55 +00:00
gtk_tooltips_set_tip ( tooltips , summary_data_rb , ( " Search for string in the Info column of the packet summary (top pane) " ) , NULL ) ;
2003-08-11 22:41:10 +00:00
gtk_widget_show ( summary_data_rb ) ;
2004-02-28 22:07:33 +00:00
/* Packet details */
decode_data_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC ( summary_data_rb ,
" Packet details " , accel_group ) ;
2004-04-15 23:28:11 +00:00
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( decode_data_rb ) , decode_data ) ;
2004-02-28 22:07:33 +00:00
gtk_box_pack_start ( GTK_BOX ( data_vb ) , decode_data_rb , TRUE , TRUE , 0 ) ;
gtk_tooltips_set_tip ( tooltips , decode_data_rb , ( " Search for string in the decoded packet display (middle pane) " ) , NULL ) ;
gtk_widget_show ( decode_data_rb ) ;
/* Packet bytes */
2004-08-13 02:39:49 +00:00
hex_data_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC ( summary_data_rb ,
2004-02-28 22:07:33 +00:00
" Packet bytes " , accel_group ) ;
2004-04-15 23:28:11 +00:00
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( hex_data_rb ) , ! decode_data & & ! summary_data ) ;
2004-02-28 22:07:33 +00:00
gtk_box_pack_start ( GTK_BOX ( data_vb ) , hex_data_rb , TRUE , TRUE , 0 ) ;
gtk_tooltips_set_tip ( tooltips , hex_data_rb , ( " Search for string in the packet data " ) , NULL ) ;
gtk_widget_show ( hex_data_rb ) ;
2003-08-28 23:25:55 +00:00
2004-02-28 22:07:33 +00:00
/* string options frame */
string_opt_frame = gtk_frame_new ( " String Options " ) ;
gtk_box_pack_start ( GTK_BOX ( main_options_hb ) , string_opt_frame , TRUE , TRUE , 0 ) ;
gtk_widget_show ( string_opt_frame ) ;
string_opt_vb = gtk_vbox_new ( FALSE , 0 ) ;
gtk_container_add ( GTK_CONTAINER ( string_opt_frame ) , string_opt_vb ) ;
gtk_container_border_width ( GTK_CONTAINER ( string_opt_vb ) , 3 ) ;
gtk_widget_show ( string_opt_vb ) ;
case_cb = CHECK_BUTTON_NEW_WITH_MNEMONIC (
" Case sensitive " , accel_group ) ;
2004-04-15 23:28:11 +00:00
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( case_cb ) , ! case_type ) ;
2004-02-28 22:07:33 +00:00
gtk_container_add ( GTK_CONTAINER ( string_opt_vb ) , case_cb ) ;
gtk_tooltips_set_tip ( tooltips , case_cb , ( " Search by mixed upper/lower case? " ) , NULL ) ;
gtk_widget_show ( case_cb ) ;
combo_lb = gtk_label_new ( " Character set: " ) ;
gtk_container_add ( GTK_CONTAINER ( string_opt_vb ) , combo_lb ) ;
gtk_misc_set_alignment ( GTK_MISC ( combo_lb ) , 0.0 , 0.5 ) ;
gtk_widget_show ( combo_lb ) ;
2003-08-28 23:25:55 +00:00
2004-08-13 02:39:49 +00:00
/* String Type Selection Dropdown Box
2003-08-11 22:41:10 +00:00
These only apply to the Hex Window search option */
2003-07-22 23:08:48 +00:00
/* Create Combo Box */
combo_cb = gtk_combo_new ( ) ;
glist = g_list_append ( glist , " ASCII Unicode & Non-Unicode " ) ;
glist = g_list_append ( glist , " ASCII Non-Unicode " ) ;
glist = g_list_append ( glist , " ASCII Unicode " ) ;
gtk_combo_set_popdown_strings ( GTK_COMBO ( combo_cb ) , glist ) ;
2003-08-29 04:56:46 +00:00
/* You only get to choose from the options we offer */
gtk_entry_set_editable ( GTK_ENTRY ( GTK_COMBO ( combo_cb ) - > entry ) , FALSE ) ;
2004-02-28 22:07:33 +00:00
gtk_container_add ( GTK_CONTAINER ( string_opt_vb ) , combo_cb ) ;
2003-07-22 23:08:48 +00:00
gtk_widget_show ( combo_cb ) ;
2003-08-28 23:25:55 +00:00
2004-02-28 22:07:33 +00:00
/* direction frame */
direction_frame = gtk_frame_new ( " Direction " ) ;
gtk_box_pack_start ( GTK_BOX ( main_options_hb ) , direction_frame , FALSE , FALSE , 0 ) ;
gtk_widget_show ( direction_frame ) ;
/* Direction row: Forward and reverse radio buttons */
direction_vb = gtk_vbox_new ( FALSE , 0 ) ;
gtk_container_border_width ( GTK_CONTAINER ( direction_vb ) , 3 ) ;
gtk_container_add ( GTK_CONTAINER ( direction_frame ) , direction_vb ) ;
gtk_widget_show ( direction_vb ) ;
up_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC ( NULL , " _Up " , accel_group ) ;
2004-04-15 23:28:11 +00:00
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( up_rb ) , cfile . sbackward ) ;
2004-02-28 22:07:33 +00:00
gtk_box_pack_start ( GTK_BOX ( direction_vb ) , up_rb , FALSE , FALSE , 0 ) ;
gtk_widget_show ( up_rb ) ;
down_rb = RADIO_BUTTON_NEW_WITH_MNEMONIC ( up_rb , " _Down " , accel_group ) ;
2004-04-15 23:28:11 +00:00
gtk_toggle_button_set_active ( GTK_TOGGLE_BUTTON ( down_rb ) , ! cfile . sbackward ) ;
2004-02-28 22:07:33 +00:00
gtk_box_pack_start ( GTK_BOX ( direction_vb ) , down_rb , FALSE , FALSE , 0 ) ;
gtk_widget_show ( down_rb ) ;
2003-08-05 00:01:27 +00:00
2004-01-21 21:19:34 +00:00
/* Button row */
2005-01-20 23:17:23 +00:00
if ( topic_available ( HELP_FIND_DIALOG ) ) {
bbox = dlg_button_row_new ( GTK_STOCK_FIND , GTK_STOCK_CANCEL , GTK_STOCK_HELP , NULL ) ;
} else {
bbox = dlg_button_row_new ( GTK_STOCK_FIND , GTK_STOCK_CANCEL , NULL ) ;
}
2004-01-21 21:19:34 +00:00
gtk_box_pack_start ( GTK_BOX ( main_vb ) , bbox , FALSE , FALSE , 0 ) ;
1999-11-06 06:28:07 +00:00
gtk_widget_show ( bbox ) ;
2004-01-21 21:19:34 +00:00
ok_bt = OBJECT_GET_DATA ( bbox , GTK_STOCK_FIND ) ;
2002-11-11 15:39:06 +00:00
SIGNAL_CONNECT ( ok_bt , " clicked " , find_frame_ok_cb , find_frame_w ) ;
1999-11-06 06:28:07 +00:00
2004-01-21 21:19:34 +00:00
cancel_bt = OBJECT_GET_DATA ( bbox , GTK_STOCK_CANCEL ) ;
2002-11-11 15:39:06 +00:00
SIGNAL_CONNECT ( cancel_bt , " clicked " , find_frame_close_cb , find_frame_w ) ;
1999-11-06 06:28:07 +00:00
2005-01-20 23:17:23 +00:00
if ( topic_available ( HELP_FIND_DIALOG ) ) {
help_bt = OBJECT_GET_DATA ( bbox , GTK_STOCK_HELP ) ;
SIGNAL_CONNECT ( help_bt , " clicked " , topic_cb , HELP_FIND_DIALOG ) ;
}
1999-11-06 06:28:07 +00:00
/* Attach pointers to needed widgets to the capture prefs window/object */
2003-09-05 06:16:10 +00:00
OBJECT_SET_DATA ( find_frame_w , E_FIND_FILT_KEY , filter_text_box ) ;
2004-02-28 22:07:33 +00:00
OBJECT_SET_DATA ( find_frame_w , E_FIND_BACKWARD_KEY , up_rb ) ;
2003-07-22 23:08:48 +00:00
OBJECT_SET_DATA ( find_frame_w , E_FIND_FILTERDATA_KEY , filter_rb ) ;
OBJECT_SET_DATA ( find_frame_w , E_FIND_HEXDATA_KEY , hex_rb ) ;
2004-04-15 23:28:11 +00:00
OBJECT_SET_DATA ( find_frame_w , E_FIND_STRINGDATA_KEY , string_rb ) ;
2004-02-28 22:07:33 +00:00
OBJECT_SET_DATA ( find_frame_w , E_FIND_STRINGTYPE_LABEL_KEY , combo_lb ) ;
2003-07-22 23:08:48 +00:00
OBJECT_SET_DATA ( find_frame_w , E_FIND_STRINGTYPE_KEY , combo_cb ) ;
2003-08-05 00:01:27 +00:00
OBJECT_SET_DATA ( find_frame_w , E_CASE_SEARCH_KEY , case_cb ) ;
2003-08-11 22:41:10 +00:00
OBJECT_SET_DATA ( find_frame_w , E_SOURCE_HEX_KEY , hex_data_rb ) ;
OBJECT_SET_DATA ( find_frame_w , E_SOURCE_DECODE_KEY , decode_data_rb ) ;
OBJECT_SET_DATA ( find_frame_w , E_SOURCE_SUMMARY_KEY , summary_data_rb ) ;
2003-08-28 23:25:55 +00:00
OBJECT_SET_DATA ( find_frame_w , E_FILT_TE_BUTTON_KEY , filter_bt ) ;
2004-08-13 02:39:49 +00:00
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
/*
* Now that we ' ve attached the pointers , connect the signals - if
* we do so before we ' ve attached the pointers , the signals may
* be delivered before the pointers are attached ; the signal
* handlers expect the pointers to be attached , and won ' t be happy .
*/
2004-02-28 04:18:47 +00:00
SIGNAL_CONNECT ( hex_rb , " clicked " , hex_selected_cb , find_frame_w ) ;
2004-04-15 23:28:11 +00:00
SIGNAL_CONNECT ( string_rb , " clicked " , string_selected_cb , find_frame_w ) ;
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
SIGNAL_CONNECT ( filter_rb , " clicked " , filter_selected_cb , find_frame_w ) ;
1999-11-06 06:28:07 +00:00
2004-04-15 23:28:11 +00:00
string_selected_cb ( NULL , find_frame_w ) ;
2003-08-28 23:25:55 +00:00
filter_selected_cb ( NULL , find_frame_w ) ;
2004-05-26 03:49:24 +00:00
window_set_cancel_button ( find_frame_w , cancel_bt , window_cancel_button_cb ) ;
gtk_widget_grab_default ( ok_bt ) ;
2003-04-24 23:18:07 +00:00
/* Catch the "activate" signal on the filter text entry, so that
2000-05-02 08:04:31 +00:00
if the user types Return there , we act as if the " OK " button
had been selected , as happens if Return is typed if some widget
that * doesn ' t * handle the Return key has the input focus . */
2003-09-05 06:16:10 +00:00
dlg_set_activate ( filter_text_box , ok_bt ) ;
2000-05-02 08:04:31 +00:00
2000-03-15 08:54:24 +00:00
/* Give the initial focus to the "Filter" entry box. */
2003-09-05 06:16:10 +00:00
gtk_widget_grab_focus ( filter_text_box ) ;
2000-03-15 08:54:24 +00:00
2004-05-26 03:49:24 +00:00
SIGNAL_CONNECT ( find_frame_w , " delete_event " , window_delete_event_cb , NULL ) ;
SIGNAL_CONNECT ( find_frame_w , " destroy " , find_frame_destroy_cb , NULL ) ;
1999-11-06 06:28:07 +00:00
gtk_widget_show ( find_frame_w ) ;
2004-05-26 03:49:24 +00:00
window_present ( find_frame_w ) ;
1999-11-06 06:28:07 +00:00
}
2003-09-05 06:16:10 +00:00
/* this function opens the find frame dialogue and sets the filter string */
2004-08-13 02:39:49 +00:00
void
2003-09-05 06:16:10 +00:00
find_frame_with_filter ( char * filter )
{
find_frame_cb ( NULL , NULL ) ;
gtk_entry_set_text ( GTK_ENTRY ( filter_text_box ) , filter ) ;
}
2004-02-28 04:18:47 +00:00
/*
* Check the filter syntax based on the type of search we ' re doing .
*/
static void
find_filter_te_syntax_check_cb ( GtkWidget * w , gpointer parent_w )
{
const gchar * strval ;
2004-04-15 23:28:11 +00:00
GtkWidget * hex_rb , * string_rb ;
2004-02-28 04:18:47 +00:00
guint8 * bytes = NULL ;
size_t nbytes ;
hex_rb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FIND_HEXDATA_KEY ) ;
2004-04-15 23:28:11 +00:00
string_rb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FIND_STRINGDATA_KEY ) ;
2004-02-28 04:18:47 +00:00
if ( gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( hex_rb ) ) ) {
/*
* Hex search - scan the search string to make sure it ' s valid hex .
*/
strval = gtk_entry_get_text ( GTK_ENTRY ( w ) ) ;
if ( strval = = NULL ) {
2004-08-13 02:39:49 +00:00
/* XXX - can this happen? */
2004-02-28 04:18:47 +00:00
colorize_filter_te_as_invalid ( w ) ;
} else {
bytes = convert_string_to_hex ( strval , & nbytes ) ;
if ( bytes = = NULL )
colorize_filter_te_as_invalid ( w ) ;
else {
g_free ( bytes ) ;
colorize_filter_te_as_valid ( w ) ;
}
}
2004-04-15 23:28:11 +00:00
} else if ( gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( string_rb ) ) ) {
2004-02-28 04:18:47 +00:00
/*
* String search . Make sure the string isn ' t empty .
*/
strval = gtk_entry_get_text ( GTK_ENTRY ( w ) ) ;
if ( strval = = NULL ) {
2004-08-13 02:39:49 +00:00
/* XXX - can this happen? */
2004-02-28 04:18:47 +00:00
colorize_filter_te_as_invalid ( w ) ;
} else {
if ( strcmp ( strval , " " ) = = 0 )
colorize_filter_te_as_invalid ( w ) ;
else
colorize_filter_te_as_valid ( w ) ;
}
} else {
/*
* Display filter search ; check it with " filter_te_syntax_check_cb() " .
*/
filter_te_syntax_check_cb ( w ) ;
}
}
2004-08-13 02:39:49 +00:00
/*
2004-02-28 04:18:47 +00:00
* This function will re - check the search text syntax .
2004-08-13 02:39:49 +00:00
*/
2004-02-28 04:18:47 +00:00
static void
hex_selected_cb ( GtkWidget * button_rb _U_ , gpointer parent_w )
{
2004-04-15 23:28:11 +00:00
GtkWidget * filter_text_box ;
2004-02-28 04:18:47 +00:00
filter_text_box = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FILT_TE_PTR_KEY ) ;
/* Re-check the display filter. */
find_filter_te_syntax_check_cb ( filter_text_box , parent_w ) ;
return ;
}
2004-08-13 02:39:49 +00:00
/*
2003-08-11 22:41:10 +00:00
* This function will disable the string options until
* the string search is selected .
2004-08-13 02:39:49 +00:00
*/
2003-08-11 22:41:10 +00:00
static void
2004-04-15 23:28:11 +00:00
string_selected_cb ( GtkWidget * button_rb _U_ , gpointer parent_w )
2003-08-11 22:41:10 +00:00
{
2004-04-15 23:28:11 +00:00
GtkWidget * string_rb , * hex_data_rb , * decode_data_rb , * summary_data_rb ,
2004-02-28 22:07:33 +00:00
* data_combo_lb , * data_combo_cb , * data_case_cb , * filter_text_box ;
2003-08-11 22:41:10 +00:00
2004-04-15 23:28:11 +00:00
string_rb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FIND_STRINGDATA_KEY ) ;
2003-08-11 22:41:10 +00:00
hex_data_rb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_SOURCE_HEX_KEY ) ;
decode_data_rb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_SOURCE_DECODE_KEY ) ;
summary_data_rb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_SOURCE_SUMMARY_KEY ) ;
2004-08-13 02:39:49 +00:00
2004-02-28 22:07:33 +00:00
data_combo_lb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FIND_STRINGTYPE_LABEL_KEY ) ;
2003-08-11 22:41:10 +00:00
data_combo_cb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FIND_STRINGTYPE_KEY ) ;
data_case_cb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_CASE_SEARCH_KEY ) ;
2004-02-28 04:18:47 +00:00
filter_text_box = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FILT_TE_PTR_KEY ) ;
2003-08-11 22:41:10 +00:00
2004-04-15 23:28:11 +00:00
if ( gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( string_rb ) ) ) {
2004-02-28 04:18:47 +00:00
gtk_widget_set_sensitive ( GTK_WIDGET ( hex_data_rb ) , TRUE ) ;
gtk_widget_set_sensitive ( GTK_WIDGET ( decode_data_rb ) , TRUE ) ;
gtk_widget_set_sensitive ( GTK_WIDGET ( summary_data_rb ) , TRUE ) ;
2004-02-28 22:07:33 +00:00
gtk_widget_set_sensitive ( GTK_WIDGET ( data_combo_lb ) , TRUE ) ;
2004-02-28 04:18:47 +00:00
gtk_widget_set_sensitive ( GTK_WIDGET ( data_combo_cb ) , TRUE ) ;
gtk_widget_set_sensitive ( GTK_WIDGET ( data_case_cb ) , TRUE ) ;
2003-08-11 22:41:10 +00:00
} else {
gtk_widget_set_sensitive ( GTK_WIDGET ( hex_data_rb ) , FALSE ) ;
gtk_widget_set_sensitive ( GTK_WIDGET ( decode_data_rb ) , FALSE ) ;
gtk_widget_set_sensitive ( GTK_WIDGET ( summary_data_rb ) , FALSE ) ;
2004-02-28 22:07:33 +00:00
gtk_widget_set_sensitive ( GTK_WIDGET ( data_combo_lb ) , FALSE ) ;
2003-08-11 22:41:10 +00:00
gtk_widget_set_sensitive ( GTK_WIDGET ( data_combo_cb ) , FALSE ) ;
gtk_widget_set_sensitive ( GTK_WIDGET ( data_case_cb ) , FALSE ) ;
}
2004-02-28 04:18:47 +00:00
/* Re-check the display filter. */
find_filter_te_syntax_check_cb ( filter_text_box , parent_w ) ;
2003-08-11 22:41:10 +00:00
return ;
}
2004-08-13 02:39:49 +00:00
/*
2003-08-28 23:25:55 +00:00
* This function will disable the filter button until
* the filter search is selected .
2004-08-13 02:39:49 +00:00
*/
2003-08-28 23:25:55 +00:00
static void
filter_selected_cb ( GtkWidget * button_rb _U_ , gpointer parent_w )
{
GtkWidget * filter_bt , * filter_rb ;
filter_bt = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FILT_TE_BUTTON_KEY ) ;
filter_rb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FIND_FILTERDATA_KEY ) ;
2004-08-13 02:39:49 +00:00
2003-08-28 23:25:55 +00:00
if ( gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( filter_rb ) ) )
{
gtk_widget_set_sensitive ( GTK_WIDGET ( filter_bt ) , TRUE ) ;
}
else
{
gtk_widget_set_sensitive ( GTK_WIDGET ( filter_bt ) , FALSE ) ;
}
return ;
}
1999-11-06 06:28:07 +00:00
static void
2002-03-05 11:56:00 +00:00
find_frame_ok_cb ( GtkWidget * ok_bt _U_ , gpointer parent_w )
1999-11-06 06:28:07 +00:00
{
2004-04-15 23:28:11 +00:00
GtkWidget * filter_te , * up_rb , * hex_rb , * string_rb , * combo_cb ,
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
* case_cb , * decode_data_rb , * summary_data_rb ;
2003-12-04 00:45:39 +00:00
const gchar * filter_text , * string_type ;
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
search_charset_t scs_type = SCS_ASCII_AND_UNICODE ;
guint8 * bytes = NULL ;
size_t nbytes ;
char * string = NULL ;
dfilter_t * sfcode ;
gboolean found_packet ;
1999-11-06 06:28:07 +00:00
2002-11-11 15:39:06 +00:00
filter_te = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FIND_FILT_KEY ) ;
2004-02-28 22:07:33 +00:00
up_rb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FIND_BACKWARD_KEY ) ;
2003-07-22 23:08:48 +00:00
hex_rb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FIND_HEXDATA_KEY ) ;
2004-04-15 23:28:11 +00:00
string_rb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FIND_STRINGDATA_KEY ) ;
2003-07-22 23:08:48 +00:00
combo_cb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_FIND_STRINGTYPE_KEY ) ;
2003-08-05 00:01:27 +00:00
case_cb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_CASE_SEARCH_KEY ) ;
2003-08-11 22:41:10 +00:00
decode_data_rb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_SOURCE_DECODE_KEY ) ;
summary_data_rb = ( GtkWidget * ) OBJECT_GET_DATA ( parent_w , E_SOURCE_SUMMARY_KEY ) ;
1999-11-06 06:28:07 +00:00
filter_text = gtk_entry_get_text ( GTK_ENTRY ( filter_te ) ) ;
2003-07-22 23:08:48 +00:00
string_type = gtk_entry_get_text ( GTK_ENTRY ( GTK_COMBO ( combo_cb ) - > entry ) ) ;
1999-11-06 06:28:07 +00:00
2004-02-28 22:07:33 +00:00
case_type = ! gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( case_cb ) ) ;
2003-08-11 22:41:10 +00:00
decode_data = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( decode_data_rb ) ) ;
summary_data = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( summary_data_rb ) ) ;
2003-08-05 00:01:27 +00:00
1999-11-06 06:28:07 +00:00
/*
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
* Process the search criterion .
1999-11-06 06:28:07 +00:00
*/
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
if ( gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( hex_rb ) ) ) {
/*
* Hex search - scan the search string to make sure it ' s valid hex
* and to find out how many bytes there are .
*/
bytes = convert_string_to_hex ( filter_text , & nbytes ) ;
if ( bytes = = NULL ) {
2004-01-31 03:22:42 +00:00
simple_dialog ( ESD_TYPE_ERROR , ESD_BTN_OK ,
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
" You didn't specify a valid hex string. " ) ;
return ;
}
2004-04-15 23:28:11 +00:00
} else if ( gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( string_rb ) ) ) {
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
/*
* String search .
2004-02-28 04:18:47 +00:00
* Make sure we ' re searching for something , first .
*/
if ( strcmp ( filter_text , " " ) = = 0 ) {
simple_dialog ( ESD_TYPE_ERROR , ESD_BTN_OK ,
" You didn't specify any text for which to search. " ) ;
return ;
}
/*
* We are - get the character set type .
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
*/
if ( strcmp ( string_type , " ASCII Unicode & Non-Unicode " ) = = 0 )
scs_type = SCS_ASCII_AND_UNICODE ;
else if ( strcmp ( string_type , " ASCII Non-Unicode " ) = = 0 )
scs_type = SCS_ASCII ;
else if ( strcmp ( string_type , " ASCII Unicode " ) = = 0 )
scs_type = SCS_UNICODE ;
else {
2004-01-31 03:22:42 +00:00
simple_dialog ( ESD_TYPE_ERROR , ESD_BTN_OK , " You didn't choose a valid character set. " ) ;
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
return ;
}
string = convert_string_case ( filter_text , case_type ) ;
} else {
/*
* Display filter search - try to compile the filter .
*/
if ( ! dfilter_compile ( filter_text , & sfcode ) ) {
/* The attempt failed; report an error. */
2004-02-11 00:55:28 +00:00
bad_dfilter_alert_box ( filter_text ) ;
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
return ;
}
1999-11-06 06:28:07 +00:00
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
/* Was it empty? */
if ( sfcode = = NULL ) {
/* Yes - complain. */
2004-01-31 03:22:42 +00:00
simple_dialog ( ESD_TYPE_ERROR , ESD_BTN_OK ,
2004-02-11 00:55:28 +00:00
" You specified a filter that doesn't test anything. " ) ;
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
return ;
}
1999-11-06 06:28:07 +00:00
}
/*
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
* Remember the search parameters .
1999-11-06 06:28:07 +00:00
*/
2000-06-27 04:36:03 +00:00
if ( cfile . sfilter )
g_free ( cfile . sfilter ) ;
cfile . sfilter = g_strdup ( filter_text ) ;
2004-02-28 22:07:33 +00:00
cfile . sbackward = GTK_TOGGLE_BUTTON ( up_rb ) - > active ;
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
cfile . hex = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( hex_rb ) ) ;
2004-04-15 23:28:11 +00:00
cfile . string = gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON ( string_rb ) ) ;
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
cfile . scs_type = scs_type ;
cfile . case_type = case_type ;
cfile . decode_data = decode_data ;
cfile . summary_data = summary_data ;
if ( cfile . hex ) {
2005-02-04 18:44:44 +00:00
found_packet = cf_find_packet_data ( & cfile , bytes , nbytes ) ;
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
g_free ( bytes ) ;
if ( ! found_packet ) {
/* We didn't find a packet */
2004-02-28 22:07:33 +00:00
simple_dialog ( ESD_TYPE_INFO , ESD_BTN_OK ,
" %sFound no match!%s \n \n "
" No packet contained those bytes. " ,
simple_dialog_primary_start ( ) , simple_dialog_primary_end ( ) ) ;
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
g_free ( bytes ) ;
return ;
}
2004-04-15 23:28:11 +00:00
} else if ( cfile . string ) {
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
/* OK, what are we searching? */
if ( cfile . decode_data ) {
/* The text in the protocol tree */
2005-02-04 18:44:44 +00:00
found_packet = cf_find_packet_protocol_tree ( & cfile , string ) ;
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
g_free ( string ) ;
if ( ! found_packet ) {
2003-07-22 23:08:48 +00:00
/* We didn't find the packet. */
2004-08-13 02:39:49 +00:00
simple_dialog ( ESD_TYPE_INFO , ESD_BTN_OK ,
2004-02-28 22:07:33 +00:00
" %sFound no match!%s \n \n "
" No packet contained that string in its dissected display. " ,
simple_dialog_primary_start ( ) , simple_dialog_primary_end ( ) ) ;
2003-07-22 23:08:48 +00:00
return ;
}
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
} else if ( cfile . summary_data ) {
/* The text in the summary line */
2005-02-04 18:44:44 +00:00
found_packet = cf_find_packet_summary_line ( & cfile , string ) ;
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
g_free ( string ) ;
if ( ! found_packet ) {
/* We didn't find the packet. */
2004-08-13 02:39:49 +00:00
simple_dialog ( ESD_TYPE_INFO , ESD_BTN_OK ,
2004-02-28 22:07:33 +00:00
" %sFound no match!%s \n \n "
" No packet contained that string in its Info column. " ,
simple_dialog_primary_start ( ) , simple_dialog_primary_end ( ) ) ;
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
return ;
2003-08-11 22:41:10 +00:00
}
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
} else {
/* The raw packet data */
2005-02-04 18:44:44 +00:00
found_packet = cf_find_packet_data ( & cfile , string , strlen ( string ) ) ;
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
g_free ( string ) ;
if ( ! found_packet ) {
/* We didn't find the packet. */
2004-08-13 02:39:49 +00:00
simple_dialog ( ESD_TYPE_INFO , ESD_BTN_OK ,
2004-02-28 22:07:33 +00:00
" %sFound no match!%s \n \n "
" No packet contained that string in its data. " ,
simple_dialog_primary_start ( ) , simple_dialog_primary_end ( ) ) ;
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
return ;
2003-07-22 23:08:48 +00:00
}
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
}
} else {
2005-02-04 18:44:44 +00:00
found_packet = cf_find_packet_dfilter ( & cfile , sfcode ) ;
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
dfilter_free ( sfcode ) ;
if ( ! found_packet ) {
/* We didn't find a packet */
2004-08-13 02:39:49 +00:00
simple_dialog ( ESD_TYPE_INFO , ESD_BTN_OK ,
2004-02-28 22:07:33 +00:00
" %sFound no match!%s \n \n "
" No packet matched that filter. " ,
simple_dialog_primary_start ( ) , simple_dialog_primary_end ( ) ) ;
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
g_free ( bytes ) ;
return ;
}
1999-11-06 06:54:24 +00:00
}
2004-05-26 03:49:24 +00:00
window_destroy ( GTK_WIDGET ( parent_w ) ) ;
1999-11-06 06:28:07 +00:00
}
static void
2002-03-05 11:56:00 +00:00
find_frame_close_cb ( GtkWidget * close_bt _U_ , gpointer parent_w )
1999-11-06 06:28:07 +00:00
{
gtk_grab_remove ( GTK_WIDGET ( parent_w ) ) ;
2004-05-26 03:49:24 +00:00
window_destroy ( GTK_WIDGET ( parent_w ) ) ;
1999-11-06 06:28:07 +00:00
}
Split "filter_dialog_cb()" into "filter_dialog_cb()", which pops up a
"global" dialog box when "Edit:Filters" is selected, so that the list of
filters can be edited, and "filter_browse_cb()", which pops up a dialog
box associated with a "Filter:" button and a text entry widget attached
to that button, so that a filter can be selected or saved (although it
also supports the same editing that the "global" dialog box does).
Have "filter_dialog_cb()" connect the window in which the "Filter:"
button lives and the filter dialog box, so that:
if the window in which the "Filter:" button lives goes away, so
does the filter dialog box (as it no longer has a text widget
into which it can stuff the selected filter);
if the "Filter:" button is clicked when there's already a filter
dialog box open, we just reactivate that existing dialog box
rather than popping up a new one.
Also keep a pointer to the "global" filter dialog box, so that we also
arrange that there's only one of them (by reactivating the existing on
if "Edit:Filters" is selected when there's already a "global" filter
dialog box open).
Keep around pointers to the dialog boxes that contain the "Filter:"
buttons, so that we can arrange that there be only one of them (that was
a side-effect of an earlier attempt at fixing the problems described
above, but it's still useful for keeping multiple competing dialog boxes
from being open - there's more of that to be done).
Make the pointer to the "Open Capture File" dialog box widget static to
"file_dlg.c" - nobody outside of "file_dlg.c cares about it.
svn path=/trunk/; revision=1774
2000-04-01 12:03:42 +00:00
static void
2003-01-15 05:20:19 +00:00
find_frame_destroy_cb ( GtkWidget * win _U_ , gpointer user_data _U_ )
Split "filter_dialog_cb()" into "filter_dialog_cb()", which pops up a
"global" dialog box when "Edit:Filters" is selected, so that the list of
filters can be edited, and "filter_browse_cb()", which pops up a dialog
box associated with a "Filter:" button and a text entry widget attached
to that button, so that a filter can be selected or saved (although it
also supports the same editing that the "global" dialog box does).
Have "filter_dialog_cb()" connect the window in which the "Filter:"
button lives and the filter dialog box, so that:
if the window in which the "Filter:" button lives goes away, so
does the filter dialog box (as it no longer has a text widget
into which it can stuff the selected filter);
if the "Filter:" button is clicked when there's already a filter
dialog box open, we just reactivate that existing dialog box
rather than popping up a new one.
Also keep a pointer to the "global" filter dialog box, so that we also
arrange that there's only one of them (by reactivating the existing on
if "Edit:Filters" is selected when there's already a "global" filter
dialog box open).
Keep around pointers to the dialog boxes that contain the "Filter:"
buttons, so that we can arrange that there be only one of them (that was
a side-effect of an earlier attempt at fixing the problems described
above, but it's still useful for keeping multiple competing dialog boxes
from being open - there's more of that to be done).
Make the pointer to the "Open Capture File" dialog box widget static to
"file_dlg.c" - nobody outside of "file_dlg.c cares about it.
svn path=/trunk/; revision=1774
2000-04-01 12:03:42 +00:00
{
2003-11-28 19:02:41 +00:00
/* Note that we no longer have a "Find Packet" dialog box. */
Split "filter_dialog_cb()" into "filter_dialog_cb()", which pops up a
"global" dialog box when "Edit:Filters" is selected, so that the list of
filters can be edited, and "filter_browse_cb()", which pops up a dialog
box associated with a "Filter:" button and a text entry widget attached
to that button, so that a filter can be selected or saved (although it
also supports the same editing that the "global" dialog box does).
Have "filter_dialog_cb()" connect the window in which the "Filter:"
button lives and the filter dialog box, so that:
if the window in which the "Filter:" button lives goes away, so
does the filter dialog box (as it no longer has a text widget
into which it can stuff the selected filter);
if the "Filter:" button is clicked when there's already a filter
dialog box open, we just reactivate that existing dialog box
rather than popping up a new one.
Also keep a pointer to the "global" filter dialog box, so that we also
arrange that there's only one of them (by reactivating the existing on
if "Edit:Filters" is selected when there's already a "global" filter
dialog box open).
Keep around pointers to the dialog boxes that contain the "Filter:"
buttons, so that we can arrange that there be only one of them (that was
a side-effect of an earlier attempt at fixing the problems described
above, but it's still useful for keeping multiple competing dialog boxes
from being open - there's more of that to be done).
Make the pointer to the "Open Capture File" dialog box widget static to
"file_dlg.c" - nobody outside of "file_dlg.c cares about it.
svn path=/trunk/; revision=1774
2000-04-01 12:03:42 +00:00
find_frame_w = NULL ;
}
2002-05-03 21:55:15 +00:00
static void
find_previous_next ( GtkWidget * w , gpointer d , gboolean sens )
{
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
guint8 * bytes ;
size_t nbytes ;
char * string ;
2002-05-03 21:55:15 +00:00
dfilter_t * sfcode ;
if ( cfile . sfilter ) {
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
cfile . sbackward = sens ;
if ( cfile . hex ) {
bytes = convert_string_to_hex ( cfile . sfilter , & nbytes ) ;
if ( bytes = = NULL ) {
/*
* XXX - this shouldn ' t happen , as we ' ve already successfully
* translated the string once .
*/
2002-05-03 21:55:15 +00:00
return ;
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
cf_find_packet_data ( & cfile , bytes , nbytes ) ;
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
g_free ( bytes ) ;
2004-04-15 23:28:11 +00:00
} else if ( cfile . string ) {
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
string = convert_string_case ( cfile . sfilter , cfile . case_type ) ;
/* OK, what are we searching? */
if ( cfile . decode_data ) {
/* The text in the protocol tree */
2005-02-04 18:44:44 +00:00
cf_find_packet_protocol_tree ( & cfile , string ) ;
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
} else if ( cfile . summary_data ) {
/* The text in the summary line */
2005-02-04 18:44:44 +00:00
cf_find_packet_summary_line ( & cfile , string ) ;
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
} else {
/* The raw packet data */
2005-02-04 18:44:44 +00:00
cf_find_packet_data ( & cfile , string , strlen ( string ) ) ;
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
}
g_free ( string ) ;
} else {
if ( ! dfilter_compile ( cfile . sfilter , & sfcode ) ) {
/*
* XXX - this shouldn ' t happen , as we ' ve already successfully
* translated the string once .
*/
2002-05-03 21:55:15 +00:00
return ;
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
}
if ( sfcode = = NULL ) {
/*
* XXX - this shouldn ' t happen , as we ' ve already found that the
* string wasn ' t null .
*/
return ;
}
2005-02-04 18:44:44 +00:00
cf_find_packet_dfilter ( & cfile , sfcode ) ;
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
dfilter_free ( sfcode ) ;
}
2002-05-03 21:55:15 +00:00
} else
find_frame_cb ( w , d ) ;
}
void
find_next_cb ( GtkWidget * w , gpointer d )
{
find_previous_next ( w , d , FALSE ) ;
}
void
find_previous_cb ( GtkWidget * w , gpointer d )
{
find_previous_next ( w , d , TRUE ) ;
}
2003-10-07 09:30:34 +00:00
/* this function jumps to the next packet matching the filter */
2004-08-13 02:39:49 +00:00
void
2003-10-07 09:30:34 +00:00
find_previous_next_frame_with_filter ( char * filter , gboolean backwards )
{
dfilter_t * sfcode ;
gboolean sbackwards_saved ;
/* temporarily set the direction we want to search */
sbackwards_saved = cfile . sbackward ;
cfile . sbackward = backwards ;
if ( ! dfilter_compile ( filter , & sfcode ) ) {
/*
* XXX - this shouldn ' t happen , as the filter string is machine
* generated
*/
return ;
}
if ( sfcode = = NULL ) {
/*
* XXX - this shouldn ' t happen , as the filter string is machine
* generated .
*/
return ;
}
2005-02-04 18:44:44 +00:00
cf_find_packet_dfilter ( & cfile , sfcode ) ;
2003-10-07 09:30:34 +00:00
dfilter_free ( sfcode ) ;
cfile . sbackward = sbackwards_saved ;
}