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