From c219f2eea54ef19c811bc1294416fb6b30a046f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20T=C3=BCxen?= Date: Thu, 20 Oct 2011 19:44:40 +0000 Subject: Back out infrastructure change. We missed supporting stdin and pipes. svn path=/trunk/; revision=39498 --- 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 | 489 +++++++---------------- gtk/main.h | 3 - gtk/main_welcome.c | 363 +++++++++++++----- gtk/main_welcome.h | 17 +- gtk/prefs_capture.c | 1 - 9 files changed, 1474 insertions(+), 970 deletions(-) (limited to 'gtk') diff --git a/gtk/capture_dlg.c b/gtk/capture_dlg.c index 6901359302..6980a1779e 100644 --- a/gtk/capture_dlg.c +++ b/gtk/capture_dlg.c @@ -184,6 +184,8 @@ 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 @@ -218,6 +220,9 @@ 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_) @@ -811,7 +816,7 @@ error_list_remote_interface_cb (gpointer dialog _U_, gint btn _U_, gpointer data void insert_new_rows(GList *list) { - interface_t device; + interface_row row; GtkTreeIter iter; GList *if_entry; if_info_t *if_info; @@ -822,7 +827,7 @@ void insert_new_rows(GList *list) cap_settings_t cap_settings; GSList *curr_addr; int ips = 0; - guint i; + guint i, count=0; if_addr_t *addr; GList *lt_entry; data_link_info_t *data_link_info; @@ -831,19 +836,21 @@ 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 < 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) { + for (i = 0; i < count; i++) { + row = g_array_index(rows, interface_row, i); + if (strcmp(row.name, if_info->name) == 0) { found = TRUE; break; } @@ -855,7 +862,7 @@ void insert_new_rows(GList *list) ip_str = g_string_new(""); str = ""; ips = 0; - device.name = g_strdup(if_info->name); + row.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); @@ -875,17 +882,37 @@ void insert_new_rows(GList *list) } } /* else descr != NULL */ if (if_info->loopback) { - device.display_name = g_strdup_printf("%s (loopback)", if_string); + row.display_name = g_strdup_printf("%s (loopback)", if_string); } else { - device.display_name = g_strdup(if_string); + 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 (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) - device.buffer = global_capture_opts.default_options.buffer_size; + row.buffer = global_capture_opts.default_options.buffer_size; #endif - 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); + 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_string); caps = capture_get_if_capabilities(if_string, cap_settings.monitor_mode, NULL); gtk_list_store_append (GTK_LIST_STORE(model), &iter); @@ -908,11 +935,11 @@ void insert_new_rows(GList *list) } } /* for curr_addr */ linktype_count = 0; - device.links = NULL; + row.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; + 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; @@ -923,62 +950,63 @@ void insert_new_rows(GList *list) } if (linktype_count == 0) { link_type_name = g_strdup(str); - device.active_dlt = data_link_info->dlt; + 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); - device.links = g_list_append(device.links, link); + row.links = g_list_append(row.links, link); linktype_count++; } /* for link_types */ } else { cap_settings.monitor_mode = FALSE; #if defined(HAVE_PCAP_CREATE) - device.monitor_mode_enabled = FALSE; - device.monitor_mode_supported = FALSE; + row.monitor_mode_enabled = FALSE; + row.monitor_mode_supported = FALSE; #endif - device.active_dlt = -1; + row.active_dlt = -1; link_type_name = g_strdup("default"); } - device.addresses = g_strdup(ip_str->str); - device.no_addresses = ips; + row.addresses = g_strdup(ip_str->str); + row.no_addresses = ips; if (ips == 0) { - temp = g_strdup_printf("%s", device.display_name); + temp = g_strdup_printf("%s", row.display_name); } else { - temp = g_strdup_printf("%s\n%s", device.display_name, device.addresses); + temp = g_strdup_printf("%s\n%s", row.display_name, row.addresses); } #ifdef HAVE_PCAP_REMOTE - 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; + 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; #endif #ifdef HAVE_PCAP_SETSAMPLING - device.remote_opts.sampling_method = global_remote_opts.sampling_method; - device.remote_opts.sampling_param = global_remote_opts.sampling_param; + row.remote_opts.sampling_method = global_remote_opts.sampling_method; + row.remote_opts.sampling_param = global_remote_opts.sampling_param; #endif - g_array_append_val(global_capture_opts.all_ifaces, device); - if (device.has_snaplen) { - snaplen_string = g_strdup_printf("%d", device.snaplen); + g_array_append_val(rows, row); + if (row.has_snaplen) { + snaplen_string = g_strdup_printf("%d", row.snaplen); } else { snaplen_string = g_strdup("default"); } #if defined(HAVE_PCAP_CREATE) - gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, (guint) global_capture_opts.default_options.buffer_size, MONITOR, "no",FILTER, "",-1); + 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); #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE) - gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, (guint) global_capture_opts.default_options.buffer_size, FILTER, "",-1); + 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); #else - gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, -1); + 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); #endif + count++; g_string_free(ip_str, TRUE); #ifdef HAVE_PCAP_REMOTE - add_interface_to_list(global_capture_opts.all_ifaces->len-1); + add_interface_to_list(if_info->name, if_info->description, &row.remote_opts); #endif } /*for*/ gtk_tree_view_set_model(GTK_TREE_VIEW(if_cb), model); @@ -1304,19 +1332,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_t device; + interface_row row; if (parent_w == NULL) return; - device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row); - g_array_remove_index(global_capture_opts.all_ifaces, marked_row); + row = g_array_index(rows, interface_row, marked_row); + g_array_remove_index(rows, 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); - device.remote_opts.remote_host_opts.datatx_udp = + row.remote_opts.remote_host_opts.datatx_udp = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(datatx_udp_cb)); - device.remote_opts.remote_host_opts.nocap_rpcap = + row.remote_opts.remote_host_opts.nocap_rpcap = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(nocap_rpcap_cb)); #ifdef HAVE_PCAP_SETSAMPLING @@ -1327,16 +1355,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))) - device.remote_opts.sampling_method = CAPTURE_SAMP_NONE; + row.remote_opts.sampling_method = CAPTURE_SAMP_NONE; else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_count_rb))) { - 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)); + 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)); } else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_timer_rb))) { - 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)); + 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)); } #endif /* HAVE_PCAP_SETSAMPLING*/ - g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device); + g_array_insert_val(rows, marked_row, row); window_destroy(GTK_WIDGET(parent_w)); } #endif /*HAVE_PCAP_REMOTE*/ @@ -1378,7 +1406,7 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_) GtkAdjustment *samp_count_adj, *samp_timer_adj; GSList *samp_group; #endif - interface_t device; + interface_row row; caller = gtk_widget_get_toplevel(w); opt_remote_w = g_object_get_data(G_OBJECT(caller), E_OPT_REMOTE_DIALOG_PTR_KEY); @@ -1387,7 +1415,7 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_) return; } - device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row); + row = g_array_index(rows, interface_row, 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); @@ -1406,12 +1434,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), - device.remote_opts.remote_host_opts.nocap_rpcap); + row.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), - device.remote_opts.remote_host_opts.datatx_udp); + row.remote_opts.remote_host_opts.datatx_udp); gtk_container_add(GTK_CONTAINER(capture_vb), datatx_udp_cb); #ifdef HAVE_PCAP_SETSAMPLING @@ -1430,7 +1458,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 (device.remote_opts.sampling_method == CAPTURE_SAMP_NONE) + if (row.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); @@ -1439,14 +1467,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 (device.remote_opts.sampling_method == CAPTURE_SAMP_BY_COUNT) + if (row.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)device.remote_opts.sampling_param, + (gfloat)row.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); @@ -1459,14 +1487,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 (device.remote_opts.sampling_method == CAPTURE_SAMP_BY_TIMER) + if (row.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)device.remote_opts.sampling_param, + (gfloat)row.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); @@ -1661,7 +1689,10 @@ options_edit_destroy_cb(GtkWidget *win, gpointer user_data _U_) static void update_options_table(gint index) { - interface_t device; + guint i; + gboolean found = FALSE; + interface_row row; + interface_options interface_opts; GtkTreePath *path; GtkTreeView *if_cb; GtkTreeModel *model; @@ -1671,78 +1702,122 @@ update_options_table(gint index) link_row *link = NULL; gboolean enabled; - device = g_array_index(global_capture_opts.all_ifaces, interface_t, index); + row = g_array_index(rows, interface_row, index); - 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) { + 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.has_snaplen) { - snaplen_string = g_strdup_printf("%d", device.snaplen); - } else { - snaplen_string = g_strdup("default"); + 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 (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 (!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 (interfaces_dialog_window_present()) { - update_selected_interface(g_strdup(device.name)); + } + 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 (get_welcome_window() != NULL) { - change_interface_selection(g_strdup(device.name), device.selected); + +#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); } + 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_) { @@ -1755,13 +1830,13 @@ save_options_cb(GtkWidget *win _U_, gpointer user_data _U_) GtkWidget *buffer_size_sb; #endif - interface_t device; + interface_row row; gpointer ptr; int dlt; const gchar *filter_text; - 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); + row = g_array_index(rows, interface_row, marked_row); + rows = g_array_remove_index(rows, 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) @@ -1781,31 +1856,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 */ } - device.active_dlt = dlt; + row.active_dlt = dlt; #if defined(_WIN32) || defined(HAVE_PCAP_CREATE) - 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; + 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; } else { - device.snaplen = WTAP_MAX_PACKET_SIZE; + row.snaplen = WTAP_MAX_PACKET_SIZE; } filter_text = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(filter_cm)); - if (device.cfilter) - g_free(device.cfilter); + if (row.cfilter) + g_free(row.cfilter); g_assert(filter_text != NULL); - device.cfilter = g_strdup(filter_text); + row.cfilter = g_strdup(filter_text); #ifdef HAVE_PCAP_CREATE - device.monitor_mode_enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(monitor_cb)); + row.monitor_mode_enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(monitor_cb)); #endif - g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device); + g_array_insert_val(rows, marked_row, row); window_destroy(opt_edit_w); update_options_table(marked_row); } @@ -1814,10 +1889,10 @@ static void adjust_snap_sensitivity(GtkWidget *tb _U_, gpointer parent_w _U_) { GtkWidget *snap_cb, *snap_sb; - interface_t device; + interface_row 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); + row = g_array_index(rows, interface_row, marked_row); + rows = g_array_remove_index(rows, 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); @@ -1826,8 +1901,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))); - 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); + row.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb)); + g_array_insert_val(rows, marked_row, row); } void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column _U_, gpointer userdata) @@ -1865,12 +1940,14 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum #ifdef HAVE_AIRPCAP GtkWidget *advanced_bt; #endif - interface_t device; + interface_row row; + displayed_interface d_interface; GtkTreeModel *model; GtkTreeIter iter; link_row *temp; gboolean found = FALSE; gint num_supported_link_types; + guint i; gchar *tok; GtkCellRenderer *renderer; GtkListStore *store; @@ -1883,30 +1960,43 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum return; } - device.name = NULL; - device.display_name = NULL; - device.no_addresses = 0; - device.addresses = NULL; - device.links = NULL; - device.active_dlt = -1; - device.pmode = FALSE; + row.name = NULL; + row.display_name = NULL; + row.no_addresses = 0; + row.addresses = NULL; + row.links = NULL; + row.active_dlt = -1; + row.pmode = FALSE; #ifdef HAVE_PCAP_CREATE - device.monitor_mode_enabled = FALSE; - device.monitor_mode_supported = FALSE; + row.monitor_mode_enabled = FALSE; + row.monitor_mode_supported = FALSE; #endif - device.has_snaplen = FALSE; - device.snaplen = 65535; - device.cfilter = NULL; + row.has_snaplen = FALSE; + row.snaplen = 65535; + row.cfilter = NULL; #if defined(_WIN32) || defined(HAVE_PCAP_CREATE) - device.buffer = 1; + row.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)); - - device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row); - + + 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; + } + } + } 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); @@ -1930,7 +2020,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(device.display_name); + if_lb_name = gtk_label_new(row.display_name); gtk_box_pack_start(GTK_BOX(if_hb), if_lb_name, FALSE, FALSE, 3); /* IP addresses row */ @@ -1945,8 +2035,9 @@ 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 (device.no_addresses > 0) { - gchar *temp_addresses = g_strdup(device.addresses); + + if (row.no_addresses > 0) { + gchar *temp_addresses = g_strdup(row.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); @@ -2027,7 +2118,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=device.links; list!=NULL; list=g_list_next(list)) + for (list=row.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), @@ -2035,7 +2126,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 == device.active_dlt) { + if (temp->dlt == row.active_dlt) { ws_combo_box_set_active(GTK_COMBO_BOX(linktype_combo_box), num_supported_link_types - 1); found = TRUE; } @@ -2051,7 +2142,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), - device.pmode); + row.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. " @@ -2062,8 +2153,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), device.monitor_mode_enabled); - gtk_widget_set_sensitive(monitor_cb, device.monitor_mode_supported); + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(monitor_cb), row.monitor_mode_enabled); + gtk_widget_set_sensitive(monitor_cb, row.monitor_mode_supported); g_signal_connect(monitor_cb, "toggled", G_CALLBACK(capture_prep_monitor_changed_cb), NULL); gtk_widget_set_tooltip_text(monitor_cb, @@ -2089,14 +2180,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), - device.has_snaplen); + row.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) device.snaplen, + snap_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) row.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); @@ -2108,7 +2199,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), device.has_snaplen); + gtk_widget_set_sensitive(GTK_WIDGET(snap_sb), row.has_snaplen); /* Filter row */ filter_hb = gtk_hbox_new(FALSE, 3); @@ -2141,8 +2232,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 (device.cfilter && (strlen(device.cfilter) > 0)) { - gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), device.cfilter); + if (row.cfilter && (strlen(row.cfilter) > 0)) { + gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), row.cfilter); gtk_combo_box_set_active(GTK_COMBO_BOX(filter_cm), 0); } @@ -2169,10 +2260,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) device.buffer, + buffer_size_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) row.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) device.buffer); + gtk_spin_button_set_value(GTK_SPIN_BUTTON (buffer_size_sb), (gfloat) row.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, @@ -2196,7 +2287,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 (device.name, "rpcap://", 8) == 0) { + if (strncmp (row.name, "rpcap://", 8) == 0) { gtk_widget_set_sensitive(remote_bt, TRUE); } else { gtk_widget_set_sensitive(remote_bt, FALSE); @@ -2211,7 +2302,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, device.name); + airpcap_if_selected = get_airpcap_if_from_name(airpcap_if_list, row.name); if (airpcap_if_selected != NULL) { /* It is an airpcap interface */ gtk_widget_set_sensitive(advanced_bt, TRUE); @@ -2256,94 +2347,198 @@ static void toggle_callback(GtkCellRendererToggle *cell _U_, GtkTreeView *if_cb; GtkTreeModel *model; GtkTreePath *path = gtk_tree_path_new_from_string (path_str); - gboolean enabled; + gboolean enabled, found = FALSE; GtkWidget *pcap_ng_cb; - interface_t device; - gchar *name; - gint index = -1; + interface_options interface_opts; + interface_row row; + int index = atoi(path_str); 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, 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; - } + 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); } - if (!device.locked) { - if (enabled == FALSE) { - device.selected = TRUE; - global_capture_opts.num_selected++; - } else { - device.selected = FALSE; - global_capture_opts.num_selected--; +#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); + } + /* 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; + } } - 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) { + 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); + } + } } -#ifdef USE_THREADS - if (global_capture_opts.num_selected > 0) { + } + 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; #else - if (global_capture_opts.num_selected == 1) { + 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 - gtk_widget_set_sensitive(ok_bt, TRUE); } else { - gtk_widget_set_sensitive(ok_bt, FALSE); + 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 } - /* 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); +#endif + g_array_append_val(global_capture_opts.ifaces, interface_opts); if (interfaces_dialog_window_present()) { - update_selected_interface(g_strdup(device.name)); + update_selected_interface(g_strdup(interface_opts.name), TRUE); } if (get_welcome_window() != NULL) { - change_interface_selection(g_strdup(device.name), device.selected); + change_interface_selection(g_strdup(interface_opts.name), TRUE); } } - 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 selected) +void enable_selected_interface(gchar *name, gboolean enable) { + guint i; + interface_row row; GtkTreeIter iter; GtkTreeView *if_cb; GtkTreeModel *model; - gchar *name_str; + gchar *path_str; + gboolean enabled; - 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; + 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; } } - while (gtk_tree_model_iter_next(model, &iter)); #ifdef USE_THREADS - if (global_capture_opts.num_selected > 0) { + if (num_selected > 0) { #else - if (global_capture_opts.num_selected == 1) { + if (num_selected == 1) { #endif gtk_widget_set_sensitive(ok_bt, TRUE); } else { @@ -2369,17 +2564,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) { - global_capture_opts.num_selected++; + num_selected++; } else if (capture_set && !enabled) { - global_capture_opts.num_selected--; + num_selected--; } gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, enabled, -1); } while (gtk_tree_model_iter_next(model, &iter)); } - if (global_capture_opts.num_selected >= 2) { + 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 if (global_capture_opts.num_selected <= 1) { + } else if (num_selected <= 1) { gtk_widget_set_sensitive(pcap_ng_cb, TRUE); } if (interfaces_dialog_window_present()) { @@ -2389,9 +2584,9 @@ static void capture_all_cb(GtkToggleButton *button, gpointer d _U_) change_selection_for_all(enabled); } #ifdef USE_THREADS - if (global_capture_opts.num_selected > 0) { + if (num_selected > 0) { #else - if (global_capture_opts.num_selected == 1) { + if (num_selected == 1) { #endif gtk_widget_set_sensitive(ok_bt, TRUE); } else { @@ -2406,7 +2601,7 @@ static void promisc_mode_callback(GtkToggleButton *button, gpointer d _U_) GtkTreeView *if_cb; GtkTreeModel *model; gboolean enabled = FALSE; - interface_t device; + interface_row row; interface_options interface_opts; guint i; @@ -2421,11 +2616,11 @@ static void promisc_mode_callback(GtkToggleButton *button, gpointer d _U_) } while (gtk_tree_model_iter_next(model, &iter)); } - 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 < 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.ifaces->len; i++) { @@ -2521,8 +2716,6 @@ 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; @@ -2531,7 +2724,10 @@ 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; @@ -2562,6 +2758,7 @@ 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"); @@ -2570,6 +2767,13 @@ 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 */ @@ -2620,13 +2824,6 @@ 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); @@ -2677,6 +2874,7 @@ 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); @@ -3046,9 +3244,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 (global_capture_opts.num_selected > 0) { + if (num_selected > 0) { #else - if (global_capture_opts.num_selected == 1) { + if (num_selected == 1) { #endif gtk_widget_set_sensitive(ok_bt, TRUE); } else { @@ -3130,7 +3328,7 @@ capture_start_confirmed(void) guint i; /* did the user ever select a capture interface before? */ - if(global_capture_opts.num_selected == 0 && prefs.capture_device == NULL) { + if(global_capture_opts.ifaces->len == 0 && prefs.capture_device == NULL) { simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTN_OK, "%sNo capture interface selected!%s\n\n" @@ -3182,6 +3380,10 @@ 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; @@ -3217,10 +3419,60 @@ capture_start_cb(GtkWidget *w _U_, gpointer d _U_) if (!success) return; /* error in options dialog */ } - if (global_capture_opts.num_selected == 0) { - simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, + + if (global_capture_opts.ifaces->len == 0) { + if (prefs.capture_device == NULL) { + simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "You didn't specify an interface on which to capture packets."); - return; + 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; + } } if((cfile.state != FILE_CLOSED) && !cfile.user_saved && prefs.gui_ask_unsaved) { @@ -3243,18 +3495,18 @@ select_link_type_cb(GtkWidget *linktype_combo_box, gpointer data _U_) { gpointer ptr; int dlt; - interface_t device; + interface_row 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); + row = g_array_index(rows, interface_row, marked_row); + rows = g_array_remove_index(rows, 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 */ } - device.active_dlt = dlt; - g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device); + row.active_dlt = dlt; + g_array_insert_val(rows, marked_row, row); capture_filter_check_syntax_cb(linktype_combo_box, data); } @@ -3312,7 +3564,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.num_selected == 0) { + if (global_capture_opts.ifaces->len == 0) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "You didn't specify an interface on which to capture packets."); return FALSE; @@ -3456,50 +3708,219 @@ 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; + guint i, j; link_row *link = NULL; - interface_t device; + interface_row row; + interface_options interface_opts; + gboolean found = FALSE; #if defined(HAVE_PCAP_CREATE) - store = gtk_list_store_new (9, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING); + 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); #elif defined(_WIN32) && !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_STRING, G_TYPE_UINT, 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_UINT, G_TYPE_STRING); #else - store = gtk_list_store_new (7, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); + store = gtk_list_store_new (6, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); #endif - 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); + 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); } else { - temp = g_strdup_printf("%s\n%s", device.display_name, device.addresses); + temp = g_strdup_printf("%s\n%s", row.display_name, row.addresses); } - for (list = device.links; list != NULL; list = g_list_next(list)) { + for (list = row.links; list != NULL; list = g_list_next(list)) { link = (link_row*)(list->data); - if (link->dlt == device.active_dlt) { - break; + if (link->dlt == row.active_dlt) { + break; } } - if (device.has_snaplen) { - snaplen_string = g_strdup_printf("%d", device.snaplen); + if (row.has_snaplen) { + snaplen_string = g_strdup_printf("%d", row.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, 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); + 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); #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE) - 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); + 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); #else - 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); + 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); #endif } } @@ -3586,13 +4007,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_t device; + interface_row row; GtkTreePath *path = gtk_tree_model_get_path(tree_model, iter); int index = atoi(gtk_tree_path_to_string(path)); - device = g_array_index(global_capture_opts.all_ifaces, interface_t, index); + row = g_array_index(rows, interface_row, index); - if (device.monitor_mode_supported==TRUE) { + if (row.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); @@ -3653,16 +4074,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_t device; + interface_row row; 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); - 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); + row = g_array_index(rows, interface_row, marked_row); + rows = g_array_remove_index(rows, marked_row); - if_string = g_strdup(device.name); + if_string = g_strdup(row.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); @@ -3670,15 +4091,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(device.links)-1; i >= 0; i--) { - GList* rem = g_list_nth(device.links, i); - device.links = g_list_remove_link(device.links, rem); + 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); g_list_free_1(rem); } - device.active_dlt = -1; + row.active_dlt = -1; linktype_count = 0; - device.monitor_mode_supported = caps->can_set_rfmon; - device.monitor_mode_enabled = cap_settings.monitor_mode; + row.monitor_mode_supported = caps->can_set_rfmon; + row.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; @@ -3688,7 +4109,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) { - device.active_dlt = data_link_info->dlt; + row.active_dlt = data_link_info->dlt; } link->name = g_strdup(data_link_info->description); } else { @@ -3704,7 +4125,7 @@ capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp _U_) link->name = g_strdup(str); g_free(str); } - device.links = g_list_append(device.links, link); + row.links = g_list_append(row.links, link); linktype_count++; } free_if_capabilities(caps); @@ -3712,13 +4133,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; - device.monitor_mode_enabled = FALSE; - device.monitor_mode_supported = FALSE; + row.monitor_mode_enabled = FALSE; + row.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(global_capture_opts.all_ifaces, marked_row, device); + g_array_insert_val(rows, marked_row, row); } #endif diff --git a/gtk/capture_dlg.h b/gtk/capture_dlg.h index a3bb194c0b..c782596504 100644 --- a/gtk/capture_dlg.h +++ b/gtk/capture_dlg.h @@ -32,12 +32,60 @@ * @ingroup dialog_group */ #include "capture_opts.h" -#include + +#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; enum { CAPTURE = 0, - IFACE_HIDDEN_NAME, INTERFACE, LINK, PMODE, @@ -95,7 +143,6 @@ 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 @@ -116,7 +163,6 @@ typedef struct { */ cap_settings_t capture_get_cap_settings (gchar *if_name); -#endif GtkTreeModel* create_and_fill_model (GtkTreeView *view); @@ -156,12 +202,9 @@ gboolean dlg_window_present(void); void -enable_selected_interface(gchar *name, gboolean selected); +enable_selected_interface(gchar *name, gboolean enable); 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 527a604c89..7afacaa1c6 100644 --- a/gtk/capture_if_dlg.c +++ b/gtk/capture_if_dlg.c @@ -110,13 +110,15 @@ */ 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 GArray *gtk_list; +static guint currently_selected = 0; static if_stat_cache_t *sc; @@ -128,7 +130,6 @@ 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; @@ -138,65 +139,128 @@ 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) +update_selected_interface(gchar *name, gboolean activate) { - 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); + 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); + } break; } } } static void -store_selected(GtkWidget *choose_bt, gpointer name) +store_selected(GtkWidget *choose_bt, gpointer if_data) { - interface_t device; - guint i; + if_dlg_data_t *if_dlg_data = if_data, *temp; + GList *curr; + unsigned int ifs, i; gboolean found; - for (i = 0; i < global_capture_opts.all_ifaces->len; i++) { - device = g_array_index(global_capture_opts.all_ifaces, interface_t, i); + 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); found = FALSE; - 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 (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 (gtk_widget_is_focus(choose_bt) && dlg_window_present()) { - enable_selected_interface(device.name, device.selected); + enable_selected_interface(interface_opts.name, TRUE); } - 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 && (global_capture_opts.num_selected > 0)); + gtk_widget_set_sensitive(capture_bt, !gbl_capture_in_progress && (currently_selected > 0)); #else - gtk_widget_set_sensitive(capture_bt, !gbl_capture_in_progress && (global_capture_opts.num_selected == 1)); + gtk_widget_set_sensitive(capture_bt, !gbl_capture_in_progress && (currently_selected == 1)); #endif } } @@ -209,18 +273,19 @@ 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 data; - guint ifs; - - 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); + if_dlg_data_t *temp; + GList *curr; + int ifs; #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; + if_dlg_data_t *if_dlg_data = if_data; + + airpcap_if_active = get_airpcap_if_from_name(airpcap_if_list, if_dlg_data->if_info.name); + 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? */ @@ -266,14 +331,11 @@ capture_details_cb(GtkWidget *details_bt _U_, gpointer if_data) /* update a single interface */ static void -update_if(gchar *name, if_stat_cache_t *sc) +update_if(if_dlg_data_t *if_dlg_data, if_stat_cache_t *sc) { struct pcap_stat stats; gchar *str; - guint diff, ifs; - interface_t device; - if_dlg_data_t data; - gboolean found = FALSE; + guint diff; /* @@ -284,40 +346,23 @@ update_if(gchar *name, 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) { - 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); + 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"); } } } @@ -326,17 +371,16 @@ update_if(gchar *name, if_stat_cache_t *sc) static gboolean update_all(gpointer data) { - interface_t device; - guint ifs; + GList *curr; + int ifs; if_stat_cache_t *sc = data; if (!cap_if_w) { return FALSE; } - 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); + for (ifs = 0; (curr = g_list_nth(if_data_list, ifs)); ifs++) { + update_if(curr->data, sc); } return TRUE; @@ -350,9 +394,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 && (global_capture_opts.num_selected > 0)); + gtk_widget_set_sensitive(capture_bt, !capture_in_progress && (currently_selected > 0)); #else - gtk_widget_set_sensitive(capture_bt, !capture_in_progress && (global_capture_opts.num_selected == 1)); + gtk_widget_set_sensitive(capture_bt, !capture_in_progress && (currently_selected == 1)); #endif } } @@ -362,8 +406,17 @@ 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. */ @@ -648,41 +701,17 @@ static void capture_if_stop_cb(GtkWidget *w _U_, gpointer d _U_) { guint ifs; - if_dlg_data_t data; + GList *curr; + if_dlg_data_t *if_data; - 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); + 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); } 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 @@ -692,23 +721,30 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_) *main_sw, *bbox, *close_bt, - *help_bt; + *help_bt, + *icon; #ifdef HAVE_AIRPCAP GtkWidget *decryption_cb; #endif - GtkWidget *if_tb, *icon; + GtkWidget *if_tb; GtkWidget *if_lb; GtkWidget *eb; + int err; + gchar *err_str; GtkRequisition requisition; int row, height; - guint ifs; - interface_t device; + if_dlg_data_t *if_dlg_data = NULL; + int ifs; + GList *curr; + if_info_t *if_info; GString *if_tool_str = g_string_new(""); const gchar *addr_str; gchar *user_descr; - if_dlg_data_t data; + int preselected = 0, i; + interface_options interface_opts; + gboolean found = FALSE; if (cap_if_w != NULL) { /* There's already a "Capture Interfaces" dialog box; reactivate it. */ @@ -727,13 +763,43 @@ 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) { @@ -749,7 +815,6 @@ 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); @@ -797,109 +862,142 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_) height += 30; /* Start gathering statistics (using dumpcap) */ - sc = capture_stat_start(&global_capture_opts); + sc = capture_stat_start(if_list); /* List the interfaces */ - 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); + currently_selected = 0; + for (ifs = 0; (curr = g_list_nth(if_list, ifs)); ifs++) { g_string_assign(if_tool_str, ""); + if_info = curr->data; + /* Continue if capture device is hidden */ - if (device.hidden) { + if (prefs_is_capture_device_hidden(if_info->name)) { continue; } - data.choose_bt = gtk_check_button_new(); - gtk_table_attach_defaults(GTK_TABLE(if_tb), data.choose_bt, 0, 1, row, row+1); + + 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); if (gbl_capture_in_progress) { - gtk_widget_set_sensitive(data.choose_bt, FALSE); + gtk_widget_set_sensitive(if_dlg_data->choose_bt, FALSE); } else { - gtk_widget_set_sensitive(data.choose_bt, TRUE); + gtk_widget_set_sensitive(if_dlg_data->choose_bt, TRUE); } - 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_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_table_attach_defaults(GTK_TABLE(if_tb), icon, 1, 2, row, row+1); /* device name */ - data.device_lb = gtk_label_new(device.name); + if_dlg_data->device_lb = gtk_label_new(if_info->name); + if_dlg_data->device = if_info->name; #ifndef _WIN32 - 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); + 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); #endif g_string_append(if_tool_str, "Device: "); - g_string_append(if_tool_str, device.name); + g_string_append(if_tool_str, if_info->name); g_string_append(if_tool_str, "\n"); /* description */ - user_descr = capture_dev_user_descr_find(device.name); + user_descr = capture_dev_user_descr_find(if_info->name); if (user_descr) { - data.descr_lb = gtk_label_new(user_descr); + if_dlg_data->descr_lb = gtk_label_new(user_descr); g_free (user_descr); } else { - if (device.if_info.description) - data.descr_lb = gtk_label_new(device.if_info.description); + if (if_info->description) + if_dlg_data->descr_lb = gtk_label_new(if_info->description); else - data.descr_lb = gtk_label_new(""); + if_dlg_data->descr_lb = gtk_label_new(""); } - 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) { + 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) { g_string_append(if_tool_str, "Description: "); - g_string_append(if_tool_str, device.if_info.description); + g_string_append(if_tool_str, 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: "); - data.ip_lb = gtk_label_new(""); - addr_str = set_ip_addr_label (device.if_info.addrs, data.ip_lb, 0); + if_dlg_data->ip_lb = gtk_label_new(""); + addr_str = set_ip_addr_label (if_info->addrs, if_dlg_data->ip_lb, 0); if (addr_str) { - gtk_widget_set_sensitive(data.ip_lb, TRUE); + gtk_widget_set_sensitive(if_dlg_data->ip_lb, TRUE); g_string_append(if_tool_str, addr_str); } else { - gtk_widget_set_sensitive(data.ip_lb, FALSE); + gtk_widget_set_sensitive(if_dlg_data->ip_lb, FALSE); g_string_append(if_tool_str, "none"); } eb = gtk_event_box_new (); - gtk_container_add(GTK_CONTAINER(eb), data.ip_lb); + gtk_container_add(GTK_CONTAINER(eb), if_dlg_data->ip_lb); gtk_table_attach_defaults(GTK_TABLE(if_tb), eb, 5, 6, row, row+1); - if (get_ip_addr_count(device.if_info.addrs) > 1) { + if (get_ip_addr_count(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, data.ip_lb); + g_object_set_data(G_OBJECT(eb), CAPTURE_IF_IP_ADDR_LABEL, if_dlg_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), device.if_info.addrs); + g_signal_connect(eb, "button-press-event", G_CALLBACK(ip_label_press_cb), if_info->addrs); } g_string_append(if_tool_str, "\n"); /* packets */ - data.curr_lb = gtk_label_new("-"); - gtk_table_attach_defaults(GTK_TABLE(if_tb), data.curr_lb, 6, 7, row, row+1); + 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); /* packets/s */ - data.last_lb = gtk_label_new("-"); - gtk_table_attach_defaults(GTK_TABLE(if_tb), data.last_lb, 7, 8, row, row+1); + 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); /* details button */ #ifdef _WIN32 - 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); + 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); } else { - gtk_widget_set_sensitive(data.details_bt, FALSE); + gtk_widget_set_sensitive(if_dlg_data->details_bt, FALSE); } #endif - gtk_list = g_array_remove_index(gtk_list, ifs); - g_array_insert_val(gtk_list, ifs, data); + + if_data_list = g_list_append(if_data_list, if_dlg_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(data.choose_bt), &requisition, NULL); + gtk_widget_get_preferred_size(GTK_WIDGET(if_dlg_data->choose_bt), &requisition, NULL); height += requisition.height; } } @@ -919,9 +1017,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), device.name); + g_signal_connect(options_bt, "clicked", G_CALLBACK(capture_prepare_cb), if_dlg_data); capture_bt = g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_CAPTURE_START); - g_signal_connect(capture_bt, "clicked", G_CALLBACK(capture_do_cb), device.name); + g_signal_connect(capture_bt, "clicked", G_CALLBACK(capture_do_cb), if_dlg_data); 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; @@ -952,14 +1050,16 @@ void refresh_if_window(void) capture_if_cb(NULL, NULL); } -void select_all_interfaces(gboolean enable _U_) +void select_all_interfaces(gboolean enable) { + if_dlg_data_t *temp; guint ifs; - interface_t device; + GList *curr; - 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); + 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); } } diff --git a/gtk/capture_if_dlg.h b/gtk/capture_if_dlg.h index 253c3949c7..3c2f2359d0 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); +update_selected_interface(gchar *name, gboolean activate); gboolean interfaces_dialog_window_present(void); @@ -65,9 +65,6 @@ 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 2267551078..3f5bda29c6 100644 --- a/gtk/main.c +++ b/gtk/main.c @@ -114,7 +114,6 @@ #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 @@ -513,16 +512,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 * @@ -548,17 +547,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); } @@ -695,7 +694,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--; @@ -717,8 +716,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; @@ -728,7 +727,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); } } @@ -1400,9 +1399,6 @@ 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, @@ -1421,14 +1417,6 @@ 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"); @@ -2186,8 +2174,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" @@ -2206,13 +2194,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); @@ -2281,8 +2269,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 && @@ -2455,11 +2443,6 @@ 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) { @@ -2470,6 +2453,7 @@ 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 */ @@ -2499,25 +2483,13 @@ 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; @@ -2556,7 +2528,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; @@ -2581,7 +2553,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: @@ -2590,7 +2562,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: @@ -2601,9 +2573,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 */ @@ -2654,11 +2626,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 */ @@ -2745,18 +2717,23 @@ 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 */ + 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;*/ } } } @@ -2773,32 +2750,23 @@ main(int argc, char *argv[]) /* Get the list of link-layer types for the capture devices. */ if_capabilities_t *caps; guint i; - interface_t device; - for (i = 0; i < global_capture_opts.all_ifaces->len; i++) { + interface_options interface_opts; - device = g_array_index(global_capture_opts.all_ifaces, interface_t, i); - if (device.selected) { -#if defined(_WIN32) || defined(HAVE_PCAP_CREATE) - caps = capture_get_if_capabilities(device.name, device.monitor_mode_supported, &err_str); -#else - caps = capture_get_if_capabilities(device.name, FALSE, &err_str); -#endif - 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); - } -#if defined(_WIN32) || defined(HAVE_PCAP_CREATE) - capture_opts_print_if_capabilities(caps, device.name, device.monitor_mode_supported); -#else - capture_opts_print_if_capabilities(caps, device.name, FALSE); -#endif - free_if_capabilities(caps); + 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); + } + capture_opts_print_if_capabilities(caps, interface_opts.name, interface_opts.monitor_mode); + free_if_capabilities(caps); } exit(0); } @@ -2819,20 +2787,53 @@ main(int argc, char *argv[]) exit(2); } #endif - if ((global_capture_opts.num_selected == 0) && + if ((global_capture_opts.ifaces->len == 0) && (prefs.capture_device != NULL)) { - 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; + 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; + } } } + 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 @@ -2874,8 +2875,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); @@ -2997,15 +2998,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 @@ -3020,7 +3021,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); } @@ -3040,10 +3041,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(); } @@ -3549,6 +3550,7 @@ 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); @@ -3856,218 +3858,3 @@ 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 2b70e8a2ab..59b742ddfc 100644 --- a/gtk/main.h +++ b/gtk/main.h @@ -26,7 +26,6 @@ #define __MAIN_H__ #include "globals.h" -#include "capture_opts.h" /** @defgroup main_window_group Main window * The main window has the following submodules: @@ -366,6 +365,4 @@ 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 aad9f8215d..8226f5a588 100644 --- a/gtk/main_welcome.c +++ b/gtk/main_welcome.c @@ -81,6 +81,8 @@ #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 */ @@ -101,8 +103,10 @@ 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; @@ -207,9 +211,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; } @@ -220,7 +224,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 @@ -247,12 +251,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); @@ -353,7 +357,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); @@ -419,7 +423,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 @@ -450,7 +454,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 @@ -575,16 +579,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; } @@ -714,22 +718,22 @@ static gboolean select_current_ifaces(GtkTreeModel *model, { guint i; gchar *if_name; - interface_t device; + gboolean found = FALSE; - GtkTreeSelection *selection = (GtkTreeSelection *)userdata; - device.name = NULL; + GtkTreeSelection *selection = (GtkTreeSelection *)userdata; gtk_tree_model_get (model, iter, IFACE_NAME, &if_name, -1); - 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); + 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); } + found = TRUE; break; } } + if (!found) { + gtk_tree_selection_unselect_iter(selection, iter); + } return FALSE; } @@ -741,42 +745,100 @@ gboolean on_selection_changed(GtkTreeSelection *selection _U_, { GtkTreeIter iter; gchar *if_name; - guint i; - interface_t device; - + 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; gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_get (model, &iter, IFACE_NAME, &if_name, -1); - 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 (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; if (path_currently_selected) { - if (device.selected) { - device.selected = FALSE; - device.locked = TRUE; - global_capture_opts.num_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); } - } else { - if (!device.selected) { - device.selected = TRUE; - 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 } - 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 - if (dlg_window_present()) { - enable_selected_interface(g_strdup(if_name), device.selected); + 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 (interfaces_dialog_window_present()) { - update_selected_interface(g_strdup(if_name)); + 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); } - 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; } - break; } } return TRUE; @@ -823,8 +885,10 @@ void change_selection_for_all(gboolean enable) { guint i; - 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); + if (interfaces) { + for (i = 0; i < interfaces->len; i++) { + change_interface_selection(g_array_index(interfaces, displayed_interface, i).name, enable); + } } } #endif @@ -837,7 +901,7 @@ select_ifaces(void) GtkTreeModel *model; GtkTreeSelection *entry; - if (global_capture_opts.num_selected > 0 && swindow) { + if (global_capture_opts.ifaces->len > 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)); @@ -849,24 +913,40 @@ select_ifaces(void) #ifdef HAVE_PCAP_REMOTE void -add_interface_to_list(guint index) +add_interface_to_list(gchar *name, gchar *descr, remote_options *remote_opts) { GtkWidget *view, *icon; GtkTreeModel *model; GtkTreeIter iter; gint size; gchar *lines; - interface_t device; - - device = g_array_index(global_capture_opts.all_ifaces, interface_t, index); + 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 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, device.display_name, IFACE_NAME, device.name, -1); + gtk_list_store_set(GTK_LIST_STORE(model), &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(icon)), IFACE_DESCR, descr, IFACE_NAME, name, -1); } } #endif @@ -876,40 +956,91 @@ 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 *view; + GtkWidget *icon, *view; GtkTreeSelection *entry; - interface_t device; - gboolean changed = FALSE; + displayed_interface d_interface; 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 (global_capture_opts.all_ifaces->len == 0) { - scan_local_interfaces(&global_capture_opts); + 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); + } } else { - 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) { + 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; + } gtk_list_store_append (store, &iter); - 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); + 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); } } - 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(); + 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); } #endif /* HAVE_LIBPCAP */ } @@ -920,9 +1051,23 @@ void welcome_if_panel_reload(void) { #ifdef HAVE_LIBPCAP - if (welcome_hb) { + 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); welcome_if_tree_load(); - gtk_widget_show_all(welcome_hb); + gtk_widget_show_all(welcome_if_panel_vb); } #endif /* HAVE_LIBPCAP */ } @@ -931,16 +1076,16 @@ welcome_if_panel_reload(void) static void capture_if_start(GtkWidget *w _U_, gpointer data _U_) { #ifdef HAVE_AIRPCAP - interface_t device; - guint i; + interface_options interface_opts; #endif - if (global_capture_opts.num_selected == 0) { + + if (global_capture_opts.ifaces->len == 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.num_selected > 1) { + if (global_capture_opts.ifaces->len > 1) { simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "You specified multiple interfaces for capturing which this version of Wireshark doesn't support."); return; @@ -952,15 +1097,10 @@ 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 /* 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; - } - } +#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; airpcap_set_toolbar_start_capture(airpcap_if_active); #endif capture_start_cb(NULL, NULL); @@ -991,11 +1131,14 @@ welcome_new(void) GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; + GList *if_list; + int err; + gchar *err_str = NULL; #endif /* prepare colors */ #if 0 - /* Allocating color isn't necessary? */ + /* Allocating collor isn't necessary? */ /* "page" background */ get_color(&welcome_bg); @@ -1015,7 +1158,7 @@ welcome_new(void) topic_item_idle_bg = topic_content_bg; #endif #if 0 - /* Allocating color isn't necessary? */ + /* Allocating collor isn't necessary? */ /* topic item entered color */ get_color(&topic_item_entered_bg); #endif @@ -1026,9 +1169,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(); @@ -1043,7 +1186,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 @@ -1054,10 +1197,8 @@ welcome_new(void) gtk_box_pack_start(GTK_BOX(column_vb), topic_vb, TRUE, TRUE, 0); #ifdef HAVE_LIBPCAP - if (global_capture_opts.all_ifaces->len == 0) { - scan_local_interfaces(&global_capture_opts); - } - if (global_capture_opts.all_ifaces->len > 0) { + if_list = capture_interface_list(&err, &err_str); + if (g_list_length(if_list) > 0) { item_hb = welcome_button(WIRESHARK_STOCK_CAPTURE_INTERFACES, "Interface List", "Live list of the capture interfaces\n(counts incoming packets)", @@ -1074,13 +1215,17 @@ 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(); - gtk_tree_view_column_pack_start(column, renderer, FALSE); - gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", ICON, NULL); + 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); renderer = gtk_cell_renderer_text_new(); - gtk_tree_view_column_pack_start(column, renderer, TRUE); - gtk_tree_view_column_set_attributes(column, renderer, "text", IFACE_DESCR, NULL); + column = gtk_tree_view_column_new_with_attributes ("", + GTK_CELL_RENDERER(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(); @@ -1141,6 +1286,8 @@ 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); @@ -1281,3 +1428,9 @@ 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 16cb217cf2..566f7669e2 100644 --- a/gtk/main_welcome.h +++ b/gtk/main_welcome.h @@ -40,6 +40,15 @@ 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 */ @@ -51,8 +60,6 @@ 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 @@ -78,10 +85,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(guint index); +void add_interface_to_list(gchar *name, gchar *descr, remote_options *remote_opts); #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 29e27f425c..7c704732a7 100644 --- a/gtk/prefs_capture.c +++ b/gtk/prefs_capture.c @@ -1434,7 +1434,6 @@ ifopts_write_new_hide(void) g_free(new_hide); prefs.capture_devices_hide = NULL; } - hide_interface(g_strdup(new_hide)); } } -- cgit v1.2.3