/* close the currently loaded capture file */
cf_close(capture_opts->cf);
+ collect_ifaces(capture_opts);
g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Start ...");
#ifdef _WIN32
}
/* ... and start the capture again */
+ if (capture_opts->ifaces->len == 0) {
+ collect_ifaces(capture_opts);
+ }
capture_start(capture_opts);
} else {
/* We're not doing a capture any more, so we don't have a save file. */
}
if_stat_cache_t *
-capture_stat_start(GList *if_list) {
+capture_stat_start(capture_options *capture_opts) {
int stat_fd, fork_child;
gchar *msg;
if_stat_cache_t *sc = NULL;
- GList *if_entry;
- if_info_t *if_info;
if_stat_cache_item_t *sc_item;
+ guint i;
+ interface_t device;
/* Fire up dumpcap. */
/*
sc->cache_list = NULL;
/* Initialize the cache */
- for (if_entry = if_list; if_entry != NULL; if_entry = g_list_next(if_entry)) {
- if_info = if_entry->data;
- if (if_info) {
+ for (i = 0; i < capture_opts->all_ifaces->len; i++) {
+ device = g_array_index(capture_opts->all_ifaces, interface_t, i);
+ if (&(device.if_info)) {
sc_item = g_malloc0(sizeof(if_stat_cache_item_t));
- sc_item->name = g_strdup(if_info->name);
+ sc_item->name = g_strdup(device.if_info.name);
sc->cache_list = g_list_append(sc->cache_list, sc_item);
}
}
* @param if_list A GList of if_info_t items
* @return A pointer to the statistics state data.
*/
-extern if_stat_cache_t * capture_stat_start(GList *if_list);
+extern if_stat_cache_t * capture_stat_start(capture_options *capture_opts);
/**
* Fetch capture statistics, similar to pcap_stats().
#include <glib.h>
#include <epan/packet.h>
+#include <epan/prefs.h>
+#include "simple_dialog.h"
+#include "capture_ui_utils.h"
#include "capture_opts.h"
#include "ringbuffer.h"
{
capture_opts->cf = cf;
capture_opts->ifaces = g_array_new(FALSE, FALSE, sizeof(interface_options));
+ capture_opts->all_ifaces = g_array_new(FALSE, FALSE, sizeof(interface_t));
+ capture_opts->num_selected = 0;
capture_opts->default_options.name = NULL;
capture_opts->default_options.descr = NULL;
capture_opts->default_options.cfilter = NULL;
#endif
g_array_append_val(capture_opts->ifaces, interface_opts);
+ return 0;
+}
+
+int
+capture_opts_select_iface(capture_options *capture_opts, const char *optarg_str_p)
+{
+ long adapter_index;
+ char *p;
+ GList *if_list;
+ if_info_t *if_info;
+ int err;
+ guint i;
+ gchar *err_str, *name = NULL;
+ interface_t device;
+
+ /*
+ * If the argument is a number, treat it as an index into the list
+ * of adapters, as printed by "tshark -D".
+ *
+ * This should be OK on UNIX systems, as interfaces shouldn't have
+ * names that begin with digits. It can be useful on Windows, where
+ * more than one interface can have the same name.
+ */
+ adapter_index = strtol(optarg_str_p, &p, 10);
+ if (p != NULL && *p == '\0') {
+ if (adapter_index < 0) {
+ cmdarg_err("The specified adapter index is a negative number");
+ return 1;
+ }
+ if (adapter_index > INT_MAX) {
+ cmdarg_err("The specified adapter index is too large (greater than %d)",
+ INT_MAX);
+ return 1;
+ }
+ if (adapter_index == 0) {
+ cmdarg_err("There is no interface with that adapter index");
+ return 1;
+ }
+ if_list = capture_interface_list(&err, &err_str);
+ if (if_list == NULL) {
+ switch (err) {
+ case CANT_GET_INTERFACE_LIST:
+ cmdarg_err("%s", err_str);
+ g_free(err_str);
+ break;
+
+ case NO_INTERFACES_FOUND:
+ cmdarg_err("There are no interfaces on which a capture can be done");
+ break;
+ }
+ return 2;
+ }
+ if_info = (if_info_t *)g_list_nth_data(if_list, adapter_index - 1);
+ if (if_info == NULL) {
+ cmdarg_err("There is no interface with that adapter index");
+ return 1;
+ }
+ name = g_strdup(if_info->name);
+ /* We don't set iface_descr here because doing so requires
+ * capture_ui_utils.c which requires epan/prefs.c which is
+ * probably a bit too much dependency for here...
+ */
+ free_interface_list(if_list);
+ } else {
+ name = g_strdup(optarg_str_p);
+ }
+ for(i = 0; i < capture_opts->all_ifaces->len; i++) {
+ device = g_array_index(capture_opts->all_ifaces, interface_t, i);
+ if (strcmp(device.name, name) == 0) {
+ device.selected = TRUE;
+ capture_opts->num_selected++;
+ capture_opts->all_ifaces = g_array_remove_index(capture_opts->all_ifaces, i);
+ g_array_insert_val(capture_opts->all_ifaces, i, device);
+ break;
+ }
+ }
return 0;
}
/* Did the user specify an interface to use? */
- if (capture_opts->ifaces->len == 0) {
+ if (capture_opts->num_selected == 0 && capture_opts->ifaces->len == 0) {
/* No - is a default specified in the preferences file? */
if (capture_device != NULL) {
/* Yes - use it. */
return 0;
}
+void
+collect_ifaces(capture_options *capture_opts)
+{
+ guint i;
+ interface_t device;
+ interface_options interface_opts;
+ for (i = 0; i < capture_opts->all_ifaces->len; i++) {
+ device = g_array_index(capture_opts->all_ifaces, interface_t, i);
+ if (device.selected) {
+ interface_opts.name = g_strdup(device.name);
+ interface_opts.descr = g_strdup(device.display_name);
+ interface_opts.monitor_mode = device.monitor_mode_enabled;
+ interface_opts.linktype = device.active_dlt;
+ interface_opts.cfilter = g_strdup(device.cfilter);
+ interface_opts.snaplen = device.snaplen;
+ interface_opts.has_snaplen = device.has_snaplen;
+ interface_opts.promisc_mode = device.pmode;
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+ interface_opts.buffer_size = device.buffer;
+#endif
+ if (device.type == IF_REMOTE) {
+#ifdef HAVE_PCAP_REMOTE
+ interface_opts.src_type = device.type;
+ interface_opts.remote_host = g_strdup(device.remote_opts.remote_host_opts.remote_host);
+ interface_opts.remote_port = g_strdup(device.remote_opts.remote_host_opts.remote_port);
+ interface_opts.auth_type = device.remote_opts.remote_host_opts.auth_type;
+ interface_opts.auth_username = g_strdup(device.remote_opts.remote_host_opts.auth_username);
+ interface_opts.auth_password = g_strdup(device.remote_opts.remote_host_opts.auth_password);
+ interface_opts.datatx_udp = device.remote_opts.remote_host_opts.datatx_udp;
+ interface_opts.nocap_rpcap = device.remote_opts.remote_host_opts.nocap_rpcap;
+ interface_opts.nocap_local = device.remote_opts.remote_host_opts.nocap_local;
+#endif
+#ifdef HAVE_PCAP_SETSAMPLING
+ interface_opts.sampling_method = device.remote_opts.sampling_method;
+ interface_opts.sampling_param = device.remote_opts.sampling_param;
+#endif
+ }
+ g_array_append_val(capture_opts->ifaces, interface_opts);
+ } else {
+ continue;
+ }
+ }
+}
+
+
#endif /* HAVE_LIBPCAP */
} capture_sampling;
#endif
+typedef enum {
+ IF_LOCAL,
+ IF_REMOTE,
+ IF_AIRPCAP
+} interface_type;
+
+#ifdef HAVE_PCAP_REMOTE
+struct remote_host {
+ gchar *remote_host; /**< Host name or network address for remote capturing */
+ gchar *remote_port; /**< TCP port of remote RPCAP server */
+ gint auth_type; /**< Authentication type */
+ gchar *auth_username; /**< Remote authentication parameters */
+ gchar *auth_password; /**< Remote authentication parameters */
+ gboolean datatx_udp;
+ gboolean nocap_rpcap;
+ gboolean nocap_local;
+};
+
+typedef struct remote_options_tag {
+ capture_source src_type;
+ struct remote_host remote_host_opts;
+#ifdef HAVE_PCAP_SETSAMPLING
+ capture_sampling sampling_method;
+ int sampling_param;
+#endif
+} remote_options;
+#endif /* HAVE_PCAP_REMOTE */
+
+typedef struct interface_tag {
+ gchar *name;
+ gchar *display_name;
+ guint type;
+ gchar *addresses;
+ gint no_addresses;
+ gchar *cfilter;
+ GList *links;
+ gint active_dlt;
+ gboolean pmode;
+ gboolean has_snaplen;
+ guint snaplen;
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+ gint buffer;
+ gboolean monitor_mode_enabled;
+ gboolean monitor_mode_supported;
+#endif
+#ifdef HAVE_PCAP_REMOTE
+ remote_options remote_opts;
+#endif
+ guint32 last_packets;
+ if_info_t if_info;
+ gboolean selected;
+ gboolean hidden;
+ gboolean locked;
+} interface_t;
+
+typedef struct link_row_tag {
+ gchar *name;
+ gint dlt;
+} link_row;
+
typedef struct interface_options_tag {
gchar *name;
gchar *descr;
void *cf; /**< handle to cfile (note: untyped handle) */
GArray *ifaces; /**< array of interfaces.
Currently only used by dumpcap. */
+ GArray *all_ifaces;
+ guint num_selected;
interface_options default_options;
gboolean saving_to_file; /**< TRUE if capture is writing to a file */
gchar *save_file; /**< the capture file name */
extern gboolean
capture_opts_trim_iface(capture_options *capture_opts, const char *capture_device);
+extern void
+collect_ifaces(capture_options *capture_opts);
+
+typedef struct {
+ gboolean monitor_mode;
+ int linktype;
+} cap_settings_t;
+
+/** Get capture settings for interface
+ *
+ * @param if_name interface name
+ */
+cap_settings_t
+capture_get_cap_settings (gchar *if_name);
+
+extern void
+scan_local_interfaces(capture_options* capture_opts);
+
+int
+capture_opts_select_iface(capture_options *capture_opts, const char *optarg_str_p);
+
#endif /* capture_opts.h */
}
#endif
+#ifdef HAVE_PCAP_CREATE
if (interface_opts.monitor_mode) {
argv = sync_pipe_add_arg(argv, &argc, "-I");
}
+#endif
#ifdef HAVE_PCAP_REMOTE
if (interface_opts.datatx_udp)
#include "epan/ex-opt.h"
#include "capture_ifinfo.h"
#include "capture_ui_utils.h"
+#include "simple_dialog.h"
+#include "wiretap/wtap.h"
+#include "epan/to_str.h"
/*
* Find user-specified capture device description that matches interface
static gboolean cap_open_complete; /* valid only if cap_open_w != NULL */
static GHashTable *cap_settings_history=NULL;
-static gint16 num_selected;
-static GArray *rows = NULL;
static gint marked_row;
#ifdef HAVE_PCAP_REMOTE
extern gint if_list_comparator_alph (const void *first_arg, const void *second_arg);
-static void
-make_and_fill_rows(void);
-
/* stop the currently running capture */
void
capture_stop_cb(GtkWidget *w _U_, gpointer d _U_)
void insert_new_rows(GList *list)
{
- interface_row row;
+ interface_t device;
GtkTreeIter iter;
GList *if_entry;
if_info_t *if_info;
cap_settings_t cap_settings;
GSList *curr_addr;
int ips = 0;
- guint i, count=0;
+ guint i;
if_addr_t *addr;
GList *lt_entry;
data_link_info_t *data_link_info;
GString *ip_str;
GtkTreeView *if_cb;
GtkTreeModel *model;
- interface_options interface_opts;
link_row *link = 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);
- count = rows->len;
/* 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)) {
if_info = if_entry->data;
#ifdef HAVE_PCAP_REMOTE
add_interface_to_remote_list(if_info);
#endif
- for (i = 0; i < count; i++) {
- row = g_array_index(rows, interface_row, i);
- if (strcmp(row.name, if_info->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(device.name, if_info->name) == 0) {
found = TRUE;
break;
}
ip_str = g_string_new("");
str = "";
ips = 0;
- row.name = g_strdup(if_info->name);
+ device.name = g_strdup(if_info->name);
/* Is this interface hidden and, if so, should we include it
anyway? */
descr = capture_dev_user_descr_find(if_info->name);
}
} /* else descr != NULL */
if (if_info->loopback) {
- row.display_name = g_strdup_printf("%s (loopback)", if_string);
+ device.display_name = g_strdup_printf("%s (loopback)", if_string);
} else {
- row.display_name = g_strdup(if_string);
+ device.display_name = g_strdup(if_string);
}
- found = FALSE;
- for (i = 0; i < global_capture_opts.ifaces->len; i++) {
- interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
- if (strcmp(interface_opts.name, (char*)row.name)!=0)
- continue;
- else {
- found = TRUE;
- break;
- }
- }
- if (found) {
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- row.buffer = interface_opts.buffer_size;
-#endif
- row.pmode = interface_opts.promisc_mode;
- row.has_snaplen = interface_opts.has_snaplen;
- row.snaplen = interface_opts.snaplen;
- row.cfilter = g_strdup(interface_opts.cfilter);
- } else {
#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- row.buffer = global_capture_opts.default_options.buffer_size;
+ device.buffer = global_capture_opts.default_options.buffer_size;
#endif
- row.pmode = global_capture_opts.default_options.promisc_mode;
- row.has_snaplen = global_capture_opts.default_options.has_snaplen;
- row.snaplen = global_capture_opts.default_options.snaplen;
- row.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
- }
+ device.pmode = global_capture_opts.default_options.promisc_mode;
+ 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);
cap_settings = capture_get_cap_settings(if_string);
caps = capture_get_if_capabilities(if_string, cap_settings.monitor_mode, NULL);
gtk_list_store_append (GTK_LIST_STORE(model), &iter);
}
} /* for curr_addr */
linktype_count = 0;
- row.links = NULL;
+ device.links = NULL;
if (caps != NULL) {
#ifdef HAVE_PCAP_CREATE
- row.monitor_mode_enabled = cap_settings.monitor_mode;
- row.monitor_mode_supported = caps->can_set_rfmon;
+ device.monitor_mode_enabled = cap_settings.monitor_mode;
+ device.monitor_mode_supported = caps->can_set_rfmon;
#endif
for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
data_link_info = lt_entry->data;
}
if (linktype_count == 0) {
link_type_name = g_strdup(str);
- row.active_dlt = data_link_info->dlt;
+ device.active_dlt = data_link_info->dlt;
}
link = (link_row *)g_malloc(sizeof(link_row));
link->dlt = data_link_info->dlt;
link->name = g_strdup(str);
- row.links = g_list_append(row.links, link);
+ device.links = g_list_append(device.links, link);
linktype_count++;
} /* for link_types */
} else {
cap_settings.monitor_mode = FALSE;
#if defined(HAVE_PCAP_CREATE)
- row.monitor_mode_enabled = FALSE;
- row.monitor_mode_supported = FALSE;
+ device.monitor_mode_enabled = FALSE;
+ device.monitor_mode_supported = FALSE;
#endif
- row.active_dlt = -1;
+ device.active_dlt = -1;
link_type_name = g_strdup("default");
}
- row.addresses = g_strdup(ip_str->str);
- row.no_addresses = ips;
+ device.addresses = g_strdup(ip_str->str);
+ device.no_addresses = ips;
if (ips == 0) {
- temp = g_strdup_printf("<b>%s</b>", row.display_name);
+ temp = g_strdup_printf("<b>%s</b>", device.display_name);
} else {
- temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", row.display_name, row.addresses);
+ temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", device.display_name, device.addresses);
}
#ifdef HAVE_PCAP_REMOTE
- row.remote_opts.src_type= global_remote_opts.src_type;
- row.remote_opts.remote_host_opts.remote_host = g_strdup(global_remote_opts.remote_host_opts.remote_host);
- row.remote_opts.remote_host_opts.remote_port = g_strdup(global_remote_opts.remote_host_opts.remote_port);
- row.remote_opts.remote_host_opts.auth_type = global_remote_opts.remote_host_opts.auth_type;
- row.remote_opts.remote_host_opts.auth_username = g_strdup(global_remote_opts.remote_host_opts.auth_username);
- row.remote_opts.remote_host_opts.auth_password = g_strdup(global_remote_opts.remote_host_opts.auth_password);
- row.remote_opts.remote_host_opts.datatx_udp = global_remote_opts.remote_host_opts.datatx_udp;
- row.remote_opts.remote_host_opts.nocap_rpcap = global_remote_opts.remote_host_opts.nocap_rpcap;
- row.remote_opts.remote_host_opts.nocap_local = global_remote_opts.remote_host_opts.nocap_local;
+ device.remote_opts.src_type= global_remote_opts.src_type;
+ device.remote_opts.remote_host_opts.remote_host = g_strdup(global_remote_opts.remote_host_opts.remote_host);
+ device.remote_opts.remote_host_opts.remote_port = g_strdup(global_remote_opts.remote_host_opts.remote_port);
+ device.remote_opts.remote_host_opts.auth_type = global_remote_opts.remote_host_opts.auth_type;
+ device.remote_opts.remote_host_opts.auth_username = g_strdup(global_remote_opts.remote_host_opts.auth_username);
+ device.remote_opts.remote_host_opts.auth_password = g_strdup(global_remote_opts.remote_host_opts.auth_password);
+ device.remote_opts.remote_host_opts.datatx_udp = global_remote_opts.remote_host_opts.datatx_udp;
+ device.remote_opts.remote_host_opts.nocap_rpcap = global_remote_opts.remote_host_opts.nocap_rpcap;
+ device.remote_opts.remote_host_opts.nocap_local = global_remote_opts.remote_host_opts.nocap_local;
#endif
#ifdef HAVE_PCAP_SETSAMPLING
- row.remote_opts.sampling_method = global_remote_opts.sampling_method;
- row.remote_opts.sampling_param = global_remote_opts.sampling_param;
+ device.remote_opts.sampling_method = global_remote_opts.sampling_method;
+ device.remote_opts.sampling_param = global_remote_opts.sampling_param;
#endif
- g_array_append_val(rows, row);
- if (row.has_snaplen) {
- snaplen_string = g_strdup_printf("%d", row.snaplen);
+ 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");
}
#if defined(HAVE_PCAP_CREATE)
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, INTERFACE, temp, LINK, link_type_name, PMODE, (row.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, (guint) global_capture_opts.default_options.buffer_size, MONITOR, "no",FILTER, "",-1);
+ 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, (guint) global_capture_opts.default_options.buffer_size, MONITOR, "no",FILTER, "",-1);
#elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, INTERFACE, temp, LINK, link_type_name, PMODE, (row.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, (guint) global_capture_opts.default_options.buffer_size, FILTER, "",-1);
+ 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, (guint) global_capture_opts.default_options.buffer_size, FILTER, "",-1);
#else
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, INTERFACE, temp, LINK, link_type_name, PMODE, (row.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, -1);
+ 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
- count++;
g_string_free(ip_str, TRUE);
#ifdef HAVE_PCAP_REMOTE
- add_interface_to_list(if_info->name, if_info->description, &row.remote_opts);
+ add_interface_to_list(global_capture_opts.all_ifaces->len-1);
#endif
} /*for*/
gtk_tree_view_set_model(GTK_TREE_VIEW(if_cb), model);
GtkWidget *samp_none_rb, *samp_count_rb, *samp_timer_rb,
*samp_count_sb, *samp_timer_sb;
#endif
- interface_row row;
+ interface_t device;
if (parent_w == NULL)
return;
- row = g_array_index(rows, interface_row, marked_row);
- g_array_remove_index(rows, marked_row);
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
+ g_array_remove_index(global_capture_opts.all_ifaces, marked_row);
datatx_udp_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_DATATX_UDP_CB_KEY);
nocap_rpcap_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_NOCAP_RPCAP_CB_KEY);
- row.remote_opts.remote_host_opts.datatx_udp =
+ device.remote_opts.remote_host_opts.datatx_udp =
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(datatx_udp_cb));
- row.remote_opts.remote_host_opts.nocap_rpcap =
+ device.remote_opts.remote_host_opts.nocap_rpcap =
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(nocap_rpcap_cb));
#ifdef HAVE_PCAP_SETSAMPLING
samp_timer_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_TIMER_SB_KEY);
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_none_rb)))
- row.remote_opts.sampling_method = CAPTURE_SAMP_NONE;
+ device.remote_opts.sampling_method = CAPTURE_SAMP_NONE;
else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_count_rb))) {
- row.remote_opts.sampling_method = CAPTURE_SAMP_BY_COUNT;
- row.remote_opts.sampling_param = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(samp_count_sb));
+ device.remote_opts.sampling_method = CAPTURE_SAMP_BY_COUNT;
+ device.remote_opts.sampling_param = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(samp_count_sb));
} else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_timer_rb))) {
- row.remote_opts.sampling_method = CAPTURE_SAMP_BY_TIMER;
- row.remote_opts.sampling_param = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(samp_timer_sb));
+ device.remote_opts.sampling_method = CAPTURE_SAMP_BY_TIMER;
+ device.remote_opts.sampling_param = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(samp_timer_sb));
}
#endif /* HAVE_PCAP_SETSAMPLING*/
- g_array_insert_val(rows, marked_row, row);
+ g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device);
window_destroy(GTK_WIDGET(parent_w));
}
#endif /*HAVE_PCAP_REMOTE*/
GtkAdjustment *samp_count_adj, *samp_timer_adj;
GSList *samp_group;
#endif
- interface_row row;
+ interface_t device;
caller = gtk_widget_get_toplevel(w);
opt_remote_w = g_object_get_data(G_OBJECT(caller), E_OPT_REMOTE_DIALOG_PTR_KEY);
return;
}
- row = g_array_index(rows, interface_row, marked_row);
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
opt_remote_w = dlg_window_new("Remote Capture Settings");
g_object_set_data(G_OBJECT(opt_remote_w), E_OPT_REMOTE_CALLER_PTR_KEY, caller);
g_object_set_data(G_OBJECT(caller), E_OPT_REMOTE_DIALOG_PTR_KEY, opt_remote_w);
nocap_rpcap_cb = gtk_check_button_new_with_mnemonic("Do not capture own RPCAP traffic");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(nocap_rpcap_cb),
- row.remote_opts.remote_host_opts.nocap_rpcap);
+ device.remote_opts.remote_host_opts.nocap_rpcap);
gtk_container_add(GTK_CONTAINER(capture_vb), nocap_rpcap_cb);
datatx_udp_cb = gtk_check_button_new_with_mnemonic("Use UDP for data transfer");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(datatx_udp_cb),
- row.remote_opts.remote_host_opts.datatx_udp);
+ device.remote_opts.remote_host_opts.datatx_udp);
gtk_container_add(GTK_CONTAINER(capture_vb), datatx_udp_cb);
#ifdef HAVE_PCAP_SETSAMPLING
/* "No sampling" row */
samp_none_rb = gtk_radio_button_new_with_label(NULL, "None");
- if (row.remote_opts.sampling_method == CAPTURE_SAMP_NONE)
+ if (device.remote_opts.sampling_method == CAPTURE_SAMP_NONE)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(samp_none_rb), TRUE);
g_signal_connect(samp_none_rb, "toggled",
G_CALLBACK(options_prep_adjust_sensitivity), opt_remote_w);
/* "Sampling by counter" row */
samp_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(samp_none_rb));
samp_count_rb = gtk_radio_button_new_with_label(samp_group, "1 of");
- if (row.remote_opts.sampling_method == CAPTURE_SAMP_BY_COUNT)
+ if (device.remote_opts.sampling_method == CAPTURE_SAMP_BY_COUNT)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(samp_count_rb), TRUE);
g_signal_connect(samp_count_rb, "toggled",
G_CALLBACK(options_prep_adjust_sensitivity), opt_remote_w);
gtk_table_attach_defaults(GTK_TABLE(sampling_tb), samp_count_rb, 0, 1, 1, 2);
samp_count_adj = (GtkAdjustment *) gtk_adjustment_new(
- (gfloat)row.remote_opts.sampling_param,
+ (gfloat)device.remote_opts.sampling_param,
1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
samp_count_sb = gtk_spin_button_new(samp_count_adj, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(samp_count_sb), TRUE);
/* "Sampling by timer" row */
samp_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(samp_count_rb));
samp_timer_rb = gtk_radio_button_new_with_label(samp_group, "1 every");
- if (row.remote_opts.sampling_method == CAPTURE_SAMP_BY_TIMER)
+ if (device.remote_opts.sampling_method == CAPTURE_SAMP_BY_TIMER)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(samp_timer_rb), TRUE);
g_signal_connect(samp_timer_rb, "toggled",
G_CALLBACK(options_prep_adjust_sensitivity), opt_remote_w);
gtk_table_attach_defaults(GTK_TABLE(sampling_tb), samp_timer_rb, 0, 1, 2, 3);
samp_timer_adj = (GtkAdjustment *) gtk_adjustment_new(
- (gfloat)row.remote_opts.sampling_param,
+ (gfloat)device.remote_opts.sampling_param,
1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
samp_timer_sb = gtk_spin_button_new(samp_timer_adj, 0, 0);
gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(samp_timer_sb), TRUE);
static void
update_options_table(gint index)
{
- guint i;
- gboolean found = FALSE;
- interface_row row;
- interface_options interface_opts;
+ interface_t device;
GtkTreePath *path;
GtkTreeView *if_cb;
GtkTreeModel *model;
link_row *link = NULL;
gboolean enabled;
- row = g_array_index(rows, interface_row, index);
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, index);
- if (global_capture_opts.ifaces->len > 0) {
- for (i = 0; i < global_capture_opts.ifaces->len; i++) {
- interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
- if (strcmp(interface_opts.name, row.name) == 0) {
- found = TRUE;
+ if (!device.hidden) {
+ if (device.no_addresses == 0) {
+ temp = g_strdup_printf("<b>%s</b>", device.display_name);
+ } else {
+ temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", device.display_name, device.addresses);
+ }
+ for (list=device.links; list!=NULL; list=g_list_next(list))
+ {
+ link = (link_row*)(list->data);
+ if (link->dlt == device.active_dlt) {
break;
}
}
- if (found) {
- global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
- g_free(interface_opts.cfilter);
- interface_opts.linktype = row.active_dlt;
- interface_opts.promisc_mode = row.pmode;
- interface_opts.has_snaplen = row.has_snaplen;
- interface_opts.snaplen = row.snaplen;
- interface_opts.cfilter = g_strdup(row.cfilter);
-#ifdef HAVE_PCAP_CREATE
- interface_opts.monitor_mode = row.monitor_mode_enabled;
-#else
- interface_opts.monitor_mode = FALSE;
-#endif
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- interface_opts.buffer_size = row.buffer;
-#endif
- g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
+ if (device.has_snaplen) {
+ snaplen_string = g_strdup_printf("%d", device.snaplen);
+ } else {
+ snaplen_string = g_strdup("default");
}
- }
- if (!found || global_capture_opts.ifaces->len == 0) {
- interface_opts.name = g_strdup(row.name);
- interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
- interface_opts.linktype = row.active_dlt;
- interface_opts.promisc_mode = row.pmode;
- interface_opts.has_snaplen = row.has_snaplen;
- interface_opts.snaplen = row.snaplen;
- interface_opts.cfilter = g_strdup(row.cfilter);
-#ifdef HAVE_PCAP_CREATE
- interface_opts.monitor_mode = row.monitor_mode_enabled;
-#else
- interface_opts.monitor_mode = FALSE;
-#endif
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- interface_opts.buffer_size = row.buffer;
-#endif
-#ifdef HAVE_PCAP_REMOTE
- interface_opts.src_type = global_capture_opts.default_options.src_type;
- interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
- interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
- interface_opts.auth_type = global_capture_opts.default_options.auth_type;
- interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
- interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
- interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
- interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
- interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
-#endif
-#ifdef HAVE_PCAP_SETSAMPLING
- interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
- interface_opts.sampling_param = global_capture_opts.default_options.sampling_param;
-#endif
- g_array_append_val(global_capture_opts.ifaces, interface_opts);
- }
- if (row.no_addresses == 0) {
- temp = g_strdup_printf("<b>%s</b>", row.display_name);
- } else {
- temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", row.display_name, row.addresses);
- }
- for (list=row.links; list!=NULL; list=g_list_next(list))
- {
- link = (link_row*)(list->data);
- if (link->dlt == row.active_dlt) {
- break;
+ 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", marked_row);
+ path = gtk_tree_path_new_from_string(path_str);
+ model = gtk_tree_view_get_model(if_cb);
+ gtk_tree_model_get_iter (model, &iter, path);
+ gtk_tree_model_get(model, &iter, CAPTURE, &enabled, -1);
+ if (enabled == FALSE) {
+ device.selected = TRUE;
+ global_capture_opts.num_selected++;
+ global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, index);
+ g_array_insert_val(global_capture_opts.all_ifaces, index, 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, link->name, 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, link->name, 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, link->name, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
+ #endif
+ #ifdef USE_THREADS
+ if (global_capture_opts.num_selected > 0) {
+ #else
+ if (global_capture_opts.num_selected == 1) {
+ #endif
+ gtk_widget_set_sensitive(ok_bt, TRUE);
+ } else {
+ gtk_widget_set_sensitive(ok_bt, FALSE);
+ }
+ gtk_tree_path_free (path);
}
- }
- if (row.has_snaplen) {
- snaplen_string = g_strdup_printf("%d", row.snaplen);
- } else {
- snaplen_string = g_strdup("default");
- }
- 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", marked_row);
- path = gtk_tree_path_new_from_string(path_str);
- model = gtk_tree_view_get_model(if_cb);
- gtk_tree_model_get_iter (model, &iter, path);
- gtk_tree_model_get(model, &iter, CAPTURE, &enabled, -1);
- if (enabled == FALSE) {
- num_selected++;
+ if (interfaces_dialog_window_present()) {
+ update_selected_interface(g_strdup(device.name));
}
-
-#if defined(HAVE_PCAP_CREATE)
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, TRUE, INTERFACE, temp, LINK, link->name, PMODE, row.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) row.buffer, MONITOR, row.monitor_mode_supported?(row.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, row.cfilter, -1);
-#elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, TRUE, INTERFACE, temp,LINK, link->name, PMODE, row.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) row.buffer, FILTER, row.cfilter, -1);
-#else
- gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, TRUE, INTERFACE, temp,LINK, link->name, PMODE, row.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, row.cfilter, -1);
-#endif
-#ifdef USE_THREADS
- if (num_selected > 0) {
-#else
- if (num_selected == 1) {
-#endif
- gtk_widget_set_sensitive(ok_bt, TRUE);
- } else {
- gtk_widget_set_sensitive(ok_bt, FALSE);
+ if (get_welcome_window() != NULL) {
+ change_interface_selection(g_strdup(device.name), device.selected);
}
- gtk_tree_path_free (path);
- }
- if (interfaces_dialog_window_present()) {
- update_selected_interface(g_strdup(row.name), TRUE);
- }
- if (get_welcome_window() != NULL) {
- change_interface_selection(g_strdup(row.name), TRUE);
}
}
+
+void
+update_all_rows(void)
+{
+ GtkTreeView *view;
+
+ view = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
+ create_and_fill_model(GTK_TREE_VIEW(view));
+}
+
+
static void
save_options_cb(GtkWidget *win _U_, gpointer user_data _U_)
{
GtkWidget *buffer_size_sb;
#endif
- interface_row row;
+ interface_t device;
gpointer ptr;
int dlt;
const gchar *filter_text;
- row = g_array_index(rows, interface_row, marked_row);
- rows = g_array_remove_index(rows, marked_row);
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
+ global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_row);
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)
if ((dlt = GPOINTER_TO_INT(ptr)) == -1) {
g_assert_not_reached(); /* Programming error: somehow managed to select an "unsupported" entry */
}
- row.active_dlt = dlt;
+ device.active_dlt = dlt;
#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- row.buffer = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(buffer_size_sb));
-#endif
- row.pmode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(promisc_cb));
- row.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
- if (row.has_snaplen) {
- row.snaplen = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(snap_sb));
- if (row.snaplen < 1)
- row.snaplen = WTAP_MAX_PACKET_SIZE;
- else if (row.snaplen < MIN_PACKET_SIZE)
- row.snaplen = MIN_PACKET_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) {
+ 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)
+ device.snaplen = MIN_PACKET_SIZE;
} else {
- row.snaplen = WTAP_MAX_PACKET_SIZE;
+ device.snaplen = WTAP_MAX_PACKET_SIZE;
}
filter_text = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(filter_cm));
- if (row.cfilter)
- g_free(row.cfilter);
+ if (device.cfilter)
+ g_free(device.cfilter);
g_assert(filter_text != NULL);
- row.cfilter = g_strdup(filter_text);
+ device.cfilter = g_strdup(filter_text);
#ifdef HAVE_PCAP_CREATE
- row.monitor_mode_enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(monitor_cb));
+ device.monitor_mode_enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(monitor_cb));
#endif
- g_array_insert_val(rows, marked_row, row);
+ g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device);
window_destroy(opt_edit_w);
update_options_table(marked_row);
}
adjust_snap_sensitivity(GtkWidget *tb _U_, gpointer parent_w _U_)
{
GtkWidget *snap_cb, *snap_sb;
- interface_row row;
+ interface_t device;
- row = g_array_index(rows, interface_row, marked_row);
- rows = g_array_remove_index(rows, marked_row);
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
+ global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_row);
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);
to" checkbox is on. */
gtk_widget_set_sensitive(GTK_WIDGET(snap_sb),
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb)));
- row.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
- g_array_insert_val(rows, marked_row, row);
+ device.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
+ g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device);
}
void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column _U_, gpointer userdata)
#ifdef HAVE_AIRPCAP
GtkWidget *advanced_bt;
#endif
- interface_row row;
- displayed_interface d_interface;
+ interface_t device;
GtkTreeModel *model;
GtkTreeIter iter;
link_row *temp;
gboolean found = FALSE;
gint num_supported_link_types;
- guint i;
gchar *tok;
GtkCellRenderer *renderer;
GtkListStore *store;
return;
}
- row.name = NULL;
- row.display_name = NULL;
- row.no_addresses = 0;
- row.addresses = NULL;
- row.links = NULL;
- row.active_dlt = -1;
- row.pmode = FALSE;
+ device.name = NULL;
+ device.display_name = NULL;
+ device.no_addresses = 0;
+ device.addresses = NULL;
+ device.links = NULL;
+ device.active_dlt = -1;
+ device.pmode = FALSE;
#ifdef HAVE_PCAP_CREATE
- row.monitor_mode_enabled = FALSE;
- row.monitor_mode_supported = FALSE;
+ device.monitor_mode_enabled = FALSE;
+ device.monitor_mode_supported = FALSE;
#endif
- row.has_snaplen = FALSE;
- row.snaplen = 65535;
- row.cfilter = NULL;
+ device.has_snaplen = FALSE;
+ device.snaplen = 65535;
+ device.cfilter = NULL;
#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- row.buffer = 1;
+ device.buffer = 1;
#endif
model = gtk_tree_view_get_model(view);
gtk_tree_model_get_iter (model, &iter, path);
marked_row = atoi(gtk_tree_path_to_string(path));
-
- if (cap_open_w) {
- row = g_array_index(rows, interface_row, marked_row);
- } else if (get_welcome_window() != NULL) {
- d_interface = get_interface_data(marked_row);
- if (!rows || rows->len == 0) {
- make_and_fill_rows();
- }
- for (i = 0; i < rows->len; i++) {
- row = g_array_index(rows, interface_row, i);
- if (strcmp(row.name, (char*)d_interface.name)==0) {
- marked_row = i;
- break;
- }
- }
- }
+
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
+
opt_edit_w = dlg_window_new("Edit Interface Settings");
g_object_set_data(G_OBJECT(opt_edit_w), E_OPT_EDIT_CALLER_PTR_KEY, caller);
g_object_set_data(G_OBJECT(caller), E_OPT_EDIT_DIALOG_PTR_KEY, opt_edit_w);
if_lb = gtk_label_new("Interface: ");
gtk_box_pack_start(GTK_BOX(if_hb), if_lb, FALSE, FALSE, 3);
- if_lb_name = gtk_label_new(row.display_name);
+ if_lb_name = gtk_label_new(device.display_name);
gtk_box_pack_start(GTK_BOX(if_hb), if_lb_name, FALSE, FALSE, 3);
/* IP addresses row */
if_ip_lb = gtk_label_new("IP address:");
gtk_misc_set_alignment(GTK_MISC(if_ip_lb), 0, 0); /* Left justified */
gtk_box_pack_start(GTK_BOX(if_vb_left), if_ip_lb, FALSE, FALSE, 0);
-
- if (row.no_addresses > 0) {
- gchar *temp_addresses = g_strdup(row.addresses);
+ if (device.no_addresses > 0) {
+ gchar *temp_addresses = g_strdup(device.addresses);
gtk_box_pack_start(GTK_BOX(capture_vb), if_ip_hb, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(if_ip_hb), if_vb_right, TRUE, TRUE, 3);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX(linktype_hb), linktype_combo_box, FALSE, FALSE, 0);
g_object_set_data(G_OBJECT(opt_edit_w), E_CAP_LT_CBX_KEY, linktype_combo_box);
num_supported_link_types = 0;
- for (list=row.links; list!=NULL; list=g_list_next(list))
+ for (list=device.links; list!=NULL; list=g_list_next(list))
{
temp = (link_row*)(list->data);
ws_combo_box_append_text_and_pointer(GTK_COMBO_BOX(linktype_combo_box),
GINT_TO_POINTER(temp->dlt) /* Flag as "not supported" */
);
num_supported_link_types++;
- if (temp->dlt == row.active_dlt) {
+ if (temp->dlt == device.active_dlt) {
ws_combo_box_set_active(GTK_COMBO_BOX(linktype_combo_box), num_supported_link_types - 1);
found = TRUE;
}
promisc_cb = gtk_check_button_new_with_mnemonic(
"Capture packets in _promiscuous mode");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_cb),
- row.pmode);
+ device.pmode);
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 the network adapter can \"see\", mark this option. "
#ifdef HAVE_PCAP_CREATE
/* Monitor mode row */
monitor_cb = gtk_check_button_new_with_mnemonic( "Capture packets in monitor mode");
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(monitor_cb), row.monitor_mode_enabled);
- gtk_widget_set_sensitive(monitor_cb, row.monitor_mode_supported);
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(monitor_cb), device.monitor_mode_enabled);
+ gtk_widget_set_sensitive(monitor_cb, device.monitor_mode_supported);
g_signal_connect(monitor_cb, "toggled", G_CALLBACK(capture_prep_monitor_changed_cb), NULL);
gtk_widget_set_tooltip_text(monitor_cb,
snap_cb = gtk_check_button_new_with_mnemonic("_Limit each packet to");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(snap_cb),
- row.has_snaplen);
+ device.has_snaplen);
g_signal_connect(snap_cb, "toggled", G_CALLBACK(adjust_snap_sensitivity), NULL);
gtk_widget_set_tooltip_text(snap_cb,
"Limit the maximum number of bytes to be captured from each packet. This size includes the "
"link-layer header and all subsequent headers. ");
gtk_box_pack_start(GTK_BOX(snap_hb), snap_cb, FALSE, FALSE, 0);
- snap_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) row.snaplen,
+ snap_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) device.snaplen,
MIN_PACKET_SIZE, WTAP_MAX_PACKET_SIZE, 1.0, 10.0, 0.0);
snap_sb = gtk_spin_button_new (snap_adj, 0, 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (snap_sb), TRUE);
snap_lb = gtk_label_new("bytes");
gtk_misc_set_alignment(GTK_MISC(snap_lb), 0, 0.5f);
gtk_box_pack_start(GTK_BOX(snap_hb), snap_lb, FALSE, FALSE, 0);
- gtk_widget_set_sensitive(GTK_WIDGET(snap_sb), row.has_snaplen);
+ gtk_widget_set_sensitive(GTK_WIDGET(snap_sb), device.has_snaplen);
/* Filter row */
filter_hb = gtk_hbox_new(FALSE, 3);
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 (row.cfilter && (strlen(row.cfilter) > 0)) {
- gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), row.cfilter);
+ if (device.cfilter && (strlen(device.cfilter) > 0)) {
+ gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), device.cfilter);
gtk_combo_box_set_active(GTK_COMBO_BOX(filter_cm), 0);
}
buffer_size_lb = gtk_label_new("Buffer size:");
gtk_box_pack_start (GTK_BOX(buffer_size_hb), buffer_size_lb, FALSE, FALSE, 0);
- buffer_size_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) row.buffer,
+ buffer_size_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) device.buffer,
1, 65535, 1.0, 10.0, 0.0);
buffer_size_sb = gtk_spin_button_new (buffer_size_adj, 0, 0);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON (buffer_size_sb), (gfloat) row.buffer);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON (buffer_size_sb), (gfloat) device.buffer);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (buffer_size_sb), TRUE);
gtk_widget_set_size_request(buffer_size_sb, 80, -1);
gtk_widget_set_tooltip_text(buffer_size_sb,
/* Both the callback and the data are global */
g_signal_connect(remote_bt, "clicked", G_CALLBACK(options_remote_cb), NULL);
g_object_set_data(G_OBJECT(opt_edit_w), E_OPT_REMOTE_BT_KEY, remote_bt);
- if (strncmp (row.name, "rpcap://", 8) == 0) {
+ if (strncmp (device.name, "rpcap://", 8) == 0) {
gtk_widget_set_sensitive(remote_bt, TRUE);
} else {
gtk_widget_set_sensitive(remote_bt, FALSE);
/* Both the callback and the data are global */
g_signal_connect(advanced_bt,"clicked", G_CALLBACK(options_airpcap_advanced_cb), airpcap_tb);
g_object_set_data(G_OBJECT(top_level),AIRPCAP_OPTIONS_ADVANCED_KEY, advanced_bt);
- airpcap_if_selected = get_airpcap_if_from_name(airpcap_if_list, row.name);
+ airpcap_if_selected = get_airpcap_if_from_name(airpcap_if_list, device.name);
if (airpcap_if_selected != NULL) {
/* It is an airpcap interface */
gtk_widget_set_sensitive(advanced_bt, TRUE);
GtkTreeView *if_cb;
GtkTreeModel *model;
GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
- gboolean enabled, found = FALSE;
+ gboolean enabled;
GtkWidget *pcap_ng_cb;
- interface_options interface_opts;
- interface_row row;
- int index = atoi(path_str);
+ interface_t device;
+ gchar *name;
+ gint index = -1;
guint i;
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);
- gtk_tree_model_get (model, &iter, CAPTURE, &enabled, -1);
- row = g_array_index(rows, interface_row, index);
- if (enabled == FALSE)
- num_selected++;
- else
- num_selected--;
- enabled ^= 1;
- pcap_ng_cb = (GtkWidget *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_PCAP_NG_KEY);
- if (num_selected >= 2) {
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pcap_ng_cb), TRUE);
- gtk_widget_set_sensitive(pcap_ng_cb, FALSE);
- } else {
- gtk_widget_set_sensitive(pcap_ng_cb, TRUE);
- }
-#ifdef USE_THREADS
- if (num_selected > 0) {
-#else
- if (num_selected == 1) {
-#endif
- gtk_widget_set_sensitive(ok_bt, TRUE);
- } else {
- gtk_widget_set_sensitive(ok_bt, FALSE);
+ gtk_tree_model_get (model, &iter, CAPTURE, &enabled, IFACE_HIDDEN_NAME, &name, -1);
+ /* Look for the right interface. The number of interfaces shown might be less
+ * than the real number. Therefore the path index does not correspond
+ * necessarily to the position in the list */
+ 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, name) == 0) {
+ index = i;
+ break;
+ }
}
- /* do something with the new enabled value, and set the new
- enabled value in your treemodel */
- gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, enabled, -1);
-
- if (global_capture_opts.ifaces->len > 0) {
- for (i = 0; i < global_capture_opts.ifaces->len; i++) {
- interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
- if (strcmp(interface_opts.name, row.name) == 0) {
- found = TRUE;
- break;
- }
+ if (!device.locked) {
+ if (enabled == FALSE) {
+ device.selected = TRUE;
+ global_capture_opts.num_selected++;
+ } else {
+ device.selected = FALSE;
+ global_capture_opts.num_selected--;
}
- if (found) {
- global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
- g_free(interface_opts.cfilter);
- if (enabled) {
- interface_opts.linktype = row.active_dlt;
- interface_opts.promisc_mode = row.pmode;
- interface_opts.has_snaplen = row.has_snaplen;
- interface_opts.snaplen = row.snaplen;
- interface_opts.cfilter = g_strdup(row.cfilter);
-#ifdef HAVE_PCAP_CREATE
- interface_opts.monitor_mode = row.monitor_mode_enabled;
-#else
- interface_opts.monitor_mode = FALSE;
-#endif
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- interface_opts.buffer_size = row.buffer;
-#endif
-#ifdef HAVE_PCAP_REMOTE
- interface_opts.src_type = row.remote_opts.src_type;
- if (interface_opts.src_type == CAPTURE_IFREMOTE) {
- interface_opts.remote_host = g_strdup(row.remote_opts.remote_host_opts.remote_host);
- interface_opts.remote_port = g_strdup(row.remote_opts.remote_host_opts.remote_port);
- interface_opts.auth_type = row.remote_opts.remote_host_opts.auth_type;
- interface_opts.auth_username = g_strdup(row.remote_opts.remote_host_opts.auth_username);
- interface_opts.auth_password = g_strdup(row.remote_opts.remote_host_opts.auth_password);
- interface_opts.datatx_udp = row.remote_opts.remote_host_opts.datatx_udp;
- interface_opts.nocap_rpcap = row.remote_opts.remote_host_opts.nocap_rpcap;
- interface_opts.nocap_local = row.remote_opts.remote_host_opts.nocap_local;
-#ifdef HAVE_PCAP_SETSAMPLING
- interface_opts.sampling_method = row.remote_opts.sampling_method;
- interface_opts.sampling_param = row.remote_opts.sampling_param;
-#endif
- } else {
- interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
- interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
- interface_opts.auth_type = global_capture_opts.default_options.auth_type;
- interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
- interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
- interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
- interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
- interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
-#ifdef HAVE_PCAP_SETSAMPLING
- interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
- interface_opts.sampling_param = global_capture_opts.default_options.sampling_param;
-#endif
- }
-#endif
- g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
- } else { /* not enabled */
- if (interfaces_dialog_window_present()) {
- update_selected_interface(g_strdup(interface_opts.name), FALSE);
- }
- if (get_welcome_window() != NULL) {
- change_interface_selection(g_strdup(interface_opts.name), FALSE);
- }
- }
+ device.locked = TRUE;
+ }
+ if (index != -1) {
+ global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, index);
+ g_array_insert_val(global_capture_opts.all_ifaces, index, device);
+ pcap_ng_cb = (GtkWidget *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_PCAP_NG_KEY);
+ if (global_capture_opts.num_selected >= 2) {
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pcap_ng_cb), TRUE);
+ gtk_widget_set_sensitive(pcap_ng_cb, FALSE);
+ } else {
+ gtk_widget_set_sensitive(pcap_ng_cb, TRUE);
}
- }
- if (!found && enabled) {
- interface_opts.name = g_strdup(row.name);
- interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
- interface_opts.linktype = row.active_dlt;
- interface_opts.promisc_mode = row.pmode;
- interface_opts.has_snaplen = row.has_snaplen;
- interface_opts.snaplen = row.snaplen;
- interface_opts.cfilter = g_strdup(row.cfilter);
-#ifdef HAVE_PCAP_CREATE
- interface_opts.monitor_mode = row.monitor_mode_enabled;
+#ifdef USE_THREADS
+ if (global_capture_opts.num_selected > 0) {
#else
- interface_opts.monitor_mode = FALSE;
-#endif
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- interface_opts.buffer_size = row.buffer;
-#endif
-#ifdef HAVE_PCAP_REMOTE
- interface_opts.src_type = row.remote_opts.src_type;
- if (interface_opts.src_type == CAPTURE_IFREMOTE) {
- interface_opts.remote_host = g_strdup(row.remote_opts.remote_host_opts.remote_host);
- interface_opts.remote_port = g_strdup(row.remote_opts.remote_host_opts.remote_port);
- interface_opts.auth_type = row.remote_opts.remote_host_opts.auth_type;
- interface_opts.auth_username = g_strdup(row.remote_opts.remote_host_opts.auth_username);
- interface_opts.auth_password = g_strdup(row.remote_opts.remote_host_opts.auth_password);
- interface_opts.datatx_udp = row.remote_opts.remote_host_opts.datatx_udp;
- interface_opts.nocap_rpcap = row.remote_opts.remote_host_opts.nocap_rpcap;
- interface_opts.nocap_local = row.remote_opts.remote_host_opts.nocap_local;
-#ifdef HAVE_PCAP_SETSAMPLING
- interface_opts.sampling_method = row.remote_opts.sampling_method;
- interface_opts.sampling_param = row.remote_opts.sampling_param;
+ if (global_capture_opts.num_selected == 1) {
#endif
+ gtk_widget_set_sensitive(ok_bt, TRUE);
} else {
- interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
- interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
- interface_opts.auth_type = global_capture_opts.default_options.auth_type;
- interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
- interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
- interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
- interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
- interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
-#ifdef HAVE_PCAP_SETSAMPLING
- interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
- interface_opts.sampling_param = global_capture_opts.default_options.sampling_param;
-#endif
+ gtk_widget_set_sensitive(ok_bt, FALSE);
}
-#endif
- g_array_append_val(global_capture_opts.ifaces, interface_opts);
+ /* do something with the new enabled value, and set the new
+ enabled value in your treemodel */
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, -1);
if (interfaces_dialog_window_present()) {
- update_selected_interface(g_strdup(interface_opts.name), TRUE);
+ update_selected_interface(g_strdup(device.name));
}
if (get_welcome_window() != NULL) {
- change_interface_selection(g_strdup(interface_opts.name), TRUE);
+ change_interface_selection(g_strdup(device.name), device.selected);
}
}
+ device.locked = FALSE;
+ global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, index);
+ g_array_insert_val(global_capture_opts.all_ifaces, index, device);
gtk_tree_path_free (path);
}
-void enable_selected_interface(gchar *name, gboolean enable)
+void enable_selected_interface(gchar *name, gboolean selected)
{
- guint i;
- interface_row row;
GtkTreeIter iter;
GtkTreeView *if_cb;
GtkTreeModel *model;
- gchar *path_str;
- gboolean enabled;
+ gchar *name_str;
- for (i = 0; i < rows->len; i++) {
- row = g_array_index(rows, interface_row, i);
- if (strcmp(name, row.name) == 0) {
- if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
- model = gtk_tree_view_get_model(if_cb);
- path_str = g_strdup_printf("%d", i);
- gtk_tree_model_get_iter_from_string(model, &iter, path_str);
- gtk_tree_model_get (model, &iter, CAPTURE, &enabled, -1);
- if ((enabled == TRUE) && (enable == FALSE)) {
- num_selected--;
- }
- if ((enabled == FALSE) && (enable == TRUE)) {
- num_selected++;
- }
- gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, enable, -1);
- break;
+ 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_first(model, &iter);
+ do {
+ gtk_tree_model_get(model, &iter, IFACE_HIDDEN_NAME, &name_str, -1);
+ if (strcmp(name, name_str) == 0) {
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, selected, -1);
+ break;
}
}
+ while (gtk_tree_model_iter_next(model, &iter));
#ifdef USE_THREADS
- if (num_selected > 0) {
+ if (global_capture_opts.num_selected > 0) {
#else
- if (num_selected == 1) {
+ if (global_capture_opts.num_selected == 1) {
#endif
gtk_widget_set_sensitive(ok_bt, TRUE);
} else {
do {
gtk_tree_model_get (model, &iter, CAPTURE, &capture_set, -1);
if (!capture_set && enabled) {
- num_selected++;
+ global_capture_opts.num_selected++;
} else if (capture_set && !enabled) {
- num_selected--;
+ global_capture_opts.num_selected--;
}
gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, enabled, -1);
} while (gtk_tree_model_iter_next(model, &iter));
}
- if (num_selected >= 2) {
+ if (global_capture_opts.num_selected >= 2) {
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pcap_ng_cb), TRUE);
gtk_widget_set_sensitive(pcap_ng_cb, FALSE);
- } else if (num_selected <= 1) {
+ } else if (global_capture_opts.num_selected <= 1) {
gtk_widget_set_sensitive(pcap_ng_cb, TRUE);
}
if (interfaces_dialog_window_present()) {
change_selection_for_all(enabled);
}
#ifdef USE_THREADS
- if (num_selected > 0) {
+ if (global_capture_opts.num_selected > 0) {
#else
- if (num_selected == 1) {
+ if (global_capture_opts.num_selected == 1) {
#endif
gtk_widget_set_sensitive(ok_bt, TRUE);
} else {
GtkTreeView *if_cb;
GtkTreeModel *model;
gboolean enabled = FALSE;
- interface_row row;
+ interface_t device;
interface_options interface_opts;
guint i;
} while (gtk_tree_model_iter_next(model, &iter));
}
- for (i = 0; i < rows->len; i++) {
- row = g_array_index(rows, interface_row, i);
- rows = g_array_remove_index(rows, i);
- row.pmode = (enabled?TRUE:FALSE);
- g_array_insert_val(rows, i, row);
+ for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
+ global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
+ device.pmode = (enabled?TRUE:FALSE);
+ g_array_insert_val(global_capture_opts.all_ifaces, i, device);
}
for (i = 0; i < global_capture_opts.ifaces->len; i++) {
*help_bt;
#ifdef HAVE_AIRPCAP
GtkWidget *decryption_cb;
+ int err;
+ gchar *err_str;
#endif
#ifdef HAVE_PCAP_REMOTE
GtkWidget *iftype_cbx;
GtkAdjustment *ringbuffer_nbf_adj,
*stop_packets_adj, *stop_filesize_adj, *stop_duration_adj, *stop_files_adj,
*ring_filesize_adj, *file_duration_adj;
- GList *if_list;
int row;
- int err;
- gchar *err_str;
guint32 value;
gchar *cap_title;
GtkWidget *view;
return;
}
#endif
- num_selected = 0;
/* use user-defined title if preference is set */
cap_title = create_user_window_title("Wireshark: Capture Options");
cap_open_w = dlg_window_new(cap_title);
g_free(cap_title);
- if_list = capture_interface_list(&err, &err_str);
-
- if (if_list == NULL && err == CANT_GET_INTERFACE_LIST) {
- simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
- g_free(err_str);
- }
- if_list = g_list_sort (if_list, if_list_comparator_alph);
#ifdef HAVE_AIRPCAP
/* update airpcap interface list */
g_object_set (GTK_TREE_VIEW(view), "has-tooltip", TRUE, NULL);
g_signal_connect (GTK_TREE_VIEW(view), "query-tooltip", G_CALLBACK (query_tooltip_tree_view_cb), NULL);
+ renderer = gtk_cell_renderer_text_new();
+ column = gtk_tree_view_column_new_with_attributes ("",
+ GTK_CELL_RENDERER(renderer),
+ "text", IFACE_HIDDEN_NAME,
+ NULL);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
+ gtk_tree_view_column_set_visible(column, FALSE);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (view), -1, "Interface", renderer, "markup", INTERFACE, NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW (view), INTERFACE);
gtk_container_add (GTK_CONTAINER (swindow), view);
gtk_box_pack_start(GTK_BOX(capture_vb), swindow, TRUE, TRUE, 0);
- free_interface_list(if_list);
g_object_set_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY, view);
main_hb = gtk_hbox_new(FALSE, 5);
g_signal_connect(ok_bt, "clicked", G_CALLBACK(capture_start_cb), NULL);
gtk_widget_set_tooltip_text(ok_bt, "Start the capture process.");
#ifdef USE_THREADS
- if (num_selected > 0) {
+ if (global_capture_opts.num_selected > 0) {
#else
- if (num_selected == 1) {
+ if (global_capture_opts.num_selected == 1) {
#endif
gtk_widget_set_sensitive(ok_bt, TRUE);
} else {
guint i;
/* did the user ever select a capture interface before? */
- if(global_capture_opts.ifaces->len == 0 && prefs.capture_device == NULL) {
+ if(global_capture_opts.num_selected == 0 && prefs.capture_device == NULL) {
simple_dialog(ESD_TYPE_CONFIRMATION,
ESD_BTN_OK,
"%sNo capture interface selected!%s\n\n"
capture_start_cb(GtkWidget *w _U_, gpointer d _U_)
{
gpointer dialog;
- gchar *if_name;
- cap_settings_t *cap_settings_p = NULL;
- interface_options interface_opts;
- guint i;
#ifdef HAVE_AIRPCAP
airpcap_if_active = airpcap_if_selected;
if (!success)
return; /* error in options dialog */
}
-
- if (global_capture_opts.ifaces->len == 0) {
- if (prefs.capture_device == NULL) {
- simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ if (global_capture_opts.num_selected == 0) {
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"You didn't specify an interface on which to capture packets.");
- return;
- }
- interface_opts.name = g_strdup(get_if_name(prefs.capture_device));
- interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
-#ifdef HAVE_PCAP_CREATE
- interface_opts.monitor_mode = prefs_capture_device_monitor_mode(interface_opts.name);
-#else
- interface_opts.monitor_mode = FALSE;
-#endif
- interface_opts.linktype = capture_dev_user_linktype_find(interface_opts.name);
- interface_opts.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
- interface_opts.snaplen = global_capture_opts.default_options.snaplen;
- interface_opts.has_snaplen = global_capture_opts.default_options.has_snaplen;
- interface_opts.promisc_mode = global_capture_opts.default_options.promisc_mode;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- interface_opts.buffer_size = global_capture_opts.default_options.buffer_size;
-#endif
-#ifdef HAVE_PCAP_REMOTE
- interface_opts.src_type = global_capture_opts.default_options.src_type;
- interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
- interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
- interface_opts.auth_type = global_capture_opts.default_options.auth_type;
- interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
- interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
- interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
- interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
- interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
- #endif
- #ifdef HAVE_PCAP_SETSAMPLING
- interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
- interface_opts.sampling_param = global_capture_opts.default_options.sampling_param;
- #endif
- g_array_insert_val(global_capture_opts.ifaces, 0, interface_opts);
- }
-
- if (cap_settings_history != NULL) {
- for (i = 0; i < global_capture_opts.ifaces->len; i++) {
- interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
- if_name = g_strdup(interface_opts.name);
- cap_settings_p = g_hash_table_lookup(cap_settings_history, if_name);
- if (cap_settings_p == NULL) {
- cap_settings_p = g_malloc(sizeof (cap_settings_t));
- g_hash_table_insert(cap_settings_history, if_name, cap_settings_p);
- } else {
- g_free(if_name);
- }
- cap_settings_p->monitor_mode = interface_opts.monitor_mode;
- cap_settings_p->linktype = interface_opts.linktype;
- }
+ return;
}
if((cfile.state != FILE_CLOSED) && !cfile.user_saved && prefs.gui_ask_unsaved) {
{
gpointer ptr;
int dlt;
- interface_row row;
+ interface_t device;
- row = g_array_index(rows, interface_row, marked_row);
- rows = g_array_remove_index(rows, marked_row);
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
+ global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_row);
if (! ws_combo_box_get_active_pointer(GTK_COMBO_BOX(linktype_combo_box), &ptr)) {
g_assert_not_reached(); /* Programming error: somehow nothing is active */
}
if ((dlt = GPOINTER_TO_INT(ptr)) == -1) {
g_assert_not_reached(); /* Programming error: somehow managed to select an "unsupported" entry */
}
- row.active_dlt = dlt;
- g_array_insert_val(rows, marked_row, row);
+ device.active_dlt = dlt;
+ g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device);
capture_filter_check_syntax_cb(linktype_combo_box, data);
}
n_resolv_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_N_RESOLVE_KEY);
t_resolv_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_T_RESOLVE_KEY);
- if (global_capture_opts.ifaces->len == 0) {
+ if (global_capture_opts.num_selected == 0) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"You didn't specify an interface on which to capture packets.");
return FALSE;
return TRUE;
}
-static void
-make_and_fill_rows(void)
-{
- GList *if_entry, *if_list;
- if_info_t *if_info;
- char *if_string="";
- gchar *descr;
- if_capabilities_t *caps=NULL;
- gint linktype_count;
- cap_settings_t cap_settings;
- GSList *curr_addr;
- int ips = 0, err;
- guint i;
- if_addr_t *addr;
- GList *lt_entry;
- link_row *link = NULL;
- data_link_info_t *data_link_info;
- gchar *str, *err_str = NULL;
- interface_row row;
- interface_options interface_opts;
- gboolean found = FALSE;
- GString *ip_str;
-
- rows = g_array_new(TRUE, TRUE, sizeof(interface_row));
- /* Scan through the list and build a list of strings to display. */
- if_list = capture_interface_list(&err, &err_str);
- if_list = g_list_sort (if_list, if_list_comparator_alph);
- if (if_list == NULL && err == CANT_GET_INTERFACE_LIST) {
- simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
- g_free(err_str);
- return;
- } else if (err_str) {
- g_free(err_str);
- }
- for (if_entry = if_list; if_entry != NULL; if_entry = g_list_next(if_entry)) {
- if_info = if_entry->data;
- ip_str = g_string_new("");
- str = "";
- ips = 0;
- row.name = g_strdup(if_info->name);
- /* Is this interface hidden and, if so, should we include it anyway? */
- if (!prefs_is_capture_device_hidden(if_info->name)) {
- /* It's not hidden, or it is but we should include it in the list. */
- /* Do we have a user-supplied description? */
- descr = capture_dev_user_descr_find(if_info->name);
- if (descr != NULL) {
- /* Yes, we have a user-supplied description; use it. */
- if_string = g_strdup_printf("%s: %s", descr, if_info->name);
- g_free(descr);
- } else {
- /* No, we don't have a user-supplied description; did we get
- one from the OS or libpcap? */
- if (if_info->description != NULL) {
- /* Yes - use it. */
- if_string = g_strdup_printf("%s: %s", if_info->description, if_info->name);
- } else {
- /* No. */
- if_string = g_strdup(if_info->name);
- }
- }
- if (if_info->loopback) {
- row.display_name = g_strdup_printf("%s (loopback)", if_string);
- } else {
- row.display_name = g_strdup(if_string);
- }
- found = FALSE;
- 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.name || strcmp(interface_opts.name, (char*)row.name)!=0) {
- continue;
- } else {
- found = TRUE;
- break;
- }
- }
- if (found) {
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- row.buffer = interface_opts.buffer_size;
-#endif
- row.pmode = interface_opts.promisc_mode;
- row.has_snaplen = interface_opts.has_snaplen;
- row.snaplen = interface_opts.snaplen;
- row.cfilter = g_strdup(interface_opts.cfilter);
- } else {
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- row.buffer = global_capture_opts.default_options.buffer_size;
-#endif
- row.pmode = global_capture_opts.default_options.promisc_mode;
- row.has_snaplen = global_capture_opts.default_options.has_snaplen;
- row.snaplen = global_capture_opts.default_options.snaplen;
- row.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
- }
- cap_settings = capture_get_cap_settings(if_info->name);
- caps = capture_get_if_capabilities(if_info->name, cap_settings.monitor_mode, NULL);
- for (; (curr_addr = g_slist_nth(if_info->addrs, ips)) != NULL; ips++) {
- if (ips != 0) {
- g_string_append(ip_str, "\n");
- }
- addr = (if_addr_t *)curr_addr->data;
- switch (addr->ifat_type) {
- case IF_AT_IPv4:
- g_string_append(ip_str, ip_to_str((guint8 *)&addr->addr.ip4_addr));
- break;
- case IF_AT_IPv6:
- g_string_append(ip_str, ip6_to_str((struct e_in6_addr *)&addr->addr.ip6_addr));
- break;
- default:
- /* In case we add non-IP addresses */
- break;
- }
- }
- linktype_count = 0;
- row.links = NULL;
- if (caps != NULL) {
-#ifdef HAVE_PCAP_CREATE
- row.monitor_mode_enabled = cap_settings.monitor_mode;
- row.monitor_mode_supported = caps->can_set_rfmon;
-#endif
- for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
- data_link_info = lt_entry->data;
- if (data_link_info->description != NULL) {
- str = g_strdup_printf("%s", data_link_info->description);
- } else {
- str = g_strdup_printf("%s (not supported)", data_link_info->name);
- }
- if (linktype_count == 0) {
- row.active_dlt = data_link_info->dlt;
- }
- link = (link_row *)g_malloc(sizeof(link_row));
- link->dlt = data_link_info->dlt;
- link->name = g_strdup(str);
- row.links = g_list_append(row.links, link);
- linktype_count++;
- }
- } else {
- cap_settings.monitor_mode = FALSE;
-#ifdef HAVE_PCAP_CREATE
- row.monitor_mode_enabled = FALSE;
- row.monitor_mode_supported = FALSE;
-#endif
- row.active_dlt = -1;
- }
- row.addresses = g_strdup(ip_str->str);
- row.no_addresses = ips;
- g_array_append_val(rows, row);
- if (caps != NULL) {
- free_if_capabilities(caps);
- }
- }
- g_string_free(ip_str, TRUE);
- }
-}
-
GtkTreeModel *create_and_fill_model(GtkTreeView *view)
{
GtkListStore *store;
GtkTreeIter iter;
GList *list;
char *temp="", *snaplen_string;
- guint i, j;
+ guint i;
link_row *link = NULL;
- interface_row row;
- interface_options interface_opts;
- gboolean found = FALSE;
+ interface_t device;
#if defined(HAVE_PCAP_CREATE)
- store = gtk_list_store_new (8, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING);
+ 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)
- store = gtk_list_store_new (7, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING);
+ 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 (6, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
+ 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);
#endif
- if (!rows || rows->len == 0) {
- make_and_fill_rows();
- }
- if (rows && rows->len > 0) {
- for (i = 0; i < rows->len; i++) {
- row = g_array_index(rows, interface_row, i);
- found = FALSE;
- for (j = 0; j < global_capture_opts.ifaces->len; j++) {
- interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, j);
- if (!interface_opts.name || strcmp(interface_opts.name, (char*)row.name)!=0) {
- continue;
- } else {
- found = TRUE;
- num_selected++;
- break;
- }
- }
- if (row.no_addresses == 0) {
- temp = g_strdup_printf("<b>%s</b>", row.display_name);
+ 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.no_addresses == 0) {
+ temp = g_strdup_printf("<b>%s</b>", device.display_name);
} else {
- temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", row.display_name, row.addresses);
+ temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", device.display_name, device.addresses);
}
- for (list = row.links; list != NULL; list = g_list_next(list)) {
+ for (list = device.links; list != NULL; list = g_list_next(list)) {
link = (link_row*)(list->data);
- if (link->dlt == row.active_dlt) {
- break;
+ if (link->dlt == device.active_dlt) {
+ break;
}
}
- if (row.has_snaplen) {
- snaplen_string = g_strdup_printf("%d", row.snaplen);
+ if (device.has_snaplen) {
+ snaplen_string = g_strdup_printf("%d", device.snaplen);
} else {
snaplen_string = g_strdup("default");
}
gtk_list_store_append (store, &iter);
#if defined(HAVE_PCAP_CREATE)
- gtk_list_store_set (store, &iter, CAPTURE, found, INTERFACE, temp, LINK, link->name, PMODE, row.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) row.buffer, MONITOR, row.monitor_mode_supported?(row.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, row.cfilter, -1);
+ gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link->name, 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, found, INTERFACE, temp, LINK, link->name, PMODE, row.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) row.buffer, FILTER, row.cfilter, -1);
+ gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link->name, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
#else
- gtk_list_store_set (store, &iter, CAPTURE, found, INTERFACE, temp, LINK, link->name, PMODE, row.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, row.cfilter, -1);
+ gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link->name, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
#endif
}
}
void activate_monitor (GtkTreeViewColumn *tree_column _U_, GtkCellRenderer *renderer,
GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data _U_)
{
- interface_row row;
+ interface_t device;
GtkTreePath *path = gtk_tree_model_get_path(tree_model, iter);
int index = atoi(gtk_tree_path_to_string(path));
- row = g_array_index(rows, interface_row, index);
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, index);
- if (row.monitor_mode_supported==TRUE) {
+ if (device.monitor_mode_supported==TRUE) {
g_object_set(G_OBJECT(renderer), "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
} else {
g_object_set(G_OBJECT(renderer), "mode", GTK_CELL_RENDERER_MODE_INERT, NULL);
if_capabilities_t *caps=NULL;
gint linktype_count = 0, i;
data_link_info_t *data_link_info;
- interface_row row;
+ interface_t device;
link_row *link;
GtkWidget *linktype_combo_box = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_LT_CBX_KEY);
GtkWidget *linktype_lb = g_object_get_data(G_OBJECT(linktype_combo_box), E_CAP_LT_CBX_LABEL_KEY);
- row = g_array_index(rows, interface_row, marked_row);
- rows = g_array_remove_index(rows, marked_row);
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
+ global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_row);
- if_string = g_strdup(row.name);
+ if_string = g_strdup(device.name);
cap_settings = capture_get_cap_settings(if_string);
cap_settings.monitor_mode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(monitor));
caps = capture_get_if_capabilities(if_string, cap_settings.monitor_mode, NULL);
if (caps != NULL) {
g_signal_handlers_disconnect_by_func(linktype_combo_box, G_CALLBACK(select_link_type_cb), NULL );
ws_combo_box_clear_text_and_pointer(GTK_COMBO_BOX(linktype_combo_box));
- for (i = (gint)g_list_length(row.links)-1; i >= 0; i--) {
- GList* rem = g_list_nth(row.links, i);
- row.links = g_list_remove_link(row.links, rem);
+ for (i = (gint)g_list_length(device.links)-1; i >= 0; i--) {
+ GList* rem = g_list_nth(device.links, i);
+ device.links = g_list_remove_link(device.links, rem);
g_list_free_1(rem);
}
- row.active_dlt = -1;
+ device.active_dlt = -1;
linktype_count = 0;
- row.monitor_mode_supported = caps->can_set_rfmon;
- row.monitor_mode_enabled = cap_settings.monitor_mode;
+ device.monitor_mode_supported = caps->can_set_rfmon;
+ device.monitor_mode_enabled = cap_settings.monitor_mode;
for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
link = (link_row *)g_malloc(sizeof(link_row));
data_link_info = lt_entry->data;
GINT_TO_POINTER(data_link_info->dlt));
link->dlt = data_link_info->dlt;
if (linktype_count == 0) {
- row.active_dlt = data_link_info->dlt;
+ device.active_dlt = data_link_info->dlt;
}
link->name = g_strdup(data_link_info->description);
} else {
link->name = g_strdup(str);
g_free(str);
}
- row.links = g_list_append(row.links, link);
+ device.links = g_list_append(device.links, link);
linktype_count++;
}
free_if_capabilities(caps);
/* We don't know whether this supports monitor mode or not;
don't ask for monitor mode. */
cap_settings.monitor_mode = FALSE;
- row.monitor_mode_enabled = FALSE;
- row.monitor_mode_supported = FALSE;
+ device.monitor_mode_enabled = FALSE;
+ device.monitor_mode_supported = FALSE;
}
gtk_widget_set_sensitive(linktype_lb, linktype_count >= 2);
gtk_widget_set_sensitive(linktype_combo_box, linktype_count >= 2);
ws_combo_box_set_active(GTK_COMBO_BOX(linktype_combo_box),0);
- g_array_insert_val(rows, marked_row, row);
+ g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device);
}
#endif
* @ingroup dialog_group
*/
#include "capture_opts.h"
-
-#ifdef HAVE_PCAP_REMOTE
-struct remote_host {
- gchar *remote_host; /**< Host name or network address for remote capturing */
- gchar *remote_port; /**< TCP port of remote RPCAP server */
- gint auth_type; /**< Authentication type */
- gchar *auth_username; /**< Remote authentication parameters */
- gchar *auth_password; /**< Remote authentication parameters */
- gboolean datatx_udp;
- gboolean nocap_rpcap;
- gboolean nocap_local;
-};
-
-typedef struct remote_options_tag {
- capture_source src_type;
- struct remote_host remote_host_opts;
-#ifdef HAVE_PCAP_SETSAMPLING
- capture_sampling sampling_method;
- int sampling_param;
-#endif
-} remote_options;
-#endif /* HAVE_PCAP_REMOTE */
-
-typedef struct row_options_tag {
- gchar *name;
- gchar *display_name;
- gchar *addresses;
- gint no_addresses;
- gchar *cfilter;
- GList *links;
- gint active_dlt;
- gboolean pmode;
-#ifdef HAVE_PCAP_CREATE
- gboolean monitor_mode_enabled;
- gboolean monitor_mode_supported;
-#endif
- gboolean has_snaplen;
- guint snaplen;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- gint buffer;
-#endif
-#ifdef HAVE_PCAP_REMOTE
- remote_options remote_opts;
-#endif
-} interface_row;
-
-typedef struct link_row_tag {
- gchar *name;
- gint dlt;
-} link_row;
+#include <gtk/gtk.h>
enum
{
CAPTURE = 0,
+ IFACE_HIDDEN_NAME,
INTERFACE,
LINK,
PMODE,
void
capture_air_cb(GtkWidget *widget, gpointer data);
+#if 0
/*
* We remember the capture settings for each interface when a capture
* is started on it; the next time we select that interface we start
*/
cap_settings_t
capture_get_cap_settings (gchar *if_name);
+#endif
GtkTreeModel*
create_and_fill_model (GtkTreeView *view);
dlg_window_present(void);
void
-enable_selected_interface(gchar *name, gboolean enable);
+enable_selected_interface(gchar *name, gboolean selected);
void
options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column _U_, gpointer userdata);
+void
+update_all_rows(void);
+
#endif /* capture_dlg.h */
*/
static GtkWidget *cap_if_w;
-static GList *if_data_list = NULL;
-
static guint timer_id;
static GtkWidget *stop_bt, *capture_bt, *options_bt;
static GList *if_list;
-static guint currently_selected = 0;
+static GArray *gtk_list;
static if_stat_cache_t *sc;
/* the "runtime" data of one interface */
typedef struct if_dlg_data_s {
+ gchar *device;
GtkWidget *device_lb;
GtkWidget *descr_lb;
GtkWidget *ip_lb;
#ifdef _WIN32
GtkWidget *details_bt;
#endif
- guint32 last_packets;
- gchar *device;
- if_info_t if_info;
- gboolean selected;
} if_dlg_data_t;
static gboolean gbl_capture_in_progress = FALSE;
void
-update_selected_interface(gchar *name, gboolean activate)
+update_selected_interface(gchar *name)
{
- guint ifs;
- GList *curr;
- if_dlg_data_t *temp;
-
- for (ifs = 0; ifs < g_list_length(if_data_list); ifs++) {
- curr = g_list_nth(if_data_list, ifs);
- temp = (if_dlg_data_t *)(curr->data);
- if (strcmp(name, temp->if_info.name) == 0) {
- if (activate) {
- gtk_toggle_button_set_active((GtkToggleButton *)temp->choose_bt, TRUE);
- } else {
- gtk_toggle_button_set_active((GtkToggleButton *)temp->choose_bt, FALSE);
- }
+ guint i;
+ interface_t device;
+ if_dlg_data_t data;
+
+ for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
+ data = g_array_index(gtk_list, if_dlg_data_t, i);
+ if (strcmp(name, device.name) == 0) {
+ gtk_toggle_button_set_active((GtkToggleButton *)data.choose_bt, device.selected);
break;
}
}
}
static void
-store_selected(GtkWidget *choose_bt, gpointer if_data)
+store_selected(GtkWidget *choose_bt, gpointer name)
{
- if_dlg_data_t *if_dlg_data = if_data, *temp;
- GList *curr;
- unsigned int ifs, i;
+ interface_t device;
+ guint i;
gboolean found;
- cap_settings_t cap_settings;
- interface_options interface_opts;
-
- for (ifs = 0; ifs < g_list_length(if_data_list); ifs++) {
- curr = g_list_nth(if_data_list, ifs);
- temp = (if_dlg_data_t *)(curr->data);
+ for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
found = FALSE;
- if (strcmp(if_dlg_data->if_info.name, temp->if_info.name) == 0) {
- temp->selected ^=1;
- if_data_list = g_list_remove(if_data_list, curr->data);
- if_data_list = g_list_insert(if_data_list, temp, ifs);
-
- for (i = 0; i < global_capture_opts.ifaces->len; i++) {
- if (strcmp(g_array_index(global_capture_opts.ifaces, interface_options, i).name, temp->if_info.name) == 0) {
- found = TRUE;
- if (!temp->selected) {
- interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
- global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
- if (gtk_widget_is_focus(choose_bt) && get_welcome_window()) {
- change_interface_selection(interface_opts.name, FALSE);
- }
- if (gtk_widget_is_focus(choose_bt) && dlg_window_present()) {
- enable_selected_interface(interface_opts.name, FALSE);
- }
- g_free(interface_opts.name);
- g_free(interface_opts.descr);
- g_free(interface_opts.cfilter);
-#ifdef HAVE_PCAP_REMOTE
- g_free(interface_opts.remote_host);
- g_free(interface_opts.remote_port);
- g_free(interface_opts.auth_username);
- g_free(interface_opts.auth_password);
-#endif
- break;
- }
- }
- }
- if (!found && temp->selected) {
- interface_opts.name = g_strdup(temp->if_info.name);
- interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
- interface_opts.linktype = capture_dev_user_linktype_find(interface_opts.name);
- interface_opts.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
- interface_opts.has_snaplen = global_capture_opts.default_options.has_snaplen;
- interface_opts.snaplen = global_capture_opts.default_options.snaplen;
- cap_settings = capture_get_cap_settings (interface_opts.name);;
- interface_opts.promisc_mode = global_capture_opts.default_options.promisc_mode;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- interface_opts.buffer_size = global_capture_opts.default_options.buffer_size;
-#endif
- interface_opts.monitor_mode = cap_settings.monitor_mode;
-#ifdef HAVE_PCAP_REMOTE
- interface_opts.src_type = global_capture_opts.default_options.src_type;
- interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
- interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
- interface_opts.auth_type = global_capture_opts.default_options.auth_type;
- interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
- interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
- interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
- interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
- interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
-#endif
-#ifdef HAVE_PCAP_SETSAMPLING
- interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
- interface_opts.sampling_param = global_capture_opts.default_options.sampling_param;
-#endif
- g_array_append_val(global_capture_opts.ifaces, interface_opts);
- if (gtk_widget_is_focus(choose_bt) && get_welcome_window() != NULL) {
- change_interface_selection(g_strdup(temp->if_info.name), TRUE);
+ if (strcmp(name, device.if_info.name) == 0) {
+ found = TRUE;
+ if (!device.locked) {
+ device.selected ^= 1;
+ if (device.selected) {
+ global_capture_opts.num_selected++;
+ } else {
+ global_capture_opts.num_selected--;
+ }
+ 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);
+ if (gtk_widget_is_focus(choose_bt) && get_welcome_window()) {
+ change_interface_selection(device.name, device.selected);
}
if (gtk_widget_is_focus(choose_bt) && dlg_window_present()) {
- enable_selected_interface(interface_opts.name, TRUE);
+ enable_selected_interface(device.name, device.selected);
}
+ device.locked = FALSE;
+ 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);
}
-
- if (temp->selected)
- currently_selected += 1;
- else
- currently_selected -= 1;
break;
}
}
if (cap_if_w) {
#ifdef USE_THREADS
- gtk_widget_set_sensitive(capture_bt, !gbl_capture_in_progress && (currently_selected > 0));
+ gtk_widget_set_sensitive(capture_bt, !gbl_capture_in_progress && (global_capture_opts.num_selected > 0));
#else
- gtk_widget_set_sensitive(capture_bt, !gbl_capture_in_progress && (currently_selected == 1));
+ gtk_widget_set_sensitive(capture_bt, !gbl_capture_in_progress && (global_capture_opts.num_selected == 1));
#endif
}
}
capture_do_cb(GtkWidget *capture_bt _U_, gpointer if_data _U_)
#endif
{
- if_dlg_data_t *temp;
- GList *curr;
- int ifs;
-#ifdef HAVE_AIRPCAP
- if_dlg_data_t *if_dlg_data = if_data;
+ if_dlg_data_t data;
+ guint ifs;
- airpcap_if_active = get_airpcap_if_from_name(airpcap_if_list, if_dlg_data->if_info.name);
- airpcap_if_selected = airpcap_if_active;
+ for (ifs = 0; ifs < gtk_list->len; ifs++) {
+ data = g_array_index(gtk_list, if_dlg_data_t, ifs);
+ gtk_widget_set_sensitive(data.choose_bt, FALSE);
+ gtk_list = g_array_remove_index(gtk_list, ifs);
+ g_array_insert_val(gtk_list, ifs, data);
+#ifdef HAVE_AIRPCAP
+ airpcap_if_active = get_airpcap_if_from_name(airpcap_if_list, gtk_label_get_text(GTK_LABEL(data.device_lb)));
+ airpcap_if_selected = airpcap_if_active;
#endif
-
- for (ifs = 0; (curr = g_list_nth(if_data_list, ifs)); ifs++) {
- temp = (if_dlg_data_t *)(curr->data);
- gtk_widget_set_sensitive(temp->choose_bt, FALSE);
}
/* XXX - remove this? */
/* update a single interface */
static void
-update_if(if_dlg_data_t *if_dlg_data, if_stat_cache_t *sc)
+update_if(gchar *name, if_stat_cache_t *sc)
{
struct pcap_stat stats;
gchar *str;
- guint diff;
+ guint diff, ifs;
+ interface_t device;
+ if_dlg_data_t data;
+ gboolean found = FALSE;
/*
* That's a bug, and should be fixed; "pcap_stats()" is supposed
* to work the same way on all platforms.
*/
+ device.last_packets = 0;
+ data.curr_lb = NULL;
+ data.last_lb = NULL;
if (sc) {
- if (capture_stats(sc, if_dlg_data->device, &stats)) {
- diff = stats.ps_recv - if_dlg_data->last_packets;
- if_dlg_data->last_packets = stats.ps_recv;
-
- str = g_strdup_printf("%u", if_dlg_data->last_packets);
- gtk_label_set_text(GTK_LABEL(if_dlg_data->curr_lb), str);
- g_free(str);
- str = g_strdup_printf("%u", diff);
- gtk_label_set_text(GTK_LABEL(if_dlg_data->last_lb), str);
- g_free(str);
-
- gtk_widget_set_sensitive(if_dlg_data->curr_lb, diff);
- gtk_widget_set_sensitive(if_dlg_data->last_lb, diff);
- } else {
- gtk_label_set_text(GTK_LABEL(if_dlg_data->curr_lb), "error");
- gtk_label_set_text(GTK_LABEL(if_dlg_data->last_lb), "error");
+ for (ifs = 0; ifs < global_capture_opts.all_ifaces->len; ifs++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, ifs);
+ data = g_array_index(gtk_list, if_dlg_data_t, ifs);
+ if (!device.hidden && strcmp(name, device.name) == 0) {
+ found = TRUE;
+ break;
+ }
+ }
+ if (found) {
+ if (capture_stats(sc, name, &stats)) {
+ diff = stats.ps_recv - device.last_packets;
+ device.last_packets = stats.ps_recv;
+
+ str = g_strdup_printf("%u", device.last_packets);
+ gtk_label_set_text(GTK_LABEL(data.curr_lb), str);
+ g_free(str);
+ str = g_strdup_printf("%u", diff);
+ gtk_label_set_text(GTK_LABEL(data.last_lb), str);
+ g_free(str);
+
+ gtk_widget_set_sensitive(data.curr_lb, diff);
+ gtk_widget_set_sensitive(data.last_lb, diff);
+ } else {
+ gtk_label_set_text(GTK_LABEL(data.curr_lb), "error");
+ gtk_label_set_text(GTK_LABEL(data.last_lb), "error");
+ }
+ global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, ifs);
+ g_array_insert_val(global_capture_opts.all_ifaces, ifs, device);
+ gtk_list = g_array_remove_index(gtk_list, ifs);
+ g_array_insert_val(gtk_list, ifs, data);
}
}
}
static gboolean
update_all(gpointer data)
{
- GList *curr;
- int ifs;
+ interface_t device;
+ guint ifs;
if_stat_cache_t *sc = data;
if (!cap_if_w) {
return FALSE;
}
- for (ifs = 0; (curr = g_list_nth(if_data_list, ifs)); ifs++) {
- update_if(curr->data, sc);
+ for (ifs = 0; ifs < global_capture_opts.all_ifaces->len; ifs++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, ifs);
+ update_if(device.name, sc);
}
return TRUE;
if (cap_if_w) {
gtk_widget_set_sensitive(stop_bt, capture_in_progress);
#ifdef USE_THREADS
- gtk_widget_set_sensitive(capture_bt, !capture_in_progress && (currently_selected > 0));
+ gtk_widget_set_sensitive(capture_bt, !capture_in_progress && (global_capture_opts.num_selected > 0));
#else
- gtk_widget_set_sensitive(capture_bt, !capture_in_progress && (currently_selected == 1));
+ gtk_widget_set_sensitive(capture_bt, !capture_in_progress && (global_capture_opts.num_selected == 1));
#endif
}
}
static void
capture_if_destroy_cb(GtkWidget *win _U_, gpointer user_data _U_)
{
- GList *curr;
- int ifs;
-
g_source_remove(timer_id);
- for (ifs = 0; (curr = g_list_nth(if_data_list, ifs)); ifs++) {
- g_free(curr->data);
- }
-
- if_data_list = NULL;
-
free_interface_list(if_list);
/* Note that we no longer have a "Capture Options" dialog box. */
capture_if_stop_cb(GtkWidget *w _U_, gpointer d _U_)
{
guint ifs;
- GList *curr;
- if_dlg_data_t *if_data;
+ if_dlg_data_t data;
- for (ifs = 0; ifs < g_list_length(if_data_list); ifs++) {
- curr = g_list_nth(if_data_list, ifs);
- if_data = (if_dlg_data_t *)(curr->data);
- gtk_widget_set_sensitive(if_data->choose_bt, TRUE);
+ for (ifs = 0; ifs < gtk_list->len; ifs++) {
+ data = g_array_index(gtk_list, if_dlg_data_t, ifs);
+ gtk_widget_set_sensitive(data.choose_bt, TRUE);
+ gtk_list = g_array_remove_index(gtk_list, ifs);
+ g_array_insert_val(gtk_list, ifs, data);
}
capture_stop_cb(NULL, NULL);
}
+static void
+make_gtk_array(void)
+{
+ interface_t device;
+ if_dlg_data_t data;
+ guint i;
+
+ gtk_list = g_array_new(FALSE, FALSE, sizeof(if_dlg_data_t));
+
+ for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
+ data.device_lb = NULL;
+ data.descr_lb = NULL;
+ data.ip_lb = NULL;
+ data.curr_lb = NULL;
+ data.last_lb = NULL;
+ data.choose_bt = NULL;
+#ifdef _WIN32
+ data.details_bt = NULL;
+#endif
+ g_array_append_val(gtk_list, data);
+ }
+
+}
/* start getting capture stats from all interfaces */
void
*main_sw,
*bbox,
*close_bt,
- *help_bt,
- *icon;
+ *help_bt;
#ifdef HAVE_AIRPCAP
GtkWidget *decryption_cb;
#endif
- GtkWidget *if_tb;
+ GtkWidget *if_tb, *icon;
GtkWidget *if_lb;
GtkWidget *eb;
- int err;
- gchar *err_str;
GtkRequisition requisition;
int row, height;
- if_dlg_data_t *if_dlg_data = NULL;
- int ifs;
- GList *curr;
- if_info_t *if_info;
+ guint ifs;
+ interface_t device;
GString *if_tool_str = g_string_new("");
const gchar *addr_str;
gchar *user_descr;
- int preselected = 0, i;
- interface_options interface_opts;
- gboolean found = FALSE;
+ if_dlg_data_t data;
if (cap_if_w != NULL) {
/* There's already a "Capture Interfaces" dialog box; reactivate it. */
return;
}
#endif
- preselected = global_capture_opts.ifaces->len;
- /* LOAD THE INTERFACES */
- if_list = capture_interface_list(&err, &err_str);
- if_list = g_list_sort (if_list, if_list_comparator_alph);
- if (if_list == NULL) {
- switch (err) {
-
- case CANT_GET_INTERFACE_LIST:
- simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
- g_free(err_str);
- break;
-
- case NO_INTERFACES_FOUND:
- simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
- "There are no interfaces on which a capture can be done.");
- break;
- }
- return;
- }
#ifdef HAVE_AIRPCAP
/* LOAD AIRPCAP INTERFACES */
- airpcap_if_list = get_airpcap_interface_list(&err, &err_str);
- if (airpcap_if_list == NULL)
- airpcap_if_active = airpcap_if_selected = NULL;
decryption_cb = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY);
update_decryption_mode_list(decryption_cb);
- if (airpcap_if_list == NULL && err == CANT_GET_AIRPCAP_INTERFACE_LIST) {
-#if 0
- /* XXX - Do we need to show an error here? */
- simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
-#endif
- g_free(err_str);
- }
-
/* If no airpcap interface is present, gray everything */
if (airpcap_if_active == NULL) {
if (airpcap_if_list == NULL) {
airpcap_set_toolbar_start_capture(airpcap_if_active);
#endif
+ make_gtk_array();
cap_if_w = dlg_window_new("Wireshark: Capture Interfaces"); /* transient_for top_level */
gtk_window_set_destroy_with_parent (GTK_WINDOW(cap_if_w), TRUE);
height += 30;
/* Start gathering statistics (using dumpcap) */
- sc = capture_stat_start(if_list);
+ sc = capture_stat_start(&global_capture_opts);
/* List the interfaces */
- currently_selected = 0;
- for (ifs = 0; (curr = g_list_nth(if_list, ifs)); ifs++) {
+ for (ifs = 0; ifs < global_capture_opts.all_ifaces->len; ifs++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, ifs);
+ data = g_array_index(gtk_list, if_dlg_data_t, ifs);
g_string_assign(if_tool_str, "");
- if_info = curr->data;
-
/* Continue if capture device is hidden */
- if (prefs_is_capture_device_hidden(if_info->name)) {
+ if (device.hidden) {
continue;
}
-
- if_dlg_data = g_malloc0(sizeof(if_dlg_data_t));
-
- if (preselected > 0) {
- found = FALSE;
- for (i = 0; i < (gint)global_capture_opts.ifaces->len; i++) {
- interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
- if ((interface_opts.name == NULL) ||
- (strcmp(interface_opts.name, (char*)if_info->name) != 0)) {
- continue;
- } else {
- found = TRUE;
- currently_selected++;
- preselected--;
- break;
- }
- }
- if_dlg_data->selected = found;
- } else {
- if_dlg_data->selected = FALSE;
- }
- if_dlg_data->if_info = *if_info;
-
- if_dlg_data->choose_bt = gtk_check_button_new();
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->choose_bt, 0, 1, row, row+1);
+ data.choose_bt = gtk_check_button_new();
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), data.choose_bt, 0, 1, row, row+1);
if (gbl_capture_in_progress) {
- gtk_widget_set_sensitive(if_dlg_data->choose_bt, FALSE);
+ gtk_widget_set_sensitive(data.choose_bt, FALSE);
} else {
- gtk_widget_set_sensitive(if_dlg_data->choose_bt, TRUE);
+ gtk_widget_set_sensitive(data.choose_bt, TRUE);
}
- gtk_toggle_button_set_active((GtkToggleButton *)if_dlg_data->choose_bt, if_dlg_data->selected);
- g_signal_connect(if_dlg_data->choose_bt, "toggled", G_CALLBACK(store_selected), if_dlg_data);
- /* Kind of adaptor (icon) */
-#ifdef HAVE_AIRPCAP
- if (get_airpcap_if_from_name(airpcap_if_list,if_info->name) != NULL)
- icon = xpm_to_widget(capture_airpcap_16_xpm);
- else
- icon = capture_get_if_icon(if_info);
-#else
- icon = capture_get_if_icon(if_info);
-#endif
+ gtk_toggle_button_set_active((GtkToggleButton *)data.choose_bt, device.selected);
+ g_signal_connect(data.choose_bt, "toggled", G_CALLBACK(store_selected), device.name);
+ /* Kind of adaptor (icon) */
+ icon = capture_get_if_icon(&(device.if_info));
gtk_table_attach_defaults(GTK_TABLE(if_tb), icon, 1, 2, row, row+1);
/* device name */
- if_dlg_data->device_lb = gtk_label_new(if_info->name);
- if_dlg_data->device = if_info->name;
+ data.device_lb = gtk_label_new(device.name);
#ifndef _WIN32
- gtk_misc_set_alignment(GTK_MISC(if_dlg_data->device_lb), 0.0f, 0.5f);
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->device_lb, 2, 4, row, row+1);
+ gtk_misc_set_alignment(GTK_MISC(data.device_lb), 0.0f, 0.5f);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), data.device_lb, 2, 4, row, row+1);
#endif
g_string_append(if_tool_str, "Device: ");
- g_string_append(if_tool_str, if_info->name);
+ g_string_append(if_tool_str, device.name);
g_string_append(if_tool_str, "\n");
/* description */
- user_descr = capture_dev_user_descr_find(if_info->name);
+ user_descr = capture_dev_user_descr_find(device.name);
if (user_descr) {
- if_dlg_data->descr_lb = gtk_label_new(user_descr);
+ data.descr_lb = gtk_label_new(user_descr);
g_free (user_descr);
} else {
- if (if_info->description)
- if_dlg_data->descr_lb = gtk_label_new(if_info->description);
+ if (device.if_info.description)
+ data.descr_lb = gtk_label_new(device.if_info.description);
else
- if_dlg_data->descr_lb = gtk_label_new("");
+ data.descr_lb = gtk_label_new("");
}
- gtk_misc_set_alignment(GTK_MISC(if_dlg_data->descr_lb), 0.0f, 0.5f);
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->descr_lb, 4, 5, row, row+1);
-
- if (if_info->description) {
+ gtk_misc_set_alignment(GTK_MISC(data.descr_lb), 0.0f, 0.5f);
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), data.descr_lb, 4, 5, row, row+1);
+ if (device.if_info.description) {
g_string_append(if_tool_str, "Description: ");
- g_string_append(if_tool_str, if_info->description);
+ g_string_append(if_tool_str, device.if_info.description);
g_string_append(if_tool_str, "\n");
}
/* IP address */
/* Only one IP address will be shown, start with the first */
g_string_append(if_tool_str, "IP: ");
- if_dlg_data->ip_lb = gtk_label_new("");
- addr_str = set_ip_addr_label (if_info->addrs, if_dlg_data->ip_lb, 0);
+ data.ip_lb = gtk_label_new("");
+ addr_str = set_ip_addr_label (device.if_info.addrs, data.ip_lb, 0);
if (addr_str) {
- gtk_widget_set_sensitive(if_dlg_data->ip_lb, TRUE);
+ gtk_widget_set_sensitive(data.ip_lb, TRUE);
g_string_append(if_tool_str, addr_str);
} else {
- gtk_widget_set_sensitive(if_dlg_data->ip_lb, FALSE);
+ gtk_widget_set_sensitive(data.ip_lb, FALSE);
g_string_append(if_tool_str, "none");
}
eb = gtk_event_box_new ();
- gtk_container_add(GTK_CONTAINER(eb), if_dlg_data->ip_lb);
+ gtk_container_add(GTK_CONTAINER(eb), data.ip_lb);
gtk_table_attach_defaults(GTK_TABLE(if_tb), eb, 5, 6, row, row+1);
- if (get_ip_addr_count(if_info->addrs) > 1) {
+ if (get_ip_addr_count(device.if_info.addrs) > 1) {
/* More than one IP address, make it possible to toggle */
- g_object_set_data(G_OBJECT(eb), CAPTURE_IF_IP_ADDR_LABEL, if_dlg_data->ip_lb);
+ g_object_set_data(G_OBJECT(eb), CAPTURE_IF_IP_ADDR_LABEL, data.ip_lb);
g_signal_connect(eb, "enter-notify-event", G_CALLBACK(ip_label_enter_cb), NULL);
g_signal_connect(eb, "leave-notify-event", G_CALLBACK(ip_label_leave_cb), NULL);
- g_signal_connect(eb, "button-press-event", G_CALLBACK(ip_label_press_cb), if_info->addrs);
+ g_signal_connect(eb, "button-press-event", G_CALLBACK(ip_label_press_cb), device.if_info.addrs);
}
g_string_append(if_tool_str, "\n");
/* packets */
- if_dlg_data->curr_lb = gtk_label_new("-");
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->curr_lb, 6, 7, row, row+1);
+ data.curr_lb = gtk_label_new("-");
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), data.curr_lb, 6, 7, row, row+1);
/* packets/s */
- if_dlg_data->last_lb = gtk_label_new("-");
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->last_lb, 7, 8, row, row+1);
+ data.last_lb = gtk_label_new("-");
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), data.last_lb, 7, 8, row, row+1);
/* details button */
#ifdef _WIN32
- if_dlg_data->details_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_CAPTURE_DETAILS);
- gtk_widget_set_tooltip_text(if_dlg_data->details_bt, "Open the capture details dialog of this interface.");
- gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->details_bt, 8, 9, row, row+1);
- if (capture_if_has_details(if_dlg_data->device)) {
- g_signal_connect(if_dlg_data->details_bt, "clicked", G_CALLBACK(capture_details_cb), if_dlg_data);
+ data.details_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_CAPTURE_DETAILS);
+ gtk_widget_set_tooltip_text(data.details_bt, "Open the capture details dialog of this interface.");
+ gtk_table_attach_defaults(GTK_TABLE(if_tb), data.details_bt, 8, 9, row, row+1);
+ if (capture_if_has_details(device.name)) {
+ g_signal_connect(data.details_bt, "clicked", G_CALLBACK(capture_details_cb), device.name);
} else {
- gtk_widget_set_sensitive(if_dlg_data->details_bt, FALSE);
+ gtk_widget_set_sensitive(data.details_bt, FALSE);
}
#endif
-
- if_data_list = g_list_append(if_data_list, if_dlg_data);
+ gtk_list = g_array_remove_index(gtk_list, ifs);
+ g_array_insert_val(gtk_list, ifs, data);
row++;
if (row <= 10) {
/* Lets add up 10 rows of interfaces, otherwise the window may become too high */
- gtk_widget_get_preferred_size(GTK_WIDGET(if_dlg_data->choose_bt), &requisition, NULL);
+ gtk_widget_get_preferred_size(GTK_WIDGET(data.choose_bt), &requisition, NULL);
height += requisition.height;
}
}
window_set_cancel_button(cap_if_w, close_bt, window_cancel_button_cb);
gtk_widget_set_tooltip_text(close_bt, "Close this window.");
options_bt = g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_CAPTURE_OPTIONS);
- g_signal_connect(options_bt, "clicked", G_CALLBACK(capture_prepare_cb), if_dlg_data);
+ g_signal_connect(options_bt, "clicked", G_CALLBACK(capture_prepare_cb), device.name);
capture_bt = g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_CAPTURE_START);
- g_signal_connect(capture_bt, "clicked", G_CALLBACK(capture_do_cb), if_dlg_data);
+ g_signal_connect(capture_bt, "clicked", G_CALLBACK(capture_do_cb), device.name);
gtk_widget_get_preferred_size(GTK_WIDGET(close_bt), &requisition, NULL);
/* height + static offset + what the GTK MS Windows Engine needs in addition per interface */
height += requisition.height + 40 + ifs;
capture_if_cb(NULL, NULL);
}
-void select_all_interfaces(gboolean enable)
+void select_all_interfaces(gboolean enable _U_)
{
- if_dlg_data_t *temp;
guint ifs;
- GList *curr;
+ interface_t device;
- for (ifs = 0; ifs < g_list_length(if_data_list); ifs++) {
- curr = g_list_nth(if_data_list, ifs);
- temp = (if_dlg_data_t *)(curr->data);
- update_selected_interface(temp->if_info.name, enable);
+ for (ifs = 0; ifs < global_capture_opts.all_ifaces->len; ifs++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, ifs);
+ update_selected_interface(device.if_info.name);
}
}
capture_get_if_icon(const if_info_t* if_info);
void
-update_selected_interface(gchar *name, gboolean activate);
+update_selected_interface(gchar *name);
gboolean
interfaces_dialog_window_present(void);
void
destroy_if_window(void);
+gint
+if_list_comparator_alph (const void *first_arg, const void *second_arg);
+
#endif /* HAVE_LIBPCAP */
#endif /* capture_if_dlg.h */
#include "../capture_ifinfo.h"
#include "../capture.h"
#include "../capture_sync.h"
+extern gint if_list_comparator_alph (const void *first_arg, const void *second_arg);
#endif
#ifdef _WIN32
static gboolean
is_address_column (gint column)
{
- if (((cfile.cinfo.col_fmt[column] == COL_DEF_SRC) ||
- (cfile.cinfo.col_fmt[column] == COL_RES_SRC) ||
- (cfile.cinfo.col_fmt[column] == COL_DEF_DST) ||
- (cfile.cinfo.col_fmt[column] == COL_RES_DST)) &&
- strlen(cfile.cinfo.col_expr.col_expr_val[column]))
- {
- return TRUE;
- }
+ if (((cfile.cinfo.col_fmt[column] == COL_DEF_SRC) ||
+ (cfile.cinfo.col_fmt[column] == COL_RES_SRC) ||
+ (cfile.cinfo.col_fmt[column] == COL_DEF_DST) ||
+ (cfile.cinfo.col_fmt[column] == COL_RES_DST)) &&
+ strlen(cfile.cinfo.col_expr.col_expr_val[column]))
+ {
+ return TRUE;
+ }
- return FALSE;
+ return FALSE;
}
GList *
epan_dissect_run(&edt, &cfile.pseudo_header, cfile.pd, fdata, &cfile.cinfo);
epan_dissect_fill_in_columns(&edt, TRUE, TRUE);
- /* First check selected column */
- if (is_address_column (column)) {
- addr_list = g_list_append (addr_list, se_strdup_printf("%s", cfile.cinfo.col_expr.col_expr_val[column]));
+ /* First check selected column */
+ if (is_address_column (column)) {
+ addr_list = g_list_append (addr_list, se_strdup_printf("%s", cfile.cinfo.col_expr.col_expr_val[column]));
}
- for (col = 0; col < cfile.cinfo.num_cols; col++) {
- /* Then check all columns except the selected */
- if ((col != column) && (is_address_column (col))) {
- addr_list = g_list_append (addr_list, se_strdup_printf("%s", cfile.cinfo.col_expr.col_expr_val[col]));
- }
- }
+ for (col = 0; col < cfile.cinfo.num_cols; col++) {
+ /* Then check all columns except the selected */
+ if ((col != column) && (is_address_column (col))) {
+ addr_list = g_list_append (addr_list, se_strdup_printf("%s", cfile.cinfo.col_expr.col_expr_val[col]));
+ }
+ }
epan_dissect_cleanup(&edt);
}
return;
if (set) {
frame->flags.ref_time=1;
- cfile.ref_time_count++;
+ cfile.ref_time_count++;
} else {
frame->flags.ref_time=0;
cfile.ref_time_count--;
case(ESD_BTN_YES):
timestamp_set_type(TS_RELATIVE);
recent.gui_time_format = TS_RELATIVE;
- cf_timestamp_auto_precision(&cfile);
- new_packet_list_queue_draw();
+ cf_timestamp_auto_precision(&cfile);
+ new_packet_list_queue_draw();
break;
case(ESD_BTN_NO):
break;
if (cfile.current_frame) {
set_frame_reftime(!cfile.current_frame->flags.ref_time,
- cfile.current_frame, cfile.current_row);
+ cfile.current_frame, cfile.current_row);
}
}
static void
main_cf_cb_file_closing(capture_file *cf)
{
+#ifdef HAVE_LIBPCAP
+ int i;
+#endif
/* if we have more than 10000 packets, show a splash screen while closing */
/* XXX - don't know a better way to decide whether to show or not,
destroy_packet_wins();
file_save_as_destroy();
+#ifdef HAVE_LIBPCAP
+ if (global_capture_opts.ifaces && global_capture_opts.ifaces->len > 0) {
+ for (i = (int)global_capture_opts.ifaces->len-1; i >= 0; i--) {
+ global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
+ }
+ }
+#endif
+
/* Restore the standard title bar message. */
set_main_window_name("The Wireshark Network Analyzer");
recent_read_static(&rf_path, &rf_open_errno);
if (rf_path != NULL && rf_open_errno != 0) {
simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
- "Could not open common recent file\n\"%s\": %s.",
- rf_path, g_strerror(rf_open_errno));
+ "Could not open common recent file\n\"%s\": %s.",
+ rf_path, g_strerror(rf_open_errno));
}
/* "pre-scan" the command line parameters, if we have "console only"
while ((opt = getopt(argc, argv, optstring)) != -1) {
switch (opt) {
case 'C': /* Configuration Profile */
- if (profile_exists (optarg, FALSE)) {
- set_profile_name (optarg);
- } else {
- cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
- exit(1);
- }
- break;
+ if (profile_exists (optarg, FALSE)) {
+ set_profile_name (optarg);
+ } else {
+ cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
+ exit(1);
+ }
+ break;
case 'D': /* Print a list of capture devices and exit */
#ifdef HAVE_LIBPCAP
if_list = capture_interface_list(&err, &err_str);
recent_read_profile_static(&rf_path, &rf_open_errno);
if (rf_path != NULL && rf_open_errno != 0) {
simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
- "Could not open recent file\n\"%s\": %s.",
- rf_path, g_strerror(rf_open_errno));
+ "Could not open recent file\n\"%s\": %s.",
+ rf_path, g_strerror(rf_open_errno));
}
if (recent.gui_fileopen_remembered_dir &&
/* Fill in capture options with values from the preferences */
prefs_to_capture_opts();
+#ifdef HAVE_LIBPCAP
+ if (global_capture_opts.all_ifaces->len == 0) {
+ scan_local_interfaces(&global_capture_opts);
+ }
+#endif
/* Now get our args */
while ((opt = getopt(argc, argv, optstring)) != -1) {
switch (opt) {
case 'f': /* capture filter */
case 'k': /* Start capture immediately */
case 'H': /* Hide capture info dialog box */
- case 'i': /* Use interface xxx */
case 'p': /* Don't capture in promiscuous mode */
#ifdef HAVE_PCAP_CREATE
case 'I': /* Capture in monitor mode, if available */
break;
#endif
+#ifdef HAVE_LIBPCAP
+ case 'i': /* Use interface xxx */
+ status = capture_opts_select_iface(&global_capture_opts, optarg);
+ if (status != 0) {
+ exit(status);
+ }
+#else
+ capture_option_specified = TRUE;
+ arg_error = TRUE;
+#endif
+ break;
+
/*** all non capture option specific ***/
case 'C':
/* Configuration profile settings were already processed just ignore them this time*/
- break;
+ break;
case 'd':
- dfilter = optarg;
- break;
+ dfilter = optarg;
+ break;
case 'j': /* Search backwards for a matching packet from filter in option J */
jump_backwards = TRUE;
break;
badopt = string_to_name_resolve(optarg, &gbl_resolv_flags);
if (badopt != '\0') {
cmdarg_err("-N specifies unknown resolving option '%c'; valid options are 'm', 'n', and 't'",
- badopt);
+ badopt);
exit(1);
}
break;
case PREFS_SET_NO_SUCH_PREF:
case PREFS_SET_OBSOLETE:
cmdarg_err("-o flag \"%s\" specifies unknown preference/recent value",
- optarg);
+ optarg);
exit(1);
break;
default:
break;
case PREFS_SET_OBSOLETE:
cmdarg_err("-o flag \"%s\" specifies obsolete preference",
- optarg);
+ optarg);
exit(1);
break;
default:
/* Path settings were already processed just ignore them this time*/
break;
case 'r': /* Read capture file xxx */
- /* We may set "last_open_dir" to "cf_name", and if we change
- "last_open_dir" later, we free the old value, so we have to
- set "cf_name" to something that's been allocated. */
+ /* We may set "last_open_dir" to "cf_name", and if we change
+ "last_open_dir" later, we free the old value, so we have to
+ set "cf_name" to something that's been allocated. */
cf_name = g_strdup(optarg);
break;
case 'R': /* Read file filter */
part of a tap filter. Instead, we just add the argument
to a list of stat arguments. */
if (!process_stat_cmd_arg(optarg)) {
- cmdarg_err("Invalid -z argument.");
- cmdarg_err_cont(" -z argument must be one of :");
- list_stat_cmd_args();
- exit(1);
- }
+ cmdarg_err("Invalid -z argument.");
+ cmdarg_err_cont(" -z argument must be one of :");
+ list_stat_cmd_args();
+ exit(1);
+ }
break;
default:
case '?': /* Bad flag - print usage message */
sense? */
if (global_capture_opts.multi_files_on) {
/* Ring buffer works only under certain conditions:
- a) ring buffer does not work with temporary files;
- b) real_time_mode and multi_files_on are mutually exclusive -
- real_time_mode takes precedence;
- c) it makes no sense to enable the ring buffer if the maximum
- file size is set to "infinite". */
+ a) ring buffer does not work with temporary files;
+ b) real_time_mode and multi_files_on are mutually exclusive -
+ real_time_mode takes precedence;
+ c) it makes no sense to enable the ring buffer if the maximum
+ file size is set to "infinite". */
if (global_capture_opts.save_file == NULL) {
- cmdarg_err("Ring buffer requested, but capture isn't being saved to a permanent file.");
- global_capture_opts.multi_files_on = FALSE;
+ cmdarg_err("Ring buffer requested, but capture isn't being saved to a permanent file.");
+ global_capture_opts.multi_files_on = FALSE;
}
-/* if (global_capture_opts.real_time_mode) {
- cmdarg_err("Ring buffer requested, but an \"Update list of packets in real time\" capture is being done.");
- global_capture_opts.multi_files_on = FALSE;
- }*/
if (!global_capture_opts.has_autostop_filesize && !global_capture_opts.has_file_duration) {
- cmdarg_err("Ring buffer requested, but no maximum capture file size or duration were specified.");
-/* XXX - this must be redesigned as the conditions changed */
-/* global_capture_opts.multi_files_on = FALSE;*/
+ cmdarg_err("Ring buffer requested, but no maximum capture file size or duration were specified.");
+ /* XXX - this must be redesigned as the conditions changed */
}
}
}
/* Get the list of link-layer types for the capture devices. */
if_capabilities_t *caps;
guint i;
- interface_options interface_opts;
-
- for (i = 0; i < global_capture_opts.ifaces->len; i++) {
-
- interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
- caps = capture_get_if_capabilities(interface_opts.name, interface_opts.monitor_mode, &err_str);
- if (caps == NULL) {
- cmdarg_err("%s", err_str);
- g_free(err_str);
- exit(2);
- }
- if (caps->data_link_types == NULL) {
- cmdarg_err("The capture device \"%s\" has no data link types.", interface_opts.name);
- exit(2);
+ interface_t device;
+ 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.selected) {
+ caps = capture_get_if_capabilities(device.name, device.monitor_mode_supported, &err_str);
+ if (caps == NULL) {
+ cmdarg_err("%s", err_str);
+ g_free(err_str);
+ exit(2);
+ }
+ if (caps->data_link_types == NULL) {
+ cmdarg_err("The capture device \"%s\" has no data link types.", device.name);
+ exit(2);
+ }
+ capture_opts_print_if_capabilities(caps, device.name, device.monitor_mode_supported);
+ free_if_capabilities(caps);
}
- capture_opts_print_if_capabilities(caps, interface_opts.name, interface_opts.monitor_mode);
- free_if_capabilities(caps);
}
exit(0);
}
exit(2);
}
#endif
- if ((global_capture_opts.ifaces->len == 0) &&
+ if ((global_capture_opts.num_selected == 0) &&
(prefs.capture_device != NULL)) {
- GList *curr, *combo_list;
- gboolean found = FALSE;
-
- if_list = capture_interface_list(&err, NULL);
- if (g_list_length(if_list) > 0) {
- combo_list = build_capture_combo_list(if_list, FALSE);
- free_interface_list(if_list);
- for (curr = combo_list; curr; curr = g_list_next(curr)) {
- if (strcmp(curr->data, prefs.capture_device) == 0) {
- found = TRUE;
- break;
- }
+ guint i;
+ interface_t device;
+ 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 && strcmp(device.display_name, prefs.capture_device) == 0) {
+ device.selected = TRUE;
+ global_capture_opts.num_selected++;
+ 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);
+ break;
}
}
- if (found) {
- interface_options interface_opts;
-
- interface_opts.name = g_strdup(get_if_name(prefs.capture_device));
- interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
- interface_opts.monitor_mode = prefs_capture_device_monitor_mode(interface_opts.name);
- interface_opts.linktype = capture_dev_user_linktype_find(interface_opts.name);
- interface_opts.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
- interface_opts.snaplen = global_capture_opts.default_options.snaplen;
- interface_opts.has_snaplen = global_capture_opts.default_options.has_snaplen;
- interface_opts.promisc_mode = global_capture_opts.default_options.promisc_mode;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- interface_opts.buffer_size = global_capture_opts.default_options.buffer_size;
-#endif
-#ifdef HAVE_PCAP_REMOTE
- interface_opts.src_type = global_capture_opts.default_options.src_type;
- interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
- interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
- interface_opts.auth_type = global_capture_opts.default_options.auth_type;
- interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
- interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
- interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
- interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
- interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
- #endif
- #ifdef HAVE_PCAP_SETSAMPLING
- interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
- interface_opts.sampling_param = global_capture_opts.default_options.sampling_param;
- #endif
- g_array_insert_val(global_capture_opts.ifaces, 0, interface_opts);
- }
}
#endif
recent_read_dynamic(&rf_path, &rf_open_errno);
if (rf_path != NULL && rf_open_errno != 0) {
simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
- "Could not open recent file\n\"%s\": %s.",
- rf_path, g_strerror(rf_open_errno));
+ "Could not open recent file\n\"%s\": %s.",
+ rf_path, g_strerror(rf_open_errno));
}
color_filters_enable(recent.packet_list_colorize);
break;
}
- /* If the filename is not the absolute path, prepend the current dir. This happens
- when wireshark is invoked from a cmd shell (e.g.,'wireshark -r file.pcap'). */
- if (!g_path_is_absolute(cf_name)) {
- char *old_cf_name = cf_name;
- char *pwd = g_get_current_dir();
- cf_name = g_strdup_printf("%s%s%s", pwd, G_DIR_SEPARATOR_S, cf_name);
- g_free(old_cf_name);
- g_free(pwd);
- }
+ /* If the filename is not the absolute path, prepend the current dir. This happens
+ when wireshark is invoked from a cmd shell (e.g.,'wireshark -r file.pcap'). */
+ if (!g_path_is_absolute(cf_name)) {
+ char *old_cf_name = cf_name;
+ char *pwd = g_get_current_dir();
+ cf_name = g_strdup_printf("%s%s%s", pwd, G_DIR_SEPARATOR_S, cf_name);
+ g_free(old_cf_name);
+ g_free(pwd);
+ }
/* Save the name of the containing directory specified in the
path name, if any; we can write over cf_name, which is a
dfilter_free(rfcode);
cfile.rfcode = NULL;
show_main_window(FALSE);
- /* Don't call check_and_warn_user_startup(): we did it above */
+ /* Don't call check_and_warn_user_startup(): we did it above */
set_menus_for_capture_in_progress(FALSE);
set_capture_if_dialog_for_capture_in_progress(FALSE);
}
check_and_warn_user_startup(cf_name);
if (capture_start(&global_capture_opts)) {
/* The capture started. Open stat windows; we do so after creating
- the main window, to avoid GTK warnings, and after successfully
- opening the capture file, so we know we have something to compute
- stats on, and after registering all dissectors, so that MATE will
- have registered its field array and we can have a tap filter with
+ the main window, to avoid GTK warnings, and after successfully
+ opening the capture file, so we know we have something to compute
+ stats on, and after registering all dissectors, so that MATE will
+ have registered its field array and we can have a tap filter with
one of MATE's late-registered fields as part of the filter. */
start_requested_stats();
}
if (!have_capture_file) {
if(welcome_pane) {
gtk_widget_show(welcome_pane);
- select_ifaces();
}
} else {
gtk_widget_hide(welcome_pane);
cf_redissect_packets(&cfile);
status_expert_update();
}
+
+#ifdef HAVE_LIBPCAP
+void
+scan_local_interfaces(capture_options* capture_opts)
+{
+ GList *if_entry, *lt_entry, *if_list;
+ if_info_t *if_info, *temp;
+ char *if_string="";
+ gchar *descr, *str, *err_str = NULL;
+ if_capabilities_t *caps=NULL;
+ gint linktype_count;
+ cap_settings_t cap_settings;
+ GSList *curr_addr;
+ int ips = 0, err, i;
+ guint count = 0;
+ if_addr_t *addr, *temp_addr;
+ link_row *link = NULL;
+ data_link_info_t *data_link_info;
+ interface_t device;
+ GString *ip_str;
+
+ if (capture_opts->all_ifaces->len > 0) {
+ for (i = (int)capture_opts->all_ifaces->len-1; i >= 0; i--) {
+ device = g_array_index(capture_opts->all_ifaces, interface_t, i);
+ if (device.type == IF_LOCAL) {
+ capture_opts->all_ifaces = g_array_remove_index(capture_opts->all_ifaces, i);
+ }
+ }
+ }
+ /* Scan through the list and build a list of strings to display. */
+ if_list = capture_interface_list(&err, &err_str);
+ if (if_list == NULL) {
+ switch (err) {
+
+ case CANT_GET_INTERFACE_LIST:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
+ g_free(err_str);
+ break;
+
+ case NO_INTERFACES_FOUND:
+ simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+ "There are no interfaces on which a capture can be done.");
+ break;
+ }
+ return;
+ }
+ count = 0;
+ for (if_entry = if_list; if_entry != NULL; if_entry = g_list_next(if_entry)) {
+ if_info = if_entry->data;
+ ip_str = g_string_new("");
+ str = "";
+ ips = 0;
+ device.name = g_strdup(if_info->name);
+ device.hidden = FALSE;
+ device.locked = FALSE;
+ temp = g_malloc0(sizeof(if_info_t));
+ temp->name = g_strdup(if_info->name);
+ temp->description = g_strdup(if_info->description);
+ temp->loopback = if_info->loopback;
+ /* Is this interface hidden and, if so, should we include it anyway? */
+
+ /* Do we have a user-supplied description? */
+ descr = capture_dev_user_descr_find(if_info->name);
+ if (descr != NULL) {
+ /* Yes, we have a user-supplied description; use it. */
+ if_string = g_strdup_printf("%s: %s", descr, if_info->name);
+ g_free(descr);
+ } else {
+ /* No, we don't have a user-supplied description; did we get
+ one from the OS or libpcap? */
+ if (if_info->description != NULL) {
+ /* Yes - use it. */
+ if_string = g_strdup_printf("%s: %s", if_info->description, if_info->name);
+ } else {
+ /* No. */
+ if_string = g_strdup(if_info->name);
+ }
+ }
+ if (if_info->loopback) {
+ device.display_name = g_strdup_printf("%s (loopback)", if_string);
+ } else {
+ device.display_name = g_strdup(if_string);
+ }
+ device.selected = FALSE;
+ if (prefs_is_capture_device_hidden(if_info->name)) {
+ device.hidden = TRUE;
+ }
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+ device.buffer = capture_opts->default_options.buffer_size;
+#endif
+ device.pmode = capture_opts->default_options.promisc_mode;
+ device.has_snaplen = capture_opts->default_options.has_snaplen;
+ device.snaplen = capture_opts->default_options.snaplen;
+ device.cfilter = g_strdup(capture_opts->default_options.cfilter);
+ cap_settings = capture_get_cap_settings(if_info->name);
+ caps = capture_get_if_capabilities(if_info->name, cap_settings.monitor_mode, NULL);
+ for (; (curr_addr = g_slist_nth(if_info->addrs, ips)) != NULL; ips++) {
+ temp_addr = g_malloc0(sizeof(if_addr_t));
+ if (ips != 0) {
+ g_string_append(ip_str, "\n");
+ }
+ addr = (if_addr_t *)curr_addr->data;
+ if (addr) {
+ temp_addr->ifat_type = addr->ifat_type;
+ switch (addr->ifat_type) {
+ case IF_AT_IPv4:
+ temp_addr->addr.ip4_addr = addr->addr.ip4_addr;
+ g_string_append(ip_str, ip_to_str((guint8 *)&addr->addr.ip4_addr));
+ break;
+ case IF_AT_IPv6:
+ memcpy(temp_addr->addr.ip6_addr, addr->addr.ip6_addr, sizeof(addr->addr));
+ g_string_append(ip_str, ip6_to_str((struct e_in6_addr *)&addr->addr.ip6_addr));
+ break;
+ default:
+ /* In case we add non-IP addresses */
+ break;
+ }
+ } else {
+ g_free(temp_addr);
+ temp_addr = NULL;
+ }
+ if (temp_addr) {
+ temp->addrs = g_slist_append(temp->addrs, temp_addr);
+ }
+ }
+#ifdef HAVE_PCAP_REMOTE
+ device.remote_opts.src_type = CAPTURE_IFLOCAL;
+#endif
+ linktype_count = 0;
+ device.links = NULL;
+ if (caps != NULL) {
+#ifdef HAVE_PCAP_CREATE
+ device.monitor_mode_enabled = cap_settings.monitor_mode;
+ device.monitor_mode_supported = caps->can_set_rfmon;
+#endif
+ for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
+ data_link_info = lt_entry->data;
+ if (data_link_info->description != NULL) {
+ str = g_strdup_printf("%s", data_link_info->description);
+ } else {
+ str = g_strdup_printf("%s (not supported)", data_link_info->name);
+ }
+ if (linktype_count == 0) {
+ device.active_dlt = data_link_info->dlt;
+ }
+ link = (link_row *)g_malloc(sizeof(link_row));
+ link->dlt = data_link_info->dlt;
+ link->name = g_strdup(str);
+ device.links = g_list_append(device.links, link);
+ linktype_count++;
+ }
+ } else {
+ cap_settings.monitor_mode = FALSE;
+#ifdef HAVE_PCAP_CREATE
+ device.monitor_mode_enabled = FALSE;
+ device.monitor_mode_supported = FALSE;
+#endif
+ device.active_dlt = -1;
+ }
+ device.addresses = g_strdup(ip_str->str);
+ device.no_addresses = ips;
+ device.type = IF_LOCAL;
+ device.if_info = *temp;
+ device.last_packets = 0;
+
+ if (capture_opts->all_ifaces->len <= count) {
+ g_array_append_val(capture_opts->all_ifaces, device);
+ count = capture_opts->all_ifaces->len;
+ } else {
+ g_array_insert_val(capture_opts->all_ifaces, count, device);
+ }
+ if (caps != NULL) {
+ free_if_capabilities(caps);
+ }
+
+ g_string_free(ip_str, TRUE);
+ count++;
+ }
+ free_interface_list(if_list);
+}
+
+void hide_interface(gchar* new_hide)
+{
+ gchar *tok;
+ guint i;
+ interface_t device;
+ gboolean found = FALSE;
+ GList *hidden_devices = NULL, *entry;
+ if (new_hide != NULL) {
+ for (tok = strtok (new_hide, ","); tok; tok = strtok(NULL, ",")) {
+ hidden_devices = g_list_append(hidden_devices, tok);
+ }
+ }
+ for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
+ found = FALSE;
+ for (entry = hidden_devices; entry != NULL; entry = g_list_next(entry)) {
+ if (strcmp(entry->data, device.name)==0) {
+ device.hidden = TRUE;
+ if (device.selected) {
+ device.selected = FALSE;
+ global_capture_opts.num_selected--;
+ }
+ found = TRUE;
+ break;
+ }
+ }
+ if (!found) {
+ device.hidden = FALSE;
+ }
+ 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);
+ }
+}
+#endif
#define __MAIN_H__
#include "globals.h"
+#include "capture_opts.h"
/** @defgroup main_window_group Main window
* The main window has the following submodules:
extern GtkWidget *pkt_scrollw;
+void hide_interface(gchar* new_hide);
+
#endif /* __MAIN_H__ */
#endif
/* XXX */
-extern gint if_list_comparator_alph (const void *first_arg, const void *second_arg);
-
static GtkWidget *welcome_hb = NULL;
static GtkWidget *header_lb = NULL;
/* Foreground colors are set using Pango markup */
#endif
static GtkWidget *welcome_file_panel_vb = NULL;
#ifdef HAVE_LIBPCAP
-static GtkWidget *welcome_if_panel_vb = NULL;
static GtkWidget *if_view = NULL;
static GtkWidget *swindow;
-static GArray *interfaces = NULL;
#endif
static GSList *status_messages = NULL;
welcome_item_enter_cb(GtkWidget *eb, GdkEventCrossing *event _U_, gpointer user_data _U_)
{
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_entered_bg);
+ gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_entered_bg);
#else
- gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_item_entered_bg);
+ gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_item_entered_bg);
#endif
return FALSE;
}
welcome_item_leave_cb(GtkWidget *eb, GdkEventCrossing *event _U_, gpointer user_data _U_)
{
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_idle_bg);
+ gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_idle_bg);
#else
gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_item_idle_bg);
#endif
eb = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(eb), item_hb);
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_idle_bg);
+ gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_idle_bg);
#else
gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_item_idle_bg);
#endif
if(tooltip != NULL) {
- gtk_widget_set_tooltip_text(eb, tooltip);
+ gtk_widget_set_tooltip_text(eb, tooltip);
}
g_signal_connect(eb, "enter-notify-event", G_CALLBACK(welcome_item_enter_cb), NULL);
gtk_box_pack_start(GTK_BOX(item_vb), item_hb, FALSE, FALSE, 10);
/*icon = xpm_to_widget_from_parent(top_level, wssplash_xpm);*/
- icon = xpm_to_widget(wssplash_xpm);
+ icon = xpm_to_widget(wssplash_xpm);
gtk_box_pack_start(GTK_BOX(item_hb), icon, FALSE, FALSE, 10);
header_lb = gtk_label_new(NULL);
eb = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(eb), w);
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_header_bg);
+ gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_header_bg);
#else
gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_header_bg);
#endif
topic_eb = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(topic_eb), topic_vb);
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(topic_eb, GTK_STATE_NORMAL, &rgba_topic_content_bg);
+ gtk_widget_override_background_color(topic_eb, GTK_STATE_NORMAL, &rgba_topic_content_bg);
#else
gtk_widget_modify_bg(topic_eb, GTK_STATE_NORMAL, &topic_content_bg);
#endif
g_mutex_lock(recent_mtx);
#endif
if (ri_stat->timer) {
- g_source_remove(ri_stat->timer);
- ri_stat->timer = 0;
+ g_source_remove(ri_stat->timer);
+ ri_stat->timer = 0;
}
g_object_unref(ri_stat->menu_item);
if (ri_stat->stat_done) {
- g_free(ri_stat->filename);
- g_string_free(ri_stat->str, TRUE);
- g_free(ri_stat);
+ g_free(ri_stat->filename);
+ g_string_free(ri_stat->str, TRUE);
+ g_free(ri_stat);
} else {
ri_stat->label = NULL;
}
{
guint i;
gchar *if_name;
- gboolean found = FALSE;
+ interface_t device;
- GtkTreeSelection *selection = (GtkTreeSelection *)userdata;
+ GtkTreeSelection *selection = (GtkTreeSelection *)userdata;
+ device.name = NULL;
gtk_tree_model_get (model, iter, IFACE_NAME, &if_name, -1);
- for (i = 0; i < global_capture_opts.ifaces->len; i++) {
- if (strcmp(g_array_index(global_capture_opts.ifaces, interface_options, i).name, if_name) == 0) {
- if (!gtk_tree_selection_path_is_selected(selection, path)) {
- gtk_tree_selection_select_iter(selection, iter);
+ 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, if_name) == 0) {
+ if (device.selected && !gtk_tree_selection_path_is_selected(selection, path)) {
+ gtk_tree_selection_select_iter(selection, iter);
+ } else {
+ gtk_tree_selection_unselect_iter(selection, iter);
}
- found = TRUE;
break;
}
}
- if (!found) {
- gtk_tree_selection_unselect_iter(selection, iter);
- }
return FALSE;
}
{
GtkTreeIter iter;
gchar *if_name;
- interface_options interface_opts;
- guint i, j;
- cap_settings_t cap_settings;
- gboolean found = FALSE;
- displayed_interface d_interface;
-
- d_interface.name = NULL;
- d_interface.descr = NULL;
+ guint i;
+ interface_t device;
+
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, IFACE_NAME, &if_name, -1);
- if (global_capture_opts.ifaces->len > 0) {
- for (i = 0; i < global_capture_opts.ifaces->len; i++) {
- if (strcmp(g_array_index(global_capture_opts.ifaces, interface_options, i).name, if_name) == 0) {
- found = TRUE;
+ 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, if_name) == 0) {
+ if (!device.locked) {
if (path_currently_selected) {
- interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
- global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
- if (gtk_widget_is_focus(g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES)) && interfaces_dialog_window_present()) {
- update_selected_interface(g_strdup(interface_opts.name), FALSE);
+ if (device.selected) {
+ device.selected = FALSE;
+ device.locked = TRUE;
+ global_capture_opts.num_selected--;
}
- if (gtk_widget_is_focus(g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES)) && dlg_window_present()) {
- enable_selected_interface(interface_opts.name, FALSE);
- }
- g_free(interface_opts.name);
- g_free(interface_opts.descr);
- g_free(interface_opts.cfilter);
-#ifdef HAVE_PCAP_REMOTE
- g_free(interface_opts.remote_host);
- g_free(interface_opts.remote_port);
- g_free(interface_opts.auth_username);
- g_free(interface_opts.auth_password);
-#endif
- break;
- }
- }
- }
- }
- if (!found && !path_currently_selected) {
- for (j = 0; j < interfaces->len; j++) {
- d_interface = g_array_index(interfaces, displayed_interface, j);
- if (strcmp(d_interface.name, if_name) == 0) {
- interface_opts.name = g_strdup(d_interface.name);
- interface_opts.descr = g_strdup(d_interface.descr);
- interface_opts.linktype = capture_dev_user_linktype_find(interface_opts.name);
- interface_opts.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
- interface_opts.has_snaplen = global_capture_opts.default_options.has_snaplen;
- interface_opts.snaplen = global_capture_opts.default_options.snaplen;
- cap_settings = capture_get_cap_settings (interface_opts.name);;
- interface_opts.promisc_mode = global_capture_opts.default_options.promisc_mode;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
- interface_opts.buffer_size = global_capture_opts.default_options.buffer_size;
-#endif
- interface_opts.monitor_mode = cap_settings.monitor_mode;
-#ifdef HAVE_PCAP_REMOTE
- if (d_interface.remote_opts.src_type == CAPTURE_IFREMOTE) {
- interface_opts.src_type = d_interface.remote_opts.src_type;
- interface_opts.remote_host = g_strdup(d_interface.remote_opts.remote_host_opts.remote_host);
- interface_opts.remote_port = g_strdup(d_interface.remote_opts.remote_host_opts.remote_port);
- interface_opts.auth_type = d_interface.remote_opts.remote_host_opts.auth_type;
- interface_opts.auth_username = g_strdup(d_interface.remote_opts.remote_host_opts.auth_username);
- interface_opts.auth_password = g_strdup(d_interface.remote_opts.remote_host_opts.auth_password);
- interface_opts.datatx_udp = d_interface.remote_opts.remote_host_opts.datatx_udp;
- interface_opts.nocap_rpcap = d_interface.remote_opts.remote_host_opts.nocap_rpcap;
- interface_opts.nocap_local = d_interface.remote_opts.remote_host_opts.nocap_local;
-#ifdef HAVE_PCAP_SETSAMPLING
- interface_opts.sampling_method = d_interface.remote_opts.sampling_method;
- interface_opts.sampling_param = d_interface.remote_opts.sampling_param;
-#endif
} else {
- interface_opts.src_type = global_capture_opts.default_options.src_type;
- interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
- interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
- interface_opts.auth_type = global_capture_opts.default_options.auth_type;
- interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
- interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
- interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
- interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
- interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
-#ifdef HAVE_PCAP_SETSAMPLING
- interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
- interface_opts.sampling_param = global_capture_opts.default_options.sampling_param;
-#endif
+ if (!device.selected) {
+ device.selected = TRUE;
+ device.locked = TRUE;
+ global_capture_opts.num_selected++;
+ }
}
-#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);
- g_array_append_val(global_capture_opts.ifaces, interface_opts);
- if (gtk_widget_is_focus(g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES)) && interfaces_dialog_window_present()) {
- update_selected_interface(g_strdup(interface_opts.name), TRUE);
+ if (dlg_window_present()) {
+ enable_selected_interface(strdup(if_name), device.selected);
}
- if (gtk_widget_is_focus(g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES)) && dlg_window_present()) {
- enable_selected_interface(interface_opts.name, TRUE);
+ if (interfaces_dialog_window_present()) {
+ update_selected_interface(g_strdup(if_name));
}
- break;
+ device.locked = FALSE;
+ 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);
}
+ break;
}
}
return TRUE;
{
guint i;
- if (interfaces) {
- for (i = 0; i < interfaces->len; i++) {
- change_interface_selection(g_array_index(interfaces, displayed_interface, i).name, enable);
- }
+ for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
+ change_interface_selection(g_array_index(global_capture_opts.all_ifaces, interface_t, i).name, enable);
}
}
#endif
GtkTreeModel *model;
GtkTreeSelection *entry;
- if (global_capture_opts.ifaces->len > 0 && swindow) {
+ if (global_capture_opts.num_selected > 0 && swindow) {
view = g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES);
model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
entry = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
#ifdef HAVE_PCAP_REMOTE
void
-add_interface_to_list(gchar *name, gchar *descr, remote_options *remote_opts)
+add_interface_to_list(guint index)
{
GtkWidget *view, *icon;
GtkTreeModel *model;
GtkTreeIter iter;
gint size;
gchar *lines;
- displayed_interface d_interface;
-
- d_interface.name = g_strdup(name);
- d_interface.descr = g_strdup(descr);
- d_interface.remote_opts.src_type = remote_opts->src_type;
- d_interface.remote_opts.remote_host_opts.remote_host = g_strdup(remote_opts->remote_host_opts.remote_host);
- d_interface.remote_opts.remote_host_opts.remote_port = g_strdup(remote_opts->remote_host_opts.remote_port);
- d_interface.remote_opts.remote_host_opts.auth_type = remote_opts->remote_host_opts.auth_type;
- d_interface.remote_opts.remote_host_opts.auth_username = g_strdup(remote_opts->remote_host_opts.auth_username);
- d_interface.remote_opts.remote_host_opts.auth_password = g_strdup(remote_opts->remote_host_opts.auth_password);
- d_interface.remote_opts.remote_host_opts.datatx_udp = remote_opts->remote_host_opts.datatx_udp;
- d_interface.remote_opts.remote_host_opts.nocap_rpcap = remote_opts->remote_host_opts.nocap_rpcap;
- d_interface.remote_opts.remote_host_opts.nocap_local = remote_opts->remote_host_opts.nocap_local;
-#ifdef HAVE_PCAP_SETSAMPLING
- d_interface.remote_opts.sampling_method = remote_opts->sampling_method;
- d_interface.remote_opts.sampling_param = remote_opts->sampling_param;
-#endif
+ interface_t device;
+
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, index);
icon = pixbuf_to_widget(remote_sat_pb_data);
- d_interface.icon = icon;
view = g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES);
model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
size = gtk_tree_model_iter_n_children(model, NULL);
lines = g_strdup_printf("%d", size-1);
- g_array_append_val(interfaces, d_interface);
if (gtk_tree_model_get_iter_from_string(model, &iter, lines)) {
gtk_list_store_append (GTK_LIST_STORE(model), &iter);
- gtk_list_store_set(GTK_LIST_STORE(model), &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(icon)), IFACE_DESCR, descr, IFACE_NAME, name, -1);
+ gtk_list_store_set(GTK_LIST_STORE(model), &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(icon)), IFACE_DESCR, device.display_name, IFACE_NAME, device.name, -1);
}
}
#endif
welcome_if_tree_load(void)
{
#ifdef HAVE_LIBPCAP
- if_info_t *if_info;
- GList *if_list;
- int err;
guint i;
- gchar *err_str = NULL;
- GList *curr;
- gchar *user_descr;
GtkListStore *store = NULL;
GtkTreeIter iter;
- GtkWidget *icon, *view;
+ GtkWidget *view;
GtkTreeSelection *entry;
- displayed_interface d_interface;
+ interface_t device;
+ gboolean changed = FALSE;
view = g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES);
entry = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_unselect_all(entry);
store = gtk_list_store_new(NUMCOLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
+ gtk_list_store_clear(store);
+ gtk_tree_view_set_model(GTK_TREE_VIEW(if_view), GTK_TREE_MODEL (store));
/* LOAD THE INTERFACES */
- if (interfaces && interfaces->len > 0) {
- for (i = 0; i < interfaces->len; i++) {
- d_interface = g_array_index(interfaces, displayed_interface, i);
- gtk_list_store_append (store, &iter);
- gtk_list_store_set (store, &iter, ICON, d_interface.icon, IFACE_DESCR, d_interface.descr, IFACE_NAME, d_interface.name, -1);
- }
+ if (global_capture_opts.all_ifaces->len == 0) {
+ scan_local_interfaces(&global_capture_opts);
} else {
- interfaces = g_array_new(TRUE, TRUE, sizeof(displayed_interface));
- if_list = capture_interface_list(&err, &err_str);
- if_list = g_list_sort (if_list, if_list_comparator_alph);
- if (if_list == NULL && err == CANT_GET_INTERFACE_LIST) {
- simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
- g_free(err_str);
- return;
- } else if (err_str) {
- g_free(err_str);
- }
- if (g_list_length(if_list) > 0) {
- /* List the interfaces */
- for (curr = g_list_first(if_list); curr; curr = g_list_next(curr)) {
- if_info = curr->data;
- /* Continue if capture device is hidden */
- if (prefs_is_capture_device_hidden(if_info->name)) {
- continue;
- }
+ 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) {
gtk_list_store_append (store, &iter);
- d_interface.name = g_strdup(if_info->name);
-#ifdef HAVE_PCAP_REMOTE
- d_interface.remote_opts.src_type = CAPTURE_IFLOCAL;
-#endif
-#ifdef HAVE_AIRPCAP
- if (get_airpcap_if_from_name(airpcap_if_list,if_info->name) != NULL)
- icon = xpm_to_widget(capture_airpcap_16_xpm);
- else
- icon = capture_get_if_icon(if_info);
-#else
- icon = capture_get_if_icon(if_info);
-#endif
- d_interface.icon = icon;
- user_descr = capture_dev_user_descr_find(if_info->name);
- if (user_descr) {
-#ifndef _WIN32
- gchar *comment = user_descr;
- user_descr = g_strdup_printf("%s (%s)", comment, if_info->name);
- g_free (comment);
-#endif
- gtk_list_store_set(store, &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(icon)), IFACE_DESCR, user_descr, IFACE_NAME, if_info->name, -1);
- d_interface.descr = g_strdup(user_descr);
- g_free (user_descr);
- } else if (if_info->description) {
- gtk_list_store_set (store, &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(icon)), IFACE_DESCR, if_info->description, IFACE_NAME, if_info->name, -1);
- d_interface.descr = g_strdup(if_info->description);
- } else {
- gtk_list_store_set (store, &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(icon)), IFACE_DESCR, if_info->name, IFACE_NAME, if_info->name, -1);
- d_interface.descr = g_strdup(if_info->name);
- }
- g_array_append_val(interfaces, d_interface);
+ gtk_list_store_set (store, &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(capture_get_if_icon(&(device.if_info)))), IFACE_DESCR, device.display_name, IFACE_NAME, device.name, -1);
+ }
+ if (device.selected) {
+ gtk_tree_selection_select_iter(entry, &iter);
}
}
- free_interface_list(if_list);
- gtk_tree_view_set_model(GTK_TREE_VIEW(if_view), GTK_TREE_MODEL (store));
- if (global_capture_opts.ifaces->len > 0) {
- gtk_tree_model_foreach(GTK_TREE_MODEL(store), select_current_ifaces, (gpointer) entry);
- gtk_widget_grab_focus(view);
- }
- gtk_tree_selection_set_select_function(entry, on_selection_changed, NULL, NULL);
+ changed = TRUE;
+ }
+ gtk_tree_selection_set_select_function(entry, on_selection_changed, (gpointer)&changed, NULL);
+ if (gtk_widget_is_focus(view) && dlg_window_present()) {
+ update_all_rows();
}
#endif /* HAVE_LIBPCAP */
}
welcome_if_panel_reload(void)
{
#ifdef HAVE_LIBPCAP
- GtkWidget *child_box;
- GList* child_list;
- GList* child_list_item;
-
- if(welcome_if_panel_vb) {
- child_box = scroll_box_dynamic_reset(welcome_if_panel_vb);
- child_list = gtk_container_get_children(GTK_CONTAINER(child_box));
- child_list_item = child_list;
-
- while(child_list_item) {
- gtk_container_remove(GTK_CONTAINER(child_box), child_list_item->data);
- child_list_item = g_list_next(child_list_item);
- }
-
- g_list_free(child_list);
+ if (welcome_hb) {
welcome_if_tree_load();
- gtk_widget_show_all(welcome_if_panel_vb);
+ gtk_widget_show_all(welcome_hb);
}
#endif /* HAVE_LIBPCAP */
}
static void capture_if_start(GtkWidget *w _U_, gpointer data _U_)
{
#ifdef HAVE_AIRPCAP
- interface_options interface_opts;
+ interface_t device;
+ guint i;
#endif
-
- if (global_capture_opts.ifaces->len == 0) {
+ if (global_capture_opts.num_selected == 0) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"You didn't specify an interface on which to capture packets.");
return;
}
#ifndef USE_THREADS
- if (global_capture_opts.ifaces->len > 1) {
+ if (global_capture_opts.num_selected > 1) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"You specified multiple interfaces for capturing which this version of Wireshark doesn't support.");
return;
g_free(global_capture_opts.save_file);
global_capture_opts.save_file = NULL;
}
-#ifdef HAVE_AIRPCAP
- interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, 0);
- airpcap_if_active = get_airpcap_if_from_name(airpcap_if_list, interface_opts.name);
- airpcap_if_selected = airpcap_if_active;
+#ifdef HAVE_AIRPCAP /* TODO: don't let it depend on interface_opts */
+ for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
+ device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
+ airpcap_if_active = get_airpcap_if_from_name(airpcap_if_list, device.name);
+ airpcap_if_selected = airpcap_if_active;
+ if (airpcap_if_selected) {
+ break;
+ }
+ }
airpcap_set_toolbar_start_capture(airpcap_if_active);
#endif
capture_start_cb(NULL, NULL);
GtkTreeSelection *selection;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
- GList *if_list;
- int err;
- gchar *err_str = NULL;
#endif
/* prepare colors */
#if 0
- /* Allocating collor isn't necessary? */
+ /* Allocating color isn't necessary? */
/* "page" background */
get_color(&welcome_bg);
topic_item_idle_bg = topic_content_bg;
#endif
#if 0
- /* Allocating collor isn't necessary? */
+ /* Allocating color isn't necessary? */
/* topic item entered color */
get_color(&topic_item_entered_bg);
#endif
welcome_eb = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(welcome_eb), welcome_vb);
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(welcome_eb, GTK_STATE_NORMAL, &rgba_welcome_bg);
+ gtk_widget_override_background_color(welcome_eb, GTK_STATE_NORMAL, &rgba_welcome_bg);
#else
- gtk_widget_modify_bg(welcome_eb, GTK_STATE_NORMAL, &welcome_bg);
+ gtk_widget_modify_bg(welcome_eb, GTK_STATE_NORMAL, &welcome_bg);
#endif
/* header */
header = welcome_header_new();
/* column capture */
column_vb = gtk_vbox_new(FALSE, 10);
#if GTK_CHECK_VERSION(3,0,0)
- gtk_widget_override_background_color(column_vb, GTK_STATE_NORMAL, &rgba_welcome_bg);
+ gtk_widget_override_background_color(column_vb, GTK_STATE_NORMAL, &rgba_welcome_bg);
#else
gtk_widget_modify_bg(column_vb, GTK_STATE_NORMAL, &welcome_bg);
#endif
gtk_box_pack_start(GTK_BOX(column_vb), topic_vb, TRUE, TRUE, 0);
#ifdef HAVE_LIBPCAP
- if_list = capture_interface_list(&err, &err_str);
- if (g_list_length(if_list) > 0) {
+ if (global_capture_opts.all_ifaces->len == 0) {
+ scan_local_interfaces(&global_capture_opts);
+ }
+ if (global_capture_opts.all_ifaces->len > 0) {
item_hb = welcome_button(WIRESHARK_STOCK_CAPTURE_INTERFACES,
"Interface List",
"Live list of the capture interfaces\n(counts incoming packets)",
g_object_set(G_OBJECT(if_view), "headers-visible", FALSE, NULL);
g_signal_connect(if_view, "row-activated", G_CALLBACK(options_interface_cb), (gpointer)welcome_hb);
g_object_set_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES, if_view);
+ column = gtk_tree_view_column_new();
renderer = gtk_cell_renderer_pixbuf_new();
- column = gtk_tree_view_column_new_with_attributes ("",
- GTK_CELL_RENDERER(renderer),
- "pixbuf", ICON,
- NULL);
- gtk_tree_view_append_column(GTK_TREE_VIEW(if_view), column);
+ gtk_tree_view_column_pack_start(column, renderer, FALSE);
+ gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", ICON, NULL);
renderer = gtk_cell_renderer_text_new();
- column = gtk_tree_view_column_new_with_attributes ("",
- GTK_CELL_RENDERER(renderer),
- "text", IFACE_DESCR,
- NULL);
+ gtk_tree_view_column_pack_start(column, renderer, TRUE);
+ gtk_tree_view_column_set_attributes(column, renderer, "text", IFACE_DESCR, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(if_view), column);
gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(if_view), 0), TRUE);
renderer = gtk_cell_renderer_text_new();
gtk_box_pack_start(GTK_BOX(topic_to_fill), w, FALSE, FALSE, 5);
}
- free_interface_list(if_list);
-
/* capture help topic */
topic_vb = welcome_topic_new("Capture Help", &topic_to_fill);
gtk_box_pack_start(GTK_BOX(column_vb), topic_vb, TRUE, TRUE, 0);
return welcome_hb;
}
-#ifdef HAVE_LIBPCAP
-displayed_interface get_interface_data(gint index)
-{
- return g_array_index(interfaces, displayed_interface, index);
-}
-#endif
gboolean activate;
} selected_name_t;
-typedef struct displayed_interface_s {
- gchar *name;
- gchar *descr;
- GtkWidget *icon;
-#ifdef HAVE_PCAP_REMOTE
- remote_options remote_opts;
-#endif
-} displayed_interface;
-
GtkWidget *welcome_new(void);
/* reset the list of recently used files */
/* reload the list of interfaces */
void welcome_if_panel_reload(void);
+void welcome_if_tree_load(void);
+
/** Push a status message into the welcome screen header similar to
* statusbar_push_*_msg(). This hides everything under the header.
* If msg is dynamically allocated, it is up to the caller to free
void change_selection_for_all(gboolean enable);
+void update_welcome_list(void);
+
#ifdef HAVE_PCAP_REMOTE
-void add_interface_to_list(gchar *name, gchar *descr, remote_options *remote_opts);
+void add_interface_to_list(guint index);
#endif
-displayed_interface get_interface_data(gint index);
-
#endif /* __MAIN_WELCOME_H__ */
g_free(new_hide);
prefs.capture_devices_hide = NULL;
}
+ hide_interface(strdup(new_hide));
}
}
git.samba.org / metze / wireshark / wip.git / commitdiff