Back out infrastructure change. We missed supporting

stdin and pipes. svn path=/trunk/; revision=39498
author: Michael Tüxen <tuexen@fh-muenster.de> 2011-10-20 19:44:40 +0000
committer: Michael Tüxen <tuexen@fh-muenster.de> 2011-10-20 19:44:40 +0000
commit: c219f2eea54ef19c811bc1294416fb6b30a046f8 (patch)
tree: cced8090a0b70bd451688295b593f651386440d4
parent: 3c1f16f904b786a6e98325362ae95b80ac41819f (diff)
15 files changed, 1483 insertions, 1197 deletions
diff --git a/capture.c b/capture.c
index 911a6c8a44..22bab8dd94 100644
--- a/capture.c
+++ b/capture.c
@@ -143,7 +143,6 @@ capture_start(capture_options *capture_opts)
   /* close the currently loaded capture file */
   cf_close(capture_opts->cf);
 
-  collect_ifaces(capture_opts);
   g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Start ...");
 
 #ifdef _WIN32
@@ -652,9 +651,6 @@ capture_input_closed(capture_options *capture_opts, gchar *msg)
         }
 
         /* ... and start the capture again */
-        if (capture_opts->ifaces->len == 0) {
-            collect_ifaces(capture_opts);
-        }
         capture_start(capture_opts);
     } else {
         /* We're not doing a capture any more, so we don't have a save file. */
@@ -664,13 +660,13 @@ capture_input_closed(capture_options *capture_opts, gchar *msg)
 }
 
 if_stat_cache_t *
-capture_stat_start(capture_options *capture_opts) {
+capture_stat_start(GList *if_list) {
     int stat_fd, fork_child;
     gchar *msg;
     if_stat_cache_t *sc = NULL;
+    GList *if_entry;
+    if_info_t *if_info;
     if_stat_cache_item_t *sc_item;
-    guint i;
-    interface_t device;
 
     /* Fire up dumpcap. */
     /*
@@ -698,11 +694,11 @@ capture_stat_start(capture_options *capture_opts) {
         sc->cache_list = NULL;
 
         /* Initialize the cache */
-        for (i = 0; i < capture_opts->all_ifaces->len; i++) {
-            device = g_array_index(capture_opts->all_ifaces, interface_t, i);
-            if (&(device.if_info)) {
+        for (if_entry = if_list; if_entry != NULL; if_entry = g_list_next(if_entry)) {
+            if_info = if_entry->data;
+            if (if_info) {
                 sc_item = g_malloc0(sizeof(if_stat_cache_item_t));
-                sc_item->name = g_strdup(device.if_info.name);
+                sc_item->name = g_strdup(if_info->name);
                 sc->cache_list = g_list_append(sc->cache_list, sc_item);
             }
         }
diff --git a/capture.h b/capture.h
index a9f1f08b49..a09829d58e 100644
--- a/capture.h
+++ b/capture.h
@@ -110,7 +110,7 @@ typedef struct if_stat_cache_s if_stat_cache_t;
  * @param if_list A GList of if_info_t items
  * @return A pointer to the statistics state data.
  */
-extern if_stat_cache_t * capture_stat_start(capture_options *capture_opts);
+extern if_stat_cache_t * capture_stat_start(GList *if_list);
 
 /**
  * Fetch capture statistics, similar to pcap_stats().
diff --git a/capture_opts.c b/capture_opts.c
index cbfe1b9aa5..8f7325e1ea 100644
--- a/capture_opts.c
+++ b/capture_opts.c
@@ -38,9 +38,6 @@
 #include <glib.h>
 
 #include <epan/packet.h>
-#include <epan/prefs.h>
-#include "simple_dialog.h"
-#include "capture_ui_utils.h"
 
 #include "capture_opts.h"
 #include "ringbuffer.h"
@@ -60,8 +57,6 @@ capture_opts_init(capture_options *capture_opts, void *cf)
 {
   capture_opts->cf                              = cf;
   capture_opts->ifaces                          = g_array_new(FALSE, FALSE, sizeof(interface_options));
-  capture_opts->all_ifaces                      = g_array_new(FALSE, FALSE, sizeof(interface_t));
-  capture_opts->num_selected                    = 0;
   capture_opts->default_options.name            = NULL;
   capture_opts->default_options.descr           = NULL;
   capture_opts->default_options.cfilter         = NULL;
@@ -527,83 +522,7 @@ capture_opts_add_iface_opt(capture_options *capture_opts, const char *optarg_str
 #endif
 
     g_array_append_val(capture_opts->ifaces, interface_opts);
-    return 0;
-}
-
-int
-capture_opts_select_iface(capture_options *capture_opts, const char *optarg_str_p)
-{
-    long        adapter_index;
-    char        *p;
-    GList       *if_list;
-    if_info_t   *if_info;
-    int         err;
-    guint       i;
-    gchar       *err_str, *name = NULL;
-    interface_t device;
-
-    /*
-     * If the argument is a number, treat it as an index into the list
-     * of adapters, as printed by "tshark -D".
-     *
-     * This should be OK on UNIX systems, as interfaces shouldn't have
-     * names that begin with digits.  It can be useful on Windows, where
-     * more than one interface can have the same name.
-     */
-    adapter_index = strtol(optarg_str_p, &p, 10);
-    if (p != NULL && *p == '\0') {
-        if (adapter_index < 0) {
-            cmdarg_err("The specified adapter index is a negative number");
-            return 1;
-        }
-        if (adapter_index > INT_MAX) {
-            cmdarg_err("The specified adapter index is too large (greater than %d)",
-                       INT_MAX);
-            return 1;
-        }
-        if (adapter_index == 0) {
-            cmdarg_err("There is no interface with that adapter index");
-            return 1;
-        }
-        if_list = capture_interface_list(&err, &err_str);
-        if (if_list == NULL) {
-            switch (err) {
 
-            case CANT_GET_INTERFACE_LIST:
-                cmdarg_err("%s", err_str);
-                g_free(err_str);
-                break;
-
-            case NO_INTERFACES_FOUND:
-                cmdarg_err("There are no interfaces on which a capture can be done");
-                break;
-            }
-            return 2;
-        }
-        if_info = (if_info_t *)g_list_nth_data(if_list, adapter_index - 1);
-        if (if_info == NULL) {
-            cmdarg_err("There is no interface with that adapter index");
-            return 1;
-        }
-        name = g_strdup(if_info->name);
-        /*  We don't set iface_descr here because doing so requires
-         *  capture_ui_utils.c which requires epan/prefs.c which is
-         *  probably a bit too much dependency for here...
-         */
-        free_interface_list(if_list);
-    } else {
-        name = g_strdup(optarg_str_p);
-    }
-    for(i = 0; i < capture_opts->all_ifaces->len; i++) {
-        device = g_array_index(capture_opts->all_ifaces, interface_t, i);
-        if (strcmp(device.name, name) == 0) {
-            device.selected = TRUE;
-            capture_opts->num_selected++;
-            capture_opts->all_ifaces = g_array_remove_index(capture_opts->all_ifaces, i);
-            g_array_insert_val(capture_opts->all_ifaces, i, device);
-            break;
-        }
-    } 
     return 0;
 }
 
@@ -907,7 +826,7 @@ gboolean capture_opts_trim_iface(capture_options *capture_opts, const char *capt
 
 
     /* Did the user specify an interface to use? */
-    if (capture_opts->num_selected == 0 && capture_opts->ifaces->len == 0) {
+    if (capture_opts->ifaces->len == 0) {
         /* No - is a default specified in the preferences file? */
         if (capture_device != NULL) {
             /* Yes - use it. */
@@ -1038,49 +957,4 @@ static gboolean capture_opts_output_to_pipe(const char *save_file, gboolean *is_
   return 0;
 }
 
-void
-collect_ifaces(capture_options *capture_opts)
-{
-  guint i;
-  interface_t device;
-  interface_options interface_opts;
-  for (i = 0; i < capture_opts->all_ifaces->len; i++) {
-    device = g_array_index(capture_opts->all_ifaces, interface_t, i);
-    if (device.selected) {
-      interface_opts.name = g_strdup(device.name);
-      interface_opts.descr = g_strdup(device.display_name);
-      interface_opts.monitor_mode = device.monitor_mode_enabled;
-      interface_opts.linktype = device.active_dlt;
-      interface_opts.cfilter = g_strdup(device.cfilter);
-      interface_opts.snaplen = device.snaplen;
-      interface_opts.has_snaplen = device.has_snaplen;
-      interface_opts.promisc_mode = device.pmode;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
-      interface_opts.buffer_size =  device.buffer;
-#endif
-      if (device.type == IF_REMOTE) {
-#ifdef HAVE_PCAP_REMOTE 
-        interface_opts.src_type = device.type;
-        interface_opts.remote_host = g_strdup(device.remote_opts.remote_host_opts.remote_host);
-        interface_opts.remote_port = g_strdup(device.remote_opts.remote_host_opts.remote_port);
-        interface_opts.auth_type = device.remote_opts.remote_host_opts.auth_type;
-        interface_opts.auth_username = g_strdup(device.remote_opts.remote_host_opts.auth_username);
-        interface_opts.auth_password = g_strdup(device.remote_opts.remote_host_opts.auth_password);
-        interface_opts.datatx_udp = device.remote_opts.remote_host_opts.datatx_udp;
-        interface_opts.nocap_rpcap = device.remote_opts.remote_host_opts.nocap_rpcap;
-        interface_opts.nocap_local = device.remote_opts.remote_host_opts.nocap_local;
-#endif
-#ifdef HAVE_PCAP_SETSAMPLING
-        interface_opts.sampling_method = device.remote_opts.sampling_method;
-        interface_opts.sampling_param  = device.remote_opts.sampling_param;
-#endif
-      }
-      g_array_append_val(capture_opts->ifaces, interface_opts);
-    } else {
-      continue;
-    }
-  }
-}
-
-
 #endif /* HAVE_LIBPCAP */
diff --git a/capture_opts.h b/capture_opts.h
index ed39f25f80..7778bf49af 100644
--- a/capture_opts.h
+++ b/capture_opts.h
@@ -73,66 +73,6 @@ typedef enum {
 } capture_sampling;
 #endif
 
-typedef enum {
-	IF_LOCAL,
-	IF_REMOTE,
-	IF_AIRPCAP
-} interface_type;
-
-#ifdef HAVE_PCAP_REMOTE
-struct remote_host {
-    gchar *remote_host;          /**< Host name or network address for remote capturing */
-    gchar *remote_port;          /**< TCP port of remote RPCAP server */
-    gint auth_type;              /**< Authentication type */
-    gchar *auth_username;        /**< Remote authentication parameters */
-    gchar *auth_password;        /**< Remote authentication parameters */
-    gboolean datatx_udp;
-    gboolean nocap_rpcap;
-    gboolean nocap_local;
-};
-
-typedef struct remote_options_tag {
-    capture_source src_type;
-    struct remote_host remote_host_opts;
-#ifdef HAVE_PCAP_SETSAMPLING
-    capture_sampling sampling_method;
-    int sampling_param;
-#endif
-} remote_options;
-#endif /* HAVE_PCAP_REMOTE */
-
-typedef struct interface_tag {
-    gchar *name;
-    gchar *display_name;
-    guint type;
-    gchar *addresses;
-    gint no_addresses;
-    gchar *cfilter;
-    GList *links;
-    gint active_dlt;
-    gboolean pmode;
-    gboolean has_snaplen;
-    guint snaplen;
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
-    gint buffer;
-    gboolean monitor_mode_enabled;
-    gboolean monitor_mode_supported;
-#endif
-#ifdef HAVE_PCAP_REMOTE
-    remote_options remote_opts;
-#endif
-    guint32     last_packets;
-    if_info_t   if_info;
-    gboolean    selected;
-    gboolean    hidden;
-    gboolean    locked;
-} interface_t;
-
-typedef struct link_row_tag {
-    gchar *name;
-    gint dlt;
-} link_row;
-
 typedef struct interface_options_tag {
     gchar *name;
     gchar *descr;
@@ -168,8 +108,6 @@ typedef struct capture_options_tag {
     void     *cf;                   /**< handle to cfile (note: untyped handle) */
     GArray   *ifaces;               /**< array of interfaces.
                                          Currently only used by dumpcap. */
-    GArray   *all_ifaces;
-    guint    num_selected;
     interface_options default_options;
     gboolean saving_to_file;        /**< TRUE if capture is writing to a file */
     gchar    *save_file;            /**< the capture file name */
@@ -252,25 +190,4 @@ capture_opts_trim_ring_num_files(capture_options *capture_opts);
 extern gboolean
 capture_opts_trim_iface(capture_options *capture_opts, const char *capture_device);
 
-extern void
-collect_ifaces(capture_options *capture_opts);
-
-typedef struct {
-    gboolean monitor_mode;
-    int linktype;
-} cap_settings_t;
-
-/** Get capture settings for interface
- *
- * @param if_name interface name
- */
-cap_settings_t
-capture_get_cap_settings (gchar *if_name);
-
-extern void 
-scan_local_interfaces(capture_options* capture_opts);
-
-int
-capture_opts_select_iface(capture_options *capture_opts, const char *optarg_str_p);
-
 #endif /* capture_opts.h */
diff --git a/capture_sync.c b/capture_sync.c
index 5e66da0187..bf0272bbaf 100644
--- a/capture_sync.c
+++ b/capture_sync.c
@@ -461,11 +461,9 @@ sync_pipe_start(capture_options *capture_opts) {
         }
 #endif
 
-#ifdef HAVE_PCAP_CREATE
         if (interface_opts.monitor_mode) {
             argv = sync_pipe_add_arg(argv, &argc, "-I");
         }
-#endif
 
 #ifdef HAVE_PCAP_REMOTE
         if (interface_opts.datatx_udp)
diff --git a/capture_ui_utils.c b/capture_ui_utils.c
index e58f789b03..1ebe978c68 100644
--- a/capture_ui_utils.c
+++ b/capture_ui_utils.c
@@ -38,9 +38,6 @@
 #include "epan/ex-opt.h"
 #include "capture_ifinfo.h"
 #include "capture_ui_utils.h"
-#include "simple_dialog.h"
-#include "wiretap/wtap.h"
-#include "epan/to_str.h"
 
 /*
  * Find user-specified capture device description that matches interface
diff --git a/gtk/capture_dlg.c b/gtk/capture_dlg.c
index 6901359302..6980a1779e 100644
--- a/gtk/capture_dlg.c
+++ b/gtk/capture_dlg.c
@@ -184,6 +184,8 @@ static GtkWidget *cap_open_w = NULL, *opt_edit_w = NULL, *ok_bt;
 static gboolean   cap_open_complete;  /* valid only if cap_open_w != NULL */
 
 static GHashTable *cap_settings_history=NULL;
+static gint16 num_selected;
+static GArray *rows = NULL;
 static gint marked_row;
 
 #ifdef HAVE_PCAP_REMOTE
@@ -218,6 +220,9 @@ capture_dlg_prep(gpointer parent_w);
 
 extern gint if_list_comparator_alph (const void *first_arg, const void *second_arg);
 
+static void
+make_and_fill_rows(void);
+
 /* stop the currently running capture */
 void
 capture_stop_cb(GtkWidget *w _U_, gpointer d _U_)
@@ -811,7 +816,7 @@ error_list_remote_interface_cb (gpointer dialog _U_, gint btn _U_, gpointer data
 
 void insert_new_rows(GList *list)
 {
-  interface_t device;
+  interface_row row;
   GtkTreeIter iter;
   GList *if_entry;
   if_info_t *if_info;
@@ -822,7 +827,7 @@ void insert_new_rows(GList *list)
   cap_settings_t cap_settings;
   GSList *curr_addr;
   int ips = 0;
-  guint i;
+  guint i, count=0;
   if_addr_t *addr;
   GList *lt_entry;
   data_link_info_t *data_link_info;
@@ -831,19 +836,21 @@ void insert_new_rows(GList *list)
   GString *ip_str;
   GtkTreeView  *if_cb;
   GtkTreeModel *model;
+  interface_options interface_opts;
   link_row *link = NULL;
 
   if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
   model = gtk_tree_view_get_model(if_cb);
+  count = rows->len;
   /* Scan through the list and build a list of strings to display. */
   for (if_entry = g_list_first(list); if_entry != NULL; if_entry = g_list_next(if_entry)) {
     if_info = if_entry->data;
 #ifdef HAVE_PCAP_REMOTE
     add_interface_to_remote_list(if_info);
 #endif
-    for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-      device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-      if (strcmp(device.name, if_info->name) == 0) {
+    for (i = 0; i < count; i++) {
+      row = g_array_index(rows, interface_row, i);
+      if (strcmp(row.name, if_info->name) == 0) {
         found = TRUE;
         break;
       }
@@ -855,7 +862,7 @@ void insert_new_rows(GList *list)
     ip_str = g_string_new("");
     str = "";
     ips = 0;
-    device.name = g_strdup(if_info->name);
+    row.name = g_strdup(if_info->name);
     /* Is this interface hidden and, if so, should we include it
        anyway? */
     descr = capture_dev_user_descr_find(if_info->name);
@@ -875,17 +882,37 @@ void insert_new_rows(GList *list)
       }
     } /* else descr != NULL */
     if (if_info->loopback) {
-      device.display_name = g_strdup_printf("%s (loopback)", if_string);
+      row.display_name = g_strdup_printf("%s (loopback)", if_string);
     } else {
-      device.display_name = g_strdup(if_string);
+      row.display_name = g_strdup(if_string);
     }
+    found = FALSE;
+    for (i = 0; i < global_capture_opts.ifaces->len; i++) {
+      interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
+      if (strcmp(interface_opts.name, (char*)row.name)!=0)
+        continue;
+      else {
+        found = TRUE;
+        break;
+      }
+    }
+    if (found) {
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+      row.buffer = interface_opts.buffer_size;
+#endif
+      row.pmode = interface_opts.promisc_mode;
+      row.has_snaplen = interface_opts.has_snaplen;
+      row.snaplen = interface_opts.snaplen;
+      row.cfilter = g_strdup(interface_opts.cfilter);
+    } else {
 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
-    device.buffer = global_capture_opts.default_options.buffer_size;
+      row.buffer = global_capture_opts.default_options.buffer_size;
 #endif
-    device.pmode = global_capture_opts.default_options.promisc_mode;
-    device.has_snaplen = global_capture_opts.default_options.has_snaplen;
-    device.snaplen = global_capture_opts.default_options.snaplen;
-    device.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
+      row.pmode = global_capture_opts.default_options.promisc_mode;
+      row.has_snaplen = global_capture_opts.default_options.has_snaplen;
+      row.snaplen = global_capture_opts.default_options.snaplen;
+      row.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
+    }
     cap_settings = capture_get_cap_settings(if_string);
     caps = capture_get_if_capabilities(if_string, cap_settings.monitor_mode, NULL);
     gtk_list_store_append (GTK_LIST_STORE(model), &iter);
@@ -908,11 +935,11 @@ void insert_new_rows(GList *list)
       }
     } /* for curr_addr */
     linktype_count = 0;
-    device.links = NULL;
+    row.links = NULL;
     if (caps != NULL) {
 #ifdef HAVE_PCAP_CREATE
-      device.monitor_mode_enabled = cap_settings.monitor_mode;
-      device.monitor_mode_supported = caps->can_set_rfmon;
+      row.monitor_mode_enabled = cap_settings.monitor_mode;
+      row.monitor_mode_supported = caps->can_set_rfmon;
 #endif
       for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
         data_link_info = lt_entry->data;
@@ -923,62 +950,63 @@ void insert_new_rows(GList *list)
         }
         if (linktype_count == 0) {
           link_type_name = g_strdup(str);
-          device.active_dlt = data_link_info->dlt;
+          row.active_dlt = data_link_info->dlt;
         }
         link = (link_row *)g_malloc(sizeof(link_row));
         link->dlt = data_link_info->dlt;
         link->name = g_strdup(str);
-        device.links = g_list_append(device.links, link);
+        row.links = g_list_append(row.links, link);
         linktype_count++;
       } /* for link_types */
     } else {
       cap_settings.monitor_mode = FALSE;
 #if defined(HAVE_PCAP_CREATE)
-      device.monitor_mode_enabled = FALSE;
-      device.monitor_mode_supported = FALSE;
+      row.monitor_mode_enabled = FALSE;
+      row.monitor_mode_supported = FALSE;
 #endif
-      device.active_dlt = -1;
+      row.active_dlt = -1;
       link_type_name = g_strdup("default");
     }
-    device.addresses = g_strdup(ip_str->str);
-    device.no_addresses = ips;
+    row.addresses = g_strdup(ip_str->str);
+    row.no_addresses = ips;
     if (ips == 0) {
-      temp = g_strdup_printf("<b>%s</b>", device.display_name);
+      temp = g_strdup_printf("<b>%s</b>", row.display_name);
     } else {
-      temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", device.display_name, device.addresses);
+      temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", row.display_name, row.addresses);
     }
 #ifdef HAVE_PCAP_REMOTE
-    device.remote_opts.src_type= global_remote_opts.src_type;
-    device.remote_opts.remote_host_opts.remote_host = g_strdup(global_remote_opts.remote_host_opts.remote_host);
-    device.remote_opts.remote_host_opts.remote_port = g_strdup(global_remote_opts.remote_host_opts.remote_port);
-    device.remote_opts.remote_host_opts.auth_type = global_remote_opts.remote_host_opts.auth_type;
-    device.remote_opts.remote_host_opts.auth_username = g_strdup(global_remote_opts.remote_host_opts.auth_username);
-    device.remote_opts.remote_host_opts.auth_password = g_strdup(global_remote_opts.remote_host_opts.auth_password);
-    device.remote_opts.remote_host_opts.datatx_udp = global_remote_opts.remote_host_opts.datatx_udp;
-    device.remote_opts.remote_host_opts.nocap_rpcap = global_remote_opts.remote_host_opts.nocap_rpcap;
-    device.remote_opts.remote_host_opts.nocap_local = global_remote_opts.remote_host_opts.nocap_local;
+    row.remote_opts.src_type= global_remote_opts.src_type;
+    row.remote_opts.remote_host_opts.remote_host = g_strdup(global_remote_opts.remote_host_opts.remote_host);
+    row.remote_opts.remote_host_opts.remote_port = g_strdup(global_remote_opts.remote_host_opts.remote_port);
+    row.remote_opts.remote_host_opts.auth_type = global_remote_opts.remote_host_opts.auth_type;
+    row.remote_opts.remote_host_opts.auth_username = g_strdup(global_remote_opts.remote_host_opts.auth_username);
+    row.remote_opts.remote_host_opts.auth_password = g_strdup(global_remote_opts.remote_host_opts.auth_password);
+    row.remote_opts.remote_host_opts.datatx_udp = global_remote_opts.remote_host_opts.datatx_udp;
+    row.remote_opts.remote_host_opts.nocap_rpcap = global_remote_opts.remote_host_opts.nocap_rpcap;
+    row.remote_opts.remote_host_opts.nocap_local = global_remote_opts.remote_host_opts.nocap_local;
 #endif
 #ifdef HAVE_PCAP_SETSAMPLING
-    device.remote_opts.sampling_method = global_remote_opts.sampling_method;
-    device.remote_opts.sampling_param = global_remote_opts.sampling_param;
+    row.remote_opts.sampling_method = global_remote_opts.sampling_method;
+    row.remote_opts.sampling_param = global_remote_opts.sampling_param;
 #endif
-    g_array_append_val(global_capture_opts.all_ifaces, device);
-    if (device.has_snaplen) {
-      snaplen_string = g_strdup_printf("%d", device.snaplen);
+    g_array_append_val(rows, row);
+    if (row.has_snaplen) {
+      snaplen_string = g_strdup_printf("%d", row.snaplen);
     } else {
       snaplen_string = g_strdup("default");
     }
 
 #if defined(HAVE_PCAP_CREATE)
-    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, (guint) global_capture_opts.default_options.buffer_size, MONITOR, "no",FILTER, "",-1);
+    gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, INTERFACE, temp, LINK, link_type_name, PMODE, (row.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, (guint) global_capture_opts.default_options.buffer_size, MONITOR, "no",FILTER, "",-1);
 #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
-    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, (guint) global_capture_opts.default_options.buffer_size, FILTER, "",-1);
+    gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, INTERFACE, temp, LINK, link_type_name, PMODE, (row.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, BUFFER, (guint) global_capture_opts.default_options.buffer_size, FILTER, "",-1);
  #else
-    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);
+    gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, FALSE, INTERFACE, temp, LINK, link_type_name, PMODE, (row.pmode?"enabled":"disabled"), SNAPLEN, snaplen_string, -1);
 #endif
+    count++;
     g_string_free(ip_str, TRUE);
 #ifdef HAVE_PCAP_REMOTE
-    add_interface_to_list(global_capture_opts.all_ifaces->len-1);
+    add_interface_to_list(if_info->name, if_info->description, &row.remote_opts);
 #endif
   } /*for*/
   gtk_tree_view_set_model(GTK_TREE_VIEW(if_cb), model);
@@ -1304,19 +1332,19 @@ options_remote_ok_cb(GtkWidget *win _U_, GtkWidget *parent_w)
   GtkWidget *samp_none_rb, *samp_count_rb, *samp_timer_rb,
             *samp_count_sb, *samp_timer_sb;
 #endif
-  interface_t device;
+  interface_row row;
 
   if (parent_w == NULL)
     return;
 
-  device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
-  g_array_remove_index(global_capture_opts.all_ifaces, marked_row);
+  row = g_array_index(rows, interface_row, marked_row);
+  g_array_remove_index(rows, marked_row);
   datatx_udp_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_DATATX_UDP_CB_KEY);
   nocap_rpcap_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_NOCAP_RPCAP_CB_KEY);
 
-  device.remote_opts.remote_host_opts.datatx_udp =
+  row.remote_opts.remote_host_opts.datatx_udp =
     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(datatx_udp_cb));
-  device.remote_opts.remote_host_opts.nocap_rpcap =
+  row.remote_opts.remote_host_opts.nocap_rpcap =
     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(nocap_rpcap_cb));
 
 #ifdef HAVE_PCAP_SETSAMPLING
