ui/gtk/capture_dlg.c

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