From 95ae2fe13a49c6f8bdf95554b9488f4a5160ebcd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20T=C3=BCxen?= Date: Thu, 20 Oct 2011 18:17:54 +0000 Subject: Use a global list containing all interfaces and only change properties of the entries when changes are made in the GUI. Do not misuse the list of interfaces specified on the command line anymore. This patch does not provide any new functionality, it just provides the base for future extensions like removing remote interface, mulitple airpcap devices and multiple pipes. This patch was provided by Irene Ruengeler. svn path=/trunk/; revision=39495 --- gtk/capture_dlg.c | 1045 +++++++++++++++----------------------------------- gtk/capture_dlg.h | 59 +-- gtk/capture_if_dlg.c | 462 +++++++++------------- gtk/capture_if_dlg.h | 5 +- gtk/main.c | 483 ++++++++++++++++------- gtk/main.h | 3 + gtk/main_welcome.c | 363 +++++------------- gtk/main_welcome.h | 17 +- gtk/prefs_capture.c | 1 + 9 files changed, 963 insertions(+), 1475 deletions(-) (limited to 'gtk') diff --git a/gtk/capture_dlg.c b/gtk/capture_dlg.c index 6980a1779e..6901359302 100644 --- a/gtk/capture_dlg.c +++ b/gtk/capture_dlg.c @@ -184,8 +184,6 @@ static GtkWidget *cap_open_w = NULL, *opt_edit_w = NULL, *ok_bt; 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 @@ -220,9 +218,6 @@ capture_dlg_prep(gpointer parent_w); 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_) @@ -816,7 +811,7 @@ error_list_remote_interface_cb (gpointer dialog _U_, gint btn _U_, gpointer data void insert_new_rows(GList *list) { - interface_row row; + interface_t device; GtkTreeIter iter; GList *if_entry; if_info_t *if_info; @@ -827,7 +822,7 @@ void insert_new_rows(GList *list) 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; @@ -836,21 +831,19 @@ void insert_new_rows(GList *list) 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; } @@ -862,7 +855,7 @@ void insert_new_rows(GList *list) 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); @@ -882,37 +875,17 @@ void insert_new_rows(GList *list) } } /* 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); @@ -935,11 +908,11 @@ void insert_new_rows(GList *list) } } /* 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; @@ -950,63 +923,62 @@ void insert_new_rows(GList *list) } 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("%s", row.display_name); + temp = g_strdup_printf("%s", device.display_name); } else { - temp = g_strdup_printf("%s\n%s", row.display_name, row.addresses); + temp = g_strdup_printf("%s\n%s", 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); @@ -1332,19 +1304,19 @@ options_remote_ok_cb(GtkWidget *win _U_, GtkWidget *parent_w) 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 @@ -1355,16 +1327,16 @@ options_remote_ok_cb(GtkWidget *win _U_, GtkWidget *parent_w) 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*/ @@ -1406,7 +1378,7 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_) 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); @@ -1415,7 +1387,7 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_) 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); @@ -1434,12 +1406,12 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_) 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 @@ -1458,7 +1430,7 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_) /* "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); @@ -1467,14 +1439,14 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_) /* "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); @@ -1487,14 +1459,14 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_) /* "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); @@ -1689,10 +1661,7 @@ options_edit_destroy_cb(GtkWidget *win, gpointer user_data _U_) 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; @@ -1702,122 +1671,78 @@ update_options_table(gint index) 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("%s", device.display_name); + } else { + temp = g_strdup_printf("%s\n%s", 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("%s", row.display_name); - } else { - temp = g_strdup_printf("%s\n%s", 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_) { @@ -1830,13 +1755,13 @@ 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) @@ -1856,31 +1781,31 @@ save_options_cb(GtkWidget *win _U_, gpointer user_data _U_) 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); } @@ -1889,10 +1814,10 @@ static void 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); @@ -1901,8 +1826,8 @@ adjust_snap_sensitivity(GtkWidget *tb _U_, gpointer parent_w _U_) 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) @@ -1940,14 +1865,12 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum #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; @@ -1960,43 +1883,30 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum 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); @@ -2020,7 +1930,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum 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 */ @@ -2035,9 +1945,8 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum 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); @@ -2118,7 +2027,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum 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), @@ -2126,7 +2035,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum 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; } @@ -2142,7 +2051,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum 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. " @@ -2153,8 +2062,8 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum #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, @@ -2180,14 +2089,14 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum 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); @@ -2199,7 +2108,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum 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); @@ -2232,8 +2141,8 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum 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); } @@ -2260,10 +2169,10 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum 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, @@ -2287,7 +2196,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum /* 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); @@ -2302,7 +2211,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum /* 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); @@ -2347,198 +2256,94 @@ static void toggle_callback(GtkCellRendererToggle *cell _U_, 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 { @@ -2564,17 +2369,17 @@ static void capture_all_cb(GtkToggleButton *button, gpointer d _U_) 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()) { @@ -2584,9 +2389,9 @@ static void capture_all_cb(GtkToggleButton *button, gpointer d _U_) 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 { @@ -2601,7 +2406,7 @@ static void promisc_mode_callback(GtkToggleButton *button, gpointer d _U_) GtkTreeView *if_cb; GtkTreeModel *model; gboolean enabled = FALSE; - interface_row row; + interface_t device; interface_options interface_opts; guint i; @@ -2616,11 +2421,11 @@ static void promisc_mode_callback(GtkToggleButton *button, gpointer d _U_) } 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++) { @@ -2716,6 +2521,8 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_) *help_bt; #ifdef HAVE_AIRPCAP GtkWidget *decryption_cb; + int err; + gchar *err_str; #endif #ifdef HAVE_PCAP_REMOTE GtkWidget *iftype_cbx; @@ -2724,10 +2531,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_) 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; @@ -2758,7 +2562,6 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_) return; } #endif - num_selected = 0; /* use user-defined title if preference is set */ cap_title = create_user_window_title("Wireshark: Capture Options"); @@ -2767,13 +2570,6 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_) 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 */ @@ -2824,6 +2620,13 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_) 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); @@ -2874,7 +2677,6 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_) 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); @@ -3244,9 +3046,9 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_) 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 { @@ -3328,7 +3130,7 @@ capture_start_confirmed(void) 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" @@ -3380,10 +3182,6 @@ void 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; @@ -3419,60 +3217,10 @@ capture_start_cb(GtkWidget *w _U_, gpointer d _U_) 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) { @@ -3495,18 +3243,18 @@ select_link_type_cb(GtkWidget *linktype_combo_box, gpointer data _U_) { 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); } @@ -3564,7 +3312,7 @@ capture_dlg_prep(gpointer parent_w) { 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; @@ -3708,219 +3456,50 @@ capture_dlg_prep(gpointer parent_w) { 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("%s", 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("%s", device.display_name); } else { - temp = g_strdup_printf("%s\n%s", row.display_name, row.addresses); + temp = g_strdup_printf("%s\n%s", 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 } } @@ -4007,13 +3586,13 @@ gboolean query_tooltip_tree_view_cb (GtkWidget *widget, 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); @@ -4074,16 +3653,16 @@ capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp _U_) 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); @@ -4091,15 +3670,15 @@ capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp _U_) 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; @@ -4109,7 +3688,7 @@ capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp _U_) 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 { @@ -4125,7 +3704,7 @@ capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp _U_) 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); @@ -4133,13 +3712,13 @@ capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp _U_) /* 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 diff --git a/gtk/capture_dlg.h b/gtk/capture_dlg.h index c782596504..a3bb194c0b 100644 --- a/gtk/capture_dlg.h +++ b/gtk/capture_dlg.h @@ -32,60 +32,12 @@ * @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 enum { CAPTURE = 0, + IFACE_HIDDEN_NAME, INTERFACE, LINK, PMODE, @@ -143,6 +95,7 @@ void capture_start_confirmed(void); 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 @@ -163,6 +116,7 @@ typedef struct { */ cap_settings_t capture_get_cap_settings (gchar *if_name); +#endif GtkTreeModel* create_and_fill_model (GtkTreeView *view); @@ -202,9 +156,12 @@ gboolean 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 */ diff --git a/gtk/capture_if_dlg.c b/gtk/capture_if_dlg.c index 7afacaa1c6..527a604c89 100644 --- a/gtk/capture_if_dlg.c +++ b/gtk/capture_if_dlg.c @@ -110,15 +110,13 @@ */ 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; @@ -130,6 +128,7 @@ 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; @@ -139,128 +138,65 @@ typedef struct if_dlg_data_s { #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 } } @@ -273,19 +209,18 @@ capture_do_cb(GtkWidget *capture_bt _U_, gpointer if_data) 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? */ @@ -331,11 +266,14 @@ capture_details_cb(GtkWidget *details_bt _U_, gpointer if_data) /* 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; /* @@ -346,23 +284,40 @@ update_if(if_dlg_data_t *if_dlg_data, if_stat_cache_t *sc) * 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); } } } @@ -371,16 +326,17 @@ update_if(if_dlg_data_t *if_dlg_data, if_stat_cache_t *sc) 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; @@ -394,9 +350,9 @@ set_capture_if_dialog_for_capture_in_progress(gboolean capture_in_progress) 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 } } @@ -406,17 +362,8 @@ set_capture_if_dialog_for_capture_in_progress(gboolean capture_in_progress) 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. */ @@ -701,17 +648,41 @@ static void 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 @@ -721,30 +692,23 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_) *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. */ @@ -763,43 +727,13 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_) 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) { @@ -815,6 +749,7 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_) 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); @@ -862,142 +797,109 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_) 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; } } @@ -1017,9 +919,9 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_) 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; @@ -1050,16 +952,14 @@ void refresh_if_window(void) 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); } } diff --git a/gtk/capture_if_dlg.h b/gtk/capture_if_dlg.h index 3c2f2359d0..253c3949c7 100644 --- a/gtk/capture_if_dlg.h +++ b/gtk/capture_if_dlg.h @@ -51,7 +51,7 @@ GtkWidget * 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); @@ -65,6 +65,9 @@ select_all_interfaces(gboolean enable); 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 */ diff --git a/gtk/main.c b/gtk/main.c index 3f5bda29c6..b8b888374a 100644 --- a/gtk/main.c +++ b/gtk/main.c @@ -114,6 +114,7 @@ #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 @@ -512,16 +513,16 @@ selected_ptree_ref_cb(GtkWidget *widget _U_, gpointer data _U_) 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 * @@ -547,17 +548,17 @@ get_ip_address_list_from_packet_list_row(gpointer data) 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); } @@ -694,7 +695,7 @@ set_frame_reftime(gboolean set, frame_data *frame, gint row) { 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--; @@ -716,8 +717,8 @@ static void reftime_answered_cb(gpointer dialog _U_, gint btn, gpointer data _U_ 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; @@ -727,7 +728,7 @@ static void reftime_answered_cb(gpointer dialog _U_, gint btn, gpointer data _U_ 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); } } @@ -1399,6 +1400,9 @@ npf_warning_dialog_cb(gpointer dialog, gint btn _U_, gpointer data _U_) 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, @@ -1417,6 +1421,14 @@ main_cf_cb_file_closing(capture_file *cf) 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"); @@ -2174,8 +2186,8 @@ main(int argc, char *argv[]) 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" @@ -2194,13 +2206,13 @@ main(int argc, char *argv[]) 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); @@ -2269,8 +2281,8 @@ main(int argc, char *argv[]) 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 && @@ -2443,6 +2455,11 @@ main(int argc, char *argv[]) /* 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) { @@ -2453,7 +2470,6 @@ main(int argc, char *argv[]) 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 */ @@ -2483,13 +2499,25 @@ main(int argc, char *argv[]) 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; @@ -2528,7 +2556,7 @@ main(int argc, char *argv[]) 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; @@ -2553,7 +2581,7 @@ main(int argc, char *argv[]) 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: @@ -2562,7 +2590,7 @@ main(int argc, char *argv[]) break; case PREFS_SET_OBSOLETE: cmdarg_err("-o flag \"%s\" specifies obsolete preference", - optarg); + optarg); exit(1); break; default: @@ -2573,9 +2601,9 @@ main(int argc, char *argv[]) /* 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 */ @@ -2626,11 +2654,11 @@ main(int argc, char *argv[]) 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 */ @@ -2717,23 +2745,18 @@ main(int argc, char *argv[]) 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 */ } } } @@ -2750,23 +2773,24 @@ main(int argc, char *argv[]) /* 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); } @@ -2787,53 +2811,20 @@ main(int argc, char *argv[]) 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 @@ -2875,8 +2866,8 @@ main(int argc, char *argv[]) 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); @@ -2998,15 +2989,15 @@ main(int argc, char *argv[]) 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 @@ -3021,7 +3012,7 @@ main(int argc, char *argv[]) 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); } @@ -3041,10 +3032,10 @@ main(int argc, char *argv[]) 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(); } @@ -3550,7 +3541,6 @@ main_widgets_show_or_hide(void) if (!have_capture_file) { if(welcome_pane) { gtk_widget_show(welcome_pane); - select_ifaces(); } } else { gtk_widget_hide(welcome_pane); @@ -3858,3 +3848,218 @@ void redissect_packets(void) 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 diff --git a/gtk/main.h b/gtk/main.h index 59b742ddfc..2b70e8a2ab 100644 --- a/gtk/main.h +++ b/gtk/main.h @@ -26,6 +26,7 @@ #define __MAIN_H__ #include "globals.h" +#include "capture_opts.h" /** @defgroup main_window_group Main window * The main window has the following submodules: @@ -365,4 +366,6 @@ extern GList *get_ip_address_list_from_packet_list_row(gpointer data); extern GtkWidget *pkt_scrollw; +void hide_interface(gchar* new_hide); + #endif /* __MAIN_H__ */ diff --git a/gtk/main_welcome.c b/gtk/main_welcome.c index 8226f5a588..82406e7fa9 100644 --- a/gtk/main_welcome.c +++ b/gtk/main_welcome.c @@ -81,8 +81,6 @@ #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 */ @@ -103,10 +101,8 @@ static GdkColor topic_item_entered_bg = { 0, 0xd3d3, 0xd8d8, 0xdada }; #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; @@ -211,9 +207,9 @@ static gboolean 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; } @@ -224,7 +220,7 @@ static gboolean 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 @@ -251,12 +247,12 @@ welcome_button(const gchar *stock_item, 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); @@ -357,7 +353,7 @@ welcome_header_new(void) 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); @@ -423,7 +419,7 @@ welcome_topic_header_new(const char *header) 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 @@ -454,7 +450,7 @@ welcome_topic_new(const char *header, GtkWidget **to_fill) 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 @@ -579,16 +575,16 @@ static void welcome_filename_destroy_cb(GtkWidget *w _U_, gpointer data) { 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; } @@ -718,22 +714,22 @@ static gboolean select_current_ifaces(GtkTreeModel *model, { 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; } @@ -745,100 +741,42 @@ gboolean on_selection_changed(GtkTreeSelection *selection _U_, { 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; @@ -885,10 +823,8 @@ void change_selection_for_all(gboolean enable) { 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 @@ -901,7 +837,7 @@ select_ifaces(void) 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)); @@ -913,40 +849,24 @@ select_ifaces(void) #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 @@ -956,91 +876,40 @@ void 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 */ } @@ -1051,23 +920,9 @@ void 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 */ } @@ -1076,16 +931,16 @@ welcome_if_panel_reload(void) 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; @@ -1097,10 +952,15 @@ static void capture_if_start(GtkWidget *w _U_, gpointer data _U_) 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); @@ -1131,14 +991,11 @@ welcome_new(void) 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); @@ -1158,7 +1015,7 @@ welcome_new(void) 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 @@ -1169,9 +1026,9 @@ welcome_new(void) 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(); @@ -1186,7 +1043,7 @@ welcome_new(void) /* 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 @@ -1197,8 +1054,10 @@ welcome_new(void) 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)", @@ -1215,17 +1074,13 @@ welcome_new(void) 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(); @@ -1286,8 +1141,6 @@ welcome_new(void) 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); @@ -1428,9 +1281,3 @@ GtkWidget* get_welcome_window(void) return welcome_hb; } -#ifdef HAVE_LIBPCAP -displayed_interface get_interface_data(gint index) -{ - return g_array_index(interfaces, displayed_interface, index); -} -#endif diff --git a/gtk/main_welcome.h b/gtk/main_welcome.h index 566f7669e2..16cb217cf2 100644 --- a/gtk/main_welcome.h +++ b/gtk/main_welcome.h @@ -40,15 +40,6 @@ typedef struct selected_name_s { 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 */ @@ -60,6 +51,8 @@ void main_welcome_add_recent_capture_file(const char *widget_cf_name, GObject *m /* 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 @@ -85,10 +78,10 @@ void change_interface_selection(gchar* name, gboolean activate); 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__ */ diff --git a/gtk/prefs_capture.c b/gtk/prefs_capture.c index 7c704732a7..c7257809bb 100644 --- a/gtk/prefs_capture.c +++ b/gtk/prefs_capture.c @@ -1434,6 +1434,7 @@ ifopts_write_new_hide(void) g_free(new_hide); prefs.capture_devices_hide = NULL; } + hide_interface(strdup(new_hide)); } } -- cgit v1.2.3