@@ -1327,16 +1355,16 @@ options_remote_ok_cb(GtkWidget *win _U_, GtkWidget *parent_w)
   samp_timer_sb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_SAMP_TIMER_SB_KEY);
 
   if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_none_rb)))
-    device.remote_opts.sampling_method = CAPTURE_SAMP_NONE;
+    row.remote_opts.sampling_method = CAPTURE_SAMP_NONE;
   else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_count_rb))) {
-    device.remote_opts.sampling_method = CAPTURE_SAMP_BY_COUNT;
-    device.remote_opts.sampling_param = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(samp_count_sb));
+    row.remote_opts.sampling_method = CAPTURE_SAMP_BY_COUNT;
+    row.remote_opts.sampling_param = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(samp_count_sb));
   } else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(samp_timer_rb))) {
-    device.remote_opts.sampling_method = CAPTURE_SAMP_BY_TIMER;
-    device.remote_opts.sampling_param = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(samp_timer_sb));
+    row.remote_opts.sampling_method = CAPTURE_SAMP_BY_TIMER;
+    row.remote_opts.sampling_param = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(samp_timer_sb));
   }
 #endif /* HAVE_PCAP_SETSAMPLING*/
-  g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device);
+  g_array_insert_val(rows, marked_row, row);
   window_destroy(GTK_WIDGET(parent_w));
 }
 #endif /*HAVE_PCAP_REMOTE*/
@@ -1378,7 +1406,7 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_)
   GtkAdjustment *samp_count_adj, *samp_timer_adj;
   GSList        *samp_group;
 #endif
-  interface_t device;
+  interface_row row;
 
   caller = gtk_widget_get_toplevel(w);
   opt_remote_w = g_object_get_data(G_OBJECT(caller), E_OPT_REMOTE_DIALOG_PTR_KEY);
@@ -1387,7 +1415,7 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_)
     return;
   }
 
-  device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
+  row = g_array_index(rows, interface_row, marked_row);
   opt_remote_w = dlg_window_new("Remote Capture Settings");
   g_object_set_data(G_OBJECT(opt_remote_w), E_OPT_REMOTE_CALLER_PTR_KEY, caller);
   g_object_set_data(G_OBJECT(caller), E_OPT_REMOTE_DIALOG_PTR_KEY, opt_remote_w);
@@ -1406,12 +1434,12 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_)
 
   nocap_rpcap_cb = gtk_check_button_new_with_mnemonic("Do not capture own RPCAP traffic");
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(nocap_rpcap_cb),
-          device.remote_opts.remote_host_opts.nocap_rpcap);
+          row.remote_opts.remote_host_opts.nocap_rpcap);
   gtk_container_add(GTK_CONTAINER(capture_vb), nocap_rpcap_cb);
 
   datatx_udp_cb = gtk_check_button_new_with_mnemonic("Use UDP for data transfer");
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(datatx_udp_cb),
-          device.remote_opts.remote_host_opts.datatx_udp);
+          row.remote_opts.remote_host_opts.datatx_udp);
   gtk_container_add(GTK_CONTAINER(capture_vb), datatx_udp_cb);
 
 #ifdef HAVE_PCAP_SETSAMPLING
@@ -1430,7 +1458,7 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_)
 
   /* "No sampling" row */
   samp_none_rb = gtk_radio_button_new_with_label(NULL, "None");
-  if (device.remote_opts.sampling_method == CAPTURE_SAMP_NONE)
+  if (row.remote_opts.sampling_method == CAPTURE_SAMP_NONE)
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(samp_none_rb), TRUE);
   g_signal_connect(samp_none_rb, "toggled",
                  G_CALLBACK(options_prep_adjust_sensitivity), opt_remote_w);
@@ -1439,14 +1467,14 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_)
   /* "Sampling by counter" row */
   samp_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(samp_none_rb));
   samp_count_rb = gtk_radio_button_new_with_label(samp_group, "1 of");
-  if (device.remote_opts.sampling_method == CAPTURE_SAMP_BY_COUNT)
+  if (row.remote_opts.sampling_method == CAPTURE_SAMP_BY_COUNT)
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(samp_count_rb), TRUE);
   g_signal_connect(samp_count_rb, "toggled",
                  G_CALLBACK(options_prep_adjust_sensitivity), opt_remote_w);
   gtk_table_attach_defaults(GTK_TABLE(sampling_tb), samp_count_rb, 0, 1, 1, 2);
 
   samp_count_adj = (GtkAdjustment *) gtk_adjustment_new(
-                        (gfloat)device.remote_opts.sampling_param,
+                        (gfloat)row.remote_opts.sampling_param,
                         1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
   samp_count_sb = gtk_spin_button_new(samp_count_adj, 0, 0);
   gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(samp_count_sb), TRUE);
@@ -1459,14 +1487,14 @@ options_remote_cb(GtkWidget *w _U_, gpointer d _U_)
   /* "Sampling by timer" row */
   samp_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(samp_count_rb));
   samp_timer_rb = gtk_radio_button_new_with_label(samp_group, "1 every");
-  if (device.remote_opts.sampling_method == CAPTURE_SAMP_BY_TIMER)
+  if (row.remote_opts.sampling_method == CAPTURE_SAMP_BY_TIMER)
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(samp_timer_rb), TRUE);
   g_signal_connect(samp_timer_rb, "toggled",
                  G_CALLBACK(options_prep_adjust_sensitivity), opt_remote_w);
   gtk_table_attach_defaults(GTK_TABLE(sampling_tb), samp_timer_rb, 0, 1, 2, 3);
 
   samp_timer_adj = (GtkAdjustment *) gtk_adjustment_new(
-                        (gfloat)device.remote_opts.sampling_param,
+                        (gfloat)row.remote_opts.sampling_param,
                         1, (gfloat)INT_MAX, 1.0, 10.0, 0.0);
   samp_timer_sb = gtk_spin_button_new(samp_timer_adj, 0, 0);
   gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(samp_timer_sb), TRUE);
@@ -1661,7 +1689,10 @@ options_edit_destroy_cb(GtkWidget *win, gpointer user_data _U_)
 static void
 update_options_table(gint index)
 {
-  interface_t  device;
+  guint i;
+  gboolean found = FALSE;
+  interface_row row;
+  interface_options interface_opts;
   GtkTreePath  *path;
   GtkTreeView  *if_cb;
   GtkTreeModel *model;
@@ -1671,78 +1702,122 @@ update_options_table(gint index)
   link_row *link = NULL;
   gboolean enabled;
 
-  device = g_array_index(global_capture_opts.all_ifaces, interface_t, index);
+  row = g_array_index(rows, interface_row, index);
 
-  if (!device.hidden) {
-    if (device.no_addresses == 0) {
-      temp = g_strdup_printf("<b>%s</b>", device.display_name);
-    } else {
-      temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", device.display_name, device.addresses);
-    }
-    for (list=device.links; list!=NULL; list=g_list_next(list))
-    {
-      link = (link_row*)(list->data);
-      if (link->dlt == device.active_dlt) {
+  if (global_capture_opts.ifaces->len > 0) {
+    for (i = 0; i < global_capture_opts.ifaces->len; i++) {
+      interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
+      if (strcmp(interface_opts.name, row.name) == 0) {
+        found = TRUE;
         break;
       }
     }
-    if (device.has_snaplen) {
-      snaplen_string = g_strdup_printf("%d", device.snaplen);
-    } else {
-      snaplen_string = g_strdup("default");
+    if (found) {
+      global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
+      g_free(interface_opts.cfilter);
+      interface_opts.linktype = row.active_dlt;
+      interface_opts.promisc_mode = row.pmode;
+      interface_opts.has_snaplen = row.has_snaplen;
+      interface_opts.snaplen = row.snaplen;
+      interface_opts.cfilter = g_strdup(row.cfilter);
+#ifdef HAVE_PCAP_CREATE
+      interface_opts.monitor_mode = row.monitor_mode_enabled;
+#else
+      interface_opts.monitor_mode = FALSE;
+#endif
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+      interface_opts.buffer_size = row.buffer;
+#endif
+      g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
     }
-    if (cap_open_w) {
-      if_cb      = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
-      path_str = g_strdup_printf("%d", marked_row);
-      path = gtk_tree_path_new_from_string(path_str);
-      model = gtk_tree_view_get_model(if_cb);
-      gtk_tree_model_get_iter (model, &iter, path);
-      gtk_tree_model_get(model, &iter, CAPTURE, &enabled, -1);
-      if (enabled == FALSE) {
-        device.selected = TRUE;
-        global_capture_opts.num_selected++;
-        global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, index);
-        g_array_insert_val(global_capture_opts.all_ifaces, index, device);
-      }
-  
-  #if defined(HAVE_PCAP_CREATE)
-      gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link->name,  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);
-  #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
-      gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, link->name,  PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
-  #else
-      gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp,LINK, link->name,  PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
-  #endif
-  #ifdef USE_THREADS
-      if (global_capture_opts.num_selected > 0) {
-  #else
-      if (global_capture_opts.num_selected == 1) {
-  #endif
-        gtk_widget_set_sensitive(ok_bt, TRUE);
-      } else {
-        gtk_widget_set_sensitive(ok_bt, FALSE);
-      }
-      gtk_tree_path_free (path);
+  }
+  if (!found || global_capture_opts.ifaces->len == 0) {
+    interface_opts.name = g_strdup(row.name);
+    interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
+    interface_opts.linktype = row.active_dlt;
+    interface_opts.promisc_mode = row.pmode;
+    interface_opts.has_snaplen = row.has_snaplen;
+    interface_opts.snaplen = row.snaplen;
+    interface_opts.cfilter = g_strdup(row.cfilter);
+#ifdef HAVE_PCAP_CREATE
+    interface_opts.monitor_mode = row.monitor_mode_enabled;
+#else
+    interface_opts.monitor_mode = FALSE;
+#endif
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+    interface_opts.buffer_size = row.buffer;
+#endif
+#ifdef HAVE_PCAP_REMOTE
+    interface_opts.src_type = global_capture_opts.default_options.src_type;
+    interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
+    interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
+    interface_opts.auth_type = global_capture_opts.default_options.auth_type;
+    interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
+    interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
+    interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
+    interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
+    interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
+#endif
+#ifdef HAVE_PCAP_SETSAMPLING
+    interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
+    interface_opts.sampling_param  = global_capture_opts.default_options.sampling_param;
+#endif
+    g_array_append_val(global_capture_opts.ifaces, interface_opts);
+  }
+  if (row.no_addresses == 0) {
+    temp = g_strdup_printf("<b>%s</b>", row.display_name);
+  } else {
+    temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", row.display_name, row.addresses);
+  }
+  for (list=row.links; list!=NULL; list=g_list_next(list))
+  {
+    link = (link_row*)(list->data);
+    if (link->dlt == row.active_dlt) {
+      break;
     }
-    if (interfaces_dialog_window_present()) {
-      update_selected_interface(g_strdup(device.name));
+  }
+  if (row.has_snaplen) {
+    snaplen_string = g_strdup_printf("%d", row.snaplen);
+  } else {
+    snaplen_string = g_strdup("default");
+  }
+  if (cap_open_w) {
+    if_cb      = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
+    path_str = g_strdup_printf("%d", marked_row);
+    path = gtk_tree_path_new_from_string(path_str);
+    model = gtk_tree_view_get_model(if_cb);
+    gtk_tree_model_get_iter (model, &iter, path);
+    gtk_tree_model_get(model, &iter, CAPTURE, &enabled, -1);
+    if (enabled == FALSE) {
+      num_selected++;
     }
-    if (get_welcome_window() != NULL) {
-      change_interface_selection(g_strdup(device.name), device.selected);
+
+#if defined(HAVE_PCAP_CREATE)
+    gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, TRUE, INTERFACE, temp, LINK, link->name,  PMODE, row.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) row.buffer, MONITOR, row.monitor_mode_supported?(row.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, row.cfilter, -1);
+#elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
+    gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, TRUE, INTERFACE, temp,LINK, link->name,  PMODE, row.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) row.buffer, FILTER, row.cfilter, -1);
+#else
+    gtk_list_store_set (GTK_LIST_STORE(model), &iter, CAPTURE, TRUE, INTERFACE, temp,LINK, link->name,  PMODE, row.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, row.cfilter, -1);
+#endif
+#ifdef USE_THREADS
+    if (num_selected > 0) {
+#else
+    if (num_selected == 1) {
+#endif
+      gtk_widget_set_sensitive(ok_bt, TRUE);
+    } else {
+      gtk_widget_set_sensitive(ok_bt, FALSE);
     }
+    gtk_tree_path_free (path);
+  }
+  if (interfaces_dialog_window_present()) {
+    update_selected_interface(g_strdup(row.name), TRUE);
+  }
+  if (get_welcome_window() != NULL) {
+    change_interface_selection(g_strdup(row.name), TRUE);
   }
 }
 
-
-void
-update_all_rows(void) 
-{
-    GtkTreeView *view;
-  
-    view = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
-    create_and_fill_model(GTK_TREE_VIEW(view));
-}
-
-
 static void
 save_options_cb(GtkWidget *win _U_, gpointer user_data _U_)
 {
@@ -1755,13 +1830,13 @@ save_options_cb(GtkWidget *win _U_, gpointer user_data _U_)
   GtkWidget *buffer_size_sb;
 #endif
 
-  interface_t device;
+  interface_row row;
   gpointer  ptr;
   int       dlt;
   const gchar *filter_text;
 
-  device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
-  global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_row);
+  row = g_array_index(rows, interface_row, marked_row);
+  rows = g_array_remove_index(rows, marked_row);
   snap_cb    = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_SNAP_CB_KEY);
   snap_sb    = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_SNAP_SB_KEY);
 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
@@ -1781,31 +1856,31 @@ save_options_cb(GtkWidget *win _U_, gpointer user_data _U_)
   if ((dlt = GPOINTER_TO_INT(ptr)) == -1) {
     g_assert_not_reached();  /* Programming error: somehow managed to select an "unsupported" entry */
   }
-  device.active_dlt = dlt;
+  row.active_dlt = dlt;
 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
-  device.buffer = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(buffer_size_sb));
-#endif
-  device.pmode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(promisc_cb));
-  device.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
-  if (device.has_snaplen) {
-    device.snaplen = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(snap_sb));
-    if (device.snaplen < 1)
-      device.snaplen = WTAP_MAX_PACKET_SIZE;
-    else if (device.snaplen < MIN_PACKET_SIZE)
-      device.snaplen = MIN_PACKET_SIZE;
+  row.buffer = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(buffer_size_sb));
+#endif
+  row.pmode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(promisc_cb));
+  row.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
+  if (row.has_snaplen) {
+    row.snaplen = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(snap_sb));
+    if (row.snaplen < 1)
+      row.snaplen = WTAP_MAX_PACKET_SIZE;
+    else if (row.snaplen < MIN_PACKET_SIZE)
+      row.snaplen = MIN_PACKET_SIZE;
   } else {
-    device.snaplen = WTAP_MAX_PACKET_SIZE;
+    row.snaplen = WTAP_MAX_PACKET_SIZE;
   }
 
   filter_text = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(filter_cm));
-  if (device.cfilter)
-    g_free(device.cfilter);
+  if (row.cfilter)
+    g_free(row.cfilter);
   g_assert(filter_text != NULL);
-  device.cfilter = g_strdup(filter_text);
+  row.cfilter = g_strdup(filter_text);
 #ifdef HAVE_PCAP_CREATE
-  device.monitor_mode_enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(monitor_cb));
+  row.monitor_mode_enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(monitor_cb));
 #endif
-  g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device);
+  g_array_insert_val(rows, marked_row, row);
   window_destroy(opt_edit_w);
   update_options_table(marked_row);
 }
@@ -1814,10 +1889,10 @@ static void
 adjust_snap_sensitivity(GtkWidget *tb _U_, gpointer parent_w _U_)
 {
   GtkWidget *snap_cb, *snap_sb;
-  interface_t device;
+  interface_row row;
 
-  device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
-  global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_row);
+  row = g_array_index(rows, interface_row, marked_row);
+  rows = g_array_remove_index(rows, marked_row);
 
   snap_cb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_SNAP_CB_KEY);
   snap_sb = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_SNAP_SB_KEY);
@@ -1826,8 +1901,8 @@ adjust_snap_sensitivity(GtkWidget *tb _U_, gpointer parent_w _U_)
      to" checkbox is on. */
   gtk_widget_set_sensitive(GTK_WIDGET(snap_sb),
       gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb)));
-  device.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
-  g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device);
+  row.has_snaplen = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(snap_cb));
+  g_array_insert_val(rows, marked_row, row);
 }
 
 void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column _U_, gpointer userdata)
@@ -1865,12 +1940,14 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
  #ifdef HAVE_AIRPCAP
   GtkWidget     *advanced_bt;
 #endif
-  interface_t   device;
+  interface_row row;
+  displayed_interface d_interface;
   GtkTreeModel  *model;
   GtkTreeIter   iter;
   link_row      *temp;
   gboolean      found = FALSE;
   gint          num_supported_link_types;
+  guint         i;
   gchar         *tok;
   GtkCellRenderer *renderer;
   GtkListStore    *store;
@@ -1883,30 +1960,43 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
     return;
   }
 
-  device.name = NULL;
-  device.display_name = NULL;
-  device.no_addresses = 0;
-  device.addresses = NULL;
-  device.links = NULL;
-  device.active_dlt = -1;
-  device.pmode = FALSE;
+  row.name = NULL;
+  row.display_name = NULL;
+  row.no_addresses = 0;
+  row.addresses = NULL;
+  row.links = NULL;
+  row.active_dlt = -1;
+  row.pmode = FALSE;
 #ifdef HAVE_PCAP_CREATE
-  device.monitor_mode_enabled = FALSE;
-  device.monitor_mode_supported = FALSE;
+  row.monitor_mode_enabled = FALSE;
+  row.monitor_mode_supported = FALSE;
 #endif
-  device.has_snaplen = FALSE;
-  device.snaplen = 65535;
-  device.cfilter = NULL;
+  row.has_snaplen = FALSE;
+  row.snaplen = 65535;
+  row.cfilter = NULL;
 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
-  device.buffer = 1;
+  row.buffer = 1;
 #endif
 
   model = gtk_tree_view_get_model(view);
   gtk_tree_model_get_iter (model, &iter, path);
   marked_row = atoi(gtk_tree_path_to_string(path));
- 
-  device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
-  
+
+  if (cap_open_w) {
+    row = g_array_index(rows, interface_row, marked_row);
+  } else if (get_welcome_window() != NULL) {
+    d_interface = get_interface_data(marked_row);
+    if (!rows || rows->len == 0) {
+      make_and_fill_rows();
+    }
+    for (i = 0; i < rows->len; i++) {
+     row = g_array_index(rows, interface_row, i);
+     if (strcmp(row.name, (char*)d_interface.name)==0) {
+       marked_row = i;
+       break;
+     }
+    }
+  }
   opt_edit_w = dlg_window_new("Edit Interface Settings");
   g_object_set_data(G_OBJECT(opt_edit_w), E_OPT_EDIT_CALLER_PTR_KEY, caller);
   g_object_set_data(G_OBJECT(caller), E_OPT_EDIT_DIALOG_PTR_KEY, opt_edit_w);
@@ -1930,7 +2020,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
   if_lb = gtk_label_new("Interface:  ");
   gtk_box_pack_start(GTK_BOX(if_hb), if_lb, FALSE, FALSE, 3);
 
-  if_lb_name = gtk_label_new(device.display_name);
+  if_lb_name = gtk_label_new(row.display_name);
   gtk_box_pack_start(GTK_BOX(if_hb), if_lb_name, FALSE, FALSE, 3);
 
   /* IP addresses row */
