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