* Routines for the "Capture Options" dialog and dialog windows popped
* up from it
*
- * $Id$
- *
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
#ifdef HAVE_LIBPCAP
-#include <string.h>
-
#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
#include <gtk/gtk.h>
#include <epan/packet.h>
#include <epan/addr_resolv.h>
#include <epan/prefs.h>
-#include <epan/filesystem.h>
+#include <wsutil/filesystem.h>
-#include "../capture.h"
-#include "../capture_ifinfo.h"
-#include "../capture-pcap-util.h"
-#include "../capture_ui_utils.h"
+#include "ui/capture.h"
+#include "caputils/capture_ifinfo.h"
+#include "caputils/capture-pcap-util.h"
#include "../ringbuffer.h"
+#include "ui/capture_ui_utils.h"
#include "ui/capture_globals.h"
#include "ui/iface_lists.h"
#include "ui/preference_utils.h"
#include "ui/recent.h"
#include "ui/recent_utils.h"
-#include "ui/simple_dialog.h"
+#include "ui/util.h"
#include "ui/gtk/main.h"
#include "ui/gtk/gui_utils.h"
#include "ui/gtk/filter_dlg.h"
#include "ui/gtk/dlg_utils.h"
#include "ui/gtk/file_dlg.h"
-#include "ui/gtk/stock_icons.h"
#include "ui/gtk/capture_file_dlg.h"
#include "ui/gtk/help_dlg.h"
#include "ui/gtk/gtkglobals.h"
#include "ui/gtk/cfilter_combo_utils.h"
#include "ui/gtk/capture_if_dlg.h"
#include "ui/gtk/main_welcome.h"
-#include "ui/gtk/network_icons.h"
#include "ui/gtk/menus.h"
#include "ui/gtk/prefs_dlg.h"
#include "ui/gtk/main_80211_toolbar.h"
+#include "ui/gtk/stock_icons.h"
+#ifndef HAVE_GRESOURCE
+#include "ui/gtk/pixbuf-csource.h"
+#endif
+#include "simple_dialog.h"
#include "ui/gtk/keys.h"
#include "ui/gtk/old-gtk-compat.h"
-#include "ui/gtk/expert_indicators.h"
#ifdef HAVE_AIRPCAP
-#include <airpcap.h>
-#include "airpcap_loader.h"
+#include <caputils/airpcap.h>
+#include <caputils/airpcap_loader.h>
#include "airpcap_gui_utils.h"
#include "airpcap_dlg.h"
#endif
+#ifdef HAVE_EXTCAP
+#include "extcap.h"
+#include "ui/gtk/extcap_gtk.h"
+#endif
+
/*
* Symbolic names for column indices.
*/
LINK,
PMODE,
SNAPLEN,
-#if defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
BUFFER,
+#endif
+#ifdef HAVE_PCAP_CREATE
MONITOR,
-#elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
- BUFFER,
#endif
FILTER,
NUM_COLUMNS
#define E_CAP_SNAP_CB_KEY "cap_snap_cb"
#define E_CAP_LT_CBX_KEY "cap_lt_cbx"
#define E_CAP_LT_CBX_LABEL_KEY "cap_lt_cbx_label"
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
#define E_CAP_BUFFER_SIZE_SB_KEY "cap_buffer_size_sb"
#endif
#define E_CAP_SNAP_SB_KEY "cap_snap_sb"
#define E_CAP_T_RESOLVE_KEY "cap_t_resolve"
#define E_CAP_E_RESOLVE_KEY "cap_e_resolve"
+#ifdef HAVE_EXTCAP
+#define E_CAP_EXTCAP_KEY "cap_extcap_vbox"
+#endif
+
#define E_CAP_IFTYPE_CBX_KEY "cap_iftype_cbx"
#ifdef HAVE_PCAP_REMOTE
#define E_CAP_IF_LIST_KEY "cap_if_list"
static GtkWidget *compile_bpf_w = NULL;
#endif
static gboolean cap_open_complete; /* valid only if cap_open_w != NULL */
-static const gchar *pipe_name;
+static const gchar *pipe_name = NULL;
static const gchar *selected_name;
static GtkWidget *columns_menu_object;
static GtkUIManager *ui_manager_columns = NULL;
static gint marked_row;
#ifdef HAVE_PCAP_REMOTE
-static GHashTable *remote_host_list=NULL;
static remote_options global_remote_opts;
static guint num_selected = 0;
#endif
+static gulong capture_all_handler_id;
+static gulong promisc_all_handler_id;
+
static void
capture_prep_file_cb(GtkWidget *file_bt, GtkWidget *file_te);
break;
case SNAPLEN: col_name = g_strdup("SNAPLEN");
break;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
case BUFFER: col_name = g_strdup("BUFFER");
break;
#endif
-#if defined (HAVE_PCAP_CREATE)
+#ifdef HAVE_PCAP_CREATE
case MONITOR: col_name = g_strdup("MONITOR");
break;
#endif
}
static
-gint col_title_to_index(gchar *name)
+gint col_title_to_index(const gchar *name)
{
if (strcmp(name, "Capture") == 0) return CAPTURE;
if (strcmp(name, "Interface") == 0) return INTERFACE;
if (strcmp(name, "Link-layer header") == 0) return LINK;
if (strcmp(name, "Prom. Mode") == 0) return PMODE;
if (strcmp(name, "Snaplen [B]") == 0) return SNAPLEN;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- if (strcmp(name, "Buffer [MB]") == 0) return BUFFER;
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
+ if (strcmp(name, "Buffer [MiB]") == 0) return BUFFER;
#endif
-#if defined (HAVE_PCAP_CREATE)
+#ifdef HAVE_PCAP_CREATE
if (strcmp(name, "Mon. Mode") == 0) return MONITOR;
#endif
if (strcmp(name, "Capture Filter") == 0) return FILTER;
GtkTreeViewColumn *col;
view = (GtkTreeView *)g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
- for (col_id = 2; col_id < NUM_COLUMNS; col_id++) {
+ gtk_tree_view_column_set_visible(gtk_tree_view_get_column(GTK_TREE_VIEW(view), INTERFACE), TRUE);
+ for (col_id = 3; col_id < NUM_COLUMNS; col_id++) {
col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), col_id);
gtk_tree_view_column_set_visible(col, prefs_capture_options_dialog_column_is_visible(col_index_to_name(col_id))?TRUE:FALSE);
}
sub_menu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM(menu_columns), sub_menu);
- for (col_id = 2; col_id < NUM_COLUMNS; col_id++) {
+ for (col_id = 3; col_id < NUM_COLUMNS; col_id++) {
title = col_index_to_name(col_id);
menu_item = gtk_check_menu_item_new_with_label(title);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), prefs_capture_options_dialog_column_is_visible(title));
GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data);
#endif
-void
+static void
init_columns_menu(void)
{
GtkActionGroup *columns_action_group;
columns_action_group = gtk_action_group_new ("ColumnsPopUpMenuActionGroup");
gtk_action_group_add_actions (columns_action_group, /* the action group */
- (GtkActionEntry *)columns_menu_popup_action_entries, /* an array of action descriptions */
+ (const GtkActionEntry *)columns_menu_popup_action_entries, /* an array of action descriptions */
G_N_ELEMENTS(columns_menu_popup_action_entries), /* the number of entries */
columns_menu_object); /* data to pass to the action callbacks */
airpcap_set_toolbar_stop_capture(airpcap_if_active);
#endif
- capture_stop(&global_capture_opts);
+ capture_stop(&global_capture_session);
}
/* restart (stop - delete old file - start) running capture */
airpcap_set_toolbar_start_capture(airpcap_if_active);
#endif
- capture_restart(&global_capture_opts);
+ capture_restart(&global_capture_session);
}
enum cfc_state_t {
*/
/* We could make this smarter by caching results */
-capture_filter_check_t cfc_data;
+static capture_filter_check_t cfc_data;
static GMutex *pcap_compile_mtx;
static GCond *cfc_data_cond;
filter_text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(filter_cm));
if (strlen(filter_text) == 0) {
colorize_filter_te_as_empty(filter_te);
- if (strlen(device.cfilter) == 1) {
+ if (strlen(device.cfilter) > 0) {
g_array_remove_index(global_capture_opts.all_ifaces, i);
+ g_free(device.cfilter);
device.cfilter = g_strdup(filter_text);
g_array_insert_val(global_capture_opts.all_ifaces, i, device);
update_filter_string(device.name, filter_text);
}
g_assert(filter_text != NULL);
g_array_remove_index(global_capture_opts.all_ifaces, i);
+ g_free(device.cfilter);
device.cfilter = g_strdup(filter_text);
g_array_insert_val(global_capture_opts.all_ifaces, i, device);
g_mutex_lock(cfc_data_mtx);
static const char *size_unit_name[MAX_SIZE_UNITS] = {
"kilobyte(s)",
"megabyte(s)",
- "gigabyte(s)",
+ "gigabyte(s)"
};
/* create one of the size options */
/* the selected combo_box item can't be changed, once the combo_box
is created, so set the matching combo_box item now */
/* gigabytes */
- if (value >= 1024 * 1024) {
+ if (value >= 1000 * 1000) {
gtk_combo_box_set_active(GTK_COMBO_BOX(unit_combo_box), SIZE_UNIT_GIGABYTES);
} else {
/* megabytes */
- if (value >= 1024) {
+ if (value >= 1000) {
gtk_combo_box_set_active(GTK_COMBO_BOX(unit_combo_box), SIZE_UNIT_MEGABYTES);
} else {
/* kilobytes */
return unit_combo_box;
}
-/* convert size value from raw to displayed (e.g. 1024 Bytes -> 1 KB) */
+/* convert size value from raw to displayed (e.g. 1000 Bytes -> 1 kB) */
static guint32 size_unit_combo_box_set_value(
guint32 value)
{
/* gigabytes */
- if (value >= 1024 * 1024) {
- return value / (1024 * 1024);
+ if (value >= 1000 * 1000) {
+ return value / (1000 * 1000);
}
/* megabytes */
- if (value >= 1024) {
- return value / (1024);
+ if (value >= 1000) {
+ return value / (1000);
}
/* kilobytes */
switch(unit) {
case(SIZE_UNIT_KILOBYTES):
- return value;
+ if (value > (((guint32)G_MAXINT + 1) / 1000)) {
+ return 0;
+ } else {
+ return value;
+ }
case(SIZE_UNIT_MEGABYTES):
- if (value > G_MAXINT / 1024) {
+ if (value > (((guint32)G_MAXINT + 1) / (1000 * 1000))) {
return 0;
} else {
- return value * 1024;
+ return value * 1000;
}
case(SIZE_UNIT_GIGABYTES):
- if (value > G_MAXINT / (1024 * 1024)) {
+ if (value > (((guint32)G_MAXINT + 1) / (1000 * 1000 * 1000))) {
return 0;
} else {
- return value * 1024 * 1024;
+ return value * 1000 * 1000;
}
default:
g_assert_not_reached();
GtkTreeIter iter;
gboolean create_new = FALSE;
gchar *string;
- guint i, pos = REMOTE_HOST_START;
- struct remote_host_info *rh;
+ guint pos = REMOTE_HOST_START;
+ struct remote_host *rh;
- rh = g_hash_table_lookup (remote_host_list, device->remote_opts.remote_host_opts.remote_host);
+ rh = recent_get_remote_host(device->remote_opts.remote_host_opts.remote_host);
if (!rh) {
rh = g_malloc0 (sizeof (*rh));
- if (g_hash_table_size (remote_host_list) == 0) {
+ if (recent_get_remote_host_list_size() == 0) {
iftype_combo_box_add_remote_separators (iftype_cbx);
}
gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(iftype_cbx), pos, device->remote_opts.remote_host_opts.remote_host);
- rh->remote_host = g_strdup (device->remote_opts.remote_host_opts.remote_host);
+ rh->r_host = g_strdup (device->remote_opts.remote_host_opts.remote_host);
create_new = TRUE;
} else {
- model = gtk_combo_box_get_model(GTK_COMBO_BOX(iftype_cbx));
- if (gtk_tree_model_get_iter_first(model, &iter)) {
- /* Skip the first entries */
- for (i = 0; i < REMOTE_HOST_START; i++)
- gtk_tree_model_iter_next(model, &iter);
- do {
+ model = (GtkTreeModel *)gtk_combo_box_get_model(GTK_COMBO_BOX(iftype_cbx));
+ if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter)) {
+ while (gtk_tree_model_iter_next(model, &iter)) {
gtk_tree_model_get(model, &iter, 0, &string, -1);
if (string) {
if (strcmp (device->remote_opts.remote_host_opts.remote_host, string) == 0) {
g_free (string);
}
pos++;
- } while (gtk_tree_model_iter_next(model, &iter));
+ }
}
g_free (rh->remote_port);
rh->auth_password = g_strdup (device->remote_opts.remote_host_opts.auth_password);
if (create_new) {
- g_hash_table_insert (remote_host_list, g_strdup (device->remote_opts.remote_host_opts.remote_host), rh);
+ recent_add_remote_host(g_strdup (device->remote_opts.remote_host_opts.remote_host), rh);
}
g_object_set_data(G_OBJECT(iftype_cbx), E_CAP_CBX_IFTYPE_NOUPDATE_KEY, GINT_TO_POINTER(1));
iftype_combo_box_add_remote_host (gpointer key, gpointer value _U_, gpointer user_data)
{
gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(user_data), REMOTE_HOST_START, key);
-
-/* if (g_array_index(global_capture_opts.ifaces, interface_options, 0).src_type == CAPTURE_IFREMOTE) {*/
- /* Ensure we select the correct entry */
- /* if (strcmp ((char *)key, g_array_index(global_capture_opts.ifaces, interface_options, 0).remote_host) == 0) {
- gtk_combo_box_set_active(GTK_COMBO_BOX(user_data), REMOTE_HOST_START);
- }
- }*/
}
/* Fill the menu of available types of interfaces */
iftype_combo_box_new(void)
{
GtkWidget *iftype_cbx;
+ GHashTable *ht;
iftype_cbx = gtk_combo_box_text_new_with_entry();
- /* for (i = 0; i < sizeof(iftype) / sizeof(iftype[0]); i++) {
- gtk_combo_box_text_append_text(GTK_COMBO_BOX(iftype_cbx), iftype[i].name);
- }*/
-
- if (g_hash_table_size (remote_host_list) > 0) {
+ ht = get_remote_host_list();
+ if (g_hash_table_size (ht) > 0) {
/* Add remote hosts */
- g_hash_table_foreach (remote_host_list, iftype_combo_box_add_remote_host, iftype_cbx);
+ g_hash_table_foreach (ht, iftype_combo_box_add_remote_host, iftype_cbx);
iftype_combo_box_add_remote_separators (iftype_cbx);
}
GtkTreeView *if_cb;
GtkTreeModel *model;
link_row *linkr = NULL;
+ address addr_str;
+ char* temp_addr_str = NULL;
if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
model = gtk_tree_view_get_model(if_cb);
/* Scan through the list and build a list of strings to display. */
for (if_entry = g_list_first(list); if_entry != NULL; if_entry = g_list_next(if_entry)) {
+ gchar *auth_str = NULL;
if_info = (if_info_t *)if_entry->data;
#ifdef HAVE_PCAP_REMOTE
add_interface_to_remote_list(if_info);
ip_str = g_string_new("");
str = "";
ips = 0;
+ memset(&device, 0, sizeof(device));
device.name = g_strdup(if_info->name);
/* Is this interface hidden and, if so, should we include it
anyway? */
} else {
device.display_name = g_strdup(if_string);
}
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
if ((device.buffer = capture_dev_user_buffersize_find(if_string)) == -1) {
device.buffer = global_capture_opts.default_options.buffer_size;
}
#endif
- if ((device.pmode = capture_dev_user_pmode_find(if_string)) == -1) {
+ if (!capture_dev_user_pmode_find(if_string, &device.pmode)) {
device.pmode = global_capture_opts.default_options.promisc_mode;
}
- device.has_snaplen = global_capture_opts.default_options.has_snaplen;
- if ((device.snaplen = capture_dev_user_snaplen_find(if_string)) == -1) {
+ if (!capture_dev_user_snaplen_find(if_string, &device.has_snaplen,
+ &device.snaplen)) {
+ device.has_snaplen = global_capture_opts.default_options.has_snaplen;
device.snaplen = global_capture_opts.default_options.snaplen;
}
device.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
monitor_mode = prefs_capture_device_monitor_mode(if_string);
- caps = capture_get_if_capabilities(if_string, monitor_mode, NULL);
+#ifdef HAVE_PCAP_REMOTE
+ if (global_remote_opts.remote_host_opts.auth_type == CAPTURE_AUTH_PWD) {
+ auth_str = g_strdup_printf("%s:%s", global_remote_opts.remote_host_opts.auth_username,
+ global_remote_opts.remote_host_opts.auth_password);
+ }
+#endif
+ caps = capture_get_if_capabilities(if_string, monitor_mode, auth_str, NULL, main_window_update);
+ g_free(auth_str);
gtk_list_store_append (GTK_LIST_STORE(model), &iter);
for (; (curr_addr = g_slist_nth(if_info->addrs, ips)) != NULL; ips++) {
if (ips != 0) {
switch (addr->ifat_type) {
case IF_AT_IPv4:
- g_string_append(ip_str, ip_to_str((guint8 *)&addr->addr.ip4_addr));
+ set_address(&addr_str, AT_IPv4, 4, &addr->addr.ip4_addr);
+ temp_addr_str = (char*)address_to_str(NULL, &addr_str);
+ g_string_append(ip_str, temp_addr_str);
break;
case IF_AT_IPv6:
- g_string_append(ip_str, ip6_to_str((struct e_in6_addr *)&addr->addr.ip6_addr));
+ set_address(&addr_str, AT_IPv6, 16, addr->addr.ip6_addr);
+ temp_addr_str = (char*)address_to_str(NULL, &addr_str);
+ g_string_append(ip_str, temp_addr_str);
break;
default:
/* In case we add non-IP addresses */
+ temp_addr_str = NULL;
break;
}
+
+ wmem_free(NULL, temp_addr_str);
} /* for curr_addr */
linktype_count = 0;
device.links = NULL;
for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
data_link_info = (data_link_info_t *)lt_entry->data;
linkr = (link_row *)g_malloc(sizeof(link_row));
+ /*
+ * For link-layer types libpcap/WinPcap doesn't know about, the
+ * name will be "DLT n", and the description will be null.
+ * We mark those as unsupported, and don't allow them to be
+ * used.
+ */
if (data_link_info->description != NULL) {
str = g_strdup_printf("%s", data_link_info->description);
linkr->dlt = data_link_info->dlt;
device.remote_opts.sampling_method = global_remote_opts.sampling_method;
device.remote_opts.sampling_param = global_remote_opts.sampling_param;
#endif
+ device.selected = TRUE;
+ global_capture_opts.num_selected++;
g_array_append_val(global_capture_opts.all_ifaces, device);
- if (device.has_snaplen) {
- snaplen_string = g_strdup_printf("%d", device.snaplen);
- } else {
- snaplen_string = g_strdup("default");
- }
+ snaplen_string = g_strdup_printf("%d", device.snaplen);
#if defined(HAVE_PCAP_CREATE)
gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, device.buffer, MONITOR, "no",FILTER, "",-1);
-#elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
+#elif defined(CAN_SET_CAPTURE_BUFFER_SIZE)
gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, device.buffer, FILTER, "",-1);
#else
gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, -1);
#endif
#ifdef HAVE_PCAP_REMOTE
-/* Retrieve the list of local or remote interfaces according to selected
+/* Retrieve the list of remote interfaces according to selected
* options and re-fill interface name combobox */
static void
-update_interface_list(void)
+update_remote_interface_list(void)
{
GtkWidget *iftype_cbx;
- GList *if_list, *if_r_list;
- int iftype_id, err;
+ GList *if_list;
+ int err;
gchar *err_str;
if (cap_open_w == NULL)
return;
iftype_cbx = (GtkWidget *)g_object_get_data(G_OBJECT(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY)), E_REMOTE_HOST_TE_KEY);
- iftype_id = CAPTURE_IFREMOTE;
- if (iftype_id >= CAPTURE_IFREMOTE) {
- if_r_list = get_remote_interface_list(global_remote_opts.remote_host_opts.remote_host,
- global_remote_opts.remote_host_opts.remote_port,
- global_remote_opts.remote_host_opts.auth_type,
- global_remote_opts.remote_host_opts.auth_username,
- global_remote_opts.remote_host_opts.auth_password,
- &err, &err_str);
-
- if_list = if_r_list;
- } else {
- if_list = capture_interface_list(&err, &err_str); /* Warning: see capture_prep_cb() */
- g_object_set_data(G_OBJECT(cap_open_w), E_CAP_IF_LIST_KEY, NULL);
- }
-
+ if_list = get_remote_interface_list(global_remote_opts.remote_host_opts.remote_host,
+ global_remote_opts.remote_host_opts.remote_port,
+ global_remote_opts.remote_host_opts.auth_type,
+ global_remote_opts.remote_host_opts.auth_username,
+ global_remote_opts.remote_host_opts.auth_password,
+ &err, &err_str);
if (if_list == NULL &&
(err == CANT_GET_INTERFACE_LIST || err == DONT_HAVE_PCAP)) {
gpointer dialog = simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
g_free(err_str);
- if (iftype_id >= CAPTURE_IFREMOTE) {
- /* Fall back to previous interface list */
- simple_dialog_set_cb(dialog, error_list_remote_interface_cb, iftype_cbx);
- return;
- }
- } else if (iftype_id == CAPTURE_IFREMOTE) {
+ /* Fall back to previous interface list */
+ simple_dialog_set_cb(dialog, error_list_remote_interface_cb, iftype_cbx);
+ return;
+ } else {
/* New remote interface */
insert_new_rows(if_list);
refresh_non_local_interface_lists();
gtk_widget_set_sensitive(GTK_WIDGET(passwd_te), state);
}
-/* user requested to destroy the dialog */
-static void
-capture_remote_destroy_cb(GtkWidget *win, gpointer user_data _U_)
-{
- g_object_set_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY, NULL);
-}
/* user requested to accept remote interface options */
static void
{
GtkWidget *host_te, *port_te, *username_te, *passwd_te, *auth_passwd_rb;
gchar *hostname;
+ struct remote_host *rh;
if (remote_w == NULL) {
return;
global_remote_opts.remote_host_opts.auth_password =
g_strdup(gtk_entry_get_text(GTK_ENTRY(passwd_te)));
- window_destroy(GTK_WIDGET(remote_w));
- update_interface_list();
+ rh = g_malloc (sizeof (*rh));
+ rh->r_host = g_strdup(global_remote_opts.remote_host_opts.remote_host);
+ rh->remote_port = g_strdup(global_remote_opts.remote_host_opts.remote_port);
+ rh->auth_type = global_remote_opts.remote_host_opts.auth_type;
+ rh->auth_password = g_strdup("");
+ rh->auth_username = g_strdup("");
+
+ recent_add_remote_host(hostname, rh);
+
+ update_remote_interface_list();
fill_remote_list();
+ window_destroy(GTK_WIDGET(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY)));
}
static void
window_cancel_button_cb (win, data);
}
-static gboolean
-free_remote_host (gpointer key _U_, gpointer value, gpointer user _U_)
-{
- struct remote_host *rh = value;
-
- g_free (rh->remote_host);
- g_free (rh->remote_port);
- g_free (rh->auth_username);
- g_free (rh->auth_password);
-
- return TRUE;
-}
-
static void
select_if_type_cb(GtkComboBox *iftype_cbx, gpointer data _U_)
{
struct remote_host *rh;
int new_iftype = gtk_combo_box_get_active(GTK_COMBO_BOX(iftype_cbx));
- gint num_remote = g_hash_table_size (remote_host_list);
+ gint num_remote = recent_get_remote_host_list_size();
if (new_iftype != -1 && new_iftype == num_remote+1) {
- g_hash_table_foreach_remove (remote_host_list, free_remote_host, NULL);
+ free_remote_host_list();
num_remote += 2;
while (num_remote--) { /* Remove separator lines and "Clear" item */
gtk_combo_box_text_remove (GTK_COMBO_BOX_TEXT(iftype_cbx), num_remote);
capture_remote_cb(GTK_WIDGET(iftype_cbx), FALSE);
} else {
string = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(iftype_cbx));
- rh = g_hash_table_lookup (remote_host_list, string);
+ rh = recent_get_remote_host(string);
g_free (string);
if (rh) {
remote_w = g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY);
title = create_user_window_title("Wireshark: Remote Interface");
remote_w = dlg_window_new(title);
+ gtk_window_set_transient_for(GTK_WINDOW(remote_w), GTK_WINDOW(interface_management_w));
g_object_set_data(G_OBJECT(remote_w), E_CAP_REMOTE_CALLER_PTR_KEY, interface_management_w);
g_object_set_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY, remote_w);
g_free(title);
gtk_entry_set_visibility(GTK_ENTRY(passwd_te), FALSE);
ws_gtk_grid_attach_defaults(GTK_GRID (auth_passwd_grid), passwd_te, 1, 1, 1, 1);
- /* Button row: "Start" and "Cancel" buttons */
+ /* Button row: "OK" and "Cancel" buttons */
bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, NULL);
gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 5);
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(host_te, ok_but);
dlg_set_activate(port_te, ok_but);
dlg_set_activate(user_te, ok_but);
dlg_set_activate(passwd_te, ok_but);
g_signal_connect(remote_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
- g_signal_connect(remote_w, "destroy", G_CALLBACK(capture_remote_destroy_cb), NULL);
g_object_set_data(G_OBJECT(remote_w), E_REMOTE_HOST_TE_KEY, host_te);
g_object_set_data(G_OBJECT(remote_w), E_REMOTE_PORT_TE_KEY, port_te);
window_present(opt_remote_w);
}
-static void
-recent_print_remote_host (gpointer key _U_, gpointer value, gpointer user)
-{
- FILE *rf = user;
- struct remote_host_info *ri = value;
-
- fprintf (rf, RECENT_KEY_REMOTE_HOST ": %s,%s,%d\n", ri->remote_host, ri->remote_port, ri->auth_type);
-}
-
-void
-capture_remote_combo_recent_write_all(FILE *rf)
-{
- if (remote_host_list && g_hash_table_size (remote_host_list) > 0) {
- /* Write all remote interfaces to the recent file */
- g_hash_table_foreach (remote_host_list, recent_print_remote_host, rf);
- }
-}
-
-gboolean
-capture_remote_combo_add_recent(const gchar *s)
-{
- GList *vals = prefs_get_string_list (s);
- GList *valp = vals;
- gint auth_type;
- char *p;
- struct remote_host_info *rh;
-
- if (valp == NULL)
- return FALSE;
-
- if (remote_host_list == NULL) {
- remote_host_list = g_hash_table_new (g_str_hash, g_str_equal);
- }
-
- rh = g_malloc (sizeof (*rh));
-
- /* First value is the host */
- rh->remote_host = g_strdup (valp->data);
- if (strlen(rh->remote_host) == 0) {
- /* Empty remote host */
- g_free(rh->remote_host);
- g_free(rh);
- return FALSE;
- }
- rh->auth_type = CAPTURE_AUTH_NULL;
- valp = valp->next;
-
- if (valp) {
- /* Found value 2, this is the port number */
- rh->remote_port = g_strdup (valp->data);
- valp = valp->next;
- } else {
- /* Did not find a port number */
- rh->remote_port = g_strdup ("");
- }
-
- if (valp) {
- /* Found value 3, this is the authentication type */
- auth_type = strtol(valp->data, &p, 0);
- if (p != valp->data && *p == '\0') {
- rh->auth_type = auth_type;
- }
- }
-
- /* Do not store username and password */
- rh->auth_username = g_strdup ("");
- rh->auth_password = g_strdup ("");
-
- prefs_clear_string_list(vals);
-
- g_hash_table_insert (remote_host_list, g_strdup(rh->remote_host), rh);
-
- return TRUE;
-}
-
#endif /* HAVE_PCAP_REMOTE */
#if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
gtk_list_store_append (GTK_LIST_STORE(model), &iter);
if (error) {
+#ifdef HAVE_GRESOURCE
+ icon = pixbuf_to_widget("/org/wireshark/image/toolbar/14x14/x-expert-error.png");
+#else
icon = pixbuf_to_widget(expert_error_pb_data);
+#endif
gtk_list_store_set(GTK_LIST_STORE(model), &iter, COMPILE_ERROR, 1, SIGN, gtk_image_get_pixbuf(GTK_IMAGE(icon)), INAME, name, -1);
} else {
+#ifdef HAVE_GRESOURCE
+ icon = pixbuf_to_widget("/org/wireshark/image/expert_ok.png");
+#else
icon = pixbuf_to_widget(expert_ok_pb_data);
+#endif
gtk_list_store_set(GTK_LIST_STORE(model), &iter, COMPILE_ERROR, 0, SIGN, gtk_image_get_pixbuf(GTK_IMAGE(icon)), INAME, name, -1);
}
g_hash_table_insert(compile_results, name, text);
font = pango_font_description_from_string("Monospace");
textview = gtk_text_view_new();
+#if GTK_CHECK_VERSION(3, 0, 0)
+ gtk_widget_override_font(textview, font);
+#else
gtk_widget_modify_font(textview, font);
+#endif
scrolled_win = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(GTK_WIDGET(scrolled_win), 350, -1);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
gtk_widget_show(main_box);
font = pango_font_description_from_string("Monospace");
textview = gtk_text_view_new();
+#if GTK_CHECK_VERSION(3, 0, 0)
+ gtk_widget_override_font(textview, font);
+#else
gtk_widget_modify_font(textview, font);
+#endif
scrolled_win = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_set_size_request(GTK_WIDGET(scrolled_win), 350, -1);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
break;
}
}
- if (device.has_snaplen) {
- snaplen_string = g_strdup_printf("%d", device.snaplen);
- } else {
- snaplen_string = g_strdup("default");
- }
+ if (!linkname)
+ linkname = g_strdup("unknown");
+ snaplen_string = g_strdup_printf("%d", device.snaplen);
if (cap_open_w) {
if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
path_str = g_strdup_printf("%d", indx);
g_array_insert_val(global_capture_opts.all_ifaces, marked_interface, device);
}
#if defined(HAVE_PCAP_CREATE)
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, linkname?linkname:"This should not happen", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, MONITOR, device.monitor_mode_supported?(device.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, device.cfilter, -1);
- #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, linkname?linkname:"This should not happen", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
+ gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, linkname, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, MONITOR, device.monitor_mode_supported?(device.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, device.cfilter, -1);
+ #elif defined(CAN_SET_CAPTURE_BUFFER_SIZE)
+ gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, linkname, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
#else
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, linkname?linkname:"This should not happen", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
+ gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, linkname, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
#endif
if (global_capture_opts.num_selected > 0) {
gtk_widget_set_sensitive(ok_bt, TRUE);
if (get_welcome_window() != NULL) {
change_interface_selection(g_strdup(device.name), device.selected);
}
+ g_free(linkname);
}
+ set_sensitivity_for_start_icon();
}
*monitor_cb,
#endif
*filter_cm, *linktype_combo_box;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
GtkWidget *buffer_size_sb;
#endif
+#ifdef HAVE_EXTCAP
+ GtkWidget *extcap_vbox = NULL;
+#endif
interface_t device;
gpointer ptr = NULL;
global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_interface);
snap_cb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_SNAP_CB_KEY);
snap_sb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_SNAP_SB_KEY);
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
buffer_size_sb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_BUFFER_SIZE_SB_KEY);
#endif
promisc_cb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_PROMISC_KEY);
linktype_combo_box = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_LT_CBX_KEY);
+#ifdef HAVE_EXTCAP
+ extcap_vbox = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_EXTCAP_KEY);
+#endif
+
if (device.links != NULL) {
if (ws_combo_box_get_active_pointer(GTK_COMBO_BOX(linktype_combo_box), &ptr)) {
/* Even though device.links != NULL, we might not have an active pointer
}
}
device.active_dlt = dlt;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
device.buffer = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(buffer_size_sb));
#endif
device.pmode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(promisc_cb));
device.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
if (device.has_snaplen) {
- if (device.snaplen != (guint)gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(snap_sb))) {
- }
device.snaplen = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(snap_sb));
- if (device.snaplen < 1)
- device.snaplen = WTAP_MAX_PACKET_SIZE;
- else if (device.snaplen < MIN_PACKET_SIZE)
+ if (device.snaplen < MIN_PACKET_SIZE)
device.snaplen = MIN_PACKET_SIZE;
} else {
device.snaplen = WTAP_MAX_PACKET_SIZE;
g_free(device.cfilter);
g_assert(filter_text != NULL);
device.cfilter = filter_text;
+
+#ifdef HAVE_EXTCAP
+ if (device.external_cap_args_settings != NULL)
+ g_hash_table_unref(device.external_cap_args_settings);
+
+ if (extcap_vbox != NULL)
+ device.external_cap_args_settings = extcap_gtk_get_state(extcap_vbox);
+
+ /* Destroy the args data linked in the gtk widget */
+#if 0
+ extcap_gtk_free_args(extcap_vbox);
+#endif
+#endif
+
#ifdef HAVE_PCAP_CREATE
/* if dumpcap reported that the interface does not support monitor
mode, we disable monitor mode even if the user explicitly selected it */
g_array_insert_val(global_capture_opts.all_ifaces, marked_interface, device);
}
+#ifdef HAVE_EXTCAP
+
+static GtkWidget *build_extcap_options(const gchar *name, GHashTable *hash) {
+ GtkWidget *ret_box = NULL;
+ GList *arglist = NULL;
+ GList *elem = NULL;
+
+ arglist = extcap_get_if_configuration( name );
+ for ( elem = g_list_first(arglist); elem; elem = elem->next )
+ {
+ GSList *widget_list;
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+ ret_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3);
+#else
+ ret_box = gtk_vbox_new(FALSE, 3);
+#endif
+ widget_list = extcap_populate_gtk_vbox((GList *) elem->data, ret_box, hash);
+ g_object_set_data(G_OBJECT(ret_box), EXTCAP_GTK_DATA_KEY_WIDGETLIST, widget_list);
+ }
+
+ return ret_box;
+}
+#endif
+
+/*
+ * If we have an AirPcap "Wireless Settings" checkbox, have two columns
+ * (vboxes) of settings, and put the buffer size in the right column.
+ *
+ * If we have remote capture support, and if this is a remote interface,
+ * have two columns of settings, have a "Remote Sttings" button, and
+ * put it in the right column.
+ *
+ * If we can set the buffer size, then have two columns of settings
+ * and, if we don't have a "Remote Settings" button, put it in the
+ * right column.
+ *
+ * We avoid having the right column if we don't need it, because it
+ * steals 3 pixels.
+ */
+#if defined(HAVE_AIRPCAP) || defined(HAVE_PCAP_REMOTE) || defined(CAN_SET_CAPTURE_BUFFER_SIZE)
+#define HAVE_TWO_SETTING_COLUMNS
+# if !defined(HAVE_PCAP_REMOTE)
+# define BUFFER_SIZE_IN_RIGHT_COLUMN
+# endif /* !defined(HAVE_PCAP_REMOTE) */
+#endif /* defined(HAVE_AIRPCAP) || defined(HAVE_PCAP_REMOTE) || defined(CAN_SET_CAPTURE_BUFFER_SIZE) */
+
void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column _U_, gpointer userdata)
{
GtkWidget *caller, *window, *swindow = NULL, *if_view,
*main_vb, *if_hb, *if_lb, *if_lb_name,
*main_hb, *left_vb,
-#if defined (HAVE_AIRPCAP) || defined (HAVE_PCAP_REMOTE) || defined (HAVE_PCAP_CREATE)
+#ifdef HAVE_TWO_SETTING_COLUMNS
*right_vb,
#endif
*capture_fr, *capture_vb,
*compile_bt,
#endif
*bbox, *ok_but, *cancel_bt,
+#ifdef HAVE_EXTCAP
+ *extcap_vbox,
+#endif
*help_bt;
+
GList *cf_entry, *list, *cfilter_list;
GtkAdjustment *snap_adj;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
GtkAdjustment *buffer_size_adj;
GtkWidget *buffer_size_lb, *buffer_size_sb, *buffer_size_hb;
#endif
#ifdef HAVE_PCAP_REMOTE
GtkWidget *remote_bt;
#endif
- #ifdef HAVE_AIRPCAP
+#ifdef HAVE_AIRPCAP
GtkWidget *advanced_bt;
#endif
interface_t device;
gchar *tok, *name;
GtkCellRenderer *renderer;
GtkListStore *store;
+ const gchar *new_cfilter;
+#ifdef HAVE_EXTCAP
+ GHashTable *extcap_hash;
+#endif
window = (GtkWidget *)userdata;
caller = gtk_widget_get_toplevel(GTK_WIDGET(window));
device.has_snaplen = FALSE;
device.snaplen = 65535;
device.cfilter = NULL;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
device.buffer = DEFAULT_CAPTURE_BUFFER_SIZE;
#endif
+#ifdef HAVE_EXTCAP
+ device.external_cap_args_settings = NULL;
+#endif
model = gtk_tree_view_get_model(view);
gtk_tree_model_get_iter (model, &iter, path);
gtk_container_set_border_width(GTK_CONTAINER(left_vb), 0);
gtk_box_pack_start(GTK_BOX(main_hb), left_vb, TRUE, TRUE, 0);
-#if defined (HAVE_AIRPCAP) || defined (HAVE_PCAP_REMOTE) || defined (HAVE_PCAP_CREATE)
- /* Avoid adding the right vbox if not needed, because it steals 3 pixels */
+#ifdef HAVE_TWO_SETTING_COLUMNS
right_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(right_vb), 0);
gtk_box_pack_start(GTK_BOX(main_hb), right_vb, FALSE, FALSE, 3);
filter_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
gtk_box_pack_start(GTK_BOX(capture_vb), filter_hb, FALSE, FALSE, 0);
- filter_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_CAPTURE_FILTER_ENTRY);
+ filter_bt = ws_gtk_button_new_from_stock(WIRESHARK_STOCK_CAPTURE_FILTER_ENTRY);
g_signal_connect(filter_bt, "clicked", G_CALLBACK(capture_filter_construct_cb), NULL);
g_signal_connect(filter_bt, "destroy", G_CALLBACK(filter_button_destroy_cb), NULL);
gtk_widget_set_tooltip_text(filter_bt,
/* Create the capture filter combo box*/
filter_cm = gtk_combo_box_text_new_with_entry();
- cfilter_list = (GList *)g_object_get_data(G_OBJECT(opt_edit_w), E_CFILTER_FL_KEY);
- g_object_set_data(G_OBJECT(opt_edit_w), E_CFILTER_FL_KEY, cfilter_list);
g_object_set_data(G_OBJECT(opt_edit_w), E_CFILTER_CM_KEY, filter_cm);
filter_te = gtk_bin_get_child(GTK_BIN(filter_cm));
colorize_filter_te_as_empty(filter_te);
g_signal_connect(filter_te, "changed", G_CALLBACK(capture_filter_check_syntax_cb), NULL);
g_signal_connect(filter_te, "destroy", G_CALLBACK(capture_filter_destroy_cb), NULL);
+ cfilter_list = recent_get_cfilter_list(name);
for (cf_entry = cfilter_list; cf_entry != NULL; cf_entry = g_list_next(cf_entry)) {
- if (cf_entry->data && (strlen((const char *)cf_entry->data) > 0)) {
- gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(filter_cm), (const gchar *)cf_entry->data);
+ new_cfilter = (const gchar *)cf_entry->data;
+ /* If this is the current dfilter or the default cfilter, don't put
+ it in the list, as it'll be added later. */
+ if ((device.cfilter == NULL || strcmp(device.cfilter, new_cfilter) != 0) &&
+ (global_capture_opts.default_options.cfilter == NULL || strcmp(global_capture_opts.default_options.cfilter, new_cfilter) != 0)) {
+ gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), new_cfilter);
}
}
if (global_capture_opts.default_options.cfilter && (strlen(global_capture_opts.default_options.cfilter) > 0)) {
- gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), global_capture_opts.default_options.cfilter);
+ /* If this is the current dfilter, don't put it in the list, as it'll be
+ added later. */
+ if (device.cfilter == NULL || strcmp(device.cfilter, global_capture_opts.default_options.cfilter) != 0) {
+ gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), global_capture_opts.default_options.cfilter);
+ }
}
if (device.cfilter && (strlen(device.cfilter) > 0)) {
gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), device.cfilter);
gtk_box_pack_start(GTK_BOX(filter_hb), compile_bt, FALSE, FALSE, 3);
#endif
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
buffer_size_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
buffer_size_lb = gtk_label_new("Buffer size:");
gtk_box_pack_start (GTK_BOX(buffer_size_hb), buffer_size_lb, FALSE, FALSE, 0);
"The memory buffer size used while capturing. If you notice packet drops, you can try to increase this size.");
gtk_box_pack_start (GTK_BOX(buffer_size_hb), buffer_size_sb, FALSE, FALSE, 0);
g_object_set_data(G_OBJECT(opt_edit_w), E_CAP_BUFFER_SIZE_SB_KEY, buffer_size_sb);
- buffer_size_lb = gtk_label_new("megabyte(s)");
+ buffer_size_lb = gtk_label_new("mebibyte(s)");
gtk_box_pack_start (GTK_BOX(buffer_size_hb), buffer_size_lb, FALSE, FALSE, 3);
gtk_misc_set_alignment(GTK_MISC(buffer_size_lb), 1, 0);
-#ifdef HAVE_PCAP_REMOTE
- gtk_box_pack_start (GTK_BOX(left_vb), buffer_size_hb, FALSE, FALSE, 0);
-#else
+#ifdef BUFFER_SIZE_IN_RIGHT_COLUMN
gtk_box_pack_start (GTK_BOX(right_vb), buffer_size_hb, FALSE, FALSE, 0);
-#endif
-#endif
+#else /* BUFFER_SIZE_IN_RIGHT_COLUMN */
+ gtk_box_pack_start (GTK_BOX(left_vb), buffer_size_hb, FALSE, FALSE, 0);
+#endif /* BUFFER_SIZE_IN_RIGHT_COLUMN */
+#endif /* CAN_SET_CAPTURE_BUFFER_SIZE */
#ifdef HAVE_PCAP_REMOTE
/*
* confuse users, so that they ask why this is grayed out on
* their non-Windows machine and ask how to enable it.
*/
- airpcap_if_selected = get_airpcap_if_from_name(airpcap_if_list, device.name);
+ airpcap_if_selected = get_airpcap_if_from_name(g_airpcap_if_list, device.name);
if (airpcap_if_selected != NULL) {
advanced_bt = gtk_button_new_with_label("Wireless Settings");
}
#endif
+#ifdef HAVE_EXTCAP
+ extcap_hash = device.external_cap_args_settings;
+ extcap_vbox = build_extcap_options(device.name, extcap_hash);
+ if (extcap_vbox != NULL) {
+ gtk_box_pack_start(GTK_BOX(capture_vb), extcap_vbox, FALSE, FALSE, 5);
+ gtk_widget_show(extcap_vbox);
+ }
+ g_object_set_data(G_OBJECT(opt_edit_w), E_CAP_EXTCAP_KEY, extcap_vbox);
+#endif
+
/* Button row: "Start", "Cancel" and "Help" buttons */
bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL);
gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 5);
gint indx = -1;
guint i;
+ /* Initialise device */
+ device.locked = FALSE;
+ device.cfilter = NULL;
+
if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
model = gtk_tree_view_get_model(if_cb);
gtk_tree_model_get_iter (model, &iter, path);
GtkTreeIter iter;
GtkTreeView *if_cb;
GtkTreeModel *model;
- GtkWidget *pcap_ng_cb;
- gboolean enabled = FALSE, capture_set = FALSE;
+ GtkWidget *filter_cm, *pcap_ng_cb;
+ gchar *interface = NULL, *filter_text = NULL;
+ gboolean enabled = FALSE, capture_set = FALSE, pseudo = FALSE;
+ guint16 num_temp, i;
+ interface_t device;
if (gtk_toggle_button_get_active(button))
enabled = TRUE;
if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
model = gtk_tree_view_get_model(if_cb);
pcap_ng_cb = (GtkWidget *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_PCAP_NG_KEY);
+ num_temp = global_capture_opts.num_selected++;
+ filter_cm = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY);
+ filter_text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(filter_cm));
if (gtk_tree_model_get_iter_first(model, &iter)) {
do {
- gtk_tree_model_get (model, &iter, CAPTURE, &capture_set, -1);
- if (!capture_set && enabled) {
- global_capture_opts.num_selected++;
- } else if (capture_set && !enabled) {
- global_capture_opts.num_selected--;
+ gtk_tree_model_get (model, &iter, CAPTURE, &capture_set, IFACE_HIDDEN_NAME, &interface, -1);
+ if (strcmp(interface, "any") == 0) {
+ pseudo = TRUE;
+ }
+ if (!capture_set && enabled && !pseudo) {
+ num_temp++;
+ } else if (capture_set && (!enabled || (enabled && pseudo))) {
+ num_temp--;
+ }
+ if (!pseudo) {
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, enabled, -1);
+ if (strlen(filter_text) != 0) {
+ for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
+ if (strcmp(device.name, interface) == 0) {
+ g_array_remove_index(global_capture_opts.all_ifaces, i);
+ g_free(device.cfilter);
+ device.cfilter = g_strdup(filter_text);
+ g_array_insert_val(global_capture_opts.all_ifaces, i, device);
+ update_filter_string(device.name, filter_text);
+ }
+ }
+ }
+ } else {
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, -1);
}
- gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, enabled, -1);
+ pseudo = FALSE;
} while (gtk_tree_model_iter_next(model, &iter));
}
- if (global_capture_opts.num_selected >= 2) {
+ if (num_temp >= 2) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pcap_ng_cb), TRUE);
gtk_widget_set_sensitive(pcap_ng_cb, FALSE);
- } else if (global_capture_opts.num_selected <= 1) {
+ } else if (num_temp <= 1) {
gtk_widget_set_sensitive(pcap_ng_cb, TRUE);
}
if (interfaces_dialog_window_present()) {
if (get_welcome_window() != NULL) {
change_selection_for_all(enabled);
}
+ if (global_capture_opts.num_selected != num_temp) {
+ global_capture_opts.num_selected = num_temp;
+ }
if (global_capture_opts.num_selected > 0) {
gtk_widget_set_sensitive(ok_bt, TRUE);
#if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
gtk_widget_set_sensitive(all_compile_bt, FALSE);
#endif
}
+ set_sensitivity_for_start_icon();
}
GtkTreeIter iter;
GtkTreeView *if_cb;
GtkTreeModel *model;
- gboolean enabled = FALSE, set;
+ gboolean enabled = FALSE;
interface_t device;
interface_options interface_opts;
guint i;
- set = gtk_toggle_button_get_active(button);
- gtk_toggle_button_set_active(button, (set?FALSE:TRUE));
if (gtk_toggle_button_get_active(button))
enabled = TRUE;
case(ESD_BTN_OK):
for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
- if (strcmp((gchar *)data, device.name) == 0) {
- simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
- "%sA pipe with this name already exists.%s",
- simple_dialog_primary_start(), simple_dialog_primary_end());
- if_cb = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_L_KEY));
- pipe_te = (GtkWidget *) g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY);
- model = gtk_tree_view_get_model(if_cb);
- if (gtk_tree_model_get_iter_first (model, &iter)) {
- do {
- gtk_tree_model_get(model, &iter, 0, &optname, -1);
- if (strcmp(optname, (gchar *) data) == 0) {
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, pipe_name, -1);
- gtk_entry_set_text(GTK_ENTRY(pipe_te), pipe_name);
- break;
- }
- } while (gtk_tree_model_iter_next(model, &iter));
- g_free(optname);
- }
- return;
+ if (strcmp((gchar *)data, device.name) == 0) {
+ simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
+ "%sA pipe with this name already exists.%s",
+ simple_dialog_primary_start(), simple_dialog_primary_end());
+ if_cb = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_L_KEY));
+ pipe_te = (GtkWidget *) g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY);
+ model = gtk_tree_view_get_model(if_cb);
+ if (gtk_tree_model_get_iter_first (model, &iter)) {
+ do {
+ gtk_tree_model_get(model, &iter, 0, &optname, -1);
+ if (strcmp(optname, (gchar *) data) == 0) {
+ gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, pipe_name, -1);
+ gtk_entry_set_text(GTK_ENTRY(pipe_te), pipe_name);
+ break;
+ }
+ } while (gtk_tree_model_iter_next(model, &iter));
+ g_free(optname);
}
+ return;
}
- for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
- device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
- if (strcmp(pipe_name, device.name) == 0) {
- device.name = g_strdup((gchar *)data);
- device.display_name = g_strdup_printf("%s", device.name);
- g_array_remove_index(global_capture_opts.all_ifaces, i);
- g_array_insert_val(global_capture_opts.all_ifaces, i, device);
- temp = g_strdup_printf("<b>%s</b>", device.display_name);
- if (device.has_snaplen) {
- snaplen_string = g_strdup_printf("%d", device.snaplen);
- } else {
- snaplen_string = g_strdup("default");
- }
- if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
- model = gtk_tree_view_get_model(if_cb);
- if (gtk_tree_model_get_iter_first (model, &iter)) {
- do {
- gtk_tree_model_get(model, &iter, IFACE_HIDDEN_NAME, &optname, -1);
- if (strcmp(optname, pipe_name) == 0) {
+ }
+ for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
+ if (strcmp(pipe_name, device.name) == 0) {
+ g_free(device.name);
+ g_free(device.display_name);
+ device.name = g_strdup((gchar *)data);
+ device.display_name = g_strdup_printf("%s", device.name);
+ g_array_remove_index(global_capture_opts.all_ifaces, i);
+ g_array_insert_val(global_capture_opts.all_ifaces, i, device);
+ temp = g_strdup_printf("<b>%s</b>", device.display_name);
+ snaplen_string = g_strdup_printf("%d", device.snaplen);
+ if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
+ model = gtk_tree_view_get_model(if_cb);
+ if (gtk_tree_model_get_iter_first (model, &iter)) {
+ do {
+ gtk_tree_model_get(model, &iter, IFACE_HIDDEN_NAME, &optname, -1);
+ if (strcmp(optname, pipe_name) == 0) {
#if defined(HAVE_PCAP_CREATE)
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, MONITOR, device.monitor_mode_supported?(device.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, device.cfilter, -1);
-#elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
+ gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, MONITOR, device.monitor_mode_supported?(device.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, device.cfilter, -1);
+#elif defined(CAN_SET_CAPTURE_BUFFER_SIZE)
+ gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
#else
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
+ gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
#endif
#if 0
- oldname = g_strdup(pipe_name);
+ oldname = g_strdup(pipe_name);
#endif
- pipe_name = g_strdup(device.name);
- break;
- }
- } while (gtk_tree_model_iter_next(model, &iter));
+ pipe_name = g_strdup(device.name);
+ break;
+ }
+ } while (gtk_tree_model_iter_next(model, &iter));
- g_free(optname);
- }
- if (global_capture_opts.num_selected > 0) {
- gtk_widget_set_sensitive(ok_bt, TRUE);
+ g_free(optname);
+ }
+ if (global_capture_opts.num_selected > 0) {
+ gtk_widget_set_sensitive(ok_bt, TRUE);
#if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
- gtk_widget_set_sensitive(all_compile_bt, TRUE);
+ gtk_widget_set_sensitive(all_compile_bt, TRUE);
#endif
- } else {
- gtk_widget_set_sensitive(ok_bt, FALSE);
+ } else {
+ gtk_widget_set_sensitive(ok_bt, FALSE);
#if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
- gtk_widget_set_sensitive(all_compile_bt, FALSE);
+ gtk_widget_set_sensitive(all_compile_bt, FALSE);
#endif
- }
- refresh_non_local_interface_lists();
- break;
}
+ refresh_non_local_interface_lists();
+ break;
}
- break;
- case(ESD_BTN_CANCEL): {
- if_cb = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_L_KEY));
- pipe_te = (GtkWidget *) g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY);
- model = gtk_tree_view_get_model(if_cb);
+ }
+ break;
+ case(ESD_BTN_CANCEL): {
+ if_cb = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_L_KEY));
+ pipe_te = (GtkWidget *) g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY);
+ model = gtk_tree_view_get_model(if_cb);
- if (gtk_tree_model_get_iter_first (model, &iter)) {
- do {
- gtk_tree_model_get(model, &iter, 0, &optname, -1);
- if (strcmp(optname, (gchar *) data) == 0) {
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, pipe_name, -1);
- gtk_entry_set_text(GTK_ENTRY(pipe_te), pipe_name);
- break;
- }
- } while (gtk_tree_model_iter_next(model, &iter));
- g_free(optname);
- }
- break;
+ if (gtk_tree_model_get_iter_first (model, &iter)) {
+ do {
+ gtk_tree_model_get(model, &iter, 0, &optname, -1);
+ if (strcmp(optname, (gchar *) data) == 0) {
+ gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, pipe_name, -1);
+ gtk_entry_set_text(GTK_ENTRY(pipe_te), pipe_name);
+ break;
+ }
+ } while (gtk_tree_model_iter_next(model, &iter));
+ g_free(optname);
}
- default:
- g_assert_not_reached();
+ break;
+ }
+ default:
+ g_assert_not_reached();
}
}
guint i;
gpointer dialog;
+ if (!pipe_name)
+ return;
+
pipe_te = (GtkWidget *) g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY);
g_save_file = gtk_entry_get_text(GTK_ENTRY(pipe_te));
name = g_strdup(g_save_file);
}
}
pipe_name = g_strdup(g_save_file);
+ memset(&device, 0, sizeof(device));
device.name = g_strdup(g_save_file);
device.display_name = g_strdup_printf("%s", device.name);
device.hidden = FALSE;
device.no_addresses = 0;
device.last_packets = 0;
device.links = NULL;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
device.buffer = DEFAULT_CAPTURE_BUFFER_SIZE;
#endif
device.active_dlt = -1;
device.if_info.vendor_description = NULL;
device.if_info.addrs = NULL;
device.if_info.loopback = FALSE;
+ device.if_info.type = IF_PIPE;
+#ifdef HAVE_EXTCAP
+ device.if_info.extcap = NULL;
+ device.external_cap_args_settings = NULL;
+#endif
#if defined(HAVE_PCAP_CREATE)
device.monitor_mode_enabled = FALSE;
device.monitor_mode_supported = FALSE;
indx = global_capture_opts.all_ifaces->len;
temp = g_strdup_printf("<b>%s</b>", device.display_name);
- if (device.has_snaplen) {
- snaplen_string = g_strdup_printf("%d", device.snaplen);
- } else {
- snaplen_string = g_strdup("default");
- }
+ snaplen_string = g_strdup_printf("%d", device.snaplen);
if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
path_str = g_strdup_printf("%d", indx);
gtk_list_store_append (GTK_LIST_STORE(model), &iter);
#if defined(HAVE_PCAP_CREATE)
gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, MONITOR, device.monitor_mode_supported?(device.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, device.cfilter, -1);
-#elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
+#elif defined(CAN_SET_CAPTURE_BUFFER_SIZE)
gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
#else
gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
static void
cancel_pipe_cb (gpointer w _U_)
{
+#ifdef HAVE_PCAP_REMOTE
+ if (interface_management_w && G_IS_OBJECT(interface_management_w)) {
+ GtkWidget *remote_w;
+ remote_w = g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY);
+ if (remote_w != NULL && G_IS_OBJECT(remote_w))
+ window_destroy(remote_w);
+ }
+#endif
window_destroy(GTK_WIDGET(interface_management_w));
+ pipe_name = NULL;
}
static void
hide_interface(g_strdup(new_hide));
/* Refresh all places that are displaying an interface list
- that includes local interfaces. */
+ that includes local interfaces, in case we've changed
+ a property of the interface list that changes how it's
+ displayed. */
refresh_local_interface_lists();
/* save changes to the preferences file */
{
GtkTreeView *view;
- fill_local_list();
+ if (interface_management_w)
+ fill_local_list();
view = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
create_and_fill_model(GTK_TREE_VIEW(view));
update_properties_all();
}
+/*
+ * We've been asked to rescan the system looking for interfaces.
+ */
static void
rescan_local_cb(GtkWidget *button _U_, gpointer *data _U_)
{
gchar *host = "";
GtkTreeView *remote_l;
GtkTreeStore *store;
- GtkWidget *host_te, *remote_w;
num_selected = 0;
- gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(interface_management_w), E_REMOTE_DEL_BT_KEY), FALSE);
remote_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_L_KEY));
store = gtk_tree_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING);
for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
} else {
/* fill the store */
if (strcmp(host, device.remote_opts.remote_host_opts.remote_host) != 0) {
- remote_w = g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY);
- host_te = (GtkWidget *)g_object_get_data(G_OBJECT(remote_w), E_REMOTE_HOST_TE_KEY);
- iftype_combo_box_add (host_te, &device);
host = g_strdup(device.remote_opts.remote_host_opts.remote_host);
gtk_tree_store_append(store, &iter, NULL);
gtk_tree_store_set(store, &iter, 0, host, 3, "FALSE", -1);
} while (gtk_tree_model_iter_next(model, &iter));
g_free(name);
}
- hide_interface(g_strdup(new_hide));
+ hide_interface(new_hide);
/* Refresh all places that are displaying an interface list
that includes interfaces other than local interfaces
} else {
if (strcmp(host, device.remote_opts.remote_host_opts.remote_host) == 0) {
g_array_remove_index(global_capture_opts.all_ifaces, i);
+ capture_opts_free_interface_t(&device);
}
}
}
GtkTreeSelection *selection;
#endif
+ if (interface_management_w != NULL && G_IS_OBJECT(interface_management_w)) {
+ /* There's already a "Manage Interfaces" dialog box; reactivate it. */
+ reactivate_window(interface_management_w);
+ return;
+ }
+
interface_management_w = window_new(GTK_WINDOW_TOPLEVEL, "Interface Management");
gtk_window_set_transient_for(GTK_WINDOW(interface_management_w), GTK_WINDOW(parent_win));
gtk_window_set_destroy_with_parent(GTK_WINDOW(interface_management_w), TRUE);
gtk_container_add(GTK_CONTAINER(edit_fr), list_bb);
gtk_widget_show(list_bb);
- new_bt = gtk_button_new_from_stock(GTK_STOCK_NEW);
+ new_bt = ws_gtk_button_new_from_stock(GTK_STOCK_NEW);
g_signal_connect(new_bt, "clicked", G_CALLBACK(pipe_new_bt_clicked_cb), NULL);
gtk_widget_show(new_bt);
gtk_box_pack_start (GTK_BOX (list_bb), new_bt, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text (new_bt, "Add a new pipe (with default properties)");
- del_bt = gtk_button_new_from_stock(GTK_STOCK_DELETE);
+ del_bt = ws_gtk_button_new_from_stock(GTK_STOCK_DELETE);
g_signal_connect(del_bt, "clicked", G_CALLBACK(pipe_del_bt_clicked_cb), NULL);
gtk_widget_show(del_bt);
gtk_widget_set_sensitive(del_bt, FALSE);
);
gtk_box_pack_start(GTK_BOX(middle_hb), pipe_te, TRUE, TRUE, 3);
gtk_widget_set_sensitive(pipe_te, FALSE);
- pipe_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_BROWSE);
+ pipe_bt = ws_gtk_button_new_from_stock(WIRESHARK_STOCK_BROWSE);
gtk_widget_set_tooltip_text(GTK_WIDGET(pipe_bt),
"Select a pipe from which data should be captured, "
"instead of entering the pipe name directly. "
gtk_widget_show(help_hbox);
gtk_box_set_spacing(GTK_BOX(help_hbox), DLG_BUTTON_SPACING);
- add_but = gtk_button_new_from_stock(GTK_STOCK_ADD);
+ add_but = ws_gtk_button_new_from_stock(GTK_STOCK_ADD);
g_object_set_data(G_OBJECT(bbox), GTK_STOCK_ADD, add_but);
gtk_box_pack_start(GTK_BOX(help_hbox), add_but, FALSE, FALSE, 0);
g_signal_connect(add_but, "clicked", G_CALLBACK(show_remote_dialog), NULL);
gtk_widget_set_tooltip_text(GTK_WIDGET(add_but), "Add a remote host to the list");
gtk_widget_show(add_but);
- delete_bt = gtk_button_new_from_stock(GTK_STOCK_DELETE);
+ delete_bt = ws_gtk_button_new_from_stock(GTK_STOCK_DELETE);
g_object_set_data(G_OBJECT(bbox), GTK_STOCK_DELETE, delete_bt);
gtk_box_pack_start(GTK_BOX(help_hbox), delete_bt, FALSE, FALSE, 0);
g_signal_connect(delete_bt, "clicked", G_CALLBACK(remove_remote_host), NULL);
g_object_set_data(G_OBJECT(interface_management_w), E_REMOTE_DEL_BT_KEY, delete_bt);
gtk_widget_show(delete_bt);
- ok_but = gtk_button_new_from_stock(GTK_STOCK_APPLY);
+ ok_but = ws_gtk_button_new_from_stock(GTK_STOCK_APPLY);
gtk_box_pack_end(GTK_BOX(button_hbox), ok_but, FALSE, FALSE, 0);
g_signal_connect(GTK_WIDGET(ok_but), "clicked", G_CALLBACK(ok_remote_cb), NULL);
gtk_widget_set_tooltip_text(GTK_WIDGET(ok_but), "Apply the changes to the general list of local interfaces");
gtk_widget_show(ok_but);
- cancel_bt = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
+ cancel_bt = ws_gtk_button_new_from_stock(GTK_STOCK_CLOSE);
gtk_box_pack_end(GTK_BOX(button_hbox), cancel_bt, FALSE, FALSE, 0);
g_signal_connect(GTK_WIDGET(cancel_bt), "clicked", G_CALLBACK(cancel_pipe_cb), interface_management_w);
gtk_widget_set_tooltip_text(GTK_WIDGET(cancel_bt), "Cancel and exit dialog.");
}
static void
-update_properties_all(void) {
+update_properties_all(void)
+{
unsigned int i;
interface_t device;
- gchar * filter_str = NULL;
- gboolean filter_all = TRUE;
- gboolean capture_all = TRUE;
- gboolean promisc_all = TRUE;
+ gboolean capture_all;
+ gboolean promisc_all;
+ gboolean filter_all;
+ gchar * filter_str;
GtkWidget *promisc_b;
GtkWidget *capture_b;
+ GtkWidget *all_filter_te;
+ /* If we don't have a Capture Options dialog open, there's nothing
+ for us to do. */
+ if (!cap_open_w)
+ return;
+
+ /* Determine whether all interfaces:
+
+ are selected for capturing;
+
+ all selected interfaces are in promiscuous mode;
+
+ all selected interfaces have the same capture filter.
+
+ Start out by assuming that all three are the case, and change that
+ once we find an interface where it's not the case. */
+ capture_all = TRUE;
+ promisc_all = TRUE;
+ filter_all = TRUE;
+ filter_str = NULL;
for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
if (!device.hidden) {
if (!device.selected) {
+ /* This interface isn't selected, so not all interfaces are selected. */
capture_all = FALSE;
- } else if (device.cfilter != NULL && filter_all) {
- if (filter_str == NULL) {
- filter_str = g_strdup(device.cfilter);
- } else if (strcmp(device.cfilter, filter_str)) {
- filter_str = NULL;
- filter_all = FALSE;
+ } else {
+ /* This interface is selected; is it in promiscuous mode? */
+ if (!device.pmode) {
+ /* No, so not all selected interfaces are in promiscuous mode. */
+ promisc_all = FALSE;
+ }
+ /* Have we seen the same capture filter on all interfaces at
+ which we've looked so far? */
+ if (device.cfilter != NULL && filter_all) {
+ /* Yes. Is this the first interface for which we've seen a
+ filter? */
+ if (filter_str == NULL) {
+ /* First selected interface - save its capture filter;
+ there aren't any filters against which to compare. */
+ filter_str = g_strdup(device.cfilter);
+ } else {
+ /* Not the first selected interface; is its capture filter
+ the same as the one the other interfaces we've looked
+ at have? */
+ if (strcmp(device.cfilter, filter_str) != 0) {
+ /* No, so not all selected interfaces have the same capture
+ filter. */
+ if (filter_str != NULL) {
+ g_free(filter_str);
+ }
+ filter_str = NULL;
+ filter_all = FALSE;
+ }
+ }
}
- }
- if (!device.pmode) {
- promisc_all = FALSE;
}
}
}
+
+ /* If all interfaces are selected, check the "capture on all interfaces"
+ checkbox, otherwise un-check it. */
+ capture_b = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_CAP_KEY_ALL);
+ g_signal_handler_block(capture_b, capture_all_handler_id);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(capture_b), capture_all);
+ g_signal_handler_unblock(capture_b, capture_all_handler_id);
+
+ /* If all selected interfaces are in promiscuous mode, check the global
+ "promiscuous mode" checkbox, otherwise un-check it. */
promisc_b = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_CAP_PROMISC_KEY_ALL);
+ g_signal_handler_block(promisc_b, promisc_all_handler_id);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_b), promisc_all);
-
- if (capture_all) {
- capture_b = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_CAP_KEY_ALL);
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(capture_b), TRUE);
- }
- if (filter_all && filter_str != NULL) {
- gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(g_object_get_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY)), 0, filter_str);
- gtk_combo_box_set_active(GTK_COMBO_BOX(g_object_get_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY)), 0);
+ g_signal_handler_unblock(promisc_b, promisc_all_handler_id);
+
+ /* If all selected interfaces have the same filter string, set the
+ global filter string to it. */
+ all_filter_te = gtk_bin_get_child(GTK_BIN(g_object_get_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY)));
+ if (filter_all) {
+ /* Either no interfaces were selected, or all selected interfaces
+ have the same filter. In the former case, make the global capture
+ filter empty; in the latter case, make it that filter. */
+ if (filter_str != NULL) {
+ gtk_entry_set_text(GTK_ENTRY(all_filter_te), filter_str);
+ g_free(filter_str);
+ } else {
+ gtk_entry_set_text(GTK_ENTRY(all_filter_te), "");
+ }
} else {
- gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(g_object_get_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY)), 0, "");
- gtk_combo_box_set_active(GTK_COMBO_BOX(g_object_get_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY)), 0);
+ /* Not all selected interfaces have the same filter, so there is no
+ global capture filter; make it empty to reflect that. */
+ gtk_entry_set_text(GTK_ENTRY(all_filter_te), "");
}
}
gboolean if_present = TRUE;
GList *all_cfilter_list, *cf_entry;
window_geometry_t tl_geom;
+ const gchar *new_cfilter;
if (interfaces_dialog_window_present()) {
destroy_if_window();
}
- if (cap_open_w != NULL) {
+ if (cap_open_w != NULL && G_IS_OBJECT(cap_open_w)) {
/* There's already a "Capture Options" dialog box; reactivate it. */
reactivate_window(cap_open_w);
return;
/* update airpcap interface list */
/* load the airpcap interfaces */
- airpcap_if_list = get_airpcap_interface_list(&err, &err_str);
+ g_airpcap_if_list = get_airpcap_interface_list(&err, &err_str);
/* If we don't get a list don't do any thing.
- * If the error is AIRPCAP_NOT_LOADED it avoids a unneccessay rescan of the packet list
+ * If the error is AIRPCAP_NOT_LOADED it avoids an unnecessary rescan of the packet list
* ( see airpcap_loader.h for error codes).
*/
- if (airpcap_if_list == NULL) {
+ if (g_airpcap_if_list == NULL) {
if (err == CANT_GET_AIRPCAP_INTERFACE_LIST) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
g_free(err_str);
}
}else{
decryption_cb = (GtkWidget *)g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY);
- /* XXXX update_decryption_mode_list() trigers a rescan, should only be done if the mode is changed */
+ /* XXXX update_decryption_mode_list() triggers a rescan, should only be done if the mode is changed */
update_decryption_mode_list(decryption_cb);
/* select the first as default (THIS SHOULD BE CHANGED) */
- airpcap_if_active = airpcap_get_default_if(airpcap_if_list);
+ airpcap_if_active = airpcap_get_default_if(g_airpcap_if_list);
}
#endif
gtk_container_set_border_width(GTK_CONTAINER(capture_vb), DLG_OUTER_MARGIN);
gtk_container_add(GTK_CONTAINER(capture_fr), capture_vb);
-#if defined (HAVE_PCAP_REMOTE)
- if (remote_host_list == NULL) {
- remote_host_list = g_hash_table_new (g_str_hash, g_str_equal);
- }
-#endif
-
swindow = gtk_scrolled_window_new (NULL, NULL);
- gtk_widget_set_size_request(swindow, 676, 180);
+ gtk_widget_set_size_request(swindow, 676, 100);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swindow), GTK_SHADOW_IN);
view = gtk_tree_view_new ();
gtk_tree_view_column_set_resizable(column, TRUE );
gtk_tree_view_column_set_alignment(column, 0.5f);
g_object_set_data(G_OBJECT(column), E_MCAPTURE_COLUMNS_COL_KEY, GINT_TO_POINTER(INTERFACE));
- gtk_tree_view_column_set_clickable(column, TRUE);
- gtk_tree_view_column_set_reorderable(column, TRUE);
- g_signal_connect(gtk_tree_view_column_get_button(column), "button_press_event",
- G_CALLBACK(column_button_pressed_cb), column);
if (!prefs.capture_columns || prefs_capture_options_dialog_column_is_visible("INTERFACE"))
gtk_tree_view_column_set_visible(column, TRUE);
else
gtk_tree_view_column_set_visible(column, FALSE);
g_object_set(renderer, "xalign", 0.5f, NULL);
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
renderer = gtk_cell_renderer_text_new();
- column = gtk_tree_view_column_new_with_attributes("Buffer [MB]", renderer, "text", BUFFER, NULL);
+ column = gtk_tree_view_column_new_with_attributes("Buffer [MiB]", renderer, "text", BUFFER, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
gtk_tree_view_column_set_reorderable(column, TRUE);
g_object_set_data(G_OBJECT(column), E_MCAPTURE_COLUMNS_COL_KEY, GINT_TO_POINTER(BUFFER));
all_cb = gtk_check_button_new_with_mnemonic( "Capture on all interfaces");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(all_cb), FALSE);
- g_signal_connect(all_cb, "toggled", G_CALLBACK(capture_all_cb), NULL);
+ capture_all_handler_id = g_signal_connect(all_cb, "toggled", G_CALLBACK(capture_all_cb), NULL);
gtk_widget_set_tooltip_text(all_cb, "Activate the box to capture on all interfaces. "
"Deactivate it to capture on none and set the interfaces individually.");
gtk_box_pack_start(GTK_BOX(left_vb), all_cb, TRUE, TRUE, 0);
gtk_widget_set_sensitive(GTK_WIDGET(all_cb), if_present);
/* Promiscuous mode row */
- promisc_cb = gtk_check_button_new_with_mnemonic("Capture all in _promiscuous mode");
- if (!global_capture_opts.session_started) {
+ promisc_cb = gtk_check_button_new_with_mnemonic("Use _promiscuous mode on all interfaces");
+ if (!global_capture_session.session_started) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_cb), prefs.capture_prom_mode);
} else {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_cb), get_all_prom_mode());
}
- g_signal_connect(promisc_cb, "button-press-event", G_CALLBACK(promisc_mode_callback), NULL);
+ promisc_all_handler_id = g_signal_connect(promisc_cb, "toggled", G_CALLBACK(promisc_mode_callback), NULL);
gtk_widget_set_tooltip_text(promisc_cb,
"Usually a network adapter will only capture the traffic sent to its own network address. "
- "If you want to capture all traffic that all network adapters can \"see\", mark this option. "
- "If you want to set this option on a per interface basis, unmark this button and set the "
- "option individually."
+ "If you want to capture all traffic that all network adapters can \"see\", select this option. "
+ "If you want to set this option on a per-interface basis, do not select this option. "
+ "Instead, select the individual checkboxes in the interface list's \"Prom. Mode\" column. "
"See the FAQ for some more details of capturing packets from a switched network.");
gtk_box_pack_start(GTK_BOX(left_vb), promisc_cb, TRUE, TRUE, DLG_LABEL_SPACING);
g_object_set_data(G_OBJECT(cap_open_w), E_CAP_IFTYPE_CBX_KEY, iftype_cbx);
gtk_box_pack_start(GTK_BOX(right_vb), iftype_cbx, FALSE, FALSE, 0);
- g_signal_connect(iftype_cbx, "clicked", G_CALLBACK(show_add_interfaces_dialog), cap_open_w);
+ g_signal_connect(iftype_cbx, "clicked", G_CALLBACK(show_add_interfaces_dialog), NULL);
gtk_widget_show(iftype_cbx);
main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DLG_UNRELATED_SPACING, FALSE);
all_filter_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE);
gtk_box_pack_start(GTK_BOX(all_vb), all_filter_hb, FALSE, FALSE, DLG_LABEL_SPACING);
- all_filter_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_CAPTURE_FILTER_ENTRY);
+ all_filter_bt = ws_gtk_button_new_from_stock(WIRESHARK_STOCK_CAPTURE_FILTER_ENTRY);
g_signal_connect(all_filter_bt, "clicked", G_CALLBACK(capture_filter_construct_cb), NULL);
g_signal_connect(all_filter_bt, "destroy", G_CALLBACK(filter_button_destroy_cb), NULL);
gtk_widget_set_tooltip_text(all_filter_bt,
/* Create the capture filter combo box*/
all_filter_cm = gtk_combo_box_text_new_with_entry();
- all_cfilter_list = (GList *)g_object_get_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_FL_KEY);
- g_object_set_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_FL_KEY, all_cfilter_list);
g_object_set_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY, all_filter_cm);
all_filter_te = gtk_bin_get_child(GTK_BIN(all_filter_cm));
colorize_filter_te_as_empty(all_filter_te);
g_signal_connect(all_filter_te, "changed", G_CALLBACK(capture_all_filter_check_syntax_cb), NULL);
g_signal_connect(all_filter_te, "destroy", G_CALLBACK(capture_filter_destroy_cb), NULL);
+ all_cfilter_list = recent_get_cfilter_list(NULL);
for (cf_entry = all_cfilter_list; cf_entry != NULL; cf_entry = g_list_next(cf_entry)) {
- if (cf_entry->data && (strlen((const char *)cf_entry->data) > 0)) {
- gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(all_filter_cm), (const gchar *)cf_entry->data);
+ new_cfilter = (const gchar *)cf_entry->data;
+ /* If this is the default cfilter, don't put it in the list, as it'll
+ be added later. */
+ if (global_capture_opts.default_options.cfilter == NULL || strcmp(global_capture_opts.default_options.cfilter, new_cfilter) != 0) {
+ gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(all_filter_cm), new_cfilter);
}
}
if (global_capture_opts.default_options.cfilter && (strlen(global_capture_opts.default_options.cfilter) > 0)) {
);
gtk_box_pack_start(GTK_BOX(file_hb), file_te, TRUE, TRUE, 3);
- file_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_BROWSE);
+ file_bt = ws_gtk_button_new_from_stock(WIRESHARK_STOCK_BROWSE);
gtk_widget_set_tooltip_text(file_bt,
"Select a file to which captured data will be written, "
"instead of entering the file name directly. "
gtk_widget_set_tooltip_text(multi_files_on_cb,
"Instead of using a single capture file, multiple files will be created. "
"The generated file names will contain an incrementing number and the start time of the capture.");
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), multi_files_on_cb, 0, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), multi_files_on_cb, 0, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
/* Pcap-NG row */
pcap_ng_cb = gtk_check_button_new_with_mnemonic("Use pcap-ng format");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pcap_ng_cb), global_capture_opts.use_pcapng);
gtk_widget_set_tooltip_text(pcap_ng_cb, "Capture packets in the next-generation capture file format. "
"This is still experimental.");
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), pcap_ng_cb, 2, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), pcap_ng_cb, 2, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
row++;
/* Ring buffer filesize row */
gtk_widget_set_tooltip_text(ring_filesize_cb,
"If the selected file size is exceeded, capturing switches to the next file.\n"
"PLEASE NOTE: at least one of the \"Next file every\" options MUST be selected.");
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), ring_filesize_cb, 0, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), ring_filesize_cb, 0, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
ring_filesize_adj = (GtkAdjustment *) gtk_adjustment_new(0.0,
1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
ring_filesize_sb = gtk_spin_button_new (ring_filesize_adj, 0, 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (ring_filesize_sb), TRUE);
gtk_widget_set_size_request(ring_filesize_sb, 80, -1);
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), ring_filesize_sb, 1, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), ring_filesize_sb, 1, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
ring_filesize_cbx = size_unit_combo_box_new(global_capture_opts.autostop_filesize);
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), ring_filesize_cbx, 2, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), ring_filesize_cbx, 2, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
value = size_unit_combo_box_set_value(global_capture_opts.autostop_filesize);
- gtk_adjustment_set_value(ring_filesize_adj, (gfloat) value);
+ gtk_adjustment_set_value(ring_filesize_adj, (gdouble) value);
row++;
gtk_widget_set_tooltip_text(file_duration_cb,
"If the selected duration is exceeded, capturing switches to the next file.\n"
"PLEASE NOTE: at least one of the \"Next file every\" options MUST be selected.");
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), file_duration_cb, 0, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), file_duration_cb, 0, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
file_duration_adj = (GtkAdjustment *)gtk_adjustment_new(0.0,
1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
file_duration_sb = gtk_spin_button_new (file_duration_adj, 0, 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (file_duration_sb), TRUE);
gtk_widget_set_size_request(file_duration_sb, 80, -1);
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), file_duration_sb, 1, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), file_duration_sb, 1, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
file_duration_cbx = time_unit_combo_box_new(global_capture_opts.file_duration);
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), file_duration_cbx, 2, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), file_duration_cbx, 2, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
value = time_unit_combo_box_convert_value(global_capture_opts.file_duration);
- gtk_adjustment_set_value(file_duration_adj, (gfloat) value);
+ gtk_adjustment_set_value(file_duration_adj, (gdouble) value);
row++;
/* Ring buffer files row */
"After capturing has switched to the next file and the given number of files has exceeded, "
"the oldest file will be removed."
);
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), ringbuffer_nbf_cb, 0, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), ringbuffer_nbf_cb, 0, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
ringbuffer_nbf_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) global_capture_opts.ring_num_files,
2/*RINGBUFFER_MIN_NUM_FILES*/, RINGBUFFER_MAX_NUM_FILES, 1.0, 10.0, 0.0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (ringbuffer_nbf_sb), TRUE);
gtk_widget_set_size_request(ringbuffer_nbf_sb, 80, -1);
g_signal_connect(ringbuffer_nbf_sb, "changed", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), ringbuffer_nbf_sb, 1, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), ringbuffer_nbf_sb, 1, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
ringbuffer_nbf_lb = gtk_label_new("files");
gtk_misc_set_alignment(GTK_MISC(ringbuffer_nbf_lb), 0, 0.5f);
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), ringbuffer_nbf_lb, 2, row, 1, 1);
- row++;
-
- /* Files row */
- stop_files_cb = gtk_check_button_new_with_label("Stop capture after");
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stop_files_cb),
- global_capture_opts.has_autostop_files);
- g_signal_connect(stop_files_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
- gtk_widget_set_tooltip_text(stop_files_cb, "Stop capturing after the given number of \"file switches\" have been done.");
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), stop_files_cb, 0, row, 1, 1);
-
- stop_files_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat)global_capture_opts.autostop_files,
- 1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
- stop_files_sb = gtk_spin_button_new (stop_files_adj, 0, 0);
- gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_files_sb), TRUE);
- gtk_widget_set_size_request(stop_files_sb, 80, -1);
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), stop_files_sb, 1, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), ringbuffer_nbf_lb, 2, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
- stop_files_lb = gtk_label_new("file(s)");
- gtk_misc_set_alignment(GTK_MISC(stop_files_lb), 0, 0.5f);
- ws_gtk_grid_attach_defaults(GTK_GRID (multi_grid), stop_files_lb, 2, row, 1, 1);
row++;
/* Capture limits frame */
- limit_fr = frame_new("Stop Capture...");
+ limit_fr = frame_new("Stop Capture Automatically After...");
gtk_box_pack_start(GTK_BOX (left_vb), limit_fr, TRUE, TRUE, 0);
limit_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_UNRELATED_SPACING, FALSE);
row = 0;
/* Packet count row */
- stop_packets_cb = gtk_check_button_new_with_label("after");
+ stop_packets_cb = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stop_packets_cb),
global_capture_opts.has_autostop_packets);
g_signal_connect(stop_packets_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
- gtk_widget_set_tooltip_text(stop_packets_cb, "Stop capturing after the given number of packets have been captured.");
- ws_gtk_grid_attach_defaults(GTK_GRID (limit_grid), stop_packets_cb, 0, row, 1, 1);
+ gtk_widget_set_tooltip_text(stop_packets_cb, "Stop capturing after the specified number of packets have been captured.");
+ ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_packets_cb, 0, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
stop_packets_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat)global_capture_opts.autostop_packets,
1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
stop_packets_sb = gtk_spin_button_new (stop_packets_adj, 0, 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_packets_sb), TRUE);
gtk_widget_set_size_request(stop_packets_sb, 80, -1);
- ws_gtk_grid_attach_defaults(GTK_GRID (limit_grid), stop_packets_sb, 1, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_packets_sb, 1, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
stop_packets_lb = gtk_label_new("packet(s)");
gtk_misc_set_alignment(GTK_MISC(stop_packets_lb), 0, 0.5f);
- ws_gtk_grid_attach_defaults(GTK_GRID (limit_grid), stop_packets_lb, 2, row, 1, 1);
- row++;
+ ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_packets_lb, 2, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
/* Filesize row */
- stop_filesize_cb = gtk_check_button_new_with_label("after");
+ stop_filesize_cb = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stop_filesize_cb),
global_capture_opts.has_autostop_filesize);
g_signal_connect(stop_filesize_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
- gtk_widget_set_tooltip_text(stop_filesize_cb, "Stop capturing after the given amount of capture data has been captured.");
- ws_gtk_grid_attach_defaults(GTK_GRID (limit_grid), stop_filesize_cb, 0, row, 1, 1);
+ gtk_widget_set_tooltip_text(stop_filesize_cb, "Stop capturing after the specified amount of data has been captured.");
+ ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_filesize_cb, 3, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
stop_filesize_adj = (GtkAdjustment *) gtk_adjustment_new(0.0,
1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
stop_filesize_sb = gtk_spin_button_new (stop_filesize_adj, 0, 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_filesize_sb), TRUE);
gtk_widget_set_size_request(stop_filesize_sb, 80, -1);
- ws_gtk_grid_attach_defaults(GTK_GRID (limit_grid), stop_filesize_sb, 1, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_filesize_sb, 4, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
stop_filesize_cbx = size_unit_combo_box_new(global_capture_opts.autostop_filesize);
- ws_gtk_grid_attach_defaults(GTK_GRID (limit_grid), stop_filesize_cbx, 2, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_filesize_cbx, 5, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
value = size_unit_combo_box_set_value(global_capture_opts.autostop_filesize);
- gtk_adjustment_set_value(stop_filesize_adj, (gfloat) value);
+ gtk_adjustment_set_value(stop_filesize_adj, (gdouble) value);
row++;
+ /* Files row */
+ stop_files_cb = gtk_check_button_new();
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stop_files_cb),
+ global_capture_opts.has_autostop_files);
+ g_signal_connect(stop_files_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
+ gtk_widget_set_tooltip_text(stop_files_cb, "Stop capturing after the given number of \"file switches\" have been done.");
+ ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_files_cb, 0, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
+
+ stop_files_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat)global_capture_opts.autostop_files,
+ 1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
+ stop_files_sb = gtk_spin_button_new (stop_files_adj, 0, 0);
+ gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_files_sb), TRUE);
+ gtk_widget_set_size_request(stop_files_sb, 80, -1);
+ ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_files_sb, 1, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
+
+ stop_files_lb = gtk_label_new("file(s)");
+ gtk_misc_set_alignment(GTK_MISC(stop_files_lb), 0, 0.5f);
+ ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_files_lb, 2, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
+
/* Duration row */
- stop_duration_cb = gtk_check_button_new_with_label("after");
+ stop_duration_cb = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stop_duration_cb),
global_capture_opts.has_autostop_duration);
g_signal_connect(stop_duration_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
- gtk_widget_set_tooltip_text(stop_duration_cb, "Stop capturing after the given time is exceeded.");
- ws_gtk_grid_attach_defaults(GTK_GRID (limit_grid), stop_duration_cb, 0, row, 1, 1);
+ gtk_widget_set_tooltip_text(stop_duration_cb, "Stop capturing after the specified amount of time has passed.");
+ ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_duration_cb, 3, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
stop_duration_adj = (GtkAdjustment *) gtk_adjustment_new(0.0,
1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
stop_duration_sb = gtk_spin_button_new (stop_duration_adj, 0, 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_duration_sb), TRUE);
gtk_widget_set_size_request(stop_duration_sb, 80, -1);
- ws_gtk_grid_attach_defaults(GTK_GRID (limit_grid), stop_duration_sb, 1, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_duration_sb, 4, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
stop_duration_cbx = time_unit_combo_box_new(global_capture_opts.autostop_duration);
- ws_gtk_grid_attach_defaults(GTK_GRID (limit_grid), stop_duration_cbx, 2, row, 1, 1);
+ ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_duration_cbx, 5, row, 1, 1,
+ (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
value = time_unit_combo_box_convert_value(global_capture_opts.autostop_duration);
- gtk_adjustment_set_value(stop_duration_adj, (gfloat) value);
+ gtk_adjustment_set_value(stop_duration_adj, (gdouble) value);
row++;
/* Display-related options frame */
display_fr = frame_new("Display Options");
gtk_box_pack_start(GTK_BOX (right_vb), display_fr, TRUE, TRUE, 0);
- display_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_UNRELATED_SPACING, FALSE);
+ display_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_LABEL_SPACING, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(display_vb), DLG_OUTER_MARGIN);
gtk_container_add(GTK_CONTAINER(display_fr), display_vb);
gtk_widget_set_tooltip_text(sync_cb,
"Using this option will show the captured packets immediately on the main screen. "
"Please note: this will slow down capturing, so increased packet drops might appear.");
- gtk_box_pack_start(GTK_BOX (display_vb), sync_cb, TRUE, TRUE, 0);
+ gtk_box_pack_start(GTK_BOX (display_vb), sync_cb, FALSE, TRUE, 0);
/* "Auto-scroll live update" row */
- auto_scroll_cb = gtk_check_button_new_with_mnemonic("_Automatic scrolling in live capture");
+ auto_scroll_cb = gtk_check_button_new_with_mnemonic("_Automatically scroll during live capture");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(auto_scroll_cb), auto_scroll_live);
gtk_widget_set_tooltip_text(auto_scroll_cb,
"This will scroll the \"Packet List\" automatically to the latest captured packet, "
"when the \"Update List of packets in real time\" option is used.");
- gtk_box_pack_start(GTK_BOX (display_vb), auto_scroll_cb, TRUE, TRUE, 0);
+ gtk_box_pack_start(GTK_BOX (display_vb), auto_scroll_cb, FALSE, TRUE, 0);
/* "Hide capture info" row */
hide_info_cb = gtk_check_button_new_with_mnemonic("_Hide capture info dialog");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hide_info_cb), !global_capture_opts.show_info);
gtk_widget_set_tooltip_text(hide_info_cb, "Hide the capture info dialog while capturing.");
- gtk_box_pack_start(GTK_BOX (display_vb), hide_info_cb, TRUE, TRUE, 0);
+ gtk_box_pack_start(GTK_BOX (display_vb), hide_info_cb, FALSE, TRUE, 0);
/* Name Resolution frame */
resolv_fr = frame_new("Name Resolution");
gtk_box_pack_start(GTK_BOX (right_vb), resolv_fr, TRUE, TRUE, 0);
- resolv_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_UNRELATED_SPACING, FALSE);
+ resolv_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_LABEL_SPACING, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(resolv_vb), DLG_OUTER_MARGIN);
gtk_container_add(GTK_CONTAINER(resolv_fr), resolv_vb);
m_resolv_cb = gtk_check_button_new_with_mnemonic(
- "Enable _MAC name resolution");
+ "Resolve _MAC addresses");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_resolv_cb),
gbl_resolv_flags.mac_name);
gtk_widget_set_tooltip_text(m_resolv_cb, "Perform MAC layer name resolution while capturing.");
- gtk_box_pack_start(GTK_BOX (resolv_vb), m_resolv_cb, TRUE, TRUE, 0);
+ gtk_box_pack_start(GTK_BOX (resolv_vb), m_resolv_cb, FALSE, TRUE, 0);
+
+ n_resolv_cb = gtk_check_button_new_with_mnemonic(
+ "Resolve _network-layer names");
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(n_resolv_cb),
+ gbl_resolv_flags.network_name);
+ gtk_widget_set_tooltip_text(n_resolv_cb, "Perform network layer name resolution while capturing.");
+ gtk_box_pack_start(GTK_BOX (resolv_vb), n_resolv_cb, FALSE, TRUE, 0);
t_resolv_cb = gtk_check_button_new_with_mnemonic(
- "Enable _transport name resolution");
+ "Resolve _transport-layer name");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(t_resolv_cb),
gbl_resolv_flags.transport_name);
gtk_widget_set_tooltip_text(t_resolv_cb,
"Perform transport layer name resolution while capturing.");
- gtk_box_pack_start(GTK_BOX (resolv_vb), t_resolv_cb, TRUE, TRUE, 0);
-
- n_resolv_cb = gtk_check_button_new_with_mnemonic(
- "Enable _network name resolution");
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(n_resolv_cb),
- gbl_resolv_flags.network_name);
- gtk_widget_set_tooltip_text(n_resolv_cb, "Perform network layer name resolution while capturing.");
- gtk_box_pack_start(GTK_BOX (resolv_vb), n_resolv_cb, TRUE, TRUE, 0);
+ gtk_box_pack_start(GTK_BOX (resolv_vb), t_resolv_cb, FALSE, TRUE, 0);
e_resolv_cb = gtk_check_button_new_with_mnemonic(
"Use _external network name resolver");
gbl_resolv_flags.use_external_net_name_resolver);
gtk_widget_set_tooltip_text(e_resolv_cb,
"Use the (system's) configured name resolver (e.g., DNS) to resolve network names.");
- gtk_box_pack_start(GTK_BOX (resolv_vb), e_resolv_cb, TRUE, TRUE, 0);
+ gtk_box_pack_start(GTK_BOX (resolv_vb), e_resolv_cb, FALSE, TRUE, 0);
/* Button row: "Start", "Cancel" and "Help" buttons */
bbox = dlg_button_row_new(WIRESHARK_STOCK_CAPTURE_START, GTK_STOCK_CLOSE, GTK_STOCK_HELP, NULL);
gtk_widget_grab_default(ok_bt);
/* Attach pointers to needed widgets to the capture prefs window/object */
-#if defined(HAVE_PCAP_REMOTE)
- g_object_set_data(G_OBJECT(cap_open_w), E_CAP_REMOTE_DIALOG_PTR_KEY, NULL);
-#endif
g_object_set_data(G_OBJECT(cap_open_w), E_CAP_KEY_ALL, all_cb);
g_object_set_data(G_OBJECT(cap_open_w), E_CAP_PROMISC_KEY_ALL, promisc_cb);
g_object_set_data(G_OBJECT(cap_open_w), E_CAP_PCAP_NG_KEY, pcap_ng_cb);
window_get_geometry(top_level, &tl_geom);
gtk_window_set_default_size(GTK_WINDOW(cap_open_w), tl_geom.width * 8 / 10, -1);
-
+
gtk_widget_show_all(cap_open_w);
window_present(cap_open_w);
cap_open_complete = TRUE; /* "Capture:Start" is now OK */
- global_capture_opts.session_started = TRUE;
-}
-
-/* everythings prepared, now it's really time to start the capture */
-static void
-capture_start_confirmed(void)
-{
- interface_options interface_opts;
- guint i;
-
- /* did the user ever select a capture interface before? */
- if (global_capture_opts.num_selected == 0 &&
- ((prefs.capture_device == NULL) || (*prefs.capture_device != '\0'))) {
- simple_dialog(ESD_TYPE_CONFIRMATION,
- ESD_BTN_OK,
- "%sNo capture interface selected!%s\n\n"
- "To select an interface use:\n\n"
- "Capture->Options (until Wireshark is stopped)\n"
- "Edit->Preferences/Capture (permanent, if saved)",
- simple_dialog_primary_start(), simple_dialog_primary_end());
- return;
- }
-
- /* XXX - we might need to init other pref data as well... */
- main_auto_scroll_live_changed(auto_scroll_live);
-
- /* XXX - can this ever happen? */
- if (global_capture_opts.state != CAPTURE_STOPPED)
- return;
-
- /* close the currently loaded capture file */
- cf_close((capture_file *)global_capture_opts.cf);
-
- /* Copy the selected interfaces to the set of interfaces to use for
- this capture. */
- collect_ifaces(&global_capture_opts);
-
- if (capture_start(&global_capture_opts)) {
- /* The capture succeeded, which means the capture filter syntax is
- valid; add this capture filter to the recent capture filter list. */
- for (i = 0; i < global_capture_opts.ifaces->len; i++) {
- interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
- if (interface_opts.cfilter) {
- cfilter_combo_add_recent(interface_opts.cfilter);
- }
- }
- }
+ global_capture_session.session_started = TRUE;
}
/* user pressed the "Start" button (in dialog or toolbar) */
void
capture_start_cb(GtkWidget *w _U_, gpointer d _U_)
{
+ interface_options interface_opts;
+ guint i;
+ gchar * filter_str;
+
#ifdef HAVE_AIRPCAP
airpcap_if_active = airpcap_if_selected;
if (airpcap_if_active)
/* XXX - will closing this remove a temporary file? */
if(!do_file_close(&cfile, FALSE, " before starting a new capture")){
- return;
+ return;
}
if (cap_open_w) {
/*
return; /* Building options window: ignore "capture start" */
}
success = capture_dlg_prep(cap_open_w);
- window_destroy(GTK_WIDGET(cap_open_w));
+ if (success)
+ window_destroy(GTK_WIDGET(cap_open_w));
if (!success)
return; /* error in options dialog */
}
"You didn't specify an interface on which to capture packets.");
return;
}
-
- capture_start_confirmed();
+
+ /* everything's prepared, now it's really time to start the capture */
+
+ /* XXX - we might need to init other pref data as well... */
+ main_auto_scroll_live_changed(auto_scroll_live);
+
+ /* XXX - can this ever happen? */
+ if (global_capture_session.state != CAPTURE_STOPPED)
+ return;
+
+ /* close the currently loaded capture file */
+ cf_close((capture_file *)global_capture_session.cf);
+
+ /* Copy the selected interfaces to the set of interfaces to use for
+ this capture. */
+ collect_ifaces(&global_capture_opts);
+
+ if (capture_start(&global_capture_opts, &global_capture_session, &global_info_data, main_window_update)) {
+ /* The capture succeeded, which means the capture filters specified are
+ valid; add them to the recent capture filter lists for the interfaces.
+
+ If the same capture filter is used for all the selected interfaces,
+ add it to the global recent capture filter list as well. */
+ filter_str = NULL;
+ for (i = 0; i < global_capture_opts.ifaces->len; i++) {
+ interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
+ if (interface_opts.cfilter) {
+ recent_add_cfilter(interface_opts.name, interface_opts.cfilter);
+ if (filter_str == NULL) {
+ /* First selected interface - save its capture filter. */
+ filter_str = g_strdup(interface_opts.cfilter);
+ } else {
+ /* Not the first selected interface; is its capture filter
+ the same as the one the other interfaces we've looked
+ at have? */
+ if (strcmp(interface_opts.cfilter, filter_str) != 0) {
+ /* No, so not all selected interfaces have the same capture
+ filter. */
+ if (filter_str != NULL) {
+ g_free(filter_str);
+ }
+ filter_str = NULL;
+ }
+ }
+ }
+ }
+ if (filter_str != NULL) {
+ if (filter_str[0] != '\0') {
+ recent_add_cfilter(NULL, filter_str);
+ }
+ g_free(filter_str);
+ }
+ }
}
if (g_save_file && g_save_file[0]) {
/* User specified a file to which the capture should be written. */
global_capture_opts.save_file = g_strdup(g_save_file);
+ global_capture_opts.orig_save_file = g_strdup(g_save_file);
/* Save the directory name for future file dialogs. */
cf_name = g_strdup(g_save_file);
dirname = get_dirname(cf_name); /* Overwrites cf_name */
} else {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"%sMultiple files: Requested filesize too large!%s\n\n"
- "The setting \"Next file every x byte(s)\" can't be greater than %u bytes (2GB).",
- simple_dialog_primary_start(), simple_dialog_primary_end(), G_MAXINT);
+ "The setting \"Next file every x byte(s)\" can't be greater than %u bytes (2GiB).",
+ simple_dialog_primary_start(), simple_dialog_primary_end(), (guint32)G_MAXINT + 1);
return FALSE;
}
}
} else {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"%sStop Capture: Requested filesize too large!%s\n\n"
- "The setting \"after x byte(s)\" can't be greater than %u bytes (2GB).",
- simple_dialog_primary_start(), simple_dialog_primary_end(), G_MAXINT);
+ "The setting \"after x byte(s)\" can't be greater than %u bytes (2GiB).",
+ simple_dialog_primary_start(), simple_dialog_primary_end(), (guint32)G_MAXINT + 1);
return FALSE;
}
}
guint i;
link_row *linkr = NULL;
interface_t device;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
gint buffer;
#endif
gint snaplen;
#if defined(HAVE_PCAP_CREATE)
store = gtk_list_store_new (9, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING);
-#elif defined(_WIN32) && !defined (HAVE_PCAP_CREATE)
+#elif defined(CAN_SET_CAPTURE_BUFFER_SIZE)
store = gtk_list_store_new (8, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING);
#else
store = gtk_list_store_new (7, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
} else {
temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", device.display_name, device.addresses);
}
+ set_active_dlt(&device, global_capture_opts.default_options.linktype);
linkname = NULL;
- if(global_capture_opts.session_started == FALSE && capture_dev_user_linktype_find(device.name) != -1) {
- device.active_dlt = capture_dev_user_linktype_find(device.name);
- }
for (list = device.links; list != NULL; list = g_list_next(list)) {
linkr = (link_row*)(list->data);
if (linkr->dlt == device.active_dlt) {
break;
}
}
- pmode = capture_dev_user_pmode_find(device.name);
- if (global_capture_opts.session_started == FALSE && pmode != -1) {
+ if (!linkname)
+ linkname = g_strdup("unknown");
+ if (capture_dev_user_pmode_find(device.name, &pmode)) {
device.pmode = pmode;
}
- if(global_capture_opts.session_started == FALSE) {
- hassnap = capture_dev_user_hassnap_find(device.name);
- snaplen = capture_dev_user_snaplen_find(device.name);
- if(snaplen != -1 && hassnap != -1) {
- /* Default snap lenght set in preferences */
- device.snaplen = snaplen;
- device.has_snaplen = hassnap;
- } else {
- /* No preferences set yet, use default values */
- device.snaplen = WTAP_MAX_PACKET_SIZE;
- device.has_snaplen = FALSE;
- }
- }
- if (device.has_snaplen) {
- snaplen_string = g_strdup_printf("%d", device.snaplen);
+ if (capture_dev_user_snaplen_find(device.name, &hassnap, &snaplen)) {
+ /* Default snap length set in preferences */
+ device.snaplen = snaplen;
+ device.has_snaplen = hassnap;
} else {
- snaplen_string = g_strdup("default");
+ /* No preferences set yet, use default values */
+ device.snaplen = WTAP_MAX_PACKET_SIZE;
+ device.has_snaplen = FALSE;
}
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- if (global_capture_opts.session_started == FALSE && capture_dev_user_buffersize_find(device.name) != -1) {
+ snaplen_string = g_strdup_printf("%d", device.snaplen);
+
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
+ if (capture_dev_user_buffersize_find(device.name) != -1) {
buffer = capture_dev_user_buffersize_find(device.name);
device.buffer = buffer;
- } else if (global_capture_opts.session_started == FALSE) {
+ } else {
device.buffer = DEFAULT_CAPTURE_BUFFER_SIZE;
- }
+ }
#endif
global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
g_array_insert_val(global_capture_opts.all_ifaces, i, device);
gtk_list_store_append (store, &iter);
#if defined(HAVE_PCAP_CREATE)
- gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, linkname?linkname:"This should not happen", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, MONITOR, device.monitor_mode_supported?(device.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, device.cfilter, -1);
-#elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
- gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, linkname?linkname:"This should not happen", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
+ gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, linkname, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, MONITOR, device.monitor_mode_supported?(device.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, device.cfilter, -1);
+#elif defined(CAN_SET_CAPTURE_BUFFER_SIZE)
+ gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, linkname, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
#else
- gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, linkname?linkname:"This should not happen", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
+ gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, linkname, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
#endif
+ g_free(linkname);
}
}
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
gtk_tree_model_get (model, &iter, 0, &tmp, -1);
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tree_view), (gint) x, (gint) y, NULL, &column, NULL, NULL)) {
- idx = col_title_to_index((gchar *)gtk_tree_view_column_get_title(column));
+ idx = col_title_to_index((const gchar *)gtk_tree_view_column_get_title(column));
switch (idx)
{
case SNAPLEN: g_snprintf(buffer, sizeof(buffer), "Limit the maximum number of bytes to be captured from each packet. This size includes the "
"link-layer header and all subsequent headers.");
break;
-#if defined(HAVE_PCAP_CREATE)
+#ifdef CAN_SET_CAPTURE_BUFFER_SIZE
case BUFFER: g_snprintf (buffer, sizeof(buffer), "The memory buffer size used while capturing. "
"If you notice packet drops, you can try increasing this size.");
break;
+#endif
+#if defined(HAVE_PCAP_CREATE)
case MONITOR: g_snprintf (buffer, sizeof(buffer), "Usually a Wi-Fi adapter will, even in promiscuous mode, only capture "
"the traffic on the BSS to which it's associated. "
"If you want to capture all traffic that the Wi-Fi adapter can \"receive\", select this option. "
"it might be necessary to turn this option on.\n\n"
"Note that, in monitor mode, the adapter might disassociate from the network to which it's associated.");
break;
-#elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
- case BUFFER: g_snprintf (buffer, sizeof(buffer), "The memory buffer size used while capturing. "
- "If you notice packet drops, you can try increasing this size.");
- break;
#endif
case FILTER: g_snprintf(buffer, sizeof(buffer), "Selected capture filter to reduce the amount of packets to be captured.");
break;
GtkWidget *fs;
#ifdef HAVE_PCAP_REMOTE
GList *if_list;
- GtkWidget *remote_w;
#endif
+ if (!cap_open_w || !G_IS_OBJECT(cap_open_w))
+ return;
/* Is there a file selection dialog associated with this
Capture Options dialog? */
fs = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_FILE_SEL_DIALOG_PTR_KEY);
}
#endif
- if (fs != NULL) {
+ if (fs != NULL && G_IS_OBJECT(fs)) {
/* Yes. Destroy it. */
window_destroy(fs);
}
if (airpcap_if_active)
airpcap_set_toolbar_stop_capture(airpcap_if_active);
#endif
-
-#ifdef HAVE_PCAP_REMOTE
- remote_w = g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY);
- if (remote_w != NULL)
- window_destroy(remote_w);
-#endif
}
link_row *linkr;
GtkWidget *linktype_combo_box = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_LT_CBX_KEY);
GtkWidget *linktype_lb = (GtkWidget *)g_object_get_data(G_OBJECT(linktype_combo_box), E_CAP_LT_CBX_LABEL_KEY);
+ gchar *auth_str = NULL;
device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_interface);
global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_interface);
if_string = g_strdup(device.name);
monitor_mode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(monitor));
- caps = capture_get_if_capabilities(if_string, monitor_mode, NULL);
+#ifdef HAVE_PCAP_REMOTE
+ if (device.remote_opts.remote_host_opts.auth_type == CAPTURE_AUTH_PWD) {
+ auth_str = g_strdup_printf("%s:%s", device.remote_opts.remote_host_opts.auth_username,
+ device.remote_opts.remote_host_opts.auth_password);
+ }
+#endif
+ caps = capture_get_if_capabilities(if_string, monitor_mode, auth_str, NULL, main_window_update);
+ g_free(auth_str);
if (caps != NULL) {
g_signal_handlers_disconnect_by_func(linktype_combo_box, G_CALLBACK(select_link_type_cb), NULL );
for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
linkr = (link_row *)g_malloc(sizeof(link_row));
data_link_info = (data_link_info_t *)lt_entry->data;
+ /*
+ * For link-layer types libpcap/WinPcap doesn't know about, the
+ * name will be "DLT n", and the description will be null.
+ * We mark those as unsupported, and don't allow them to be
+ * used - capture filters won't work on them, for example.
+ */
if (data_link_info->description != NULL) {
ws_combo_box_append_text_and_pointer(GTK_COMBO_BOX(linktype_combo_box),
data_link_info->description,
linkr->name = g_strdup(data_link_info->description);
} else {
gchar *str;
- /* Not supported - tell them about it but don't let them select it. */
+ /* XXX - should we just omit them? */
str = g_strdup_printf("%s (not supported)", data_link_info->name);
ws_combo_box_append_text_and_pointer_full(GTK_COMBO_BOX(linktype_combo_box),
NULL,
refresh_local_interface_lists(void)
{
/* Reload the local interface list. */
- if (global_capture_opts.session_started == FALSE)
- scan_local_interfaces();
+ scan_local_interfaces(main_window_update);
/* If there's an interfaces dialog up, refresh it. */
if (interfaces_dialog_window_present())
git.samba.org / metze / wireshark / wip.git / blobdiff