@@ -1945,8 +2035,9 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
   if_ip_lb = gtk_label_new("IP address:");
   gtk_misc_set_alignment(GTK_MISC(if_ip_lb), 0, 0); /* Left justified */
   gtk_box_pack_start(GTK_BOX(if_vb_left), if_ip_lb, FALSE, FALSE, 0);
-  if (device.no_addresses > 0) {
-    gchar *temp_addresses = g_strdup(device.addresses);
+
+  if (row.no_addresses > 0) {
+    gchar *temp_addresses = g_strdup(row.addresses);
     gtk_box_pack_start(GTK_BOX(capture_vb), if_ip_hb, TRUE, TRUE, 0);
     gtk_box_pack_start(GTK_BOX(if_ip_hb), if_vb_right, TRUE, TRUE, 3);
     swindow = gtk_scrolled_window_new (NULL, NULL);
@@ -2027,7 +2118,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
   gtk_box_pack_start (GTK_BOX(linktype_hb), linktype_combo_box, FALSE, FALSE, 0);
   g_object_set_data(G_OBJECT(opt_edit_w), E_CAP_LT_CBX_KEY, linktype_combo_box);
   num_supported_link_types = 0;
-  for (list=device.links; list!=NULL; list=g_list_next(list))
+  for (list=row.links; list!=NULL; list=g_list_next(list))
   {
     temp = (link_row*)(list->data);
     ws_combo_box_append_text_and_pointer(GTK_COMBO_BOX(linktype_combo_box),
@@ -2035,7 +2126,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
                                                   GINT_TO_POINTER(temp->dlt)  /* Flag as "not supported" */
                                                   );
     num_supported_link_types++;
-    if (temp->dlt == device.active_dlt) {
+    if (temp->dlt == row.active_dlt) {
       ws_combo_box_set_active(GTK_COMBO_BOX(linktype_combo_box), num_supported_link_types - 1);
       found = TRUE;
     }
@@ -2051,7 +2142,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
   promisc_cb = gtk_check_button_new_with_mnemonic(
       "Capture packets in _promiscuous mode");
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(promisc_cb),
-                               device.pmode);
+                               row.pmode);
   gtk_widget_set_tooltip_text(promisc_cb,
     "Usually a network adapter will only capture the traffic sent to its own network address. "
     "If you want to capture all traffic that the network adapter can \"see\", mark this option. "
@@ -2062,8 +2153,8 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
 #ifdef HAVE_PCAP_CREATE
   /* Monitor mode row */
   monitor_cb = gtk_check_button_new_with_mnemonic( "Capture packets in monitor mode");
-  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(monitor_cb), device.monitor_mode_enabled);
-  gtk_widget_set_sensitive(monitor_cb, device.monitor_mode_supported);
+  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(monitor_cb), row.monitor_mode_enabled);
+  gtk_widget_set_sensitive(monitor_cb, row.monitor_mode_supported);
   g_signal_connect(monitor_cb, "toggled", G_CALLBACK(capture_prep_monitor_changed_cb), NULL);
 
   gtk_widget_set_tooltip_text(monitor_cb,
@@ -2089,14 +2180,14 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
 
   snap_cb = gtk_check_button_new_with_mnemonic("_Limit each packet to");
   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(snap_cb),
-                               device.has_snaplen);
+                               row.has_snaplen);
   g_signal_connect(snap_cb, "toggled", G_CALLBACK(adjust_snap_sensitivity), NULL);
   gtk_widget_set_tooltip_text(snap_cb,
     "Limit the maximum number of bytes to be captured from each packet. This size includes the "
     "link-layer header and all subsequent headers. ");
   gtk_box_pack_start(GTK_BOX(snap_hb), snap_cb, FALSE, FALSE, 0);
 
-  snap_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) device.snaplen,
+  snap_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) row.snaplen,
     MIN_PACKET_SIZE, WTAP_MAX_PACKET_SIZE, 1.0, 10.0, 0.0);
   snap_sb = gtk_spin_button_new (snap_adj, 0, 0);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (snap_sb), TRUE);
@@ -2108,7 +2199,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
   snap_lb = gtk_label_new("bytes");
   gtk_misc_set_alignment(GTK_MISC(snap_lb), 0, 0.5f);
   gtk_box_pack_start(GTK_BOX(snap_hb), snap_lb, FALSE, FALSE, 0);
-  gtk_widget_set_sensitive(GTK_WIDGET(snap_sb), device.has_snaplen);
+  gtk_widget_set_sensitive(GTK_WIDGET(snap_sb), row.has_snaplen);
 
   /* Filter row */
   filter_hb = gtk_hbox_new(FALSE, 3);
@@ -2141,8 +2232,8 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
   if (global_capture_opts.default_options.cfilter && (strlen(global_capture_opts.default_options.cfilter) > 0)) {
     gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), global_capture_opts.default_options.cfilter);
   }
-  if (device.cfilter && (strlen(device.cfilter) > 0)) {
-    gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), device.cfilter);
+  if (row.cfilter && (strlen(row.cfilter) > 0)) {
+    gtk_combo_box_text_prepend_text(GTK_COMBO_BOX_TEXT(filter_cm), row.cfilter);
     gtk_combo_box_set_active(GTK_COMBO_BOX(filter_cm), 0);
   }
 
@@ -2169,10 +2260,10 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
   buffer_size_lb = gtk_label_new("Buffer size:");
   gtk_box_pack_start (GTK_BOX(buffer_size_hb), buffer_size_lb, FALSE, FALSE, 0);
 
-  buffer_size_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) device.buffer,
+  buffer_size_adj = (GtkAdjustment *) gtk_adjustment_new((gfloat) row.buffer,
     1, 65535, 1.0, 10.0, 0.0);
   buffer_size_sb = gtk_spin_button_new (buffer_size_adj, 0, 0);
