ui/gtk/capture_dlg.c

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