1999-09-09 03:32:03 +00:00
|
|
|
/* capture_dlg.c
|
|
|
|
* Routines for packet capture windows
|
|
|
|
*
|
2001-12-09 03:20:19 +00:00
|
|
|
* $Id: capture_dlg.c,v 1.52 2001/12/09 03:20:19 guy Exp $
|
1999-09-09 03:32:03 +00:00
|
|
|
*
|
|
|
|
* Ethereal - Network traffic analyzer
|
2001-09-26 20:02:36 +00:00
|
|
|
* By Gerald Combs <gerald@ethereal.com>
|
1999-09-09 03:32:03 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* 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
|
|
|
|
|
1999-10-02 19:33:14 +00:00
|
|
|
#ifdef HAVE_LIBPCAP
|
|
|
|
|
1999-09-09 03:32:03 +00:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <gtk/gtk.h>
|
|
|
|
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <time.h>
|
|
|
|
|
2001-01-28 23:56:29 +00:00
|
|
|
#include <pcap.h>
|
|
|
|
|
1999-09-11 06:23:28 +00:00
|
|
|
#ifdef NEED_SNPRINTF_H
|
|
|
|
# include "snprintf.h"
|
|
|
|
#endif
|
|
|
|
|
1999-09-09 03:32:03 +00:00
|
|
|
#include "capture.h"
|
|
|
|
#include "globals.h"
|
2000-10-19 22:59:24 +00:00
|
|
|
#include "resolv.h"
|
1999-09-09 03:32:03 +00:00
|
|
|
#include "main.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-09-09 03:32:03 +00:00
|
|
|
#include "capture_dlg.h"
|
2000-02-12 06:46:54 +00:00
|
|
|
#include "filter_prefs.h"
|
2000-01-03 06:59:25 +00:00
|
|
|
#include "simple_dialog.h"
|
2000-05-03 07:09:40 +00:00
|
|
|
#include "dlg_utils.h"
|
2001-11-09 07:44:51 +00:00
|
|
|
#include "pcap-util.h"
|
2001-04-13 14:59:30 +00:00
|
|
|
#include "prefs.h"
|
2001-12-04 08:26:00 +00:00
|
|
|
#include "ringbuffer.h"
|
1999-09-09 03:32:03 +00:00
|
|
|
|
2001-04-03 05:26:27 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
#include "capture-wpcap.h"
|
|
|
|
#endif
|
|
|
|
|
1999-09-09 03:32:03 +00:00
|
|
|
/* Capture callback data keys */
|
2000-01-18 09:25:04 +00:00
|
|
|
#define E_CAP_IFACE_KEY "cap_iface"
|
|
|
|
#define E_CAP_FILT_KEY "cap_filter_te"
|
|
|
|
#define E_CAP_FILE_TE_KEY "cap_file_te"
|
|
|
|
#define E_CAP_COUNT_KEY "cap_count"
|
|
|
|
#define E_CAP_SNAP_KEY "cap_snap"
|
2000-09-15 05:32:49 +00:00
|
|
|
#define E_CAP_PROMISC_KEY "cap_promisc"
|
2000-01-18 09:25:04 +00:00
|
|
|
#define E_CAP_SYNC_KEY "cap_sync"
|
|
|
|
#define E_CAP_AUTO_SCROLL_KEY "cap_auto_scroll"
|
2001-05-31 08:36:46 +00:00
|
|
|
#define E_CAP_M_RESOLVE_KEY "cap_m_resolve"
|
|
|
|
#define E_CAP_N_RESOLVE_KEY "cap_n_resolve"
|
|
|
|
#define E_CAP_T_RESOLVE_KEY "cap_t_resolve"
|
2001-12-04 07:32:05 +00:00
|
|
|
#define E_CAP_FILESIZE_KEY "cap_filesize"
|
|
|
|
#define E_CAP_DURATION_KEY "cap_duration"
|
2001-12-04 09:46:01 +00:00
|
|
|
#define E_CAP_RING_ON_TB_KEY "cap_ringbuffer_on_tb"
|
|
|
|
#define E_CAP_RING_NBF_LB_KEY "cap_ringbuffer_nbf_lb"
|
|
|
|
#define E_CAP_RING_NBF_SB_KEY "cap_ringbuffer_nbf_sb"
|
1999-09-09 03:32:03 +00:00
|
|
|
|
2000-05-08 05:42:54 +00:00
|
|
|
#define E_FS_CALLER_PTR_KEY "fs_caller_ptr"
|
|
|
|
#define E_FILE_SEL_DIALOG_PTR_KEY "file_sel_dialog_ptr"
|
|
|
|
|
1999-10-02 07:13:20 +00:00
|
|
|
static void
|
|
|
|
capture_prep_file_cb(GtkWidget *w, gpointer te);
|
|
|
|
|
|
|
|
static void
|
|
|
|
cap_prep_fs_ok_cb(GtkWidget *w, gpointer data);
|
|
|
|
|
|
|
|
static void
|
|
|
|
cap_prep_fs_cancel_cb(GtkWidget *w, gpointer data);
|
|
|
|
|
2000-05-08 05:42:54 +00:00
|
|
|
static void
|
|
|
|
cap_prep_fs_destroy_cb(GtkWidget *win, gpointer data);
|
|
|
|
|
2001-12-04 08:26:00 +00:00
|
|
|
static void
|
2001-12-04 09:46:01 +00:00
|
|
|
capture_prep_adjust_sensitivity(GtkWidget *tb, gpointer parent_w);
|
2001-12-04 08:26:00 +00:00
|
|
|
|
1999-09-09 03:32:03 +00:00
|
|
|
static void
|
|
|
|
capture_prep_ok_cb(GtkWidget *ok_bt, gpointer parent_w);
|
|
|
|
|
|
|
|
static void
|
|
|
|
capture_prep_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
|
|
|
|
capture_prep_destroy_cb(GtkWidget *win, gpointer user_data);
|
|
|
|
|
2000-10-11 06:01:16 +00:00
|
|
|
void
|
|
|
|
capture_stop_cb(GtkWidget *w, gpointer d)
|
|
|
|
{
|
|
|
|
capture_stop();
|
|
|
|
}
|
|
|
|
|
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
|
|
|
/*
|
|
|
|
* Keep a static pointer to the current "Capture Preferences" window, if
|
|
|
|
* any, so that if somebody tries to do "Capture:Start" while there's
|
|
|
|
* already a "Capture Preferences" window up, we just pop up the existing
|
|
|
|
* one, rather than creating a new one.
|
|
|
|
*/
|
|
|
|
static GtkWidget *cap_open_w;
|
|
|
|
|
1999-09-09 03:32:03 +00:00
|
|
|
void
|
1999-10-02 07:13:20 +00:00
|
|
|
capture_prep_cb(GtkWidget *w, gpointer d)
|
|
|
|
{
|
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
|
|
|
GtkWidget *if_cb, *if_lb,
|
2000-08-23 20:55:44 +00:00
|
|
|
*count_lb, *count_cb, *main_vb,
|
|
|
|
*filter_bt, *filter_te,
|
|
|
|
*file_bt, *file_te,
|
2001-12-04 07:32:05 +00:00
|
|
|
*filesize_lb, *filesize_cb,
|
|
|
|
*duration_lb, *duration_cb,
|
2000-08-23 20:55:44 +00:00
|
|
|
*caplen_hb, *table,
|
1999-09-09 03:32:03 +00:00
|
|
|
*bbox, *ok_bt, *cancel_bt, *snap_lb,
|
2001-05-31 08:36:46 +00:00
|
|
|
*snap_sb, *promisc_cb, *sync_cb, *auto_scroll_cb,
|
2001-12-04 08:26:00 +00:00
|
|
|
*m_resolv_cb, *n_resolv_cb, *t_resolv_cb,
|
|
|
|
*ringbuffer_hb, *ringbuffer_on_tb, *ringbuffer_nbf_lb, *ringbuffer_nbf_sb;
|
2000-05-08 05:51:37 +00:00
|
|
|
GtkAccelGroup *accel_group;
|
2001-12-04 08:26:00 +00:00
|
|
|
GtkAdjustment *snap_adj, *ringbuffer_nbf_adj;
|
2001-12-04 07:32:05 +00:00
|
|
|
GList *if_list, *count_list = NULL, *filesize_list = NULL, *duration_list = NULL;
|
|
|
|
gchar *count_item1 = "0 (Infinite)", count_item2[16],
|
|
|
|
*filesize_item1 = "0 (Infinite)", filesize_item2[16],
|
|
|
|
*duration_item1 = "0 (Infinite)", duration_item2[16];
|
2000-01-16 02:48:12 +00:00
|
|
|
int err;
|
|
|
|
char err_str[PCAP_ERRBUF_SIZE];
|
1999-09-09 03:32:03 +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 (cap_open_w != NULL) {
|
|
|
|
/* There's already a "Capture Preferences" dialog box; reactivate it. */
|
|
|
|
reactivate_window(cap_open_w);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2001-04-03 05:26:27 +00:00
|
|
|
#ifdef _WIN32
|
|
|
|
/* Is WPcap loaded? */
|
|
|
|
if (!has_wpcap) {
|
|
|
|
simple_dialog(ESD_TYPE_CRIT, NULL,
|
2001-09-26 20:02:36 +00:00
|
|
|
"Unable to load WinPcap (wpcap.dll); Ethereal will not be able\n"
|
|
|
|
"to capture packets.\n\n"
|
|
|
|
"In order to capture packets, WinPcap must be installed; see\n"
|
2001-09-28 07:50:48 +00:00
|
|
|
"\n"
|
2001-09-29 19:56:08 +00:00
|
|
|
" http://netgroup-serv.polito.it/winpcap/\n"
|
|
|
|
"\n"
|
|
|
|
"or the mirror at\n"
|
|
|
|
"\n"
|
2001-10-31 07:11:08 +00:00
|
|
|
" http://netgroup-mirror.ethereal.com/winpcap/\n"
|
|
|
|
"\n"
|
|
|
|
"or the mirror at\n"
|
|
|
|
"\n"
|
2001-09-29 19:56:08 +00:00
|
|
|
" http://www.wiretapped.net/security/packet-capture/winpcap/default.htm\n"
|
2001-09-28 07:50:48 +00:00
|
|
|
"\n"
|
2001-09-26 20:02:36 +00:00
|
|
|
"for a downloadable version of WinPcap and for instructions\n"
|
|
|
|
"on how to install WinPcap.");
|
2001-04-03 05:26:27 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2000-01-16 02:48:12 +00:00
|
|
|
if_list = get_interface_list(&err, err_str);
|
|
|
|
if (if_list == NULL && err == CANT_GET_INTERFACE_LIST) {
|
|
|
|
simple_dialog(ESD_TYPE_WARN, NULL, "Can't get list of interfaces: %s",
|
|
|
|
err_str);
|
|
|
|
}
|
1999-09-09 03:32:03 +00:00
|
|
|
|
2000-08-23 06:56:31 +00:00
|
|
|
cap_open_w = dlg_window_new("Ethereal: Capture Preferences");
|
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
|
|
|
gtk_signal_connect(GTK_OBJECT(cap_open_w), "destroy",
|
|
|
|
GTK_SIGNAL_FUNC(capture_prep_destroy_cb), NULL);
|
2000-05-08 05:51:37 +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(cap_open_w), accel_group);
|
1999-09-09 03:32:03 +00:00
|
|
|
|
|
|
|
main_vb = gtk_vbox_new(FALSE, 3);
|
|
|
|
gtk_container_border_width(GTK_CONTAINER(main_vb), 5);
|
|
|
|
gtk_container_add(GTK_CONTAINER(cap_open_w), main_vb);
|
|
|
|
gtk_widget_show(main_vb);
|
|
|
|
|
2001-12-04 07:32:05 +00:00
|
|
|
/* Table : container of the first 6 rows */
|
|
|
|
table = gtk_table_new (6, 2, FALSE);
|
2000-08-23 20:55:44 +00:00
|
|
|
gtk_table_set_row_spacings(GTK_TABLE (table), 5);
|
|
|
|
gtk_table_set_col_spacings(GTK_TABLE (table), 5);
|
|
|
|
gtk_container_add(GTK_CONTAINER(main_vb), table);
|
|
|
|
gtk_widget_show(table);
|
|
|
|
|
1999-09-09 03:32:03 +00:00
|
|
|
/* Interface row */
|
|
|
|
|
|
|
|
if_lb = gtk_label_new("Interface:");
|
2000-08-23 20:55:44 +00:00
|
|
|
gtk_table_attach_defaults(GTK_TABLE(table), if_lb, 0, 1, 0, 1);
|
1999-09-09 03:32:03 +00:00
|
|
|
gtk_widget_show(if_lb);
|
|
|
|
|
|
|
|
if_cb = gtk_combo_new();
|
I thought I'd seen a problem with the combo box in the "Capture:Start"
dialog box if we hadn't found any interfaces on which we could capture,
but perhaps the problem was that "gtk_combo_set_popdown_strings()"
doesn't like it if you set the list of items to a NULL list - if you
don't set it at all, you get a combo box with only one blank entry in
the list, but you don't seem to get complaints from GTK+ 1.2.6, at
least.
Pop up the "Capture:Start" dialog box even if we don't find any
interfaces on which we could capture; at least this way, they won't just
get confronted with a
There are no network interfaces that can be opened.
Please check to make sure you have sufficient permission
to capture packets.
message box and no way to give us any more information other than "it
said 'There are no network interfaces that can be opened...'" - they can
at least try the interfaces that *should* work, and report the error
messages they get, giving us a better chance at figuring out what the
problem is.
Trim white space from the entry in that combo box, and, if there isn't
anything other than possibly white space, pop up a
You didn't specify an interface on which to capture packets.
message box and leave the dialog box up so that the user can supply an
interface name.
svn path=/trunk/; revision=1373
1999-12-23 09:31:09 +00:00
|
|
|
if (if_list != NULL)
|
|
|
|
gtk_combo_set_popdown_strings(GTK_COMBO(if_cb), if_list);
|
2000-06-27 04:36:03 +00:00
|
|
|
if (cfile.iface)
|
|
|
|
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(if_cb)->entry), cfile.iface);
|
1999-09-09 03:32:03 +00:00
|
|
|
else if (if_list)
|
|
|
|
gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(if_cb)->entry), if_list->data);
|
2000-08-23 20:55:44 +00:00
|
|
|
gtk_table_attach_defaults(GTK_TABLE(table), if_cb, 1, 2, 0, 1);
|
1999-09-09 03:32:03 +00:00
|
|
|
gtk_widget_show(if_cb);
|
|
|
|
|
2000-01-16 02:48:12 +00:00
|
|
|
free_interface_list(if_list);
|
1999-09-09 03:32:03 +00:00
|
|
|
|
|
|
|
/* Count row */
|
|
|
|
|
|
|
|
count_lb = gtk_label_new("Count:");
|
2000-08-23 20:55:44 +00:00
|
|
|
gtk_table_attach_defaults(GTK_TABLE(table), count_lb, 0, 1, 1, 2);
|
1999-09-09 03:32:03 +00:00
|
|
|
gtk_widget_show(count_lb);
|
|
|
|
|
|
|
|
count_list = g_list_append(count_list, count_item1);
|
2000-06-27 04:36:03 +00:00
|
|
|
if (cfile.count) {
|
|
|
|
snprintf(count_item2, 15, "%d", cfile.count);
|
1999-09-09 03:32:03 +00:00
|
|
|
count_list = g_list_append(count_list, count_item2);
|
|
|
|
}
|
|
|
|
|
|
|
|
count_cb = gtk_combo_new();
|
|
|
|
gtk_combo_set_popdown_strings(GTK_COMBO(count_cb), count_list);
|
2000-08-23 20:55:44 +00:00
|
|
|
gtk_table_attach_defaults(GTK_TABLE(table), count_cb, 1, 2, 1, 2);
|
1999-09-09 03:32:03 +00:00
|
|
|
gtk_widget_show(count_cb);
|
|
|
|
|
|
|
|
while (count_list)
|
|
|
|
count_list = g_list_remove_link(count_list, count_list);
|
|
|
|
|
2001-12-04 07:32:05 +00:00
|
|
|
/* Filesize row */
|
|
|
|
|
|
|
|
filesize_lb = gtk_label_new("File size:");
|
|
|
|
gtk_table_attach_defaults(GTK_TABLE(table), filesize_lb, 0, 1, 2, 3);
|
|
|
|
gtk_widget_show(filesize_lb);
|
|
|
|
|
|
|
|
filesize_list = g_list_append(filesize_list, filesize_item1);
|
|
|
|
if (cfile.autostop_filesize) {
|
2001-12-04 08:26:00 +00:00
|
|
|
snprintf(filesize_item2, 15, "%d", cfile.autostop_filesize);
|
2001-12-04 07:32:05 +00:00
|
|
|
filesize_list = g_list_append(filesize_list, filesize_item2);
|
|
|
|
}
|
|
|
|
|
|
|
|
filesize_cb = gtk_combo_new();
|
|
|
|
gtk_combo_set_popdown_strings(GTK_COMBO(filesize_cb), filesize_list);
|
|
|
|
gtk_table_attach_defaults(GTK_TABLE(table), filesize_cb, 1, 2, 2, 3);
|
|
|
|
gtk_widget_show(filesize_cb);
|
|
|
|
|
|
|
|
while (filesize_list)
|
|
|
|
filesize_list = g_list_remove_link(filesize_list, filesize_list);
|
|
|
|
|
|
|
|
/* Duration row */
|
|
|
|
|
|
|
|
duration_lb = gtk_label_new("Duration:");
|
|
|
|
gtk_table_attach_defaults(GTK_TABLE(table), duration_lb, 0, 1, 3, 4);
|
|
|
|
gtk_widget_show(duration_lb);
|
|
|
|
|
|
|
|
duration_list = g_list_append(duration_list, duration_item1);
|
|
|
|
if (cfile.autostop_duration) {
|
|
|
|
snprintf(duration_item2, 15, "%d", cfile.autostop_duration);
|
|
|
|
duration_list = g_list_append(duration_list, duration_item2);
|
|
|
|
}
|
|
|
|
|
|
|
|
duration_cb = gtk_combo_new();
|
|
|
|
gtk_combo_set_popdown_strings(GTK_COMBO(duration_cb), duration_list);
|
|
|
|
gtk_table_attach_defaults(GTK_TABLE(table), duration_cb, 1, 2, 3, 4);
|
|
|
|
gtk_widget_show(duration_cb);
|
|
|
|
|
|
|
|
while (duration_list)
|
|
|
|
duration_list = g_list_remove_link(duration_list, duration_list);
|
|
|
|
|
1999-09-09 03:32:03 +00:00
|
|
|
/* Filter row */
|
|
|
|
|
|
|
|
filter_bt = gtk_button_new_with_label("Filter:");
|
|
|
|
gtk_signal_connect(GTK_OBJECT(filter_bt), "clicked",
|
2001-01-02 01:32:21 +00:00
|
|
|
GTK_SIGNAL_FUNC(capture_filter_construct_cb), NULL);
|
2001-12-04 07:32:05 +00:00
|
|
|
gtk_table_attach_defaults(GTK_TABLE(table), filter_bt, 0, 1, 4, 5);
|
1999-09-09 03:32:03 +00:00
|
|
|
gtk_widget_show(filter_bt);
|
|
|
|
|
|
|
|
filter_te = gtk_entry_new();
|
2000-06-27 04:36:03 +00:00
|
|
|
if (cfile.cfilter) gtk_entry_set_text(GTK_ENTRY(filter_te), cfile.cfilter);
|
1999-09-09 03:32:03 +00:00
|
|
|
gtk_object_set_data(GTK_OBJECT(filter_bt), E_FILT_TE_PTR_KEY, filter_te);
|
2001-12-04 07:32:05 +00:00
|
|
|
gtk_table_attach_defaults(GTK_TABLE(table), filter_te, 1, 2, 4, 5);
|
1999-09-09 03:32:03 +00:00
|
|
|
gtk_widget_show(filter_te);
|
1999-10-02 07:13:20 +00:00
|
|
|
|
|
|
|
/* File row */
|
|
|
|
|
|
|
|
file_bt = gtk_button_new_with_label("File:");
|
2001-12-04 07:32:05 +00:00
|
|
|
gtk_table_attach_defaults(GTK_TABLE(table), file_bt, 0, 1, 5, 6);
|
1999-10-02 07:13:20 +00:00
|
|
|
gtk_widget_show(file_bt);
|
|
|
|
|
|
|
|
file_te = gtk_entry_new();
|
2001-12-04 07:32:05 +00:00
|
|
|
gtk_table_attach_defaults(GTK_TABLE(table), file_te, 1, 2, 5, 6);
|
1999-10-02 07:13:20 +00:00
|
|
|
gtk_widget_show(file_te);
|
|
|
|
|
|
|
|
gtk_signal_connect(GTK_OBJECT(file_bt), "clicked",
|
|
|
|
GTK_SIGNAL_FUNC(capture_prep_file_cb), GTK_OBJECT(file_te));
|
1999-09-09 03:32:03 +00:00
|
|
|
|
2001-12-04 07:32:05 +00:00
|
|
|
/* Misc row: Snap spinbutton */
|
1999-09-09 03:32:03 +00:00
|
|
|
caplen_hb = gtk_hbox_new(FALSE, 3);
|
|
|
|
gtk_container_add(GTK_CONTAINER(main_vb), caplen_hb);
|
|
|
|
gtk_widget_show(caplen_hb);
|
|
|
|
|
|
|
|
snap_lb = gtk_label_new("Capture length");
|
|
|
|
gtk_misc_set_alignment(GTK_MISC(snap_lb), 0, 0.5);
|
|
|
|
gtk_box_pack_start(GTK_BOX(caplen_hb), snap_lb, FALSE, FALSE, 6);
|
|
|
|
gtk_widget_show(snap_lb);
|
|
|
|
|
2001-12-04 07:32:05 +00:00
|
|
|
snap_adj = (GtkAdjustment *) gtk_adjustment_new((float) cfile.snap,
|
1999-09-09 03:32:03 +00:00
|
|
|
MIN_PACKET_SIZE, WTAP_MAX_PACKET_SIZE, 1.0, 10.0, 0.0);
|
2001-12-04 07:32:05 +00:00
|
|
|
snap_sb = gtk_spin_button_new (snap_adj, 0, 0);
|
1999-09-09 03:32:03 +00:00
|
|
|
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (snap_sb), TRUE);
|
|
|
|
gtk_widget_set_usize (snap_sb, 80, 0);
|
|
|
|
gtk_box_pack_start (GTK_BOX(caplen_hb), snap_sb, FALSE, FALSE, 3);
|
|
|
|
gtk_widget_show(snap_sb);
|
|
|
|
|
2000-09-15 05:32:49 +00:00
|
|
|
promisc_cb = dlg_check_button_new_with_label_with_mnemonic(
|
|
|
|
"Capture packets in _promiscuous mode", accel_group);
|
2001-04-13 14:59:30 +00:00
|
|
|
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(promisc_cb), prefs.capture_prom_mode);
|
2000-09-15 05:32:49 +00:00
|
|
|
gtk_container_add(GTK_CONTAINER(main_vb), promisc_cb);
|
|
|
|
gtk_widget_show(promisc_cb);
|
|
|
|
|
2001-12-04 09:46:01 +00:00
|
|
|
/* Misc row: Ring buffer toggle button and Ring buffer spinbutton */
|
2001-12-04 08:26:00 +00:00
|
|
|
ringbuffer_hb = gtk_hbox_new(FALSE, 3);
|
|
|
|
gtk_container_add(GTK_CONTAINER(main_vb), ringbuffer_hb);
|
|
|
|
gtk_widget_show(ringbuffer_hb);
|
|
|
|
|
|
|
|
ringbuffer_on_tb = dlg_check_button_new_with_label_with_mnemonic(
|
2001-12-04 09:46:01 +00:00
|
|
|
"Use _ring buffer", accel_group);
|
|
|
|
/* Ring buffer mode is allowed only if we're not doing an "Update list of
|
|
|
|
packets in real time" capture, so force it off if we're doing such
|
|
|
|
a capture. */
|
|
|
|
if (prefs.capture_real_time)
|
2001-12-04 08:26:00 +00:00
|
|
|
cfile.ringbuffer_on = FALSE;
|
|
|
|
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(ringbuffer_on_tb),cfile.ringbuffer_on);
|
|
|
|
gtk_signal_connect(GTK_OBJECT(ringbuffer_on_tb), "toggled",
|
2001-12-04 09:46:01 +00:00
|
|
|
GTK_SIGNAL_FUNC(capture_prep_adjust_sensitivity), GTK_OBJECT(cap_open_w));
|
2001-12-04 08:26:00 +00:00
|
|
|
gtk_box_pack_start(GTK_BOX(ringbuffer_hb), ringbuffer_on_tb, FALSE, FALSE, 0);
|
|
|
|
gtk_widget_show(ringbuffer_on_tb);
|
|
|
|
|
|
|
|
ringbuffer_nbf_lb = gtk_label_new("Number of files");
|
|
|
|
gtk_misc_set_alignment(GTK_MISC(ringbuffer_nbf_lb), 1, 0.5);
|
|
|
|
gtk_box_pack_start(GTK_BOX(ringbuffer_hb), ringbuffer_nbf_lb, FALSE, FALSE, 6);
|
|
|
|
gtk_widget_show(ringbuffer_nbf_lb);
|
|
|
|
|
|
|
|
ringbuffer_nbf_adj = (GtkAdjustment *) gtk_adjustment_new((float) cfile.ringbuffer_num_files,
|
|
|
|
RINGBUFFER_MIN_NUM_FILES, RINGBUFFER_MAX_NUM_FILES, 1.0, 10.0, 0.0);
|
|
|
|
ringbuffer_nbf_sb = gtk_spin_button_new (ringbuffer_nbf_adj, 0, 0);
|
|
|
|
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (ringbuffer_nbf_sb), TRUE);
|
|
|
|
gtk_widget_set_usize (ringbuffer_nbf_sb, 40, 0);
|
|
|
|
gtk_box_pack_start (GTK_BOX(ringbuffer_hb), ringbuffer_nbf_sb, TRUE, TRUE, 0);
|
|
|
|
gtk_widget_show(ringbuffer_nbf_sb);
|
|
|
|
|
2001-12-04 07:32:05 +00:00
|
|
|
/* Misc row: Capture file checkboxes */
|
2000-05-08 05:51:37 +00:00
|
|
|
sync_cb = dlg_check_button_new_with_label_with_mnemonic(
|
|
|
|
"_Update list of packets in real time", accel_group);
|
2001-04-13 14:59:30 +00:00
|
|
|
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(sync_cb), prefs.capture_real_time);
|
2001-12-04 08:26:00 +00:00
|
|
|
gtk_signal_connect(GTK_OBJECT(sync_cb), "toggled",
|
2001-12-04 09:46:01 +00:00
|
|
|
GTK_SIGNAL_FUNC(capture_prep_adjust_sensitivity), GTK_OBJECT(cap_open_w));
|
Move the toolkit-independent code to create a temporary capture file,
and to fork off and run a separate copy of "ethereal" for "-S" and "-F"
captures or just call "capture()" otherwise, out of "gtk/capture_dlg.c"
and into a routine in "capture.c".
If the attempt to create said temporary capture file fails, pop up a
dialog box and don't do the capture.
Have the child capture process send a message upstream after it either
successfully starts the capture and syncs out the header of the capture
file, or fails to start the capture; the message indicates whether it
succeeded or failed, and, if it failed, includes a failure message.
This:
avoids the use of a signal, and thus means we don't have to
worry about whether to capture the signal, or whether to start
or stop capturing depending on whether this particular capture
is in sync mode or not;
lets us pop up the message box for the error in the parent
process if we're in sync mode, rather than doing it in the
child, which didn't work well.
Add a check button to the Capture/Start dialog box, so that we can
control, for each capture, whether it's to be done in sync mode or not.
svn path=/trunk/; revision=708
1999-09-23 06:27:27 +00:00
|
|
|
gtk_container_add(GTK_CONTAINER(main_vb), sync_cb);
|
|
|
|
gtk_widget_show(sync_cb);
|
1999-09-26 14:40:01 +00:00
|
|
|
|
2000-05-08 05:51:37 +00:00
|
|
|
auto_scroll_cb = dlg_check_button_new_with_label_with_mnemonic(
|
|
|
|
"_Automatic scrolling in live capture", accel_group);
|
2001-04-13 14:59:30 +00:00
|
|
|
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(auto_scroll_cb), prefs.capture_auto_scroll);
|
2000-01-18 09:25:04 +00:00
|
|
|
gtk_container_add(GTK_CONTAINER(main_vb), auto_scroll_cb);
|
|
|
|
gtk_widget_show(auto_scroll_cb);
|
|
|
|
|
2001-05-31 08:36:46 +00:00
|
|
|
m_resolv_cb = dlg_check_button_new_with_label_with_mnemonic(
|
|
|
|
"Enable _MAC name resolution", accel_group);
|
|
|
|
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(m_resolv_cb),
|
|
|
|
prefs.name_resolve & PREFS_RESOLV_MAC);
|
|
|
|
gtk_container_add(GTK_CONTAINER(main_vb), m_resolv_cb);
|
|
|
|
gtk_widget_show(m_resolv_cb);
|
|
|
|
|
|
|
|
n_resolv_cb = dlg_check_button_new_with_label_with_mnemonic(
|
|
|
|
"Enable _network name resolution", accel_group);
|
|
|
|
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(n_resolv_cb),
|
|
|
|
prefs.name_resolve & PREFS_RESOLV_NETWORK);
|
|
|
|
gtk_container_add(GTK_CONTAINER(main_vb), n_resolv_cb);
|
|
|
|
gtk_widget_show(n_resolv_cb);
|
|
|
|
|
|
|
|
t_resolv_cb = dlg_check_button_new_with_label_with_mnemonic(
|
|
|
|
"Enable _transport name resolution", accel_group);
|
|
|
|
gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(t_resolv_cb),
|
|
|
|
prefs.name_resolve & PREFS_RESOLV_TRANSPORT);
|
|
|
|
gtk_container_add(GTK_CONTAINER(main_vb), t_resolv_cb);
|
|
|
|
gtk_widget_show(t_resolv_cb);
|
Move the toolkit-independent code to create a temporary capture file,
and to fork off and run a separate copy of "ethereal" for "-S" and "-F"
captures or just call "capture()" otherwise, out of "gtk/capture_dlg.c"
and into a routine in "capture.c".
If the attempt to create said temporary capture file fails, pop up a
dialog box and don't do the capture.
Have the child capture process send a message upstream after it either
successfully starts the capture and syncs out the header of the capture
file, or fails to start the capture; the message indicates whether it
succeeded or failed, and, if it failed, includes a failure message.
This:
avoids the use of a signal, and thus means we don't have to
worry about whether to capture the signal, or whether to start
or stop capturing depending on whether this particular capture
is in sync mode or not;
lets us pop up the message box for the error in the parent
process if we're in sync mode, rather than doing it in the
child, which didn't work well.
Add a check button to the Capture/Start dialog box, so that we can
control, for each capture, whether it's to be done in sync mode or not.
svn path=/trunk/; revision=708
1999-09-23 06:27:27 +00:00
|
|
|
|
1999-09-09 03:32:03 +00:00
|
|
|
/* Button row: OK and cancel buttons */
|
|
|
|
bbox = gtk_hbutton_box_new();
|
|
|
|
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
|
|
|
|
gtk_button_box_set_spacing(GTK_BUTTON_BOX(bbox), 5);
|
|
|
|
gtk_container_add(GTK_CONTAINER(main_vb), bbox);
|
|
|
|
gtk_widget_show(bbox);
|
|
|
|
|
|
|
|
ok_bt = gtk_button_new_with_label ("OK");
|
|
|
|
gtk_signal_connect(GTK_OBJECT(ok_bt), "clicked",
|
|
|
|
GTK_SIGNAL_FUNC(capture_prep_ok_cb), GTK_OBJECT(cap_open_w));
|
|
|
|
GTK_WIDGET_SET_FLAGS(ok_bt, GTK_CAN_DEFAULT);
|
|
|
|
gtk_box_pack_start (GTK_BOX (bbox), ok_bt, TRUE, TRUE, 0);
|
|
|
|
gtk_widget_grab_default(ok_bt);
|
|
|
|
gtk_widget_show(ok_bt);
|
|
|
|
|
|
|
|
cancel_bt = gtk_button_new_with_label ("Cancel");
|
|
|
|
gtk_signal_connect(GTK_OBJECT(cancel_bt), "clicked",
|
|
|
|
GTK_SIGNAL_FUNC(capture_prep_close_cb), GTK_OBJECT(cap_open_w));
|
|
|
|
GTK_WIDGET_SET_FLAGS(cancel_bt, GTK_CAN_DEFAULT);
|
|
|
|
gtk_box_pack_start (GTK_BOX (bbox), cancel_bt, TRUE, TRUE, 0);
|
|
|
|
gtk_widget_show(cancel_bt);
|
|
|
|
|
|
|
|
/* Attach pointers to needed widgets to the capture prefs window/object */
|
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_IFACE_KEY, if_cb);
|
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_FILT_KEY, filter_te);
|
1999-10-02 07:13:20 +00:00
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_FILE_TE_KEY, file_te);
|
1999-09-09 03:32:03 +00:00
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_COUNT_KEY, count_cb);
|
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_SNAP_KEY, snap_sb);
|
2000-09-15 05:32:49 +00:00
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_PROMISC_KEY, promisc_cb);
|
Move the toolkit-independent code to create a temporary capture file,
and to fork off and run a separate copy of "ethereal" for "-S" and "-F"
captures or just call "capture()" otherwise, out of "gtk/capture_dlg.c"
and into a routine in "capture.c".
If the attempt to create said temporary capture file fails, pop up a
dialog box and don't do the capture.
Have the child capture process send a message upstream after it either
successfully starts the capture and syncs out the header of the capture
file, or fails to start the capture; the message indicates whether it
succeeded or failed, and, if it failed, includes a failure message.
This:
avoids the use of a signal, and thus means we don't have to
worry about whether to capture the signal, or whether to start
or stop capturing depending on whether this particular capture
is in sync mode or not;
lets us pop up the message box for the error in the parent
process if we're in sync mode, rather than doing it in the
child, which didn't work well.
Add a check button to the Capture/Start dialog box, so that we can
control, for each capture, whether it's to be done in sync mode or not.
svn path=/trunk/; revision=708
1999-09-23 06:27:27 +00:00
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_SYNC_KEY, sync_cb);
|
2000-01-18 09:25:04 +00:00
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_AUTO_SCROLL_KEY, auto_scroll_cb);
|
2001-05-31 08:36:46 +00:00
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_M_RESOLVE_KEY, m_resolv_cb);
|
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_N_RESOLVE_KEY, n_resolv_cb);
|
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_T_RESOLVE_KEY, t_resolv_cb);
|
2001-12-04 07:32:05 +00:00
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_FILESIZE_KEY, filesize_cb);
|
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_DURATION_KEY, duration_cb);
|
2001-12-04 09:46:01 +00:00
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_RING_ON_TB_KEY, ringbuffer_on_tb);
|
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_RING_NBF_LB_KEY, ringbuffer_nbf_lb);
|
|
|
|
gtk_object_set_data(GTK_OBJECT(cap_open_w), E_CAP_RING_NBF_SB_KEY, ringbuffer_nbf_sb);
|
|
|
|
|
|
|
|
/* Set the sensitivity of various widgets as per the settings of other
|
|
|
|
widgets. */
|
|
|
|
capture_prep_adjust_sensitivity(NULL, cap_open_w);
|
1999-09-09 03:32:03 +00:00
|
|
|
|
2000-05-03 07:09:40 +00:00
|
|
|
/* Catch the "activate" signal on the frame number and file name text
|
|
|
|
entries, so that 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. */
|
|
|
|
dlg_set_activate(filter_te, ok_bt);
|
|
|
|
dlg_set_activate(file_te, ok_bt);
|
|
|
|
|
|
|
|
/* Catch the "key_press_event" signal in the window, so that we can catch
|
|
|
|
the ESC key being pressed and act as if the "Cancel" button had
|
|
|
|
been selected. */
|
|
|
|
dlg_set_cancel(cap_open_w, cancel_bt);
|
|
|
|
|
|
|
|
/* XXX - why does not
|
|
|
|
|
|
|
|
gtk_widget_grab_focus(if_cb);
|
|
|
|
|
|
|
|
give the initial focus to the "Interface" combo box?
|
|
|
|
|
|
|
|
Or should I phrase that as "why does GTK+ continually frustrate
|
|
|
|
attempts to make GUIs driveable from the keyboard?" We have to
|
|
|
|
go catch the activate signal on every single GtkEntry widget
|
|
|
|
(rather than having widgets whose activate signal is *not*
|
|
|
|
caught not catch the Return keystroke, so that it passes on,
|
|
|
|
ultimately, to the window, which can activate the default
|
|
|
|
widget, i.e. the "OK" button); we have to catch the "key_press_event"
|
|
|
|
signal and have the handler check for ESC, so that we can have ESC
|
|
|
|
activate the "Cancel" button; in order to support Alt+<key> mnemonics
|
|
|
|
for buttons and the like, we may have to construct an accelerator
|
|
|
|
group by hand and set up the accelerators by hand (if that even
|
|
|
|
works - I've not tried it yet); we have to do a "gtk_widget_grab_focus()"
|
|
|
|
to keep some container widget from getting the initial focus, so that
|
|
|
|
you don't have to tab into the first widget in order to start typing
|
|
|
|
in it; and it now appears that you simply *can't* make a combo box
|
|
|
|
get the initial focus, at least not in the obvious fashion. Sigh.... */
|
|
|
|
|
1999-09-09 03:32:03 +00:00
|
|
|
gtk_widget_show(cap_open_w);
|
|
|
|
}
|
|
|
|
|
1999-10-02 07:13:20 +00:00
|
|
|
static void
|
|
|
|
capture_prep_file_cb(GtkWidget *w, gpointer file_te)
|
|
|
|
{
|
2000-05-08 05:42:54 +00:00
|
|
|
GtkWidget *caller = gtk_widget_get_toplevel(w);
|
1999-10-02 07:13:20 +00:00
|
|
|
GtkWidget *fs;
|
|
|
|
|
2000-05-08 05:42:54 +00:00
|
|
|
/* Has a file selection dialog box already been opened for that top-level
|
|
|
|
widget? */
|
|
|
|
fs = gtk_object_get_data(GTK_OBJECT(caller), E_FILE_SEL_DIALOG_PTR_KEY);
|
|
|
|
|
|
|
|
if (fs != NULL) {
|
|
|
|
/* Yes. Just re-activate that dialog box. */
|
|
|
|
reactivate_window(fs);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
1999-10-02 07:13:20 +00:00
|
|
|
fs = gtk_file_selection_new ("Ethereal: Capture File");
|
|
|
|
|
|
|
|
gtk_object_set_data(GTK_OBJECT(fs), E_CAP_FILE_TE_KEY, file_te);
|
|
|
|
|
2000-05-08 05:42:54 +00:00
|
|
|
/* Set the E_FS_CALLER_PTR_KEY for the new dialog to point to our caller. */
|
|
|
|
gtk_object_set_data(GTK_OBJECT(fs), E_FS_CALLER_PTR_KEY, caller);
|
|
|
|
|
|
|
|
/* Set the E_FILE_SEL_DIALOG_PTR_KEY for the caller to point to us */
|
|
|
|
gtk_object_set_data(GTK_OBJECT(caller), E_FILE_SEL_DIALOG_PTR_KEY, fs);
|
|
|
|
|
|
|
|
/* Call a handler when the file selection box is destroyed, so we can inform
|
|
|
|
our caller, if any, that it's been destroyed. */
|
|
|
|
gtk_signal_connect(GTK_OBJECT(fs), "destroy",
|
|
|
|
GTK_SIGNAL_FUNC(cap_prep_fs_destroy_cb), NULL);
|
|
|
|
|
1999-10-02 07:13:20 +00:00
|
|
|
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(fs)->ok_button),
|
|
|
|
"clicked", (GtkSignalFunc) cap_prep_fs_ok_cb, fs);
|
|
|
|
|
|
|
|
/* Connect the cancel_button to destroy the widget */
|
|
|
|
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION(fs)->cancel_button),
|
|
|
|
"clicked", (GtkSignalFunc) cap_prep_fs_cancel_cb, fs);
|
2000-05-08 07:13:40 +00:00
|
|
|
|
|
|
|
/* Catch the "key_press_event" signal in the window, so that we can catch
|
|
|
|
the ESC key being pressed and act as if the "Cancel" button had
|
|
|
|
been selected. */
|
|
|
|
dlg_set_cancel(fs, GTK_FILE_SELECTION(fs)->cancel_button);
|
1999-10-02 07:13:20 +00:00
|
|
|
|
|
|
|
gtk_widget_show(fs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
cap_prep_fs_ok_cb(GtkWidget *w, gpointer data)
|
|
|
|
{
|
|
|
|
gtk_entry_set_text(GTK_ENTRY(gtk_object_get_data(GTK_OBJECT(data),
|
|
|
|
E_CAP_FILE_TE_KEY)),
|
|
|
|
gtk_file_selection_get_filename (GTK_FILE_SELECTION(data)));
|
|
|
|
gtk_widget_destroy(GTK_WIDGET(data));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
cap_prep_fs_cancel_cb(GtkWidget *w, gpointer data)
|
|
|
|
{
|
|
|
|
gtk_widget_destroy(GTK_WIDGET(data));
|
|
|
|
}
|
|
|
|
|
2000-05-08 05:42:54 +00:00
|
|
|
static void
|
|
|
|
cap_prep_fs_destroy_cb(GtkWidget *win, gpointer data)
|
|
|
|
{
|
|
|
|
GtkWidget *caller;
|
|
|
|
|
|
|
|
/* Get the widget that requested that we be popped up.
|
|
|
|
(It should arrange to destroy us if it's destroyed, so
|
|
|
|
that we don't get a pointer to a non-existent window here.) */
|
|
|
|
caller = gtk_object_get_data(GTK_OBJECT(win), E_FS_CALLER_PTR_KEY);
|
|
|
|
|
|
|
|
/* Tell it we no longer exist. */
|
|
|
|
gtk_object_set_data(GTK_OBJECT(caller), E_FILE_SEL_DIALOG_PTR_KEY, NULL);
|
|
|
|
|
|
|
|
/* Now nuke this window. */
|
|
|
|
gtk_grab_remove(GTK_WIDGET(win));
|
|
|
|
gtk_widget_destroy(GTK_WIDGET(win));
|
|
|
|
}
|
|
|
|
|
2001-12-04 07:32:05 +00:00
|
|
|
static int
|
|
|
|
get_positive_int(const char *string, const char *name)
|
|
|
|
{
|
|
|
|
long number;
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
number = strtol(string, &p, 10);
|
|
|
|
/*
|
|
|
|
* XXX - we allow extra stuff after 0, so that we don't have
|
|
|
|
* problems with the "(Infinite)" value.
|
|
|
|
*/
|
|
|
|
if (p == string || (*p != '\0' && number != 0)) {
|
|
|
|
simple_dialog(ESD_TYPE_CRIT, NULL,
|
|
|
|
"The specified %s is not a decimal number.", name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (number < 0) {
|
|
|
|
simple_dialog(ESD_TYPE_CRIT, NULL,
|
|
|
|
"The specified %s is a negative number.", name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (number > INT_MAX) {
|
|
|
|
simple_dialog(ESD_TYPE_CRIT, NULL,
|
|
|
|
"The specified %s is too large (greater than %d).", name, INT_MAX);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return number;
|
|
|
|
}
|
|
|
|
|
1999-09-09 03:32:03 +00:00
|
|
|
static void
|
|
|
|
capture_prep_ok_cb(GtkWidget *ok_bt, gpointer parent_w) {
|
2000-09-15 05:32:49 +00:00
|
|
|
GtkWidget *if_cb, *filter_te, *file_te, *count_cb, *snap_sb, *promisc_cb,
|
2001-12-04 07:32:05 +00:00
|
|
|
*sync_cb, *auto_scroll_cb, *m_resolv_cb, *n_resolv_cb, *t_resolv_cb,
|
2001-12-04 08:26:00 +00:00
|
|
|
*filesize_cb, *duration_cb, *ringbuffer_on_tb, *ringbuffer_nbf_sb;
|
I thought I'd seen a problem with the combo box in the "Capture:Start"
dialog box if we hadn't found any interfaces on which we could capture,
but perhaps the problem was that "gtk_combo_set_popdown_strings()"
doesn't like it if you set the list of items to a NULL list - if you
don't set it at all, you get a combo box with only one blank entry in
the list, but you don't seem to get complaints from GTK+ 1.2.6, at
least.
Pop up the "Capture:Start" dialog box even if we don't find any
interfaces on which we could capture; at least this way, they won't just
get confronted with a
There are no network interfaces that can be opened.
Please check to make sure you have sufficient permission
to capture packets.
message box and no way to give us any more information other than "it
said 'There are no network interfaces that can be opened...'" - they can
at least try the interfaces that *should* work, and report the error
messages they get, giving us a better chance at figuring out what the
problem is.
Trim white space from the entry in that combo box, and, if there isn't
anything other than possibly white space, pop up a
You didn't specify an interface on which to capture packets.
message box and leave the dialog box up so that the user can supply an
interface name.
svn path=/trunk/; revision=1373
1999-12-23 09:31:09 +00:00
|
|
|
gchar *if_text;
|
|
|
|
gchar *if_name;
|
1999-09-09 03:32:03 +00:00
|
|
|
gchar *filter_text;
|
1999-10-02 07:13:20 +00:00
|
|
|
gchar *save_file;
|
2001-12-04 07:32:05 +00:00
|
|
|
int value;
|
1999-09-09 03:32:03 +00:00
|
|
|
|
|
|
|
if_cb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_IFACE_KEY);
|
|
|
|
filter_te = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_FILT_KEY);
|
1999-10-02 07:13:20 +00:00
|
|
|
file_te = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_FILE_TE_KEY);
|
1999-09-09 03:32:03 +00:00
|
|
|
count_cb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_COUNT_KEY);
|
|
|
|
snap_sb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_SNAP_KEY);
|
2000-09-15 05:32:49 +00:00
|
|
|
promisc_cb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_PROMISC_KEY);
|
Move the toolkit-independent code to create a temporary capture file,
and to fork off and run a separate copy of "ethereal" for "-S" and "-F"
captures or just call "capture()" otherwise, out of "gtk/capture_dlg.c"
and into a routine in "capture.c".
If the attempt to create said temporary capture file fails, pop up a
dialog box and don't do the capture.
Have the child capture process send a message upstream after it either
successfully starts the capture and syncs out the header of the capture
file, or fails to start the capture; the message indicates whether it
succeeded or failed, and, if it failed, includes a failure message.
This:
avoids the use of a signal, and thus means we don't have to
worry about whether to capture the signal, or whether to start
or stop capturing depending on whether this particular capture
is in sync mode or not;
lets us pop up the message box for the error in the parent
process if we're in sync mode, rather than doing it in the
child, which didn't work well.
Add a check button to the Capture/Start dialog box, so that we can
control, for each capture, whether it's to be done in sync mode or not.
svn path=/trunk/; revision=708
1999-09-23 06:27:27 +00:00
|
|
|
sync_cb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_SYNC_KEY);
|
2000-01-18 09:25:04 +00:00
|
|
|
auto_scroll_cb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_AUTO_SCROLL_KEY);
|
2001-05-31 08:36:46 +00:00
|
|
|
m_resolv_cb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_M_RESOLVE_KEY);
|
|
|
|
n_resolv_cb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_N_RESOLVE_KEY);
|
|
|
|
t_resolv_cb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_T_RESOLVE_KEY);
|
2001-12-04 07:32:05 +00:00
|
|
|
filesize_cb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_FILESIZE_KEY);
|
|
|
|
duration_cb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_DURATION_KEY);
|
2001-12-04 09:46:01 +00:00
|
|
|
ringbuffer_on_tb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_RING_ON_TB_KEY);
|
|
|
|
ringbuffer_nbf_sb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_RING_NBF_SB_KEY);
|
1999-09-09 03:32:03 +00:00
|
|
|
|
I thought I'd seen a problem with the combo box in the "Capture:Start"
dialog box if we hadn't found any interfaces on which we could capture,
but perhaps the problem was that "gtk_combo_set_popdown_strings()"
doesn't like it if you set the list of items to a NULL list - if you
don't set it at all, you get a combo box with only one blank entry in
the list, but you don't seem to get complaints from GTK+ 1.2.6, at
least.
Pop up the "Capture:Start" dialog box even if we don't find any
interfaces on which we could capture; at least this way, they won't just
get confronted with a
There are no network interfaces that can be opened.
Please check to make sure you have sufficient permission
to capture packets.
message box and no way to give us any more information other than "it
said 'There are no network interfaces that can be opened...'" - they can
at least try the interfaces that *should* work, and report the error
messages they get, giving us a better chance at figuring out what the
problem is.
Trim white space from the entry in that combo box, and, if there isn't
anything other than possibly white space, pop up a
You didn't specify an interface on which to capture packets.
message box and leave the dialog box up so that the user can supply an
interface name.
svn path=/trunk/; revision=1373
1999-12-23 09:31:09 +00:00
|
|
|
if_text =
|
|
|
|
g_strdup(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(if_cb)->entry)));
|
|
|
|
if_name = strtok(if_text, " \t");
|
|
|
|
if (if_name == NULL) {
|
2000-07-20 05:10:02 +00:00
|
|
|
simple_dialog(ESD_TYPE_CRIT, NULL,
|
I thought I'd seen a problem with the combo box in the "Capture:Start"
dialog box if we hadn't found any interfaces on which we could capture,
but perhaps the problem was that "gtk_combo_set_popdown_strings()"
doesn't like it if you set the list of items to a NULL list - if you
don't set it at all, you get a combo box with only one blank entry in
the list, but you don't seem to get complaints from GTK+ 1.2.6, at
least.
Pop up the "Capture:Start" dialog box even if we don't find any
interfaces on which we could capture; at least this way, they won't just
get confronted with a
There are no network interfaces that can be opened.
Please check to make sure you have sufficient permission
to capture packets.
message box and no way to give us any more information other than "it
said 'There are no network interfaces that can be opened...'" - they can
at least try the interfaces that *should* work, and report the error
messages they get, giving us a better chance at figuring out what the
problem is.
Trim white space from the entry in that combo box, and, if there isn't
anything other than possibly white space, pop up a
You didn't specify an interface on which to capture packets.
message box and leave the dialog box up so that the user can supply an
interface name.
svn path=/trunk/; revision=1373
1999-12-23 09:31:09 +00:00
|
|
|
"You didn't specify an interface on which to capture packets.");
|
2001-05-31 05:33:15 +00:00
|
|
|
g_free(if_text);
|
I thought I'd seen a problem with the combo box in the "Capture:Start"
dialog box if we hadn't found any interfaces on which we could capture,
but perhaps the problem was that "gtk_combo_set_popdown_strings()"
doesn't like it if you set the list of items to a NULL list - if you
don't set it at all, you get a combo box with only one blank entry in
the list, but you don't seem to get complaints from GTK+ 1.2.6, at
least.
Pop up the "Capture:Start" dialog box even if we don't find any
interfaces on which we could capture; at least this way, they won't just
get confronted with a
There are no network interfaces that can be opened.
Please check to make sure you have sufficient permission
to capture packets.
message box and no way to give us any more information other than "it
said 'There are no network interfaces that can be opened...'" - they can
at least try the interfaces that *should* work, and report the error
messages they get, giving us a better chance at figuring out what the
problem is.
Trim white space from the entry in that combo box, and, if there isn't
anything other than possibly white space, pop up a
You didn't specify an interface on which to capture packets.
message box and leave the dialog box up so that the user can supply an
interface name.
svn path=/trunk/; revision=1373
1999-12-23 09:31:09 +00:00
|
|
|
return;
|
|
|
|
}
|
2000-06-27 04:36:03 +00:00
|
|
|
if (cfile.iface)
|
|
|
|
g_free(cfile.iface);
|
|
|
|
cfile.iface = g_strdup(if_name);
|
I thought I'd seen a problem with the combo box in the "Capture:Start"
dialog box if we hadn't found any interfaces on which we could capture,
but perhaps the problem was that "gtk_combo_set_popdown_strings()"
doesn't like it if you set the list of items to a NULL list - if you
don't set it at all, you get a combo box with only one blank entry in
the list, but you don't seem to get complaints from GTK+ 1.2.6, at
least.
Pop up the "Capture:Start" dialog box even if we don't find any
interfaces on which we could capture; at least this way, they won't just
get confronted with a
There are no network interfaces that can be opened.
Please check to make sure you have sufficient permission
to capture packets.
message box and no way to give us any more information other than "it
said 'There are no network interfaces that can be opened...'" - they can
at least try the interfaces that *should* work, and report the error
messages they get, giving us a better chance at figuring out what the
problem is.
Trim white space from the entry in that combo box, and, if there isn't
anything other than possibly white space, pop up a
You didn't specify an interface on which to capture packets.
message box and leave the dialog box up so that the user can supply an
interface name.
svn path=/trunk/; revision=1373
1999-12-23 09:31:09 +00:00
|
|
|
g_free(if_text);
|
1999-09-09 03:32:03 +00:00
|
|
|
|
2000-06-27 04:36:03 +00:00
|
|
|
/* XXX - don't try to get clever and set "cfile.filter" to NULL if the
|
2000-01-06 05:09:01 +00:00
|
|
|
filter string is empty, as an indication that we don't have a filter
|
|
|
|
and thus don't have to set a filter when capturing - the version of
|
|
|
|
libpcap in Red Hat Linux 6.1, and versions based on later patches
|
|
|
|
in that series, don't bind the AF_PACKET socket to an interface
|
|
|
|
until a filter is set, which means they aren't bound at all if
|
|
|
|
no filter is set, which means no packets arrive as input on that
|
|
|
|
socket, which means Ethereal never sees any packets. */
|
1999-09-09 03:32:03 +00:00
|
|
|
filter_text = gtk_entry_get_text(GTK_ENTRY(filter_te));
|
2000-06-27 04:36:03 +00:00
|
|
|
if (cfile.cfilter)
|
|
|
|
g_free(cfile.cfilter);
|
2000-01-06 05:09:01 +00:00
|
|
|
g_assert(filter_text != NULL);
|
2000-06-27 04:36:03 +00:00
|
|
|
cfile.cfilter = g_strdup(filter_text);
|
1999-10-02 07:13:20 +00:00
|
|
|
|
|
|
|
save_file = gtk_entry_get_text(GTK_ENTRY(file_te));
|
|
|
|
if (save_file && save_file[0]) {
|
|
|
|
/* User specified a file to which the capture should be written. */
|
|
|
|
save_file = g_strdup(save_file);
|
|
|
|
} else {
|
|
|
|
/* User didn't specify a file; save to a temporary file. */
|
|
|
|
save_file = NULL;
|
|
|
|
}
|
|
|
|
|
2001-12-09 03:20:19 +00:00
|
|
|
value = get_positive_int(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(count_cb)->entry)),
|
|
|
|
"maximum packet count");
|
|
|
|
if (value == -1)
|
|
|
|
return; /* error */
|
|
|
|
cfile.count = value;
|
1999-10-02 07:13:20 +00:00
|
|
|
|
2001-12-04 07:32:05 +00:00
|
|
|
value = get_positive_int(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(filesize_cb)->entry)),
|
|
|
|
"maximum capture file size");
|
|
|
|
if (value == -1)
|
|
|
|
return; /* error */
|
|
|
|
cfile.autostop_filesize = value;
|
|
|
|
|
|
|
|
value = get_positive_int(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(duration_cb)->entry)),
|
|
|
|
"capture duration");
|
|
|
|
if (value == -1)
|
|
|
|
return; /* error */
|
|
|
|
cfile.autostop_duration = value;
|
|
|
|
|
2000-06-27 04:36:03 +00:00
|
|
|
cfile.snap = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(snap_sb));
|
|
|
|
if (cfile.snap < 1)
|
|
|
|
cfile.snap = WTAP_MAX_PACKET_SIZE;
|
|
|
|
else if (cfile.snap < MIN_PACKET_SIZE)
|
|
|
|
cfile.snap = MIN_PACKET_SIZE;
|
1999-10-02 07:13:20 +00:00
|
|
|
|
2001-04-13 14:59:30 +00:00
|
|
|
prefs.capture_prom_mode = GTK_TOGGLE_BUTTON (promisc_cb)->active;
|
2000-09-15 05:32:49 +00:00
|
|
|
|
2001-04-13 14:59:30 +00:00
|
|
|
prefs.capture_real_time = GTK_TOGGLE_BUTTON (sync_cb)->active;
|
1999-10-02 07:13:20 +00:00
|
|
|
|
2001-04-13 14:59:30 +00:00
|
|
|
prefs.capture_auto_scroll = GTK_TOGGLE_BUTTON (auto_scroll_cb)->active;
|
2000-01-18 09:25:04 +00:00
|
|
|
|
2001-05-31 08:36:46 +00:00
|
|
|
prefs.name_resolve = PREFS_RESOLV_NONE;
|
|
|
|
prefs.name_resolve |= (GTK_TOGGLE_BUTTON (m_resolv_cb)->active ? PREFS_RESOLV_MAC : PREFS_RESOLV_NONE);
|
|
|
|
prefs.name_resolve |= (GTK_TOGGLE_BUTTON (n_resolv_cb)->active ? PREFS_RESOLV_NETWORK : PREFS_RESOLV_NONE);
|
|
|
|
prefs.name_resolve |= (GTK_TOGGLE_BUTTON (t_resolv_cb)->active ? PREFS_RESOLV_TRANSPORT : PREFS_RESOLV_NONE);
|
1999-09-09 03:32:03 +00:00
|
|
|
|
2001-12-04 08:26:00 +00:00
|
|
|
cfile.ringbuffer_on = GTK_TOGGLE_BUTTON (ringbuffer_on_tb)->active && !(prefs.capture_real_time);
|
|
|
|
if (cfile.ringbuffer_on == TRUE) {
|
|
|
|
if (save_file == NULL) {
|
|
|
|
simple_dialog(ESD_TYPE_CRIT, NULL,
|
2001-12-04 09:46:01 +00:00
|
|
|
"You must specify a save file if you want to use the ring buffer.");
|
2001-12-04 08:26:00 +00:00
|
|
|
return;
|
|
|
|
} else if (cfile.autostop_filesize == 0) {
|
|
|
|
simple_dialog(ESD_TYPE_CRIT, NULL,
|
2001-12-04 09:46:01 +00:00
|
|
|
"You must specify a maximum save file size other \nthan 0 (infinite) if you want to use the ring buffer.");
|
2001-12-04 08:26:00 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
cfile.ringbuffer_num_files = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ringbuffer_nbf_sb));
|
|
|
|
if (cfile.ringbuffer_num_files < RINGBUFFER_MIN_NUM_FILES)
|
|
|
|
cfile.ringbuffer_num_files = RINGBUFFER_MIN_NUM_FILES;
|
|
|
|
else if (cfile.ringbuffer_num_files > RINGBUFFER_MAX_NUM_FILES)
|
|
|
|
cfile.ringbuffer_num_files = RINGBUFFER_MAX_NUM_FILES;
|
|
|
|
|
1999-09-09 03:32:03 +00:00
|
|
|
gtk_widget_destroy(GTK_WIDGET(parent_w));
|
|
|
|
|
1999-10-02 07:13:20 +00:00
|
|
|
do_capture(save_file);
|
1999-09-09 03:32:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
capture_prep_close_cb(GtkWidget *close_bt, gpointer parent_w)
|
|
|
|
{
|
|
|
|
gtk_grab_remove(GTK_WIDGET(parent_w));
|
|
|
|
gtk_widget_destroy(GTK_WIDGET(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
|
|
|
|
capture_prep_destroy_cb(GtkWidget *win, gpointer user_data)
|
|
|
|
{
|
|
|
|
GtkWidget *capture_prep_filter_w;
|
2000-05-08 05:42:54 +00:00
|
|
|
GtkWidget *fs;
|
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
|
|
|
|
|
|
|
/* Is there a filter edit/selection dialog associated with this
|
|
|
|
Capture Preferences dialog? */
|
|
|
|
capture_prep_filter_w = gtk_object_get_data(GTK_OBJECT(win), E_FILT_DIALOG_PTR_KEY);
|
|
|
|
|
|
|
|
if (capture_prep_filter_w != NULL) {
|
|
|
|
/* Yes. Destroy it. */
|
|
|
|
gtk_widget_destroy(capture_prep_filter_w);
|
|
|
|
}
|
|
|
|
|
2000-05-08 05:42:54 +00:00
|
|
|
/* Is there a file selection dialog associated with this
|
|
|
|
Print File dialog? */
|
|
|
|
fs = gtk_object_get_data(GTK_OBJECT(win), E_FILE_SEL_DIALOG_PTR_KEY);
|
|
|
|
|
|
|
|
if (fs != NULL) {
|
|
|
|
/* Yes. Destroy it. */
|
|
|
|
gtk_widget_destroy(fs);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
/* Note that we no longer have a "Capture Preferences" dialog box. */
|
|
|
|
cap_open_w = NULL;
|
|
|
|
}
|
|
|
|
|
2001-12-04 09:46:01 +00:00
|
|
|
/*
|
|
|
|
* Adjust the sensitivity of various widgets as per the current setting
|
|
|
|
* of other widgets.
|
|
|
|
*/
|
2001-12-04 08:26:00 +00:00
|
|
|
static void
|
2001-12-04 09:46:01 +00:00
|
|
|
capture_prep_adjust_sensitivity(GtkWidget *tb, gpointer parent_w)
|
2001-12-04 08:26:00 +00:00
|
|
|
{
|
2001-12-04 09:46:01 +00:00
|
|
|
GtkWidget *sync_cb, *auto_scroll_cb, *ringbuffer_on_tb;
|
|
|
|
GtkWidget *ringbuffer_nbf_lb, *ringbuffer_nbf_sb;
|
2001-12-04 08:26:00 +00:00
|
|
|
|
|
|
|
sync_cb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_SYNC_KEY);
|
2001-12-04 09:46:01 +00:00
|
|
|
auto_scroll_cb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_AUTO_SCROLL_KEY);
|
|
|
|
ringbuffer_on_tb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_RING_ON_TB_KEY);
|
|
|
|
ringbuffer_nbf_lb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_RING_NBF_LB_KEY);
|
|
|
|
ringbuffer_nbf_sb = (GtkWidget *) gtk_object_get_data(GTK_OBJECT(parent_w), E_CAP_RING_NBF_SB_KEY);
|
|
|
|
|
|
|
|
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sync_cb))) {
|
|
|
|
/* "Update list of packets in real time" captures enabled; we don't
|
|
|
|
support ring buffer mode for those captures, so turn ring buffer
|
|
|
|
mode off if it's on, and make its toggle button, and the spin
|
|
|
|
button for the number of ring buffer files (and the spin button's
|
|
|
|
label), insensitive. */
|
|
|
|
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ringbuffer_on_tb))) {
|
|
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ringbuffer_on_tb), FALSE);
|
|
|
|
}
|
|
|
|
gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_on_tb), FALSE);
|
2001-12-04 08:26:00 +00:00
|
|
|
|
2001-12-04 09:46:01 +00:00
|
|
|
/* Auto-scroll mode is meaningful only in "Update list of packets
|
|
|
|
in real time" captures, so make its toggle button sensitive. */
|
|
|
|
gtk_widget_set_sensitive(GTK_WIDGET(auto_scroll_cb), TRUE);
|
|
|
|
} else {
|
|
|
|
/* "Update list of packets in real time" captures disabled; that
|
|
|
|
means ring buffer mode is OK, so make its toggle button
|
|
|
|
sensitive. */
|
|
|
|
gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_on_tb), TRUE);
|
|
|
|
|
|
|
|
/* Auto-scroll mode is meaningful only in "Update list of packets
|
|
|
|
in real time" captures, so make its toggle button insensitive. */
|
|
|
|
gtk_widget_set_sensitive(GTK_WIDGET(auto_scroll_cb), FALSE);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ringbuffer_on_tb))) {
|
|
|
|
/* Ring buffer mode enabled. Make the spin button for the number
|
|
|
|
of ring buffer files, and its label, sensitive. */
|
|
|
|
gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_lb), TRUE);
|
2001-12-04 08:26:00 +00:00
|
|
|
gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_sb), TRUE);
|
|
|
|
} else {
|
2001-12-04 09:46:01 +00:00
|
|
|
/* Ring buffer mode disabled. Make the spin button for the number
|
|
|
|
of ring buffer files, and its label insensitive. */
|
|
|
|
gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_lb), FALSE);
|
2001-12-04 08:26:00 +00:00
|
|
|
gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_sb), FALSE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-10-02 19:33:14 +00:00
|
|
|
#endif /* HAVE_LIBPCAP */
|