-  gtk_spin_button_set_value(GTK_SPIN_BUTTON (buffer_size_sb), (gfloat) device.buffer);
+  gtk_spin_button_set_value(GTK_SPIN_BUTTON (buffer_size_sb), (gfloat) row.buffer);
   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (buffer_size_sb), TRUE);
   gtk_widget_set_size_request(buffer_size_sb, 80, -1);
   gtk_widget_set_tooltip_text(buffer_size_sb,
@@ -2196,7 +2287,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
   /* Both the callback and the data are global */
   g_signal_connect(remote_bt, "clicked", G_CALLBACK(options_remote_cb), NULL);
   g_object_set_data(G_OBJECT(opt_edit_w), E_OPT_REMOTE_BT_KEY, remote_bt);
-  if (strncmp (device.name, "rpcap://", 8) == 0)  {
+  if (strncmp (row.name, "rpcap://", 8) == 0)  {
     gtk_widget_set_sensitive(remote_bt, TRUE);
   } else {
     gtk_widget_set_sensitive(remote_bt, FALSE);
@@ -2211,7 +2302,7 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
   /* Both the callback and the data are global */
   g_signal_connect(advanced_bt,"clicked", G_CALLBACK(options_airpcap_advanced_cb), airpcap_tb);
   g_object_set_data(G_OBJECT(top_level),AIRPCAP_OPTIONS_ADVANCED_KEY, advanced_bt);
-  airpcap_if_selected = get_airpcap_if_from_name(airpcap_if_list, device.name);
+  airpcap_if_selected = get_airpcap_if_from_name(airpcap_if_list, row.name);
   if (airpcap_if_selected != NULL) {
     /* It is an airpcap interface */
     gtk_widget_set_sensitive(advanced_bt, TRUE);
@@ -2256,94 +2347,198 @@ static void toggle_callback(GtkCellRendererToggle *cell _U_,
   GtkTreeView  *if_cb;
   GtkTreeModel *model;
   GtkTreePath *path = gtk_tree_path_new_from_string (path_str);
-  gboolean enabled;
+  gboolean enabled, found = FALSE;
   GtkWidget *pcap_ng_cb;
-  interface_t device;
-  gchar *name;
-  gint index = -1;
+  interface_options interface_opts;
+  interface_row row;
+  int index = atoi(path_str);
   guint i;
 
   if_cb = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
   model = gtk_tree_view_get_model(if_cb);
   gtk_tree_model_get_iter (model, &iter, path);
-  gtk_tree_model_get (model, &iter, CAPTURE, &enabled, IFACE_HIDDEN_NAME, &name, -1);
-  /* Look for the right interface. The number of interfaces shown might be less 
-   * than the real number. Therefore the path index does not correspond 
-   * necessarily to the position in the list */
-  for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-    device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-    if (strcmp(device.name, name) == 0) {
-      index = i;
-      break;
-    }
+  gtk_tree_model_get (model, &iter, CAPTURE, &enabled, -1);
+  row = g_array_index(rows, interface_row, index);
+  if (enabled == FALSE)
+    num_selected++;
+  else
+    num_selected--;
+  enabled ^= 1;
+  pcap_ng_cb = (GtkWidget *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_PCAP_NG_KEY);
+  if (num_selected >= 2) {
+    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pcap_ng_cb), TRUE);
+    gtk_widget_set_sensitive(pcap_ng_cb, FALSE);
+  } else {
+    gtk_widget_set_sensitive(pcap_ng_cb, TRUE);
   }
-  if (!device.locked) {
-    if (enabled == FALSE) {
-      device.selected = TRUE;
-      global_capture_opts.num_selected++;
-    } else {
-      device.selected = FALSE;
-      global_capture_opts.num_selected--;
+#ifdef USE_THREADS
+  if (num_selected > 0) {
+#else
+  if (num_selected == 1) {
+#endif
+    gtk_widget_set_sensitive(ok_bt, TRUE);
+  } else {
+    gtk_widget_set_sensitive(ok_bt, FALSE);
+  }
+  /* do something with the new enabled value, and set the new
+     enabled value in your treemodel */
+  gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, enabled, -1);
+
+  if (global_capture_opts.ifaces->len > 0) {
+    for (i = 0; i < global_capture_opts.ifaces->len; i++) {
+      interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
+      if (strcmp(interface_opts.name, row.name) == 0) {
+        found = TRUE;
+        break;
+      }
     }
-    device.locked = TRUE;
-  }
-  if (index != -1) {
-    global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, index);
-    g_array_insert_val(global_capture_opts.all_ifaces, index, device);
-    pcap_ng_cb = (GtkWidget *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_PCAP_NG_KEY);
-    if (global_capture_opts.num_selected >= 2) {
-      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pcap_ng_cb), TRUE);
-      gtk_widget_set_sensitive(pcap_ng_cb, FALSE);
-    } else {
-      gtk_widget_set_sensitive(pcap_ng_cb, TRUE);
+    if (found) {
+      global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
+      g_free(interface_opts.cfilter);
+      if (enabled) {
+        interface_opts.linktype = row.active_dlt;
+        interface_opts.promisc_mode = row.pmode;
+        interface_opts.has_snaplen = row.has_snaplen;
+        interface_opts.snaplen = row.snaplen;
+        interface_opts.cfilter = g_strdup(row.cfilter);
+#ifdef HAVE_PCAP_CREATE
+        interface_opts.monitor_mode = row.monitor_mode_enabled;
+#else
+        interface_opts.monitor_mode = FALSE;
+#endif
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+        interface_opts.buffer_size = row.buffer;
+#endif
+#ifdef HAVE_PCAP_REMOTE
+        interface_opts.src_type = row.remote_opts.src_type;
+        if (interface_opts.src_type == CAPTURE_IFREMOTE) {
+          interface_opts.remote_host = g_strdup(row.remote_opts.remote_host_opts.remote_host);
+          interface_opts.remote_port = g_strdup(row.remote_opts.remote_host_opts.remote_port);
+          interface_opts.auth_type = row.remote_opts.remote_host_opts.auth_type;
+          interface_opts.auth_username = g_strdup(row.remote_opts.remote_host_opts.auth_username);
+          interface_opts.auth_password = g_strdup(row.remote_opts.remote_host_opts.auth_password);
+          interface_opts.datatx_udp = row.remote_opts.remote_host_opts.datatx_udp;
+          interface_opts.nocap_rpcap = row.remote_opts.remote_host_opts.nocap_rpcap;
+          interface_opts.nocap_local = row.remote_opts.remote_host_opts.nocap_local;
+#ifdef HAVE_PCAP_SETSAMPLING
+          interface_opts.sampling_method = row.remote_opts.sampling_method;
+          interface_opts.sampling_param  = row.remote_opts.sampling_param;
+#endif
+        } else {
+          interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
+          interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
+          interface_opts.auth_type = global_capture_opts.default_options.auth_type;
+          interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
+          interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
+          interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
+          interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
+          interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
+#ifdef HAVE_PCAP_SETSAMPLING
+          interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
+          interface_opts.sampling_param  = global_capture_opts.default_options.sampling_param;
+#endif
+        }
+#endif
+        g_array_insert_val(global_capture_opts.ifaces, i, interface_opts);
+      } else { /* not enabled */
+        if (interfaces_dialog_window_present()) {
+          update_selected_interface(g_strdup(interface_opts.name), FALSE);
+        }
+        if (get_welcome_window() != NULL) {
+          change_interface_selection(g_strdup(interface_opts.name), FALSE);
+        }
+      }
     }
-#ifdef USE_THREADS
-    if (global_capture_opts.num_selected > 0) {
+  }
+  if (!found && enabled) {
+    interface_opts.name = g_strdup(row.name);
+    interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
+    interface_opts.linktype = row.active_dlt;
+    interface_opts.promisc_mode = row.pmode;
+    interface_opts.has_snaplen = row.has_snaplen;
+    interface_opts.snaplen = row.snaplen;
+    interface_opts.cfilter = g_strdup(row.cfilter);
+#ifdef HAVE_PCAP_CREATE
+    interface_opts.monitor_mode = row.monitor_mode_enabled;
 #else
-    if (global_capture_opts.num_selected == 1) {
+    interface_opts.monitor_mode = FALSE;
+#endif
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+    interface_opts.buffer_size = row.buffer;
+#endif
+#ifdef HAVE_PCAP_REMOTE
+    interface_opts.src_type = row.remote_opts.src_type;
+    if (interface_opts.src_type == CAPTURE_IFREMOTE) {
+      interface_opts.remote_host = g_strdup(row.remote_opts.remote_host_opts.remote_host);
+      interface_opts.remote_port = g_strdup(row.remote_opts.remote_host_opts.remote_port);
+      interface_opts.auth_type = row.remote_opts.remote_host_opts.auth_type;
+      interface_opts.auth_username = g_strdup(row.remote_opts.remote_host_opts.auth_username);
+      interface_opts.auth_password = g_strdup(row.remote_opts.remote_host_opts.auth_password);
+      interface_opts.datatx_udp = row.remote_opts.remote_host_opts.datatx_udp;
+      interface_opts.nocap_rpcap = row.remote_opts.remote_host_opts.nocap_rpcap;
+      interface_opts.nocap_local = row.remote_opts.remote_host_opts.nocap_local;
+#ifdef HAVE_PCAP_SETSAMPLING
+      interface_opts.sampling_method = row.remote_opts.sampling_method;
+      interface_opts.sampling_param  = row.remote_opts.sampling_param;
 #endif
-      gtk_widget_set_sensitive(ok_bt, TRUE);
     } else {
-      gtk_widget_set_sensitive(ok_bt, FALSE);
+      interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
+      interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
+      interface_opts.auth_type = global_capture_opts.default_options.auth_type;
+      interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
+      interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
+      interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
+      interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
+      interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
+#ifdef HAVE_PCAP_SETSAMPLING
+      interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
+      interface_opts.sampling_param  = global_capture_opts.default_options.sampling_param;
+#endif
     }
-  /* do something with the new enabled value, and set the new
-     enabled value in your treemodel */
-    gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, device.selected, -1);
+#endif
+    g_array_append_val(global_capture_opts.ifaces, interface_opts);
     if (interfaces_dialog_window_present()) {
-      update_selected_interface(g_strdup(device.name));
+      update_selected_interface(g_strdup(interface_opts.name), TRUE);
     }
     if (get_welcome_window() != NULL) {
-      change_interface_selection(g_strdup(device.name), device.selected);
+      change_interface_selection(g_strdup(interface_opts.name), TRUE);
     }
   }
-  device.locked = FALSE;
-  global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, index);
-  g_array_insert_val(global_capture_opts.all_ifaces, index, device);
   gtk_tree_path_free (path);
 }
 
-void enable_selected_interface(gchar *name, gboolean selected)
+void enable_selected_interface(gchar *name, gboolean enable)
 {
+  guint i;
+  interface_row row;
   GtkTreeIter  iter;
   GtkTreeView  *if_cb;
   GtkTreeModel *model;
-  gchar *name_str;
+  gchar *path_str;
+  gboolean enabled;
 
-  if_cb      = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
-  model = gtk_tree_view_get_model(if_cb);
-  gtk_tree_model_get_iter_first(model, &iter);
-  do {
-    gtk_tree_model_get(model, &iter, IFACE_HIDDEN_NAME, &name_str, -1);
-    if (strcmp(name, name_str) == 0) {
-    gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, selected, -1);
-    break;
+  for (i = 0; i < rows->len; i++) {
+    row = g_array_index(rows, interface_row, i);
+    if (strcmp(name, row.name) == 0) {
+      if_cb      = (GtkTreeView *) g_object_get_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY);
+      model = gtk_tree_view_get_model(if_cb);
+      path_str = g_strdup_printf("%d", i);
+      gtk_tree_model_get_iter_from_string(model, &iter, path_str);
+      gtk_tree_model_get (model, &iter, CAPTURE, &enabled, -1);
+      if ((enabled == TRUE) && (enable == FALSE)) {
+        num_selected--;
+      }
+      if ((enabled == FALSE) && (enable == TRUE)) {
+        num_selected++;
+      }
+      gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, enable, -1);
+      break;
     }
   }
-  while (gtk_tree_model_iter_next(model, &iter));
 #ifdef USE_THREADS
-  if (global_capture_opts.num_selected > 0) {
+  if (num_selected > 0) {
 #else
-  if (global_capture_opts.num_selected == 1) {
+  if (num_selected == 1) {
 #endif
     gtk_widget_set_sensitive(ok_bt, TRUE);
   } else {
@@ -2369,17 +2564,17 @@ static void capture_all_cb(GtkToggleButton *button, gpointer d _U_)
     do {
       gtk_tree_model_get (model, &iter, CAPTURE, &capture_set, -1);
       if (!capture_set && enabled) {
-        global_capture_opts.num_selected++;
+        num_selected++;
       } else if (capture_set && !enabled) {
-        global_capture_opts.num_selected--;
+        num_selected--;
       }
       gtk_list_store_set(GTK_LIST_STORE(model), &iter, CAPTURE, enabled, -1);
     } while (gtk_tree_model_iter_next(model, &iter));
   }
-  if (global_capture_opts.num_selected >= 2) {
+  if (num_selected >= 2) {
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pcap_ng_cb), TRUE);
     gtk_widget_set_sensitive(pcap_ng_cb, FALSE);
-  } else if (global_capture_opts.num_selected <= 1) {
+  } else if (num_selected <= 1) {
     gtk_widget_set_sensitive(pcap_ng_cb, TRUE);
   }
   if (interfaces_dialog_window_present()) {
@@ -2389,9 +2584,9 @@ static void capture_all_cb(GtkToggleButton *button, gpointer d _U_)
     change_selection_for_all(enabled);
   }
 #ifdef USE_THREADS
-  if (global_capture_opts.num_selected > 0) {
+  if (num_selected > 0) {
 #else
-  if (global_capture_opts.num_selected == 1) {
+  if (num_selected == 1) {
 #endif
     gtk_widget_set_sensitive(ok_bt, TRUE);
   } else {
@@ -2406,7 +2601,7 @@ static void promisc_mode_callback(GtkToggleButton *button, gpointer d _U_)
   GtkTreeView  *if_cb;
   GtkTreeModel *model;
   gboolean enabled = FALSE;
-  interface_t device;
+  interface_row row;
   interface_options interface_opts;
   guint i;
 
@@ -2421,11 +2616,11 @@ static void promisc_mode_callback(GtkToggleButton *button, gpointer d _U_)
     } while (gtk_tree_model_iter_next(model, &iter));
   }
 
-  for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-    device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-    global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
-    device.pmode = (enabled?TRUE:FALSE);
-    g_array_insert_val(global_capture_opts.all_ifaces, i, device);
+  for (i = 0; i < rows->len; i++) {
+    row = g_array_index(rows, interface_row, i);
+    rows = g_array_remove_index(rows, i);
+    row.pmode = (enabled?TRUE:FALSE);
+    g_array_insert_val(rows, i, row);
   }
 
   for (i = 0; i < global_capture_opts.ifaces->len; i++) {
@@ -2521,8 +2716,6 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
                 *help_bt;
 #ifdef HAVE_AIRPCAP
   GtkWidget     *decryption_cb;
-  int           err;
-  gchar         *err_str;
 #endif
 #ifdef HAVE_PCAP_REMOTE
   GtkWidget     *iftype_cbx;
@@ -2531,7 +2724,10 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   GtkAdjustment *ringbuffer_nbf_adj,
                 *stop_packets_adj, *stop_filesize_adj, *stop_duration_adj, *stop_files_adj,
                 *ring_filesize_adj, *file_duration_adj;
+  GList           *if_list;
   int              row;
+  int              err;
+  gchar            *err_str;
   guint32          value;
   gchar            *cap_title;
   GtkWidget        *view;
@@ -2562,6 +2758,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
     return;
   }
 #endif
+  num_selected = 0;
   /* use user-defined title if preference is set */
 
   cap_title = create_user_window_title("Wireshark: Capture Options");
@@ -2570,6 +2767,13 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   cap_open_w = dlg_window_new(cap_title);
   g_free(cap_title);
 
+  if_list = capture_interface_list(&err, &err_str);
+
+  if (if_list == NULL && err == CANT_GET_INTERFACE_LIST) {
+    simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
+    g_free(err_str);
+  }
+  if_list = g_list_sort (if_list, if_list_comparator_alph);
 #ifdef HAVE_AIRPCAP
   /* update airpcap interface list */
 
@@ -2620,13 +2824,6 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   g_object_set (GTK_TREE_VIEW(view), "has-tooltip", TRUE, NULL);
   g_signal_connect (GTK_TREE_VIEW(view), "query-tooltip", G_CALLBACK (query_tooltip_tree_view_cb), NULL);
 
-  renderer = gtk_cell_renderer_text_new();
-  column = gtk_tree_view_column_new_with_attributes ("",
-                                               GTK_CELL_RENDERER(renderer),
-                                               "text", IFACE_HIDDEN_NAME,
-                                               NULL);
-  gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
-  gtk_tree_view_column_set_visible(column, FALSE);
   renderer = gtk_cell_renderer_text_new ();
   gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (view), -1, "Interface", renderer, "markup", INTERFACE, NULL);
   column = gtk_tree_view_get_column(GTK_TREE_VIEW (view), INTERFACE);
@@ -2677,6 +2874,7 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   gtk_container_add (GTK_CONTAINER (swindow), view);
   gtk_box_pack_start(GTK_BOX(capture_vb), swindow, TRUE, TRUE, 0);
 
+  free_interface_list(if_list);
   g_object_set_data(G_OBJECT(cap_open_w), E_CAP_IFACE_KEY, view);
 
   main_hb = gtk_hbox_new(FALSE, 5);
@@ -3046,9 +3244,9 @@ capture_prep_cb(GtkWidget *w _U_, gpointer d _U_)
   g_signal_connect(ok_bt, "clicked", G_CALLBACK(capture_start_cb), NULL);
   gtk_widget_set_tooltip_text(ok_bt, "Start the capture process.");
 #ifdef USE_THREADS
-  if (global_capture_opts.num_selected > 0) {
+  if (num_selected > 0) {
 #else
-  if (global_capture_opts.num_selected == 1) {
+  if (num_selected == 1) {
 #endif
     gtk_widget_set_sensitive(ok_bt, TRUE);
   } else {
@@ -3130,7 +3328,7 @@ capture_start_confirmed(void)
   guint i;
 
   /* did the user ever select a capture interface before? */
-  if(global_capture_opts.num_selected == 0 && prefs.capture_device == NULL) {
+  if(global_capture_opts.ifaces->len == 0 && prefs.capture_device == NULL) {
     simple_dialog(ESD_TYPE_CONFIRMATION,
                   ESD_BTN_OK,
                   "%sNo capture interface selected!%s\n\n"
@@ -3182,6 +3380,10 @@ void
 capture_start_cb(GtkWidget *w _U_, gpointer d _U_)
 {
   gpointer  dialog;
+  gchar *if_name;
+  cap_settings_t *cap_settings_p = NULL;
+  interface_options interface_opts;
+  guint i;
 
 #ifdef HAVE_AIRPCAP
   airpcap_if_active = airpcap_if_selected;
@@ -3217,10 +3419,60 @@ capture_start_cb(GtkWidget *w _U_, gpointer d _U_)
     if (!success)
       return;   /* error in options dialog */
   }
-  if (global_capture_opts.num_selected == 0) {
-    simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+
+  if (global_capture_opts.ifaces->len == 0) {
+    if (prefs.capture_device == NULL) {
+      simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
         "You didn't specify an interface on which to capture packets.");
-    return;
+      return;
+    }
+    interface_opts.name = g_strdup(get_if_name(prefs.capture_device));
+    interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
+#ifdef HAVE_PCAP_CREATE
+    interface_opts.monitor_mode = prefs_capture_device_monitor_mode(interface_opts.name);
+#else
+    interface_opts.monitor_mode = FALSE;
+#endif
+    interface_opts.linktype = capture_dev_user_linktype_find(interface_opts.name);
+    interface_opts.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
+    interface_opts.snaplen = global_capture_opts.default_options.snaplen;
+    interface_opts.has_snaplen = global_capture_opts.default_options.has_snaplen;
+    interface_opts.promisc_mode = global_capture_opts.default_options.promisc_mode;
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+    interface_opts.buffer_size =  global_capture_opts.default_options.buffer_size;
+#endif
+#ifdef HAVE_PCAP_REMOTE
+    interface_opts.src_type = global_capture_opts.default_options.src_type;
+    interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
+    interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
+    interface_opts.auth_type = global_capture_opts.default_options.auth_type;
+    interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
+    interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
+    interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
+    interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
+    interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
+ #endif
+ #ifdef HAVE_PCAP_SETSAMPLING
+    interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
+    interface_opts.sampling_param  = global_capture_opts.default_options.sampling_param;
+ #endif
+    g_array_insert_val(global_capture_opts.ifaces, 0, interface_opts);
+  }
+
+  if (cap_settings_history != NULL) {
+    for (i = 0; i < global_capture_opts.ifaces->len; i++) {
+      interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
+      if_name = g_strdup(interface_opts.name);
+      cap_settings_p = g_hash_table_lookup(cap_settings_history, if_name);
+      if (cap_settings_p == NULL) {
+        cap_settings_p = g_malloc(sizeof (cap_settings_t));
+        g_hash_table_insert(cap_settings_history, if_name, cap_settings_p);
+      } else {
+        g_free(if_name);
+      }
+      cap_settings_p->monitor_mode = interface_opts.monitor_mode;
+      cap_settings_p->linktype = interface_opts.linktype;
+    }
   }
 
   if((cfile.state != FILE_CLOSED) && !cfile.user_saved && prefs.gui_ask_unsaved) {
@@ -3243,18 +3495,18 @@ select_link_type_cb(GtkWidget *linktype_combo_box, gpointer data _U_)
 {
   gpointer  ptr;
   int       dlt;
-  interface_t device;
+  interface_row row;
 
-  device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
-  global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_row);
+  row = g_array_index(rows, interface_row, marked_row);
+  rows = g_array_remove_index(rows, marked_row);
   if (! ws_combo_box_get_active_pointer(GTK_COMBO_BOX(linktype_combo_box), &ptr)) {
     g_assert_not_reached();  /* Programming error: somehow nothing is active */
   }
   if ((dlt = GPOINTER_TO_INT(ptr)) == -1) {
     g_assert_not_reached();  /* Programming error: somehow managed to select an "unsupported" entry */
   }
-  device.active_dlt = dlt;
-  g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device);
+  row.active_dlt = dlt;
+  g_array_insert_val(rows, marked_row, row);
   capture_filter_check_syntax_cb(linktype_combo_box, data);
 }
 
@@ -3312,7 +3564,7 @@ capture_dlg_prep(gpointer parent_w) {
   n_resolv_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_N_RESOLVE_KEY);
   t_resolv_cb = (GtkWidget *) g_object_get_data(G_OBJECT(parent_w), E_CAP_T_RESOLVE_KEY);
 
-  if (global_capture_opts.num_selected == 0) {
+  if (global_capture_opts.ifaces->len == 0) {
     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
       "You didn't specify an interface on which to capture packets.");
     return FALSE;
@@ -3456,50 +3708,219 @@ capture_dlg_prep(gpointer parent_w) {
   return TRUE;
 }
 
+static void
+make_and_fill_rows(void)
+{
+  GList *if_entry, *if_list;
+  if_info_t *if_info;
+  char *if_string="";
+  gchar *descr;
+  if_capabilities_t *caps=NULL;
+  gint linktype_count;
+  cap_settings_t cap_settings;
+  GSList *curr_addr;
+  int ips = 0, err;
+  guint i;
+  if_addr_t *addr;
+  GList *lt_entry;
+  link_row *link = NULL;
+  data_link_info_t *data_link_info;
+  gchar *str, *err_str = NULL;
+  interface_row row;
+  interface_options interface_opts;
+  gboolean found = FALSE;
+  GString *ip_str;
+
+  rows = g_array_new(TRUE, TRUE, sizeof(interface_row));
+  /* Scan through the list and build a list of strings to display. */
+  if_list = capture_interface_list(&err, &err_str);
+  if_list = g_list_sort (if_list, if_list_comparator_alph);
+  if (if_list == NULL && err == CANT_GET_INTERFACE_LIST) {
+    simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
+    g_free(err_str);
+    return;
+  } else if (err_str) {
+    g_free(err_str);
+  }
+  for (if_entry = if_list; if_entry != NULL; if_entry = g_list_next(if_entry)) {
+    if_info = if_entry->data;
+    ip_str = g_string_new("");
+    str = "";
+    ips = 0;
+    row.name = g_strdup(if_info->name);
+    /* Is this interface hidden and, if so, should we include it anyway? */
+    if (!prefs_is_capture_device_hidden(if_info->name)) {
+      /* It's not hidden, or it is but we should include it in the list. */
+      /* Do we have a user-supplied description? */
+      descr = capture_dev_user_descr_find(if_info->name);
+      if (descr != NULL) {
+        /* Yes, we have a user-supplied description; use it. */
+        if_string = g_strdup_printf("%s: %s", descr, if_info->name);
+        g_free(descr);
+      } else {
+        /* No, we don't have a user-supplied description; did we get
+           one from the OS or libpcap? */
+        if (if_info->description != NULL) {
+          /* Yes - use it. */
+          if_string = g_strdup_printf("%s: %s", if_info->description, if_info->name);
+        } else {
+          /* No. */
+          if_string = g_strdup(if_info->name);
+        }
+      }
+      if (if_info->loopback) {
+        row.display_name = g_strdup_printf("%s (loopback)", if_string);
+      } else {
+        row.display_name = g_strdup(if_string);
+      }
+      found = FALSE;
+      for (i = 0; i < global_capture_opts.ifaces->len; i++) {
+        interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
+        if (!interface_opts.name || strcmp(interface_opts.name, (char*)row.name)!=0) {
+          continue;
+        } else {
+          found = TRUE;
+          break;
+        }
+      }
+      if (found) {
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+        row.buffer = interface_opts.buffer_size;
+#endif
+        row.pmode = interface_opts.promisc_mode;
+        row.has_snaplen = interface_opts.has_snaplen;
+        row.snaplen = interface_opts.snaplen;
+        row.cfilter = g_strdup(interface_opts.cfilter);
+      } else {
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+        row.buffer = global_capture_opts.default_options.buffer_size;
+#endif
+        row.pmode = global_capture_opts.default_options.promisc_mode;
+        row.has_snaplen = global_capture_opts.default_options.has_snaplen;
+        row.snaplen = global_capture_opts.default_options.snaplen;
+        row.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
+      }
+      cap_settings = capture_get_cap_settings(if_info->name);
+      caps = capture_get_if_capabilities(if_info->name, cap_settings.monitor_mode, NULL);
+      for (; (curr_addr = g_slist_nth(if_info->addrs, ips)) != NULL; ips++) {
+        if (ips != 0) {
+          g_string_append(ip_str, "\n");
+        }
+        addr = (if_addr_t *)curr_addr->data;
+        switch (addr->ifat_type) {
+          case IF_AT_IPv4:
+            g_string_append(ip_str, ip_to_str((guint8 *)&addr->addr.ip4_addr));
+            break;
+          case IF_AT_IPv6:
+            g_string_append(ip_str,  ip6_to_str((struct e_in6_addr *)&addr->addr.ip6_addr));
+            break;
+          default:
+            /* In case we add non-IP addresses */
+            break;
+        }
+      }
+      linktype_count = 0;
+      row.links = NULL;
+      if (caps != NULL) {
+#ifdef HAVE_PCAP_CREATE
+        row.monitor_mode_enabled = cap_settings.monitor_mode;
+        row.monitor_mode_supported = caps->can_set_rfmon;
+#endif
+        for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
+          data_link_info = lt_entry->data;
+          if (data_link_info->description != NULL) {
+            str = g_strdup_printf("%s", data_link_info->description);
+          } else {
+            str = g_strdup_printf("%s (not supported)", data_link_info->name);
+          }
+          if (linktype_count == 0) {
+            row.active_dlt = data_link_info->dlt;
+          }
+          link = (link_row *)g_malloc(sizeof(link_row));
+          link->dlt = data_link_info->dlt;
+          link->name = g_strdup(str);
+          row.links = g_list_append(row.links, link);
+          linktype_count++;
+        }
+      } else {
+        cap_settings.monitor_mode = FALSE;
+#ifdef HAVE_PCAP_CREATE
+        row.monitor_mode_enabled = FALSE;
+        row.monitor_mode_supported = FALSE;
+#endif
+        row.active_dlt = -1;
+      }
+      row.addresses = g_strdup(ip_str->str);
+      row.no_addresses = ips;
+      g_array_append_val(rows, row);
+      if (caps != NULL) {
+        free_if_capabilities(caps);
+      }
+    }
+    g_string_free(ip_str, TRUE);
+  }
+}
+
 GtkTreeModel *create_and_fill_model(GtkTreeView *view)
 {
   GtkListStore *store;
   GtkTreeIter iter;
   GList *list;
   char *temp="", *snaplen_string;
-  guint i;
+  guint i, j;
   link_row *link = NULL;
-  interface_t device;
+  interface_row row;
+  interface_options interface_opts;
+  gboolean found = FALSE;
 
 #if defined(HAVE_PCAP_CREATE)
-  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);
+  store = gtk_list_store_new (8, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING);
 #elif defined(_WIN32) && !defined (HAVE_PCAP_CREATE)
-  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);
+  store = gtk_list_store_new (7, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_STRING);
 #else
-  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);
+  store = gtk_list_store_new (6, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
 #endif
 
-  for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-    device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-    if (!device.hidden) {
-      if (device.no_addresses == 0) {
-        temp = g_strdup_printf("<b>%s</b>", device.display_name);
+  if (!rows || rows->len == 0) {
+    make_and_fill_rows();
+  }
+  if (rows && rows->len > 0) {
+    for (i = 0; i < rows->len; i++) {
+      row = g_array_index(rows, interface_row, i);
+      found = FALSE;
+      for (j = 0; j < global_capture_opts.ifaces->len; j++) {
+        interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, j);
+        if (!interface_opts.name || strcmp(interface_opts.name, (char*)row.name)!=0) {
+          continue;
+        } else {
+          found = TRUE;
+          num_selected++;
+          break;
+        }
+      }
+      if (row.no_addresses == 0) {
+        temp = g_strdup_printf("<b>%s</b>", row.display_name);
       } else {
-        temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", device.display_name, device.addresses);
+        temp = g_strdup_printf("<b>%s</b>\n<span size='small'>%s</span>", row.display_name, row.addresses);
       }
-      for (list = device.links; list != NULL; list = g_list_next(list)) {
+      for (list = row.links; list != NULL; list = g_list_next(list)) {
         link = (link_row*)(list->data);
-        if (link->dlt == device.active_dlt) {
-        break;
+        if (link->dlt == row.active_dlt) {
+          break;
         }
       }
-      if (device.has_snaplen) {
-        snaplen_string = g_strdup_printf("%d", device.snaplen);
+      if (row.has_snaplen) {
+        snaplen_string = g_strdup_printf("%d", row.snaplen);
       } else {
         snaplen_string = g_strdup("default");
       }
       gtk_list_store_append (store, &iter);
 #if defined(HAVE_PCAP_CREATE)
-      gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link->name,  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);
+      gtk_list_store_set (store, &iter, CAPTURE, found, INTERFACE, temp, LINK, link->name,  PMODE, row.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) row.buffer, MONITOR, row.monitor_mode_supported?(row.monitor_mode_enabled?"enabled":"disabled"):"n/a", FILTER, row.cfilter, -1);
 #elif defined(_WIN32) && !defined(HAVE_PCAP_CREATE)
-      gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link->name,  PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) device.buffer, FILTER, device.cfilter, -1);
+      gtk_list_store_set (store, &iter, CAPTURE, found, INTERFACE, temp, LINK, link->name,  PMODE, row.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, BUFFER, (guint) row.buffer, FILTER, row.cfilter, -1);
 #else
-      gtk_list_store_set (store, &iter, CAPTURE, device.selected, IFACE_HIDDEN_NAME, device.name, INTERFACE, temp, LINK, link->name,  PMODE, device.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, device.cfilter, -1);
+      gtk_list_store_set (store, &iter, CAPTURE, found, INTERFACE, temp, LINK, link->name,  PMODE, row.pmode?"enabled":"disabled", SNAPLEN, snaplen_string, FILTER, row.cfilter, -1);
 #endif
     }
   }
@@ -3586,13 +4007,13 @@ gboolean query_tooltip_tree_view_cb (GtkWidget  *widget,
 void activate_monitor (GtkTreeViewColumn *tree_column _U_, GtkCellRenderer *renderer,
                               GtkTreeModel *tree_model, GtkTreeIter *iter, gpointer data _U_)
 {
-  interface_t device;
+  interface_row row;
   GtkTreePath *path = gtk_tree_model_get_path(tree_model, iter);
   int index = atoi(gtk_tree_path_to_string(path));
 
-  device = g_array_index(global_capture_opts.all_ifaces, interface_t, index);
+  row = g_array_index(rows, interface_row, index);
 
-  if (device.monitor_mode_supported==TRUE) {
+  if (row.monitor_mode_supported==TRUE) {
     g_object_set(G_OBJECT(renderer), "mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE, NULL);
   } else {
     g_object_set(G_OBJECT(renderer), "mode", GTK_CELL_RENDERER_MODE_INERT, NULL);
@@ -3653,16 +4074,16 @@ capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp _U_)
   if_capabilities_t *caps=NULL;
   gint linktype_count = 0, i;
   data_link_info_t *data_link_info;
-  interface_t device;
+  interface_row row;
   link_row *link;
   GtkWidget *linktype_combo_box = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_LT_CBX_KEY);
   GtkWidget *linktype_lb = g_object_get_data(G_OBJECT(linktype_combo_box), E_CAP_LT_CBX_LABEL_KEY);
 
-  device = g_array_index(global_capture_opts.all_ifaces, interface_t, marked_row);
-  global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, marked_row);
+  row = g_array_index(rows, interface_row, marked_row);
+  rows = g_array_remove_index(rows, marked_row);
 
 
-  if_string = g_strdup(device.name);
+  if_string = g_strdup(row.name);
   cap_settings = capture_get_cap_settings(if_string);
   cap_settings.monitor_mode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(monitor));
   caps = capture_get_if_capabilities(if_string, cap_settings.monitor_mode, NULL);
@@ -3670,15 +4091,15 @@ capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp _U_)
   if (caps != NULL) {
     g_signal_handlers_disconnect_by_func(linktype_combo_box, G_CALLBACK(select_link_type_cb), NULL );
     ws_combo_box_clear_text_and_pointer(GTK_COMBO_BOX(linktype_combo_box));
-    for (i = (gint)g_list_length(device.links)-1; i >= 0; i--) {
-      GList* rem = g_list_nth(device.links, i);
-      device.links = g_list_remove_link(device.links, rem);
+    for (i = (gint)g_list_length(row.links)-1; i >= 0; i--) {
+      GList* rem = g_list_nth(row.links, i);
+      row.links = g_list_remove_link(row.links, rem);
       g_list_free_1(rem);
     }
-    device.active_dlt = -1;
+    row.active_dlt = -1;
     linktype_count = 0;
-    device.monitor_mode_supported = caps->can_set_rfmon;
-    device.monitor_mode_enabled = cap_settings.monitor_mode;
+    row.monitor_mode_supported = caps->can_set_rfmon;
+    row.monitor_mode_enabled = cap_settings.monitor_mode;
     for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
       link = (link_row *)g_malloc(sizeof(link_row));
       data_link_info = lt_entry->data;
@@ -3688,7 +4109,7 @@ capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp _U_)
                                              GINT_TO_POINTER(data_link_info->dlt));
         link->dlt = data_link_info->dlt;
         if (linktype_count == 0) {
-          device.active_dlt = data_link_info->dlt;
+          row.active_dlt = data_link_info->dlt;
         }
         link->name = g_strdup(data_link_info->description);
       } else {
@@ -3704,7 +4125,7 @@ capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp _U_)
         link->name = g_strdup(str);
         g_free(str);
       }
-      device.links = g_list_append(device.links, link);
+      row.links = g_list_append(row.links, link);
       linktype_count++;
     }
     free_if_capabilities(caps);
@@ -3712,13 +4133,13 @@ capture_prep_monitor_changed_cb(GtkWidget *monitor, gpointer argp _U_)
     /* We don't know whether this supports monitor mode or not;
     don't ask for monitor mode. */
     cap_settings.monitor_mode = FALSE;
-    device.monitor_mode_enabled = FALSE;
-    device.monitor_mode_supported = FALSE;
+    row.monitor_mode_enabled = FALSE;
+    row.monitor_mode_supported = FALSE;
   }
   gtk_widget_set_sensitive(linktype_lb, linktype_count >= 2);
   gtk_widget_set_sensitive(linktype_combo_box, linktype_count >= 2);
   ws_combo_box_set_active(GTK_COMBO_BOX(linktype_combo_box),0);
-  g_array_insert_val(global_capture_opts.all_ifaces, marked_row, device);
+  g_array_insert_val(rows, marked_row, row);
 }
 #endif
 
diff --git a/gtk/capture_dlg.h b/gtk/capture_dlg.h
index a3bb194c0b..c782596504 100644
--- a/gtk/capture_dlg.h
+++ b/gtk/capture_dlg.h
@@ -32,12 +32,60 @@
  *  @ingroup dialog_group
  */
 #include "capture_opts.h"
-#include <gtk/gtk.h>
+
+#ifdef HAVE_PCAP_REMOTE
+struct remote_host {
+    gchar *remote_host;          /**< Host name or network address for remote capturing */
+    gchar *remote_port;          /**< TCP port of remote RPCAP server */
+    gint auth_type;              /**< Authentication type */
+    gchar *auth_username;        /**< Remote authentication parameters */
+    gchar *auth_password;        /**< Remote authentication parameters */
+    gboolean datatx_udp;
+    gboolean nocap_rpcap;
+    gboolean nocap_local;
+};
+
+typedef struct remote_options_tag {
+    capture_source src_type;
+    struct remote_host remote_host_opts;
+#ifdef HAVE_PCAP_SETSAMPLING
+    capture_sampling sampling_method;
+    int sampling_param;
+#endif
+} remote_options;
+#endif /* HAVE_PCAP_REMOTE */
+
+typedef struct row_options_tag {
+    gchar *name;
+    gchar *display_name;
+    gchar *addresses;
+    gint no_addresses;
+    gchar *cfilter;
+    GList *links;
+    gint active_dlt;
+    gboolean pmode;
+#ifdef HAVE_PCAP_CREATE
+    gboolean monitor_mode_enabled;
+    gboolean monitor_mode_supported;
+#endif
+    gboolean has_snaplen;
+    guint snaplen;
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+    gint buffer;
+#endif
+#ifdef HAVE_PCAP_REMOTE
+    remote_options remote_opts;
+#endif
+} interface_row;
+
+typedef struct link_row_tag {
+    gchar *name;
+    gint dlt;
+} link_row;
 
 enum
 {
     CAPTURE = 0,
-	IFACE_HIDDEN_NAME, 
     INTERFACE,
     LINK,
     PMODE,
@@ -95,7 +143,6 @@ void capture_start_confirmed(void);
 void
 capture_air_cb(GtkWidget *widget, gpointer data);
 
-#if 0
 /*
  * We remember the capture settings for each interface when a capture
  * is started on it; the next time we select that interface we start
@@ -116,7 +163,6 @@ typedef struct {
  */
 cap_settings_t
 capture_get_cap_settings (gchar *if_name);
-#endif
 
 GtkTreeModel*
 create_and_fill_model (GtkTreeView *view);
@@ -156,12 +202,9 @@ gboolean
 dlg_window_present(void);
 
 void
-enable_selected_interface(gchar *name, gboolean selected);
+enable_selected_interface(gchar *name, gboolean enable);
 
 void
 options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column _U_, gpointer userdata);
 
-void
-update_all_rows(void);
-
 #endif /* capture_dlg.h */
diff --git a/gtk/capture_if_dlg.c b/gtk/capture_if_dlg.c
index 527a604c89..7afacaa1c6 100644
--- a/gtk/capture_if_dlg.c
+++ b/gtk/capture_if_dlg.c
@@ -110,13 +110,15 @@
  */
 static GtkWidget *cap_if_w;
 
+static GList     *if_data_list = NULL;
+
 static guint     timer_id;
 
 static GtkWidget *stop_bt, *capture_bt, *options_bt;
 
 static GList     *if_list;
 
-static GArray    *gtk_list;
+static guint     currently_selected = 0;
 
 static if_stat_cache_t   *sc;
 
@@ -128,7 +130,6 @@ static if_stat_cache_t   *sc;
 
 /* the "runtime" data of one interface */
 typedef struct if_dlg_data_s {
-    gchar       *device;
     GtkWidget   *device_lb;
     GtkWidget   *descr_lb;
     GtkWidget   *ip_lb;
@@ -138,65 +139,128 @@ typedef struct if_dlg_data_s {
 #ifdef _WIN32
     GtkWidget   *details_bt;
 #endif
+    guint32     last_packets;
+    gchar       *device;
+    if_info_t   if_info;
+    gboolean    selected;
 } if_dlg_data_t;
 
 static gboolean gbl_capture_in_progress = FALSE;
 
 void
-update_selected_interface(gchar *name)
+update_selected_interface(gchar *name, gboolean activate)
 {
-  guint i;
-  interface_t device;
-  if_dlg_data_t data;
-
-  for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-    device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-    data = g_array_index(gtk_list, if_dlg_data_t, i);
-    if (strcmp(name, device.name) == 0) {
-      gtk_toggle_button_set_active((GtkToggleButton *)data.choose_bt, device.selected);
+  guint ifs;
+  GList *curr;
+  if_dlg_data_t *temp;
+
+  for (ifs = 0; ifs < g_list_length(if_data_list); ifs++) {
+    curr = g_list_nth(if_data_list, ifs);
+    temp = (if_dlg_data_t *)(curr->data);
+    if (strcmp(name, temp->if_info.name) == 0) {
+      if (activate) {
+        gtk_toggle_button_set_active((GtkToggleButton *)temp->choose_bt, TRUE);
+      } else {
+        gtk_toggle_button_set_active((GtkToggleButton *)temp->choose_bt, FALSE);
+      }
       break;
     }
   }
 }
 
 static void
-store_selected(GtkWidget *choose_bt, gpointer name)
+store_selected(GtkWidget *choose_bt, gpointer if_data)
 {
-  interface_t device;
-  guint i;
+  if_dlg_data_t *if_dlg_data = if_data, *temp;
+  GList *curr;
+  unsigned int ifs, i;
   gboolean found;
-  for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-    device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
+  cap_settings_t cap_settings;
+  interface_options interface_opts;
+
+  for (ifs = 0; ifs < g_list_length(if_data_list); ifs++) {
+    curr = g_list_nth(if_data_list, ifs);
+    temp = (if_dlg_data_t *)(curr->data);
     found = FALSE;
-    if (strcmp(name, device.if_info.name) == 0) {
-      found = TRUE;
-      if (!device.locked) {
-        device.selected ^= 1;
-        if (device.selected) {
-          global_capture_opts.num_selected++;
-        } else {
-          global_capture_opts.num_selected--;
-        }
-        global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
-        g_array_insert_val(global_capture_opts.all_ifaces, i, device);
-        if (gtk_widget_is_focus(choose_bt) && get_welcome_window()) {
-          change_interface_selection(device.name, device.selected);
+    if (strcmp(if_dlg_data->if_info.name, temp->if_info.name) == 0) {
+      temp->selected ^=1;
+      if_data_list = g_list_remove(if_data_list, curr->data);
+      if_data_list = g_list_insert(if_data_list, temp, ifs);
+      
+      for (i = 0; i < global_capture_opts.ifaces->len; i++) {
+        if (strcmp(g_array_index(global_capture_opts.ifaces, interface_options, i).name, temp->if_info.name) == 0) {
+          found = TRUE;
+          if (!temp->selected) {
+            interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
+            global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
+            if (gtk_widget_is_focus(choose_bt) && get_welcome_window()) {
+              change_interface_selection(interface_opts.name, FALSE);
+            }
+            if (gtk_widget_is_focus(choose_bt) && dlg_window_present()) {
+              enable_selected_interface(interface_opts.name, FALSE);
+            }
+            g_free(interface_opts.name);
+            g_free(interface_opts.descr);
+            g_free(interface_opts.cfilter);
+#ifdef HAVE_PCAP_REMOTE
+            g_free(interface_opts.remote_host);
+            g_free(interface_opts.remote_port);
+            g_free(interface_opts.auth_username);
+            g_free(interface_opts.auth_password);
+#endif
+            break;
+          }
+        } 
+      } 
+      if (!found && temp->selected) {
+        interface_opts.name = g_strdup(temp->if_info.name);
+        interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
+        interface_opts.linktype = capture_dev_user_linktype_find(interface_opts.name);
+        interface_opts.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
+        interface_opts.has_snaplen = global_capture_opts.default_options.has_snaplen;
+        interface_opts.snaplen = global_capture_opts.default_options.snaplen;
+        cap_settings = capture_get_cap_settings (interface_opts.name);;
+        interface_opts.promisc_mode = global_capture_opts.default_options.promisc_mode;
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+        interface_opts.buffer_size =  global_capture_opts.default_options.buffer_size;
+#endif
+        interface_opts.monitor_mode = cap_settings.monitor_mode;
+#ifdef HAVE_PCAP_REMOTE
+        interface_opts.src_type = global_capture_opts.default_options.src_type;
+        interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
+        interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
+        interface_opts.auth_type = global_capture_opts.default_options.auth_type;
+        interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
+        interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
+        interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
+        interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
+        interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
+#endif
+#ifdef HAVE_PCAP_SETSAMPLING
+        interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
+        interface_opts.sampling_param  = global_capture_opts.default_options.sampling_param;
+#endif
+        g_array_append_val(global_capture_opts.ifaces, interface_opts);
+        if (gtk_widget_is_focus(choose_bt) && get_welcome_window() != NULL) {
+          change_interface_selection(g_strdup(temp->if_info.name), TRUE);
         }
         if (gtk_widget_is_focus(choose_bt) && dlg_window_present()) {
-          enable_selected_interface(device.name, device.selected);
+          enable_selected_interface(interface_opts.name, TRUE);
         }
-        device.locked = FALSE;
-        global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
-        g_array_insert_val(global_capture_opts.all_ifaces, i, device);
       }
+      
+      if (temp->selected)
+        currently_selected += 1;
+      else
+        currently_selected -= 1;
       break;
     }
   }
   if (cap_if_w) {
 #ifdef USE_THREADS
-    gtk_widget_set_sensitive(capture_bt, !gbl_capture_in_progress && (global_capture_opts.num_selected > 0));
+    gtk_widget_set_sensitive(capture_bt, !gbl_capture_in_progress && (currently_selected > 0));
 #else
-    gtk_widget_set_sensitive(capture_bt, !gbl_capture_in_progress && (global_capture_opts.num_selected == 1));
+    gtk_widget_set_sensitive(capture_bt, !gbl_capture_in_progress && (currently_selected == 1));
 #endif
   }
 }
@@ -209,18 +273,19 @@ capture_do_cb(GtkWidget *capture_bt _U_, gpointer if_data)
 capture_do_cb(GtkWidget *capture_bt _U_, gpointer if_data _U_)
 #endif
 {
-  if_dlg_data_t data;
-  guint ifs;
-
-  for (ifs = 0; ifs < gtk_list->len; ifs++) {
-    data = g_array_index(gtk_list, if_dlg_data_t, ifs);
-    gtk_widget_set_sensitive(data.choose_bt, FALSE);
-    gtk_list = g_array_remove_index(gtk_list, ifs);
-    g_array_insert_val(gtk_list, ifs, data);
+  if_dlg_data_t *temp;
+  GList *curr;
+  int ifs;
 #ifdef HAVE_AIRPCAP
-    airpcap_if_active = get_airpcap_if_from_name(airpcap_if_list, gtk_label_get_text(GTK_LABEL(data.device_lb)));
-    airpcap_if_selected = airpcap_if_active;
+  if_dlg_data_t *if_dlg_data = if_data;
+
+  airpcap_if_active = get_airpcap_if_from_name(airpcap_if_list, if_dlg_data->if_info.name);
+  airpcap_if_selected = airpcap_if_active;
 #endif
+
+  for (ifs = 0; (curr = g_list_nth(if_data_list, ifs)); ifs++) {
+    temp = (if_dlg_data_t *)(curr->data);
+    gtk_widget_set_sensitive(temp->choose_bt, FALSE);
   }
 
   /* XXX - remove this? */
@@ -266,14 +331,11 @@ capture_details_cb(GtkWidget *details_bt _U_, gpointer if_data)
 
 /* update a single interface */
 static void
-update_if(gchar *name, if_stat_cache_t *sc)
+update_if(if_dlg_data_t *if_dlg_data, if_stat_cache_t *sc)
 {
   struct pcap_stat stats;
   gchar *str;
-  guint diff, ifs;
-  interface_t  device;
-  if_dlg_data_t data;
-  gboolean  found = FALSE;
+  guint diff;
 
 
   /*
@@ -284,40 +346,23 @@ update_if(gchar *name, if_stat_cache_t *sc)
    * That's a bug, and should be fixed; "pcap_stats()" is supposed
    * to work the same way on all platforms.
    */
-  device.last_packets = 0;
-  data.curr_lb = NULL;
-  data.last_lb = NULL;
   if (sc) {
-    for (ifs = 0; ifs < global_capture_opts.all_ifaces->len; ifs++) {
-        device = g_array_index(global_capture_opts.all_ifaces, interface_t, ifs);
-        data = g_array_index(gtk_list, if_dlg_data_t, ifs);
-        if (!device.hidden && strcmp(name, device.name) == 0) {
-          found = TRUE;
-          break;
-        }
-    }
-    if (found) {
-      if (capture_stats(sc, name, &stats)) {
-        diff = stats.ps_recv - device.last_packets;
-        device.last_packets = stats.ps_recv;
-  
-        str = g_strdup_printf("%u", device.last_packets);
-        gtk_label_set_text(GTK_LABEL(data.curr_lb), str);
-        g_free(str);
-        str = g_strdup_printf("%u", diff);
-        gtk_label_set_text(GTK_LABEL(data.last_lb), str);
-        g_free(str);
-  
-        gtk_widget_set_sensitive(data.curr_lb, diff);
-        gtk_widget_set_sensitive(data.last_lb, diff);
-      } else {
-        gtk_label_set_text(GTK_LABEL(data.curr_lb), "error");
-        gtk_label_set_text(GTK_LABEL(data.last_lb), "error");
-      }
-      global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, ifs);
-      g_array_insert_val(global_capture_opts.all_ifaces, ifs, device);
-      gtk_list = g_array_remove_index(gtk_list, ifs);
-      g_array_insert_val(gtk_list, ifs, data);
+    if (capture_stats(sc, if_dlg_data->device, &stats)) {
+      diff = stats.ps_recv - if_dlg_data->last_packets;
+      if_dlg_data->last_packets = stats.ps_recv;
+
+      str = g_strdup_printf("%u", if_dlg_data->last_packets);
+      gtk_label_set_text(GTK_LABEL(if_dlg_data->curr_lb), str);
+      g_free(str);
+      str = g_strdup_printf("%u", diff);
+      gtk_label_set_text(GTK_LABEL(if_dlg_data->last_lb), str);
+      g_free(str);
+
+      gtk_widget_set_sensitive(if_dlg_data->curr_lb, diff);
+      gtk_widget_set_sensitive(if_dlg_data->last_lb, diff);
+    } else {
+      gtk_label_set_text(GTK_LABEL(if_dlg_data->curr_lb), "error");
+      gtk_label_set_text(GTK_LABEL(if_dlg_data->last_lb), "error");
     }
   }
 }
@@ -326,17 +371,16 @@ update_if(gchar *name, if_stat_cache_t *sc)
 static gboolean
 update_all(gpointer data)
 {
-    interface_t device;
-    guint ifs;
+    GList *curr;
+    int ifs;
     if_stat_cache_t *sc = data;
 
     if (!cap_if_w) {
         return FALSE;
     }
 
-    for (ifs = 0; ifs < global_capture_opts.all_ifaces->len; ifs++) {
-        device = g_array_index(global_capture_opts.all_ifaces, interface_t, ifs);
-        update_if(device.name, sc);
+    for (ifs = 0; (curr = g_list_nth(if_data_list, ifs)); ifs++) {
+        update_if(curr->data, sc);
     }
 
     return TRUE;
@@ -350,9 +394,9 @@ set_capture_if_dialog_for_capture_in_progress(gboolean capture_in_progress)
   if (cap_if_w) {
     gtk_widget_set_sensitive(stop_bt, capture_in_progress);
 #ifdef USE_THREADS
-    gtk_widget_set_sensitive(capture_bt, !capture_in_progress && (global_capture_opts.num_selected > 0));
+    gtk_widget_set_sensitive(capture_bt, !capture_in_progress && (currently_selected > 0));
 #else
-    gtk_widget_set_sensitive(capture_bt, !capture_in_progress && (global_capture_opts.num_selected == 1));
+    gtk_widget_set_sensitive(capture_bt, !capture_in_progress && (currently_selected == 1));
 #endif
   }
 }
@@ -362,8 +406,17 @@ set_capture_if_dialog_for_capture_in_progress(gboolean capture_in_progress)
 static void
 capture_if_destroy_cb(GtkWidget *win _U_, gpointer user_data _U_)
 {
+    GList *curr;
+    int ifs;
+
     g_source_remove(timer_id);
 
+    for (ifs = 0; (curr = g_list_nth(if_data_list, ifs)); ifs++) {
+        g_free(curr->data);
+    }
+
+    if_data_list = NULL;
+
     free_interface_list(if_list);
 
     /* Note that we no longer have a "Capture Options" dialog box. */
@@ -648,41 +701,17 @@ static void
 capture_if_stop_cb(GtkWidget *w _U_, gpointer d _U_)
 {
   guint ifs;
-  if_dlg_data_t data;
+  GList *curr;
+  if_dlg_data_t *if_data;
 
-  for (ifs = 0; ifs < gtk_list->len; ifs++) {
-    data = g_array_index(gtk_list, if_dlg_data_t, ifs);
-    gtk_widget_set_sensitive(data.choose_bt, TRUE);
-    gtk_list = g_array_remove_index(gtk_list, ifs);
-    g_array_insert_val(gtk_list, ifs, data);
+  for (ifs = 0; ifs < g_list_length(if_data_list); ifs++) {
+    curr = g_list_nth(if_data_list, ifs);
+    if_data = (if_dlg_data_t *)(curr->data);
+    gtk_widget_set_sensitive(if_data->choose_bt, TRUE);
   }
   capture_stop_cb(NULL, NULL);
 }
 
-static void
-make_gtk_array(void)
-{
-  interface_t   device;
-  if_dlg_data_t data;
-  guint         i;
-  
-  gtk_list = g_array_new(FALSE, FALSE, sizeof(if_dlg_data_t));
-  
-  for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-     device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-     data.device_lb  = NULL;
-     data.descr_lb   = NULL;
-     data.ip_lb      = NULL;
-     data.curr_lb    = NULL;
-     data.last_lb    = NULL;
-     data.choose_bt  = NULL;
-#ifdef _WIN32
-     data.details_bt = NULL;
-#endif
-     g_array_append_val(gtk_list, data);
-  }
-  
-}
 
 /* start getting capture stats from all interfaces */
 void
@@ -692,23 +721,30 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_)
                     *main_sw,
                     *bbox,
                     *close_bt,
-                    *help_bt;
+                    *help_bt,
+                    *icon;
 
 #ifdef HAVE_AIRPCAP
   GtkWidget         *decryption_cb;
 #endif
 
-  GtkWidget         *if_tb, *icon;
+  GtkWidget         *if_tb;
   GtkWidget         *if_lb;
   GtkWidget         *eb;
+  int               err;
+  gchar             *err_str;
   GtkRequisition    requisition;
   int               row, height;
-  guint             ifs;
-  interface_t       device;
+  if_dlg_data_t     *if_dlg_data = NULL;
+  int               ifs;
+  GList             *curr;
+  if_info_t         *if_info;
   GString           *if_tool_str = g_string_new("");
   const gchar       *addr_str;
   gchar             *user_descr;
-  if_dlg_data_t     data;
+  int               preselected = 0, i;
+  interface_options interface_opts;
+  gboolean      found = FALSE;
 
   if (cap_if_w != NULL) {
     /* There's already a "Capture Interfaces" dialog box; reactivate it. */
@@ -727,13 +763,43 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_)
     return;
   }
 #endif
+  preselected = global_capture_opts.ifaces->len;
+  /* LOAD THE INTERFACES */
+  if_list = capture_interface_list(&err, &err_str);
+  if_list = g_list_sort (if_list, if_list_comparator_alph);
+  if (if_list == NULL) {
+    switch (err) {
+
+    case CANT_GET_INTERFACE_LIST:
+      simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
+      g_free(err_str);
+      break;
+
+    case NO_INTERFACES_FOUND:
+      simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
+                    "There are no interfaces on which a capture can be done.");
+      break;
+    }
+    return;
+  }
 
 #ifdef HAVE_AIRPCAP
   /* LOAD AIRPCAP INTERFACES */
+  airpcap_if_list = get_airpcap_interface_list(&err, &err_str);
+  if (airpcap_if_list == NULL)
+    airpcap_if_active = airpcap_if_selected = NULL;
 
   decryption_cb = g_object_get_data(G_OBJECT(airpcap_tb),AIRPCAP_TOOLBAR_DECRYPTION_KEY);
   update_decryption_mode_list(decryption_cb);
 
+  if (airpcap_if_list == NULL && err == CANT_GET_AIRPCAP_INTERFACE_LIST) {
+#if 0
+    /* XXX - Do we need to show an error here? */
+    simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
+#endif
+    g_free(err_str);
+  }
+
   /* If no airpcap interface is present, gray everything */
   if (airpcap_if_active == NULL) {
     if (airpcap_if_list == NULL) {
@@ -749,7 +815,6 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_)
   airpcap_set_toolbar_start_capture(airpcap_if_active);
 #endif
 
-  make_gtk_array();
   cap_if_w = dlg_window_new("Wireshark: Capture Interfaces");  /* transient_for top_level */
   gtk_window_set_destroy_with_parent (GTK_WINDOW(cap_if_w), TRUE);
 
@@ -797,109 +862,142 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_)
 
   height += 30;
   /* Start gathering statistics (using dumpcap) */
-  sc = capture_stat_start(&global_capture_opts);
+  sc = capture_stat_start(if_list);
 
   /* List the interfaces */
-  for (ifs = 0; ifs < global_capture_opts.all_ifaces->len; ifs++) {
-    device = g_array_index(global_capture_opts.all_ifaces, interface_t, ifs);
-    data = g_array_index(gtk_list, if_dlg_data_t, ifs);
+  currently_selected = 0;
+  for (ifs = 0; (curr = g_list_nth(if_list, ifs)); ifs++) {
     g_string_assign(if_tool_str, "");
+    if_info = curr->data;
+
     /* Continue if capture device is hidden */
-    if (device.hidden) {
+    if (prefs_is_capture_device_hidden(if_info->name)) {
       continue;
     }
-    data.choose_bt = gtk_check_button_new();
-    gtk_table_attach_defaults(GTK_TABLE(if_tb), data.choose_bt, 0, 1, row, row+1);
+
+    if_dlg_data = g_malloc0(sizeof(if_dlg_data_t));
+
+    if (preselected > 0) {
+      found = FALSE;
+      for (i = 0; i < (gint)global_capture_opts.ifaces->len; i++) {
+        interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
+        if ((interface_opts.name == NULL) ||
+            (strcmp(interface_opts.name, (char*)if_info->name) != 0)) {
+          continue;
+        } else {
+          found = TRUE;
+          currently_selected++;
+          preselected--;
+          break;
+        }
+      }
+      if_dlg_data->selected = found;
+    } else {
+      if_dlg_data->selected = FALSE;
+    }
+    if_dlg_data->if_info = *if_info;
+
+    if_dlg_data->choose_bt = gtk_check_button_new();
+    gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->choose_bt, 0, 1, row, row+1);
     if (gbl_capture_in_progress) {
-      gtk_widget_set_sensitive(data.choose_bt, FALSE);
+      gtk_widget_set_sensitive(if_dlg_data->choose_bt, FALSE);
     } else {
-      gtk_widget_set_sensitive(data.choose_bt, TRUE);
+      gtk_widget_set_sensitive(if_dlg_data->choose_bt, TRUE);
     }
-    gtk_toggle_button_set_active((GtkToggleButton *)data.choose_bt, device.selected);
-    g_signal_connect(data.choose_bt, "toggled", G_CALLBACK(store_selected), device.name);
-    /* Kind of adaptor (icon) */
-    icon = capture_get_if_icon(&(device.if_info));
+    gtk_toggle_button_set_active((GtkToggleButton *)if_dlg_data->choose_bt, if_dlg_data->selected);
+    g_signal_connect(if_dlg_data->choose_bt, "toggled", G_CALLBACK(store_selected), if_dlg_data);
+     /* Kind of adaptor (icon) */
+#ifdef HAVE_AIRPCAP
+    if (get_airpcap_if_from_name(airpcap_if_list,if_info->name) != NULL)
+      icon = xpm_to_widget(capture_airpcap_16_xpm);
+    else
+      icon = capture_get_if_icon(if_info);
+#else
+    icon = capture_get_if_icon(if_info);
+#endif
     gtk_table_attach_defaults(GTK_TABLE(if_tb), icon, 1, 2, row, row+1);
 
       /* device name */
-    data.device_lb = gtk_label_new(device.name);
+    if_dlg_data->device_lb = gtk_label_new(if_info->name);
+    if_dlg_data->device = if_info->name;
 #ifndef _WIN32
-    gtk_misc_set_alignment(GTK_MISC(data.device_lb), 0.0f, 0.5f);
-    gtk_table_attach_defaults(GTK_TABLE(if_tb), data.device_lb, 2, 4, row, row+1);
+    gtk_misc_set_alignment(GTK_MISC(if_dlg_data->device_lb), 0.0f, 0.5f);
+    gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->device_lb, 2, 4, row, row+1);
 #endif
     g_string_append(if_tool_str, "Device: ");
-    g_string_append(if_tool_str, device.name);
+    g_string_append(if_tool_str, if_info->name);
     g_string_append(if_tool_str, "\n");
 
     /* description */
-    user_descr = capture_dev_user_descr_find(device.name);
+    user_descr = capture_dev_user_descr_find(if_info->name);
     if (user_descr) {
-      data.descr_lb = gtk_label_new(user_descr);
+      if_dlg_data->descr_lb = gtk_label_new(user_descr);
       g_free (user_descr);
     } else {
-      if (device.if_info.description)
-        data.descr_lb = gtk_label_new(device.if_info.description);
+      if (if_info->description)
+        if_dlg_data->descr_lb = gtk_label_new(if_info->description);
       else
-        data.descr_lb = gtk_label_new("");
+        if_dlg_data->descr_lb = gtk_label_new("");
     }
-    gtk_misc_set_alignment(GTK_MISC(data.descr_lb), 0.0f, 0.5f);
-    gtk_table_attach_defaults(GTK_TABLE(if_tb), data.descr_lb, 4, 5, row, row+1);
-    if (device.if_info.description) {
+    gtk_misc_set_alignment(GTK_MISC(if_dlg_data->descr_lb), 0.0f, 0.5f);
+    gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->descr_lb, 4, 5, row, row+1);
+
+    if (if_info->description) {
       g_string_append(if_tool_str, "Description: ");
-      g_string_append(if_tool_str, device.if_info.description);
+      g_string_append(if_tool_str, if_info->description);
       g_string_append(if_tool_str, "\n");
     }
 
     /* IP address */
     /* Only one IP address will be shown, start with the first */
     g_string_append(if_tool_str, "IP: ");
-    data.ip_lb = gtk_label_new("");
-    addr_str = set_ip_addr_label (device.if_info.addrs, data.ip_lb, 0);
+    if_dlg_data->ip_lb = gtk_label_new("");
+    addr_str = set_ip_addr_label (if_info->addrs, if_dlg_data->ip_lb, 0);
     if (addr_str) {
-      gtk_widget_set_sensitive(data.ip_lb, TRUE);
+      gtk_widget_set_sensitive(if_dlg_data->ip_lb, TRUE);
       g_string_append(if_tool_str, addr_str);
     } else {
-      gtk_widget_set_sensitive(data.ip_lb, FALSE);
+      gtk_widget_set_sensitive(if_dlg_data->ip_lb, FALSE);
       g_string_append(if_tool_str, "none");
     }
     eb = gtk_event_box_new ();
-    gtk_container_add(GTK_CONTAINER(eb), data.ip_lb);
+    gtk_container_add(GTK_CONTAINER(eb), if_dlg_data->ip_lb);
     gtk_table_attach_defaults(GTK_TABLE(if_tb), eb, 5, 6, row, row+1);
-    if (get_ip_addr_count(device.if_info.addrs) > 1) {
+    if (get_ip_addr_count(if_info->addrs) > 1) {
       /* More than one IP address, make it possible to toggle */
-      g_object_set_data(G_OBJECT(eb), CAPTURE_IF_IP_ADDR_LABEL, data.ip_lb);
+      g_object_set_data(G_OBJECT(eb), CAPTURE_IF_IP_ADDR_LABEL, if_dlg_data->ip_lb);
       g_signal_connect(eb, "enter-notify-event", G_CALLBACK(ip_label_enter_cb), NULL);
       g_signal_connect(eb, "leave-notify-event", G_CALLBACK(ip_label_leave_cb), NULL);
-      g_signal_connect(eb, "button-press-event", G_CALLBACK(ip_label_press_cb), device.if_info.addrs);
+      g_signal_connect(eb, "button-press-event", G_CALLBACK(ip_label_press_cb), if_info->addrs);
     }
     g_string_append(if_tool_str, "\n");
 
     /* packets */
-    data.curr_lb = gtk_label_new("-");
-    gtk_table_attach_defaults(GTK_TABLE(if_tb), data.curr_lb, 6, 7, row, row+1);
+    if_dlg_data->curr_lb = gtk_label_new("-");
+    gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->curr_lb, 6, 7, row, row+1);
 
     /* packets/s */
-    data.last_lb = gtk_label_new("-");
-    gtk_table_attach_defaults(GTK_TABLE(if_tb), data.last_lb, 7, 8, row, row+1);
+    if_dlg_data->last_lb = gtk_label_new("-");
+    gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->last_lb, 7, 8, row, row+1);
 
     /* details button */
 #ifdef _WIN32
-    data.details_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_CAPTURE_DETAILS);
-    gtk_widget_set_tooltip_text(data.details_bt, "Open the capture details dialog of this interface.");
-    gtk_table_attach_defaults(GTK_TABLE(if_tb), data.details_bt, 8, 9, row, row+1);
-    if (capture_if_has_details(device.name)) {
-      g_signal_connect(data.details_bt, "clicked", G_CALLBACK(capture_details_cb), device.name);
+    if_dlg_data->details_bt = gtk_button_new_from_stock(WIRESHARK_STOCK_CAPTURE_DETAILS);
+    gtk_widget_set_tooltip_text(if_dlg_data->details_bt, "Open the capture details dialog of this interface.");
+    gtk_table_attach_defaults(GTK_TABLE(if_tb), if_dlg_data->details_bt, 8, 9, row, row+1);
+    if (capture_if_has_details(if_dlg_data->device)) {
+      g_signal_connect(if_dlg_data->details_bt, "clicked", G_CALLBACK(capture_details_cb), if_dlg_data);
     } else {
-      gtk_widget_set_sensitive(data.details_bt, FALSE);
+      gtk_widget_set_sensitive(if_dlg_data->details_bt, FALSE);
     }
 #endif
-    gtk_list = g_array_remove_index(gtk_list, ifs);
-    g_array_insert_val(gtk_list, ifs, data);
+
+    if_data_list = g_list_append(if_data_list, if_dlg_data);
     
     row++;
     if (row <= 10) {
         /* Lets add up 10 rows of interfaces, otherwise the window may become too high */
-      gtk_widget_get_preferred_size(GTK_WIDGET(data.choose_bt), &requisition, NULL);
+      gtk_widget_get_preferred_size(GTK_WIDGET(if_dlg_data->choose_bt), &requisition, NULL);
       height += requisition.height;
     } 
   }
@@ -919,9 +1017,9 @@ capture_if_cb(GtkWidget *w _U_, gpointer d _U_)
   window_set_cancel_button(cap_if_w, close_bt, window_cancel_button_cb);
   gtk_widget_set_tooltip_text(close_bt, "Close this window.");
   options_bt = g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_CAPTURE_OPTIONS);
-  g_signal_connect(options_bt, "clicked", G_CALLBACK(capture_prepare_cb), device.name);
+  g_signal_connect(options_bt, "clicked", G_CALLBACK(capture_prepare_cb), if_dlg_data);
   capture_bt = g_object_get_data(G_OBJECT(bbox), WIRESHARK_STOCK_CAPTURE_START);
-  g_signal_connect(capture_bt, "clicked", G_CALLBACK(capture_do_cb), device.name);
+  g_signal_connect(capture_bt, "clicked", G_CALLBACK(capture_do_cb), if_dlg_data);
   gtk_widget_get_preferred_size(GTK_WIDGET(close_bt), &requisition, NULL);
   /* height + static offset + what the GTK MS Windows Engine needs in addition per interface */
   height += requisition.height + 40 + ifs;
@@ -952,14 +1050,16 @@ void refresh_if_window(void)
   capture_if_cb(NULL, NULL);
 }
 
-void select_all_interfaces(gboolean enable _U_)
+void select_all_interfaces(gboolean enable)
 {
+  if_dlg_data_t *temp;
   guint ifs;
-  interface_t device;
+  GList *curr;
 
-  for (ifs = 0; ifs < global_capture_opts.all_ifaces->len; ifs++) {
-    device = g_array_index(global_capture_opts.all_ifaces, interface_t, ifs);
-    update_selected_interface(device.if_info.name);
+  for (ifs = 0; ifs < g_list_length(if_data_list); ifs++) {
+    curr = g_list_nth(if_data_list, ifs);
+    temp = (if_dlg_data_t *)(curr->data);
+    update_selected_interface(temp->if_info.name, enable);
  } 
 }
 
diff --git a/gtk/capture_if_dlg.h b/gtk/capture_if_dlg.h
index 253c3949c7..3c2f2359d0 100644
--- a/gtk/capture_if_dlg.h
+++ b/gtk/capture_if_dlg.h
@@ -51,7 +51,7 @@ GtkWidget *
 capture_get_if_icon(const if_info_t* if_info);
 
 void
-update_selected_interface(gchar *name);
+update_selected_interface(gchar *name, gboolean activate);
 
 gboolean
 interfaces_dialog_window_present(void);
@@ -65,9 +65,6 @@ select_all_interfaces(gboolean enable);
 void
 destroy_if_window(void);
 
-gint 
-if_list_comparator_alph (const void *first_arg, const void *second_arg);
-
 #endif /* HAVE_LIBPCAP */
 
 #endif /* capture_if_dlg.h */
diff --git a/gtk/main.c b/gtk/main.c
index 2267551078..3f5bda29c6 100644
--- a/gtk/main.c
+++ b/gtk/main.c
@@ -114,7 +114,6 @@
 #include "../capture_ifinfo.h"
 #include "../capture.h"
 #include "../capture_sync.h"
-extern gint if_list_comparator_alph (const void *first_arg, const void *second_arg);
 #endif
 
 #ifdef _WIN32
@@ -513,16 +512,16 @@ selected_ptree_ref_cb(GtkWidget *widget _U_, gpointer data _U_)
 static gboolean
 is_address_column (gint column)
 {
-    if (((cfile.cinfo.col_fmt[column] == COL_DEF_SRC) ||
-         (cfile.cinfo.col_fmt[column] == COL_RES_SRC) ||
-         (cfile.cinfo.col_fmt[column] == COL_DEF_DST) ||
-         (cfile.cinfo.col_fmt[column] == COL_RES_DST)) &&
-          strlen(cfile.cinfo.col_expr.col_expr_val[column]))
-    {
-        return TRUE;
-    }
+  if (((cfile.cinfo.col_fmt[column] == COL_DEF_SRC) ||
+       (cfile.cinfo.col_fmt[column] == COL_RES_SRC) ||
+       (cfile.cinfo.col_fmt[column] == COL_DEF_DST) ||
+       (cfile.cinfo.col_fmt[column] == COL_RES_DST)) &&
+      strlen(cfile.cinfo.col_expr.col_expr_val[column]))
+  {
+    return TRUE;
+  }
 
-    return FALSE;
+  return FALSE;
 }
 
 GList *
@@ -548,17 +547,17 @@ get_ip_address_list_from_packet_list_row(gpointer data)
         epan_dissect_run(&edt, &cfile.pseudo_header, cfile.pd, fdata, &cfile.cinfo);
         epan_dissect_fill_in_columns(&edt, TRUE, TRUE);
 
-        /* First check selected column */
-        if (is_address_column (column)) {
-            addr_list = g_list_append (addr_list, se_strdup_printf("%s", cfile.cinfo.col_expr.col_expr_val[column]));
+	/* First check selected column */
+	if (is_address_column (column)) {
+	  addr_list = g_list_append (addr_list, se_strdup_printf("%s", cfile.cinfo.col_expr.col_expr_val[column]));
         }
 
-        for (col = 0; col < cfile.cinfo.num_cols; col++) {
-            /* Then check all columns except the selected */
-            if ((col != column) && (is_address_column (col))) {
-                addr_list = g_list_append (addr_list, se_strdup_printf("%s", cfile.cinfo.col_expr.col_expr_val[col]));
-            }
-        }
+	for (col = 0; col < cfile.cinfo.num_cols; col++) {
+	  /* Then check all columns except the selected */
+	  if ((col != column) && (is_address_column (col))) {
+	    addr_list = g_list_append (addr_list, se_strdup_printf("%s", cfile.cinfo.col_expr.col_expr_val[col]));
+	  }
+	}
 
         epan_dissect_cleanup(&edt);
     }
@@ -695,7 +694,7 @@ set_frame_reftime(gboolean set, frame_data *frame, gint row) {
     return;
   if (set) {
     frame->flags.ref_time=1;
-    cfile.ref_time_count++;
+	cfile.ref_time_count++;
   } else {
     frame->flags.ref_time=0;
     cfile.ref_time_count--;
@@ -717,8 +716,8 @@ static void reftime_answered_cb(gpointer dialog _U_, gint btn, gpointer data _U_
     case(ESD_BTN_YES):
         timestamp_set_type(TS_RELATIVE);
         recent.gui_time_format  = TS_RELATIVE;
-        cf_timestamp_auto_precision(&cfile);
-        new_packet_list_queue_draw();
+		cf_timestamp_auto_precision(&cfile);
+		new_packet_list_queue_draw();
         break;
     case(ESD_BTN_NO):
         break;
@@ -728,7 +727,7 @@ static void reftime_answered_cb(gpointer dialog _U_, gint btn, gpointer data _U_
 
     if (cfile.current_frame) {
       set_frame_reftime(!cfile.current_frame->flags.ref_time,
-      cfile.current_frame, cfile.current_row);
+			cfile.current_frame, cfile.current_row);
     }
 }
 
@@ -1400,9 +1399,6 @@ npf_warning_dialog_cb(gpointer dialog, gint btn _U_, gpointer data _U_)
 static void
 main_cf_cb_file_closing(capture_file *cf)
 {
-#ifdef HAVE_LIBPCAP
-    int i;
-#endif
 
     /* if we have more than 10000 packets, show a splash screen while closing */
     /* XXX - don't know a better way to decide whether to show or not,
@@ -1421,14 +1417,6 @@ main_cf_cb_file_closing(capture_file *cf)
     destroy_packet_wins();
     file_save_as_destroy();
 
-#ifdef HAVE_LIBPCAP
-    if (global_capture_opts.ifaces && global_capture_opts.ifaces->len > 0) {
-        for (i = (int)global_capture_opts.ifaces->len-1; i >= 0; i--) {
-            global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
-        }
-    } 
-#endif
-    
     /* Restore the standard title bar message. */
     set_main_window_name("The Wireshark Network Analyzer");
 
@@ -2186,8 +2174,8 @@ main(int argc, char *argv[])
   recent_read_static(&rf_path, &rf_open_errno);
   if (rf_path != NULL && rf_open_errno != 0) {
     simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
-      "Could not open common recent file\n\"%s\": %s.",
-      rf_path, g_strerror(rf_open_errno));
+		  "Could not open common recent file\n\"%s\": %s.",
+		  rf_path, g_strerror(rf_open_errno));
   }
 
   /* "pre-scan" the command line parameters, if we have "console only"
@@ -2206,13 +2194,13 @@ main(int argc, char *argv[])
   while ((opt = getopt(argc, argv, optstring)) != -1) {
     switch (opt) {
       case 'C':        /* Configuration Profile */
-        if (profile_exists (optarg, FALSE)) {
-          set_profile_name (optarg);
-        } else {
-          cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
-          exit(1);
-        }
-        break;
+	if (profile_exists (optarg, FALSE)) {
+	  set_profile_name (optarg);
+	} else {
+	  cmdarg_err("Configuration Profile \"%s\" does not exist", optarg);
+	  exit(1);
+	}
+	break;
       case 'D':        /* Print a list of capture devices and exit */
 #ifdef HAVE_LIBPCAP
         if_list = capture_interface_list(&err, &err_str);
@@ -2281,8 +2269,8 @@ main(int argc, char *argv[])
   recent_read_profile_static(&rf_path, &rf_open_errno);
   if (rf_path != NULL && rf_open_errno != 0) {
     simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
-      "Could not open recent file\n\"%s\": %s.",
-      rf_path, g_strerror(rf_open_errno));
+		  "Could not open recent file\n\"%s\": %s.",
+		  rf_path, g_strerror(rf_open_errno));
   }
 
   if (recent.gui_fileopen_remembered_dir &&
@@ -2455,11 +2443,6 @@ main(int argc, char *argv[])
   /* Fill in capture options with values from the preferences */
   prefs_to_capture_opts();
 
-#ifdef HAVE_LIBPCAP
-  if (global_capture_opts.all_ifaces->len == 0) {
-    scan_local_interfaces(&global_capture_opts);
-  }
-#endif
   /* Now get our args */
   while ((opt = getopt(argc, argv, optstring)) != -1) {
     switch (opt) {
@@ -2470,6 +2453,7 @@ main(int argc, char *argv[])
       case 'f':        /* capture filter */
       case 'k':        /* Start capture immediately */
       case 'H':        /* Hide capture info dialog box */
+      case 'i':        /* Use interface xxx */
       case 'p':        /* Don't capture in promiscuous mode */
 #ifdef HAVE_PCAP_CREATE
       case 'I':        /* Capture in monitor mode, if available */
@@ -2499,25 +2483,13 @@ main(int argc, char *argv[])
         break;
 #endif
 
-#ifdef HAVE_LIBPCAP
-      case 'i':       /* Use interface xxx */
-        status = capture_opts_select_iface(&global_capture_opts, optarg);
-        if (status != 0) {
-            exit(status);
-        }
-#else
-        capture_option_specified = TRUE;
-        arg_error = TRUE;
-#endif
-        break;
-        
       /*** all non capture option specific ***/
       case 'C':
         /* Configuration profile settings were already processed just ignore them this time*/
-        break;
+	break;
       case 'd':
-        dfilter = optarg;
-        break;
+	dfilter = optarg;
+	break;
       case 'j':        /* Search backwards for a matching packet from filter in option J */
         jump_backwards = TRUE;
         break;
@@ -2556,7 +2528,7 @@ main(int argc, char *argv[])
         badopt = string_to_name_resolve(optarg, &gbl_resolv_flags);
         if (badopt != '\0') {
           cmdarg_err("-N specifies unknown resolving option '%c'; valid options are 'm', 'n', and 't'",
-            badopt);
+			badopt);
           exit(1);
         }
         break;
@@ -2581,7 +2553,7 @@ main(int argc, char *argv[])
             case PREFS_SET_NO_SUCH_PREF:
             case PREFS_SET_OBSOLETE:
               cmdarg_err("-o flag \"%s\" specifies unknown preference/recent value",
-                optarg);
+	            optarg);
               exit(1);
               break;
             default:
@@ -2590,7 +2562,7 @@ main(int argc, char *argv[])
           break;
         case PREFS_SET_OBSOLETE:
           cmdarg_err("-o flag \"%s\" specifies obsolete preference",
-            optarg);
+			optarg);
           exit(1);
           break;
         default:
@@ -2601,9 +2573,9 @@ main(int argc, char *argv[])
         /* Path settings were already processed just ignore them this time*/
         break;
       case 'r':        /* Read capture file xxx */
-        /* We may set "last_open_dir" to "cf_name", and if we change
-        "last_open_dir" later, we free the old value, so we have to
-        set "cf_name" to something that's been allocated. */
+	/* We may set "last_open_dir" to "cf_name", and if we change
+	   "last_open_dir" later, we free the old value, so we have to
+	   set "cf_name" to something that's been allocated. */
         cf_name = g_strdup(optarg);
         break;
       case 'R':        /* Read file filter */
@@ -2654,11 +2626,11 @@ main(int argc, char *argv[])
            part of a tap filter.  Instead, we just add the argument
            to a list of stat arguments. */
         if (!process_stat_cmd_arg(optarg)) {
-          cmdarg_err("Invalid -z argument.");
-          cmdarg_err_cont("  -z argument must be one of :");
-          list_stat_cmd_args();
-          exit(1);
-        }
+	  cmdarg_err("Invalid -z argument.");
+	  cmdarg_err_cont("  -z argument must be one of :");
+	  list_stat_cmd_args();
+	  exit(1);
+	}
         break;
       default:
       case '?':        /* Bad flag - print usage message */
@@ -2745,18 +2717,23 @@ main(int argc, char *argv[])
        sense? */
     if (global_capture_opts.multi_files_on) {
       /* Ring buffer works only under certain conditions:
-      a) ring buffer does not work with temporary files;
-      b) real_time_mode and multi_files_on are mutually exclusive -
-         real_time_mode takes precedence;
-      c) it makes no sense to enable the ring buffer if the maximum
-         file size is set to "infinite". */
+	 a) ring buffer does not work with temporary files;
+	 b) real_time_mode and multi_files_on are mutually exclusive -
+	    real_time_mode takes precedence;
+	 c) it makes no sense to enable the ring buffer if the maximum
+	    file size is set to "infinite". */
       if (global_capture_opts.save_file == NULL) {
-        cmdarg_err("Ring buffer requested, but capture isn't being saved to a permanent file.");
-        global_capture_opts.multi_files_on = FALSE;
+	cmdarg_err("Ring buffer requested, but capture isn't being saved to a permanent file.");
+	global_capture_opts.multi_files_on = FALSE;
       }
+/*      if (global_capture_opts.real_time_mode) {
+	cmdarg_err("Ring buffer requested, but an \"Update list of packets in real time\" capture is being done.");
+	global_capture_opts.multi_files_on = FALSE;
+      }*/
       if (!global_capture_opts.has_autostop_filesize && !global_capture_opts.has_file_duration) {
-        cmdarg_err("Ring buffer requested, but no maximum capture file size or duration were specified.");
-        /* XXX - this must be redesigned as the conditions changed */
+	cmdarg_err("Ring buffer requested, but no maximum capture file size or duration were specified.");
+/* XXX - this must be redesigned as the conditions changed */
+/*	global_capture_opts.multi_files_on = FALSE;*/
       }
     }
   }
@@ -2773,32 +2750,23 @@ main(int argc, char *argv[])
     /* Get the list of link-layer types for the capture devices. */
     if_capabilities_t *caps;
     guint i;
-    interface_t device;
-    for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
+    interface_options interface_opts;
 
-      device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-      if (device.selected) {
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
-        caps = capture_get_if_capabilities(device.name, device.monitor_mode_supported, &err_str);
-#else
-        caps = capture_get_if_capabilities(device.name, FALSE, &err_str);
-#endif
-        if (caps == NULL) {
-          cmdarg_err("%s", err_str);
-          g_free(err_str);
-          exit(2);
-        }
-        if (caps->data_link_types == NULL) {
-          cmdarg_err("The capture device \"%s\" has no data link types.", device.name);
-          exit(2);
-        }
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
-        capture_opts_print_if_capabilities(caps, device.name, device.monitor_mode_supported);
-#else
-        capture_opts_print_if_capabilities(caps, device.name, FALSE);
-#endif
-        free_if_capabilities(caps);
+    for (i = 0; i < global_capture_opts.ifaces->len; i++) {
+
+      interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
+      caps = capture_get_if_capabilities(interface_opts.name, interface_opts.monitor_mode, &err_str);
+      if (caps == NULL) {
+        cmdarg_err("%s", err_str);
+        g_free(err_str);
+        exit(2);
       }
+      if (caps->data_link_types == NULL) {
+        cmdarg_err("The capture device \"%s\" has no data link types.", interface_opts.name);
+        exit(2);
+      }
+      capture_opts_print_if_capabilities(caps, interface_opts.name, interface_opts.monitor_mode);
+      free_if_capabilities(caps);
     }
     exit(0);
   }
@@ -2819,20 +2787,53 @@ main(int argc, char *argv[])
     exit(2);
   }
 #endif
-  if ((global_capture_opts.num_selected == 0) &&
+  if ((global_capture_opts.ifaces->len == 0) &&
       (prefs.capture_device != NULL)) {
-    guint i;
-    interface_t device;
-    for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-      device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-      if (!device.hidden && strcmp(device.display_name, prefs.capture_device) == 0) {
-        device.selected = TRUE;
-        global_capture_opts.num_selected++;
-        global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
-        g_array_insert_val(global_capture_opts.all_ifaces, i, device);
-        break;
+    GList *curr, *combo_list;
+    gboolean found = FALSE;
+
+    if_list = capture_interface_list(&err, NULL);
+    if (g_list_length(if_list) > 0) {
+      combo_list = build_capture_combo_list(if_list, FALSE);
+      free_interface_list(if_list);
+      for (curr = combo_list; curr; curr = g_list_next(curr)) {
+        if (strcmp(curr->data, prefs.capture_device) == 0) {
+          found = TRUE;
+          break;
+        }
       }
     }
+    if (found) {
+      interface_options interface_opts;
+
+      interface_opts.name = g_strdup(get_if_name(prefs.capture_device));
+      interface_opts.descr = get_interface_descriptive_name(interface_opts.name);
+      interface_opts.monitor_mode = prefs_capture_device_monitor_mode(interface_opts.name);
+      interface_opts.linktype = capture_dev_user_linktype_find(interface_opts.name);
+      interface_opts.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
+      interface_opts.snaplen = global_capture_opts.default_options.snaplen;
+      interface_opts.has_snaplen = global_capture_opts.default_options.has_snaplen;
+      interface_opts.promisc_mode = global_capture_opts.default_options.promisc_mode;
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+      interface_opts.buffer_size =  global_capture_opts.default_options.buffer_size;
+#endif
+#ifdef HAVE_PCAP_REMOTE
+      interface_opts.src_type = global_capture_opts.default_options.src_type;
+      interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
+      interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
+      interface_opts.auth_type = global_capture_opts.default_options.auth_type;
+      interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
+      interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
+      interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
+      interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
+      interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
+ #endif
+ #ifdef HAVE_PCAP_SETSAMPLING
+      interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
+      interface_opts.sampling_param  = global_capture_opts.default_options.sampling_param;
+ #endif
+      g_array_insert_val(global_capture_opts.ifaces, 0, interface_opts);
+    }
   }
 #endif
 
@@ -2874,8 +2875,8 @@ main(int argc, char *argv[])
   recent_read_dynamic(&rf_path, &rf_open_errno);
   if (rf_path != NULL && rf_open_errno != 0) {
     simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
-      "Could not open recent file\n\"%s\": %s.",
-      rf_path, g_strerror(rf_open_errno));
+		  "Could not open recent file\n\"%s\": %s.",
+		  rf_path, g_strerror(rf_open_errno));
   }
 
   color_filters_enable(recent.packet_list_colorize);
@@ -2997,15 +2998,15 @@ main(int argc, char *argv[])
           break;
         }
 
-        /* If the filename is not the absolute path, prepend the current dir. This happens
-        when wireshark is invoked from a cmd shell (e.g.,'wireshark -r file.pcap'). */
-        if (!g_path_is_absolute(cf_name)) {
-          char *old_cf_name = cf_name;
-          char *pwd = g_get_current_dir();
-          cf_name = g_strdup_printf("%s%s%s", pwd, G_DIR_SEPARATOR_S, cf_name);
-          g_free(old_cf_name);
-          g_free(pwd);
-        }
+	/* If the filename is not the absolute path, prepend the current dir. This happens
+	   when wireshark is invoked from a cmd shell (e.g.,'wireshark -r file.pcap'). */
+	if (!g_path_is_absolute(cf_name)) {
+	  char *old_cf_name = cf_name;
+	  char *pwd = g_get_current_dir();
+	  cf_name = g_strdup_printf("%s%s%s", pwd, G_DIR_SEPARATOR_S, cf_name);
+	  g_free(old_cf_name);
+	  g_free(pwd);
+	}
 
         /* Save the name of the containing directory specified in the
            path name, if any; we can write over cf_name, which is a
@@ -3020,7 +3021,7 @@ main(int argc, char *argv[])
           dfilter_free(rfcode);
         cfile.rfcode = NULL;
         show_main_window(FALSE);
-        /* Don't call check_and_warn_user_startup(): we did it above */
+	/* Don't call check_and_warn_user_startup(): we did it above */
         set_menus_for_capture_in_progress(FALSE);
         set_capture_if_dialog_for_capture_in_progress(FALSE);
       }
