?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add parameter dcerpc_info to PIDL_dissect_ipv?address()
[wireshark-wip.git] / ui / gtk / capture_dlg.c
blob34845c382704f31ccdfe2c32a16848cb2a8f0704
1 /* capture_dlg.c
2 * Routines for the "Capture Options" dialog and dialog windows popped
3 * up from it
4 *
5 * $Id$
6 *
7 * Wireshark - Network traffic analyzer
8 * By Gerald Combs <gerald@wireshark.org>
9 * Copyright 1998 Gerald Combs
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License
13 * as published by the Free Software Foundation; either version 2
14 * of the License, or (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
24 */
25
26 #include "config.h"
27
28 #ifdef HAVE_LIBPCAP
29
30 #include <string.h>
31
32 #include <stdio.h>
33
34 #include <gtk/gtk.h>
35
36 #include <epan/packet.h>
37 #include <epan/addr_resolv.h>
38 #include <epan/prefs.h>
39 #include <epan/filesystem.h>
40
41 #include "../capture.h"
42 #include "../capture_ifinfo.h"
43 #include "../capture-pcap-util.h"
44 #include "../capture_ui_utils.h"
45 #include "../ringbuffer.h"
46
47 #include "ui/capture_globals.h"
48 #include "ui/iface_lists.h"
49 #include "ui/preference_utils.h"
50 #include "ui/recent.h"
51 #include "ui/recent_utils.h"
52 #include "ui/simple_dialog.h"
53 #include "ui/util.h"
54
55 #include "ui/gtk/main.h"
56 #include "ui/gtk/gui_utils.h"
57 #include "ui/gtk/capture_dlg.h"
58 #include "ui/gtk/filter_dlg.h"
59 #include "ui/gtk/dlg_utils.h"
60 #include "ui/gtk/file_dlg.h"
61 #include "ui/gtk/stock_icons.h"
62 #include "ui/gtk/capture_file_dlg.h"
63 #include "ui/gtk/help_dlg.h"
64 #include "ui/gtk/gtkglobals.h"
65 #include "ui/gtk/cfilter_combo_utils.h"
66 #include "ui/gtk/capture_if_dlg.h"
67 #include "ui/gtk/main_welcome.h"
68 #include "ui/gtk/network_icons.h"
69 #include "ui/gtk/menus.h"
70 #include "ui/gtk/prefs_dlg.h"
71 #include "ui/gtk/main_80211_toolbar.h"
72
73 #include "ui/gtk/keys.h"
74
75 #include "ui/gtk/old-gtk-compat.h"
76 #include "ui/gtk/expert_indicators.h"
77
78 #ifdef HAVE_AIRPCAP
79 #include <airpcap.h>
80 #include "airpcap_loader.h"
81 #include "airpcap_gui_utils.h"
82 #include "airpcap_dlg.h"
83 #endif
84
85 /*
86 * Symbolic names for column indices.
87 */
88 enum
89 {
90 CAPTURE = 0,
91 IFACE_HIDDEN_NAME,
92 INTERFACE,
93 LINK,
94 PMODE,
95 SNAPLEN,
96 #if defined(HAVE_PCAP_CREATE)
97 BUFFER,
98 MONITOR,
99 #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
100 BUFFER,
101 #endif
102 FILTER,
103 NUM_COLUMNS
104 };
105
106 enum
107 {
108 COMPILE_ERROR = 0,
109 SIGN,
110 INAME
111 };
112
113 #ifdef _WIN32
114 #define LOCAL_OFFSET 1
115 #else
116 #define LOCAL_OFFSET 0
117 #endif
118
119 /* Capture callback data keys */
120 #define E_CAP_IFACE_KEY "cap_iface"
121 #define E_CAP_IFACE_IP_KEY "cap_iface_ip"
122 #define E_CAP_SNAP_CB_KEY "cap_snap_cb"
123 #define E_CAP_LT_CBX_KEY "cap_lt_cbx"
124 #define E_CAP_LT_CBX_LABEL_KEY "cap_lt_cbx_label"
125 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
126 #define E_CAP_BUFFER_SIZE_SB_KEY "cap_buffer_size_sb"
127 #endif
128 #define E_CAP_SNAP_SB_KEY "cap_snap_sb"
129 #define E_CAP_PROMISC_KEY "cap_promisc"
130 #define E_CAP_PROMISC_KEY_ALL "cap_promisc_all"
131 #define E_CAP_KEY_ALL "cap_all"
132 #ifdef HAVE_PCAP_CREATE
133 #define E_CAP_MONITOR_KEY "cap_monitor"
134 #endif
135 #define E_CAP_PCAP_NG_KEY "cap_pcap_ng"
136 #define E_CAP_FILT_KEY "cap_filter_te"
137 #define E_OPT_EDIT_DIALOG_PTR_KEY "cap_edit_opt_dialog"
138 #define E_OPT_EDIT_CALLER_PTR_KEY "cap_edit_opt_caller"
139 #define E_CAP_FILE_TE_KEY "cap_file_te"
140 #define E_CAP_MULTI_FILES_ON_CB_KEY "cap_multi_files_on_cb"
141 #define E_CAP_RING_FILESIZE_CB_KEY "cap_ring_filesize_cb"
142 #define E_CAP_RING_FILESIZE_SB_KEY "cap_ring_filesize_sb"
143 #define E_CAP_RING_FILESIZE_CBX_KEY "cap_ring_filesize_cbx"
144 #define E_CAP_FILE_DURATION_CB_KEY "cap_file_duration_cb"
145 #define E_CAP_FILE_DURATION_SB_KEY "cap_file_duration_sb"
146 #define E_CAP_FILE_DURATION_CBX_KEY "cap_file_duration_cbx"
147 #define E_CAP_RING_NBF_CB_KEY "cap_ring_nbf_cb"
148 #define E_CAP_RING_NBF_SB_KEY "cap_ring_nbf_sb"
149 #define E_CAP_RING_NBF_LB_KEY "cap_ring_nbf_lb"
150 #define E_CAP_STOP_FILES_CB_KEY "cap_stop_files_cb"
151 #define E_CAP_STOP_FILES_SB_KEY "cap_stop_files_sb"
152 #define E_CAP_STOP_FILES_LB_KEY "cap_stop_files_lb"
153 #define E_CAP_SYNC_KEY "cap_sync"
154 #define E_CAP_AUTO_SCROLL_KEY "cap_auto_scroll"
155 #define E_CAP_HIDE_INFO_KEY "cap_hide_info"
156 #define E_CAP_STOP_PACKETS_CB_KEY "cap_stop_packets_cb"
157 #define E_CAP_STOP_PACKETS_SB_KEY "cap_stop_packets_sb"
158 #define E_CAP_STOP_PACKETS_LB_KEY "cap_stop_packets_lb"
159 #define E_CAP_STOP_FILESIZE_CB_KEY "cap_stop_filesize_cb"
160 #define E_CAP_STOP_FILESIZE_SB_KEY "cap_stop_filesize_sb"
161 #define E_CAP_STOP_FILESIZE_CBX_KEY "cap_stop_filesize_cbx"
162 #define E_CAP_STOP_DURATION_CB_KEY "cap_stop_duration_cb"
163 #define E_CAP_STOP_DURATION_SB_KEY "cap_stop_duration_sb"
164 #define E_CAP_STOP_DURATION_CBX_KEY "cap_stop_duration_cbx"
165 #define E_CAP_M_RESOLVE_KEY "cap_m_resolve"
166 #define E_CAP_N_RESOLVE_KEY "cap_n_resolve"
167 #define E_CAP_T_RESOLVE_KEY "cap_t_resolve"
168 #define E_CAP_E_RESOLVE_KEY "cap_e_resolve"
169
170 #define E_CAP_IFTYPE_CBX_KEY "cap_iftype_cbx"
171 #ifdef HAVE_PCAP_REMOTE
172 #define E_CAP_IF_LIST_KEY "cap_if_list"
173 #define E_CAP_DATATX_UDP_CB_KEY "cap_datatx_udp_cb"
174 #define E_CAP_NOCAP_RPCAP_CB_KEY "cap_nocap_rpcap_cb"
175 #define E_CAP_REMOTE_DIALOG_PTR_KEY "cap_remote_dialog"
176 #define E_CAP_REMOTE_CALLER_PTR_KEY "cap_remote_caller"
177 #define E_REMOTE_HOST_TE_KEY "cap_remote_host"
178 #define E_REMOTE_PORT_TE_KEY "cap_remote_port"
179 #define E_REMOTE_AUTH_NULL_KEY "cap_remote_auth_null"
180 #define E_REMOTE_AUTH_PASSWD_KEY "cap_remote_auth_passwd"
181 #define E_REMOTE_USERNAME_LB_KEY "cap_remote_username_lb"
182 #define E_REMOTE_USERNAME_TE_KEY "cap_remote_username_te"
183 #define E_REMOTE_PASSWD_LB_KEY "cap_remote_passwd_lb"
184 #define E_REMOTE_PASSWD_TE_KEY "cap_remote_passwd_te"
185 #define E_REMOTE_OK_BT_KEY "cap_remote_ok_bt"
186 #define E_REMOTE_DEL_BT_KEY "cap_remote_delete_bt"
187 #define E_CAP_CBX_IFTYPE_NOUPDATE_KEY "cap_cbx_iftype_noupdate"
188 #define E_OPT_REMOTE_DIALOG_PTR_KEY "cap_remote_opt_dialog"
189 #define E_OPT_REMOTE_CALLER_PTR_KEY "cap_remote_opt_caller"
190 #endif
191 #ifdef HAVE_PCAP_SETSAMPLING
192 #define E_CAP_SAMP_NONE_RB_KEY "cap_samp_none_rb"
193 #define E_CAP_SAMP_COUNT_RB_KEY "cap_samp_count_rb"
194 #define E_CAP_SAMP_COUNT_SB_KEY "cap_samp_count_sb"
195 #define E_CAP_SAMP_TIMER_RB_KEY "cap_samp_timer_rb"
196 #define E_CAP_SAMP_TIMER_SB_KEY "cap_samp_timer_sb"
197 #endif
198 #define E_CAP_PIPE_TE_KEY "cap_pipe_te"
199 #define E_CAP_PIPE_L_KEY "cap_pipe_list"
200 #define E_CAP_PIPE_DEL_KEY "cap_pipe_delete_key"
201 #define E_CAP_LOCAL_L_KEY "cap_local_list"
202 #define E_CAP_REMOTE_L_KEY "cap_remote_list"
203
204 #define E_COMPILE_SW_SCROLLW_KEY "compileScrolledWindowInterfaces"
205 #define E_COMPILE_TREE_VIEW_INTERFACES "compileTreeViewInterfaces"
206
207 #define DUMMY_SNAPLENGTH 65535
208 #define DUMMY_NETMASK 0xFF000000
209
210 enum
211 {
212 COL_NAME = 0,
213 COL_ADDRESS,
214 COL_LINK
215 } ;
216
217 /*
218 * Keep a static pointer to the current "Capture Options" window, if
219 * any, so that if somebody tries to do "Capture:Options" while there's
220 * already a "Capture Options" window up, we just pop up the existing
221 * one, rather than creating a new one.
222 * Also: Capture:Start obtains info from the "Capture Options" window
223 * if it exists and if its creation is complete.
224 */
225 static GtkWidget *cap_open_w = NULL, *opt_edit_w = NULL, *ok_bt, *interface_management_w = NULL;
226 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
227 static GtkWidget *compile_bpf_w = NULL;
228 #endif
229 static gboolean cap_open_complete; /* valid only if cap_open_w != NULL */
230 static const gchar *pipe_name;
231 static const gchar *selected_name;
232 static GtkWidget *columns_menu_object;
233 static GtkUIManager *ui_manager_columns = NULL;
234 static GSList *popup_menu_list = NULL;
235 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
236 static GHashTable *compile_results = NULL;
237 static GtkWidget *all_compile_bt;
238 #endif
239
240 static gint marked_interface;
241 static gint marked_row;
242
243 #ifdef HAVE_PCAP_REMOTE
244 static GHashTable *remote_host_list=NULL;
245 static remote_options global_remote_opts;
246 static guint num_selected = 0;
247 #endif
248
249 static void
250 capture_prep_file_cb(GtkWidget *file_bt, GtkWidget *file_te);
251
252 static void
253 capture_prep_pipe_cb(GtkWidget *pipe_bt, GtkWidget *pipe_te);
254
255 static void
256 select_link_type_cb(GtkWidget *w, gpointer data);
257
258 #ifdef HAVE_PCAP_REMOTE
259 static void
260 capture_remote_cb(GtkWidget *w, gboolean focus_username);
261
262 static void
263 select_if_type_cb(GtkComboBox *iftype_cbx, gpointer data);
264
265 static void
266 fill_remote_list(void);
267 #endif
268
269 static void
270 capture_prep_adjust_sensitivity(GtkWidget *tb, gpointer parent_w);
271
272 static void
273 capture_prep_destroy_cb(GtkWidget *win, gpointer user_data);
274
275 #ifdef HAVE_PCAP_CREATE
276 static void
277 capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp);
278 #endif
279
280 static gboolean
281 capture_dlg_prep(gpointer parent_w);
282
283 static GtkTreeModel*
284 create_and_fill_model(GtkTreeView *view);
285
286 static void
287 update_options_table(gint indx);
288
289 static void
290 update_properties_all(void);
291
292 static gboolean
293 query_tooltip_tree_view_cb (GtkWidget *widget,
294 gint x,
295 gint y,
296 gboolean keyboard_tip,
297 GtkTooltip *tooltip,
298 gpointer data);
299
300 static
301 gchar *col_index_to_name(gint indx)
302 {
303 gchar *col_name;
304
305 switch (indx)
306 {
307 case INTERFACE: col_name = g_strdup("INTERFACE");
308 break;
309 case LINK: col_name = g_strdup("LINK");
310 break;
311 case PMODE: col_name = g_strdup("PMODE");
312 break;
313 case SNAPLEN: col_name = g_strdup("SNAPLEN");
314 break;
315 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
316 case BUFFER: col_name = g_strdup("BUFFER");
317 break;
318 #endif
319 #if defined (HAVE_PCAP_CREATE)
320 case MONITOR: col_name = g_strdup("MONITOR");
321 break;
322 #endif
323 case FILTER: col_name = g_strdup("FILTER");
324 break;
325 default: return NULL;
326 }
327 return col_name;
328 }
329
330 static
331 gint col_title_to_index(const gchar *name)
332 {
333 if (strcmp(name, "Capture") == 0) return CAPTURE;
334 if (strcmp(name, "Interface") == 0) return INTERFACE;
335 if (strcmp(name, "Link-layer header") == 0) return LINK;
336 if (strcmp(name, "Prom. Mode") == 0) return PMODE;
337 if (strcmp(name, "Snaplen [B]") == 0) return SNAPLEN;
338 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
339 if (strcmp(name, "Buffer [MB]") == 0) return BUFFER;
340 #endif
341 #if defined (HAVE_PCAP_CREATE)
342 if (strcmp(name, "Mon. Mode") == 0) return MONITOR;
343 #endif
344 if (strcmp(name, "Capture Filter") == 0) return FILTER;
345 return -1;
346 }
347
348 static void
349 set_capture_column_visible(gchar *col, gboolean visible _U_)
350 {
351 GList *curr;
352 gchar *col_name;
353
354 if (visible && !prefs_capture_options_dialog_column_is_visible(col)) {
355 prefs.capture_columns = g_list_append(prefs.capture_columns, col);
356 } else if (!visible && prefs_capture_options_dialog_column_is_visible(col)) {
357 for (curr = g_list_first(prefs.capture_columns); curr; curr = g_list_next(curr)) {
358 col_name = (gchar *)curr->data;
359 if (col_name && (g_ascii_strcasecmp(col_name, col) == 0)) {
360 prefs.capture_columns = g_list_remove(prefs.capture_columns, curr->data);
361 break;
362 }
363 }
364 }
365 }
366
367 static void
368 toggle_visible_column_cb (GtkWidget *w _U_, gpointer data)
369 {
370 GtkTreeView *view;
371 GtkTreeViewColumn *col;
372 gchar *col_name;
373 gint col_id;
374
375 col_id = GPOINTER_TO_INT(data);
376 view = (GtkTreeView *)g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
377 col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), col_id);
378 col_name = col_index_to_name(col_id);
379 gtk_tree_view_column_set_visible(col, prefs_capture_options_dialog_column_is_visible(col_name)?FALSE:TRUE);
380 set_capture_column_visible(col_name, prefs_capture_options_dialog_column_is_visible(col_name)?FALSE:TRUE);
381 }
382
383
384 static void
385 set_all_columns_visible (void)
386 {
387 GtkTreeViewColumn *col;
388 int col_id;
389 GtkTreeView *view;
390 gchar *name;
391
392 view = (GtkTreeView *)g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
393 for (col_id = 2; col_id < NUM_COLUMNS; col_id++) {
394 col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), col_id);
395 gtk_tree_view_column_set_visible(col, TRUE);
396 if ((name = col_index_to_name(col_id)) != NULL) {
397 set_capture_column_visible(name, TRUE);
398 }
399 }
400
401 if (!prefs.gui_use_pref_save) {
402 prefs_main_write();
403 }
404
405 update_visible_columns_menu ();
406 }
407
408 static void
409 columns_activate_all_columns_cb(GtkAction *action _U_, gpointer user_data _U_)
410 {
411 set_all_columns_visible ();
412 }
413
414 void
415 update_visible_tree_view_columns(void)
416 {
417 GtkTreeView *view;
418 gint col_id;
419 GtkTreeViewColumn *col;
420
421 view = (GtkTreeView *)g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
422 gtk_tree_view_column_set_visible(gtk_tree_view_get_column(GTK_TREE_VIEW(view), INTERFACE), TRUE);
423 for (col_id = 3; col_id < NUM_COLUMNS; col_id++) {
424 col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), col_id);
425 gtk_tree_view_column_set_visible(col, prefs_capture_options_dialog_column_is_visible(col_index_to_name(col_id))?TRUE:FALSE);
426 }
427 }
428
429
430 void
431 update_visible_columns_menu (void)
432 {
433 GtkWidget *menu_columns, *menu_item;
434 GtkWidget *sub_menu;
435 gchar *title;
436 gint col_id;
437
438 menu_columns = gtk_ui_manager_get_widget(ui_manager_columns, "/ColumnsPopup/DisplayedColumns");
439 /* Debug */
440 if (! menu_columns){
441 fprintf (stderr, "Warning: couldn't find menu_columns path=/ColumnsPopup/DisplayedColumns");
442 }
443
444 sub_menu = gtk_menu_new();
445 gtk_menu_item_set_submenu (GTK_MENU_ITEM(menu_columns), sub_menu);
446
447 for (col_id = 3; col_id < NUM_COLUMNS; col_id++) {
448 title = col_index_to_name(col_id);
449 menu_item = gtk_check_menu_item_new_with_label(title);
450 gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_item), prefs_capture_options_dialog_column_is_visible(title));
451 g_signal_connect(G_OBJECT(menu_item), "activate", G_CALLBACK(toggle_visible_column_cb), GINT_TO_POINTER(col_id));
452 gtk_menu_shell_append (GTK_MENU_SHELL(sub_menu), menu_item);
453 gtk_widget_show (menu_item);
454 }
455 menu_item = gtk_menu_item_new();
456 gtk_menu_shell_append (GTK_MENU_SHELL(sub_menu), menu_item);
457 gtk_widget_show (menu_item);
458
459 menu_item = gtk_menu_item_new_with_label ("Display All");
460 gtk_menu_shell_append (GTK_MENU_SHELL(sub_menu), menu_item);
461 g_signal_connect(menu_item, "activate", G_CALLBACK(columns_activate_all_columns_cb), NULL);
462 gtk_widget_show (menu_item);
463 }
464
465 static void
466 columns_pref_cb(GtkAction *action _U_, gpointer user_data)
467 {
468 GtkWidget *widget = gtk_ui_manager_get_widget(ui_manager_columns, "/ColumnsPopup/ColumnPreferences");
469 prefs_page_cb( widget , user_data, PREFS_PAGE_CAPTURE);
470 }
471
472 static void
473 columns_hide_col_cb(GtkAction *action _U_, gpointer user_data _U_)
474 {
475 GtkTreeView *view;
476 GtkTreeViewColumn *col;
477 gint num;
478 gchar *name;
479
480 view = (GtkTreeView *)g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
481 col = (GtkTreeViewColumn *)g_object_get_data(G_OBJECT(view), E_MCAPTURE_COLUMNS_COLUMN_KEY);
482 gtk_tree_view_column_set_visible(col, FALSE);
483 num = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(col), E_MCAPTURE_COLUMNS_COL_KEY));
484 if ((name = col_index_to_name(num)) != NULL) {
485 set_capture_column_visible(name, FALSE);
486 if (!prefs.gui_use_pref_save) {
487 prefs_main_write();
488 }
489 update_visible_columns_menu ();
490 }
491 }
492
493 static const char *ui_desc_columns_menu_popup =
494 "<ui>\n"
495 " <popup name='ColumnsPopup' action='PopupAction'>\n"
496 " <menuitem name='ColumnPreferences' action='/Column Preferences'/>\n"
497 " <menu name='DisplayedColumns' action='/Displayed Columns'>\n"
498 " <menuitem name='Display All' action='/Displayed Columns/Display All'/>\n"
499 " </menu>\n"
500 " <menuitem name='HideColumn' action='/Hide Column'/>\n"
501 " </popup>\n"
502 "</ui>\n";
503
504 static const GtkActionEntry columns_menu_popup_action_entries[] = {
505 { "/Column Preferences", GTK_STOCK_PREFERENCES, "Column Preferences...", NULL, NULL, G_CALLBACK(columns_pref_cb) },
506 { "/Displayed Columns", NULL, "Displayed Columns", NULL, NULL, NULL },
507 { "/Displayed Columns/Display All", NULL, "Display All", NULL, NULL, G_CALLBACK(columns_activate_all_columns_cb) },
508 { "/Hide Column", NULL, "Hide Column", NULL, NULL, G_CALLBACK(columns_hide_col_cb) },
509 };
510
511 #ifdef HAVE_PCAP_CREATE
512 static void
513 activate_monitor(GtkTreeViewColumn *tree_column, GtkCellRenderer *renderer,
514 GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data);
515 #endif
516
517 static void
518 init_columns_menu(void)
519 {
520 GtkActionGroup *columns_action_group;
521 GError *error = NULL;
522
523 columns_menu_object = gtk_menu_new();
524 /* columns pop-up menu */
525 columns_action_group = gtk_action_group_new ("ColumnsPopUpMenuActionGroup");
526
527 gtk_action_group_add_actions (columns_action_group, /* the action group */
528 (const GtkActionEntry *)columns_menu_popup_action_entries, /* an array of action descriptions */
529 G_N_ELEMENTS(columns_menu_popup_action_entries), /* the number of entries */
530 columns_menu_object); /* data to pass to the action callbacks */
531
532 ui_manager_columns = gtk_ui_manager_new ();
533 gtk_ui_manager_insert_action_group (ui_manager_columns,
534 columns_action_group,
535 0); /* the position at which the group will be inserted. */
536
537 gtk_ui_manager_add_ui_from_string (ui_manager_columns, ui_desc_columns_menu_popup, -1, &error);
538 if (error != NULL)
539 {
540 fprintf (stderr, "Warning: building Packet List Heading Pop-Up failed: %s\n", error->message);
541 g_error_free (error);
542 error = NULL;
543 }
544
545 g_object_set_data(G_OBJECT(columns_menu_object), PM_COLUMNS_KEY,
546 gtk_ui_manager_get_widget(ui_manager_columns, "/ColumnsPopup"));
547
548 popup_menu_list = g_slist_append((GSList *)popup_menu_list, ui_manager_columns);
549 }
550
551 /* stop the currently running capture */
552 void
553 capture_stop_cb(GtkWidget *w _U_, gpointer d _U_)
554 {
555 #ifdef HAVE_AIRPCAP
556 if (airpcap_if_active)
557 airpcap_set_toolbar_stop_capture(airpcap_if_active);
558 #endif
559
560 capture_stop(&global_capture_session);
561 }
562
563 /* restart (stop - delete old file - start) running capture */
564 void
565 capture_restart_cb(GtkWidget *w _U_, gpointer d _U_)
566 {
567 #ifdef HAVE_AIRPCAP
568 if (airpcap_if_active)
569 airpcap_set_toolbar_start_capture(airpcap_if_active);
570 #endif
571
572 capture_restart(&global_capture_session);
573 }
574
575 enum cfc_state_t {
576 CFC_PENDING,
577 CFC_UNKNOWN,
578 CFC_VALID,
579 CFC_INVALID
580 };
581
582 typedef struct capture_filter_check {
583 enum cfc_state_t state;
584 gchar *filter_text;
585 GtkWidget *filter_te;
586 int dlt;
587 } capture_filter_check_t;
588
589 /* Valid states:
590 *
591 * Idle: filter_text = NULL, state = ?
592 * Pending: filter_text != NULL, state = CFC_PENDING
593 * Unknown: filter_text != NULL, state = CFC_UNKNOWN
594 * Known: filter_text != NULL, state = CFC_VALID || CFC_INVALID
595 *
596 * We assume that only one text entry is active at a time.
597 */
598
599 /* We could make this smarter by caching results */
600 static capture_filter_check_t cfc_data;
601
602 static GMutex *pcap_compile_mtx;
603 static GCond *cfc_data_cond;
604 static GMutex *cfc_data_mtx;
605
606 #if 0
607 #define DEBUG_SYNTAX_CHECK(state1, state2) g_warning("CF state %s -> %s : %s", state1, state2, cfc_data.filter_text)
608 #else
609 #define DEBUG_SYNTAX_CHECK(state1, state2)
610 #endif
611
612 static void *
613 check_capture_filter_syntax(void *data _U_) {
614 struct bpf_program fcode;
615 int pc_err;
616
617 while (1) {
618 g_mutex_lock(cfc_data_mtx);
619 while (!cfc_data.filter_text || cfc_data.state != CFC_PENDING) {
620 /* Do we really need to use a mutex here? We only have one thread... */
621 g_cond_wait(cfc_data_cond, cfc_data_mtx);
622 }
623 cfc_data.state = CFC_UNKNOWN;
624 DEBUG_SYNTAX_CHECK("pending", "unknown");
625
626 g_mutex_unlock(cfc_data_mtx);
627 g_mutex_lock(pcap_compile_mtx);
628
629 /* pcap_compile_nopcap will not alter the filter string, so the (char *) cast is "safe" */
630 pc_err = pcap_compile_nopcap(DUMMY_SNAPLENGTH /* use a dummy snaplength for syntax-checking */,
631 cfc_data.dlt, &fcode, cfc_data.filter_text, 1 /* Do optimize */,
632 DUMMY_NETMASK /* use a dummy netmask for syntax-checking */);
633
634 g_mutex_unlock(pcap_compile_mtx);
635 g_mutex_lock(cfc_data_mtx);
636
637 if (cfc_data.state == CFC_UNKNOWN) { /* No more input came in */
638 if (pc_err) {
639 DEBUG_SYNTAX_CHECK("unknown", "known bad");
640 cfc_data.state = CFC_INVALID;
641 } else {
642 DEBUG_SYNTAX_CHECK("unknown", "known good");
643 cfc_data.state = CFC_VALID;
644 }
645 }
646 g_mutex_unlock(cfc_data_mtx);
647 }
648 return NULL;
649 }
650
651 static gboolean
652 update_capture_filter_te(gpointer data _U_) {
653
654 g_mutex_lock(cfc_data_mtx);
655
656 if (cfc_data.filter_text && cfc_data.filter_te) {
657 if (cfc_data.state == CFC_VALID) {
658 colorize_filter_te_as_valid(cfc_data.filter_te);
659 } else if (cfc_data.state == CFC_INVALID) {
660 colorize_filter_te_as_invalid(cfc_data.filter_te);
661 } else {
662 colorize_filter_te_as_empty(cfc_data.filter_te);
663 }
664
665 if (cfc_data.state == CFC_VALID || cfc_data.state == CFC_INVALID) {
666 DEBUG_SYNTAX_CHECK("known", "idle");
667 /* Reset the current state to idle. */
668 if (cfc_data.filter_text != NULL) {
669 g_free(cfc_data.filter_text);
670 }
671 cfc_data.filter_text = NULL;
672 cfc_data.state = CFC_PENDING;
673 }
674 }
675 g_mutex_unlock(cfc_data_mtx);
676 return TRUE;
677 }
678
679 /** Initialize background capture filter syntax checking
680 */
681 void capture_filter_init(void) {
682 cfc_data.filter_text = NULL;
683 cfc_data.filter_te = NULL;
684 cfc_data.state = CFC_PENDING;
685
686 #if GLIB_CHECK_VERSION(2,31,0)
687 pcap_compile_mtx = g_new(GMutex,1);
688 g_mutex_init(pcap_compile_mtx);
689 cfc_data_cond = g_new(GCond,1);
690 g_cond_init(cfc_data_cond);
691 cfc_data_mtx = g_new(GMutex,1);
692 g_mutex_init(cfc_data_mtx);
693 g_thread_new("Capture filter syntax", check_capture_filter_syntax, NULL);
694 #else
695 pcap_compile_mtx = g_mutex_new();
696 cfc_data_cond = g_cond_new();
697 cfc_data_mtx = g_mutex_new();
698 g_thread_create(check_capture_filter_syntax, NULL, FALSE, NULL);
699 #endif
700
701 g_timeout_add(200, update_capture_filter_te, NULL);
702 }
703
704 static void
705 update_filter_string(gchar *name, gchar *text)
706 {
707 GtkTreeIter iter;
708 GtkTreeView *if_cb;
709 GtkTreeModel *model;
710 gchar *name_str;
711
712 if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
713 model = gtk_tree_view_get_model(if_cb);
714 gtk_tree_model_get_iter_first(model, &iter);
715 do {
716 gtk_tree_model_get(model, &iter, IFACE_HIDDEN_NAME, &name_str, -1);
717 if (strcmp(name, name_str) == 0) {
718 gtk_list_store_set (GTK_LIST_STORE(model), &iter, FILTER, g_strdup(text), -1);
719 break;
720 }
721 } while (gtk_tree_model_iter_next(model, &iter));
722 }
723
724 static void
725 capture_all_filter_check_syntax_cb(GtkWidget *w _U_, gpointer user_data _U_)
726 {
727 GtkWidget *filter_cm, *filter_te;
728 gchar *filter_text = NULL;
729 guint i;
730
731 filter_cm = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY);
732
733 if (!filter_cm)
734 return;
735
736 filter_te = gtk_bin_get_child(GTK_BIN(filter_cm));
737
738 if (!filter_te)
739 return;
740
741 if (global_capture_opts.num_selected > 0) {
742 interface_t device;
743
744 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
745 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
746 if (!device.selected) {
747 continue;
748 }
749 if (device.active_dlt == -1) {
750 colorize_filter_te_as_empty(filter_te);
751 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "The link type of interface %s was not specified.", device.name);
752 continue; /* Programming error: somehow managed to select an "unsupported" entry */
753 }
754 filter_text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(filter_cm));
755 if (strlen(filter_text) == 0) {
756 colorize_filter_te_as_empty(filter_te);
757 if (strlen(device.cfilter) > 0) {
758 g_array_remove_index(global_capture_opts.all_ifaces, i);
759 device.cfilter = g_strdup(filter_text);
760 g_array_insert_val(global_capture_opts.all_ifaces, i, device);
761 update_filter_string(device.name, filter_text);
762 }
763 g_free(filter_text);
764 continue;
765 }
766 g_assert(filter_text != NULL);
767 g_array_remove_index(global_capture_opts.all_ifaces, i);
768 device.cfilter = g_strdup(filter_text);
769 g_array_insert_val(global_capture_opts.all_ifaces, i, device);
770 g_mutex_lock(cfc_data_mtx);
771 /* Ruthlessly clobber the current state. */
772 g_free(cfc_data.filter_text);
773 cfc_data.dlt = device.active_dlt;
774 cfc_data.filter_text = filter_text;
775 cfc_data.filter_te = filter_te;
776 cfc_data.state = CFC_PENDING;
777 DEBUG_SYNTAX_CHECK("?", "pending");
778 g_cond_signal(cfc_data_cond);
779 g_mutex_unlock(cfc_data_mtx);
780 update_filter_string(device.name, filter_text);
781 }
782 }
783 }
784
785 static void
786 capture_filter_check_syntax_cb(GtkWidget *w _U_, gpointer user_data _U_)
787 {
788 GtkWidget *filter_cm, *filter_te, *linktype_combo_box;
789 gchar *filter_text;
790 gpointer dlt_ptr;
791
792 filter_cm = (GtkWidget *)g_object_get_data(G_OBJECT(opt_edit_w), E_CFILTER_CM_KEY);
793 if (!filter_cm)
794 return;
795 filter_te = gtk_bin_get_child(GTK_BIN(filter_cm));
796 if (!filter_te)
797 return;
798
799 linktype_combo_box = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_LT_CBX_KEY);
800
801 if (! ws_combo_box_get_active_pointer(GTK_COMBO_BOX(linktype_combo_box), &dlt_ptr)) {
802 /*
803 * There is no guarantee that we will even know the list of link-layer
804 * header types; we will not have it if, for example, we have a named
805 * pipe rather than an interface, as a named pipe doesn't *have* a
806 * link-layer header type until the capture is started and the
807 * pcap file header or pcap-ng interface description block is
808 * written, and we can't wait for that. We won't have it if we can't
809 * open the interface, either.
810 *
811 * We also won't have an active pointer, even if we have the list of
812 * link-layer header types, if none of the types are supported.
813 *
814 * Just mark it as empty, as a way of saying "damned if I know whether
815 * this filter is valid".
816 */
817 colorize_filter_te_as_empty(filter_te);
818 return;
819 }
820 if ((cfc_data.dlt = GPOINTER_TO_INT(dlt_ptr)) == -1) {
821 g_assert_not_reached(); /* Programming error: somehow managed to select an "unsupported" entry */
822 }
823
824 filter_text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(filter_cm));
825
826 if (strlen(filter_text) == 0) {
827 colorize_filter_te_as_empty(filter_te);
828 g_free(filter_text);
829 return;
830 }
831
832 g_mutex_lock(cfc_data_mtx);
833 /* Ruthlessly clobber the current state. */
834 if (cfc_data.filter_text != NULL) {
835 g_free(cfc_data.filter_text);
836 }
837 cfc_data.filter_text = filter_text;
838 cfc_data.filter_te = filter_te;
839 cfc_data.state = CFC_PENDING;
840 DEBUG_SYNTAX_CHECK("?", "pending");
841 g_cond_signal(cfc_data_cond);
842 g_mutex_unlock(cfc_data_mtx);
843 }
844
845 static void
846 capture_filter_destroy_cb(GtkWidget *w _U_, gpointer user_data _U_)
847 {
848 g_mutex_lock(cfc_data_mtx);
849 /* Reset the current state to idle. */
850 if (cfc_data.filter_text != NULL) {
851 g_free(cfc_data.filter_text);
852 }
853 cfc_data.filter_text = NULL;
854 cfc_data.filter_te = NULL;
855 cfc_data.state = CFC_PENDING;
856 g_mutex_unlock(cfc_data_mtx);
857 }
858
859 #define TIME_UNIT_SECOND 0
860 #define TIME_UNIT_MINUTE 1
861 #define TIME_UNIT_HOUR 2
862 #define TIME_UNIT_DAY 3
863 #define MAX_TIME_UNITS 4
864 static const char *time_unit_name[MAX_TIME_UNITS] = {
865 "second(s)",
866 "minute(s)",
867 "hour(s)",
868 "day(s)",
869 };
870
871 /* create one of the duration options */
872 /* (and select the matching unit depending on the given value) */
873 static GtkWidget *time_unit_combo_box_new(guint32 value) {
874 GtkWidget *unit_combo_box;
875 int i;
876
877 unit_combo_box = gtk_combo_box_text_new ();
878 for (i = 0; i < MAX_TIME_UNITS; i++) {
879 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (unit_combo_box), time_unit_name[i]);
880 }
881 /* the selected combo_box item can't be changed, once the combo_box
882 is created, so set the matching combo_box item now */
883 /* days */
884 if (value >= 60 * 60 * 24) {
885 gtk_combo_box_set_active(GTK_COMBO_BOX(unit_combo_box), TIME_UNIT_DAY);
886 } else {
887 /* hours */
888 if (value >= 60 * 60) {
889 gtk_combo_box_set_active(GTK_COMBO_BOX(unit_combo_box), TIME_UNIT_HOUR);
890 } else {
891 /* minutes */
892 if (value >= 60) {
893 gtk_combo_box_set_active(GTK_COMBO_BOX(unit_combo_box), TIME_UNIT_MINUTE);
894 } else {
895 /* seconds */
896 gtk_combo_box_set_active(GTK_COMBO_BOX(unit_combo_box), TIME_UNIT_SECOND);
897 }
898 }
899 }
900 return unit_combo_box;
901 }
902
903 /* convert time value from raw to displayed (e.g. 60s -> 1min) */
904 static guint32 time_unit_combo_box_convert_value(
905 guint32 value)
906 {
907 /* days */
908 if (value >= 60 * 60 * 24) {
909 return value / (60 * 60 * 24);
910 }
911
912 /* hours */
913 if (value >= 60 * 60) {
914 return value / (60 * 60);
915 }
916
917 /* minutes */
918 if (value >= 60) {
919 return value / 60;
920 }
921
922 /* seconds */
923 return value;
924 }
925
926 /* get raw value from unit and value fields */
927 static guint32 time_unit_combo_box_get_value(
928 GtkWidget *unit_combo_box,
929 guint32 value)
930 {
931 int unit;
932
933 unit = gtk_combo_box_get_active (GTK_COMBO_BOX(unit_combo_box));
934
935 switch(unit) {
936 case(TIME_UNIT_SECOND):
937 return value;
938 case(TIME_UNIT_MINUTE):
939 return value * 60;
940 case(TIME_UNIT_HOUR):
941 return value * 60 * 60;
942 case(TIME_UNIT_DAY):
943 return value * 60 * 60 * 24;
944 default:
945 g_assert_not_reached();
946 return 0;
947 }
948 }
949
950
951 #define SIZE_UNIT_KILOBYTES 0
952 #define SIZE_UNIT_MEGABYTES 1
953 #define SIZE_UNIT_GIGABYTES 2
954 #define MAX_SIZE_UNITS 3
955 static const char *size_unit_name[MAX_SIZE_UNITS] = {
956 "kibibyte(s)",
957 "mebibyte(s)",
958 "gibibyte(s)"
959 };
960
961 /* create one of the size options */
962 /* (and select the matching unit depending on the given value) */
963 static GtkWidget *size_unit_combo_box_new(guint32 value) {
964 GtkWidget *unit_combo_box;
965 int i;
966
967 unit_combo_box=gtk_combo_box_text_new();
968 for (i=0; i<MAX_SIZE_UNITS; i++){
969 gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (unit_combo_box), size_unit_name[i]);
970 }
971 /* the selected combo_box item can't be changed, once the combo_box
972 is created, so set the matching combo_box item now */
973 /* gigabytes */
974 if (value >= 1024 * 1024) {
975 gtk_combo_box_set_active(GTK_COMBO_BOX(unit_combo_box), SIZE_UNIT_GIGABYTES);
976 } else {
977 /* megabytes */
978 if (value >= 1024) {
979 gtk_combo_box_set_active(GTK_COMBO_BOX(unit_combo_box), SIZE_UNIT_MEGABYTES);
980 } else {
981 /* kilobytes */
982 gtk_combo_box_set_active(GTK_COMBO_BOX(unit_combo_box), SIZE_UNIT_KILOBYTES);
983 }
984 }
985 return unit_combo_box;
986 }
987
988 /* convert size value from raw to displayed (e.g. 1024 Bytes -> 1 KB) */
989 static guint32 size_unit_combo_box_set_value(
990 guint32 value)
991 {
992 /* gigabytes */
993 if (value >= 1024 * 1024) {
994 return value / (1024 * 1024);
995 }
996
997 /* megabytes */
998 if (value >= 1024) {
999 return value / (1024);
1000 }
1001
1002 /* kilobytes */
1003 return value;
1004 }
1005
1006 /* get raw value from unit and value fields */
1007 static guint32 size_unit_combo_box_convert_value(
1008 GtkWidget *unit_combo_box,
1009 guint32 value)
1010 {
1011 int unit;
1012
1013 unit = gtk_combo_box_get_active (GTK_COMBO_BOX(unit_combo_box));
1014
1015 switch(unit) {
1016 case(SIZE_UNIT_KILOBYTES):
1017 if (value > (((guint32)G_MAXINT + 1) / 1024)) {
1018 return 0;
1019 } else {
1020 return value;
1021 }
1022 case(SIZE_UNIT_MEGABYTES):
1023 if (value > (((guint32)G_MAXINT + 1) / (1024 * 1024))) {
1024 return 0;
1025 } else {
1026 return value * 1024;
1027 }
1028 case(SIZE_UNIT_GIGABYTES):
1029 if (value > (((guint32)G_MAXINT + 1) / (1024 * 1024 * 1024))) {
1030 return 0;
1031 } else {
1032 return value * 1024 * 1024;
1033 }
1034 default:
1035 g_assert_not_reached();
1036 return 0;
1037 }
1038 }
1039
1040 #ifdef HAVE_AIRPCAP
1041 /*
1042 * Sets the toolbar before calling the advanced dialog with for the right interface
1043 */
1044 static void
1045 options_airpcap_advanced_cb(GtkWidget *w, gpointer d)
1046 {
1047 int *from_widget;
1048
1049 from_widget = (gint*)g_malloc(sizeof(gint));
1050 *from_widget = AIRPCAP_ADVANCED_FROM_OPTIONS;
1051 g_object_set_data(G_OBJECT(wireless_tb),AIRPCAP_ADVANCED_FROM_KEY,from_widget);
1052
1053 airpcap_if_active = airpcap_if_selected;
1054 airpcap_enable_toolbar_widgets(wireless_tb,FALSE);
1055 display_airpcap_advanced_cb(w,d);
1056 }
1057 #endif
1058
1059 #ifdef HAVE_PCAP_REMOTE
1060 /* PCAP interface type menu item */
1061 struct iftype_info {
1062 capture_source id;
1063 const char *name;
1064 };
1065
1066 /* List of available types of PCAP interface */
1067 static struct iftype_info iftype[] = {
1068 { CAPTURE_IFLOCAL, "Local" },
1069 { CAPTURE_IFREMOTE, "Remote..." }
1070 };
1071
1072 #define REMOTE_HOST_START ((sizeof(iftype) / sizeof(iftype[0])) + 1)
1073 #define REMOTE_HOST_SEPARATOR "---"
1074
1075 static void
1076 iftype_combo_box_add_remote_separators (GtkWidget *iftype_cbx)
1077 {
1078 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(iftype_cbx), REMOTE_HOST_SEPARATOR);
1079 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(iftype_cbx), "Clear list");
1080 }
1081
1082 static void
1083 iftype_combo_box_add (GtkWidget *iftype_cbx, interface_t *device)
1084 {
1085 GtkTreeModel *model;
1086 GtkTreeIter iter;
1087 gboolean create_new = FALSE;
1088 gchar *string;
1089 guint i, pos = REMOTE_HOST_START;
1090 struct remote_host_info *rh;
1091
1092 rh = g_hash_table_lookup (remote_host_list, device->remote_opts.remote_host_opts.remote_host);
1093 if (!rh) {
1094 rh = g_malloc0 (sizeof (*rh));
1095 if (g_hash_table_size (remote_host_list) == 0) {
1096 iftype_combo_box_add_remote_separators (iftype_cbx);
1097 }
1098 gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(iftype_cbx), pos, device->remote_opts.remote_host_opts.remote_host);
1099 rh->remote_host = g_strdup (device->remote_opts.remote_host_opts.remote_host);
1100 create_new = TRUE;
1101 } else {
1102 model = gtk_combo_box_get_model(GTK_COMBO_BOX(iftype_cbx));
1103 if (gtk_tree_model_get_iter_first(model, &iter)) {
1104 /* Skip the first entries */
1105 for (i = 0; i < REMOTE_HOST_START; i++)
1106 gtk_tree_model_iter_next(model, &iter);
1107 do {
1108 gtk_tree_model_get(model, &iter, 0, &string, -1);
1109 if (string) {
1110 if (strcmp (device->remote_opts.remote_host_opts.remote_host, string) == 0) {
1111 /* Found match, show this position in combo box */
1112 g_free (string);
1113 break;
1114 }
1115 g_free (string);
1116 }
1117 pos++;
1118 } while (gtk_tree_model_iter_next(model, &iter));
1119 }
1120
1121 g_free (rh->remote_port);
1122 g_free (rh->auth_username);
1123 g_free (rh->auth_password);
1124 }
1125
1126 rh->remote_port = g_strdup (device->remote_opts.remote_host_opts.remote_port);
1127 rh->auth_type = device->remote_opts.remote_host_opts.auth_type;
1128 rh->auth_username = g_strdup (device->remote_opts.remote_host_opts.auth_username);
1129 rh->auth_password = g_strdup (device->remote_opts.remote_host_opts.auth_password);
1130
1131 if (create_new) {
1132 g_hash_table_insert (remote_host_list, g_strdup (device->remote_opts.remote_host_opts.remote_host), rh);
1133 }
1134
1135 g_object_set_data(G_OBJECT(iftype_cbx), E_CAP_CBX_IFTYPE_NOUPDATE_KEY, GINT_TO_POINTER(1));
1136 gtk_combo_box_set_active(GTK_COMBO_BOX(iftype_cbx), pos);
1137 g_object_set_data(G_OBJECT(iftype_cbx), E_CAP_CBX_IFTYPE_NOUPDATE_KEY, GINT_TO_POINTER(0));
1138 }
1139
1140 static void
1141 iftype_combo_box_add_remote_host (gpointer key, gpointer value _U_, gpointer user_data)
1142 {
1143 gtk_combo_box_text_insert_text(GTK_COMBO_BOX_TEXT(user_data), REMOTE_HOST_START, key);
1144
1145 /* if (g_array_index(global_capture_opts.ifaces, interface_options, 0).src_type == CAPTURE_IFREMOTE) {*/
1146 /* Ensure we select the correct entry */
1147 /* if (strcmp ((char *)key, g_array_index(global_capture_opts.ifaces, interface_options, 0).remote_host) == 0) {
1148 gtk_combo_box_set_active(GTK_COMBO_BOX(user_data), REMOTE_HOST_START);
1149 }
1150 }*/
1151 }
1152
1153 /* Fill the menu of available types of interfaces */
1154 static GtkWidget *
1155 iftype_combo_box_new(void)
1156 {
1157 GtkWidget *iftype_cbx;
1158
1159 iftype_cbx = gtk_combo_box_text_new_with_entry();
1160
1161 /* for (i = 0; i < sizeof(iftype) / sizeof(iftype[0]); i++) {
1162 gtk_combo_box_text_append_text(GTK_COMBO_BOX(iftype_cbx), iftype[i].name);
1163 }*/
1164
1165 if (g_hash_table_size (remote_host_list) > 0) {
1166 /* Add remote hosts */
1167 g_hash_table_foreach (remote_host_list, iftype_combo_box_add_remote_host, iftype_cbx);
1168 iftype_combo_box_add_remote_separators (iftype_cbx);
1169 }
1170
1171 g_signal_connect(iftype_cbx, "changed", G_CALLBACK(select_if_type_cb), NULL);
1172
1173 return iftype_cbx;
1174 }
1175
1176 static gboolean
1177 iftype_combo_is_separator (GtkTreeModel *model, GtkTreeIter *iter, gpointer data _U_)
1178 {
1179 gboolean result = FALSE;
1180 gchar *string;
1181
1182 gtk_tree_model_get(model, iter, 0, &string, -1);
1183 if (string) {
1184 result = !strcmp (string, REMOTE_HOST_SEPARATOR);
1185 g_free (string);
1186 }
1187
1188 return result;
1189
1190 }
1191 #endif
1192
1193 #ifdef HAVE_PCAP_REMOTE
1194 static void
1195 error_list_remote_interface_cb (gpointer dialog _U_, gint btn _U_, gpointer data)
1196 {
1197 capture_remote_cb(GTK_WIDGET(data), FALSE);
1198 }
1199
1200 static void
1201 insert_new_rows(GList *list)
1202 {
1203 interface_t device;
1204 GtkTreeIter iter;
1205 GList *if_entry;
1206 if_info_t *if_info;
1207 char *if_string = NULL, *temp = NULL, *snaplen_string;
1208 gchar *descr;
1209 if_capabilities_t *caps;
1210 gint linktype_count;
1211 gboolean monitor_mode;
1212 GSList *curr_addr;
1213 int ips = 0;
1214 guint i;
1215 if_addr_t *addr;
1216 GList *lt_entry;
1217 data_link_info_t *data_link_info;
1218 gchar *str = NULL, *link_type_name = NULL;
1219 gboolean found = FALSE;
1220 GString *ip_str;
1221 GtkTreeView *if_cb;
1222 GtkTreeModel *model;
1223 link_row *linkr = NULL;
1224
1225 if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
1226 model = gtk_tree_view_get_model(if_cb);
1227 /* Scan through the list and build a list of strings to display. */
1228 for (if_entry = g_list_first(list); if_entry != NULL; if_entry = g_list_next(if_entry)) {
1229 if_info = (if_info_t *)if_entry->data;
1230 #ifdef HAVE_PCAP_REMOTE
1231 add_interface_to_remote_list(if_info);
1232 #endif
1233 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
1234 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
1235 if (strcmp(device.name, if_info->name) == 0) {
1236 found = TRUE;
1237 break;
1238 }
1239 }
1240 if (found) {
1241 found = FALSE;
1242 continue;
1243 }
1244 ip_str = g_string_new("");
1245 str = "";
1246 ips = 0;
1247 device.name = g_strdup(if_info->name);
1248 /* Is this interface hidden and, if so, should we include it
1249 anyway? */
1250 descr = capture_dev_user_descr_find(if_info->name);
1251 if (descr != NULL) {
1252 /* Yes, we have a user-supplied description; use it. */
1253 if_string = g_strdup_printf("%s: %s", descr, if_info->name);
1254 g_free(descr);
1255 } else {
1256 /* No, we don't have a user-supplied description; did we get
1257 one from the OS or libpcap? */
1258 if (if_info->vendor_description != NULL) {
1259 /* Yes - use it. */
1260 if_string = g_strdup_printf("%s: %s", if_info->vendor_description, if_info->name);
1261 } else {
1262 /* No. */
1263 if_string = g_strdup(if_info->name);
1264 }
1265 } /* else descr != NULL */
1266 if (if_info->loopback) {
1267 device.display_name = g_strdup_printf("%s (loopback)", if_string);
1268 } else {
1269 device.display_name = g_strdup(if_string);
1270 }
1271 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
1272 if ((device.buffer = capture_dev_user_buffersize_find(if_string)) == -1) {
1273 device.buffer = global_capture_opts.default_options.buffer_size;
1274 }
1275 #endif
1276 if ((device.pmode = capture_dev_user_pmode_find(if_string)) == -1) {
1277 device.pmode = global_capture_opts.default_options.promisc_mode;
1278 }
1279 device.has_snaplen = global_capture_opts.default_options.has_snaplen;
1280 if ((device.snaplen = capture_dev_user_snaplen_find(if_string)) == -1) {
1281 device.snaplen = global_capture_opts.default_options.snaplen;
1282 }
1283 device.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
1284 monitor_mode = prefs_capture_device_monitor_mode(if_string);
1285 caps = capture_get_if_capabilities(if_string, monitor_mode, NULL,main_window_update);
1286 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
1287 for (; (curr_addr = g_slist_nth(if_info->addrs, ips)) != NULL; ips++) {
1288 if (ips != 0) {
1289 g_string_append(ip_str, "\n");
1290 }
1291 addr = (if_addr_t *)curr_addr->data;
1292
1293 switch (addr->ifat_type) {
1294 case IF_AT_IPv4:
1295 g_string_append(ip_str, ip_to_str((guint8 *)&addr->addr.ip4_addr));
1296 break;
1297 case IF_AT_IPv6:
1298 g_string_append(ip_str, ip6_to_str((struct e_in6_addr *)&addr->addr.ip6_addr));
1299 break;
1300 default:
1301 /* In case we add non-IP addresses */
1302 break;
1303 }
1304 } /* for curr_addr */
1305 linktype_count = 0;
1306 device.links = NULL;
1307 if (caps != NULL) {
1308 #ifdef HAVE_PCAP_CREATE
1309 device.monitor_mode_enabled = monitor_mode;
1310 device.monitor_mode_supported = caps->can_set_rfmon;
1311 #endif
1312 for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
1313 data_link_info = (data_link_info_t *)lt_entry->data;
1314 linkr = (link_row *)g_malloc(sizeof(link_row));
1315 if (data_link_info->description != NULL) {
1316 str = g_strdup_printf("%s", data_link_info->description);
1317 linkr->dlt = data_link_info->dlt;
1318 } else {
1319 str = g_strdup_printf("%s (not supported)", data_link_info->name);
1320 linkr->dlt = -1;
1321 }
1322 if (linktype_count == 0) {
1323 link_type_name = g_strdup(str);
1324 device.active_dlt = data_link_info->dlt;
1325 }
1326 linkr->name = g_strdup(str);
1327 g_free(str);
1328 device.links = g_list_append(device.links, linkr);
1329 linktype_count++;
1330 } /* for link_types */
1331 } else {
1332 #if defined(HAVE_PCAP_CREATE)
1333 device.monitor_mode_enabled = FALSE;
1334 device.monitor_mode_supported = FALSE;
1335 #endif
1336 device.active_dlt = -1;
1337 link_type_name = g_strdup("default");
1338 }
1339 device.addresses = g_strdup(ip_str->str);
1340 device.no_addresses = ips;
1341 if (ips == 0) {
1342 temp = g_strdup_printf("<b>%s</b>", device.display_name);
1343 } else {
1344 temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", device.display_name, device.addresses);
1345 }
1346 #ifdef HAVE_PCAP_REMOTE
1347 device.remote_opts.src_type= global_remote_opts.src_type;
1348 if (device.remote_opts.src_type == CAPTURE_IFREMOTE) {
1349 device.local = FALSE;
1350 }
1351 device.remote_opts.remote_host_opts.remote_host = g_strdup(global_remote_opts.remote_host_opts.remote_host);
1352 device.remote_opts.remote_host_opts.remote_port = g_strdup(global_remote_opts.remote_host_opts.remote_port);
1353 device.remote_opts.remote_host_opts.auth_type = global_remote_opts.remote_host_opts.auth_type;
1354 device.remote_opts.remote_host_opts.auth_username = g_strdup(global_remote_opts.remote_host_opts.auth_username);
1355 device.remote_opts.remote_host_opts.auth_password = g_strdup(global_remote_opts.remote_host_opts.auth_password);
1356 device.remote_opts.remote_host_opts.datatx_udp = global_remote_opts.remote_host_opts.datatx_udp;
1357 device.remote_opts.remote_host_opts.nocap_rpcap = global_remote_opts.remote_host_opts.nocap_rpcap;
1358 device.remote_opts.remote_host_opts.nocap_local = global_remote_opts.remote_host_opts.nocap_local;
1359 #else
1360 device.local = TRUE;
1361 #endif
1362 #ifdef HAVE_PCAP_SETSAMPLING
1363 device.remote_opts.sampling_method = global_remote_opts.sampling_method;
1364 device.remote_opts.sampling_param = global_remote_opts.sampling_param;
1365 #endif
1366 device.selected = TRUE;
1367 global_capture_opts.num_selected++;
1368 g_array_append_val(global_capture_opts.all_ifaces, device);
1369 if (device.has_snaplen) {
1370 snaplen_string = g_strdup_printf("%d", device.snaplen);
1371 } else {
1372 snaplen_string = g_strdup("default");
1373 }
1374
1375 #if defined(HAVE_PCAP_CREATE)
1376 gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, device.buffer, MONITOR, "no",FILTER, "",-1);
1377 #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
1378 gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link_type_name, PMODE, (device.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, device.buffer, FILTER, "",-1);
1379 #else
1380 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);
1381 #endif
1382 g_string_free(ip_str, TRUE);
1383 #ifdef HAVE_PCAP_REMOTE
1384 add_interface_to_list(global_capture_opts.all_ifaces->len-1);
1385 #endif
1386 } /*for*/
1387 gtk_tree_view_set_model(GTK_TREE_VIEW(if_cb), model);
1388 }
1389 #endif
1390
1391 #ifdef HAVE_PCAP_REMOTE
1392 /* Retrieve the list of local or remote interfaces according to selected
1393 * options and re-fill interface name combobox */
1394 static void
1395 update_interface_list(void)
1396 {
1397 GtkWidget *iftype_cbx;
1398 GList *if_list, *if_r_list;
1399 int iftype_id, err;
1400 gchar *err_str;
1401
1402 if (cap_open_w == NULL)
1403 return;
1404 iftype_cbx = (GtkWidget *)g_object_get_data(G_OBJECT(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY)), E_REMOTE_HOST_TE_KEY);
1405 iftype_id = CAPTURE_IFREMOTE;
1406 if (iftype_id >= CAPTURE_IFREMOTE) {
1407 if_r_list = get_remote_interface_list(global_remote_opts.remote_host_opts.remote_host,
1408 global_remote_opts.remote_host_opts.remote_port,
1409 global_remote_opts.remote_host_opts.auth_type,
1410 global_remote_opts.remote_host_opts.auth_username,
1411 global_remote_opts.remote_host_opts.auth_password,
1412 &err, &err_str);
1413
1414 if_list = if_r_list;
1415 } else {
1416 if_list = capture_interface_list(&err, &err_str, main_window_update); /* Warning: see capture_prep_cb() */
1417 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_IF_LIST_KEY, NULL);
1418 }
1419
1420 if (if_list == NULL &&
1421 (err == CANT_GET_INTERFACE_LIST || err == DONT_HAVE_PCAP)) {
1422 gpointer dialog = simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
1423 g_free(err_str);
1424
1425 if (iftype_id >= CAPTURE_IFREMOTE) {
1426 /* Fall back to previous interface list */
1427 simple_dialog_set_cb(dialog, error_list_remote_interface_cb, iftype_cbx);
1428 return;
1429 }
1430 } else if (iftype_id == CAPTURE_IFREMOTE) {
1431 /* New remote interface */
1432 insert_new_rows(if_list);
1433 refresh_non_local_interface_lists();
1434 }
1435 }
1436
1437 /* User changed an interface entry of "Remote interface" dialog */
1438 static void
1439 capture_remote_adjust_sensitivity(GtkWidget *tb _U_, gpointer parent_w)
1440 {
1441 GtkWidget *auth_passwd_rb,
1442 *username_lb, *username_te,
1443 *passwd_lb, *passwd_te;
1444 gboolean state;
1445
1446 auth_passwd_rb = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w),
1447 E_REMOTE_AUTH_PASSWD_KEY);
1448 username_lb = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w),
1449 E_REMOTE_USERNAME_LB_KEY);
1450 username_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w),
1451 E_REMOTE_USERNAME_TE_KEY);
1452 passwd_lb = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_REMOTE_PASSWD_LB_KEY);
1453 passwd_te = (GtkWidget *)g_object_get_data(G_OBJECT(parent_w), E_REMOTE_PASSWD_TE_KEY);
1454
1455 state = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(auth_passwd_rb));
1456 gtk_widget_set_sensitive(GTK_WIDGET(username_lb), state);
1457 gtk_widget_set_sensitive(GTK_WIDGET(username_te), state);
1458 gtk_widget_set_sensitive(GTK_WIDGET(passwd_lb), state);
1459 gtk_widget_set_sensitive(GTK_WIDGET(passwd_te), state);
1460 }
1461
1462 /* user requested to destroy the dialog */
1463 static void
1464 capture_remote_destroy_cb(GtkWidget *win, gpointer user_data _U_)
1465 {
1466 g_object_set_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY, NULL);
1467 }
1468
1469 /* user requested to accept remote interface options */
1470 static void
1471 capture_remote_ok_cb(GtkWidget *win _U_, GtkWidget *remote_w)
1472 {
1473 GtkWidget *host_te, *port_te, *username_te, *passwd_te, *auth_passwd_rb;
1474 gchar *hostname;
1475
1476 if (remote_w == NULL) {
1477 return;
1478 }
1479
1480 host_te = (GtkWidget *)g_object_get_data(G_OBJECT(remote_w), E_REMOTE_HOST_TE_KEY);
1481 hostname = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(host_te));
1482 port_te = (GtkWidget *)g_object_get_data(G_OBJECT(remote_w), E_REMOTE_PORT_TE_KEY);
1483 username_te = (GtkWidget *)g_object_get_data(G_OBJECT(remote_w),
1484 E_REMOTE_USERNAME_TE_KEY);
1485 passwd_te = (GtkWidget *)g_object_get_data(G_OBJECT(remote_w), E_REMOTE_PASSWD_TE_KEY);
1486 auth_passwd_rb = (GtkWidget *) g_object_get_data(G_OBJECT(remote_w), E_REMOTE_AUTH_PASSWD_KEY);
1487 g_free(global_remote_opts.remote_host_opts.remote_host);
1488 global_remote_opts.remote_host_opts.remote_host = hostname;
1489 g_free(global_remote_opts.remote_host_opts.remote_port);
1490 global_remote_opts.remote_host_opts.remote_port = g_strdup(gtk_entry_get_text(GTK_ENTRY(port_te)));
1491 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(auth_passwd_rb)))
1492 global_remote_opts.remote_host_opts.auth_type = CAPTURE_AUTH_PWD;
1493 else
1494 global_remote_opts.remote_host_opts.auth_type = CAPTURE_AUTH_NULL;
1495 g_free(global_remote_opts.remote_host_opts.auth_username);
1496 global_remote_opts.remote_host_opts.auth_username =
1497 g_strdup(gtk_entry_get_text(GTK_ENTRY(username_te)));
1498
1499 g_free(global_remote_opts.remote_host_opts.auth_password);
1500 global_remote_opts.remote_host_opts.auth_password =
1501 g_strdup(gtk_entry_get_text(GTK_ENTRY(passwd_te)));
1502
1503 window_destroy(GTK_WIDGET(remote_w));
1504 update_interface_list();
1505 fill_remote_list();
1506 }
1507
1508 static void
1509 capture_remote_cancel_cb(GtkWidget *win, gpointer data)
1510 {
1511 window_cancel_button_cb (win, data);
1512 }
1513
1514 static gboolean
1515 free_remote_host (gpointer key _U_, gpointer value, gpointer user _U_)
1516 {
1517 struct remote_host *rh = value;
1518
1519 g_free (rh->remote_host);
1520 g_free (rh->remote_port);
1521 g_free (rh->auth_username);
1522 g_free (rh->auth_password);
1523
1524 return TRUE;
1525 }
1526
1527 static void
1528 select_if_type_cb(GtkComboBox *iftype_cbx, gpointer data _U_)
1529 {
1530 gchar *string;
1531 GtkWidget *port_te, *auth_rb, *user_te, *pass_te;
1532 GtkWidget *remote_w;
1533 struct remote_host *rh;
1534
1535 int new_iftype = gtk_combo_box_get_active(GTK_COMBO_BOX(iftype_cbx));
1536 gint num_remote = g_hash_table_size (remote_host_list);
1537
1538 if (new_iftype != -1 && new_iftype == num_remote+1) {
1539 g_hash_table_foreach_remove (remote_host_list, free_remote_host, NULL);
1540 num_remote += 2;
1541 while (num_remote--) { /* Remove separator lines and "Clear" item */
1542 gtk_combo_box_text_remove (GTK_COMBO_BOX_TEXT(iftype_cbx), num_remote);
1543 }
1544 remote_w = g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY);
1545 window_destroy(GTK_WIDGET(remote_w));
1546 capture_remote_cb(GTK_WIDGET(iftype_cbx), FALSE);
1547 } else {
1548 string = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(iftype_cbx));
1549 rh = g_hash_table_lookup (remote_host_list, string);
1550 g_free (string);
1551 if (rh) {
1552 remote_w = g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY);
1553 port_te = g_object_get_data(G_OBJECT(remote_w), E_REMOTE_PORT_TE_KEY);
1554 gtk_entry_set_text(GTK_ENTRY(port_te), rh->remote_port);
1555 auth_rb = g_object_get_data(G_OBJECT(remote_w), E_REMOTE_AUTH_PASSWD_KEY);
1556 if (rh->auth_type == CAPTURE_AUTH_PWD) {
1557 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(auth_rb), TRUE);
1558 } else {
1559 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(auth_rb), FALSE);
1560 }
1561 user_te = g_object_get_data(G_OBJECT(remote_w), E_REMOTE_USERNAME_TE_KEY);
1562 gtk_entry_set_text(GTK_ENTRY(user_te), rh->auth_username);
1563 pass_te = g_object_get_data(G_OBJECT(remote_w), E_REMOTE_PASSWD_TE_KEY);
1564 gtk_entry_set_text(GTK_ENTRY(pass_te), rh->auth_password);
1565 }
1566 }
1567 }
1568
1569 /* Show remote capture interface parameters dialog */
1570 static void
1571 capture_remote_cb(GtkWidget *w, gboolean focus_username)
1572 {
1573 GtkWidget *remote_w,
1574 *main_vb, *host_grid,
1575 *host_lb, *host_te, *port_lb, *port_te,
1576 *auth_fr, *auth_vb,
1577 *auth_null_rb, *auth_passwd_rb, *auth_passwd_grid,
1578 *user_lb, *user_te, *passwd_lb, *passwd_te,
1579 *bbox, *ok_but, *cancel_bt;
1580 gchar *title;
1581 GSList *auth_group;
1582
1583 title = create_user_window_title("Wireshark: Remote Interface");
1584 remote_w = dlg_window_new(title);
1585 gtk_window_set_transient_for(GTK_WINDOW(remote_w), GTK_WINDOW(interface_management_w));
1586 g_object_set_data(G_OBJECT(remote_w), E_CAP_REMOTE_CALLER_PTR_KEY, interface_management_w);
1587 g_object_set_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY, remote_w);
1588 g_free(title);
1589
1590 main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
1591 gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5);
1592 gtk_container_add(GTK_CONTAINER(remote_w), main_vb);
1593
1594 /* Host/port table */
1595 host_grid = ws_gtk_grid_new();
1596 ws_gtk_grid_set_row_spacing(GTK_GRID(host_grid), DLG_LABEL_SPACING);
1597 ws_gtk_grid_set_column_spacing(GTK_GRID(host_grid), DLG_UNRELATED_SPACING);
1598 gtk_box_pack_start(GTK_BOX(main_vb), host_grid, FALSE, FALSE, 0);
1599
1600 /* Host row */
1601 host_lb = gtk_label_new("Host:");
1602 ws_gtk_grid_attach_defaults(GTK_GRID (host_grid), host_lb, 0, 0, 1, 1);
1603
1604 host_te = iftype_combo_box_new();
1605 ws_gtk_grid_attach_defaults(GTK_GRID (host_grid), host_te, 1, 0, 1, 1);
1606
1607 /* Port row */
1608 port_lb = gtk_label_new("Port:");
1609 ws_gtk_grid_attach_defaults(GTK_GRID (host_grid), port_lb, 0, 1, 1, 1);
1610
1611 port_te = gtk_entry_new();
1612 gtk_widget_set_tooltip_text(port_te, "Enter the TCP port number used by RPCAP server at remote host "
1613 "(leave it empty for default port number).");
1614 ws_gtk_grid_attach_defaults(GTK_GRID (host_grid), port_te, 1, 1, 1, 1);
1615
1616 /* Authentication options frame */
1617 auth_fr = gtk_frame_new("Authentication");
1618 gtk_box_pack_start(GTK_BOX (main_vb), auth_fr, TRUE, TRUE, 0);
1619
1620 auth_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
1621 gtk_container_set_border_width(GTK_CONTAINER(auth_vb), 5);
1622 gtk_container_add(GTK_CONTAINER(auth_fr), auth_vb);
1623
1624 auth_null_rb = gtk_radio_button_new_with_label(NULL,
1625 "Null authentication");
1626 gtk_box_pack_start(GTK_BOX(auth_vb), auth_null_rb, TRUE, TRUE, 0);
1627
1628 auth_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(auth_null_rb));
1629 auth_passwd_rb = gtk_radio_button_new_with_label(auth_group,
1630 "Password authentication");
1631 gtk_box_pack_start(GTK_BOX(auth_vb), auth_passwd_rb, TRUE, TRUE, 0);
1632 g_signal_connect(auth_passwd_rb, "toggled",
1633 G_CALLBACK(capture_remote_adjust_sensitivity), remote_w);
1634
1635 auth_passwd_grid = ws_gtk_grid_new();
1636 ws_gtk_grid_set_row_spacing(GTK_GRID(auth_passwd_grid), DLG_LABEL_SPACING);
1637 ws_gtk_grid_set_column_spacing(GTK_GRID(auth_passwd_grid), DLG_UNRELATED_SPACING);
1638
1639 gtk_box_pack_start(GTK_BOX(auth_vb), auth_passwd_grid, FALSE, FALSE, 0);
1640
1641 user_lb = gtk_label_new("Username:");
1642 ws_gtk_grid_attach_defaults(GTK_GRID (auth_passwd_grid), user_lb, 0, 0, 1, 1);
1643
1644 user_te = gtk_entry_new();
1645 ws_gtk_grid_attach_defaults(GTK_GRID (auth_passwd_grid), user_te, 1, 0, 1, 1);
1646
1647 passwd_lb = gtk_label_new("Password:");
1648 ws_gtk_grid_attach_defaults(GTK_GRID (auth_passwd_grid), passwd_lb, 0, 1, 1, 1);
1649
1650 passwd_te = gtk_entry_new();
1651 gtk_entry_set_visibility(GTK_ENTRY(passwd_te), FALSE);
1652 ws_gtk_grid_attach_defaults(GTK_GRID (auth_passwd_grid), passwd_te, 1, 1, 1, 1);
1653
1654 /* Button row: "Start" and "Cancel" buttons */
1655 bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, NULL);
1656 gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 5);
1657
1658 ok_but = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
1659 gtk_widget_set_can_default(ok_but, TRUE);
1660 g_signal_connect(ok_but, "clicked", G_CALLBACK(capture_remote_ok_cb), remote_w);
1661 gtk_widget_set_tooltip_text(ok_but,
1662 "Accept remote host parameters and lookup "
1663 "remote interfaces.");
1664 g_object_set_data(G_OBJECT(remote_w), E_REMOTE_OK_BT_KEY, ok_but);
1665 cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
1666 gtk_widget_set_tooltip_text(cancel_bt, "Cancel and exit dialog.");
1667 window_set_cancel_button(remote_w, cancel_bt, capture_remote_cancel_cb);
1668
1669 if (focus_username) {
1670 /* Give the initial focus to the "Username" entry box. */
1671 gtk_widget_grab_focus(user_te);
1672 }
1673
1674 gtk_widget_grab_default(ok_but);
1675
1676 /* Catch the "activate" signal on the text
1677 entries, so that if the user types Return there, we act as if the
1678 "OK" button had been selected, as happens if Return is typed if some
1679 widget that *doesn't* handle the Return key has the input focus. */
1680 dlg_set_activate(host_te, ok_but);
1681 dlg_set_activate(port_te, ok_but);
1682 dlg_set_activate(user_te, ok_but);
1683 dlg_set_activate(passwd_te, ok_but);
1684
1685 g_signal_connect(remote_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
1686 g_signal_connect(remote_w, "destroy", G_CALLBACK(capture_remote_destroy_cb), NULL);
1687
1688 g_object_set_data(G_OBJECT(remote_w), E_REMOTE_HOST_TE_KEY, host_te);
1689 g_object_set_data(G_OBJECT(remote_w), E_REMOTE_PORT_TE_KEY, port_te);
1690 g_object_set_data(G_OBJECT(remote_w), E_REMOTE_AUTH_NULL_KEY, auth_null_rb);
1691 g_object_set_data(G_OBJECT(remote_w), E_REMOTE_AUTH_PASSWD_KEY, auth_passwd_rb);
1692 g_object_set_data(G_OBJECT(remote_w), E_REMOTE_USERNAME_LB_KEY, user_lb);
1693 g_object_set_data(G_OBJECT(remote_w), E_REMOTE_USERNAME_TE_KEY, user_te);
1694 g_object_set_data(G_OBJECT(remote_w), E_REMOTE_PASSWD_LB_KEY, passwd_lb);
1695 g_object_set_data(G_OBJECT(remote_w), E_REMOTE_PASSWD_TE_KEY, passwd_te);
1696
1697 if (global_remote_opts.remote_host_opts.auth_type == CAPTURE_AUTH_PWD)
1698 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(auth_passwd_rb), TRUE);
1699 else
1700 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(auth_null_rb), TRUE);
1701 capture_remote_adjust_sensitivity(NULL, remote_w);
1702
1703 gtk_widget_show_all(remote_w);
1704 window_present(remote_w);
1705 }
1706
1707 /* user requested to destroy the dialog */
1708 static void
1709 options_remote_destroy_cb(GtkWidget *win, gpointer user_data _U_)
1710 {
1711 GtkWidget *caller;
1712
1713 caller = g_object_get_data(G_OBJECT(win), E_OPT_REMOTE_CALLER_PTR_KEY);
1714 g_object_set_data(G_OBJECT(caller), E_OPT_REMOTE_DIALOG_PTR_KEY, NULL);
1715 }
1716
1717 /* user requested to accept remote interface options */
1718 static void
1719 options_remote_ok_cb(GtkWidget *win _U_, GtkWidget *parent_w)
1720 {
1721 GtkWidget *datatx_udp_cb, *nocap_rpcap_cb;
1722 #ifdef HAVE_PCAP_SETSAMPLING
1723 GtkWidget *samp_none_rb, *samp_count_rb, *samp_timer_rb,
1724 *samp_count_sb, *samp_timer_sb;
1725 #endif
1726 interface_t device;
1727
1728 if (parent_w == NULL)
1729 return;
1730
1731 device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_interface);
1732 g_array_remove_index(global_capture_opts.all_ifaces, marked_interface);
1733 datatx_udp_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_DATATX_UDP_CB_KEY);
1734 nocap_rpcap_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_NOCAP_RPCAP_CB_KEY);
1735
1736 device.remote_opts.remote_host_opts.datatx_udp =
1737 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(datatx_udp_cb));
1738 device.remote_opts.remote_host_opts.nocap_rpcap =
1739 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(nocap_rpcap_cb));
1740
1741 #ifdef HAVE_PCAP_SETSAMPLING
1742 samp_none_rb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_NONE_RB_KEY);
1743 samp_count_rb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_COUNT_RB_KEY);
1744 samp_timer_rb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_TIMER_RB_KEY);
1745 samp_count_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_COUNT_SB_KEY);
1746 samp_timer_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_TIMER_SB_KEY);
1747
1748 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_none_rb)))
1749 device.remote_opts.sampling_method = CAPTURE_SAMP_NONE;
1750 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_count_rb))) {
1751 device.remote_opts.sampling_method = CAPTURE_SAMP_BY_COUNT;
1752 device.remote_opts.sampling_param = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(samp_count_sb));
1753 } else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_timer_rb))) {
1754 device.remote_opts.sampling_method = CAPTURE_SAMP_BY_TIMER;
1755 device.remote_opts.sampling_param = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(samp_timer_sb));
1756 }
1757 #endif /* HAVE_PCAP_SETSAMPLING*/
1758 g_array_insert_val(global_capture_opts.all_ifaces, marked_interface, device);
1759 window_destroy(GTK_WIDGET(parent_w));
1760 }
1761 #endif /*HAVE_PCAP_REMOTE*/
1762
1763 #ifdef HAVE_PCAP_SETSAMPLING
1764 static void
1765 options_prep_adjust_sensitivity(GtkWidget *tb _U_, gpointer parent_w)
1766 {
1767 GtkWidget *samp_count_rb, *samp_timer_rb,
1768 *samp_count_sb, *samp_timer_sb;
1769
1770 samp_count_rb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_COUNT_RB_KEY);
1771 samp_timer_rb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_TIMER_RB_KEY);
1772 samp_count_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_COUNT_SB_KEY);
1773 samp_timer_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_TIMER_SB_KEY);
1774
1775 if (samp_count_sb && samp_count_rb)
1776 gtk_widget_set_sensitive(GTK_WIDGET(samp_count_sb),
1777 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_count_rb)));
1778
1779 if (samp_timer_sb && samp_timer_rb)
1780 gtk_widget_set_sensitive(GTK_WIDGET(samp_timer_sb),
1781 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_timer_rb)));
1782 }
1783
1784 #endif /*HAVE_PCAP_SETSAMPLING*/
1785 #ifdef HAVE_PCAP_REMOTE
1786 static void
1787 options_remote_cb(GtkWidget *w _U_, gpointer d _U_)
1788 {
1789 GtkWidget *opt_remote_w, *main_vb;
1790 GtkWidget *caller, *bbox, *ok_but, *cancel_bt;
1791 GtkWidget *capture_fr, *capture_vb;
1792 GtkWidget *nocap_rpcap_cb, *datatx_udp_cb;
1793 #ifdef HAVE_PCAP_SETSAMPLING
1794 GtkWidget *sampling_fr, *sampling_vb, *sampling_grid, *sampling_lb,
1795 *samp_none_rb, *samp_count_rb, *samp_timer_rb,
1796 *samp_count_sb, *samp_timer_sb;
1797 GtkAdjustment *samp_count_adj, *samp_timer_adj;
1798 GSList *samp_group;
1799 #endif
1800 interface_t device;
1801
1802 caller = gtk_widget_get_toplevel(w);
1803 opt_remote_w = g_object_get_data(G_OBJECT(caller), E_OPT_REMOTE_DIALOG_PTR_KEY);
1804 if (opt_remote_w != NULL) {
1805 reactivate_window(opt_remote_w);
1806 return;
1807 }
1808
1809 device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_interface);
1810 opt_remote_w = dlg_window_new("Remote Capture Settings");
1811 gtk_window_set_modal(GTK_WINDOW(opt_remote_w), TRUE);
1812 gtk_window_set_transient_for(GTK_WINDOW(opt_remote_w), GTK_WINDOW(caller));
1813 gtk_window_set_type_hint(GTK_WINDOW(opt_remote_w), GDK_WINDOW_TYPE_HINT_DIALOG);
1814
1815 g_object_set_data(G_OBJECT(opt_remote_w), E_OPT_REMOTE_CALLER_PTR_KEY, caller);
1816 g_object_set_data(G_OBJECT(caller), E_OPT_REMOTE_DIALOG_PTR_KEY, opt_remote_w);
1817
1818 main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
1819 gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5);
1820 gtk_container_add(GTK_CONTAINER(opt_remote_w), main_vb);
1821
1822 /* Remote capture options */
1823 capture_fr = gtk_frame_new("Capture Options");
1824 gtk_box_pack_start(GTK_BOX (main_vb), capture_fr, TRUE, TRUE, 0);
1825
1826 capture_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
1827 gtk_container_set_border_width(GTK_CONTAINER(capture_vb), 5);
1828 gtk_container_add(GTK_CONTAINER(capture_fr), capture_vb);
1829
1830 nocap_rpcap_cb = gtk_check_button_new_with_mnemonic("Do not capture own RPCAP traffic");
1831 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(nocap_rpcap_cb),
1832 device.remote_opts.remote_host_opts.nocap_rpcap);
1833 gtk_box_pack_start(GTK_BOX (capture_vb), nocap_rpcap_cb, TRUE, TRUE, 0);
1834
1835 datatx_udp_cb = gtk_check_button_new_with_mnemonic("Use UDP for data transfer");
1836 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(datatx_udp_cb),
1837 device.remote_opts.remote_host_opts.datatx_udp);
1838 gtk_box_pack_start(GTK_BOX (capture_vb), datatx_udp_cb, TRUE, TRUE, 0);
1839
1840
1841 #ifdef HAVE_PCAP_SETSAMPLING
1842 /* Sampling options */
1843 sampling_fr = gtk_frame_new("Sampling Options");
1844 gtk_box_pack_start(GTK_BOX (main_vb), sampling_fr, TRUE, TRUE, 0);
1845
1846 sampling_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
1847 gtk_container_set_border_width(GTK_CONTAINER(sampling_vb), 5);
1848 gtk_container_add(GTK_CONTAINER(sampling_fr), sampling_vb);
1849
1850 sampling_grid = ws_gtk_grid_new();
1851 ws_gtk_grid_set_row_spacing(GTK_GRID(sampling_grid), DLG_LABEL_SPACING);
1852 ws_gtk_grid_set_column_spacing(GTK_GRID(sampling_grid), DLG_UNRELATED_SPACING);
1853 gtk_box_pack_start(GTK_BOX(sampling_vb), sampling_grid, FALSE, FALSE, 0);
1854
1855 /* "No sampling" row */
1856 samp_none_rb = gtk_radio_button_new_with_label(NULL, "None");
1857 if (device.remote_opts.sampling_method == CAPTURE_SAMP_NONE)
1858 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(samp_none_rb), TRUE);
1859 g_signal_connect(samp_none_rb, "toggled",
1860 G_CALLBACK(options_prep_adjust_sensitivity), opt_remote_w);
1861 ws_gtk_grid_attach_defaults(GTK_GRID (sampling_grid), samp_none_rb, 0, 0, 1, 1);
1862
1863 /* "Sampling by counter" row */
1864 samp_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(samp_none_rb));
1865 samp_count_rb = gtk_radio_button_new_with_label(samp_group, "1 of");
1866 if (device.remote_opts.sampling_method == CAPTURE_SAMP_BY_COUNT)
1867 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(samp_count_rb), TRUE);
1868 g_signal_connect(samp_count_rb, "toggled",
1869 G_CALLBACK(options_prep_adjust_sensitivity), opt_remote_w);
1870 ws_gtk_grid_attach_defaults(GTK_GRID (sampling_grid), samp_count_rb, 0, 1, 1, 1);
1871
1872 samp_count_adj = (GtkAdjustment *) gtk_adjustment_new(
1873 (gfloat)device.remote_opts.sampling_param,
1874 1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
1875 samp_count_sb = gtk_spin_button_new(samp_count_adj, 0, 0);
1876 gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(samp_count_sb), TRUE);
1877 ws_gtk_grid_attach_defaults(GTK_GRID (sampling_grid), samp_count_sb, 1, 1, 1, 1);
1878
1879 sampling_lb = gtk_label_new("packets");
1880 gtk_misc_set_alignment(GTK_MISC(sampling_lb), 0, 0.5f);
1881 ws_gtk_grid_attach_defaults(GTK_GRID (sampling_grid), sampling_lb, 2, 1, 1, 1);
1882
1883 /* "Sampling by timer" row */
1884 samp_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(samp_count_rb));
1885 samp_timer_rb = gtk_radio_button_new_with_label(samp_group, "1 every");
1886 if (device.remote_opts.sampling_method == CAPTURE_SAMP_BY_TIMER)
1887 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(samp_timer_rb), TRUE);
1888 g_signal_connect(samp_timer_rb, "toggled",
1889 G_CALLBACK(options_prep_adjust_sensitivity), opt_remote_w);
1890 ws_gtk_grid_attach_defaults(GTK_GRID (sampling_grid), samp_timer_rb, 0, 2, 1, 1);
1891
1892 samp_timer_adj = (GtkAdjustment *) gtk_adjustment_new(
1893 (gfloat)device.remote_opts.sampling_param,
1894 1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
1895 samp_timer_sb = gtk_spin_button_new(samp_timer_adj, 0, 0);
1896 gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(samp_timer_sb), TRUE);
1897 ws_gtk_grid_attach_defaults(GTK_GRID(sampling_grid), samp_timer_sb, 1, 2, 1, 1);
1898
1899 sampling_lb = gtk_label_new("milliseconds");
1900 gtk_misc_set_alignment(GTK_MISC(sampling_lb), 0, 0.5f);
1901 ws_gtk_grid_attach_defaults(GTK_GRID (sampling_grid), sampling_lb, 2, 2, 1, 1);
1902 #endif
1903
1904 /* Button row: "Start" and "Cancel" buttons */
1905 bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, NULL);
1906 gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 5);
1907
1908 ok_but = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
1909 g_signal_connect(ok_but, "clicked", G_CALLBACK(options_remote_ok_cb), opt_remote_w);
1910 gtk_widget_set_tooltip_text(ok_but, "Accept parameters and close dialog");
1911 cancel_bt = g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
1912 gtk_widget_set_tooltip_text(cancel_bt, "Cancel and exit dialog.");
1913 window_set_cancel_button(opt_remote_w, cancel_bt, window_cancel_button_cb);
1914
1915 gtk_widget_grab_default(ok_but);
1916
1917 g_signal_connect(opt_remote_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
1918 g_signal_connect(opt_remote_w, "destroy", G_CALLBACK(options_remote_destroy_cb), NULL);
1919
1920 g_object_set_data(G_OBJECT(opt_remote_w), E_CAP_NOCAP_RPCAP_CB_KEY, nocap_rpcap_cb);
1921 g_object_set_data(G_OBJECT(opt_remote_w), E_CAP_DATATX_UDP_CB_KEY, datatx_udp_cb);
1922
1923 #ifdef HAVE_PCAP_SETSAMPLING
1924 g_object_set_data(G_OBJECT(opt_remote_w), E_CAP_SAMP_NONE_RB_KEY, samp_none_rb);
1925 g_object_set_data(G_OBJECT(opt_remote_w), E_CAP_SAMP_COUNT_RB_KEY, samp_count_rb);
1926 g_object_set_data(G_OBJECT(opt_remote_w), E_CAP_SAMP_COUNT_SB_KEY, samp_count_sb);
1927 g_object_set_data(G_OBJECT(opt_remote_w), E_CAP_SAMP_TIMER_RB_KEY, samp_timer_rb);
1928 g_object_set_data(G_OBJECT(opt_remote_w), E_CAP_SAMP_TIMER_SB_KEY, samp_timer_sb);
1929 #endif
1930
1931 #ifdef HAVE_PCAP_SETSAMPLING
1932 /* Set the sensitivity of various widgets as per the settings of other
1933 widgets. */
1934 options_prep_adjust_sensitivity(NULL, opt_remote_w);
1935 #endif
1936
1937 gtk_widget_show_all(opt_remote_w);
1938 window_present(opt_remote_w);
1939 }
1940
1941 static void
1942 recent_print_remote_host (gpointer key _U_, gpointer value, gpointer user)
1943 {
1944 FILE *rf = user;
1945 struct remote_host_info *ri = value;
1946
1947 fprintf (rf, RECENT_KEY_REMOTE_HOST ": %s,%s,%d\n", ri->remote_host, ri->remote_port, ri->auth_type);
1948 }
1949
1950 void
1951 capture_remote_combo_recent_write_all(FILE *rf)
1952 {
1953 if (remote_host_list && g_hash_table_size (remote_host_list) > 0) {
1954 /* Write all remote interfaces to the recent file */
1955 g_hash_table_foreach (remote_host_list, recent_print_remote_host, rf);
1956 }
1957 }
1958
1959 gboolean
1960 capture_remote_combo_add_recent(const gchar *s)
1961 {
1962 GList *vals = prefs_get_string_list (s);
1963 GList *valp = vals;
1964 gint auth_type;
1965 char *p;
1966 struct remote_host_info *rh;
1967
1968 if (valp == NULL)
1969 return FALSE;
1970
1971 if (remote_host_list == NULL) {
1972 remote_host_list = g_hash_table_new (g_str_hash, g_str_equal);
1973 }
1974
1975 rh = g_malloc (sizeof (*rh));
1976
1977 /* First value is the host */
1978 rh->remote_host = g_strdup (valp->data);
1979 if (strlen(rh->remote_host) == 0) {
1980 /* Empty remote host */
1981 g_free(rh->remote_host);
1982 g_free(rh);
1983 return FALSE;
1984 }
1985 rh->auth_type = CAPTURE_AUTH_NULL;
1986 valp = valp->next;
1987
1988 if (valp) {
1989 /* Found value 2, this is the port number */
1990 rh->remote_port = g_strdup (valp->data);
1991 valp = valp->next;
1992 } else {
1993 /* Did not find a port number */
1994 rh->remote_port = g_strdup ("");
1995 }
1996
1997 if (valp) {
1998 /* Found value 3, this is the authentication type */
1999 auth_type = strtol(valp->data, &p, 0);
2000 if (p != valp->data && *p == '\0') {
2001 rh->auth_type = auth_type;
2002 }
2003 }
2004
2005 /* Do not store username and password */
2006 rh->auth_username = g_strdup ("");
2007 rh->auth_password = g_strdup ("");
2008
2009 prefs_clear_string_list(vals);
2010
2011 g_hash_table_insert (remote_host_list, g_strdup(rh->remote_host), rh);
2012
2013 return TRUE;
2014 }
2015
2016 #endif /* HAVE_PCAP_REMOTE */
2017
2018 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
2019
2020 static void
2021 compile_bpf_destroy_cb(GtkWidget *win _U_, gpointer user_data _U_)
2022 {
2023 /* Note that we no longer have an "About Wireshark" dialog box. */
2024 compile_bpf_w = NULL;
2025 }
2026
2027 static void
2028 select_first_entry(void)
2029 {
2030 GtkWidget *view;
2031 GtkTreeModel *model;
2032 GtkTreeIter iter;
2033 GtkTreeSelection *selection;
2034
2035 view = (GtkWidget *)g_object_get_data(G_OBJECT(compile_bpf_w), E_COMPILE_TREE_VIEW_INTERFACES);
2036 model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
2037 gtk_tree_model_get_iter_first(model, &iter);
2038 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
2039 gtk_tree_selection_select_iter(selection, &iter);
2040 }
2041
2042 static void
2043 add_page(gchar *name, gchar *text, gboolean error)
2044 {
2045 GtkWidget *view, *icon;
2046 GtkTreeModel *model;
2047 GtkTreeIter iter;
2048
2049 view = (GtkWidget *)g_object_get_data(G_OBJECT(compile_bpf_w), E_COMPILE_TREE_VIEW_INTERFACES);
2050 model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
2051 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
2052 if (error) {
2053 icon = pixbuf_to_widget(expert_error_pb_data);
2054 gtk_list_store_set(GTK_LIST_STORE(model), &iter, COMPILE_ERROR, 1, SIGN, gtk_image_get_pixbuf(GTK_IMAGE(icon)), INAME, name, -1);
2055 } else {
2056 icon = pixbuf_to_widget(expert_ok_pb_data);
2057 gtk_list_store_set(GTK_LIST_STORE(model), &iter, COMPILE_ERROR, 0, SIGN, gtk_image_get_pixbuf(GTK_IMAGE(icon)), INAME, name, -1);
2058 }
2059 g_hash_table_insert(compile_results, name, text);
2060 }
2061
2062 static void
2063 compile_tree_select_cb(GtkTreeSelection *sel, gpointer dummy _U_)
2064 {
2065 gchar *name, *text;
2066 GtkTreeModel *model;
2067 GtkTreeIter iter;
2068 GtkWidget *textview;
2069 GtkTextBuffer *buffer;
2070 guint error;
2071
2072 if (gtk_tree_selection_get_selected(sel, &model, &iter))
2073 {
2074 gtk_tree_model_get(model, &iter, COMPILE_ERROR, &error, INAME, &name, -1);
2075 text = (gchar *)g_hash_table_lookup(compile_results, name);
2076 textview = (GtkWidget *)g_object_get_data(G_OBJECT(compile_bpf_w), CR_MAIN_NB);
2077 if (error == 1) {
2078 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_CHAR);
2079 } else {
2080 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_NONE);
2081 }
2082 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
2083 gtk_text_buffer_set_text(buffer, text, -1);
2084 gtk_widget_show_all(compile_bpf_w);
2085 }
2086 }
2087
2088 static void
2089 compile_results_prep(GtkWidget *w _U_, gpointer data _U_)
2090 {
2091 GtkWidget *main_box, *main_vb, *bbox, *ok_btn, *top_hb, *ct_sb;
2092 GtkListStore *store;
2093 GtkWidget *view, *scrolled_win, *textview;
2094 GtkTreeSelection *selection;
2095 GtkCellRenderer *renderer;
2096 GtkTreeViewColumn *column;
2097 PangoFontDescription *font;
2098
2099 if (compile_bpf_w != NULL) {
2100 /* There's already an "About Wireshark" dialog box; reactivate it. */
2101 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "The requested dialog is already open. Please close it first.");
2102 return;
2103 }
2104
2105 compile_bpf_w = dlg_window_new("Compile selected BPFs");
2106 /* set the initial position (must be done, before show is called!) */
2107 /* default position is not appropriate for the about dialog */
2108 gtk_window_set_position(GTK_WINDOW(compile_bpf_w), GTK_WIN_POS_CENTER_ON_PARENT);
2109 gtk_window_set_default_size(GTK_WINDOW(compile_bpf_w), 600, 400);
2110 gtk_window_set_modal(GTK_WINDOW(compile_bpf_w), TRUE);
2111 gtk_window_set_transient_for(GTK_WINDOW(compile_bpf_w), GTK_WINDOW(cap_open_w));
2112 gtk_container_set_border_width(GTK_CONTAINER(compile_bpf_w), 6);
2113
2114 main_box = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 12, FALSE);
2115 gtk_container_set_border_width(GTK_CONTAINER(main_box), 6);
2116 gtk_container_add(GTK_CONTAINER(compile_bpf_w), main_box);
2117 gtk_widget_show(main_box);
2118
2119 /* Top row: Interfaces tree and notebook */
2120 top_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10, FALSE);
2121 gtk_box_pack_start(GTK_BOX(main_box), top_hb, TRUE, TRUE, 0);
2122 gtk_widget_show(top_hb);
2123
2124 /* scrolled window on the left for the categories tree */
2125 ct_sb = scrolled_window_new(NULL, NULL);
2126 gtk_widget_set_size_request(GTK_WIDGET(ct_sb), 50, -1);
2127 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(ct_sb),
2128 GTK_SHADOW_IN);
2129 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ct_sb),
2130 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2131 gtk_box_pack_start(GTK_BOX(top_hb), ct_sb, TRUE, TRUE, 0);
2132 gtk_widget_show(ct_sb);
2133 g_object_set_data(G_OBJECT(compile_bpf_w), E_COMPILE_SW_SCROLLW_KEY, ct_sb);
2134
2135 store = gtk_list_store_new(3, G_TYPE_UINT, GDK_TYPE_PIXBUF, G_TYPE_STRING);
2136 view = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
2137 gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL (store));
2138 g_object_set(G_OBJECT(view), "headers-visible", FALSE, NULL);
2139 g_object_set_data(G_OBJECT(compile_bpf_w), E_COMPILE_TREE_VIEW_INTERFACES, view);
2140 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
2141 gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
2142 column = gtk_tree_view_column_new();
2143 renderer = gtk_cell_renderer_text_new();
2144 gtk_tree_view_column_pack_start(column, renderer, TRUE);
2145 gtk_tree_view_column_set_attributes(column, renderer, "text", COMPILE_ERROR, NULL);
2146 gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
2147 gtk_tree_view_column_set_visible(column, FALSE);
2148 column = gtk_tree_view_column_new();
2149 renderer = gtk_cell_renderer_pixbuf_new();
2150 gtk_tree_view_column_pack_start(column, renderer, FALSE);
2151 gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", SIGN, NULL);
2152 renderer = gtk_cell_renderer_text_new();
2153 gtk_tree_view_column_pack_start(column, renderer, TRUE);
2154 gtk_tree_view_column_set_attributes(column, renderer, "text", INAME, NULL);
2155 gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
2156 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(view), 0), TRUE);
2157
2158 g_signal_connect(selection, "changed", G_CALLBACK(compile_tree_select_cb), NULL);
2159 gtk_container_add(GTK_CONTAINER(ct_sb), view);
2160 gtk_widget_show(view);
2161
2162 main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 10, FALSE);
2163 gtk_box_pack_start(GTK_BOX(top_hb), main_vb, TRUE, TRUE, 0);
2164 gtk_widget_show(main_vb);
2165 g_object_set_data(G_OBJECT(compile_bpf_w), CR_MAIN_NB, main_vb);
2166
2167 font = pango_font_description_from_string("Monospace");
2168 textview = gtk_text_view_new();
2169 #if GTK_CHECK_VERSION(3, 0, 0)
2170 gtk_widget_override_font(textview, font);
2171 #else
2172 gtk_widget_modify_font(textview, font);
2173 #endif
2174 scrolled_win = gtk_scrolled_window_new(NULL, NULL);
2175 gtk_widget_set_size_request(GTK_WIDGET(scrolled_win), 350, -1);
2176 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
2177 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2178 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_win),
2179 GTK_SHADOW_IN);
2180 gtk_container_add(GTK_CONTAINER(scrolled_win), textview);
2181 gtk_box_pack_start(GTK_BOX(main_vb), scrolled_win, TRUE, TRUE, 0);
2182 g_object_set_data(G_OBJECT(compile_bpf_w), CR_MAIN_NB, textview);
2183
2184 /* Button row */
2185 bbox = dlg_button_row_new(GTK_STOCK_OK, NULL);
2186 gtk_box_pack_start(GTK_BOX(main_box), bbox, FALSE, FALSE, 0);
2187
2188 ok_btn = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
2189 gtk_widget_grab_focus(ok_btn);
2190 gtk_widget_grab_default(ok_btn);
2191 window_set_cancel_button(compile_bpf_w, ok_btn, window_cancel_button_cb);
2192
2193 g_signal_connect(compile_bpf_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
2194 g_signal_connect(compile_bpf_w, "destroy", G_CALLBACK(compile_bpf_destroy_cb), NULL);
2195
2196 gtk_widget_show_all(compile_bpf_w);
2197 window_present(compile_bpf_w);
2198
2199 compile_results = g_hash_table_new(g_str_hash, g_str_equal);
2200 }
2201
2202 static void
2203 capture_all_filter_compile_cb(GtkWidget *w _U_, gpointer user_data _U_)
2204 {
2205 pcap_t *pd;
2206 struct bpf_program fcode;
2207
2208 GtkWidget *filter_cm;
2209 gchar *filter_text;
2210 guint i;
2211 gboolean set = FALSE;
2212
2213 filter_cm = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY);
2214
2215 if (!filter_cm)
2216 return;
2217
2218 if (global_capture_opts.all_ifaces->len > 0) {
2219 interface_t device;
2220
2221 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
2222 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
2223 if (!device.selected || device.hidden) {
2224 continue;
2225 }
2226 if (device.active_dlt == -1) {
2227 g_assert_not_reached(); /* Programming error: somehow managed to select an "unsupported" entry */
2228 }
2229 if (!set) {
2230 set = TRUE;
2231 compile_results_prep(NULL, NULL);
2232 }
2233 pd = pcap_open_dead(device.active_dlt, DUMMY_SNAPLENGTH);
2234
2235 filter_text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(filter_cm));
2236 g_mutex_lock(pcap_compile_mtx);
2237 #ifdef PCAP_NETMASK_UNKNOWN
2238 if (pcap_compile(pd, &fcode, filter_text, 1 /* Do optimize */, PCAP_NETMASK_UNKNOWN) < 0)
2239 #else
2240 if (pcap_compile(pd, &fcode, filter_text, 1 /* Do optimize */, 0) < 0)
2241 #endif
2242 {
2243 g_mutex_unlock(pcap_compile_mtx);
2244 add_page(device.name, g_strdup(pcap_geterr(pd)), TRUE);
2245 } else {
2246 GString *bpf_code_dump = g_string_new("");
2247 struct bpf_insn *insn = fcode.bf_insns;
2248 int ii, n = fcode.bf_len;
2249 gchar *bpf_code_str;
2250
2251 for (ii = 0; ii < n; ++insn, ++ii) {
2252 g_string_append(bpf_code_dump, bpf_image(insn, ii));
2253 g_string_append(bpf_code_dump, "\n");
2254 }
2255 bpf_code_str = g_string_free(bpf_code_dump, FALSE);
2256 g_mutex_unlock(pcap_compile_mtx);
2257 add_page(device.name, g_strdup(bpf_code_str), FALSE);
2258 g_free(bpf_code_str);
2259 }
2260 g_free(filter_text);
2261 pcap_close(pd);
2262 }
2263 }
2264 select_first_entry();
2265 }
2266 #endif /* HAVE_PCAP_OPEN_DEAD && HAVE_BPF_IMAGE */
2267
2268
2269 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
2270 static void
2271 compile_results_win(gchar *text, gboolean error)
2272 {
2273 GtkWidget *main_box, *bbox, *ok_btn, *results_w;
2274 GtkWidget *scrolled_win, *textview;
2275 PangoFontDescription *font;
2276 GtkTextBuffer *buffer;
2277
2278 results_w = dlg_window_new("Compile results");
2279 /* set the initial position (must be done, before show is called!) */
2280 /* default position is not appropriate for the about dialog */
2281 gtk_window_set_position(GTK_WINDOW(results_w), GTK_WIN_POS_CENTER_ON_PARENT);
2282 gtk_window_set_default_size(GTK_WINDOW(results_w), 400, 400);
2283 gtk_window_set_modal(GTK_WINDOW(results_w), TRUE);
2284 gtk_window_set_transient_for(GTK_WINDOW(results_w), GTK_WINDOW(opt_edit_w));
2285 gtk_container_set_border_width(GTK_CONTAINER(results_w), 6);
2286 main_box = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 12, FALSE);
2287 gtk_container_set_border_width(GTK_CONTAINER(main_box), 6);
2288 gtk_container_add(GTK_CONTAINER(results_w), main_box);
2289 gtk_widget_show(main_box);
2290 font = pango_font_description_from_string("Monospace");
2291 textview = gtk_text_view_new();
2292 #if GTK_CHECK_VERSION(3, 0, 0)
2293 gtk_widget_override_font(textview, font);
2294 #else
2295 gtk_widget_modify_font(textview, font);
2296 #endif
2297 scrolled_win = gtk_scrolled_window_new(NULL, NULL);
2298 gtk_widget_set_size_request(GTK_WIDGET(scrolled_win), 350, -1);
2299 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
2300 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2301 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled_win),
2302 GTK_SHADOW_IN);
2303 gtk_container_add(GTK_CONTAINER(scrolled_win), textview);
2304 gtk_box_pack_start(GTK_BOX(main_box), scrolled_win, TRUE, TRUE, 0);
2305 if (error == 1) {
2306 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_CHAR);
2307 } else {
2308 gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_NONE);
2309 }
2310 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
2311 gtk_text_buffer_set_text(buffer, g_strdup(text), -1);
2312 /* Button row */
2313 bbox = dlg_button_row_new(GTK_STOCK_OK, NULL);
2314 gtk_box_pack_start(GTK_BOX(main_box), bbox, FALSE, FALSE, 0);
2315
2316 ok_btn = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
2317 gtk_widget_grab_focus(ok_btn);
2318 gtk_widget_grab_default(ok_btn);
2319 window_set_cancel_button(results_w, ok_btn, window_cancel_button_cb);
2320
2321 g_signal_connect(results_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
2322 g_signal_connect(results_w, "destroy", G_CALLBACK(compile_bpf_destroy_cb), NULL);
2323
2324 gtk_widget_show_all(results_w);
2325 window_present(results_w);
2326 }
2327
2328
2329 static void
2330 capture_filter_compile_cb(GtkWidget *w _U_, gpointer user_data _U_)
2331 {
2332 pcap_t *pd;
2333 struct bpf_program fcode;
2334
2335 GtkWidget *filter_cm;
2336 gchar *filter_text;
2337 gpointer ptr;
2338 int dlt;
2339 GtkWidget *linktype_combo_box = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_LT_CBX_KEY);
2340
2341 if (! ws_combo_box_get_active_pointer(GTK_COMBO_BOX(linktype_combo_box), &ptr)) {
2342 g_assert_not_reached(); /* Programming error: somehow nothing is active */
2343 }
2344 if ((dlt = GPOINTER_TO_INT(ptr)) == -1) {
2345 g_assert_not_reached(); /* Programming error: somehow managed to select an "unsupported" entry */
2346 }
2347 pd = pcap_open_dead(dlt, DUMMY_SNAPLENGTH);
2348 filter_cm = (GtkWidget *)g_object_get_data(G_OBJECT(opt_edit_w), E_CFILTER_CM_KEY);
2349 filter_text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(filter_cm));
2350 g_mutex_lock(pcap_compile_mtx);
2351 #ifdef PCAP_NETMASK_UNKNOWN
2352 if (pcap_compile(pd, &fcode, filter_text, 1 /* Do optimize */, PCAP_NETMASK_UNKNOWN) < 0) {
2353 #else
2354 if (pcap_compile(pd, &fcode, filter_text, 1 /* Do optimize */, 0) < 0) {
2355 #endif
2356 g_mutex_unlock(pcap_compile_mtx);
2357 compile_results_win(g_strdup(pcap_geterr(pd)), 1);
2358 } else {
2359 GString *bpf_code_dump = g_string_new("");
2360 struct bpf_insn *insn = fcode.bf_insns;
2361 int i, n = fcode.bf_len;
2362
2363 gchar *bpf_code_str;
2364
2365 g_mutex_unlock(pcap_compile_mtx);
2366
2367 for (i = 0; i < n; ++insn, ++i) {
2368 g_string_append(bpf_code_dump, bpf_image(insn, i));
2369 g_string_append(bpf_code_dump, "\n");
2370 }
2371
2372 bpf_code_str = g_string_free(bpf_code_dump, FALSE);
2373 compile_results_win(g_strdup(bpf_code_str), 0);
2374
2375 g_free(bpf_code_str);
2376 }
2377 g_free(filter_text);
2378
2379 pcap_close(pd);
2380 }
2381 #endif /* HAVE_PCAP_OPEN_DEAD && HAVE_BPF_IMAGE */
2382
2383 static void
2384 options_edit_destroy_cb(GtkWidget *win, gpointer user_data _U_)
2385 {
2386 GtkWidget *caller;
2387
2388 caller = (GtkWidget *)g_object_get_data(G_OBJECT(win), E_OPT_EDIT_CALLER_PTR_KEY);
2389 g_object_set_data(G_OBJECT(caller), E_OPT_EDIT_DIALOG_PTR_KEY, NULL);
2390 }
2391
2392 static void
2393 update_options_table(gint indx)
2394 {
2395 interface_t device;
2396 GtkTreePath *path;
2397 GtkTreeView *if_cb;
2398 GtkTreeModel *model;
2399 GtkTreeIter iter;
2400 gchar *temp, *path_str, *snaplen_string, *linkname;
2401 GList *list;
2402 link_row *linkr = NULL;
2403 gboolean enabled;
2404
2405 device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_interface);
2406
2407 if (!device.hidden) {
2408 if (device.no_addresses == 0) {
2409 temp = g_strdup_printf("<b>%s</b>", device.display_name);
2410 } else {
2411 temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", device.display_name, device.addresses);
2412 }
2413 linkname = NULL;
2414 for (list=device.links; list!=NULL; list=g_list_next(list))
2415 {
2416 linkr = (link_row*)(list->data);
2417 if (linkr->dlt == device.active_dlt) {
2418 linkname = g_strdup(linkr->name);
2419 break;
2420 }
2421 }
2422 if (!linkname)
2423 linkname = g_strdup("unknown");
2424 if (device.has_snaplen) {
2425 snaplen_string = g_strdup_printf("%d", device.snaplen);
2426 } else {
2427 snaplen_string = g_strdup("default");
2428 }
2429 if (cap_open_w) {
2430 if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
2431 path_str = g_strdup_printf("%d", indx);
2432 path = gtk_tree_path_new_from_string(path_str);
2433 model = gtk_tree_view_get_model(if_cb);
2434 gtk_tree_model_get_iter(model, &iter, path);
2435 gtk_tree_model_get(model, &iter, CAPTURE, &enabled, -1);
2436 if (enabled == FALSE) {
2437 device.selected = TRUE;
2438 global_capture_opts.num_selected++;
2439 global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_interface);
2440 g_array_insert_val(global_capture_opts.all_ifaces, marked_interface, device);
2441 }
2442 #if defined(HAVE_PCAP_CREATE)
2443 gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, linkname, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, MONITOR, device.monitor_mode_supported?(device.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, device.cfilter, -1);
2444 #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
2445 gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, linkname, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
2446 #else
2447 gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, linkname, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
2448 #endif
2449 if (global_capture_opts.num_selected > 0) {
2450 gtk_widget_set_sensitive(ok_bt, TRUE);
2451 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
2452 gtk_widget_set_sensitive(all_compile_bt, TRUE);
2453 #endif
2454 } else {
2455 gtk_widget_set_sensitive(ok_bt, FALSE);
2456 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
2457 gtk_widget_set_sensitive(all_compile_bt, FALSE);
2458 #endif
2459 }
2460 gtk_tree_path_free (path);
2461 g_free(path_str);
2462 }
2463 if (interfaces_dialog_window_present()) {
2464 update_selected_interface(g_strdup(device.name));
2465 }
2466 if (get_welcome_window() != NULL) {
2467 change_interface_selection(g_strdup(device.name), device.selected);
2468 }
2469 g_free(linkname);
2470 }
2471 set_sensitivity_for_start_icon();
2472 }
2473
2474
2475 static void
2476 save_options_cb(GtkWidget *win _U_, gpointer user_data _U_)
2477 {
2478 GtkWidget *snap_cb, *snap_sb, *promisc_cb,
2479 #ifdef HAVE_PCAP_CREATE
2480 *monitor_cb,
2481 #endif
2482 *filter_cm, *linktype_combo_box;
2483 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
2484 GtkWidget *buffer_size_sb;
2485 #endif
2486
2487 interface_t device;
2488 gpointer ptr = NULL;
2489 int dlt = -1;
2490 gchar *filter_text;
2491
2492 device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_interface);
2493 global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_interface);
2494 snap_cb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_SNAP_CB_KEY);
2495 snap_sb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_SNAP_SB_KEY);
2496 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
2497 buffer_size_sb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_BUFFER_SIZE_SB_KEY);
2498 #endif
2499 promisc_cb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_PROMISC_KEY);
2500 #ifdef HAVE_PCAP_CREATE
2501 monitor_cb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_MONITOR_KEY);
2502 #endif
2503 filter_cm = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CFILTER_CM_KEY);
2504
2505 linktype_combo_box = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_LT_CBX_KEY);
2506
2507 if (device.links != NULL) {
2508 if (ws_combo_box_get_active_pointer(GTK_COMBO_BOX(linktype_combo_box), &ptr)) {
2509 /* Even though device.links != NULL, we might not have an active pointer
2510 * if all of the available links are unsupported, so the failure of
2511 * ws_combo_box_get_active_pointer() is not cause for
2512 * g_assert_not_reached().
2513 */
2514 if (ptr != NULL && (dlt = GPOINTER_TO_INT(ptr)) == -1)
2515 g_assert_not_reached(); /* Programming error: somehow managed to select an "unsupported" entry */
2516 }
2517 }
2518 device.active_dlt = dlt;
2519 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
2520 device.buffer = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(buffer_size_sb));
2521 #endif
2522 device.pmode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(promisc_cb));
2523 device.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
2524 if (device.has_snaplen) {
2525 if (device.snaplen != (guint)gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(snap_sb))) {
2526 }
2527 device.snaplen = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(snap_sb));
2528 if (device.snaplen < 1)
2529 device.snaplen = WTAP_MAX_PACKET_SIZE;
2530 else if (device.snaplen < MIN_PACKET_SIZE)
2531 device.snaplen = MIN_PACKET_SIZE;
2532 } else {
2533 device.snaplen = WTAP_MAX_PACKET_SIZE;
2534 }
2535 filter_text = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(filter_cm));
2536 if (device.cfilter)
2537 g_free(device.cfilter);
2538 g_assert(filter_text != NULL);
2539 device.cfilter = filter_text;
2540 #ifdef HAVE_PCAP_CREATE
2541 /* if dumpcap reported that the interface does not support monitor
2542 mode, we disable monitor mode even if the user explicitly selected it */
2543 device.monitor_mode_enabled = device.monitor_mode_supported ?
2544 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(monitor_cb)) : FALSE;
2545 #endif
2546 g_array_insert_val(global_capture_opts.all_ifaces, marked_interface, device);
2547 window_destroy(opt_edit_w);
2548 update_options_table(marked_row);
2549 update_properties_all();
2550 }
2551
2552 static void
2553 adjust_snap_sensitivity(GtkWidget *tb _U_, gpointer parent_w _U_)
2554 {
2555 GtkWidget *snap_cb, *snap_sb;
2556 interface_t device;
2557
2558 device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_interface);
2559 global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_interface);
2560
2561 snap_cb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_SNAP_CB_KEY);
2562 snap_sb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_SNAP_SB_KEY);
2563
2564 /* The snapshot length spinbox is sensitive if the "Limit each packet
2565 to" checkbox is on. */
2566 gtk_widget_set_sensitive(GTK_WIDGET(snap_sb),
2567 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb)));
2568 device.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
2569 if (!device.has_snaplen) {
2570 gtk_spin_button_set_value(GTK_SPIN_BUTTON (snap_sb), WTAP_MAX_PACKET_SIZE);
2571 device.snaplen = WTAP_MAX_PACKET_SIZE;
2572 }
2573 g_array_insert_val(global_capture_opts.all_ifaces, marked_interface, device);
2574 }
2575
2576 void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column _U_, gpointer userdata)
2577 {
2578 GtkWidget *caller, *window, *swindow = NULL, *if_view,
2579 *main_vb, *if_hb, *if_lb, *if_lb_name,
2580 *main_hb, *left_vb,
2581 #if defined (HAVE_AIRPCAP) || defined (HAVE_PCAP_REMOTE) || defined (HAVE_PCAP_CREATE)
2582 *right_vb,
2583 #endif
2584 *capture_fr, *capture_vb,
2585 *if_ip_hb, *if_ip_lb = NULL, *if_ip_name,
2586 *if_vb_left, *if_vb_right,
2587 *linktype_hb, *linktype_lb, *linktype_combo_box,
2588 *snap_hb, *snap_cb, *snap_sb, *snap_lb,
2589 *promisc_cb,
2590 #ifdef HAVE_PCAP_CREATE
2591 *monitor_cb,
2592 #endif
2593 *filter_hb, *filter_bt, *filter_te, *filter_cm,
2594 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
2595 *compile_bt,
2596 #endif
2597 *bbox, *ok_but, *cancel_bt,
2598 *help_bt;
2599 GList *cf_entry, *list, *cfilter_list;
2600 GtkAdjustment *snap_adj;
2601 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
2602 GtkAdjustment *buffer_size_adj;
2603 GtkWidget *buffer_size_lb, *buffer_size_sb, *buffer_size_hb;
2604 #endif
2605 #ifdef HAVE_PCAP_REMOTE
2606 GtkWidget *remote_bt;
2607 #endif
2608 #ifdef HAVE_AIRPCAP
2609 GtkWidget *advanced_bt;
2610 #endif
2611 interface_t device;
2612 GtkTreeModel *model;
2613 GtkTreeIter iter;
2614 link_row *temp;
2615 gboolean found = FALSE;
2616 gint num_link_types, num_supported_link_types, first_supported_index;
2617 guint i;
2618 gchar *tok, *name;
2619 GtkCellRenderer *renderer;
2620 GtkListStore *store;
2621 const gchar *new_cfilter;
2622
2623 window = (GtkWidget *)userdata;
2624 caller = gtk_widget_get_toplevel(GTK_WIDGET(window));
2625 opt_edit_w = (GtkWidget *)g_object_get_data(G_OBJECT(caller), E_OPT_EDIT_DIALOG_PTR_KEY);
2626 if (opt_edit_w != NULL) {
2627 reactivate_window(opt_edit_w);
2628 return;
2629 }
2630
2631 device.name = NULL;
2632 device.display_name = NULL;
2633 device.no_addresses = 0;
2634 device.addresses = NULL;
2635 device.links = NULL;
2636 device.active_dlt = -1;
2637 device.pmode = FALSE;
2638 #ifdef HAVE_PCAP_CREATE
2639 device.monitor_mode_enabled = FALSE;
2640 device.monitor_mode_supported = FALSE;
2641 #endif
2642 device.has_snaplen = FALSE;
2643 device.snaplen = 65535;
2644 device.cfilter = NULL;
2645 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
2646 device.buffer = DEFAULT_CAPTURE_BUFFER_SIZE;
2647 #endif
2648
2649 model = gtk_tree_view_get_model(view);
2650 gtk_tree_model_get_iter (model, &iter, path);
2651
2652 if (window == get_welcome_window()) {
2653 gtk_tree_model_get(model, &iter, IFACE_NAME, &name, -1);
2654 } else if (window == cap_open_w) {
2655 gtk_tree_model_get(model, &iter, IFACE_HIDDEN_NAME, &name, -1);
2656 } else {
2657 return;
2658 }
2659
2660 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
2661 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
2662 if (strcmp(device.name, name) == 0) {
2663 marked_interface = i;
2664 break;
2665 }
2666 }
2667 marked_row = atoi(gtk_tree_path_to_string(path));
2668 opt_edit_w = dlg_window_new("Edit Interface Settings");
2669 gtk_window_set_modal(GTK_WINDOW(opt_edit_w), TRUE);
2670 gtk_window_set_type_hint (GTK_WINDOW (opt_edit_w), GDK_WINDOW_TYPE_HINT_DIALOG);
2671 g_object_set_data(G_OBJECT(opt_edit_w), E_OPT_EDIT_CALLER_PTR_KEY, caller);
2672 g_object_set_data(G_OBJECT(caller), E_OPT_EDIT_DIALOG_PTR_KEY, opt_edit_w);
2673
2674 main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
2675 gtk_container_set_border_width(GTK_CONTAINER(main_vb), 5);
2676 gtk_container_add(GTK_CONTAINER(opt_edit_w), main_vb);
2677
2678 /* Capture-related options frame */
2679 capture_fr = gtk_frame_new("Capture");
2680 gtk_box_pack_start(GTK_BOX (main_vb), capture_fr, TRUE, TRUE, 0);
2681
2682 capture_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
2683 gtk_container_set_border_width(GTK_CONTAINER(capture_vb), 5);
2684 gtk_container_add(GTK_CONTAINER(capture_fr), capture_vb);
2685
2686 /* Interface row */
2687 if_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
2688 gtk_box_pack_start(GTK_BOX(capture_vb), if_hb, FALSE, FALSE, 3);
2689
2690 if_lb = gtk_label_new("Interface: ");
2691 gtk_box_pack_start(GTK_BOX(if_hb), if_lb, FALSE, FALSE, 3);
2692
2693 if_lb_name = gtk_label_new(device.display_name);
2694 gtk_box_pack_start(GTK_BOX(if_hb), if_lb_name, FALSE, FALSE, 3);
2695
2696 /* IP addresses row */
2697 if_ip_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
2698
2699 gtk_widget_set_tooltip_text(if_ip_hb, "Lists the IP address(es) "
2700 "assigned to the selected interface. ");
2701 if_vb_left = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
2702 gtk_box_pack_start(GTK_BOX(if_ip_hb), if_vb_left, FALSE, FALSE, 3);
2703 if_vb_right = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
2704
2705 if_ip_lb = gtk_label_new("IP address:");
2706 gtk_misc_set_alignment(GTK_MISC(if_ip_lb), 0, 0); /* Left justified */
2707 gtk_box_pack_start(GTK_BOX(if_vb_left), if_ip_lb, FALSE, FALSE, 0);
2708 if (device.no_addresses > 0) {
2709 gchar *temp_addresses = g_strdup(device.addresses);
2710 gtk_box_pack_start(GTK_BOX(capture_vb), if_ip_hb, TRUE, TRUE, 0);
2711 gtk_box_pack_start(GTK_BOX(if_ip_hb), if_vb_right, TRUE, TRUE, 3);
2712 swindow = gtk_scrolled_window_new (NULL, NULL);
2713 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swindow), GTK_SHADOW_IN);
2714 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2715 gtk_widget_set_size_request(GTK_WIDGET(swindow),-1, 50);
2716 if_view = gtk_tree_view_new ();
2717 g_object_set(G_OBJECT(if_view), "headers-visible", FALSE, NULL);
2718 renderer = gtk_cell_renderer_text_new();
2719 column = gtk_tree_view_column_new_with_attributes ("",
2720 GTK_CELL_RENDERER(renderer),
2721 "text", 0,
2722 NULL);
2723 gtk_tree_view_append_column(GTK_TREE_VIEW(if_view), column);
2724 store = gtk_list_store_new(1, G_TYPE_STRING);
2725 for (tok = strtok (temp_addresses, "\n"); tok; tok = strtok(NULL, "\n")) {
2726 gtk_list_store_append (store, &iter);
2727 gtk_list_store_set (store, &iter, 0, tok, -1);
2728 }
2729 gtk_tree_view_set_model(GTK_TREE_VIEW(if_view), GTK_TREE_MODEL (store));
2730 gtk_container_add (GTK_CONTAINER (swindow), if_view);
2731 gtk_box_pack_start(GTK_BOX(if_vb_right), swindow, TRUE, TRUE, 0);
2732 g_free(temp_addresses);
2733 } else {
2734 gtk_box_pack_start(GTK_BOX(capture_vb), if_ip_hb, FALSE, FALSE, 0);
2735 gtk_box_pack_start(GTK_BOX(if_ip_hb), if_vb_right, FALSE, FALSE, 3);
2736 if_ip_name = gtk_label_new("none");
2737 gtk_misc_set_alignment(GTK_MISC(if_ip_name), 0, 0); /* Left justified */
2738 gtk_box_pack_start(GTK_BOX(if_vb_right), if_ip_name, FALSE, FALSE, 0);
2739 }
2740 main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5, FALSE);
2741 gtk_container_set_border_width(GTK_CONTAINER(main_hb), 0);
2742 gtk_box_pack_start(GTK_BOX(capture_vb), main_hb, FALSE, FALSE, 3);
2743
2744 left_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
2745 gtk_container_set_border_width(GTK_CONTAINER(left_vb), 0);
2746 gtk_box_pack_start(GTK_BOX(main_hb), left_vb, TRUE, TRUE, 0);
2747
2748 #if defined (HAVE_AIRPCAP) || defined (HAVE_PCAP_REMOTE) || defined (HAVE_PCAP_CREATE)
2749 /* Avoid adding the right vbox if not needed, because it steals 3 pixels */
2750 right_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
2751 gtk_container_set_border_width(GTK_CONTAINER(right_vb), 0);
2752 gtk_box_pack_start(GTK_BOX(main_hb), right_vb, FALSE, FALSE, 3);
2753 #endif
2754
2755 /* Linktype row */
2756 linktype_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
2757 gtk_box_pack_start(GTK_BOX(left_vb), linktype_hb, FALSE, FALSE, 0);
2758
2759 linktype_lb = gtk_label_new("Link-layer header type:");
2760 gtk_box_pack_start(GTK_BOX(linktype_hb), linktype_lb, FALSE, FALSE, 3);
2761
2762 linktype_combo_box = ws_combo_box_new_text_and_pointer();
2763 g_object_set_data(G_OBJECT(linktype_combo_box), E_CAP_LT_CBX_LABEL_KEY, linktype_lb);
2764 /* Default to "use the default" */
2765 /* Datalink menu index is not reset; it will be restored with last used value */
2766
2767 g_object_set_data(G_OBJECT(linktype_combo_box), E_CAP_IFACE_IP_KEY, if_ip_lb);
2768 /*
2769 * XXX - in some cases, this is "multiple link-layer header types", e.g.
2770 * some 802.11 interfaces on FreeBSD 5.2 and later, where you can request
2771 * fake Ethernet, 802.11, or 802.11-plus-radio-information headers.
2772 *
2773 * In other cases, it's "multiple link-layer types", e.g., with recent
2774 * versions of libpcap, a DAG card on an "HDLC" WAN, where you can
2775 * request Cisco HDLC or PPP depending on what type of traffic is going
2776 * over the WAN, or an Ethernet interface, where you can request Ethernet
2777 * or DOCSIS, the latter being for some Cisco cable modem equipment that
2778 * can be configured to send raw DOCSIS frames over an Ethernet inside
2779 * Ethernet low-level framing, for traffic capture purposes.
2780 *
2781 * We leave it as "multiple link-layer types" for now.
2782 */
2783 gtk_widget_set_tooltip_text(linktype_combo_box, "The selected interface supports multiple link-layer types; select the desired one.");
2784 gtk_box_pack_start (GTK_BOX(linktype_hb), linktype_combo_box, FALSE, FALSE, 0);
2785 g_object_set_data(G_OBJECT(opt_edit_w), E_CAP_LT_CBX_KEY, linktype_combo_box);
2786 num_link_types = 0;
2787 num_supported_link_types = 0;
2788 first_supported_index = -1;
2789 for (list=device.links; list!=NULL; list=g_list_next(list))
2790 {
2791 temp = (link_row*)(list->data);
2792 if (temp->dlt == -1)
2793 {
2794 ws_combo_box_append_text_and_pointer_full(GTK_COMBO_BOX(linktype_combo_box),
2795 NULL,
2796 temp->name,
2797 GINT_TO_POINTER(-1), /* Flag as "not supported" */
2798 FALSE);
2799 }
2800 else
2801 {
2802 ws_combo_box_append_text_and_pointer(GTK_COMBO_BOX(linktype_combo_box),
2803 temp->name,
2804 GINT_TO_POINTER(temp->dlt));
2805 /* Record the index of the first supported link type (and thus the first
2806 * one in the list to be active) for use determining the default selected
2807 * element. */
2808 if (first_supported_index == -1)
2809 {
2810 first_supported_index = num_link_types;
2811 }
2812 if (temp->dlt == device.active_dlt)
2813 {
2814 ws_combo_box_set_active(GTK_COMBO_BOX(linktype_combo_box), num_link_types);
2815 found = TRUE;
2816 }
2817 num_supported_link_types++;
2818 }
2819 num_link_types++;
2820 }
2821 gtk_widget_set_sensitive(linktype_lb, num_link_types >= 2);
2822 gtk_widget_set_sensitive(linktype_combo_box, num_link_types >= 2);
2823 if (!found && first_supported_index >= 0)
2824 {
2825 ws_combo_box_set_active(GTK_COMBO_BOX(linktype_combo_box),first_supported_index);
2826 }
2827 g_signal_connect(linktype_combo_box, "changed", G_CALLBACK(select_link_type_cb), NULL);
2828
2829 /* Promiscuous mode row */
2830 promisc_cb = gtk_check_button_new_with_mnemonic(
2831 "Capture packets in _promiscuous mode");
2832 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_cb),
2833 device.pmode);
2834 gtk_widget_set_tooltip_text(promisc_cb,
2835 "Usually a network adapter will only capture the traffic sent to its own network address. "
2836 "If you want to capture all traffic that the network adapter can \"see\", mark this option. "
2837 "See the FAQ for some more details of capturing packets from a switched network.");
2838 gtk_box_pack_start (GTK_BOX(left_vb), promisc_cb, FALSE, FALSE, 0);
2839 g_object_set_data(G_OBJECT(opt_edit_w), E_CAP_PROMISC_KEY, promisc_cb);
2840
2841 #ifdef HAVE_PCAP_CREATE
2842 /* Monitor mode row */
2843 monitor_cb = gtk_check_button_new_with_mnemonic( "Capture packets in monitor mode");
2844 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(monitor_cb), device.monitor_mode_enabled);
2845 gtk_widget_set_sensitive(monitor_cb, device.monitor_mode_supported);
2846 g_signal_connect(monitor_cb, "toggled", G_CALLBACK(capture_prep_monitor_changed_cb), NULL);
2847
2848 gtk_widget_set_tooltip_text(monitor_cb,
2849 "Usually a Wi-Fi adapter will, even in promiscuous mode, only capture the traffic on the BSS to which it's associated. "
2850 "If you want to capture all traffic that the Wi-Fi adapter can \"receive\", mark this option. "
2851 "In order to see IEEE 802.11 headers or to see radio information for captured packets, "
2852 "it might be necessary to turn this option on.\n\n"
2853 "Note that, in monitor mode, the adapter might disassociate from the network to which it's associated.");
2854 gtk_box_pack_start (GTK_BOX(left_vb), monitor_cb, FALSE, FALSE, 0);
2855
2856 g_object_set_data(G_OBJECT(opt_edit_w), E_CAP_MONITOR_KEY, monitor_cb);
2857 #endif
2858
2859 /*
2860 * This controls the sensitivity of both the link-type list and, if
2861 * you have it, the monitor mode checkbox. That's why we do this
2862 * now.
2863 */
2864
2865 /* Capture length row */
2866 snap_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
2867 gtk_box_pack_start (GTK_BOX(left_vb), snap_hb, FALSE, FALSE, 0);
2868
2869 snap_cb = gtk_check_button_new_with_mnemonic("_Limit each packet to");
2870 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(snap_cb),
2871 device.has_snaplen);
2872 g_signal_connect(snap_cb, "toggled", G_CALLBACK(adjust_snap_sensitivity), NULL);
2873 gtk_widget_set_tooltip_text(snap_cb,
2874 "Limit the maximum number of bytes to be captured from each packet. This size includes the "
2875 "link-layer header and all subsequent headers. ");
2876 gtk_box_pack_start(GTK_BOX(snap_hb), snap_cb, FALSE, FALSE, 0);
2877
2878 snap_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) device.snaplen,
2879 MIN_PACKET_SIZE, WTAP_MAX_PACKET_SIZE, 1.0, 10.0, 0.0);
2880 snap_sb = gtk_spin_button_new (snap_adj, 0, 0);
2881 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (snap_sb), TRUE);
2882 gtk_widget_set_size_request(snap_sb, 80, -1);
2883 gtk_box_pack_start (GTK_BOX(snap_hb), snap_sb, FALSE, FALSE, 0);
2884
2885 g_object_set_data(G_OBJECT(opt_edit_w), E_CAP_SNAP_CB_KEY, snap_cb);
2886 g_object_set_data(G_OBJECT(opt_edit_w), E_CAP_SNAP_SB_KEY, snap_sb);
2887 snap_lb = gtk_label_new("bytes");
2888 gtk_misc_set_alignment(GTK_MISC(snap_lb), 0, 0.5f);
2889 gtk_box_pack_start(GTK_BOX(snap_hb), snap_lb, FALSE, FALSE, 0);
2890 gtk_widget_set_sensitive(GTK_WIDGET(snap_sb), device.has_snaplen);
2891
2892 /* Filter row */
2893 filter_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
2894 gtk_box_pack_start(GTK_BOX(capture_vb), filter_hb, FALSE, FALSE, 0);
2895
2896 filter_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_CAPTURE_FILTER_ENTRY);
2897 g_signal_connect(filter_bt, "clicked", G_CALLBACK(capture_filter_construct_cb), NULL);
2898 g_signal_connect(filter_bt, "destroy", G_CALLBACK(filter_button_destroy_cb), NULL);
2899 gtk_widget_set_tooltip_text(filter_bt,
2900 "Select a capture filter to reduce the amount of packets to be captured. "
2901 "See \"Capture Filters\" in the online help for further information how to use it."
2902 );
2903 gtk_box_pack_start(GTK_BOX(filter_hb), filter_bt, FALSE, FALSE, 3);
2904
2905 /* Create the capture filter combo box*/
2906 filter_cm = gtk_combo_box_text_new_with_entry();
2907 g_object_set_data(G_OBJECT(opt_edit_w), E_CFILTER_CM_KEY, filter_cm);
2908 filter_te = gtk_bin_get_child(GTK_BIN(filter_cm));
2909 colorize_filter_te_as_empty(filter_te);
2910 g_signal_connect(filter_te, "changed", G_CALLBACK(capture_filter_check_syntax_cb), NULL);
2911 g_signal_connect(filter_te, "destroy", G_CALLBACK(capture_filter_destroy_cb), NULL);
2912
2913 cfilter_list = recent_get_cfilter_list(name);
2914 for (cf_entry = cfilter_list; cf_entry != NULL; cf_entry = g_list_next(cf_entry)) {
2915 new_cfilter = (const gchar *)cf_entry->data;
2916 /* If this is the current dfilter or the default cfilter, don't put
2917 it in the list, as it'll be added later. */
2918 if ((device.cfilter == NULL || strcmp(device.cfilter, new_cfilter) != 0) &&
2919 (global_capture_opts.default_options.cfilter == NULL || strcmp(global_capture_opts.default_options.cfilter, new_cfilter) != 0)) {
2920 gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), new_cfilter);
2921 }
2922 }
2923 if (global_capture_opts.default_options.cfilter && (strlen(global_capture_opts.default_options.cfilter) > 0)) {
2924 /* If this is the current dfilter, don't put it in the list, as it'll be
2925 added later. */
2926 if (device.cfilter == NULL || strcmp(device.cfilter, global_capture_opts.default_options.cfilter) != 0) {
2927 gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), global_capture_opts.default_options.cfilter);
2928 }
2929 }
2930 if (device.cfilter && (strlen(device.cfilter) > 0)) {
2931 gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), device.cfilter);
2932 gtk_combo_box_set_active(GTK_COMBO_BOX(filter_cm), 0);
2933 }
2934
2935 gtk_widget_set_tooltip_text(filter_cm,
2936 "Enter a capture filter to reduce the amount of packets to be captured. "
2937 "See \"Capture Filters\" in the online help for further information how to use it. "
2938 "Syntax checking can be disabled in Preferences -> Capture -> Syntax check capture filter."
2939 );
2940 gtk_box_pack_start(GTK_BOX(filter_hb), filter_cm, TRUE, TRUE, 3);
2941
2942 /* let an eventually capture filters dialog know the text entry to fill in */
2943 g_object_set_data(G_OBJECT(filter_bt), E_FILT_TE_PTR_KEY, filter_te);
2944
2945 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
2946 compile_bt = gtk_button_new_with_label("Compile BPF");
2947 g_signal_connect(compile_bt, "clicked", G_CALLBACK(capture_filter_compile_cb), NULL);
2948 gtk_widget_set_tooltip_text(compile_bt,
2949 "Compile the capture filter expression and show the BPF (Berkeley Packet Filter) code.");
2950 /* We can't compile without any supported link-types, so disable the button in that case */
2951 gtk_widget_set_sensitive(compile_bt, (num_supported_link_types >= 1));
2952 gtk_box_pack_start(GTK_BOX(filter_hb), compile_bt, FALSE, FALSE, 3);
2953 #endif
2954
2955 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
2956 buffer_size_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
2957 buffer_size_lb = gtk_label_new("Buffer size:");
2958 gtk_box_pack_start (GTK_BOX(buffer_size_hb), buffer_size_lb, FALSE, FALSE, 0);
2959
2960 buffer_size_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) device.buffer,
2961 1, 65535, 1.0, 10.0, 0.0);
2962 buffer_size_sb = gtk_spin_button_new (buffer_size_adj, 0, 0);
2963 gtk_spin_button_set_value(GTK_SPIN_BUTTON (buffer_size_sb), (gfloat) device.buffer);
2964 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (buffer_size_sb), TRUE);
2965 gtk_widget_set_size_request(buffer_size_sb, 80, -1);
2966 gtk_widget_set_tooltip_text(buffer_size_sb,
2967 "The memory buffer size used while capturing. If you notice packet drops, you can try to increase this size.");
2968 gtk_box_pack_start (GTK_BOX(buffer_size_hb), buffer_size_sb, FALSE, FALSE, 0);
2969 g_object_set_data(G_OBJECT(opt_edit_w), E_CAP_BUFFER_SIZE_SB_KEY, buffer_size_sb);
2970 buffer_size_lb = gtk_label_new("megabyte(s)");
2971 gtk_box_pack_start (GTK_BOX(buffer_size_hb), buffer_size_lb, FALSE, FALSE, 3);
2972 gtk_misc_set_alignment(GTK_MISC(buffer_size_lb), 1, 0);
2973 #ifdef HAVE_PCAP_REMOTE
2974 gtk_box_pack_start (GTK_BOX(left_vb), buffer_size_hb, FALSE, FALSE, 0);
2975 #else
2976 gtk_box_pack_start (GTK_BOX(right_vb), buffer_size_hb, FALSE, FALSE, 0);
2977 #endif
2978 #endif
2979
2980 #ifdef HAVE_PCAP_REMOTE
2981 /*
2982 * *IF* this is a remote interface, add the "Remote Settings"
2983 * button. Do *not* add it for other interfaces, as that could
2984 * lead users to believe that it could somehow be enabled.
2985 */
2986 /* Both the callback and the data are global */
2987 if (strncmp (device.name, "rpcap://", 8) == 0) {
2988 remote_bt = gtk_button_new_with_label("Remote Settings");
2989 gtk_widget_set_tooltip_text(remote_bt, "Various settings for remote capture.");
2990
2991 g_signal_connect(remote_bt, "clicked", G_CALLBACK(options_remote_cb), NULL);
2992
2993 gtk_box_pack_start(GTK_BOX(right_vb), remote_bt, FALSE, FALSE, 0);
2994 gtk_widget_show(remote_bt);
2995 }
2996 #endif
2997
2998 #ifdef HAVE_AIRPCAP
2999 /*
3000 * *IF* this is an AirPcap interface, add the "Wireless Settings"
3001 * button. Do *not* add it for other interfaces, as that can
3002 * confuse users, so that they ask why this is grayed out on
3003 * their non-Windows machine and ask how to enable it.
3004 */
3005 airpcap_if_selected = get_airpcap_if_from_name(airpcap_if_list, device.name);
3006 if (airpcap_if_selected != NULL) {
3007 advanced_bt = gtk_button_new_with_label("Wireless Settings");
3008
3009 /* Both the callback and the data are global */
3010 g_signal_connect(advanced_bt,"clicked", G_CALLBACK(options_airpcap_advanced_cb), wireless_tb);
3011
3012 gtk_box_pack_start(GTK_BOX(right_vb), advanced_bt, FALSE, FALSE, 0);
3013 gtk_widget_show(advanced_bt);
3014 }
3015 #endif
3016
3017 /* Button row: "Start", "Cancel" and "Help" buttons */
3018 bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL);
3019 gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 5);
3020
3021 ok_but = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_OK);
3022 g_signal_connect(ok_but, "clicked", G_CALLBACK(save_options_cb), NULL);
3023 gtk_widget_set_tooltip_text(ok_but,
3024 "Accept interface settings.");
3025 cancel_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CANCEL);
3026 gtk_widget_set_tooltip_text(cancel_bt,
3027 "Cancel and exit dialog.");
3028 window_set_cancel_button(opt_edit_w, cancel_bt, window_cancel_button_cb);
3029 help_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
3030 gtk_widget_set_tooltip_text(help_bt,
3031 "Show help about capturing.");
3032 g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), (gpointer)HELP_CAPTURE_OPTIONS_DIALOG);
3033 dlg_set_activate(filter_te, ok_but);
3034 gtk_widget_grab_focus(filter_te);
3035 g_signal_connect(opt_edit_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
3036 g_signal_connect(opt_edit_w, "destroy", G_CALLBACK(options_edit_destroy_cb), NULL);
3037 gtk_widget_show_all(opt_edit_w);
3038 window_present(opt_edit_w);
3039 }
3040
3041 static void toggle_callback(GtkCellRendererToggle *cell _U_,
3042 gchar *path_str,
3043 gpointer data _U_)
3044 {
3045 /* get the treemodel from somewhere */
3046 GtkTreeIter iter;
3047 GtkTreeView *if_cb;
3048 GtkTreeModel *model;
3049 GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
3050 gboolean enabled;
3051 GtkWidget *pcap_ng_cb, *filter_cm;
3052 interface_t device;
3053 gchar *name;
3054 gint indx = -1;
3055 guint i;
3056
3057 if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
3058 model = gtk_tree_view_get_model(if_cb);
3059 gtk_tree_model_get_iter (model, &iter, path);
3060 gtk_tree_model_get (model, &iter, CAPTURE, &enabled, IFACE_HIDDEN_NAME, &name, -1);
3061 /* Look for the right interface. The number of interfaces shown might be less
3062 * than the real number. Therefore the path index does not correspond
3063 * necessarily to the position in the list */
3064 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
3065 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
3066 if (strcmp(device.name, name) == 0) {
3067 indx = i;
3068 break;
3069 }
3070 }
3071 if (!device.locked) {
3072 if (enabled == FALSE) {
3073 device.selected = TRUE;
3074 global_capture_opts.num_selected++;
3075 } else {
3076 device.selected = FALSE;
3077 global_capture_opts.num_selected--;
3078 }
3079 device.locked = TRUE;
3080 }
3081 if (indx != -1) {
3082 global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, indx);
3083 g_array_insert_val(global_capture_opts.all_ifaces, indx, device);
3084 pcap_ng_cb = (GtkWidget *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_PCAP_NG_KEY);
3085 if (global_capture_opts.num_selected >= 2) {
3086 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pcap_ng_cb), TRUE);
3087 gtk_widget_set_sensitive(pcap_ng_cb, FALSE);
3088 } else {
3089 gtk_widget_set_sensitive(pcap_ng_cb, TRUE);
3090 }
3091 if (global_capture_opts.num_selected > 0) {
3092 gtk_widget_set_sensitive(ok_bt, TRUE);
3093 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
3094 gtk_widget_set_sensitive(all_compile_bt, TRUE);
3095 #endif
3096 } else {
3097 gtk_widget_set_sensitive(ok_bt, FALSE);
3098 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
3099 gtk_widget_set_sensitive(all_compile_bt, FALSE);
3100 #endif
3101 }
3102 /* do something with the new enabled value, and set the new
3103 enabled value in your treemodel */
3104 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, -1);
3105 if (interfaces_dialog_window_present()) {
3106 update_selected_interface(g_strdup(device.name));
3107 }
3108 if (get_welcome_window() != NULL) {
3109 change_interface_selection(g_strdup(device.name), device.selected);
3110 }
3111 }
3112 if (device.cfilter != NULL) {
3113 g_free(device.cfilter);
3114 device.cfilter = NULL;
3115 update_filter_string(device.name, NULL);
3116 }
3117 device.locked = FALSE;
3118 global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, indx);
3119 g_array_insert_val(global_capture_opts.all_ifaces, indx, device);
3120 gtk_tree_path_free (path);
3121 filter_cm = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY);
3122 if (strcmp(gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(filter_cm)),"") != 0) {
3123 capture_all_filter_check_syntax_cb(NULL, NULL);
3124 }
3125 update_properties_all();
3126 }
3127
3128 void enable_selected_interface(gchar *name, gboolean selected)
3129 {
3130 GtkTreeIter iter;
3131 GtkTreeView *if_cb;
3132 GtkTreeModel *model;
3133 gchar *name_str;
3134
3135 if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
3136 model = gtk_tree_view_get_model(if_cb);
3137 gtk_tree_model_get_iter_first(model, &iter);
3138 do {
3139 gtk_tree_model_get(model, &iter, IFACE_HIDDEN_NAME, &name_str, -1);
3140 if (strcmp(name, name_str) == 0) {
3141 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, selected, -1);
3142 break;
3143 }
3144 }
3145 while (gtk_tree_model_iter_next(model, &iter));
3146 if (global_capture_opts.num_selected > 0) {
3147 gtk_widget_set_sensitive(ok_bt, TRUE);
3148 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
3149 gtk_widget_set_sensitive(all_compile_bt, TRUE);
3150 #endif
3151 } else {
3152 gtk_widget_set_sensitive(ok_bt, FALSE);
3153 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
3154 gtk_widget_set_sensitive(all_compile_bt, FALSE);
3155 #endif
3156 }
3157 }
3158
3159
3160 static void capture_all_cb(GtkToggleButton *button, gpointer d _U_)
3161 {
3162 GtkTreeIter iter;
3163 GtkTreeView *if_cb;
3164 GtkTreeModel *model;
3165 GtkWidget *filter_cm, *pcap_ng_cb;
3166 gchar *interface = NULL, *filter_text = NULL;
3167 gboolean enabled = FALSE, capture_set = FALSE, pseudo = FALSE;
3168 guint16 num_temp, i;
3169 interface_t device;
3170
3171 if (gtk_toggle_button_get_active(button))
3172 enabled = TRUE;
3173 if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
3174 model = gtk_tree_view_get_model(if_cb);
3175 pcap_ng_cb = (GtkWidget *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_PCAP_NG_KEY);
3176 num_temp = global_capture_opts.num_selected++;
3177 filter_cm = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY);
3178 filter_text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT(filter_cm));
3179 if (gtk_tree_model_get_iter_first(model, &iter)) {
3180 do {
3181 gtk_tree_model_get (model, &iter, CAPTURE, &capture_set, IFACE_HIDDEN_NAME, &interface, -1);
3182 if (strcmp(interface, "any") == 0) {
3183 pseudo = TRUE;
3184 }
3185 if (!capture_set && enabled && !pseudo) {
3186 num_temp++;
3187 } else if (capture_set && (!enabled || (enabled && pseudo))) {
3188 num_temp--;
3189 }
3190 if (!pseudo) {
3191 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, enabled, -1);
3192 if (strlen(filter_text) != 0) {
3193 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
3194 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
3195 if (strcmp(device.name, interface) == 0) {
3196 g_array_remove_index(global_capture_opts.all_ifaces, i);
3197 device.cfilter = g_strdup(filter_text);
3198 g_array_insert_val(global_capture_opts.all_ifaces, i, device);
3199 update_filter_string(device.name, filter_text);
3200 }
3201 }
3202 }
3203 } else {
3204 gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, -1);
3205 }
3206 pseudo = FALSE;
3207 } while (gtk_tree_model_iter_next(model, &iter));
3208 }
3209 if (num_temp >= 2) {
3210 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pcap_ng_cb), TRUE);
3211 gtk_widget_set_sensitive(pcap_ng_cb, FALSE);
3212 } else if (num_temp <= 1) {
3213 gtk_widget_set_sensitive(pcap_ng_cb, TRUE);
3214 }
3215 if (interfaces_dialog_window_present()) {
3216 select_all_interfaces(enabled);
3217 }
3218 if (get_welcome_window() != NULL) {
3219 change_selection_for_all(enabled);
3220 }
3221 if (global_capture_opts.num_selected != num_temp) {
3222 global_capture_opts.num_selected = num_temp;
3223 }
3224 if (global_capture_opts.num_selected > 0) {
3225 gtk_widget_set_sensitive(ok_bt, TRUE);
3226 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
3227 gtk_widget_set_sensitive(all_compile_bt, TRUE);
3228 #endif
3229 } else {
3230 gtk_widget_set_sensitive(ok_bt, FALSE);
3231 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
3232 gtk_widget_set_sensitive(all_compile_bt, FALSE);
3233 #endif
3234 }
3235 set_sensitivity_for_start_icon();
3236 }
3237
3238
3239 static gboolean get_all_prom_mode(void)
3240 {
3241 interface_options interface_opts;
3242 guint i;
3243
3244 for (i = 0; i < global_capture_opts.ifaces->len; i++) {
3245 interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
3246 if (!interface_opts.promisc_mode) {
3247 return FALSE;
3248 }
3249 }
3250 return TRUE;
3251 }
3252
3253 static void promisc_mode_callback(GtkToggleButton *button, gpointer d _U_)
3254 {
3255 GtkTreeIter iter;
3256 GtkTreeView *if_cb;
3257 GtkTreeModel *model;
3258 gboolean enabled = FALSE, set;
3259 interface_t device;
3260 interface_options interface_opts;
3261 guint i;
3262
3263 set = gtk_toggle_button_get_active(button);
3264 gtk_toggle_button_set_active(button, (set?FALSE:TRUE));
3265 if (gtk_toggle_button_get_active(button))
3266 enabled = TRUE;
3267
3268 if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
3269 model = gtk_tree_view_get_model(if_cb);
3270 if (gtk_tree_model_get_iter_first(model, &iter)) {
3271 do {
3272 gtk_list_store_set(GTK_LIST_STORE(model), &iter, PMODE, enabled?"enabled":"disabled", -1);
3273 } while (gtk_tree_model_iter_next(model, &iter));
3274 }
3275
3276 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
3277 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
3278 global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
3279 device.pmode = (enabled?TRUE:FALSE);
3280 g_array_insert_val(global_capture_opts.all_ifaces, i, device);
3281 }
3282
3283 for (i = 0; i < global_capture_opts.ifaces->len; i++) {
3284 interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
3285 global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
3286 interface_opts.promisc_mode = (enabled?TRUE:FALSE);
3287 g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
3288 }
3289 }
3290
3291 #if defined (HAVE_PCAP_REMOTE)
3292 static void
3293 show_remote_dialog(GtkWidget *w)
3294 {
3295
3296 g_free(global_remote_opts.remote_host_opts.remote_host);
3297 g_free(global_remote_opts.remote_host_opts.remote_port);
3298 g_free(global_remote_opts.remote_host_opts.auth_username);
3299 g_free(global_remote_opts.remote_host_opts.auth_password);
3300 global_remote_opts.src_type = CAPTURE_IFREMOTE;
3301 global_remote_opts.remote_host_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
3302 global_remote_opts.remote_host_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
3303 global_remote_opts.remote_host_opts.auth_type = global_capture_opts.default_options.auth_type;
3304 global_remote_opts.remote_host_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
3305 global_remote_opts.remote_host_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
3306 global_remote_opts.remote_host_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
3307 global_remote_opts.remote_host_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
3308 global_remote_opts.remote_host_opts.nocap_local = global_capture_opts.default_options.nocap_local;
3309 #ifdef HAVE_PCAP_SETSAMPLING
3310 global_remote_opts.sampling_method = global_capture_opts.default_options.sampling_method;
3311 global_remote_opts.sampling_param = global_capture_opts.default_options.sampling_param;
3312 #endif
3313 capture_remote_cb(GTK_WIDGET(w), FALSE);
3314 }
3315 #endif
3316
3317 static void change_pipe_name_cb(gpointer dialog _U_, gint btn, gpointer data)
3318 {
3319 guint i;
3320 interface_t device;
3321 gchar *temp, *optname, *snaplen_string/*, *oldname = ""*/;
3322 GtkTreeView *if_cb;
3323 GtkTreeModel *model;
3324 GtkTreeIter iter;
3325 GtkWidget *pipe_te;
3326
3327 switch(btn) {
3328 case(ESD_BTN_OK):
3329 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
3330 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
3331 if (strcmp((gchar *)data, device.name) == 0) {
3332 simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK,
3333 "%sA pipe with this name already exists.%s",
3334 simple_dialog_primary_start(), simple_dialog_primary_end());
3335 if_cb = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_L_KEY));
3336 pipe_te = (GtkWidget *) g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY);
3337 model = gtk_tree_view_get_model(if_cb);
3338 if (gtk_tree_model_get_iter_first (model, &iter)) {
3339 do {
3340 gtk_tree_model_get(model, &iter, 0, &optname, -1);
3341 if (strcmp(optname, (gchar *) data) == 0) {
3342 gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, pipe_name, -1);
3343 gtk_entry_set_text(GTK_ENTRY(pipe_te), pipe_name);
3344 break;
3345 }
3346 } while (gtk_tree_model_iter_next(model, &iter));
3347 g_free(optname);
3348 }
3349 return;
3350 }
3351 }
3352 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
3353 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
3354 if (strcmp(pipe_name, device.name) == 0) {
3355 device.name = g_strdup((gchar *)data);
3356 device.display_name = g_strdup_printf("%s", device.name);
3357 g_array_remove_index(global_capture_opts.all_ifaces, i);
3358 g_array_insert_val(global_capture_opts.all_ifaces, i, device);
3359 temp = g_strdup_printf("<b>%s</b>", device.display_name);
3360 if (device.has_snaplen) {
3361 snaplen_string = g_strdup_printf("%d", device.snaplen);
3362 } else {
3363 snaplen_string = g_strdup("default");
3364 }
3365 if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
3366 model = gtk_tree_view_get_model(if_cb);
3367 if (gtk_tree_model_get_iter_first (model, &iter)) {
3368 do {
3369 gtk_tree_model_get(model, &iter, IFACE_HIDDEN_NAME, &optname, -1);
3370 if (strcmp(optname, pipe_name) == 0) {
3371 #if defined(HAVE_PCAP_CREATE)
3372 gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, MONITOR, device.monitor_mode_supported?(device.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, device.cfilter, -1);
3373 #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
3374 gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
3375 #else
3376 gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
3377 #endif
3378 #if 0
3379 oldname = g_strdup(pipe_name);
3380 #endif
3381 pipe_name = g_strdup(device.name);
3382 break;
3383 }
3384 } while (gtk_tree_model_iter_next(model, &iter));
3385
3386 g_free(optname);
3387 }
3388 if (global_capture_opts.num_selected > 0) {
3389 gtk_widget_set_sensitive(ok_bt, TRUE);
3390 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
3391 gtk_widget_set_sensitive(all_compile_bt, TRUE);
3392 #endif
3393 } else {
3394 gtk_widget_set_sensitive(ok_bt, FALSE);
3395 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
3396 gtk_widget_set_sensitive(all_compile_bt, FALSE);
3397 #endif
3398 }
3399 refresh_non_local_interface_lists();
3400 break;
3401 }
3402 }
3403 break;
3404 case(ESD_BTN_CANCEL): {
3405 if_cb = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_L_KEY));
3406 pipe_te = (GtkWidget *) g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY);
3407 model = gtk_tree_view_get_model(if_cb);
3408
3409 if (gtk_tree_model_get_iter_first (model, &iter)) {
3410 do {
3411 gtk_tree_model_get(model, &iter, 0, &optname, -1);
3412 if (strcmp(optname, (gchar *) data) == 0) {
3413 gtk_list_store_set (GTK_LIST_STORE(model), &iter, 0, pipe_name, -1);
3414 gtk_entry_set_text(GTK_ENTRY(pipe_te), pipe_name);
3415 break;
3416 }
3417 } while (gtk_tree_model_iter_next(model, &iter));
3418 g_free(optname);
3419 }
3420 break;
3421 }
3422 default:
3423 g_assert_not_reached();
3424 }
3425 }
3426
3427 static void
3428 add_pipe_cb(gpointer w _U_)
3429 {
3430 interface_t device;
3431 gint indx;
3432 GtkTreeView *if_cb;
3433 GtkTreeModel *model;
3434 GtkTreeIter iter;
3435 gchar *temp, *path_str, *snaplen_string;
3436 GtkWidget *pipe_te;
3437 const gchar *g_save_file;
3438 gchar *name;
3439 guint i;
3440 gpointer dialog;
3441
3442 pipe_te = (GtkWidget *) g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY);
3443 g_save_file = gtk_entry_get_text(GTK_ENTRY(pipe_te));
3444 name = g_strdup(g_save_file);
3445 if (strcmp(name, "New pipe") == 0 || strcmp(name, "") == 0) {
3446 g_free(name);
3447 return;
3448 }
3449 if (strcmp(pipe_name, "New pipe") != 0) {
3450 if (strcmp(pipe_name, name) != 0) {
3451 dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_OK_CANCEL,
3452 "%sDo you want to change %s to %s?%s",
3453 simple_dialog_primary_start(), pipe_name, name, simple_dialog_primary_end());
3454 simple_dialog_set_cb(dialog, change_pipe_name_cb, name);
3455 }
3456 } else {
3457 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
3458 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
3459 if (strcmp(name, device.name) == 0) {
3460 g_free(name);
3461 return;
3462 }
3463 }
3464 pipe_name = g_strdup(g_save_file);
3465 device.name = g_strdup(g_save_file);
3466 device.display_name = g_strdup_printf("%s", device.name);
3467 device.hidden = FALSE;
3468 device.selected = TRUE;
3469 device.type = IF_PIPE;
3470 device.pmode = global_capture_opts.default_options.promisc_mode;
3471 device.has_snaplen = global_capture_opts.default_options.has_snaplen;
3472 device.snaplen = global_capture_opts.default_options.snaplen;
3473 device.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
3474 device.addresses = NULL;
3475 device.no_addresses = 0;
3476 device.last_packets = 0;
3477 device.links = NULL;
3478 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
3479 device.buffer = DEFAULT_CAPTURE_BUFFER_SIZE;
3480 #endif
3481 device.active_dlt = -1;
3482 device.locked = FALSE;
3483 device.if_info.name = g_strdup(g_save_file);
3484 device.if_info.friendly_name = NULL;
3485 device.if_info.vendor_description = NULL;
3486 device.if_info.addrs = NULL;
3487 device.if_info.loopback = FALSE;
3488 #if defined(HAVE_PCAP_CREATE)
3489 device.monitor_mode_enabled = FALSE;
3490 device.monitor_mode_supported = FALSE;
3491 #endif
3492 global_capture_opts.num_selected++;
3493
3494 indx = global_capture_opts.all_ifaces->len;
3495 temp = g_strdup_printf("<b>%s</b>", device.display_name);
3496
3497 if (device.has_snaplen) {
3498 snaplen_string = g_strdup_printf("%d", device.snaplen);
3499 } else {
3500 snaplen_string = g_strdup("default");
3501 }
3502
3503 if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
3504 path_str = g_strdup_printf("%d", indx);
3505 model = gtk_tree_view_get_model(if_cb);
3506 gtk_tree_model_get_iter_from_string(model, &iter, path_str);
3507 g_array_append_val(global_capture_opts.all_ifaces, device);
3508 gtk_list_store_append (GTK_LIST_STORE(model), &iter);
3509 #if defined(HAVE_PCAP_CREATE)
3510 gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, MONITOR, device.monitor_mode_supported?(device.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, device.cfilter, -1);
3511 #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
3512 gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
3513 #else
3514 gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, "", PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
3515 #endif
3516 if (global_capture_opts.num_selected > 0) {
3517 gtk_widget_set_sensitive(ok_bt, TRUE);
3518 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
3519 gtk_widget_set_sensitive(all_compile_bt, TRUE);
3520 #endif
3521 } else {
3522 gtk_widget_set_sensitive(ok_bt, FALSE);
3523 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
3524 gtk_widget_set_sensitive(all_compile_bt, FALSE);
3525 #endif
3526 }
3527
3528 /* Refresh all places that are displaying an interface list
3529 that includes interfaces other than local interfaces
3530 (such as pipes). */
3531 refresh_non_local_interface_lists();
3532
3533 g_free(name);
3534 }
3535 }
3536
3537 static void
3538 pipe_new_bt_clicked_cb(GtkWidget *w _U_, gpointer data _U_)
3539 {
3540 GtkWidget *name_te = (GtkWidget *)g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY);
3541 GtkTreeView *pipe_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_L_KEY));
3542 GtkListStore *store;
3543 GtkTreeIter iter;
3544
3545 /* Add a new entry to the pipe list. */
3546
3547 store = GTK_LIST_STORE(gtk_tree_view_get_model(pipe_l));
3548 gtk_list_store_append(store, &iter);
3549
3550 gtk_list_store_set(store, &iter, 0, "New pipe", -1);
3551 pipe_name = "New pipe";
3552
3553 /* Select the item. */
3554 gtk_tree_selection_select_iter(gtk_tree_view_get_selection(pipe_l), &iter);
3555
3556 gtk_editable_select_region(GTK_EDITABLE(name_te), 0, -1);
3557
3558 gtk_widget_grab_focus(name_te);
3559 }
3560
3561 static void
3562 pipe_del_bt_clicked_cb(GtkWidget *w _U_, gpointer data _U_)
3563 {
3564 GtkWidget *pipe_l = (GtkWidget *)g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_L_KEY);
3565 GtkWidget *name_te = (GtkWidget *)g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY);
3566 GtkTreeSelection *sel;
3567 GtkTreeModel *model, *optmodel;
3568 GtkTreeIter iter, optiter;
3569 GtkTreeView *if_cb;
3570 gchar *name, *optname = NULL;
3571 guint i;
3572
3573 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(pipe_l));
3574 /* If something was selected */
3575
3576 if (gtk_tree_selection_get_selected(sel, &model, &iter)) {
3577 gtk_tree_model_get(model, &iter, 0, &name, -1);
3578 if (name != NULL && atoi(gtk_tree_model_get_string_from_iter(model, &iter)) < (gint)global_capture_opts.all_ifaces->len) {
3579 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
3580 if (strcmp(g_array_index(global_capture_opts.all_ifaces, interface_t, i).name, name) == 0) {
3581 g_array_remove_index(global_capture_opts.all_ifaces, i);
3582 break;
3583 }
3584 }
3585 gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
3586 gtk_entry_set_text(GTK_ENTRY(name_te), "");
3587 if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
3588 optmodel = gtk_tree_view_get_model(if_cb);
3589 if (gtk_tree_model_get_iter_first (optmodel, &optiter)) {
3590 do {
3591 gtk_tree_model_get(optmodel, &optiter, IFACE_HIDDEN_NAME, &optname, -1);
3592 if (optname != NULL && strcmp(optname, name) == 0) {
3593 gtk_list_store_remove(GTK_LIST_STORE(gtk_tree_view_get_model(if_cb)), &optiter);
3594 break;
3595 }
3596 } while (gtk_tree_model_iter_next(optmodel, &optiter));
3597 g_free(optname);
3598 }
3599 }
3600 g_free(name);
3601 }
3602
3603 if (gtk_tree_model_get_iter_first (model, &iter)) {
3604 gtk_tree_selection_select_iter(sel, &iter);
3605 } else {
3606 gtk_widget_set_sensitive(name_te, FALSE);
3607 }
3608
3609 /* Refresh all places that are displaying an interface list
3610 that includes interfaces other than local interfaces
3611 (such as pipes). */
3612 refresh_non_local_interface_lists();
3613 }
3614
3615 static void
3616 pipe_name_te_changed_cb(GtkWidget *w _U_, gpointer data _U_)
3617 {
3618 GtkWidget *name_te = (GtkWidget *)g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY);
3619 GtkWidget *pipe_l = (GtkWidget *)g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_L_KEY);
3620 const gchar *name;
3621 GtkTreeSelection *sel;
3622 GtkTreeModel *model;
3623 GtkTreeIter iter;
3624
3625 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(pipe_l));
3626 name = gtk_entry_get_text(GTK_ENTRY(name_te));
3627
3628 /* if something was selected */
3629 if (gtk_tree_selection_get_selected(sel, &model, &iter)) {
3630 gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, name, -1);
3631 }
3632 }
3633
3634 static void
3635 fill_pipe_list(void)
3636 {
3637 guint i;
3638 interface_t device;
3639 GtkTreeIter iter;
3640 GtkTreeView *pipe_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_L_KEY));
3641 GtkListStore *store = GTK_LIST_STORE(gtk_tree_view_get_model(pipe_l));
3642
3643 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
3644 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
3645 if (device.type == IF_PIPE) {
3646 gtk_list_store_append(store, &iter);
3647 gtk_list_store_set(store, &iter, 0, device.name, -1);
3648 } else {
3649 continue;
3650 }
3651 }
3652 }
3653
3654 static void
3655 pipe_sel_list_cb(GtkTreeSelection *sel, gpointer data _U_)
3656 {
3657 /* GtkWidget *pipe_l = GTK_WIDGET(gtk_tree_selection_get_tree_view(sel));*/
3658 GtkTreeModel *model;
3659 GtkTreeIter iter;
3660 GtkWidget *name_te = (GtkWidget *)g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY);
3661 GtkWidget *del_bt = (GtkWidget *)g_object_get_data(G_OBJECT(interface_management_w), E_CAP_PIPE_DEL_KEY);
3662 gchar *name = NULL;
3663
3664 if (gtk_tree_selection_get_selected(sel, &model, &iter)) {
3665 gtk_tree_model_get(model, &iter, 0, &name, -1);
3666 if (name) {
3667 if (name_te != NULL) {
3668 gtk_entry_set_text(GTK_ENTRY(name_te), name ? name : "");
3669 gtk_widget_set_sensitive(name_te, TRUE);
3670 selected_name = gtk_entry_get_text(GTK_ENTRY(name_te));
3671 pipe_name = g_strdup(selected_name);
3672 }
3673 if (del_bt != NULL) {
3674 gtk_widget_set_sensitive(del_bt, TRUE);
3675 }
3676 g_free(name);
3677 }
3678 }
3679 }
3680
3681 static void
3682 cancel_pipe_cb (gpointer w _U_)
3683 {
3684 window_destroy(GTK_WIDGET(interface_management_w));
3685 }
3686
3687 static void
3688 fill_local_list(void)
3689 {
3690 guint i;
3691 interface_t device;
3692 GtkTreeIter iter;
3693 GtkListStore *store;
3694 GtkTreeView *local_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_LOCAL_L_KEY));
3695
3696 #ifdef _WIN32
3697 store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
3698 #else
3699 store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
3700 #endif
3701
3702 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
3703 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
3704 if (device.local && device.type != IF_PIPE && device.type != IF_STDIN) {
3705 gtk_list_store_append(store, &iter);
3706
3707 #ifdef _WIN32
3708 gtk_list_store_set(store, &iter, 0, device.friendly_name, 1, device.name, 2, device.hidden, -1);
3709 #else
3710 gtk_list_store_set(store, &iter, 0, device.name, 1, device.hidden, -1);
3711 #endif
3712 } else {
3713 continue;
3714 }
3715 }
3716 gtk_tree_view_set_model(GTK_TREE_VIEW(local_l), GTK_TREE_MODEL(store));
3717 }
3718
3719 static void local_hide_cb(GtkCellRendererToggle *cell _U_,
3720 gchar *path_str,
3721 gpointer data _U_)
3722 {
3723 gboolean hide, hide_enabled = TRUE;
3724 gchar *name;
3725 GtkTreeModel *model;
3726 GtkTreeIter iter;
3727 GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
3728 GtkTreeView *local_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_LOCAL_L_KEY));
3729
3730 model = gtk_tree_view_get_model(local_l);
3731 gtk_tree_model_get_iter (model, &iter, path);
3732 gtk_tree_model_get (model, &iter, 0+LOCAL_OFFSET, &name, 1+LOCAL_OFFSET, &hide, -1);
3733
3734 /* See if this is the currently selected capturing device */
3735 if ((prefs.capture_device != NULL) && (*prefs.capture_device != '\0')) {
3736 guint i;
3737 interface_t device;
3738 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
3739 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
3740 if ((strcmp(device.display_name, prefs.capture_device) == 0) &&
3741 (strcmp(device.name, name) == 0)) {
3742 /* Don't allow current interface to be hidden */
3743 hide_enabled = FALSE;
3744 break;
3745 }
3746 }
3747 }
3748
3749 if (hide_enabled) {
3750 if (hide) {
3751 gtk_list_store_set(GTK_LIST_STORE(model), &iter, 1+LOCAL_OFFSET, FALSE, -1);
3752 } else {
3753 gtk_list_store_set(GTK_LIST_STORE(model), &iter, 1+LOCAL_OFFSET, TRUE, -1);
3754 }
3755 } else {
3756 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Default interface cannot be hidden");
3757 }
3758 }
3759
3760 static void
3761 apply_local_cb(GtkWidget *win _U_, gpointer *data _U_)
3762 {
3763 GtkTreeIter iter;
3764 GtkTreeModel *model;
3765 gchar *name, *new_hide;
3766 gboolean hide;
3767 gint first_if = TRUE;
3768 GtkTreeView *local_l;
3769
3770 if (global_capture_opts.all_ifaces->len > 0) {
3771 local_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_LOCAL_L_KEY));
3772 model = gtk_tree_view_get_model(local_l);
3773
3774 new_hide = (gchar*)g_malloc0(MAX_VAL_LEN);
3775
3776 if (gtk_tree_model_get_iter_first (model, &iter)) {
3777 do {
3778 gtk_tree_model_get(model, &iter, 0+LOCAL_OFFSET, &name, 1+LOCAL_OFFSET, &hide, -1);
3779 if (!hide) {
3780 continue;
3781 } else {
3782 if (first_if != TRUE) {
3783 g_strlcat (new_hide, ",", MAX_VAL_LEN);
3784 }
3785 g_strlcat (new_hide, name, MAX_VAL_LEN);
3786 first_if = FALSE;
3787 }
3788 } while (gtk_tree_model_iter_next(model, &iter));
3789 g_free(name);
3790 }
3791 /* write new "hidden" string to preferences */
3792 g_free(prefs.capture_devices_hide);
3793 prefs.capture_devices_hide = new_hide;
3794 hide_interface(g_strdup(new_hide));
3795
3796 /* Refresh all places that are displaying an interface list
3797 that includes local interfaces. */
3798 refresh_local_interface_lists();
3799
3800 /* save changes to the preferences file */
3801 if (!prefs.gui_use_pref_save) {
3802 prefs_main_write();
3803 }
3804 }
3805 }
3806
3807 void
3808 capture_dlg_refresh_if (void)
3809 {
3810 GtkTreeView *view;
3811
3812 if (interface_management_w)
3813 fill_local_list();
3814
3815 view = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
3816 create_and_fill_model(GTK_TREE_VIEW(view));
3817 update_properties_all();
3818 }
3819
3820 static void
3821 rescan_local_cb(GtkWidget *button _U_, gpointer *data _U_)
3822 {
3823 /* Refresh all places that are displaying an interface list
3824 that includes local interfaces. */
3825 refresh_local_interface_lists();
3826 }
3827
3828 #if defined(HAVE_PCAP_REMOTE)
3829 static void
3830 fill_remote_list(void)
3831 {
3832 guint i;
3833 interface_t device;
3834 GtkTreeIter iter, child;
3835 gchar *host = "";
3836 GtkTreeView *remote_l;
3837 GtkTreeStore *store;
3838 GtkWidget *host_te, *remote_w;
3839
3840 num_selected = 0;
3841 gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(interface_management_w), E_REMOTE_DEL_BT_KEY), FALSE);
3842 remote_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_L_KEY));
3843 store = gtk_tree_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING);
3844 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
3845 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
3846 if (device.local) {
3847 continue;
3848 } else {
3849 /* fill the store */
3850 if (strcmp(host, device.remote_opts.remote_host_opts.remote_host) != 0) {
3851 remote_w = g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY);
3852 host_te = (GtkWidget *)g_object_get_data(G_OBJECT(remote_w), E_REMOTE_HOST_TE_KEY);
3853 iftype_combo_box_add (host_te, &device);
3854 host = g_strdup(device.remote_opts.remote_host_opts.remote_host);
3855 gtk_tree_store_append(store, &iter, NULL);
3856 gtk_tree_store_set(store, &iter, 0, host, 3, "FALSE", -1);
3857 gtk_tree_store_append(store, &child, &iter);
3858 gtk_tree_store_set(store, &child, 1, device.name, 2, device.hidden, 3, "TRUE", -1);
3859 } else {
3860 gtk_tree_store_append(store, &child, &iter);
3861 gtk_tree_store_set(store, &child, 1, device.name, 2, device.hidden, 3, "TRUE", -1);
3862 }
3863 }
3864 }
3865 gtk_tree_view_set_model(GTK_TREE_VIEW(remote_l), GTK_TREE_MODEL(store));
3866 gtk_tree_view_expand_all(GTK_TREE_VIEW(remote_l));
3867 }
3868
3869 static void
3870 button_hide_cb(GtkTreeViewColumn *column, GtkCellRenderer *renderer,
3871 GtkTreeModel *model, GtkTreeIter *iter, gpointer data _U_)
3872 {
3873 gchar *enabled;
3874
3875 gtk_tree_model_get(model, iter, 3, &enabled, -1);
3876 if (strcmp(enabled, "TRUE") == 0) {
3877 g_object_set(G_OBJECT(renderer), "visible", TRUE, NULL);
3878 } else if (strcmp(enabled, "FALSE") == 0){
3879 g_object_set(G_OBJECT(renderer), "visible", FALSE, NULL);
3880 }
3881 }
3882
3883 static void remote_hide_cb(GtkCellRendererToggle *cell _U_,
3884 gchar *path_str,
3885 gpointer data _U_)
3886 {
3887 gboolean hide;
3888 GtkTreeModel *model;
3889 GtkTreeIter iter;
3890 GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
3891 GtkTreeView *remote_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_L_KEY));
3892
3893 model = gtk_tree_view_get_model(remote_l);
3894 gtk_tree_model_get_iter (model, &iter, path);
3895 gtk_tree_model_get (model, &iter, 2, &hide, -1);
3896
3897 if (hide) {
3898 gtk_tree_store_set(GTK_TREE_STORE(model), &iter, 2, FALSE, -1);
3899 } else {
3900 gtk_tree_store_set(GTK_TREE_STORE(model), &iter, 2, TRUE, -1);
3901 }
3902 }
3903
3904 static void
3905 ok_remote_cb(GtkWidget *win _U_, gpointer *data _U_)
3906 {
3907 GtkTreeIter iter, child;
3908 GtkTreeModel *model;
3909 gchar *name, *new_hide;
3910 gboolean hide;
3911 gint first_if = TRUE;
3912
3913 GtkTreeView *remote_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_L_KEY));
3914 model = gtk_tree_view_get_model(remote_l);
3915
3916 new_hide = g_malloc0(MAX_VAL_LEN);
3917
3918 if (gtk_tree_model_get_iter_first (model, &iter)) {
3919 do {
3920 gtk_tree_model_get(model, &iter, 1, &name, 2, &hide, -1);
3921 if (!name && gtk_tree_model_iter_children(model, &child, &iter)) {
3922 do {
3923 gtk_tree_model_get(model, &child, 1, &name, 2, &hide, -1);
3924 if (!hide) {
3925 continue;
3926 } else {
3927 if (first_if != TRUE) {
3928 g_strlcat (new_hide, ",", MAX_VAL_LEN);
3929 }
3930 g_strlcat (new_hide, name, MAX_VAL_LEN);
3931 first_if = FALSE;
3932 }
3933 } while (gtk_tree_model_iter_next(model, &child));
3934 }
3935 } while (gtk_tree_model_iter_next(model, &iter));
3936 g_free(name);
3937 }
3938 hide_interface(g_strdup(new_hide));
3939
3940 /* Refresh all places that are displaying an interface list
3941 that includes interfaces other than local interfaces
3942 (such as remote interfaces). */
3943 refresh_non_local_interface_lists();
3944 }
3945
3946 static gboolean
3947 select_host_cb(GtkTreeSelection *selection _U_,
3948 GtkTreeModel *model,
3949 GtkTreePath *path,
3950 gboolean path_currently_selected _U_,
3951 gpointer data _U_)
3952 {
3953 GtkTreeIter iter;
3954
3955 gtk_tree_model_get_iter (model, &iter, path);
3956 if (gtk_tree_model_iter_has_child(model, &iter)) {
3957 num_selected++;
3958 gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(interface_management_w), E_REMOTE_DEL_BT_KEY), TRUE);
3959 return TRUE;
3960 } else {
3961 return FALSE;
3962 }
3963 }
3964
3965 static void
3966 remove_remote_host(GtkWidget *w _U_, gpointer data _U_)
3967 {
3968 GtkTreeIter iter, child;
3969 GtkTreeModel *model;
3970 gchar *host;
3971 gint num_children, i;
3972 interface_t device;
3973 GtkTreeView *remote_l = GTK_TREE_VIEW(g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_L_KEY));
3974 GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(remote_l));
3975
3976 model = gtk_tree_view_get_model(remote_l);
3977 if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
3978 gtk_tree_model_get(model, &iter, 0, &host, -1);
3979 if ((num_children = gtk_tree_model_iter_n_children(model, &iter)) > 0) {
3980 for (i = num_children-1; i >= 0; i--) {
3981 if (gtk_tree_model_iter_nth_child(model, &child, &iter, i)) {
3982 gtk_tree_store_remove(GTK_TREE_STORE(model), &child);
3983 }
3984 }
3985 }
3986 gtk_tree_store_remove(GTK_TREE_STORE(model), &iter);
3987 if (--num_selected == 0) {
3988 gtk_widget_set_sensitive(g_object_get_data(G_OBJECT(interface_management_w), E_REMOTE_DEL_BT_KEY), FALSE);
3989 }
3990 for (i = global_capture_opts.all_ifaces->len-1; i >= 0; i--) {
3991 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
3992 if (device.local) {
3993 continue;
3994 } else {
3995 if (strcmp(host, device.remote_opts.remote_host_opts.remote_host) == 0) {
3996 g_array_remove_index(global_capture_opts.all_ifaces, i);
3997 }
3998 }
3999 }
4000
4001 /* Refresh all places that are displaying an interface list
4002 that includes interfaces other than local interfaces
4003 (such as remote interfaces). */
4004 refresh_non_local_interface_lists();
4005 }
4006 }
4007 #endif
4008
4009 static void
4010 show_add_interfaces_dialog(GtkWidget *bt _U_, GtkWidget *parent_win)
4011 {
4012 GtkWidget *vbox, *top_hb;
4013 GtkWidget *hbox, *bbox, *list_bb, *edit_fr, *pipe_fr, *pipe_sc, *pipe_l, *props_fr, *props_vb;
4014 GtkWidget *main_nb;
4015 GtkWidget *temp_page, *tmp;
4016 GtkWidget *pipe_hb, *pipe_bt, *pipe_lb, *pipe_te, *pipe_vb;
4017 GtkWidget *add_bt, *cancel_bt, *new_bt, *del_bt, *middle_hb;
4018 GtkWidget *local_fr, *local_l, *local_sc, *local_vb;
4019 GtkWidget *apply_bt, *refresh_bt;
4020 GtkCellRenderer *renderer, *toggle_renderer;
4021 GtkTreeViewColumn *column;
4022 GtkTreeSelection *sel;
4023 GtkListStore *store;
4024 #if defined(HAVE_PCAP_REMOTE)
4025 GtkWidget *remote_fr, *remote_l, *remote_sc, *remote_vb;
4026 GtkWidget *delete_bt, *add_but, *ok_but;
4027 GtkWidget *button_hbox, *help_hbox;
4028 GtkTreeSelection *selection;
4029 #endif
4030
4031 interface_management_w = window_new(GTK_WINDOW_TOPLEVEL, "Interface Management");
4032 gtk_window_set_transient_for(GTK_WINDOW(interface_management_w), GTK_WINDOW(parent_win));
4033 gtk_window_set_destroy_with_parent(GTK_WINDOW(interface_management_w), TRUE);
4034
4035 gtk_window_set_default_size(GTK_WINDOW(interface_management_w), 700, 300);
4036
4037 vbox = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
4038 gtk_container_add(GTK_CONTAINER(interface_management_w), vbox);
4039 gtk_container_set_border_width(GTK_CONTAINER(vbox), 12);
4040
4041 main_nb = gtk_notebook_new();
4042 gtk_box_pack_start(GTK_BOX(vbox), main_nb, TRUE, TRUE, 0);
4043
4044 /* --- Pipes --- */
4045 temp_page = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
4046 tmp = gtk_label_new("Pipes");
4047 gtk_widget_show(tmp);
4048 hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
4049 gtk_box_pack_start(GTK_BOX (hbox), tmp, TRUE, TRUE, 0);
4050
4051 gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), temp_page, hbox);
4052
4053 /* Pipe row */
4054 pipe_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 20, FALSE);
4055 gtk_container_set_border_width(GTK_CONTAINER(pipe_hb), 5);
4056 gtk_box_pack_start(GTK_BOX(temp_page), pipe_hb, TRUE, TRUE, 0);
4057
4058 /* Container for each row of widgets */
4059 pipe_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
4060 gtk_container_set_border_width(GTK_CONTAINER(pipe_vb), 0);
4061 gtk_box_pack_start(GTK_BOX (pipe_hb), pipe_vb, TRUE, TRUE, 0);
4062 gtk_widget_show(pipe_vb);
4063
4064 /* Top row: Buttons and pipe list */
4065 top_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE);
4066 gtk_box_pack_start(GTK_BOX (pipe_vb), top_hb, TRUE, TRUE, 0);
4067 gtk_widget_show(top_hb);
4068
4069 edit_fr = gtk_frame_new("");
4070 gtk_box_pack_start(GTK_BOX(top_hb), edit_fr, FALSE, FALSE, 0);
4071 gtk_widget_show(edit_fr);
4072
4073 list_bb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, TRUE);
4074 gtk_container_set_border_width(GTK_CONTAINER(list_bb), 5);
4075 gtk_container_add(GTK_CONTAINER(edit_fr), list_bb);
4076 gtk_widget_show(list_bb);
4077
4078 new_bt = gtk_button_new_from_stock(GTK_STOCK_NEW);
4079 g_signal_connect(new_bt, "clicked", G_CALLBACK(pipe_new_bt_clicked_cb), NULL);
4080 gtk_widget_show(new_bt);
4081 gtk_box_pack_start (GTK_BOX (list_bb), new_bt, FALSE, FALSE, 0);
4082 gtk_widget_set_tooltip_text (new_bt, "Add a new pipe (with default properties)");
4083
4084 del_bt = gtk_button_new_from_stock(GTK_STOCK_DELETE);
4085 g_signal_connect(del_bt, "clicked", G_CALLBACK(pipe_del_bt_clicked_cb), NULL);
4086 gtk_widget_show(del_bt);
4087 gtk_widget_set_sensitive(del_bt, FALSE);
4088 gtk_box_pack_start (GTK_BOX (list_bb), del_bt, FALSE, FALSE, 0);
4089 gtk_widget_set_tooltip_text (del_bt, "Remove the selected pipe from the list");
4090 g_object_set_data(G_OBJECT(interface_management_w), E_CAP_PIPE_DEL_KEY, del_bt);
4091
4092 pipe_fr = gtk_frame_new("Pipes");
4093 gtk_box_pack_start(GTK_BOX(top_hb), pipe_fr, TRUE, TRUE, 0);
4094 gtk_widget_show(pipe_fr);
4095
4096 pipe_sc = scrolled_window_new(NULL, NULL);
4097 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(pipe_sc),
4098 GTK_SHADOW_IN);
4099
4100 gtk_container_set_border_width (GTK_CONTAINER (pipe_sc), 5);
4101 gtk_container_add(GTK_CONTAINER(pipe_fr), pipe_sc);
4102 gtk_widget_show(pipe_sc);
4103
4104 store = gtk_list_store_new(1, G_TYPE_STRING);
4105 pipe_l = tree_view_new(GTK_TREE_MODEL(store));
4106 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(pipe_l), FALSE);
4107
4108 renderer = gtk_cell_renderer_text_new();
4109 column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
4110 gtk_tree_view_column_set_expand(column, TRUE);
4111 gtk_tree_view_column_set_sort_column_id(column, 0);
4112 gtk_tree_view_append_column(GTK_TREE_VIEW(pipe_l), column);
4113
4114 sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(pipe_l));
4115 gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
4116 g_object_set_data(G_OBJECT(interface_management_w), E_CAP_PIPE_L_KEY, pipe_l);
4117 g_signal_connect(sel, "changed", G_CALLBACK(pipe_sel_list_cb), pipe_vb);
4118 gtk_container_add(GTK_CONTAINER(pipe_sc), pipe_l);
4119 gtk_widget_show(pipe_l);
4120
4121 fill_pipe_list();
4122
4123 g_object_unref(G_OBJECT(store));
4124
4125 props_fr = gtk_frame_new("");
4126 gtk_box_pack_start(GTK_BOX(pipe_vb), props_fr, FALSE, FALSE, 0);
4127 gtk_widget_show(props_fr);
4128
4129 props_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
4130 gtk_container_set_border_width(GTK_CONTAINER(props_vb), 5);
4131 gtk_container_add(GTK_CONTAINER(props_fr), props_vb);
4132 gtk_widget_show(props_vb);
4133
4134 middle_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
4135 gtk_box_pack_start(GTK_BOX (props_vb), middle_hb, TRUE, TRUE, 0);
4136 gtk_widget_show(middle_hb);
4137
4138 pipe_lb = gtk_label_new("Pipe:");
4139 gtk_box_pack_start(GTK_BOX(middle_hb), pipe_lb, FALSE, FALSE, 3);
4140 pipe_te = gtk_entry_new();
4141 gtk_widget_set_tooltip_text(GTK_WIDGET(pipe_te),
4142 "Enter the name of the pipe data should be captured from. "
4143 );
4144 gtk_box_pack_start(GTK_BOX(middle_hb), pipe_te, TRUE, TRUE, 3);
4145 gtk_widget_set_sensitive(pipe_te, FALSE);
4146 pipe_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_BROWSE);
4147 gtk_widget_set_tooltip_text(GTK_WIDGET(pipe_bt),
4148 "Select a pipe from which data should be captured, "
4149 "instead of entering the pipe name directly. "
4150 );
4151 gtk_box_pack_start(GTK_BOX(middle_hb), pipe_bt, FALSE, FALSE, 0);
4152 g_signal_connect(pipe_te, "changed", G_CALLBACK(pipe_name_te_changed_cb), NULL);
4153 g_signal_connect(pipe_bt, "clicked", G_CALLBACK(capture_prep_pipe_cb), pipe_te);
4154
4155 bbox = dlg_button_row_new(GTK_STOCK_SAVE, GTK_STOCK_CLOSE, NULL);
4156 gtk_box_pack_start(GTK_BOX(temp_page), bbox, FALSE, FALSE, 5);
4157
4158 add_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_SAVE);
4159 g_signal_connect(add_bt, "clicked", G_CALLBACK(add_pipe_cb), interface_management_w);
4160 gtk_widget_set_tooltip_text(GTK_WIDGET(add_bt), "Add pipe to the list of interfaces.");
4161
4162 cancel_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
4163 g_signal_connect(GTK_WIDGET(cancel_bt), "clicked", G_CALLBACK(cancel_pipe_cb), interface_management_w);
4164 gtk_widget_set_tooltip_text(GTK_WIDGET(cancel_bt), "Cancel and exit dialog.");
4165
4166 gtk_widget_show(bbox);
4167 gtk_widget_show(temp_page);
4168
4169 g_object_set_data(G_OBJECT(interface_management_w), E_CAP_PIPE_TE_KEY, pipe_te);
4170
4171 /* --- Local interfaces --- */
4172 temp_page = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
4173 tmp = gtk_label_new("Local Interfaces");
4174 gtk_widget_show(tmp);
4175 hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
4176 gtk_box_pack_start(GTK_BOX(hbox), tmp, TRUE, TRUE, 0);
4177 gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), temp_page, hbox);
4178
4179 local_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
4180 gtk_container_set_border_width(GTK_CONTAINER(local_vb), 0);
4181 gtk_box_pack_start(GTK_BOX(temp_page), local_vb, TRUE, TRUE, 0);
4182 gtk_widget_show(local_vb);
4183
4184 local_fr = gtk_frame_new("Local Interfaces");
4185 gtk_box_pack_start(GTK_BOX(local_vb), local_fr, TRUE, TRUE, 0);
4186 gtk_widget_show(local_fr);
4187
4188 local_sc = scrolled_window_new(NULL, NULL);
4189 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(local_sc),
4190 GTK_SHADOW_IN);
4191
4192 gtk_container_set_border_width (GTK_CONTAINER (local_sc), 5);
4193 gtk_container_add(GTK_CONTAINER(local_fr), local_sc);
4194 gtk_widget_show(local_sc);
4195
4196 local_l = gtk_tree_view_new();
4197
4198 #ifdef _WIN32
4199 renderer = gtk_cell_renderer_text_new();
4200 column = gtk_tree_view_column_new_with_attributes("Friendly Name", renderer, "text", 0, NULL);
4201 gtk_tree_view_column_set_expand(column, TRUE);
4202 gtk_tree_view_column_set_sort_column_id(column, 0);
4203 gtk_tree_view_append_column(GTK_TREE_VIEW(local_l), column);
4204 #endif
4205
4206 renderer = gtk_cell_renderer_text_new();
4207 column = gtk_tree_view_column_new_with_attributes("Interface Name", renderer, "text", 0+LOCAL_OFFSET, NULL);
4208 gtk_tree_view_column_set_expand(column, TRUE);
4209 gtk_tree_view_column_set_sort_column_id(column, 0+LOCAL_OFFSET);
4210 gtk_tree_view_append_column(GTK_TREE_VIEW(local_l), column);
4211
4212 toggle_renderer = gtk_cell_renderer_toggle_new();
4213 column = gtk_tree_view_column_new_with_attributes("Hide", GTK_CELL_RENDERER(toggle_renderer), "active", 1+LOCAL_OFFSET, NULL);
4214 g_signal_connect (G_OBJECT(toggle_renderer), "toggled", G_CALLBACK (local_hide_cb), NULL);
4215 gtk_tree_view_append_column(GTK_TREE_VIEW(local_l), column);
4216 gtk_cell_renderer_toggle_set_active(GTK_CELL_RENDERER_TOGGLE(toggle_renderer), TRUE);
4217
4218 g_object_set_data(G_OBJECT(interface_management_w), E_CAP_LOCAL_L_KEY, local_l);
4219 gtk_container_add(GTK_CONTAINER(local_sc), local_l);
4220 gtk_widget_show(local_l);
4221
4222 fill_local_list();
4223
4224 bbox = dlg_button_row_new(GTK_STOCK_REFRESH, GTK_STOCK_APPLY, GTK_STOCK_CLOSE, NULL);
4225
4226 gtk_box_pack_start(GTK_BOX(temp_page), bbox, FALSE, FALSE, 5);
4227 refresh_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_REFRESH);
4228 g_signal_connect(refresh_bt, "clicked", G_CALLBACK(rescan_local_cb), NULL);
4229 gtk_widget_set_tooltip_text(GTK_WIDGET(refresh_bt), "Rescan the local interfaces and refresh the list");
4230
4231 cancel_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
4232 g_signal_connect(GTK_WIDGET(cancel_bt), "clicked", G_CALLBACK(cancel_pipe_cb), interface_management_w);
4233 gtk_widget_set_tooltip_text(GTK_WIDGET(cancel_bt), "Cancel and exit dialog.");
4234
4235 apply_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_APPLY);
4236 g_signal_connect(GTK_WIDGET(apply_bt), "clicked", G_CALLBACK(apply_local_cb), NULL);
4237 gtk_widget_set_tooltip_text(GTK_WIDGET(apply_bt), "Apply the changes to the general list of local interfaces");
4238
4239 gtk_widget_show(bbox);
4240 gtk_widget_show(temp_page);
4241
4242
4243 #if defined (HAVE_PCAP_REMOTE)
4244 /* --- remote interfaces --- */
4245 temp_page = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 6, FALSE);
4246 tmp = gtk_label_new("Remote Interfaces");
4247 gtk_widget_show(tmp);
4248 hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
4249 gtk_box_pack_start(GTK_BOX (hbox), tmp, TRUE, TRUE, 0);
4250 gtk_notebook_append_page(GTK_NOTEBOOK(main_nb), temp_page, hbox);
4251
4252 remote_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
4253 gtk_container_set_border_width(GTK_CONTAINER(remote_vb), 0);
4254 gtk_box_pack_start(GTK_BOX(temp_page), remote_vb, TRUE, TRUE, 0);
4255 gtk_widget_show(remote_vb);
4256
4257 remote_fr = gtk_frame_new("Remote Interfaces");
4258 gtk_box_pack_start(GTK_BOX(remote_vb), remote_fr, TRUE, TRUE, 0);
4259 gtk_widget_show(remote_fr);
4260
4261 remote_sc = scrolled_window_new(NULL, NULL);
4262 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(remote_sc),
4263 GTK_SHADOW_IN);
4264
4265 gtk_container_set_border_width (GTK_CONTAINER (remote_sc), 5);
4266 gtk_container_add(GTK_CONTAINER(remote_fr), remote_sc);
4267 gtk_widget_show(remote_sc);
4268
4269 remote_l = gtk_tree_view_new();
4270
4271 renderer = gtk_cell_renderer_text_new();
4272 column = gtk_tree_view_column_new_with_attributes("Host", renderer, "text", 0, NULL);
4273 gtk_tree_view_column_set_expand(column, TRUE);
4274 gtk_tree_view_column_set_sort_column_id(column, 0);
4275 gtk_tree_view_append_column(GTK_TREE_VIEW(remote_l), column);
4276
4277 renderer = gtk_cell_renderer_text_new();
4278 column = gtk_tree_view_column_new_with_attributes("Name", renderer, "text", 1, NULL);
4279 gtk_tree_view_column_set_expand(column, TRUE);
4280 gtk_tree_view_column_set_sort_column_id(column, 1);
4281 gtk_tree_view_append_column(GTK_TREE_VIEW(remote_l), column);
4282
4283 toggle_renderer = gtk_cell_renderer_toggle_new();
4284 column = gtk_tree_view_column_new_with_attributes("Hide", GTK_CELL_RENDERER(toggle_renderer), "active", 2, NULL);
4285 g_signal_connect (G_OBJECT(toggle_renderer), "toggled", G_CALLBACK (remote_hide_cb), NULL);
4286 gtk_tree_view_column_set_cell_data_func(column, toggle_renderer, button_hide_cb, NULL, FALSE);
4287 gtk_tree_view_append_column(GTK_TREE_VIEW(remote_l), column);
4288 gtk_cell_renderer_toggle_set_active(GTK_CELL_RENDERER_TOGGLE(toggle_renderer), TRUE);
4289
4290 renderer = gtk_cell_renderer_text_new();
4291 column = gtk_tree_view_column_new_with_attributes("Control", renderer, "text", 3, NULL);
4292 gtk_tree_view_column_set_visible(column, FALSE);
4293 gtk_tree_view_append_column(GTK_TREE_VIEW(remote_l), column);
4294
4295 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(remote_l));
4296 gtk_tree_selection_set_select_function(selection, select_host_cb, NULL, FALSE);
4297
4298 g_object_set_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_L_KEY, remote_l);
4299 gtk_container_add(GTK_CONTAINER(remote_sc), remote_l);
4300 gtk_widget_show(remote_l);
4301
4302 fill_remote_list();
4303
4304 bbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE);
4305 gtk_box_pack_start(GTK_BOX(temp_page), bbox, FALSE, FALSE, 5);
4306 gtk_widget_show(bbox);
4307
4308 button_hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
4309 gtk_box_pack_end(GTK_BOX(bbox), button_hbox, FALSE, FALSE, 0);
4310 gtk_widget_show(button_hbox);
4311 gtk_box_set_spacing(GTK_BOX(button_hbox), DLG_BUTTON_SPACING);
4312
4313 help_hbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
4314 gtk_box_pack_start(GTK_BOX(bbox), help_hbox, FALSE, FALSE, 0);
4315 gtk_widget_show(help_hbox);
4316 gtk_box_set_spacing(GTK_BOX(help_hbox), DLG_BUTTON_SPACING);
4317
4318 add_but = gtk_button_new_from_stock(GTK_STOCK_ADD);
4319 g_object_set_data(G_OBJECT(bbox), GTK_STOCK_ADD, add_but);
4320 gtk_box_pack_start(GTK_BOX(help_hbox), add_but, FALSE, FALSE, 0);
4321 g_signal_connect(add_but, "clicked", G_CALLBACK(show_remote_dialog), NULL);
4322 gtk_widget_set_tooltip_text(GTK_WIDGET(add_but), "Add a remote host to the list");
4323 gtk_widget_show(add_but);
4324
4325 delete_bt = gtk_button_new_from_stock(GTK_STOCK_DELETE);
4326 g_object_set_data(G_OBJECT(bbox), GTK_STOCK_DELETE, delete_bt);
4327 gtk_box_pack_start(GTK_BOX(help_hbox), delete_bt, FALSE, FALSE, 0);
4328 g_signal_connect(delete_bt, "clicked", G_CALLBACK(remove_remote_host), NULL);
4329 gtk_widget_set_tooltip_text(GTK_WIDGET(delete_bt), "Remove a remote host from the list");
4330 gtk_widget_set_sensitive(GTK_WIDGET(delete_bt), FALSE);
4331 g_object_set_data(G_OBJECT(interface_management_w), E_REMOTE_DEL_BT_KEY, delete_bt);
4332 gtk_widget_show(delete_bt);
4333
4334 ok_but = gtk_button_new_from_stock(GTK_STOCK_APPLY);
4335 gtk_box_pack_end(GTK_BOX(button_hbox), ok_but, FALSE, FALSE, 0);
4336 g_signal_connect(GTK_WIDGET(ok_but), "clicked", G_CALLBACK(ok_remote_cb), NULL);
4337 gtk_widget_set_tooltip_text(GTK_WIDGET(ok_but), "Apply the changes to the general list of local interfaces");
4338 gtk_widget_show(ok_but);
4339
4340 cancel_bt = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
4341 gtk_box_pack_end(GTK_BOX(button_hbox), cancel_bt, FALSE, FALSE, 0);
4342 g_signal_connect(GTK_WIDGET(cancel_bt), "clicked", G_CALLBACK(cancel_pipe_cb), interface_management_w);
4343 gtk_widget_set_tooltip_text(GTK_WIDGET(cancel_bt), "Cancel and exit dialog.");
4344 gtk_widget_show(cancel_bt);
4345
4346 gtk_widget_show(temp_page);
4347
4348 #endif
4349 gtk_widget_show_all(interface_management_w);
4350 }
4351
4352 /* show capture prepare (options) dialog */
4353
4354 /* XXX: Warning:
4355 Note that capture_interface_list() is called directly (or indirectly) during the
4356 creation of (and changes to) the capture options dialog window.
4357
4358 Also note that capture_interface_list() indirectly runs the gtk main loop temporarily
4359 to process queued events (which may include button-presses, key-presses, etc).
4360 (This is done while awaiting a response from dumpcap which is invoked to obtain
4361 the capture interface list).
4362 This means other Wireshark callbacks can be invoked while the capture options window
4363 is being created or updated (in effect an "interrupt" can occur).
4364
4365 Needless to say, "race conditions" may occur in "interrupt" code which depends upon the exact
4366 state of the capture options dialog window and which may be invoked during the
4367 creation of (or changes to) the capture options dialog window.
4368
4369 For example: if a user hits "Capture:Options" and then immediately hits "Capture:Start",
4370 capture_start_cb() may be invoked before capture_prep_cb() has been completed (i.e., during
4371 a call to capture_interface_list() in the code which creates the capture options window).
4372 capture_start_cb() depends upon certain properties of the capture options window having been
4373 initialized and thus fails if the properties have not (yet) been initialized.
4374
4375 An interlock has been added to handle this particular situation;
4376 Ideally a more general solution should be implemented since it's probably difficult
4377 (if not nearly impossible) to identify all the possible "race conditions".
4378
4379 ? Prevent the temporary running of the gtk main loop in cases wherein dumpcap is invoked for a
4380 simple request/reply ? (e.g., capture_interface_list()) ??
4381
4382 ? Other ??
4383 */
4384
4385 static gboolean
4386 columns_menu_handler(GtkWidget *widget, GdkEvent *event, gpointer data)
4387 {
4388 GtkWidget *menu = (GtkWidget *)data;
4389 GdkEventButton *event_button = NULL;
4390
4391 /* context menu handler */
4392 if (event->type == GDK_BUTTON_PRESS) {
4393 event_button = (GdkEventButton *) event;
4394
4395 /* To quote the "Gdk Event Structures" doc:
4396 * "Normally button 1 is the left mouse button, 2 is the middle button, and 3 is the right button" */
4397 if (event_button->button == 3) {
4398 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, widget,
4399 event_button->button,
4400 event_button->time);
4401 g_signal_stop_emission_by_name(widget, "button_press_event");
4402 return TRUE;
4403 }
4404 }
4405 return FALSE;
4406 }
4407
4408 static void
4409 update_properties_all(void)
4410 {
4411 unsigned int i;
4412 interface_t device;
4413 gboolean capture_all;
4414 gboolean promisc_all;
4415 gboolean filter_all;
4416 gchar * filter_str;
4417 GtkWidget *promisc_b;
4418 GtkWidget *capture_b;
4419 GtkWidget *all_filter_te;
4420
4421 /* If we don't have a Capture Options dialog open, there's nothing
4422 for us to do. */
4423 if (cap_open_w == NULL)
4424 return;
4425
4426 /* Determine whether all interfaces:
4427
4428 are selected for capturing;
4429
4430 all selected interfaces are in promiscuous mode;
4431
4432 all selected interfaces have the same capture filter.
4433
4434 Start out by assuming that all three are the case, and change that
4435 once we find an interface where it's not the case. */
4436 capture_all = TRUE;
4437 promisc_all = TRUE;
4438 filter_all = TRUE;
4439 filter_str = NULL;
4440 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
4441 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
4442 if (!device.hidden) {
4443 if (!device.selected) {
4444 /* This interface isn't selected, so not all interfaces are selected. */
4445 capture_all = FALSE;
4446 } else {
4447 /* This interface is selected; is it in promiscuous mode? */
4448 if (!device.pmode) {
4449 /* No, so not all selected interfaces are in promiscuous mode. */
4450 promisc_all = FALSE;
4451 }
4452 /* Have we seen the same capture filter on all interfaces at
4453 which we've looked so far? */
4454 if (device.cfilter != NULL && filter_all) {
4455 /* Yes. Is this the first interface for which we've seen a
4456 filter? */
4457 if (filter_str == NULL) {
4458 /* First selected interface - save its capture filter;
4459 there aren't any filters against which to compare. */
4460 filter_str = g_strdup(device.cfilter);
4461 } else {
4462 /* Not the first selected interface; is its capture filter
4463 the same as the one the other interfaces we've looked
4464 at have? */
4465 if (strcmp(device.cfilter, filter_str) != 0) {
4466 /* No, so not all selected interfaces have the same capture
4467 filter. */
4468 if (filter_str != NULL) {
4469 g_free(filter_str);
4470 }
4471 filter_str = NULL;
4472 filter_all = FALSE;
4473 }
4474 }
4475 }
4476 }
4477 }
4478 }
4479
4480 /* If all interfaces are selected, check the "capture on all interfaces"
4481 checkbox, otherwise un-check it. */
4482 if (capture_all) {
4483 capture_b = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_CAP_KEY_ALL);
4484 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(capture_b), TRUE);
4485 }
4486
4487 /* If all selected interfaces are in promiscuous mode, check the global
4488 "promiscuous mode" checkbox, otherwise un-check it. */
4489 promisc_b = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_CAP_PROMISC_KEY_ALL);
4490 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_b), promisc_all);
4491
4492 /* If all selected interfaces have the same filter string, set the
4493 global filter string to it. */
4494 all_filter_te = gtk_bin_get_child(GTK_BIN(g_object_get_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY)));
4495 if (filter_all) {
4496 /* Either no interfaces were selected, or all selected interfaces
4497 have the same filter. In the former case, make the global capture
4498 filter empty; in the latter case, make it that filter. */
4499 if (filter_str != NULL) {
4500 gtk_entry_set_text(GTK_ENTRY(all_filter_te), filter_str);
4501 g_free(filter_str);
4502 } else {
4503 gtk_entry_set_text(GTK_ENTRY(all_filter_te), "");
4504 }
4505 } else {
4506 /* Not all selected interfaces have the same filter, so there is no
4507 global capture filter; make it empty to reflect that. */
4508 gtk_entry_set_text(GTK_ENTRY(all_filter_te), "");
4509 }
4510 }
4511
4512
4513 static gboolean
4514 column_button_pressed_cb (GtkWidget *widget, GdkEvent *event, gpointer data)
4515 {
4516 GtkWidget *col = (GtkWidget *) data;
4517 GtkTreeView *view;
4518 GtkWidget *menu = (GtkWidget *)g_object_get_data(G_OBJECT(columns_menu_object), PM_COLUMNS_KEY);
4519
4520 view = (GtkTreeView *)g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
4521 g_object_set_data(G_OBJECT(view), E_MCAPTURE_COLUMNS_COLUMN_KEY, col);
4522 return columns_menu_handler (widget, event, menu);
4523 }
4524
4525
4526 void
4527 capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
4528 {
4529 GtkWidget *main_vb,
4530 *main_hb, *left_vb, *right_vb,
4531 *capture_fr, *capture_vb,
4532 *all_hb, *all_cb,
4533 *promisc_cb, *pcap_ng_cb,
4534 *file_fr, *file_vb,
4535 *file_hb, *file_bt, *file_lb, *file_te,
4536 *multi_hb, *multi_grid, *multi_files_on_cb,
4537 *ring_filesize_cb, *ring_filesize_sb, *ring_filesize_cbx,
4538 *file_duration_cb, *file_duration_sb, *file_duration_cbx,
4539 *ringbuffer_nbf_cb, *ringbuffer_nbf_sb, *ringbuffer_nbf_lb,
4540 *stop_files_cb, *stop_files_sb, *stop_files_lb,
4541 *limit_fr, *limit_vb, *limit_hb, *limit_grid,
4542 *stop_packets_cb, *stop_packets_sb, *stop_packets_lb,
4543 *stop_filesize_cb, *stop_filesize_sb, *stop_filesize_cbx,
4544 *stop_duration_cb, *stop_duration_sb, *stop_duration_cbx,
4545 *display_fr, *display_vb,
4546 *sync_cb, *auto_scroll_cb, *hide_info_cb,
4547 *resolv_fr, *resolv_vb,
4548 *m_resolv_cb, *n_resolv_cb, *t_resolv_cb, *e_resolv_cb,
4549 *bbox, *close_bt,
4550 *all_filter_cm, *all_filter_te, *all_filter_bt, *all_filter_hb,
4551 *all_vb,
4552 *help_bt;
4553 #ifdef HAVE_AIRPCAP
4554 GtkWidget *decryption_cb;
4555 int err;
4556 gchar *err_str;
4557 #endif
4558 GtkWidget *iftype_cbx;
4559
4560 GtkAdjustment *ringbuffer_nbf_adj,
4561 *stop_packets_adj, *stop_filesize_adj, *stop_duration_adj, *stop_files_adj,
4562 *ring_filesize_adj, *file_duration_adj;
4563 int row;
4564 guint32 value;
4565 gchar *cap_title;
4566 GtkWidget *view;
4567 GtkWidget *swindow;
4568 GtkCellRenderer *renderer;
4569 GtkCellRenderer *toggle_renderer;
4570 GtkTreeSelection *selection;
4571 GtkTreeViewColumn *column;
4572 gboolean if_present = TRUE;
4573 GList *all_cfilter_list, *cf_entry;
4574 window_geometry_t tl_geom;
4575 const gchar *new_cfilter;
4576
4577 if (interfaces_dialog_window_present()) {
4578 destroy_if_window();
4579 }
4580 if (cap_open_w != NULL) {
4581 /* There's already a "Capture Options" dialog box; reactivate it. */
4582 reactivate_window(cap_open_w);
4583 return;
4584 }
4585 init_columns_menu();
4586
4587 /* use user-defined title if preference is set */
4588
4589 cap_title = create_user_window_title("Wireshark: Capture Options");
4590
4591 cap_open_complete = FALSE;
4592 cap_open_w = dlg_window_new(cap_title);
4593 g_free(cap_title);
4594
4595 #ifdef HAVE_AIRPCAP
4596 /* update airpcap interface list */
4597
4598 /* load the airpcap interfaces */
4599 airpcap_if_list = get_airpcap_interface_list(&err, &err_str);
4600
4601 /* If we don't get a list don't do any thing.
4602 * If the error is AIRPCAP_NOT_LOADED it avoids a unneccessay rescan of the packet list
4603 * ( see airpcap_loader.h for error codes).
4604 */
4605 if (airpcap_if_list == NULL) {
4606 if (err == CANT_GET_AIRPCAP_INTERFACE_LIST) {
4607 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
4608 g_free(err_str);
4609 }
4610 }else{
4611 decryption_cb = (GtkWidget *)g_object_get_data(G_OBJECT(wireless_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY);
4612 /* XXXX update_decryption_mode_list() trigers a rescan, should only be done if the mode is changed */
4613 update_decryption_mode_list(decryption_cb);
4614 /* select the first as default (THIS SHOULD BE CHANGED) */
4615 airpcap_if_active = airpcap_get_default_if(airpcap_if_list);
4616 }
4617 #endif
4618
4619 main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
4620 gtk_container_set_border_width(GTK_CONTAINER(main_vb), DLG_OUTER_MARGIN);
4621 gtk_container_add(GTK_CONTAINER(cap_open_w), main_vb);
4622
4623 /* Capture-related options frame */
4624 capture_fr = frame_new("Capture");
4625 gtk_box_pack_start(GTK_BOX (main_vb), capture_fr, TRUE, TRUE, 0);
4626
4627 capture_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_UNRELATED_SPACING, FALSE);
4628 gtk_container_set_border_width(GTK_CONTAINER(capture_vb), DLG_OUTER_MARGIN);
4629 gtk_container_add(GTK_CONTAINER(capture_fr), capture_vb);
4630
4631 #if defined (HAVE_PCAP_REMOTE)
4632 if (remote_host_list == NULL) {
4633 remote_host_list = g_hash_table_new (g_str_hash, g_str_equal);
4634 }
4635 #endif
4636
4637 swindow = gtk_scrolled_window_new (NULL, NULL);
4638 gtk_widget_set_size_request(swindow, 676, 180);
4639 gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swindow), GTK_SHADOW_IN);
4640
4641 view = gtk_tree_view_new ();
4642 gtk_tree_view_set_rules_hint(GTK_TREE_VIEW (view), TRUE);
4643 g_signal_connect(view, "row-activated", G_CALLBACK(options_interface_cb), (gpointer)cap_open_w);
4644
4645 toggle_renderer = gtk_cell_renderer_toggle_new();
4646 column = gtk_tree_view_column_new_with_attributes("Capture", GTK_CELL_RENDERER(toggle_renderer), "active", CAPTURE, NULL);
4647 gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
4648 g_signal_connect (G_OBJECT(toggle_renderer), "toggled", G_CALLBACK (toggle_callback), NULL);
4649 g_object_set (GTK_TREE_VIEW(view), "has-tooltip", TRUE, NULL);
4650 g_signal_connect (GTK_TREE_VIEW(view), "query-tooltip", G_CALLBACK (query_tooltip_tree_view_cb), NULL);
4651
4652 renderer = gtk_cell_renderer_text_new();
4653 column = gtk_tree_view_column_new_with_attributes ("",
4654 GTK_CELL_RENDERER(renderer),
4655 "text", IFACE_HIDDEN_NAME,
4656 NULL);
4657 gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
4658 gtk_tree_view_column_set_visible(column, FALSE);
4659
4660 renderer = gtk_cell_renderer_text_new ();
4661 gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (view), -1, "Interface", renderer, "markup", INTERFACE, NULL);
4662 column = gtk_tree_view_get_column(GTK_TREE_VIEW (view), INTERFACE);
4663 gtk_tree_view_column_set_min_width(column, 200);
4664 gtk_tree_view_column_set_resizable(column, TRUE );
4665 gtk_tree_view_column_set_alignment(column, 0.5f);
4666 g_object_set_data(G_OBJECT(column), E_MCAPTURE_COLUMNS_COL_KEY, GINT_TO_POINTER(INTERFACE));
4667 if (!prefs.capture_columns || prefs_capture_options_dialog_column_is_visible("INTERFACE"))
4668 gtk_tree_view_column_set_visible(column, TRUE);
4669 else
4670 gtk_tree_view_column_set_visible(column, FALSE);
4671 g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
4672
4673 renderer = gtk_cell_renderer_text_new();
4674 column = gtk_tree_view_column_new_with_attributes ("Link-layer header", renderer, "text", LINK, NULL);
4675 gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
4676 gtk_tree_view_column_set_clickable(column, TRUE);
4677 gtk_tree_view_column_set_reorderable(column, TRUE);
4678 gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW (view),LINK), TRUE );
4679 g_object_set_data(G_OBJECT(column), E_MCAPTURE_COLUMNS_COL_KEY, GINT_TO_POINTER(LINK));
4680 g_signal_connect(gtk_tree_view_column_get_button(column), "button_press_event",
4681 G_CALLBACK(column_button_pressed_cb), column);
4682 if (!prefs.capture_columns || prefs_capture_options_dialog_column_is_visible("LINK"))
4683 gtk_tree_view_column_set_visible(column, TRUE);
4684 else
4685 gtk_tree_view_column_set_visible(column, FALSE);
4686 gtk_tree_view_column_set_alignment(column, 0.5f);
4687
4688 renderer = gtk_cell_renderer_text_new();
4689 column = gtk_tree_view_column_new_with_attributes("Prom. Mode", renderer, "text", PMODE, NULL);
4690 gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
4691 g_object_set(renderer, "xalign", 0.5f, NULL);
4692 gtk_tree_view_column_set_clickable(column, TRUE);
4693 gtk_tree_view_column_set_reorderable(column, TRUE);
4694 g_object_set_data(G_OBJECT(column), E_MCAPTURE_COLUMNS_COL_KEY, GINT_TO_POINTER(PMODE));
4695 g_signal_connect(gtk_tree_view_column_get_button(column), "button_press_event",
4696 G_CALLBACK(column_button_pressed_cb), column);
4697 if (!prefs.capture_columns || prefs_capture_options_dialog_column_is_visible("PMODE"))
4698 gtk_tree_view_column_set_visible(column, TRUE);
4699 else
4700 gtk_tree_view_column_set_visible(column, FALSE);
4701 gtk_tree_view_column_set_alignment(column, 0.5f);
4702
4703 renderer = gtk_cell_renderer_text_new();
4704 column = gtk_tree_view_column_new_with_attributes("Snaplen [B]", renderer, "text", SNAPLEN, NULL);
4705 gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
4706 gtk_tree_view_column_set_clickable(column, TRUE);
4707 gtk_tree_view_column_set_reorderable(column, TRUE);
4708 g_object_set_data(G_OBJECT(column), E_MCAPTURE_COLUMNS_COL_KEY, GINT_TO_POINTER(SNAPLEN));
4709 g_signal_connect(gtk_tree_view_column_get_button(column), "button_press_event",
4710 G_CALLBACK(column_button_pressed_cb), column);
4711 if (!prefs.capture_columns || prefs_capture_options_dialog_column_is_visible("SNAPLEN"))
4712 gtk_tree_view_column_set_visible(column, TRUE);
4713 else
4714 gtk_tree_view_column_set_visible(column, FALSE);
4715 g_object_set(renderer, "xalign", 0.5f, NULL);
4716
4717 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
4718 renderer = gtk_cell_renderer_text_new();
4719 column = gtk_tree_view_column_new_with_attributes("Buffer [MB]", renderer, "text", BUFFER, NULL);
4720 gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
4721 gtk_tree_view_column_set_reorderable(column, TRUE);
4722 g_object_set_data(G_OBJECT(column), E_MCAPTURE_COLUMNS_COL_KEY, GINT_TO_POINTER(BUFFER));
4723 gtk_tree_view_column_set_clickable(column, TRUE);
4724 g_signal_connect(gtk_tree_view_column_get_button(column), "button_press_event",
4725 G_CALLBACK(column_button_pressed_cb), column);
4726 if (!prefs.capture_columns || prefs_capture_options_dialog_column_is_visible("BUFFER"))
4727 gtk_tree_view_column_set_visible(column, TRUE);
4728 else
4729 gtk_tree_view_column_set_visible(column, FALSE);
4730 g_object_set(renderer, "xalign", 0.5f, NULL);
4731 #endif
4732
4733 #if defined (HAVE_PCAP_CREATE)
4734 renderer = gtk_cell_renderer_text_new();
4735 column = gtk_tree_view_column_new_with_attributes ("Mon. Mode", renderer, "text", MONITOR, NULL);
4736 gtk_tree_view_column_set_cell_data_func(column, renderer, activate_monitor, NULL, FALSE);
4737 gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
4738 gtk_tree_view_column_set_reorderable(column, TRUE);
4739 g_object_set_data(G_OBJECT(column), E_MCAPTURE_COLUMNS_COL_KEY, GINT_TO_POINTER(MONITOR));
4740 gtk_tree_view_column_set_clickable(column, TRUE);
4741 g_signal_connect(gtk_tree_view_column_get_button(column), "button_press_event",
4742 G_CALLBACK(column_button_pressed_cb), column);
4743 if (!prefs.capture_columns || prefs_capture_options_dialog_column_is_visible("MONITOR"))
4744 gtk_tree_view_column_set_visible(column, TRUE);
4745 else
4746 gtk_tree_view_column_set_visible(column, FALSE);
4747 g_object_set(renderer, "xalign", 0.5f, NULL);
4748 #endif
4749
4750 renderer = gtk_cell_renderer_text_new();
4751 column = gtk_tree_view_column_new_with_attributes("Capture Filter", renderer, "text", FILTER, NULL);
4752 gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
4753 gtk_tree_view_column_set_alignment(column, 0.5f);
4754 create_and_fill_model(GTK_TREE_VIEW(view));
4755 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
4756 gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
4757 gtk_tree_view_column_set_clickable(column, TRUE);
4758 gtk_tree_view_column_set_reorderable(column, TRUE);
4759 g_object_set_data(G_OBJECT(column), E_MCAPTURE_COLUMNS_COL_KEY, GINT_TO_POINTER(FILTER));
4760 g_signal_connect(gtk_tree_view_column_get_button(column), "button_press_event",
4761 G_CALLBACK(column_button_pressed_cb), column);
4762 if (!prefs.capture_columns || prefs_capture_options_dialog_column_is_visible("FILTER"))
4763 gtk_tree_view_column_set_visible(column, TRUE);
4764 else
4765 gtk_tree_view_column_set_visible(column, FALSE);
4766 gtk_container_add (GTK_CONTAINER (swindow), view);
4767 gtk_box_pack_start(GTK_BOX(capture_vb), swindow, TRUE, TRUE, 0);
4768
4769 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY, view);
4770
4771 main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DLG_UNRELATED_SPACING, FALSE);
4772 gtk_container_set_border_width(GTK_CONTAINER(main_hb), 0);
4773 gtk_box_pack_start(GTK_BOX(capture_vb), main_hb, FALSE, FALSE, 0);
4774 all_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
4775 gtk_container_set_border_width(GTK_CONTAINER(all_vb), 0);
4776 gtk_box_pack_start(GTK_BOX(main_hb), all_vb, TRUE, TRUE, 0);
4777
4778 all_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DLG_UNRELATED_SPACING, FALSE);
4779 gtk_container_set_border_width(GTK_CONTAINER(all_hb), 0);
4780 gtk_box_pack_start(GTK_BOX(all_vb), all_hb, TRUE, TRUE, 0);
4781
4782 left_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
4783 gtk_container_set_border_width(GTK_CONTAINER(left_vb), 0);
4784 gtk_box_pack_start(GTK_BOX(all_hb), left_vb, TRUE, TRUE, 0);
4785
4786 right_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 3, FALSE);
4787 gtk_container_set_border_width(GTK_CONTAINER(right_vb), 0);
4788 gtk_box_pack_start(GTK_BOX(all_hb), right_vb, FALSE, FALSE, 3);
4789
4790 all_cb = gtk_check_button_new_with_mnemonic( "Capture on all interfaces");
4791 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(all_cb), FALSE);
4792 g_signal_connect(all_cb, "toggled", G_CALLBACK(capture_all_cb), NULL);
4793 gtk_widget_set_tooltip_text(all_cb, "Activate the box to capture on all interfaces. "
4794 "Deactivate it to capture on none and set the interfaces individually.");
4795 gtk_box_pack_start(GTK_BOX(left_vb), all_cb, TRUE, TRUE, 0);
4796
4797 gtk_widget_set_sensitive(GTK_WIDGET(all_cb), if_present);
4798 /* Promiscuous mode row */
4799 promisc_cb = gtk_check_button_new_with_mnemonic("Use _promiscuous mode on all interfaces");
4800 if (!global_capture_session.session_started) {
4801 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_cb), prefs.capture_prom_mode);
4802 } else {
4803 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_cb), get_all_prom_mode());
4804 }
4805 g_signal_connect(promisc_cb, "button-press-event", G_CALLBACK(promisc_mode_callback), NULL);
4806
4807 gtk_widget_set_tooltip_text(promisc_cb,
4808 "Usually a network adapter will only capture the traffic sent to its own network address. "
4809 "If you want to capture all traffic that all network adapters can \"see\", select this option. "
4810 "If you want to set this option on a per-interface basis, do not select this option. "
4811 "Instead, select the individual checkboxes in the interface list's \"Prom. Mode\" column. "
4812 "See the FAQ for some more details of capturing packets from a switched network.");
4813 gtk_box_pack_start(GTK_BOX(left_vb), promisc_cb, TRUE, TRUE, DLG_LABEL_SPACING);
4814
4815 iftype_cbx = gtk_button_new_with_label("Manage Interfaces");
4816 gtk_widget_set_tooltip_text(iftype_cbx, "Add a new interface or pipe to capture from or remove "
4817 "an interface from the list.");
4818 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_IFTYPE_CBX_KEY, iftype_cbx);
4819
4820 gtk_box_pack_start(GTK_BOX(right_vb), iftype_cbx, FALSE, FALSE, 0);
4821 g_signal_connect(iftype_cbx, "clicked", G_CALLBACK(show_add_interfaces_dialog), cap_open_w);
4822 gtk_widget_show(iftype_cbx);
4823
4824 main_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DLG_UNRELATED_SPACING, FALSE);
4825 gtk_container_set_border_width(GTK_CONTAINER(main_hb), 0);
4826 gtk_box_pack_start(GTK_BOX(main_vb), main_hb, FALSE, FALSE, 0);
4827
4828 left_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
4829 gtk_container_set_border_width(GTK_CONTAINER(left_vb), 0);
4830 gtk_box_pack_start(GTK_BOX(main_hb), left_vb, TRUE, TRUE, 0);
4831
4832 right_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
4833 gtk_container_set_border_width(GTK_CONTAINER(right_vb), 0);
4834 gtk_box_pack_start(GTK_BOX(main_hb), right_vb, FALSE, FALSE, 0);
4835
4836 /* Filter row */
4837 all_filter_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE);
4838 gtk_box_pack_start(GTK_BOX(all_vb), all_filter_hb, FALSE, FALSE, DLG_LABEL_SPACING);
4839
4840 all_filter_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_CAPTURE_FILTER_ENTRY);
4841 g_signal_connect(all_filter_bt, "clicked", G_CALLBACK(capture_filter_construct_cb), NULL);
4842 g_signal_connect(all_filter_bt, "destroy", G_CALLBACK(filter_button_destroy_cb), NULL);
4843 gtk_widget_set_tooltip_text(all_filter_bt,
4844 "Select a capture filter for all selected interfaces to reduce the amount of packets to be captured. "
4845 "See \"Capture Filters\" in the online help for further information how to use it."
4846 );
4847 gtk_box_pack_start(GTK_BOX(all_filter_hb), all_filter_bt, FALSE, FALSE, 0);
4848
4849 /* Create the capture filter combo box*/
4850 all_filter_cm = gtk_combo_box_text_new_with_entry();
4851 g_object_set_data(G_OBJECT(cap_open_w), E_ALL_CFILTER_CM_KEY, all_filter_cm);
4852 all_filter_te = gtk_bin_get_child(GTK_BIN(all_filter_cm));
4853 colorize_filter_te_as_empty(all_filter_te);
4854 g_signal_connect(all_filter_te, "changed", G_CALLBACK(capture_all_filter_check_syntax_cb), NULL);
4855 g_signal_connect(all_filter_te, "destroy", G_CALLBACK(capture_filter_destroy_cb), NULL);
4856
4857 all_cfilter_list = recent_get_cfilter_list(NULL);
4858 for (cf_entry = all_cfilter_list; cf_entry != NULL; cf_entry = g_list_next(cf_entry)) {
4859 new_cfilter = (const gchar *)cf_entry->data;
4860 /* If this is the default cfilter, don't put it in the list, as it'll
4861 be added later. */
4862 if (global_capture_opts.default_options.cfilter == NULL || strcmp(global_capture_opts.default_options.cfilter, new_cfilter) != 0) {
4863 gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(all_filter_cm), new_cfilter);
4864 }
4865 }
4866 if (global_capture_opts.default_options.cfilter && (strlen(global_capture_opts.default_options.cfilter) > 0)) {
4867 fprintf(stderr, "Adding the default filter \"%s\"???\n", global_capture_opts.default_options.cfilter);
4868 gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(all_filter_cm), global_capture_opts.default_options.cfilter);
4869 gtk_combo_box_set_active(GTK_COMBO_BOX(all_filter_cm), 0);
4870 }
4871
4872 gtk_widget_set_tooltip_text(all_filter_cm,
4873 "Enter a capture filter for all selected interfaces to reduce the amount of packets to be captured. "
4874 "See \"Capture Filters\" in the online help for further information how to use it. "
4875 "Syntax checking can be disabled in Preferences -> Capture -> Syntax check capture filter."
4876 );
4877 gtk_box_pack_start(GTK_BOX(all_filter_hb), all_filter_cm, TRUE, TRUE, DLG_BUTTON_SPACING);
4878
4879 /* let an eventually capture filters dialog know the text entry to fill in */
4880 g_object_set_data(G_OBJECT(all_filter_bt), E_FILT_TE_PTR_KEY, all_filter_te);
4881
4882 #if defined(HAVE_PCAP_OPEN_DEAD) && defined(HAVE_BPF_IMAGE)
4883 all_compile_bt = gtk_button_new_with_label("Compile selected BPFs");
4884 g_signal_connect(all_compile_bt, "clicked", G_CALLBACK(capture_all_filter_compile_cb), NULL);
4885 gtk_widget_set_tooltip_text(all_compile_bt,
4886 "Compile the capture filter expression and show the BPF (Berkeley Packet Filter) code.");
4887 /* We can't compile without any supported link-types, so disable the button in that case */
4888 gtk_box_pack_start(GTK_BOX(all_filter_hb), all_compile_bt, FALSE, FALSE, DLG_BUTTON_SPACING);
4889 if (global_capture_opts.num_selected > 0) {
4890 gtk_widget_set_sensitive(all_compile_bt, TRUE);
4891 } else {
4892 gtk_widget_set_sensitive(all_compile_bt, FALSE);
4893 }
4894 #endif
4895
4896 /* Capture file-related options frame */
4897 file_fr = frame_new("Capture Files");
4898 gtk_box_pack_start(GTK_BOX (left_vb), file_fr, TRUE, TRUE, 0);
4899
4900 file_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_UNRELATED_SPACING, FALSE);
4901 gtk_container_set_border_width(GTK_CONTAINER(file_vb), DLG_OUTER_MARGIN);
4902 gtk_container_add(GTK_CONTAINER(file_fr), file_vb);
4903
4904 /* File row */
4905 file_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3, FALSE);
4906 gtk_box_pack_start(GTK_BOX(file_vb), file_hb, FALSE, FALSE, 0);
4907
4908 file_lb = gtk_label_new("File:");
4909 gtk_box_pack_start(GTK_BOX(file_hb), file_lb, FALSE, FALSE, 3);
4910
4911 file_te = gtk_entry_new();
4912 gtk_widget_set_tooltip_text(file_te,
4913 "Enter the file name to which captured data will be written. "
4914 "If you don't enter something here, a temporary file will be used."
4915 );
4916 gtk_box_pack_start(GTK_BOX(file_hb), file_te, TRUE, TRUE, 3);
4917
4918 file_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_BROWSE);
4919 gtk_widget_set_tooltip_text(file_bt,
4920 "Select a file to which captured data will be written, "
4921 "instead of entering the file name directly. "
4922 );
4923 gtk_box_pack_start(GTK_BOX(file_hb), file_bt, FALSE, FALSE, 0);
4924
4925 g_signal_connect(file_bt, "clicked", G_CALLBACK(capture_prep_file_cb), file_te);
4926
4927 /* multiple files table */
4928 /* XXX We want multi_grid to shrink to its minimum size horizontally
4929 * and be left-aligned within file_fr. Using a horizontal GtkBox works
4930 * in Gtk2 but not Gtk3. The situation gets sillier below with limit_fr
4931 * and limit_grid because we have both horizontal and vertical GtkBoxes.
4932 */
4933 multi_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE);
4934 gtk_box_pack_start(GTK_BOX(file_vb), multi_hb, FALSE, FALSE, 0);
4935 multi_grid = ws_gtk_grid_new();
4936 ws_gtk_grid_set_row_spacing(GTK_GRID(multi_grid), DLG_LABEL_SPACING);
4937 ws_gtk_grid_set_column_spacing(GTK_GRID(multi_grid), DLG_UNRELATED_SPACING);
4938 gtk_box_pack_start(GTK_BOX(multi_hb), multi_grid, FALSE, FALSE, 0);
4939 row = 0;
4940
4941 /* multiple files row */
4942 multi_files_on_cb = gtk_check_button_new_with_mnemonic("Use _multiple files");
4943 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(multi_files_on_cb),
4944 global_capture_opts.multi_files_on);
4945 g_signal_connect(multi_files_on_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity),
4946 cap_open_w);
4947 gtk_widget_set_tooltip_text(multi_files_on_cb,
4948 "Instead of using a single capture file, multiple files will be created. "
4949 "The generated file names will contain an incrementing number and the start time of the capture.");
4950 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), multi_files_on_cb, 0, row, 1, 1,
4951 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
4952
4953 /* Pcap-NG row */
4954 pcap_ng_cb = gtk_check_button_new_with_mnemonic("Use pcap-ng format");
4955 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pcap_ng_cb), global_capture_opts.use_pcapng);
4956 gtk_widget_set_tooltip_text(pcap_ng_cb, "Capture packets in the next-generation capture file format. "
4957 "This is still experimental.");
4958 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), pcap_ng_cb, 2, row, 1, 1,
4959 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
4960 row++;
4961
4962 /* Ring buffer filesize row */
4963 ring_filesize_cb = gtk_check_button_new_with_label("Next file every");
4964 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ring_filesize_cb),
4965 global_capture_opts.has_autostop_filesize || !global_capture_opts.has_file_duration);
4966 g_signal_connect(ring_filesize_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
4967 gtk_widget_set_tooltip_text(ring_filesize_cb,
4968 "If the selected file size is exceeded, capturing switches to the next file.\n"
4969 "PLEASE NOTE: at least one of the \"Next file every\" options MUST be selected.");
4970 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), ring_filesize_cb, 0, row, 1, 1,
4971 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
4972
4973 ring_filesize_adj = (GtkAdjustment *) gtk_adjustment_new(0.0,
4974 1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
4975 ring_filesize_sb = gtk_spin_button_new (ring_filesize_adj, 0, 0);
4976 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (ring_filesize_sb), TRUE);
4977 gtk_widget_set_size_request(ring_filesize_sb, 80, -1);
4978 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), ring_filesize_sb, 1, row, 1, 1,
4979 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
4980
4981 ring_filesize_cbx = size_unit_combo_box_new(global_capture_opts.autostop_filesize);
4982 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), ring_filesize_cbx, 2, row, 1, 1,
4983 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
4984
4985 value = size_unit_combo_box_set_value(global_capture_opts.autostop_filesize);
4986 gtk_adjustment_set_value(ring_filesize_adj, (gdouble) value);
4987
4988 row++;
4989
4990 /* Ring buffer duration row */
4991 file_duration_cb = gtk_check_button_new_with_label("Next file every");
4992 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(file_duration_cb),
4993 global_capture_opts.has_file_duration);
4994 g_signal_connect(file_duration_cb, "toggled",
4995 G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
4996 gtk_widget_set_tooltip_text(file_duration_cb,
4997 "If the selected duration is exceeded, capturing switches to the next file.\n"
4998 "PLEASE NOTE: at least one of the \"Next file every\" options MUST be selected.");
4999 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), file_duration_cb, 0, row, 1, 1,
5000 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5001
5002 file_duration_adj = (GtkAdjustment *)gtk_adjustment_new(0.0,
5003 1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
5004 file_duration_sb = gtk_spin_button_new (file_duration_adj, 0, 0);
5005 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (file_duration_sb), TRUE);
5006 gtk_widget_set_size_request(file_duration_sb, 80, -1);
5007 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), file_duration_sb, 1, row, 1, 1,
5008 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5009
5010 file_duration_cbx = time_unit_combo_box_new(global_capture_opts.file_duration);
5011 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), file_duration_cbx, 2, row, 1, 1,
5012 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5013
5014 value = time_unit_combo_box_convert_value(global_capture_opts.file_duration);
5015 gtk_adjustment_set_value(file_duration_adj, (gdouble) value);
5016 row++;
5017
5018 /* Ring buffer files row */
5019 ringbuffer_nbf_cb = gtk_check_button_new_with_label("Ring buffer with");
5020 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ringbuffer_nbf_cb),
5021 global_capture_opts.has_ring_num_files);
5022 g_signal_connect(ringbuffer_nbf_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
5023 gtk_widget_set_tooltip_text(ringbuffer_nbf_cb,
5024 "After capturing has switched to the next file and the given number of files has exceeded, "
5025 "the oldest file will be removed."
5026 );
5027 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), ringbuffer_nbf_cb, 0, row, 1, 1,
5028 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5029
5030 ringbuffer_nbf_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) global_capture_opts.ring_num_files,
5031 2/*RINGBUFFER_MIN_NUM_FILES*/, RINGBUFFER_MAX_NUM_FILES, 1.0, 10.0, 0.0);
5032 ringbuffer_nbf_sb = gtk_spin_button_new (ringbuffer_nbf_adj, 0, 0);
5033 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (ringbuffer_nbf_sb), TRUE);
5034 gtk_widget_set_size_request(ringbuffer_nbf_sb, 80, -1);
5035 g_signal_connect(ringbuffer_nbf_sb, "changed", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
5036 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), ringbuffer_nbf_sb, 1, row, 1, 1,
5037 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5038
5039 ringbuffer_nbf_lb = gtk_label_new("files");
5040 gtk_misc_set_alignment(GTK_MISC(ringbuffer_nbf_lb), 0, 0.5f);
5041 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), ringbuffer_nbf_lb, 2, row, 1, 1,
5042 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5043
5044 row++;
5045
5046 /* Files row */
5047 stop_files_cb = gtk_check_button_new_with_label("Stop capture after");
5048 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stop_files_cb),
5049 global_capture_opts.has_autostop_files);
5050 g_signal_connect(stop_files_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
5051 gtk_widget_set_tooltip_text(stop_files_cb, "Stop capturing after the given number of \"file switches\" have been done.");
5052 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), stop_files_cb, 0, row, 1, 1,
5053 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5054
5055 stop_files_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat)global_capture_opts.autostop_files,
5056 1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
5057 stop_files_sb = gtk_spin_button_new (stop_files_adj, 0, 0);
5058 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_files_sb), TRUE);
5059 gtk_widget_set_size_request(stop_files_sb, 80, -1);
5060 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), stop_files_sb, 1, row, 1, 1,
5061 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5062
5063 stop_files_lb = gtk_label_new("file(s)");
5064 gtk_misc_set_alignment(GTK_MISC(stop_files_lb), 0, 0.5f);
5065 ws_gtk_grid_attach_extended(GTK_GRID (multi_grid), stop_files_lb, 2, row, 1, 1,
5066 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5067
5068 row++;
5069
5070 /* Capture limits frame */
5071 limit_fr = frame_new("Stop Capture Automatically After...");
5072 gtk_box_pack_start(GTK_BOX (left_vb), limit_fr, TRUE, TRUE, 0);
5073
5074 limit_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_UNRELATED_SPACING, FALSE);
5075 gtk_container_set_border_width(GTK_CONTAINER(limit_vb), DLG_OUTER_MARGIN);
5076 gtk_container_add(GTK_CONTAINER(limit_fr), limit_vb);
5077
5078 /* limits table */
5079 limit_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE);
5080 gtk_box_pack_start(GTK_BOX(limit_vb), limit_hb, FALSE, FALSE, 0);
5081 limit_grid = ws_gtk_grid_new();
5082 ws_gtk_grid_set_row_spacing(GTK_GRID(limit_grid), DLG_LABEL_SPACING);
5083 ws_gtk_grid_set_column_spacing(GTK_GRID(limit_grid), DLG_UNRELATED_SPACING);
5084 gtk_box_pack_start(GTK_BOX(limit_hb), limit_grid, FALSE, FALSE, 0);
5085 row = 0;
5086
5087 /* Packet count row */
5088 stop_packets_cb = gtk_check_button_new();
5089 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stop_packets_cb),
5090 global_capture_opts.has_autostop_packets);
5091 g_signal_connect(stop_packets_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
5092 gtk_widget_set_tooltip_text(stop_packets_cb, "Stop capturing after the specified number of packets have been captured.");
5093 ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_packets_cb, 0, row, 1, 1,
5094 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5095
5096 stop_packets_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat)global_capture_opts.autostop_packets,
5097 1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
5098 stop_packets_sb = gtk_spin_button_new (stop_packets_adj, 0, 0);
5099 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_packets_sb), TRUE);
5100 gtk_widget_set_size_request(stop_packets_sb, 80, -1);
5101 ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_packets_sb, 1, row, 1, 1,
5102 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5103
5104 stop_packets_lb = gtk_label_new("packet(s)");
5105 gtk_misc_set_alignment(GTK_MISC(stop_packets_lb), 0, 0.5f);
5106 ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_packets_lb, 2, row, 1, 1,
5107 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5108
5109 row++;
5110
5111 /* Filesize row */
5112 stop_filesize_cb = gtk_check_button_new();
5113 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stop_filesize_cb),
5114 global_capture_opts.has_autostop_filesize);
5115 g_signal_connect(stop_filesize_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
5116 gtk_widget_set_tooltip_text(stop_filesize_cb, "Stop capturing after the specified amount of data has been captured.");
5117 ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_filesize_cb, 0, row, 1, 1,
5118 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5119
5120 stop_filesize_adj = (GtkAdjustment *) gtk_adjustment_new(0.0,
5121 1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
5122 stop_filesize_sb = gtk_spin_button_new (stop_filesize_adj, 0, 0);
5123 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_filesize_sb), TRUE);
5124 gtk_widget_set_size_request(stop_filesize_sb, 80, -1);
5125 ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_filesize_sb, 1, row, 1, 1,
5126 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5127
5128 stop_filesize_cbx = size_unit_combo_box_new(global_capture_opts.autostop_filesize);
5129 ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_filesize_cbx, 2, row, 1, 1,
5130 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5131
5132 value = size_unit_combo_box_set_value(global_capture_opts.autostop_filesize);
5133 gtk_adjustment_set_value(stop_filesize_adj, (gdouble) value);
5134
5135 row++;
5136
5137 /* Duration row */
5138 stop_duration_cb = gtk_check_button_new();
5139 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(stop_duration_cb),
5140 global_capture_opts.has_autostop_duration);
5141 g_signal_connect(stop_duration_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
5142 gtk_widget_set_tooltip_text(stop_duration_cb, "Stop capturing after the specified amount of time has passed.");
5143 ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_duration_cb, 0, row, 1, 1,
5144 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5145
5146 stop_duration_adj = (GtkAdjustment *) gtk_adjustment_new(0.0,
5147 1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
5148 stop_duration_sb = gtk_spin_button_new (stop_duration_adj, 0, 0);
5149 gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (stop_duration_sb), TRUE);
5150 gtk_widget_set_size_request(stop_duration_sb, 80, -1);
5151 ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_duration_sb, 1, row, 1, 1,
5152 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5153
5154 stop_duration_cbx = time_unit_combo_box_new(global_capture_opts.autostop_duration);
5155 ws_gtk_grid_attach_extended(GTK_GRID (limit_grid), stop_duration_cbx, 2, row, 1, 1,
5156 (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0);
5157
5158 value = time_unit_combo_box_convert_value(global_capture_opts.autostop_duration);
5159 gtk_adjustment_set_value(stop_duration_adj, (gdouble) value);
5160 row++;
5161
5162 /* Display-related options frame */
5163 display_fr = frame_new("Display Options");
5164 gtk_box_pack_start(GTK_BOX (right_vb), display_fr, TRUE, TRUE, 0);
5165
5166 display_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_UNRELATED_SPACING, FALSE);
5167 gtk_container_set_border_width(GTK_CONTAINER(display_vb), DLG_OUTER_MARGIN);
5168 gtk_container_add(GTK_CONTAINER(display_fr), display_vb);
5169
5170 /* "Update display in real time" row */
5171 sync_cb = gtk_check_button_new_with_mnemonic(
5172 "_Update list of packets in real time");
5173 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(sync_cb),
5174 global_capture_opts.real_time_mode);
5175 g_signal_connect(sync_cb, "toggled", G_CALLBACK(capture_prep_adjust_sensitivity), cap_open_w);
5176 gtk_widget_set_tooltip_text(sync_cb,
5177 "Using this option will show the captured packets immediately on the main screen. "
5178 "Please note: this will slow down capturing, so increased packet drops might appear.");
5179 gtk_box_pack_start(GTK_BOX (display_vb), sync_cb, TRUE, TRUE, 0);
5180
5181 /* "Auto-scroll live update" row */
5182 auto_scroll_cb = gtk_check_button_new_with_mnemonic("_Automatically scroll during live capture");
5183 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(auto_scroll_cb), auto_scroll_live);
5184 gtk_widget_set_tooltip_text(auto_scroll_cb,
5185 "This will scroll the \"Packet List\" automatically to the latest captured packet, "
5186 "when the \"Update List of packets in real time\" option is used.");
5187 gtk_box_pack_start(GTK_BOX (display_vb), auto_scroll_cb, TRUE, TRUE, 0);
5188
5189 /* "Hide capture info" row */
5190 hide_info_cb = gtk_check_button_new_with_mnemonic("_Hide capture info dialog");
5191 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(hide_info_cb), !global_capture_opts.show_info);
5192 gtk_widget_set_tooltip_text(hide_info_cb, "Hide the capture info dialog while capturing.");
5193 gtk_box_pack_start(GTK_BOX (display_vb), hide_info_cb, TRUE, TRUE, 0);
5194
5195 /* Name Resolution frame */
5196 resolv_fr = frame_new("Name Resolution");
5197 gtk_box_pack_start(GTK_BOX (right_vb), resolv_fr, TRUE, TRUE, 0);
5198
5199 resolv_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, DLG_UNRELATED_SPACING, FALSE);
5200 gtk_container_set_border_width(GTK_CONTAINER(resolv_vb), DLG_OUTER_MARGIN);
5201 gtk_container_add(GTK_CONTAINER(resolv_fr), resolv_vb);
5202
5203 m_resolv_cb = gtk_check_button_new_with_mnemonic(
5204 "Resolve _MAC addresses");
5205 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_resolv_cb),
5206 gbl_resolv_flags.mac_name);
5207 gtk_widget_set_tooltip_text(m_resolv_cb, "Perform MAC layer name resolution while capturing.");
5208 gtk_box_pack_start(GTK_BOX (resolv_vb), m_resolv_cb, TRUE, TRUE, 0);
5209
5210 n_resolv_cb = gtk_check_button_new_with_mnemonic(
5211 "Resolve _network-layer names");
5212 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(n_resolv_cb),
5213 gbl_resolv_flags.network_name);
5214 gtk_widget_set_tooltip_text(n_resolv_cb, "Perform network layer name resolution while capturing.");
5215 gtk_box_pack_start(GTK_BOX (resolv_vb), n_resolv_cb, TRUE, TRUE, 0);
5216
5217 t_resolv_cb = gtk_check_button_new_with_mnemonic(
5218 "Resolve _transport-layer name");
5219 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(t_resolv_cb),
5220 gbl_resolv_flags.transport_name);
5221 gtk_widget_set_tooltip_text(t_resolv_cb,
5222 "Perform transport layer name resolution while capturing.");
5223 gtk_box_pack_start(GTK_BOX (resolv_vb), t_resolv_cb, TRUE, TRUE, 0);
5224
5225 e_resolv_cb = gtk_check_button_new_with_mnemonic(
5226 "Use _external network name resolver");
5227 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(e_resolv_cb),
5228 gbl_resolv_flags.use_external_net_name_resolver);
5229 gtk_widget_set_tooltip_text(e_resolv_cb,
5230 "Use the (system's) configured name resolver (e.g., DNS) to resolve network names.");
5231 gtk_box_pack_start(GTK_BOX (resolv_vb), e_resolv_cb, TRUE, TRUE, 0);
5232
5233 /* Button row: "Start", "Cancel" and "Help" buttons */
5234 bbox = dlg_button_row_new(WIRESHARK_STOCK_CAPTURE_START, GTK_STOCK_CLOSE, GTK_STOCK_HELP, NULL);
5235 gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 5);
5236
5237 ok_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_CAPTURE_START);
5238 g_signal_connect(ok_bt, "clicked", G_CALLBACK(capture_start_cb), NULL);
5239 gtk_widget_set_tooltip_text(ok_bt, "Start the capture process.");
5240 if (global_capture_opts.num_selected > 0) {
5241 gtk_widget_set_sensitive(ok_bt, TRUE);
5242 } else {
5243 gtk_widget_set_sensitive(ok_bt, FALSE);
5244 }
5245
5246 close_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_CLOSE);
5247 gtk_widget_set_tooltip_text(close_bt,
5248 "Exit dialog.");
5249 window_set_cancel_button(cap_open_w, close_bt, window_cancel_button_cb);
5250
5251 help_bt = (GtkWidget *)g_object_get_data(G_OBJECT(bbox), GTK_STOCK_HELP);
5252 gtk_widget_set_tooltip_text(help_bt,
5253 "Show help about capturing.");
5254 g_signal_connect(help_bt, "clicked", G_CALLBACK(topic_cb), GUINT_TO_POINTER(HELP_CAPTURE_OPTIONS_DIALOG));
5255 gtk_widget_grab_default(ok_bt);
5256
5257 /* Attach pointers to needed widgets to the capture prefs window/object */
5258 #if defined(HAVE_PCAP_REMOTE)
5259 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_REMOTE_DIALOG_PTR_KEY, NULL);
5260 #endif
5261 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_KEY_ALL, all_cb);
5262 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_PROMISC_KEY_ALL, promisc_cb);
5263 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_PCAP_NG_KEY, pcap_ng_cb);
5264 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_FILE_TE_KEY, file_te);
5265 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_MULTI_FILES_ON_CB_KEY, multi_files_on_cb);
5266 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_RING_NBF_CB_KEY, ringbuffer_nbf_cb);
5267 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_RING_NBF_SB_KEY, ringbuffer_nbf_sb);
5268 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_RING_NBF_LB_KEY, ringbuffer_nbf_lb);
5269 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_RING_FILESIZE_CB_KEY, ring_filesize_cb);
5270 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_RING_FILESIZE_SB_KEY, ring_filesize_sb);
5271 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_RING_FILESIZE_CBX_KEY, ring_filesize_cbx);
5272 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_FILE_DURATION_CB_KEY, file_duration_cb);
5273 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_FILE_DURATION_SB_KEY, file_duration_sb);
5274 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_FILE_DURATION_CBX_KEY, file_duration_cbx);
5275 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_SYNC_KEY, sync_cb);
5276 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_AUTO_SCROLL_KEY, auto_scroll_cb);
5277 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_HIDE_INFO_KEY, hide_info_cb);
5278 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_PACKETS_CB_KEY, stop_packets_cb);
5279 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_PACKETS_SB_KEY, stop_packets_sb);
5280 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_PACKETS_LB_KEY, stop_packets_lb);
5281 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_FILESIZE_CB_KEY, stop_filesize_cb);
5282 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_FILESIZE_SB_KEY, stop_filesize_sb);
5283 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_FILESIZE_CBX_KEY, stop_filesize_cbx);
5284 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_DURATION_CB_KEY, stop_duration_cb);
5285 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_DURATION_SB_KEY, stop_duration_sb);
5286 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_DURATION_CBX_KEY, stop_duration_cbx);
5287 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_FILES_CB_KEY, stop_files_cb);
5288 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_FILES_SB_KEY, stop_files_sb);
5289 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_STOP_FILES_LB_KEY, stop_files_lb);
5290 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_M_RESOLVE_KEY, m_resolv_cb);
5291 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_N_RESOLVE_KEY, n_resolv_cb);
5292 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_T_RESOLVE_KEY, t_resolv_cb);
5293 g_object_set_data(G_OBJECT(cap_open_w), E_CAP_E_RESOLVE_KEY, e_resolv_cb);
5294
5295 /* Set the sensitivity of various widgets as per the settings of other
5296 widgets. */
5297 capture_prep_adjust_sensitivity(NULL, cap_open_w);
5298
5299 update_properties_all();
5300 update_visible_columns_menu ();
5301
5302 /* Catch the "activate" signal on the text
5303 entries, so that if the user types Return there, we act as if the
5304 "OK" button had been selected, as happens if Return is typed if some
5305 widget that *doesn't* handle the Return key has the input focus. */
5306 /*dlg_set_activate(gtk_bin_get_child(GTK_BIN(if_cb)), ok_bt);*/
5307 dlg_set_activate(file_te, ok_bt);
5308 dlg_set_activate(all_filter_te, ok_bt);
5309 gtk_widget_grab_focus(all_filter_te);
5310
5311 g_signal_connect(cap_open_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
5312 g_signal_connect(cap_open_w, "destroy", G_CALLBACK(capture_prep_destroy_cb), NULL);
5313
5314 window_get_geometry(top_level, &tl_geom);
5315 gtk_window_set_default_size(GTK_WINDOW(cap_open_w), tl_geom.width * 8 / 10, -1);
5316
5317 gtk_widget_show_all(cap_open_w);
5318 window_present(cap_open_w);
5319
5320 cap_open_complete = TRUE; /* "Capture:Start" is now OK */
5321 global_capture_session.session_started = TRUE;
5322 }
5323
5324 /* user pressed the "Start" button (in dialog or toolbar) */
5325 void
5326 capture_start_cb(GtkWidget *w _U_, gpointer d _U_)
5327 {
5328 interface_options interface_opts;
5329 guint i;
5330 gchar * filter_str;
5331
5332 #ifdef HAVE_AIRPCAP
5333 airpcap_if_active = airpcap_if_selected;
5334 if (airpcap_if_active)
5335 airpcap_set_toolbar_start_capture(airpcap_if_active);
5336 #endif
5337
5338 /* XXX - will closing this remove a temporary file? */
5339 if(!do_file_close(&cfile, FALSE, " before starting a new capture")){
5340 return;
5341 }
5342 if (cap_open_w) {
5343 /*
5344 * There's an options dialog; get the values from it and close it.
5345 */
5346 gboolean success;
5347
5348 /* Determine if "capture start" while building of the "capture options" window */
5349 /* is in progress. If so, ignore the "capture start. */
5350 /* XXX: Would it be better/cleaner for the "capture options" window code to */
5351 /* disable the capture start button temporarily ? */
5352 if (cap_open_complete == FALSE) {
5353 return; /* Building options window: ignore "capture start" */
5354 }
5355 success = capture_dlg_prep(cap_open_w);
5356 if (success)
5357 window_destroy(GTK_WIDGET(cap_open_w));
5358 if (!success)
5359 return; /* error in options dialog */
5360 }
5361 if (global_capture_opts.num_selected == 0) {
5362 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
5363 "You didn't specify an interface on which to capture packets.");
5364 return;
5365 }
5366
5367 /* everything's prepared, now it's really time to start the capture */
5368
5369 /* XXX - we might need to init other pref data as well... */
5370 main_auto_scroll_live_changed(auto_scroll_live);
5371
5372 /* XXX - can this ever happen? */
5373 if (global_capture_session.state != CAPTURE_STOPPED)
5374 return;
5375
5376 /* close the currently loaded capture file */
5377 cf_close((capture_file *)global_capture_session.cf);
5378
5379 /* Copy the selected interfaces to the set of interfaces to use for
5380 this capture. */
5381 collect_ifaces(&global_capture_opts);
5382
5383 if (capture_start(&global_capture_opts, &global_capture_session, main_window_update)) {
5384 /* The capture succeeded, which means the capture filters specified are
5385 valid; add them to the recent capture filter lists for the interfaces.
5386
5387 If the same capture filter is used for all the selected interfaces,
5388 add it to the global recent capture filter list as well. */
5389 filter_str = NULL;
5390 for (i = 0; i < global_capture_opts.ifaces->len; i++) {
5391 interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
5392 if (interface_opts.cfilter) {
5393 recent_add_cfilter(interface_opts.name, interface_opts.cfilter);
5394 if (filter_str == NULL) {
5395 /* First selected interface - save its capture filter. */
5396 filter_str = g_strdup(interface_opts.cfilter);
5397 } else {
5398 /* Not the first selected interface; is its capture filter
5399 the same as the one the other interfaces we've looked
5400 at have? */
5401 if (strcmp(interface_opts.cfilter, filter_str) != 0) {
5402 /* No, so not all selected interfaces have the same capture
5403 filter. */
5404 if (filter_str != NULL) {
5405 g_free(filter_str);
5406 }
5407 filter_str = NULL;
5408 }
5409 }
5410 }
5411 }
5412 if (filter_str != NULL) {
5413 if (filter_str[0] != '\0') {
5414 recent_add_cfilter(NULL, filter_str);
5415 }
5416 g_free(filter_str);
5417 }
5418 }
5419 }
5420
5421
5422 /* user change linktype selection;, convert to internal DLT value */
5423 static void
5424 select_link_type_cb(GtkWidget *linktype_combo_box, gpointer data _U_)
5425 {
5426 gpointer ptr;
5427 int dlt;
5428 interface_t device;
5429
5430 device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_interface);
5431 global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_interface);
5432 if (! ws_combo_box_get_active_pointer(GTK_COMBO_BOX(linktype_combo_box), &ptr)) {
5433 g_assert_not_reached(); /* Programming error: somehow nothing is active */
5434 }
5435 if ((dlt = GPOINTER_TO_INT(ptr)) == -1) {
5436 g_assert_not_reached(); /* Programming error: somehow managed to select an "unsupported" entry */
5437 }
5438 device.active_dlt = dlt;
5439 g_array_insert_val(global_capture_opts.all_ifaces, marked_interface, device);
5440 capture_filter_check_syntax_cb(linktype_combo_box, data);
5441 }
5442
5443 /* user pressed "File" button */
5444 static void
5445 capture_prep_file_cb(GtkWidget *file_bt, GtkWidget *file_te)
5446 {
5447 file_selection_browse(file_bt, file_te, "Wireshark: Specify a Capture File", FILE_SELECTION_WRITE_BROWSE);
5448 }
5449
5450 /* user pressed "Pipe" button */
5451 static void
5452 capture_prep_pipe_cb(GtkWidget *pipe_bt, GtkWidget *pipe_te)
5453 {
5454 file_selection_browse(pipe_bt, pipe_te, "Wireshark: Specify a Pipe", FILE_SELECTION_WRITE_BROWSE);
5455 }
5456
5457
5458 /* convert dialog settings into capture_opts values */
5459 static gboolean
5460 capture_dlg_prep(gpointer parent_w) {
5461 GtkWidget *pcap_ng_cb,
5462 *file_te, *multi_files_on_cb, *ringbuffer_nbf_sb, *ringbuffer_nbf_cb,
5463 *sync_cb, *auto_scroll_cb, *hide_info_cb,
5464 *stop_packets_cb, *stop_packets_sb,
5465 *stop_filesize_cb, *stop_filesize_sb, *stop_filesize_cbx,
5466 *stop_duration_cb, *stop_duration_sb, *stop_duration_cbx,
5467 *ring_filesize_cb, *ring_filesize_sb, *ring_filesize_cbx,
5468 *file_duration_cb, *file_duration_sb, *file_duration_cbx,
5469 *stop_files_cb, *stop_files_sb,
5470 *m_resolv_cb, *n_resolv_cb, *t_resolv_cb, *e_resolv_cb;
5471 const gchar *g_save_file;
5472 gchar *cf_name;
5473 gchar *dirname;
5474 gint32 tmp;
5475
5476 pcap_ng_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_PCAP_NG_KEY);
5477 file_te = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_TE_KEY);
5478 multi_files_on_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_MULTI_FILES_ON_CB_KEY);
5479 ringbuffer_nbf_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_NBF_CB_KEY);
5480 ringbuffer_nbf_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_NBF_SB_KEY);
5481 ring_filesize_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_FILESIZE_CB_KEY);
5482 ring_filesize_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_FILESIZE_SB_KEY);
5483 ring_filesize_cbx = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_FILESIZE_CBX_KEY);
5484 file_duration_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_DURATION_CB_KEY);
5485 file_duration_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_DURATION_SB_KEY);
5486 file_duration_cbx = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_DURATION_CBX_KEY);
5487 sync_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SYNC_KEY);
5488 auto_scroll_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_AUTO_SCROLL_KEY);
5489 hide_info_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_HIDE_INFO_KEY);
5490 stop_packets_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_PACKETS_CB_KEY);
5491 stop_packets_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_PACKETS_SB_KEY);
5492 stop_filesize_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILESIZE_CB_KEY);
5493 stop_filesize_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILESIZE_SB_KEY);
5494 stop_filesize_cbx = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILESIZE_CBX_KEY);
5495 stop_duration_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_DURATION_CB_KEY);
5496 stop_duration_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_DURATION_SB_KEY);
5497 stop_duration_cbx = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_DURATION_CBX_KEY);
5498 stop_files_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILES_CB_KEY);
5499 stop_files_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILES_SB_KEY);
5500 m_resolv_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_M_RESOLVE_KEY);
5501 n_resolv_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_N_RESOLVE_KEY);
5502 t_resolv_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_T_RESOLVE_KEY);
5503 e_resolv_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_E_RESOLVE_KEY);
5504
5505 if (global_capture_opts.num_selected == 0) {
5506 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
5507 "You didn't specify an interface on which to capture packets.");
5508 return FALSE;
5509 }
5510 global_capture_opts.use_pcapng =
5511 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pcap_ng_cb));
5512 /* Wireshark always saves to a capture file. */
5513 global_capture_opts.saving_to_file = TRUE;
5514 g_save_file = gtk_entry_get_text(GTK_ENTRY(file_te));
5515 if (g_save_file && g_save_file[0]) {
5516 /* User specified a file to which the capture should be written. */
5517 global_capture_opts.save_file = g_strdup(g_save_file);
5518 global_capture_opts.orig_save_file = g_strdup(g_save_file);
5519 /* Save the directory name for future file dialogs. */
5520 cf_name = g_strdup(g_save_file);
5521 dirname = get_dirname(cf_name); /* Overwrites cf_name */
5522 set_last_open_dir(dirname);
5523 g_free(cf_name);
5524 } else {
5525 /* User didn't specify a file; save to a temporary file. */
5526 global_capture_opts.save_file = NULL;
5527 }
5528
5529 global_capture_opts.has_autostop_packets =
5530 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_packets_cb));
5531 if (global_capture_opts.has_autostop_packets)
5532 global_capture_opts.autostop_packets =
5533 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(stop_packets_sb));
5534
5535 global_capture_opts.has_autostop_duration =
5536 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_duration_cb));
5537 if (global_capture_opts.has_autostop_duration) {
5538 global_capture_opts.autostop_duration =
5539 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(stop_duration_sb));
5540 global_capture_opts.autostop_duration =
5541 time_unit_combo_box_get_value(stop_duration_cbx, global_capture_opts.autostop_duration);
5542 }
5543
5544 global_capture_opts.real_time_mode =
5545 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sync_cb));
5546
5547 auto_scroll_live =
5548 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(auto_scroll_cb));
5549
5550 global_capture_opts.show_info =
5551 !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(hide_info_cb));
5552
5553 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_resolv_cb)))
5554 gbl_resolv_flags.mac_name = TRUE;
5555 else
5556 gbl_resolv_flags.mac_name = FALSE;
5557 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(n_resolv_cb)))
5558 gbl_resolv_flags.network_name = TRUE;
5559 else
5560 gbl_resolv_flags.network_name = FALSE;
5561 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(t_resolv_cb)))
5562 gbl_resolv_flags.transport_name = TRUE;
5563 else
5564 gbl_resolv_flags.transport_name = FALSE;
5565 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(e_resolv_cb)))
5566 gbl_resolv_flags.use_external_net_name_resolver = TRUE;
5567 else
5568 gbl_resolv_flags.use_external_net_name_resolver = FALSE;
5569
5570 global_capture_opts.has_ring_num_files =
5571 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ringbuffer_nbf_cb));
5572
5573 global_capture_opts.ring_num_files =
5574 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ringbuffer_nbf_sb));
5575 if (global_capture_opts.ring_num_files > RINGBUFFER_MAX_NUM_FILES)
5576 global_capture_opts.ring_num_files = RINGBUFFER_MAX_NUM_FILES;
5577 #if RINGBUFFER_MIN_NUM_FILES > 0
5578 else if (global_capture_opts.ring_num_files < RINGBUFFER_MIN_NUM_FILES)
5579 global_capture_opts.ring_num_files = RINGBUFFER_MIN_NUM_FILES;
5580 #endif
5581
5582 global_capture_opts.multi_files_on =
5583 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(multi_files_on_cb));
5584
5585 global_capture_opts.has_file_duration =
5586 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(file_duration_cb));
5587 if (global_capture_opts.has_file_duration) {
5588 global_capture_opts.file_duration =
5589 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(file_duration_sb));
5590 global_capture_opts.file_duration =
5591 time_unit_combo_box_get_value(file_duration_cbx, global_capture_opts.file_duration);
5592 }
5593
5594 global_capture_opts.has_autostop_files =
5595 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_files_cb));
5596 if (global_capture_opts.has_autostop_files)
5597 global_capture_opts.autostop_files =
5598 gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(stop_files_sb));
5599
5600 if (global_capture_opts.multi_files_on) {
5601 global_capture_opts.has_autostop_filesize =
5602 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ring_filesize_cb));
5603 if (global_capture_opts.has_autostop_filesize) {
5604 tmp = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(ring_filesize_sb));
5605 tmp = size_unit_combo_box_convert_value(ring_filesize_cbx, tmp);
5606 if (tmp != 0) {
5607 global_capture_opts.autostop_filesize = tmp;
5608 } else {
5609 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
5610 "%sMultiple files: Requested filesize too large!%s\n\n"
5611 "The setting \"Next file every x byte(s)\" can't be greater than %u bytes (2GiB).",
5612 simple_dialog_primary_start(), simple_dialog_primary_end(), (guint32)G_MAXINT + 1);
5613 return FALSE;
5614 }
5615 }
5616
5617 /* test if the settings are ok for a ringbuffer */
5618 if (global_capture_opts.save_file == NULL) {
5619 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
5620 "%sMultiple files: No capture file name given!%s\n\n"
5621 "You must specify a filename if you want to use multiple files.",
5622 simple_dialog_primary_start(), simple_dialog_primary_end());
5623 return FALSE;
5624 } else if (!global_capture_opts.has_autostop_filesize && !global_capture_opts.has_file_duration) {
5625 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
5626 "%sMultiple files: No file limit given!%s\n\n"
5627 "You must specify a file size or duration at which is switched to the next capture file\n"
5628 "if you want to use multiple files.",
5629 simple_dialog_primary_start(), simple_dialog_primary_end());
5630 g_free(global_capture_opts.save_file);
5631 global_capture_opts.save_file = NULL;
5632 return FALSE;
5633 }
5634 } else {
5635 global_capture_opts.has_autostop_filesize =
5636 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_filesize_cb));
5637 if (global_capture_opts.has_autostop_filesize) {
5638 tmp = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(stop_filesize_sb));
5639 tmp = size_unit_combo_box_convert_value(stop_filesize_cbx, tmp);
5640 if (tmp != 0) {
5641 global_capture_opts.autostop_filesize = tmp;
5642 } else {
5643 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
5644 "%sStop Capture: Requested filesize too large!%s\n\n"
5645 "The setting \"after x byte(s)\" can't be greater than %u bytes (2GiB).",
5646 simple_dialog_primary_start(), simple_dialog_primary_end(), (guint32)G_MAXINT + 1);
5647 return FALSE;
5648 }
5649 }
5650 } /* multi_files_on */
5651 return TRUE;
5652 }
5653
5654 static GtkTreeModel *
5655 create_and_fill_model(GtkTreeView *view)
5656 {
5657 GtkListStore *store;
5658 GtkTreeIter iter;
5659 GList *list;
5660 char *temp, *snaplen_string, *linkname;
5661 guint i;
5662 link_row *linkr = NULL;
5663 interface_t device;
5664 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
5665 gint buffer;
5666 #endif
5667 gint snaplen;
5668 gboolean hassnap, pmode;
5669
5670 #if defined(HAVE_PCAP_CREATE)
5671 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);
5672 #elif defined(_WIN32) && !defined (HAVE_PCAP_CREATE)
5673 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);
5674 #else
5675 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);
5676 #endif
5677
5678 for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
5679 device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
5680 if (!device.hidden) {
5681 if (device.no_addresses == 0) {
5682 temp = g_strdup_printf("<b>%s</b>", device.display_name);
5683 } else {
5684 temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", device.display_name, device.addresses);
5685 }
5686 linkname = NULL;
5687 if(capture_dev_user_linktype_find(device.name) != -1) {
5688 device.active_dlt = capture_dev_user_linktype_find(device.name);
5689 }
5690 for (list = device.links; list != NULL; list = g_list_next(list)) {
5691 linkr = (link_row*)(list->data);
5692 if (linkr->dlt == device.active_dlt) {
5693 linkname = g_strdup(linkr->name);
5694 break;
5695 }
5696 }
5697 if (!linkname)
5698 linkname = g_strdup("unknown");
5699 pmode = capture_dev_user_pmode_find(device.name);
5700 if (pmode != -1) {
5701 device.pmode = pmode;
5702 }
5703 hassnap = capture_dev_user_hassnap_find(device.name);
5704 snaplen = capture_dev_user_snaplen_find(device.name);
5705 if(snaplen != -1 && hassnap != -1) {
5706 /* Default snap lenght set in preferences */
5707 device.snaplen = snaplen;
5708 device.has_snaplen = hassnap;
5709 } else {
5710 /* No preferences set yet, use default values */
5711 device.snaplen = WTAP_MAX_PACKET_SIZE;
5712 device.has_snaplen = FALSE;
5713 }
5714
5715 if (device.has_snaplen) {
5716 snaplen_string = g_strdup_printf("%d", device.snaplen);
5717 } else {
5718 snaplen_string = g_strdup("default");
5719 }
5720
5721 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
5722 if (capture_dev_user_buffersize_find(device.name) != -1) {
5723 buffer = capture_dev_user_buffersize_find(device.name);
5724 device.buffer = buffer;
5725 } else {
5726 device.buffer = DEFAULT_CAPTURE_BUFFER_SIZE;
5727 }
5728 #endif
5729 global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
5730 g_array_insert_val(global_capture_opts.all_ifaces, i, device);
5731 gtk_list_store_append (store, &iter);
5732 #if defined(HAVE_PCAP_CREATE)
5733 gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, linkname, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, MONITOR, device.monitor_mode_supported?(device.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, device.cfilter, -1);
5734 #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
5735 gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, linkname, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
5736 #else
5737 gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, linkname, PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
5738 #endif
5739 g_free(linkname);
5740 }
5741 }
5742 gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
5743 return GTK_TREE_MODEL(store);
5744 }
5745
5746 static gboolean
5747 query_tooltip_tree_view_cb (GtkWidget *widget,
5748 gint x,
5749 gint y,
5750 gboolean keyboard_tip,
5751 GtkTooltip *tooltip,
5752 gpointer data _U_)
5753 {
5754 GtkTreeIter iter;
5755 GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
5756 GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
5757 GtkTreePath *path = NULL;
5758 gchar *tmp;
5759 GtkTreeViewColumn *column;
5760 GtkCellRenderer* renderer = NULL;
5761 GList *renderer_list;
5762 gint idx;
5763
5764 char buffer[512];
5765
5766 if (!gtk_tree_view_get_tooltip_context (tree_view, &x, &y, keyboard_tip, &model, &path, &iter))
5767 return FALSE;
5768
5769 gtk_tree_model_get (model, &iter, 0, &tmp, -1);
5770
5771 if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(tree_view), (gint) x, (gint) y, NULL, &column, NULL, NULL)) {
5772 idx = col_title_to_index((const gchar *)gtk_tree_view_column_get_title(column));
5773
5774 switch (idx)
5775 {
5776 case CAPTURE: g_snprintf (buffer, sizeof(buffer), "Choose which interface (network adapter) will be used to capture packets from. "
5777 "Be sure to select the correct one, as it's a common mistake to select the wrong interface.");
5778 break;
5779 case INTERFACE: g_snprintf (buffer, sizeof(buffer), "Lists the interface name and the IP address(es) assigned to it. ");
5780 break;
5781 case LINK: g_snprintf (buffer, sizeof(buffer), "Link-layer type the interface supports.");
5782 break;
5783 case PMODE: g_snprintf (buffer, sizeof(buffer), "Usually a network adapter will only capture the traffic sent to its own network address. "
5784 "If you want to capture all traffic that the network adapter can \"see\", promiscuous mode should be configured.");
5785 break;
5786 case SNAPLEN: g_snprintf(buffer, sizeof(buffer), "Limit the maximum number of bytes to be captured from each packet. This size includes the "
5787 "link-layer header and all subsequent headers.");
5788 break;
5789 #if defined(HAVE_PCAP_CREATE)
5790 case BUFFER: g_snprintf (buffer, sizeof(buffer), "The memory buffer size used while capturing. "
5791 "If you notice packet drops, you can try increasing this size.");
5792 break;
5793 case MONITOR: g_snprintf (buffer, sizeof(buffer), "Usually a Wi-Fi adapter will, even in promiscuous mode, only capture "
5794 "the traffic on the BSS to which it's associated. "
5795 "If you want to capture all traffic that the Wi-Fi adapter can \"receive\", select this option. "
5796 "In order to see IEEE 802.11 headers or to see radio information for captured packets, "
5797 "it might be necessary to turn this option on.\n\n"
5798 "Note that, in monitor mode, the adapter might disassociate from the network to which it's associated.");
5799 break;
5800 #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
5801 case BUFFER: g_snprintf (buffer, sizeof(buffer), "The memory buffer size used while capturing. "
5802 "If you notice packet drops, you can try increasing this size.");
5803 break;
5804 #endif
5805 case FILTER: g_snprintf(buffer, sizeof(buffer), "Selected capture filter to reduce the amount of packets to be captured.");
5806 break;
5807 default: g_snprintf(buffer, sizeof(buffer), "another option");
5808 }
5809
5810 gtk_tooltip_set_markup (tooltip, buffer);
5811 renderer_list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(column));
5812 /* get the first renderer */
5813 if (g_list_first(renderer_list)) {
5814 renderer = (GtkCellRenderer*)g_list_nth_data(renderer_list, 0);
5815 gtk_tree_view_set_tooltip_cell (tree_view, tooltip, path, column, renderer);
5816 }
5817 }
5818 gtk_tree_path_free (path);
5819
5820 return TRUE;
5821 }
5822
5823 #if defined (HAVE_PCAP_CREATE)
5824 static void
5825 activate_monitor(GtkTreeViewColumn *tree_column _U_, GtkCellRenderer *renderer,
5826 GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data _U_)
5827 {
5828 interface_t device;
5829 GtkTreePath *path = gtk_tree_model_get_path(tree_model, iter);
5830 int indx = atoi(gtk_tree_path_to_string(path));
5831
5832 device = g_array_index(global_capture_opts.all_ifaces, interface_t, indx);
5833
5834 if (device.monitor_mode_supported == TRUE) {
5835 g_object_set(G_OBJECT(renderer), "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
5836 } else {
5837 g_object_set(G_OBJECT(renderer), "mode", GTK_CELL_RENDERER_MODE_INERT, NULL);
5838 }
5839 }
5840 #endif
5841
5842 /* user requested to destroy the dialog */
5843 static void
5844 capture_prep_destroy_cb(GtkWidget *win _U_, gpointer user_data _U_)
5845 {
5846 GtkWidget *fs;
5847 #ifdef HAVE_PCAP_REMOTE
5848 GList *if_list;
5849 GtkWidget *remote_w;
5850 #endif
5851
5852 /* Is there a file selection dialog associated with this
5853 Capture Options dialog? */
5854 fs = (GtkWidget *)g_object_get_data(G_OBJECT(cap_open_w), E_FILE_SEL_DIALOG_PTR_KEY);
5855
5856 #ifdef HAVE_PCAP_REMOTE
5857 if_list = (GList *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IF_LIST_KEY);
5858 if (if_list && g_list_length(if_list)>0) {
5859 free_interface_list(if_list);
5860 }
5861 #endif
5862
5863 if (fs != NULL) {
5864 /* Yes. Destroy it. */
5865 window_destroy(fs);
5866 }
5867
5868 /* Note that we no longer have a "Capture Options" dialog box. */
5869 cap_open_w = NULL;
5870
5871 #ifdef HAVE_AIRPCAP
5872 /* update airpcap toolbar */
5873 if (airpcap_if_active)
5874 airpcap_set_toolbar_stop_capture(airpcap_if_active);
5875 #endif
5876
5877 #ifdef HAVE_PCAP_REMOTE
5878 remote_w = g_object_get_data(G_OBJECT(interface_management_w), E_CAP_REMOTE_DIALOG_PTR_KEY);
5879 if (remote_w != NULL)
5880 window_destroy(remote_w);
5881 #endif
5882 }
5883
5884
5885 #ifdef HAVE_PCAP_CREATE
5886 /* user changed the setting of the monitor-mode checkbox */
5887 static void
5888 capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp _U_)
5889 {
5890 GList *lt_entry;
5891 gchar *if_string;
5892 gboolean monitor_mode;
5893 if_capabilities_t *caps;
5894 gint linktype_count = 0, i;
5895 data_link_info_t *data_link_info;
5896 interface_t device;
5897 link_row *linkr;
5898 GtkWidget *linktype_combo_box = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_LT_CBX_KEY);
5899 GtkWidget *linktype_lb = (GtkWidget *)g_object_get_data(G_OBJECT(linktype_combo_box), E_CAP_LT_CBX_LABEL_KEY);
5900
5901 device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_interface);
5902 global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_interface);
5903
5904
5905 if_string = g_strdup(device.name);
5906 monitor_mode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(monitor));
5907 caps = capture_get_if_capabilities(if_string, monitor_mode, NULL, main_window_update);
5908
5909 if (caps != NULL) {
5910 g_signal_handlers_disconnect_by_func(linktype_combo_box, G_CALLBACK(select_link_type_cb), NULL );
5911 ws_combo_box_clear_text_and_pointer(GTK_COMBO_BOX(linktype_combo_box));
5912 for (i = (gint)g_list_length(device.links)-1; i >= 0; i--) {
5913 GList* rem = g_list_nth(device.links, i);
5914 device.links = g_list_remove_link(device.links, rem);
5915 g_list_free_1(rem);
5916 }
5917 device.active_dlt = -1;
5918 linktype_count = 0;
5919 device.monitor_mode_supported = caps->can_set_rfmon;
5920 device.monitor_mode_enabled = monitor_mode;
5921 for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
5922 linkr = (link_row *)g_malloc(sizeof(link_row));
5923 data_link_info = (data_link_info_t *)lt_entry->data;
5924 if (data_link_info->description != NULL) {
5925 ws_combo_box_append_text_and_pointer(GTK_COMBO_BOX(linktype_combo_box),
5926 data_link_info->description,
5927 GINT_TO_POINTER(data_link_info->dlt));
5928 linkr->dlt = data_link_info->dlt;
5929 if (linktype_count == 0) {
5930 device.active_dlt = data_link_info->dlt;
5931 }
5932 linkr->name = g_strdup(data_link_info->description);
5933 } else {
5934 gchar *str;
5935 /* Not supported - tell them about it but don't let them select it. */
5936 str = g_strdup_printf("%s (not supported)", data_link_info->name);
5937 ws_combo_box_append_text_and_pointer_full(GTK_COMBO_BOX(linktype_combo_box),
5938 NULL,
5939 str,
5940 GINT_TO_POINTER(-1), /* Flag as "not supported" */
5941 FALSE);
5942 linkr->dlt = -1;
5943 linkr->name = g_strdup(str);
5944 g_free(str);
5945 }
5946 device.links = g_list_append(device.links, linkr);
5947 linktype_count++;
5948 }
5949 free_if_capabilities(caps);
5950 } else {
5951 /* We don't know whether this supports monitor mode or not;
5952 don't ask for monitor mode. */
5953 device.monitor_mode_enabled = FALSE;
5954 device.monitor_mode_supported = FALSE;
5955 }
5956 gtk_widget_set_sensitive(linktype_lb, linktype_count >= 2);
5957 gtk_widget_set_sensitive(linktype_combo_box, linktype_count >= 2);
5958 ws_combo_box_set_active(GTK_COMBO_BOX(linktype_combo_box),0);
5959 g_array_insert_val(global_capture_opts.all_ifaces, marked_interface, device);
5960 }
5961 #endif
5962
5963 /*
5964 * Adjust the sensitivity of various widgets as per the current setting
5965 * of other widgets.
5966 */
5967 static void
5968 capture_prep_adjust_sensitivity(GtkWidget *tb _U_, gpointer parent_w)
5969 {
5970 GtkWidget *multi_files_on_cb, *ringbuffer_nbf_cb, *ringbuffer_nbf_sb, *ringbuffer_nbf_lb,
5971 *ring_filesize_cb, *ring_filesize_sb, *ring_filesize_cbx,
5972 *file_duration_cb, *file_duration_sb, *file_duration_cbx,
5973 *sync_cb, *auto_scroll_cb,
5974 *stop_packets_cb, *stop_packets_sb, *stop_packets_lb,
5975 *stop_filesize_cb, *stop_filesize_sb, *stop_filesize_cbx,
5976 *stop_duration_cb, *stop_duration_sb, *stop_duration_cbx,
5977 *stop_files_cb, *stop_files_sb, *stop_files_lb;
5978
5979 multi_files_on_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_MULTI_FILES_ON_CB_KEY);
5980 ringbuffer_nbf_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_NBF_CB_KEY);
5981 ringbuffer_nbf_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_NBF_SB_KEY);
5982 ringbuffer_nbf_lb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_NBF_LB_KEY);
5983 ring_filesize_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_FILESIZE_CB_KEY);
5984 ring_filesize_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_FILESIZE_SB_KEY);
5985 ring_filesize_cbx = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_RING_FILESIZE_CBX_KEY);
5986 file_duration_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_DURATION_CB_KEY);
5987 file_duration_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_DURATION_SB_KEY);
5988 file_duration_cbx = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_FILE_DURATION_CBX_KEY);
5989 sync_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SYNC_KEY);
5990 auto_scroll_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_AUTO_SCROLL_KEY);
5991 stop_packets_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_PACKETS_CB_KEY);
5992 stop_packets_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_PACKETS_SB_KEY);
5993 stop_packets_lb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_PACKETS_LB_KEY);
5994 stop_filesize_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILESIZE_CB_KEY);
5995 stop_filesize_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILESIZE_SB_KEY);
5996 stop_filesize_cbx = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILESIZE_CBX_KEY);
5997 stop_duration_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_DURATION_CB_KEY);
5998 stop_duration_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_DURATION_SB_KEY);
5999 stop_duration_cbx = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_DURATION_CBX_KEY);
6000 stop_files_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILES_CB_KEY);
6001 stop_files_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILES_SB_KEY);
6002 stop_files_lb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_STOP_FILES_LB_KEY);
6003
6004 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sync_cb))) {
6005 /* "Update list of packets in real time" captures enabled; we don't
6006 support ring buffer mode for those captures, so turn ring buffer
6007 mode off if it's on, and make its toggle button, and the spin
6008 button for the number of ring buffer files (and the spin button's
6009 label), insensitive. */
6010 #if 0
6011 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(multi_files_on_cb), FALSE);
6012 gtk_widget_set_sensitive(GTK_WIDGET(multi_files_on_cb), FALSE);
6013 #endif
6014
6015 /* Auto-scroll mode is meaningful only in "Update list of packets
6016 in real time" captures, so make its toggle button sensitive. */
6017 gtk_widget_set_sensitive(GTK_WIDGET(auto_scroll_cb), TRUE);
6018
6019 /*gtk_widget_set_sensitive(GTK_WIDGET(hide_info_cb), TRUE);*/
6020 } else {
6021 /* "Update list of packets in real time" captures disabled; that
6022 means ring buffer mode is OK, so make its toggle button
6023 sensitive. */
6024 /* gtk_widget_set_sensitive(GTK_WIDGET(multi_files_on_cb), TRUE);*/
6025
6026 /* Auto-scroll mode is meaningful only in "Update list of packets
6027 in real time" captures, so make its toggle button insensitive. */
6028 gtk_widget_set_sensitive(GTK_WIDGET(auto_scroll_cb), FALSE);
6029
6030 /*gtk_widget_set_sensitive(GTK_WIDGET(hide_info_cb), FALSE);*/
6031 }
6032
6033 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(multi_files_on_cb))) {
6034 /* Ring buffer mode enabled. */
6035
6036 /* Force at least one of the "file switch" conditions (we need at least one) */
6037 if ((gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ring_filesize_cb)) == FALSE) &&
6038 (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(file_duration_cb)) == FALSE)) {
6039 if (tb == ring_filesize_cb)
6040 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(file_duration_cb), TRUE);
6041 else
6042 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ring_filesize_cb), TRUE);
6043 }
6044
6045 gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_cb), TRUE);
6046 gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_sb),
6047 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ringbuffer_nbf_cb)));
6048 gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_lb),
6049 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ringbuffer_nbf_cb)));
6050
6051 /* The ring filesize spinbox is sensitive if the "Next capture file
6052 after N kilobytes" checkbox is on. */
6053 gtk_widget_set_sensitive(GTK_WIDGET(ring_filesize_cb), TRUE);
6054 gtk_widget_set_sensitive(GTK_WIDGET(ring_filesize_sb),
6055 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ring_filesize_cb)));
6056 gtk_widget_set_sensitive(GTK_WIDGET(ring_filesize_cbx),
6057 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ring_filesize_cb)));
6058
6059 /* The ring duration spinbox is sensitive if the "Next capture file
6060 after N seconds" checkbox is on. */
6061 gtk_widget_set_sensitive(GTK_WIDGET(file_duration_cb), TRUE);
6062 gtk_widget_set_sensitive(GTK_WIDGET(file_duration_sb),
6063 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(file_duration_cb)));
6064 gtk_widget_set_sensitive(GTK_WIDGET(file_duration_cbx),
6065 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(file_duration_cb)));
6066
6067 gtk_widget_set_sensitive(GTK_WIDGET(stop_filesize_cb), FALSE);
6068 gtk_widget_set_sensitive(GTK_WIDGET(stop_filesize_sb), FALSE);
6069 gtk_widget_set_sensitive(GTK_WIDGET(stop_filesize_cbx), FALSE);
6070
6071 gtk_widget_set_sensitive(GTK_WIDGET(stop_files_cb), TRUE);
6072 gtk_widget_set_sensitive(GTK_WIDGET(stop_files_sb),
6073 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_files_cb)));
6074 gtk_widget_set_sensitive(GTK_WIDGET(stop_files_lb),
6075 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_files_cb)));
6076 } else {
6077 /* Ring buffer mode disabled. */
6078 gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_cb), FALSE);
6079 gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_sb), FALSE);
6080 gtk_widget_set_sensitive(GTK_WIDGET(ringbuffer_nbf_lb), FALSE);
6081
6082 gtk_widget_set_sensitive(GTK_WIDGET(ring_filesize_cb), FALSE);
6083 gtk_widget_set_sensitive(GTK_WIDGET(ring_filesize_sb),FALSE);
6084 gtk_widget_set_sensitive(GTK_WIDGET(ring_filesize_cbx),FALSE);
6085
6086 gtk_widget_set_sensitive(GTK_WIDGET(file_duration_cb), FALSE);
6087 gtk_widget_set_sensitive(GTK_WIDGET(file_duration_sb),FALSE);
6088 gtk_widget_set_sensitive(GTK_WIDGET(file_duration_cbx),FALSE);
6089
6090 /* The maximum file size spinbox is sensitive if the "Stop capture
6091 after N kilobytes" checkbox is on. */
6092 gtk_widget_set_sensitive(GTK_WIDGET(stop_filesize_cb), TRUE);
6093 gtk_widget_set_sensitive(GTK_WIDGET(stop_filesize_sb),
6094 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_filesize_cb)));
6095 gtk_widget_set_sensitive(GTK_WIDGET(stop_filesize_cbx),
6096 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_filesize_cb)));
6097
6098 gtk_widget_set_sensitive(GTK_WIDGET(stop_files_cb), FALSE);
6099 gtk_widget_set_sensitive(GTK_WIDGET(stop_files_sb), FALSE);
6100 gtk_widget_set_sensitive(GTK_WIDGET(stop_files_lb), FALSE);
6101 }
6102
6103 /* The maximum packet count spinbox is sensitive if the "Stop capture
6104 after N packets" checkbox is on. */
6105 gtk_widget_set_sensitive(GTK_WIDGET(stop_packets_sb),
6106 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_packets_cb)));
6107 gtk_widget_set_sensitive(GTK_WIDGET(stop_packets_lb),
6108 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_packets_cb)));
6109
6110 /* The capture duration spinbox is sensitive if the "Stop capture
6111 after N seconds" checkbox is on. */
6112 gtk_widget_set_sensitive(GTK_WIDGET(stop_duration_sb),
6113 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_duration_cb)));
6114 gtk_widget_set_sensitive(GTK_WIDGET(stop_duration_cbx),
6115 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(stop_duration_cb)));
6116 }
6117
6118 gboolean capture_dlg_window_present(void)
6119 {
6120 return (cap_open_w?TRUE:FALSE);
6121 }
6122
6123 /*
6124 * Refresh everything visible that shows an interface list that
6125 * includes local interfaces.
6126 */
6127 void
6128 refresh_local_interface_lists(void)
6129 {
6130 /* Reload the local interface list. */
6131 scan_local_interfaces(main_window_update);
6132
6133 /* If there's an interfaces dialog up, refresh it. */
6134 if (interfaces_dialog_window_present())
6135 refresh_if_window();
6136
6137 /* If there's a capture options dialog up, refresh it. */
6138 if (capture_dlg_window_present())
6139 capture_dlg_refresh_if();
6140
6141 /* If the welcome screen is up, refresh its interface list. */
6142 if (get_welcome_window() != NULL)
6143 welcome_if_panel_reload();
6144
6145 /* Refresh the 802.11 toolbar. */
6146 tb80211_refresh_interfaces();
6147 }
6148
6149 /*
6150 * Refresh everything visible that shows an interface list that
6151 * includes non-local interfaces.
6152 */
6153 void
6154 refresh_non_local_interface_lists(void)
6155 {
6156 /* If there's a capture options dialog up, refresh it. */
6157 if (capture_dlg_window_present())
6158 capture_dlg_refresh_if();
6159
6160 /* If the welcome screen is up, refresh its interface list. */
6161 if (get_welcome_window() != NULL)
6162 welcome_if_panel_reload();
6163 }
6164
6165 #endif /* HAVE_LIBPCAP */
6166
6167 /*
6168 * Editor modelines
6169 *
6170 * Local Variables:
6171 * c-basic-offset: 2
6172 * tab-width: 8
6173 * indent-tabs-mode: nil
6174 * End:
6175 *
6176 * ex: set shiftwidth=2 tabstop=8 expandtab:
6177 * :indentSize=2:tabSize=8:noTabs=true:
6178 */