@@ -3040,10 +3041,10 @@ main(int argc, char *argv[])
       check_and_warn_user_startup(cf_name);
       if (capture_start(&global_capture_opts)) {
         /* The capture started.  Open stat windows; we do so after creating
-           the main window, to avoid GTK warnings, and after successfully
-           opening the capture file, so we know we have something to compute
-           stats on, and after registering all dissectors, so that MATE will
-           have registered its field array and we can have a tap filter with
+	   the main window, to avoid GTK warnings, and after successfully
+	   opening the capture file, so we know we have something to compute
+	   stats on, and after registering all dissectors, so that MATE will
+	   have registered its field array and we can have a tap filter with
            one of MATE's late-registered fields as part of the filter. */
         start_requested_stats();
       }
@@ -3549,6 +3550,7 @@ main_widgets_show_or_hide(void)
     if (!have_capture_file) {
         if(welcome_pane) {
             gtk_widget_show(welcome_pane);
+            select_ifaces();
         }
     } else {
         gtk_widget_hide(welcome_pane);
@@ -3856,218 +3858,3 @@ void redissect_packets(void)
     cf_redissect_packets(&cfile);
     status_expert_update();
 }
-
-#ifdef HAVE_LIBPCAP
-void
-scan_local_interfaces(capture_options* capture_opts)
-{
-    GList             *if_entry, *lt_entry, *if_list;
-    if_info_t         *if_info, *temp;
-    char              *if_string="";
-    gchar             *descr, *str, *err_str = NULL;
-    if_capabilities_t *caps=NULL;
-    gint              linktype_count;
-    cap_settings_t    cap_settings;
-    GSList            *curr_addr;
-    int               ips = 0, err, i;
-    guint             count = 0;
-    if_addr_t         *addr, *temp_addr;
-    link_row          *link = NULL;
-    data_link_info_t  *data_link_info;
-    interface_t       device;
-    GString           *ip_str;
-
-    if (capture_opts->all_ifaces->len > 0) {
-        for (i = (int)capture_opts->all_ifaces->len-1; i >= 0; i--) {
-            device = g_array_index(capture_opts->all_ifaces, interface_t, i);
-            if (device.type == IF_LOCAL) {
-                capture_opts->all_ifaces = g_array_remove_index(capture_opts->all_ifaces, i);
-            }
-        }
-    }
-    /* Scan through the list and build a list of strings to display. */
-    if_list = capture_interface_list(&err, &err_str);
-    if (if_list == NULL) {
-    switch (err) {
-
-    case CANT_GET_INTERFACE_LIST:
-      simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
-      g_free(err_str);
-      break;
-
-    case NO_INTERFACES_FOUND:
-      simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
-                    "There are no interfaces on which a capture can be done.");
-      break;
-    }
-    return;
-  }
-    count = 0;
-    for (if_entry = if_list; if_entry != NULL; if_entry = g_list_next(if_entry)) {
-        if_info = if_entry->data;
-        ip_str = g_string_new("");
-        str = "";
-        ips = 0;
-        device.name = g_strdup(if_info->name);
-        device.hidden = FALSE;
-        device.locked = FALSE;
-        temp = g_malloc0(sizeof(if_info_t));
-        temp->name = g_strdup(if_info->name);
-        temp->description = g_strdup(if_info->description);
-        temp->loopback = if_info->loopback;
-        /* Is this interface hidden and, if so, should we include it anyway? */
-
-        /* Do we have a user-supplied description? */
-        descr = capture_dev_user_descr_find(if_info->name);
-        if (descr != NULL) {
-            /* Yes, we have a user-supplied description; use it. */
-            if_string = g_strdup_printf("%s: %s", descr, if_info->name);
-            g_free(descr);
-        } else {
-            /* No, we don't have a user-supplied description; did we get
-            one from the OS or libpcap? */
-            if (if_info->description != NULL) {
-                /* Yes - use it. */
-                if_string = g_strdup_printf("%s: %s", if_info->description, if_info->name);
-            } else {
-                /* No. */
-                if_string = g_strdup(if_info->name);
-            }
-        }
-        if (if_info->loopback) {
-            device.display_name = g_strdup_printf("%s (loopback)", if_string);
-        } else {
-            device.display_name = g_strdup(if_string);
-        }
-        device.selected = FALSE;
-        if (prefs_is_capture_device_hidden(if_info->name)) {
-            device.hidden = TRUE;
-        } 
-#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
-        device.buffer = capture_opts->default_options.buffer_size;
-#endif
-        device.pmode = capture_opts->default_options.promisc_mode;
-        device.has_snaplen = capture_opts->default_options.has_snaplen;
-        device.snaplen = capture_opts->default_options.snaplen;
-        device.cfilter = g_strdup(capture_opts->default_options.cfilter);
-        cap_settings = capture_get_cap_settings(if_info->name);
-        caps = capture_get_if_capabilities(if_info->name, cap_settings.monitor_mode, NULL);
-        for (; (curr_addr = g_slist_nth(if_info->addrs, ips)) != NULL; ips++) {
-            temp_addr = g_malloc0(sizeof(if_addr_t));
-            if (ips != 0) {
-                g_string_append(ip_str, "\n");
-            }
-            addr = (if_addr_t *)curr_addr->data;
-            if (addr) {
-                temp_addr->ifat_type = addr->ifat_type;
-                switch (addr->ifat_type) {
-                    case IF_AT_IPv4:
-                        temp_addr->addr.ip4_addr = addr->addr.ip4_addr;
-                        g_string_append(ip_str, ip_to_str((guint8 *)&addr->addr.ip4_addr));
-                        break;
-                    case IF_AT_IPv6:
-                        memcpy(temp_addr->addr.ip6_addr, addr->addr.ip6_addr, sizeof(addr->addr));
-                        g_string_append(ip_str,  ip6_to_str((struct e_in6_addr *)&addr->addr.ip6_addr));
-                        break;
-                    default:
-                        /* In case we add non-IP addresses */
-                        break;
-                }
-            } else {
-                g_free(temp_addr);
-                temp_addr = NULL;
-            }
-            if (temp_addr) {
-                temp->addrs = g_slist_append(temp->addrs, temp_addr);
-            }
-        }
-#ifdef HAVE_PCAP_REMOTE
-        device.remote_opts.src_type = CAPTURE_IFLOCAL;
-#endif
-        linktype_count = 0;
-        device.links = NULL;
-        if (caps != NULL) {
-#ifdef HAVE_PCAP_CREATE
-            device.monitor_mode_enabled = cap_settings.monitor_mode;
-            device.monitor_mode_supported = caps->can_set_rfmon;
-#endif 
-            for (lt_entry = caps->data_link_types; lt_entry != NULL; lt_entry = g_list_next(lt_entry)) {
-                data_link_info = lt_entry->data;
-                if (data_link_info->description != NULL) {
-                    str = g_strdup_printf("%s", data_link_info->description);
-                } else {
-                    str = g_strdup_printf("%s (not supported)", data_link_info->name);
-                }
-                if (linktype_count == 0) {
-                    device.active_dlt = data_link_info->dlt;
-                }
-                link = (link_row *)g_malloc(sizeof(link_row));
-                link->dlt = data_link_info->dlt;
-                link->name = g_strdup(str);
-                device.links = g_list_append(device.links, link);
-                linktype_count++;
-            }
-        } else {
-            cap_settings.monitor_mode = FALSE;
-#ifdef HAVE_PCAP_CREATE
-            device.monitor_mode_enabled = FALSE;
-            device.monitor_mode_supported = FALSE;
-#endif
-            device.active_dlt = -1;
-        }
-        device.addresses = g_strdup(ip_str->str);
-        device.no_addresses = ips;
-        device.type = IF_LOCAL;
-        device.if_info = *temp;
-        device.last_packets = 0;
-
-        if (capture_opts->all_ifaces->len <= count) {
-            g_array_append_val(capture_opts->all_ifaces, device);
-            count = capture_opts->all_ifaces->len;
-        } else {
-            g_array_insert_val(capture_opts->all_ifaces, count, device);
-        }
-        if (caps != NULL) {
-            free_if_capabilities(caps);
-        }
-            
-        g_string_free(ip_str, TRUE);
-        count++;
-    }
-    free_interface_list(if_list);
-}
-
-void hide_interface(gchar* new_hide)
-{
-    gchar       *tok;
-    guint       i;
-    interface_t device;
-    gboolean    found = FALSE;
-    GList       *hidden_devices = NULL, *entry;
-    if (new_hide != NULL) {
-        for (tok = strtok (new_hide, ","); tok; tok = strtok(NULL, ",")) {
-            hidden_devices = g_list_append(hidden_devices, tok);
-        }
-    }
-    for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-        device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-        found = FALSE;
-        for (entry = hidden_devices; entry != NULL; entry = g_list_next(entry)) {
-            if (strcmp(entry->data, device.name)==0) {
-                device.hidden = TRUE;
-                if (device.selected) {
-                    device.selected = FALSE;
-                    global_capture_opts.num_selected--;
-                }
-                found = TRUE;
-                break;
-            }
-        } 
-        if (!found) {
-            device.hidden = FALSE;
-        }
-        global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
-        g_array_insert_val(global_capture_opts.all_ifaces, i, device);
-    }
-}
-#endif
diff --git a/gtk/main.h b/gtk/main.h
index 2b70e8a2ab..59b742ddfc 100644
--- a/gtk/main.h
+++ b/gtk/main.h
@@ -26,7 +26,6 @@
 #define __MAIN_H__
 
 #include "globals.h"
-#include "capture_opts.h"
 
 /** @defgroup main_window_group Main window
  * The main window has the following submodules:
@@ -366,6 +365,4 @@ extern GList *get_ip_address_list_from_packet_list_row(gpointer data);
 
 extern GtkWidget *pkt_scrollw;
 
-void hide_interface(gchar* new_hide);
-
 #endif /* __MAIN_H__ */
diff --git a/gtk/main_welcome.c b/gtk/main_welcome.c
index aad9f8215d..8226f5a588 100644
--- a/gtk/main_welcome.c
+++ b/gtk/main_welcome.c
@@ -81,6 +81,8 @@
 #endif
 
 /* XXX */
+extern gint if_list_comparator_alph (const void *first_arg, const void *second_arg);
+
 static GtkWidget *welcome_hb = NULL;
 static GtkWidget *header_lb = NULL;
 /* Foreground colors are set using Pango markup */
@@ -101,8 +103,10 @@ static GdkColor topic_item_entered_bg = { 0, 0xd3d3, 0xd8d8, 0xdada };
 #endif
 static GtkWidget *welcome_file_panel_vb = NULL;
 #ifdef HAVE_LIBPCAP
+static GtkWidget *welcome_if_panel_vb = NULL;
 static GtkWidget *if_view = NULL;
 static GtkWidget *swindow;
+static GArray *interfaces = NULL;
 #endif
 
 static GSList *status_messages = NULL;
@@ -207,9 +211,9 @@ static gboolean
 welcome_item_enter_cb(GtkWidget *eb, GdkEventCrossing *event _U_, gpointer user_data _U_)
 {
 #if GTK_CHECK_VERSION(3,0,0)
-    gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_entered_bg);
+	gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_entered_bg);
 #else
-    gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_item_entered_bg);
+	gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_item_entered_bg);
 #endif
     return FALSE;
 }
@@ -220,7 +224,7 @@ static gboolean
 welcome_item_leave_cb(GtkWidget *eb, GdkEventCrossing *event _U_, gpointer user_data _U_)
 {
 #if GTK_CHECK_VERSION(3,0,0)
-    gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_idle_bg);
+	gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_idle_bg);
 #else
     gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_item_idle_bg);
 #endif
@@ -247,12 +251,12 @@ welcome_button(const gchar *stock_item,
     eb = gtk_event_box_new();
     gtk_container_add(GTK_CONTAINER(eb), item_hb);
 #if GTK_CHECK_VERSION(3,0,0)
-    gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_idle_bg);
+	gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_item_idle_bg);
 #else
     gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_item_idle_bg);
 #endif
     if(tooltip != NULL) {
-        gtk_widget_set_tooltip_text(eb, tooltip);
+		gtk_widget_set_tooltip_text(eb, tooltip);
     }
 
     g_signal_connect(eb, "enter-notify-event", G_CALLBACK(welcome_item_enter_cb), NULL);
@@ -353,7 +357,7 @@ welcome_header_new(void)
     gtk_box_pack_start(GTK_BOX(item_vb), item_hb, FALSE, FALSE, 10);
 
     /*icon = xpm_to_widget_from_parent(top_level, wssplash_xpm);*/
-    icon = xpm_to_widget(wssplash_xpm);
+	icon = xpm_to_widget(wssplash_xpm);
     gtk_box_pack_start(GTK_BOX(item_hb), icon, FALSE, FALSE, 10);
 
     header_lb = gtk_label_new(NULL);
@@ -419,7 +423,7 @@ welcome_topic_header_new(const char *header)
     eb = gtk_event_box_new();
     gtk_container_add(GTK_CONTAINER(eb), w);
 #if GTK_CHECK_VERSION(3,0,0)
-    gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_header_bg);
+	gtk_widget_override_background_color(eb, GTK_STATE_NORMAL, &rgba_topic_header_bg);
 #else
     gtk_widget_modify_bg(eb, GTK_STATE_NORMAL, &topic_header_bg);
 #endif
@@ -450,7 +454,7 @@ welcome_topic_new(const char *header, GtkWidget **to_fill)
     topic_eb = gtk_event_box_new();
     gtk_container_add(GTK_CONTAINER(topic_eb), topic_vb);
 #if GTK_CHECK_VERSION(3,0,0)
-    gtk_widget_override_background_color(topic_eb, GTK_STATE_NORMAL, &rgba_topic_content_bg);
+	gtk_widget_override_background_color(topic_eb, GTK_STATE_NORMAL, &rgba_topic_content_bg);
 #else
     gtk_widget_modify_bg(topic_eb, GTK_STATE_NORMAL, &topic_content_bg);
 #endif
@@ -575,16 +579,16 @@ static void welcome_filename_destroy_cb(GtkWidget *w _U_, gpointer data) {
     g_mutex_lock(recent_mtx);
 #endif
     if (ri_stat->timer) {
-        g_source_remove(ri_stat->timer);
-        ri_stat->timer = 0;
+	g_source_remove(ri_stat->timer);
+	ri_stat->timer = 0;
     }
 
     g_object_unref(ri_stat->menu_item);
 
     if (ri_stat->stat_done) {
-        g_free(ri_stat->filename);
-        g_string_free(ri_stat->str, TRUE);
-        g_free(ri_stat);
+	g_free(ri_stat->filename);
+	g_string_free(ri_stat->str, TRUE);
+	g_free(ri_stat);
     } else {
         ri_stat->label = NULL;
     }
@@ -714,22 +718,22 @@ static gboolean select_current_ifaces(GtkTreeModel  *model,
 {
     guint i;
     gchar *if_name;
-    interface_t device;
+    gboolean found = FALSE;
 
-    GtkTreeSelection *selection = (GtkTreeSelection *)userdata; 
-    device.name = NULL;
+    GtkTreeSelection *selection = (GtkTreeSelection *)userdata;
     gtk_tree_model_get (model, iter, IFACE_NAME, &if_name, -1);
-    for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-        device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-        if (strcmp(device.name, if_name) == 0) {
-            if (device.selected && !gtk_tree_selection_path_is_selected(selection, path)) {
-                gtk_tree_selection_select_iter(selection, iter);
-            } else {
-                gtk_tree_selection_unselect_iter(selection, iter);
+    for (i = 0; i < global_capture_opts.ifaces->len; i++) {
+        if (strcmp(g_array_index(global_capture_opts.ifaces, interface_options, i).name, if_name) == 0) {
+            if (!gtk_tree_selection_path_is_selected(selection, path)) {
+              gtk_tree_selection_select_iter(selection, iter);
             }
+            found = TRUE;
             break;
         }
     }
+    if (!found) {
+        gtk_tree_selection_unselect_iter(selection, iter);
+    }
     return FALSE;
 }
 
@@ -741,42 +745,100 @@ gboolean on_selection_changed(GtkTreeSelection *selection _U_,
 {
     GtkTreeIter  iter;
     gchar *if_name;
-    guint i;
-    interface_t device;
-    
+    interface_options interface_opts;
+    guint i, j;
+    cap_settings_t    cap_settings;
+    gboolean found = FALSE;
+    displayed_interface d_interface;
+
+    d_interface.name = NULL;
+    d_interface.descr = NULL;
     gtk_tree_model_get_iter (model, &iter, path);
     gtk_tree_model_get (model, &iter, IFACE_NAME, &if_name, -1);
-    for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-        device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-        if (strcmp(device.name, if_name) == 0) {
-            if (!device.locked) {
+    if (global_capture_opts.ifaces->len > 0) {
+        for (i = 0; i < global_capture_opts.ifaces->len; i++) {
+            if (strcmp(g_array_index(global_capture_opts.ifaces, interface_options, i).name, if_name) == 0) {
+                found = TRUE;
                 if (path_currently_selected) {
-                    if (device.selected) {
-                        device.selected = FALSE;
-                        device.locked = TRUE;
-                        global_capture_opts.num_selected--;
+                    interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, i);
+                    global_capture_opts.ifaces = g_array_remove_index(global_capture_opts.ifaces, i);
+                    if (gtk_widget_is_focus(g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES)) && interfaces_dialog_window_present()) {
+                        update_selected_interface(g_strdup(interface_opts.name), FALSE);
                     }
-                } else {
-                    if (!device.selected) {
-                        device.selected = TRUE;
-                        device.locked = TRUE;
-                        global_capture_opts.num_selected++;
+                    if (gtk_widget_is_focus(g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES)) && dlg_window_present()) {
+                      enable_selected_interface(interface_opts.name, FALSE);
                     }
+                    g_free(interface_opts.name);
+                    g_free(interface_opts.descr);
+                    g_free(interface_opts.cfilter);
+#ifdef HAVE_PCAP_REMOTE
+                    g_free(interface_opts.remote_host);
+                    g_free(interface_opts.remote_port);
+                    g_free(interface_opts.auth_username);
+                    g_free(interface_opts.auth_password);
+#endif
+                    break;
+                }
+            }
+        }
+    }
+    if (!found && !path_currently_selected) {
+        for (j = 0; j < interfaces->len; j++) {
+            d_interface = g_array_index(interfaces, displayed_interface, j);
+            if (strcmp(d_interface.name, if_name) == 0) {
+                interface_opts.name = g_strdup(d_interface.name);
+                interface_opts.descr = g_strdup(d_interface.descr);
+                interface_opts.linktype = capture_dev_user_linktype_find(interface_opts.name);
+                interface_opts.cfilter = g_strdup(global_capture_opts.default_options.cfilter);
+                interface_opts.has_snaplen = global_capture_opts.default_options.has_snaplen;
+                interface_opts.snaplen = global_capture_opts.default_options.snaplen;
+                cap_settings = capture_get_cap_settings (interface_opts.name);;
+                interface_opts.promisc_mode = global_capture_opts.default_options.promisc_mode;
+#if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
+                interface_opts.buffer_size =  global_capture_opts.default_options.buffer_size;
+#endif
+                interface_opts.monitor_mode = cap_settings.monitor_mode;
+#ifdef HAVE_PCAP_REMOTE
+                if (d_interface.remote_opts.src_type == CAPTURE_IFREMOTE) {
+                    interface_opts.src_type = d_interface.remote_opts.src_type;
+                    interface_opts.remote_host = g_strdup(d_interface.remote_opts.remote_host_opts.remote_host);
+                    interface_opts.remote_port = g_strdup(d_interface.remote_opts.remote_host_opts.remote_port);
+                    interface_opts.auth_type = d_interface.remote_opts.remote_host_opts.auth_type;
+                    interface_opts.auth_username = g_strdup(d_interface.remote_opts.remote_host_opts.auth_username);
+                    interface_opts.auth_password = g_strdup(d_interface.remote_opts.remote_host_opts.auth_password);
+                    interface_opts.datatx_udp = d_interface.remote_opts.remote_host_opts.datatx_udp;
+                    interface_opts.nocap_rpcap = d_interface.remote_opts.remote_host_opts.nocap_rpcap;
+                    interface_opts.nocap_local = d_interface.remote_opts.remote_host_opts.nocap_local;
+#ifdef HAVE_PCAP_SETSAMPLING
+                    interface_opts.sampling_method = d_interface.remote_opts.sampling_method;
+                    interface_opts.sampling_param  = d_interface.remote_opts.sampling_param;
+#endif
+                } else {
+                    interface_opts.src_type = global_capture_opts.default_options.src_type;
+                    interface_opts.remote_host = g_strdup(global_capture_opts.default_options.remote_host);
+                    interface_opts.remote_port = g_strdup(global_capture_opts.default_options.remote_port);
+                    interface_opts.auth_type = global_capture_opts.default_options.auth_type;
+                    interface_opts.auth_username = g_strdup(global_capture_opts.default_options.auth_username);
+                    interface_opts.auth_password = g_strdup(global_capture_opts.default_options.auth_password);
+                    interface_opts.datatx_udp = global_capture_opts.default_options.datatx_udp;
+                    interface_opts.nocap_rpcap = global_capture_opts.default_options.nocap_rpcap;
+                    interface_opts.nocap_local = global_capture_opts.default_options.nocap_local;
+#ifdef HAVE_PCAP_SETSAMPLING
+                    interface_opts.sampling_method = global_capture_opts.default_options.sampling_method;
+                    interface_opts.sampling_param  = global_capture_opts.default_options.sampling_param;
+#endif
                 }
-                global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
-                g_array_insert_val(global_capture_opts.all_ifaces, i, device);
+#endif
 
-                if (dlg_window_present()) {
-                    enable_selected_interface(g_strdup(if_name), device.selected);
+                g_array_append_val(global_capture_opts.ifaces, interface_opts);
+                if (gtk_widget_is_focus(g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES)) && interfaces_dialog_window_present()) {
+                    update_selected_interface(g_strdup(interface_opts.name), TRUE);
                 }
-                if (interfaces_dialog_window_present()) {
-                    update_selected_interface(g_strdup(if_name));
+                if (gtk_widget_is_focus(g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES)) && dlg_window_present()) {
+                    enable_selected_interface(interface_opts.name, TRUE);
                 }
-                device.locked = FALSE;
-                global_capture_opts.all_ifaces = g_array_remove_index(global_capture_opts.all_ifaces, i);
-                g_array_insert_val(global_capture_opts.all_ifaces, i, device);
+                break;
             }
-            break;
         }
     }
     return TRUE;
@@ -823,8 +885,10 @@ void change_selection_for_all(gboolean enable)
 {
   guint i;
 
-  for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-    change_interface_selection(g_array_index(global_capture_opts.all_ifaces, interface_t, i).name, enable);
+  if (interfaces) {
+    for (i = 0; i < interfaces->len; i++) {
+      change_interface_selection(g_array_index(interfaces, displayed_interface, i).name, enable);
+    }
   }
 }
 #endif
@@ -837,7 +901,7 @@ select_ifaces(void)
     GtkTreeModel     *model;
     GtkTreeSelection *entry;
 
-    if (global_capture_opts.num_selected > 0 && swindow) {
+    if (global_capture_opts.ifaces->len > 0 && swindow) {
         view = g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES);
         model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
         entry = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
@@ -849,24 +913,40 @@ select_ifaces(void)
 
 #ifdef HAVE_PCAP_REMOTE
 void
-add_interface_to_list(guint index)
+add_interface_to_list(gchar *name, gchar *descr, remote_options *remote_opts)
 {
     GtkWidget *view, *icon;
     GtkTreeModel *model;
     GtkTreeIter iter;
     gint size;
     gchar *lines;
-    interface_t device;
-
-    device = g_array_index(global_capture_opts.all_ifaces, interface_t, index);
+    displayed_interface d_interface;
+
+    d_interface.name = g_strdup(name);
+    d_interface.descr = g_strdup(descr);
+    d_interface.remote_opts.src_type = remote_opts->src_type;
+    d_interface.remote_opts.remote_host_opts.remote_host = g_strdup(remote_opts->remote_host_opts.remote_host);
+    d_interface.remote_opts.remote_host_opts.remote_port = g_strdup(remote_opts->remote_host_opts.remote_port);
+    d_interface.remote_opts.remote_host_opts.auth_type = remote_opts->remote_host_opts.auth_type;
+    d_interface.remote_opts.remote_host_opts.auth_username = g_strdup(remote_opts->remote_host_opts.auth_username);
+    d_interface.remote_opts.remote_host_opts.auth_password = g_strdup(remote_opts->remote_host_opts.auth_password);
+    d_interface.remote_opts.remote_host_opts.datatx_udp = remote_opts->remote_host_opts.datatx_udp;
+    d_interface.remote_opts.remote_host_opts.nocap_rpcap = remote_opts->remote_host_opts.nocap_rpcap;
+    d_interface.remote_opts.remote_host_opts.nocap_local = remote_opts->remote_host_opts.nocap_local;
+#ifdef HAVE_PCAP_SETSAMPLING
+    d_interface.remote_opts.sampling_method = remote_opts->sampling_method;
+    d_interface.remote_opts.sampling_param = remote_opts->sampling_param;
+#endif
     icon = pixbuf_to_widget(remote_sat_pb_data);
+    d_interface.icon = icon;
     view = g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES);
     model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
     size = gtk_tree_model_iter_n_children(model, NULL);
     lines = g_strdup_printf("%d", size-1);
+    g_array_append_val(interfaces, d_interface);
     if (gtk_tree_model_get_iter_from_string(model, &iter, lines)) {
         gtk_list_store_append (GTK_LIST_STORE(model), &iter);
-        gtk_list_store_set(GTK_LIST_STORE(model), &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(icon)), IFACE_DESCR, device.display_name, IFACE_NAME, device.name, -1);
+        gtk_list_store_set(GTK_LIST_STORE(model), &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(icon)), IFACE_DESCR, descr, IFACE_NAME, name, -1);
     }
 }
 #endif
@@ -876,40 +956,91 @@ void
 welcome_if_tree_load(void)
 {
 #ifdef HAVE_LIBPCAP
+    if_info_t           *if_info;
+    GList               *if_list;
+    int                 err;
     guint               i;
+    gchar               *err_str = NULL;
+    GList               *curr;
+    gchar               *user_descr;
     GtkListStore        *store = NULL;
     GtkTreeIter         iter;
-    GtkWidget           *view;
+    GtkWidget           *icon, *view;
     GtkTreeSelection    *entry;
-    interface_t         device;
-    gboolean 						changed = FALSE;
+    displayed_interface d_interface;
 
     view = g_object_get_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES);
     entry = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
     gtk_tree_selection_unselect_all(entry);
     store = gtk_list_store_new(NUMCOLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
 
-     gtk_list_store_clear(store);
-     gtk_tree_view_set_model(GTK_TREE_VIEW(if_view), GTK_TREE_MODEL (store));
     /* LOAD THE INTERFACES */
-    if (global_capture_opts.all_ifaces->len == 0) {
-      scan_local_interfaces(&global_capture_opts);
+    if (interfaces && interfaces->len > 0) {
+        for (i = 0; i < interfaces->len; i++) {
+            d_interface = g_array_index(interfaces, displayed_interface, i);
+            gtk_list_store_append (store, &iter);
+            gtk_list_store_set (store, &iter, ICON, d_interface.icon, IFACE_DESCR, d_interface.descr, IFACE_NAME, d_interface.name, -1);
+        }
     } else {
-        for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-            device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-            if (!device.hidden) {
+        interfaces = g_array_new(TRUE, TRUE, sizeof(displayed_interface));
+        if_list = capture_interface_list(&err, &err_str);
+        if_list = g_list_sort (if_list, if_list_comparator_alph);
+        if (if_list == NULL && err == CANT_GET_INTERFACE_LIST) {
+            simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "%s", err_str);
+            g_free(err_str);
+            return;
+        } else if (err_str) {
+            g_free(err_str);
+        }
+        if (g_list_length(if_list) > 0) {
+            /* List the interfaces */
+            for (curr = g_list_first(if_list); curr; curr = g_list_next(curr)) {
+                if_info = curr->data;
+                /* Continue if capture device is hidden */
+                if (prefs_is_capture_device_hidden(if_info->name)) {
+                    continue;
+                }
                 gtk_list_store_append (store, &iter);
-                gtk_list_store_set (store, &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(capture_get_if_icon(&(device.if_info)))), IFACE_DESCR, device.display_name, IFACE_NAME, device.name, -1);
-            }
-            if (device.selected) {
-                gtk_tree_selection_select_iter(entry, &iter);
+                d_interface.name = g_strdup(if_info->name);
+#ifdef HAVE_PCAP_REMOTE
+                d_interface.remote_opts.src_type = CAPTURE_IFLOCAL;
+#endif
+#ifdef HAVE_AIRPCAP
+                if (get_airpcap_if_from_name(airpcap_if_list,if_info->name) != NULL)
+                    icon = xpm_to_widget(capture_airpcap_16_xpm);
+                else
+                    icon = capture_get_if_icon(if_info);
+#else
+                icon = capture_get_if_icon(if_info);
+#endif
+                d_interface.icon = icon;
+                user_descr = capture_dev_user_descr_find(if_info->name);
+                if (user_descr) {
+#ifndef _WIN32
+                    gchar *comment = user_descr;
+                    user_descr = g_strdup_printf("%s (%s)", comment, if_info->name);
+                    g_free (comment);
+#endif
+                    gtk_list_store_set(store, &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(icon)), IFACE_DESCR, user_descr, IFACE_NAME, if_info->name, -1);
+                    d_interface.descr = g_strdup(user_descr);               
+                    g_free (user_descr);
+                } else if (if_info->description) {
+                    gtk_list_store_set (store, &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(icon)), IFACE_DESCR, if_info->description, IFACE_NAME, if_info->name, -1);
+                    d_interface.descr = g_strdup(if_info->description);
+                } else {
+                    gtk_list_store_set (store, &iter, ICON, gtk_image_get_pixbuf(GTK_IMAGE(icon)), IFACE_DESCR, if_info->name, IFACE_NAME, if_info->name, -1);
+                    d_interface.descr = g_strdup(if_info->name); 
+                }
+                g_array_append_val(interfaces, d_interface);
             }
         }
-        changed = TRUE;
-    }
-    gtk_tree_selection_set_select_function(entry, on_selection_changed, (gpointer)&changed, NULL);
-    if (gtk_widget_is_focus(view) && dlg_window_present()) {
-        update_all_rows();
+        free_interface_list(if_list);
+        gtk_tree_view_set_model(GTK_TREE_VIEW(if_view), GTK_TREE_MODEL (store));
+        if (global_capture_opts.ifaces->len > 0) {
+            gtk_tree_model_foreach(GTK_TREE_MODEL(store), select_current_ifaces, (gpointer) entry);
+            gtk_widget_grab_focus(view);
+        }
+        gtk_tree_selection_set_select_function(entry, on_selection_changed, NULL, NULL);
     }
 #endif  /* HAVE_LIBPCAP */
 }
@@ -920,9 +1051,23 @@ void
 welcome_if_panel_reload(void)
 {
 #ifdef HAVE_LIBPCAP
-    if (welcome_hb) {
+    GtkWidget *child_box;
+    GList* child_list;
+    GList* child_list_item;
+
+    if(welcome_if_panel_vb) {
+        child_box = scroll_box_dynamic_reset(welcome_if_panel_vb);
+        child_list = gtk_container_get_children(GTK_CONTAINER(child_box));
+        child_list_item = child_list;
+
+        while(child_list_item) {
+            gtk_container_remove(GTK_CONTAINER(child_box), child_list_item->data);
+            child_list_item = g_list_next(child_list_item);
+        }
+
+        g_list_free(child_list);
         welcome_if_tree_load();
-        gtk_widget_show_all(welcome_hb);
+        gtk_widget_show_all(welcome_if_panel_vb);
     }
 #endif  /* HAVE_LIBPCAP */
 }
@@ -931,16 +1076,16 @@ welcome_if_panel_reload(void)
 static void capture_if_start(GtkWidget *w _U_, gpointer data _U_)
 {
 #ifdef HAVE_AIRPCAP
-  interface_t device;
-  guint i;
+  interface_options interface_opts;
 #endif
-  if (global_capture_opts.num_selected == 0) {
+
+  if (global_capture_opts.ifaces->len == 0) {
     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
       "You didn't specify an interface on which to capture packets.");
     return;
   }
 #ifndef USE_THREADS
-  if (global_capture_opts.num_selected > 1) {
+  if (global_capture_opts.ifaces->len > 1) {
     simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
       "You specified multiple interfaces for capturing which this version of Wireshark doesn't support.");
     return;
@@ -952,15 +1097,10 @@ static void capture_if_start(GtkWidget *w _U_, gpointer data _U_)
       g_free(global_capture_opts.save_file);
       global_capture_opts.save_file = NULL;
   }
-#ifdef HAVE_AIRPCAP  /* TODO: don't let it depend on interface_opts */
-  for (i = 0; i < global_capture_opts.all_ifaces->len; i++) {
-    device = g_array_index(global_capture_opts.all_ifaces, interface_t, i);
-    airpcap_if_active = get_airpcap_if_from_name(airpcap_if_list, device.name);
-    airpcap_if_selected = airpcap_if_active;
-    if (airpcap_if_selected) {
-        break;
-    }
-  }
+#ifdef HAVE_AIRPCAP
+  interface_opts = g_array_index(global_capture_opts.ifaces, interface_options, 0);
+  airpcap_if_active = get_airpcap_if_from_name(airpcap_if_list, interface_opts.name);
+  airpcap_if_selected = airpcap_if_active;
   airpcap_set_toolbar_start_capture(airpcap_if_active);
 #endif
   capture_start_cb(NULL, NULL);
@@ -991,11 +1131,14 @@ welcome_new(void)
     GtkTreeSelection *selection;
     GtkCellRenderer *renderer;
     GtkTreeViewColumn *column;
+    GList     *if_list;
+    int err;
+    gchar *err_str = NULL;
 #endif
 
     /* prepare colors */
 #if 0
-    /* Allocating color isn't necessary? */
+	/* Allocating collor isn't necessary? */
 
     /* "page" background */
     get_color(&welcome_bg);
@@ -1015,7 +1158,7 @@ welcome_new(void)
     topic_item_idle_bg = topic_content_bg;
 #endif
 #if 0
-    /* Allocating color isn't necessary? */
+	/* Allocating collor isn't necessary? */
     /* topic item entered color */
     get_color(&topic_item_entered_bg);
 #endif
@@ -1026,9 +1169,9 @@ welcome_new(void)
     welcome_eb = gtk_event_box_new();
     gtk_container_add(GTK_CONTAINER(welcome_eb), welcome_vb);
 #if GTK_CHECK_VERSION(3,0,0)
-    gtk_widget_override_background_color(welcome_eb, GTK_STATE_NORMAL, &rgba_welcome_bg);
+	gtk_widget_override_background_color(welcome_eb, GTK_STATE_NORMAL, &rgba_welcome_bg);
 #else
-    gtk_widget_modify_bg(welcome_eb, GTK_STATE_NORMAL, &welcome_bg);
+	gtk_widget_modify_bg(welcome_eb, GTK_STATE_NORMAL, &welcome_bg);
 #endif
     /* header */
     header = welcome_header_new();
@@ -1043,7 +1186,7 @@ welcome_new(void)
     /* column capture */
     column_vb = gtk_vbox_new(FALSE, 10);
 #if GTK_CHECK_VERSION(3,0,0)
-    gtk_widget_override_background_color(column_vb, GTK_STATE_NORMAL, &rgba_welcome_bg);
+	gtk_widget_override_background_color(column_vb, GTK_STATE_NORMAL, &rgba_welcome_bg);
 #else
     gtk_widget_modify_bg(column_vb, GTK_STATE_NORMAL, &welcome_bg);
 #endif
@@ -1054,10 +1197,8 @@ welcome_new(void)
     gtk_box_pack_start(GTK_BOX(column_vb), topic_vb, TRUE, TRUE, 0);
 
 #ifdef HAVE_LIBPCAP
-    if (global_capture_opts.all_ifaces->len == 0) {
-        scan_local_interfaces(&global_capture_opts);
-    }
-    if (global_capture_opts.all_ifaces->len > 0) {
+    if_list = capture_interface_list(&err, &err_str);
+    if (g_list_length(if_list) > 0) {
         item_hb = welcome_button(WIRESHARK_STOCK_CAPTURE_INTERFACES,
             "Interface List",
             "Live list of the capture interfaces\n(counts incoming packets)",
@@ -1074,13 +1215,17 @@ welcome_new(void)
         g_object_set(G_OBJECT(if_view), "headers-visible", FALSE, NULL);
         g_signal_connect(if_view, "row-activated", G_CALLBACK(options_interface_cb), (gpointer)welcome_hb);
         g_object_set_data(G_OBJECT(welcome_hb), TREE_VIEW_INTERFACES, if_view);
-        column = gtk_tree_view_column_new();
         renderer = gtk_cell_renderer_pixbuf_new();
-        gtk_tree_view_column_pack_start(column, renderer, FALSE);
-        gtk_tree_view_column_set_attributes(column, renderer, "pixbuf", ICON, NULL);
+        column = gtk_tree_view_column_new_with_attributes ("",
+                                               GTK_CELL_RENDERER(renderer),
+                                               "pixbuf", ICON,
+                                               NULL);
+        gtk_tree_view_append_column(GTK_TREE_VIEW(if_view), column);
         renderer = gtk_cell_renderer_text_new();
-        gtk_tree_view_column_pack_start(column, renderer, TRUE);
-        gtk_tree_view_column_set_attributes(column, renderer, "text", IFACE_DESCR, NULL);
+        column = gtk_tree_view_column_new_with_attributes ("",
+                                               GTK_CELL_RENDERER(renderer),
+                                               "text", IFACE_DESCR,
+                                               NULL);
         gtk_tree_view_append_column(GTK_TREE_VIEW(if_view), column);
         gtk_tree_view_column_set_resizable(gtk_tree_view_get_column(GTK_TREE_VIEW(if_view), 0), TRUE);
         renderer = gtk_cell_renderer_text_new();
@@ -1141,6 +1286,8 @@ welcome_new(void)
         gtk_box_pack_start(GTK_BOX(topic_to_fill), w, FALSE, FALSE, 5);
     }
 
+    free_interface_list(if_list);
+
     /* capture help topic */
     topic_vb = welcome_topic_new("Capture Help", &topic_to_fill);
     gtk_box_pack_start(GTK_BOX(column_vb), topic_vb, TRUE, TRUE, 0);
@@ -1281,3 +1428,9 @@ GtkWidget* get_welcome_window(void)
   return welcome_hb;
 }
 
+#ifdef HAVE_LIBPCAP
+displayed_interface get_interface_data(gint index)
+{
+  return g_array_index(interfaces, displayed_interface, index);
+}
+#endif
diff --git a/gtk/main_welcome.h b/gtk/main_welcome.h
index 16cb217cf2..566f7669e2 100644
--- a/gtk/main_welcome.h
+++ b/gtk/main_welcome.h
@@ -40,6 +40,15 @@ typedef struct selected_name_s {
   gboolean activate;
 } selected_name_t;
 
+typedef struct displayed_interface_s {
+	gchar *name;
+	gchar *descr;
+	GtkWidget *icon;
+#ifdef HAVE_PCAP_REMOTE
+	remote_options remote_opts;
+#endif
+} displayed_interface;
+
 GtkWidget *welcome_new(void);
 
 /* reset the list of recently used files */
@@ -51,8 +60,6 @@ void main_welcome_add_recent_capture_file(const char *widget_cf_name, GObject *m
 /* reload the list of interfaces */
 void welcome_if_panel_reload(void);
 
-void welcome_if_tree_load(void);
-
 /** Push a status message into the welcome screen header similar to
  *  statusbar_push_*_msg(). This hides everything under the header.
  *  If msg is dynamically allocated, it is up to the caller to free
@@ -78,10 +85,10 @@ void change_interface_selection(gchar* name, gboolean activate);
 
 void change_selection_for_all(gboolean enable);
 
-void update_welcome_list(void);
-
 #ifdef HAVE_PCAP_REMOTE
-void add_interface_to_list(guint index);
+void add_interface_to_list(gchar *name, gchar *descr, remote_options *remote_opts);
 #endif
 
+displayed_interface get_interface_data(gint index);
+
 #endif /* __MAIN_WELCOME_H__ */
diff --git a/gtk/prefs_capture.c b/gtk/prefs_capture.c
index 29e27f425c..7c704732a7 100644
--- a/gtk/prefs_capture.c
+++ b/gtk/prefs_capture.c
@@ -1434,7 +1434,6 @@ ifopts_write_new_hide(void)
 			g_free(new_hide);
 			prefs.capture_devices_hide = NULL;
 		}
-		hide_interface(g_strdup(new_hide));
 	}
 }
author	Michael Tüxen <tuexen@fh-muenster.de>	2011-10-20 19:44:40 +0000
committer	Michael Tüxen <tuexen@fh-muenster.de>	2011-10-20 19:44:40 +0000
commit	c219f2eea54ef19c811bc1294416fb6b30a046f8 (patch)
tree	cced8090a0b70bd451688295b593f651386440d4
parent	3c1f16f904b786a6e98325362ae95b80ac41819f (diff)