Extcap Capture Interface

 Extcap is a plugin interface, which allows for the usage
 of external capture interfaces via pipes using a predefined
 configuration language which results in a graphical gui.

 This implementation seeks for a generic implementation,
 which results in a seamless integration with the current
 system, and does add all external interfaces as simple
 interfaces.

 Windows Note: Due to limitations with GTK and Windows,
 a gspawn-winXX-helper.exe, respective gspawn-winXX-helper-console.exe
 is needed, which is part of any GTK windows installation.

 The default installation directory from the build is an extcap
 subdirectory underneath the run directory. The folder used by
 extcap may be viewed in the folders tab of the about dialog.

 The default installation directory for extcap plugins with
 a pre-build or installer version of wireshark is the extcap
 subdirectory underneath the main wireshark directory.

 For more information see:

  http://youtu.be/Nn84T506SwU
  bug #9009

 Also take a look in doc/extcap_example.py for a Python-example
 and in extcap.pod for the arguments grammer.

 Todo:
   - Integrate with Qt - currently no GUI is generated, but
     the interfaces are still usable

Change-Id: I4f1239b2f1ebd8b2969f73af137915f5be1ce50f
Signed-off-by: Mike Ryan <mikeryan+wireshark@lacklustre.net>
Signed-off-by: Mike Kershaw <dragorn@kismetwireless.net>
Signed-off-by: Roland Knall <rknall@gmail.com>
Reviewed-on: https://code.wireshark.org/review/359
Petri-Dish: Michael Mann <mmann78@netscape.net>
Tested-by: Petri Dish Buildbot <buildbot-no-reply@wireshark.org>
Reviewed-by: Michael Mann <mmann78@netscape.net>

10 files changed, 1055 insertions, 0 deletions

diff --git a/ui/gtk/CMakeLists.txt b/ui/gtk/CMakeLists.txt
index a97a72e893..545781eebc 100644
--- a/ui/gtk/CMakeLists.txt
+++ b/ui/gtk/CMakeLists.txt
@@ -119,6 +119,13 @@ set(WIRESHARK_GTK_SRC
 	webbrowser.c
 )
 
+if(HAVE_EXTCAP)
+	set(WIRESHARK_GTK_SRC
+		${WIRESHARK_GTK_SRC}
+		extcap_gtk.c
+	)
+endif()
+
 set(WIRESHARK_DIRTY_TAP_SRC
 )
 
diff --git a/ui/gtk/Makefile.common b/ui/gtk/Makefile.common
index 405ae13c9a..c2a0a726e1 100644
--- a/ui/gtk/Makefile.common
+++ b/ui/gtk/Makefile.common
@@ -135,6 +135,7 @@ WIRESHARK_GTK_SRC = \
 	uat_gui.c	\
 	voip_calls.c	\
 	webbrowser.c	\
+	extcap_gtk.c	\
 	$(WIRESHARK_CUSTOM_GTK_SRC)
 
 about_dlg.c main_welcome.c: wssplash.h remote_icons.h
@@ -317,4 +318,5 @@ noinst_HEADERS = \
 	wsiconcap.h \
 	wsicon.h \
 	wssplash.h \
+	extcap_gtk.h \
 	$(WIRESHARK_CUSTOM_HDRS)
diff --git a/ui/gtk/about_dlg.c b/ui/gtk/about_dlg.c
index a7b251defc..151a691feb 100644
--- a/ui/gtk/about_dlg.c
+++ b/ui/gtk/about_dlg.c
@@ -484,6 +484,18 @@ about_folders_page_new(void)
   g_free(path);
 #endif
 
+#ifdef HAVE_EXTCAP
+  /* extcap */
+  constpath = get_extcap_dir();
+
+  resultArray = g_strsplit(constpath, G_SEARCHPATH_SEPARATOR_S, 10);
+
+  for(i = 0; resultArray[i]; i++)
+    about_folders_row(table, "Extcap path", g_strstrip(resultArray[i]),
+		      "Extcap Plugins search path");
+  g_strfreev(resultArray);
+#endif
+
   gtk_container_add(GTK_CONTAINER(scrolledwindow), table);
 
   return scrolledwindow;
diff --git a/ui/gtk/capture_dlg.c b/ui/gtk/capture_dlg.c
index 4a628c022b..7a299d047c 100644
--- a/ui/gtk/capture_dlg.c
+++ b/ui/gtk/capture_dlg.c
@@ -80,6 +80,11 @@
 #include "airpcap_dlg.h"
 #endif
 
+#ifdef HAVE_EXTCAP
+#include "extcap.h"
+#include "ui/gtk/extcap_gtk.h"
+#endif
+
 /*
  * Symbolic names for column indices.
  */
@@ -165,6 +170,10 @@ enum
 #define E_CAP_T_RESOLVE_KEY             "cap_t_resolve"
 #define E_CAP_E_RESOLVE_KEY             "cap_e_resolve"
 
+#ifdef HAVE_EXTCAP
+#define E_CAP_EXTCAP_KEY                "cap_extcap_vbox"
+#endif
+
 #define E_CAP_IFTYPE_CBX_KEY            "cap_iftype_cbx"
 #ifdef HAVE_PCAP_REMOTE
 #define E_CAP_IF_LIST_KEY               "cap_if_list"
@@ -2382,6 +2391,9 @@ save_options_cb(GtkWidget *win _U_, gpointer user_data _U_)
 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
   GtkWidget *buffer_size_sb;
 #endif
+#ifdef HAVE_EXTCAP
+  GtkWidget *extcap_vbox;
+#endif
 
   interface_t device;
   gpointer   ptr = NULL;
@@ -2403,6 +2415,10 @@ save_options_cb(GtkWidget *win _U_, gpointer user_data _U_)
 
   linktype_combo_box = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_LT_CBX_KEY);
 
+#ifdef HAVE_EXTCAP
+  extcap_vbox  = (GtkWidget *) g_object_get_data(G_OBJECT(opt_edit_w), E_CAP_EXTCAP_KEY);
+#endif
+
   if (device.links != NULL) {
      if (ws_combo_box_get_active_pointer(GTK_COMBO_BOX(linktype_combo_box), &ptr)) {
        /* Even though device.links != NULL, we might not have an active pointer
@@ -2436,6 +2452,19 @@ save_options_cb(GtkWidget *win _U_, gpointer user_data _U_)
     g_free(device.cfilter);
   g_assert(filter_text != NULL);
   device.cfilter = filter_text;
+
+#ifdef HAVE_EXTCAP
+  if (device.external_cap_args_settings != NULL)
+    g_hash_table_unref(device.external_cap_args_settings);
+
+  device.external_cap_args_settings = extcap_gtk_get_state(extcap_vbox);
+
+  /* Destroy the args data linked in the gtk widget */
+#if 0
+  extcap_gtk_free_args(extcap_vbox);
+#endif
+#endif
+
 #ifdef HAVE_PCAP_CREATE
   /* if dumpcap reported that the interface does not support monitor
      mode, we disable monitor mode even if the user explicitly selected it */
@@ -2472,6 +2501,36 @@ adjust_snap_sensitivity(GtkWidget *tb _U_, gpointer parent_w _U_)
   g_array_insert_val(global_capture_opts.all_ifaces, marked_interface, device);
 }
 
+#ifdef HAVE_EXTCAP
+void
+extcap_free_arglist(gpointer data, gpointer user_data _U_)
+{
+  extcap_free_arg ( (extcap_arg *) data );
+}
+
+static GtkWidget *build_extcap_options(const gchar *name, GHashTable *hash) {
+  GtkWidget *ret_box = NULL;
+  GList *arglist = NULL;
+  GList *elem = NULL;
+
+  arglist = extcap_get_if_configuration( name );
+  for ( elem = g_list_first(arglist); elem; elem = elem->next )
+  {
+      GSList *widget_list;
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+      ret_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 3);
+#else
+      ret_box = gtk_vbox_new(FALSE, 3);
+#endif
+      widget_list = extcap_populate_gtk_vbox((GList *) elem->data, ret_box, hash);
+      g_object_set_data(G_OBJECT(ret_box), EXTCAP_GTK_DATA_KEY_WIDGETLIST, widget_list);
+  }
+
+  return ret_box;
+}
+#endif
+
 void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column _U_, gpointer userdata)
 {
   GtkWidget       *caller, *window, *swindow = NULL, *if_view,
@@ -2494,7 +2553,11 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
                   *compile_bt,
 #endif
                   *bbox, *ok_but, *cancel_bt,
+#ifdef HAVE_EXTCAP
+                  *extcap_vbox,
+#endif
                   *help_bt;
+
   GList           *cf_entry, *list, *cfilter_list;
   GtkAdjustment   *snap_adj;
 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
@@ -2518,6 +2581,9 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
   GtkCellRenderer *renderer;
   GtkListStore    *store;
   const gchar     *new_cfilter;
+#ifdef HAVE_EXTCAP
+  GHashTable      *extcap_hash;
+#endif
 
   window = (GtkWidget *)userdata;
   caller = gtk_widget_get_toplevel(GTK_WIDGET(window));
@@ -2544,6 +2610,9 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
 #if defined(_WIN32) || defined(HAVE_PCAP_CREATE)
   device.buffer = DEFAULT_CAPTURE_BUFFER_SIZE;
 #endif
+#ifdef HAVE_EXTCAP
+  device.external_cap_args_settings = NULL;
+#endif
 
   model = gtk_tree_view_get_model(view);
   gtk_tree_model_get_iter (model, &iter, path);
@@ -2913,6 +2982,14 @@ void options_interface_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColum
   }
 #endif
 
+#ifdef HAVE_EXTCAP
+  extcap_hash = device.external_cap_args_settings;
+  extcap_vbox = build_extcap_options(device.name, extcap_hash);
+  gtk_box_pack_start(GTK_BOX(capture_vb), extcap_vbox, FALSE, FALSE, 5);
+  gtk_widget_show(extcap_vbox);
+  g_object_set_data(G_OBJECT(opt_edit_w), E_CAP_EXTCAP_KEY, extcap_vbox);
+#endif
+
 /* Button row: "Start", "Cancel" and "Help" buttons */
   bbox = dlg_button_row_new(GTK_STOCK_OK, GTK_STOCK_CANCEL, GTK_STOCK_HELP, NULL);
   gtk_box_pack_start(GTK_BOX(main_vb), bbox, FALSE, FALSE, 5);
diff --git a/ui/gtk/capture_if_dlg.c b/ui/gtk/capture_if_dlg.c
index 9eb002cc27..d792af83eb 100644
--- a/ui/gtk/capture_if_dlg.c
+++ b/ui/gtk/capture_if_dlg.c
@@ -426,6 +426,9 @@ GtkWidget * capture_get_if_icon(interface_t *device)
     return pixbuf_to_widget(network_wired_pb_data);
   case IF_PIPE:
   case IF_STDIN:
+#ifdef HAVE_EXTCAP
+  case IF_EXTCAP:
+#endif
     return pixbuf_to_widget(pipe_pb_data);
   default:
     printf("unknown device type\n");
diff --git a/ui/gtk/extcap_gtk.c b/ui/gtk/extcap_gtk.c
new file mode 100644
index 0000000000..69f3908626
--- /dev/null
+++ b/ui/gtk/extcap_gtk.c
@@ -0,0 +1,806 @@
+/* extcap_gtk.c
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include <glib.h>
+#include <gtk/gtk.h>
+
+#include <ui/gtk/gui_utils.h>
+#include <wsutil/filesystem.h>
+
+#include <extcap_parser.h>
+#include "extcap_gtk.h"
+
+GHashTable *extcap_gtk_get_state(GtkWidget *widget) {
+	GSList *widget_list, *widget_iter;
+	GSList *radio_list = NULL, *radio_iter = NULL;
+
+	GtkWidget *list_widget, *radio_widget, *tree_widget, *entry_widget;
+
+	extcap_arg *arg = NULL;
+	extcap_value *value = NULL;
+	extcap_complex *parsed_complex = NULL;
+
+	GtkTreeSelection *treeselection;
+	GtkTreeModel *treemodel;
+	GtkTreeIter treeiter;
+
+	GHashTable *ret_hash;
+
+	gchar *call_string = NULL;
+
+	gchar **multi_list = NULL;
+	int multi_num = 0;
+	gboolean multi_valid, multi_enabled;
+
+	widget_list = (GSList *) g_object_get_data(G_OBJECT(widget),
+	EXTCAP_GTK_DATA_KEY_WIDGETLIST);
+
+	if (widget_list == NULL)
+		return NULL ;
+
+	/* String hash */
+	ret_hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
+
+	for (widget_iter = widget_list; widget_iter; widget_iter =
+			widget_iter->next) {
+		list_widget = (GtkWidget *) widget_iter->data;
+
+		if ((arg = (extcap_arg *) g_object_get_data(G_OBJECT(list_widget),
+		EXTCAP_GTK_DATA_KEY_ARGPTR)) == NULL) {
+			continue;
+		}
+
+		switch (arg->arg_type) {
+		case EXTCAP_ARG_INTEGER:
+		case EXTCAP_ARG_UNSIGNED:
+		case EXTCAP_ARG_LONG:
+		case EXTCAP_ARG_DOUBLE:
+		case EXTCAP_ARG_STRING:
+			parsed_complex = extcap_parse_complex(arg->arg_type,
+					gtk_entry_get_text(GTK_ENTRY(list_widget)));
+			if (parsed_complex == NULL) {
+				continue;
+			}
+			break;
+		case EXTCAP_ARG_BOOLEAN:
+		case EXTCAP_ARG_BOOLFLAG:
+			parsed_complex = extcap_parse_complex(arg->arg_type,
+					gtk_toggle_button_get_active(
+							GTK_TOGGLE_BUTTON(list_widget)) ? "true" : "false");
+			break;
+		case EXTCAP_ARG_FILESELECT:
+			if ((entry_widget =
+					(GtkWidget *) g_object_get_data(G_OBJECT(list_widget),
+							EXTCAP_GTK_DATA_KEY_FILENAME)) == NULL) {
+				continue;
+			}
+			parsed_complex = extcap_parse_complex(arg->arg_type,
+					gtk_entry_get_text(GTK_ENTRY(entry_widget)));
+			if (parsed_complex == NULL) {
+				continue;
+			}
+			break;
+		case EXTCAP_ARG_MENU:
+			break;
+		case EXTCAP_ARG_RADIO:
+			if ((radio_widget = (GtkWidget *) g_object_get_data(
+					G_OBJECT(list_widget),
+					EXTCAP_GTK_DATA_KEY_FIRSTRADIO)) == NULL) {
+				continue;
+			}
+
+			if ((radio_list = gtk_radio_button_get_group(
+					GTK_RADIO_BUTTON(radio_widget))) == NULL) {
+				continue;
+			}
+
+			for (radio_iter = radio_list; radio_iter;
+					radio_iter = radio_iter->next) {
+				GtkWidget *cur_radio = (GtkWidget *) radio_iter->data;
+
+				if (gtk_toggle_button_get_active(
+						GTK_TOGGLE_BUTTON(cur_radio))) {
+					if ((value = (extcap_value *) g_object_get_data(
+							G_OBJECT(cur_radio),
+							EXTCAP_GTK_DATA_KEY_VALPTR)) == NULL) {
+						continue;
+					}
+
+					if (value->is_default)
+						continue;
+
+					call_string = g_strdup(value->call);
+					break;
+				}
+			}
+
+			break;
+		case EXTCAP_ARG_SELECTOR:
+			if ((tree_widget = (GtkWidget *) g_object_get_data(
+					G_OBJECT(list_widget),
+					EXTCAP_GTK_DATA_KEY_TREEVIEW)) == NULL) {
+				continue;
+			}
+
+			treeselection = gtk_tree_view_get_selection(
+					GTK_TREE_VIEW(tree_widget));
+			treemodel = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_widget));
+			if (gtk_tree_selection_get_selected(treeselection, &treemodel,
+					&treeiter)) {
+				gtk_tree_model_get(treemodel, &treeiter, EXTCAP_GTK_COL_VALUE,
+						&value, -1);
+
+				if (value->is_default)
+					continue;
+
+				call_string = g_strdup(value->call);
+			}
+
+			break;
+		case EXTCAP_ARG_MULTICHECK:
+			if ((tree_widget = (GtkWidget *) g_object_get_data(
+					G_OBJECT(list_widget),
+					EXTCAP_GTK_DATA_KEY_TREEVIEW)) == NULL) {
+				continue;
+			}
+
+			treeselection = gtk_tree_view_get_selection(
+					GTK_TREE_VIEW(tree_widget));
+			treemodel = gtk_tree_view_get_model(GTK_TREE_VIEW(tree_widget));
+
+			multi_num = 0;
+
+			/* Count the # of items enabled */
+			multi_valid = gtk_tree_model_get_iter_first(treemodel, &treeiter);
+			while (multi_valid) {
+				gtk_tree_model_get(treemodel, &treeiter,
+						EXTCAP_GTK_MULTI_COL_CHECK, &multi_enabled, -1);
+
+				if (multi_enabled)
+					multi_num++;
+
+				multi_valid = gtk_tree_model_iter_next(treemodel, &treeiter);
+			}
+
+			multi_list = g_new(gchar *, multi_num + 1);
+
+			multi_num = 0;
+
+			/* Count the # of items enabled */
+			multi_valid = gtk_tree_model_get_iter_first(treemodel, &treeiter);
+			while (multi_valid) {
+				gtk_tree_model_get(treemodel, &treeiter,
+						EXTCAP_GTK_MULTI_COL_CHECK, &multi_enabled,
+						EXTCAP_GTK_MULTI_COL_VALUE, &value, -1);
+
+				if (multi_enabled) {
+					multi_list[multi_num] = g_strdup(value->call);
+					multi_num++;
+				}
+
+				multi_valid = gtk_tree_model_iter_next(treemodel, &treeiter);
+			}
+			multi_list[multi_num] = NULL;
+
+			call_string = g_strjoinv(",", multi_list);
+
+			g_strfreev(multi_list);
+
+			break;
+		default:
+			break;
+		}
+
+		if (parsed_complex == NULL && call_string == NULL)
+			continue;
+
+		/* Comparing if the user has changed the value at all, and ignoring it if so */
+		if (extcap_compare_is_default(arg, parsed_complex))
+			continue;
+
+		/* Flags are set as is, and have not true/false switch */
+		if ((arg->arg_type == EXTCAP_ARG_BOOLFLAG)
+				&& (extcap_complex_get_bool(parsed_complex) == TRUE)) {
+			call_string = g_strdup(" ");
+		}
+
+		if (parsed_complex != NULL && call_string == NULL)
+			call_string = extcap_get_complex_as_string(parsed_complex);
+
+		g_hash_table_insert(ret_hash, g_strdup(arg->call),
+				g_strdup(call_string));
+
+		g_free(call_string);
+		call_string = NULL;
+
+		g_free(parsed_complex);
+		parsed_complex = NULL;
+	}
+
+	return ret_hash;
+}
+
+static void extcap_gtk_treeview_vscroll_map_handler(GtkTreeView *treeView,
+		gpointer data) {
+	GtkWidget *padBox = (GtkWidget*) data;
+	gint x, y;
+
+	g_assert(GTK_IS_BOX(padBox));
+
+	/* Set the padding above the scrollbar to the height of the tree header window */
+	gtk_tree_view_convert_bin_window_to_widget_coords(GTK_TREE_VIEW(treeView),
+			0, 0, &x, &y);
+	gtk_widget_set_size_request(padBox, -1, y);
+}
+
+static GtkWidget *extcap_gtk_wrap_scroll_treeview(GtkWidget *view) {
+	GtkWidget *vscroll, *padbox, *hbox, *vbox;
+	GtkAdjustment *padj;
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+	padj = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(view));
+#if GTK_CHECK_VERSION(3, 2, 0)
+	vscroll = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, padj);
+#else
+	vscroll = gtk_vscrollbar_new(padj);
+#endif
+#else
+	padj = gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(view));
+	vscroll = gtk_vscrollbar_new(padj);
+#endif
+
+	hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE);
+
+	/* First insert the tree view */
+	gtk_box_pack_start(GTK_BOX(hbox), view, TRUE, TRUE, 0);
+	gtk_widget_show(view);
+
+	/* Pack to the right a vbox containing a box for padding at top and scrollbar */
+	vbox = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
+	gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
+	gtk_widget_show(vbox);
+
+	padbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE);
+	gtk_box_pack_start(GTK_BOX(vbox), padbox, FALSE, FALSE, 0);
+	gtk_widget_show(padbox);
+
+	gtk_box_pack_start(GTK_BOX(vbox), vscroll, TRUE, TRUE, 0);
+	gtk_widget_show(vscroll);
+
+	g_object_set_data(G_OBJECT(hbox), EXTCAP_GTK_DATA_KEY_TREEVIEW, view);
+
+	g_signal_connect(view, "map",
+			G_CALLBACK(extcap_gtk_treeview_vscroll_map_handler), padbox);
+
+	return hbox;
+}
+
+GtkWidget *extcap_create_gtk_listwidget(extcap_arg *argument,
+		GHashTable *prev_map) {
+	GtkCellRenderer *renderer;
+	GtkTreeModel *model;
+	GtkWidget *view, *retview;
+	GtkListStore *store;
+	GtkTreeIter iter;
+	GtkTreeSelection *selection;
+	extcap_value *v = NULL;
+	GList * walker = NULL;
+	gchar *prev_item = NULL;
+
+	if (g_list_length(argument->values) == 0)
+		return NULL ;
+
+	view = gtk_tree_view_new();
+
+	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
+
+	store = gtk_list_store_new(EXTCAP_GTK_NUM_COLS, G_TYPE_STRING,
+			G_TYPE_POINTER);
+
+	model = GTK_TREE_MODEL(store);
+	gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
+	gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
+
+	if (prev_map != NULL)
+		prev_item = (gchar *) g_hash_table_lookup(prev_map, argument->call);
+
+	for (walker = g_list_first(argument->values); walker != NULL ; walker =
+			walker->next) {
+		v = (extcap_value *) walker->data;
+		if (v->display == NULL)
+			break;
+
+		gtk_list_store_append(store, &iter);
+		gtk_list_store_set(store, &iter, EXTCAP_GTK_COL_DISPLAY, v->display,
+				EXTCAP_GTK_COL_VALUE, v, -1);
+
+		if (prev_item != NULL) {
+			if (g_ascii_strcasecmp(prev_item, v->call) == 0) {
+				gtk_tree_selection_select_iter(selection, &iter);
+			}
+		} else if (v->is_default) {
+			gtk_tree_selection_select_iter(selection, &iter);
+		}
+	}
+
+	renderer = gtk_cell_renderer_text_new();
+	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, "Name",
+			renderer, "text", EXTCAP_GTK_COL_DISPLAY, NULL);
+
+	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
+
+	retview = extcap_gtk_wrap_scroll_treeview(view);
+
+	if (gtk_tree_model_iter_n_children(model, NULL) > 3)
+		gtk_widget_set_size_request(retview, 0, 100);
+
+	/* Tree view has own reference */
+	g_object_unref(model);
+
+	return retview;
+}
+
+GtkWidget *extcap_create_gtk_radiowidget(extcap_arg *argument,
+		GHashTable *prev_map) {
+	GtkWidget *radiobox = NULL, *last_radio = NULL;
+	extcap_value *v = NULL;
+	GList * walker = NULL;
+	gchar *prev_item = NULL;
+
+	if (g_list_length(argument->values) == 0)
+		return NULL ;
+
+	if (prev_map != NULL)
+		prev_item = (gchar *) g_hash_table_lookup(prev_map, argument->call);
+
+	radiobox = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 1, FALSE);
+
+	for (walker = g_list_first(argument->values); walker != NULL ; walker =
+			walker->next) {
+		v = (extcap_value *) walker->data;
+
+		if (last_radio == NULL) {
+			last_radio = gtk_radio_button_new_with_label(NULL, v->display);
+			/* Set a pointer to the first radio button */
+			g_object_set_data(G_OBJECT(radiobox),
+					EXTCAP_GTK_DATA_KEY_FIRSTRADIO, last_radio);
+		} else {
+			last_radio = gtk_radio_button_new_with_label_from_widget(
+					GTK_RADIO_BUTTON(last_radio), v->display);
+		}
+
+		/* Set a pointer to the value used in this radio */
+		g_object_set_data(G_OBJECT(last_radio), EXTCAP_GTK_DATA_KEY_VALPTR, v);
+
+		if (prev_item != NULL) {
+			if (g_ascii_strcasecmp(prev_item, v->call) == 0) {
+				gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(last_radio),
+						TRUE);
+			}
+		} else if (v->is_default) {
+			gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(last_radio), TRUE);
+		}
+
+		gtk_box_pack_start(GTK_BOX(radiobox), last_radio, TRUE, TRUE, 0);
+		gtk_widget_show(last_radio);
+	}
+
+	return radiobox;
+}
+
+static void extcap_gtk_multicheck_toggled(GtkCellRendererToggle *cell _U_,
+		gchar *path_str, gpointer data) {
+	GtkTreeModel *model = (GtkTreeModel *) data;
+	GtkTreeIter iter;
+	GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
+	gboolean enabled;
+
+	gtk_tree_model_get_iter(model, &iter, path);
+	gtk_tree_model_get(model, &iter, EXTCAP_GTK_MULTI_COL_CHECK, &enabled, -1);
+
+	enabled ^= 1;
+
+	gtk_list_store_set(GTK_LIST_STORE(model), &iter, EXTCAP_GTK_MULTI_COL_CHECK,
+			enabled, -1);
+
+	gtk_tree_path_free(path);
+}
+
+GtkWidget *extcap_create_gtk_rangewidget(extcap_arg *argument,
+		GHashTable *prev_map _U_) {
+	GtkWidget *spinButton;
+	GtkAdjustment *adjustment;
+
+	gfloat def = 0.0, min = 0.0, max = 0.0;
+
+	switch (argument->arg_type) {
+	case EXTCAP_ARG_INTEGER:
+		def = (gfloat) extcap_complex_get_int(argument->default_complex);
+		min = (gfloat) extcap_complex_get_int(argument->range_start);
+		max = (gfloat) extcap_complex_get_int(argument->range_end);
+		break;
+	case EXTCAP_ARG_UNSIGNED:
+		def = (gfloat) extcap_complex_get_uint(argument->default_complex);
+		min = (gfloat) extcap_complex_get_uint(argument->range_start);
+		max = (gfloat) extcap_complex_get_uint(argument->range_end);
+		break;
+	case EXTCAP_ARG_LONG:
+		def = (gfloat) extcap_complex_get_long(argument->default_complex);
+		min = (gfloat) extcap_complex_get_long(argument->range_start);
+		max = (gfloat) extcap_complex_get_long(argument->range_end);
+		break;
+	case EXTCAP_ARG_DOUBLE:
+		def = (gfloat) extcap_complex_get_double(argument->default_complex);
+		min = (gfloat) extcap_complex_get_double(argument->range_start);
+		max = (gfloat) extcap_complex_get_double(argument->range_end);
+		break;
+	default:
+		return NULL ;
+		break;
+	}
+
+	adjustment = (GtkAdjustment *)gtk_adjustment_new(def, min, max, 1.0, 10.0, 0.0);
+
+	spinButton = gtk_spin_button_new(adjustment, 0, 0);
+	gtk_spin_button_set_wrap(GTK_SPIN_BUTTON(spinButton), TRUE);
+	gtk_widget_set_size_request(spinButton, 80, -1);
+
+	return spinButton;
+}
+
+static void extcap_file_selectiondialog( GtkWidget *widget _U_, gpointer data )
+{
+	GtkWidget * filechooser = NULL;
+	GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
+	gchar *filename = NULL;
+	gint res = 0;
+	extcap_arg *argument = NULL;
+
+	if ( GTK_ENTRY(data) == NULL )
+		return;
+
+	argument = (extcap_arg *)g_object_get_data(G_OBJECT(data), EXTCAP_GTK_DATA_KEY_ARGUMENT);
+	if ( argument != NULL && argument->fileexists == TRUE )
+		action = GTK_FILE_CHOOSER_ACTION_OPEN;
+
+	filechooser = gtk_file_chooser_dialog_new("Select file path", NULL, action,
+			"_Cancel", GTK_RESPONSE_CANCEL, "_Open", GTK_RESPONSE_ACCEPT, NULL);
+
+	res = gtk_dialog_run (GTK_DIALOG (filechooser));
+	if (res == GTK_RESPONSE_ACCEPT)
+	{
+	    GtkFileChooser *chooser = GTK_FILE_CHOOSER (filechooser);
+	    filename = gtk_file_chooser_get_filename (chooser);
+
+	    /* this check might not be necessary, but just to be on the safe side */
+	    if ( action == GTK_FILE_CHOOSER_ACTION_OPEN && ! file_exists ( filename ) )
+			filename = g_strdup ( " " );
+
+	    gtk_entry_set_text(GTK_ENTRY(data), filename);
+	}
+
+	gtk_widget_destroy (filechooser);
+}
+
+static GtkWidget *extcap_create_gtk_fileselect(extcap_arg *argument,
+		GHashTable *prev_map _U_, gchar * file _U_) {
+	GtkWidget * entry = NULL;
+	GtkWidget * button = NULL;
+	GtkWidget * ret_box = NULL;
+
+	button = gtk_button_new_with_label ("...");
+	entry = gtk_entry_new();
+	if (file != NULL)
+		gtk_entry_set_text(GTK_ENTRY(entry), file);
+	gtk_editable_set_editable (GTK_EDITABLE (entry), FALSE);
+	g_object_set_data(G_OBJECT(entry), EXTCAP_GTK_DATA_KEY_ARGUMENT, argument);
+
+#if GTK_CHECK_VERSION(3, 0, 0)
+	ret_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3);
+#else
+	ret_box = gtk_hbox_new(FALSE, 3);
+#endif
+
+	gtk_box_pack_start ( GTK_BOX(ret_box), entry, TRUE, TRUE, 5 );
+	gtk_widget_show(entry);
+	gtk_box_pack_end ( GTK_BOX(ret_box), button, FALSE, FALSE, 5 );
+	gtk_widget_show(button);
+
+	g_signal_connect (button, "clicked",
+			      G_CALLBACK (extcap_file_selectiondialog), (gpointer) entry);
+
+	g_object_set_data(G_OBJECT(ret_box), EXTCAP_GTK_DATA_KEY_FILENAME, entry);
+
+	return ret_box;
+}
+
+GtkWidget *extcap_create_gtk_multicheckwidget(extcap_arg *argument,
+		GHashTable *prev_map) {
+	GtkCellRenderer *renderer, *togglerenderer;
+	GtkTreeModel *model;
+	GtkWidget *view, *retview;
+	GtkListStore *store;
+	GtkTreeIter iter;
+	GtkTreeSelection *selection;
+	extcap_value *v = NULL;
+	GList * walker = NULL;
+	gchar *prev_item = NULL;
+	gchar **prev_list = NULL, **prev_iter = NULL;
+	gboolean prev_value, prev_matched;
+
+	if (g_list_length(argument->values) == 0)
+		return NULL ;
+
+	view = gtk_tree_view_new();
+
+	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
+
+	store = gtk_list_store_new(EXTCAP_GTK_MULTI_NUM_COLS, G_TYPE_BOOLEAN,
+			G_TYPE_STRING, G_TYPE_POINTER);
+
+	model = GTK_TREE_MODEL(store);
+	gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
+	gtk_tree_selection_set_mode(selection, GTK_SELECTION_NONE);
+
+	if (prev_map != NULL)
+		prev_item = (gchar *) g_hash_table_lookup(prev_map, argument->call);
+
+	if (prev_item != NULL)
+		prev_list = g_strsplit(prev_item, ",", 0);
+
+	for (walker = g_list_first(argument->values); walker != NULL ; walker =
+			walker->next) {
+		v = (extcap_value *) walker->data;
+		if (v->display == NULL)
+			break;
+
+		prev_value = FALSE;
+		prev_matched = FALSE;
+		gtk_list_store_append(store, &iter);
+
+		if (prev_list != NULL) {
+			prev_matched = FALSE;
+			prev_iter = prev_list;
+
+			while (*prev_iter != NULL ) {
+				if (g_strcmp0(*prev_iter, v->call) == 0) {
+					prev_matched = TRUE;
+					prev_value = TRUE;
+					break;
+				}
+
+				prev_iter++;
+			}
+		}
+
+		if (prev_matched == FALSE)
+			prev_value = v->enabled;
+
+		gtk_list_store_set(store, &iter, EXTCAP_GTK_MULTI_COL_CHECK, prev_value,
+				EXTCAP_GTK_MULTI_COL_DISPLAY, v->display,
+				EXTCAP_GTK_MULTI_COL_VALUE, v, -1);
+	}
+
+	if (prev_list != NULL)
+		g_strfreev(prev_list);
+
+	renderer = gtk_cell_renderer_text_new();
+	togglerenderer = gtk_cell_renderer_toggle_new();
+	g_signal_connect(togglerenderer, "toggled",
+			G_CALLBACK(extcap_gtk_multicheck_toggled), model);
+	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1,
+			"Enabled", togglerenderer, "active", EXTCAP_GTK_MULTI_COL_CHECK,
+			NULL);
+	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1, "Name",
+			renderer, "text", EXTCAP_GTK_MULTI_COL_DISPLAY,
+			NULL);
+
+	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
+
+	retview = extcap_gtk_wrap_scroll_treeview(view);
+
+	if (gtk_tree_model_iter_n_children(model, NULL) > 3)
+		gtk_widget_set_size_request(retview, 0, 100);
+
+	/* Tree view has own reference */
+	g_object_unref(model);
+
+	return retview;
+}
+
+void extcap_gtk_free_args(GtkWidget *vbox) {
+	GList *arguments = (GList *) g_object_get_data(G_OBJECT(vbox),
+			EXTCAP_GTK_DATA_KEY_ARGPTR);
+	extcap_free_arg_list(arguments);
+	g_object_set_data(G_OBJECT(vbox), EXTCAP_GTK_DATA_KEY_ARGPTR, NULL);
+}
+
+GSList *extcap_populate_gtk_vbox(GList *arguments, GtkWidget *vbox,
+		GHashTable *prev_map) {
+	GSList *widget_toplist = NULL;
+
+	extcap_arg *arg_iter = NULL;
+
+	extcap_complex *prev_complex = NULL;
+	gchar *prev_call, *default_str;
+
+	GList * arg_list = g_list_first(arguments);
+	if ( arg_list == NULL )
+		return NULL;
+	arg_iter = (extcap_arg*) (arg_list->data);
+
+	g_object_set_data(G_OBJECT(vbox), EXTCAP_GTK_DATA_KEY_ARGPTR, arguments);
+
+	while (arg_list != NULL ) {
+		GtkWidget *hbox = NULL, *label = NULL, *item = NULL;
+
+		arg_iter = (extcap_arg*) (arg_list->data);
+
+		/* A new storage box for label + element */
+
+		hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5, FALSE);
+
+		if (prev_map != NULL
+				&& (prev_call = (gchar *) g_hash_table_lookup(prev_map,
+						arg_iter->call)) != NULL) {
+			prev_complex = extcap_parse_complex(arg_iter->arg_type, prev_call);
+		} else {
+			prev_complex = NULL;
+		}
+
+		switch (arg_iter->arg_type) {
+		case EXTCAP_ARG_INTEGER:
+		case EXTCAP_ARG_UNSIGNED:
+		case EXTCAP_ARG_LONG:
+		case EXTCAP_ARG_DOUBLE:
+			label = gtk_label_new(arg_iter->display);
+			gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.1f);
+			item = extcap_create_gtk_rangewidget(arg_iter, prev_map);
+			if (item == NULL) {
+				item = gtk_entry_new();
+
+				if (prev_complex != NULL) {
+					default_str = extcap_get_complex_as_string(prev_complex);
+					gtk_entry_set_text(GTK_ENTRY(item), default_str);
+					g_free(default_str);
+				} else if (arg_iter->default_complex != NULL) {
+					default_str = extcap_get_complex_as_string(
+							arg_iter->default_complex);
+					gtk_entry_set_text(GTK_ENTRY(item), default_str);
+					g_free(default_str);
+				}
+			}
+			break;
+		case EXTCAP_ARG_STRING:
+			label = gtk_label_new(arg_iter->display);
+
+			item = gtk_entry_new();
+			default_str = NULL;
+
+			if (prev_complex != NULL)
+				default_str = extcap_get_complex_as_string(prev_complex);
+			else if (arg_iter->default_complex != NULL)
+				default_str = extcap_get_complex_as_string(
+						arg_iter->default_complex);
+
+			if (default_str != NULL) {
+				gtk_entry_set_text(GTK_ENTRY(item), default_str);
+				g_free(default_str);
+			}
+
+			break;
+		case EXTCAP_ARG_FILESELECT:
+			label = gtk_label_new(arg_iter->display);
+			default_str = NULL;
+
+			if (prev_complex != NULL)
+				default_str = extcap_get_complex_as_string(prev_complex);
+			else if (arg_iter->default_complex != NULL)
+				default_str = extcap_get_complex_as_string(
+						arg_iter->default_complex);
+
+			gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.1f);
+			item = extcap_create_gtk_fileselect(arg_iter, prev_map, default_str);
+			if (default_str != NULL)
+				g_free(default_str);
+			break;
+		case EXTCAP_ARG_BOOLEAN:
+		case EXTCAP_ARG_BOOLFLAG:
+			item = gtk_check_button_new_with_label(arg_iter->display);
+
+			if (prev_complex != NULL) {
+				if (extcap_complex_get_bool(prev_complex))
+					gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(item), TRUE);
+			} else if (arg_iter->default_complex != NULL
+					&& extcap_complex_get_bool(arg_iter->default_complex)) {
+				gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(item), TRUE);
+			}
+
+			break;
+		case EXTCAP_ARG_MENU:
+			break;
+		case EXTCAP_ARG_RADIO:
+			label = gtk_label_new(arg_iter->display);
+			gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.1f);
+			item = extcap_create_gtk_radiowidget(arg_iter, prev_map);
+			break;
+		case EXTCAP_ARG_SELECTOR:
+			label = gtk_label_new(arg_iter->display);
+			gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.1f);
+			item = extcap_create_gtk_listwidget(arg_iter, prev_map);
+			break;
+		case EXTCAP_ARG_MULTICHECK:
+			label = gtk_label_new(arg_iter->display);
+			gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.1f);
+			item = extcap_create_gtk_multicheckwidget(arg_iter, prev_map);
+			break;
+		default:
+			break;
+		}
+
+		if (prev_complex != NULL)
+			extcap_free_complex(prev_complex);
+
+		if (label != NULL) {
+			gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
+			gtk_widget_show(label);
+		}
+
+		if (item != NULL) {
+			gtk_box_pack_start(GTK_BOX(hbox), item, TRUE, TRUE, 0);
+			gtk_widget_show(item);
+			g_object_set_data(G_OBJECT(item), EXTCAP_GTK_DATA_KEY_ARGPTR,
+					arg_iter);
+
+			if (arg_iter->tooltip != NULL) {
+				gtk_widget_set_tooltip_text(item, arg_iter->tooltip);
+			}
+
+			widget_toplist = g_slist_append(widget_toplist, item);
+		}
+
+		gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 1);
+
+		gtk_widget_show(hbox);
+
+		arg_list = arg_list->next;
+	}
+
+	return widget_toplist;
+}
+
+/*
+ * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 4
+ * indent-tabs-mode: t
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=4 noexpandtab:
+ * :indentSize=4:tabSize=4:noTabs=false:
+ */
diff --git a/ui/gtk/extcap_gtk.h b/ui/gtk/extcap_gtk.h
new file mode 100644
index 0000000000..07a8f21e7b
--- /dev/null
+++ b/ui/gtk/extcap_gtk.h
@@ -0,0 +1,122 @@
+/* extcap_gtk.c
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef __EXTCAP_GTK_H__
+#define __EXTCAP_GTK_H__
+
+#include <stdio.h>
+#include <string.h>
+
+#include <glib.h>
+#include <gtk/gtk.h>
+
+#include <extcap_parser.h>
+
+/*
+ * GObject data keys for linking argument records to the gtk
+ * UI
+ */
+#define EXTCAP_GTK_DATA_KEY_ARGPTR		"EXTCAP_ARGPTR"
+#define EXTCAP_GTK_DATA_KEY_VALPTR		"EXTCAP_VALPTR"
+#define EXTCAP_GTK_DATA_KEY_FIRSTRADIO	"EXTCAP_FIRSTRADIO"
+#define EXTCAP_GTK_DATA_KEY_WIDGETLIST	"EXTCAP_WIDGETLIST"
+#define EXTCAP_GTK_DATA_KEY_TREEVIEW	"EXTCAP_TREEVIEW"
+#define EXTCAP_GTK_DATA_KEY_FILENAME	"EXTCAP_FILENAME"
+#define EXTCAP_GTK_DATA_KEY_ARGUMENT	"EXTCAP_ARGUMENT"
+
+/*
+ * GTK UI / EXTCAP Linkage:
+ *
+ * Packed vbox of widgets
+ *		Contains EXTCAP_WIDGETLIST pointing to enclosed widget list
+ *
+ * GSList gtk_ui_widgets
+ * 		Linked list of drawable widgets in the UI
+ *
+ * GtkWidget contained in GSList
+ * 		Drawn GTK UI element.  If UI element is directly linked
+ * 		to argument, will contain EXTCAP_ARGPTR.
+ *
+ * 		Top-level GTK widgets will include text boxes, sliders
+ * 		(if supported), and checkboxes.
+ *
+ * 		If the top level widget contains radio buttons, it will
+ * 		contain an EXTCAP_ARGPTR *and* an EXTCAP_FIRSTRADIO
+ *
+ * Radio buttons
+ * 		Each radio button will contain an EXTCAP_VALPTR reference
+ * 		to the extcap_value * value being used.
+ *
+ * Selectors
+ * 		Each selector row contains a pointer to the value, in the
+ * 		column COL_VALUE
+ *
+ */
+
+enum extcap_gtk_col_types {
+	EXTCAP_GTK_COL_DISPLAY = 0, EXTCAP_GTK_COL_VALUE = 1, EXTCAP_GTK_NUM_COLS
+};
+
+enum extcap_gtk_multi_col_types {
+	EXTCAP_GTK_MULTI_COL_CHECK = 0,
+	EXTCAP_GTK_MULTI_COL_DISPLAY = 1,
+	EXTCAP_GTK_MULTI_COL_VALUE = 2,
+	EXTCAP_GTK_MULTI_NUM_COLS
+};
+
+/* Get a hash map of calls and values from the top widget */
+GHashTable *extcap_gtk_get_state(GtkWidget *widget);
+
+GtkWidget *extcap_create_gtk_rangewidget(extcap_arg *argument,
+		GHashTable *prev_map);
+GtkWidget *extcap_create_gtk_listwidget(extcap_arg *argument,
+		GHashTable *prev_map);
+GtkWidget *extcap_create_gtk_radiowidget(extcap_arg *argument,
+		GHashTable *prev_map);
+GtkWidget *extcap_create_gtk_multicheckwidget(extcap_arg *argument,
+		GHashTable *prev_map);
+
+/*
+ * Populate a (pre-created) container widget based on an arguments record.
+ * For secondary repopulations, a saved state can be passed to populate
+ * with known values.  This should occur when setting interface options
+ * repeatedly, for example
+ */
+GSList *extcap_populate_gtk_vbox(GList *arguments, GtkWidget *vbox,
+		GHashTable *prev_map);
+
+/* Free args associated with a GTK item */
+void extcap_gtk_free_args(GtkWidget *vbox);
+
+#endif
+
+/*
+ * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 4
+ * indent-tabs-mode: t
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=4 noexpandtab:
+ * :indentSize=4:tabSize=4:noTabs=false:
+ */
diff --git a/ui/iface_lists.c b/ui/iface_lists.c
index a9dd10c72b..1cf3dfeffb 100644
--- a/ui/iface_lists.c
+++ b/ui/iface_lists.c
@@ -136,6 +136,9 @@ scan_local_interfaces(void (*update_cb)(void))
         temp->vendor_description = g_strdup(if_info->vendor_description);
         temp->loopback = if_info->loopback;
         temp->type = if_info->type;
+#ifdef HAVE_EXTCAP
+        temp->extcap = g_strdup(if_info->extcap);
+#endif
         /* Is this interface hidden and, if so, should we include it anyway? */
 
         /* Do we have a user-supplied description? */
@@ -318,6 +321,11 @@ scan_local_interfaces(void (*update_cb)(void))
                 }
             }
         }
+
+#ifdef HAVE_EXTCAP
+        /* Extcap devices start with no cached args */
+        device.external_cap_args_settings = NULL;
+#endif
         if (global_capture_opts.all_ifaces->len <= count) {
             g_array_append_val(global_capture_opts.all_ifaces, device);
             count = global_capture_opts.all_ifaces->len;
@@ -374,6 +382,9 @@ scan_local_interfaces(void (*update_cb)(void))
             device.if_info.vendor_description = g_strdup(interface_opts.descr);
             device.if_info.addrs = NULL;
             device.if_info.loopback = FALSE;
+#ifdef HAVE_EXTCAP
+            device.if_info.extcap = g_strdup(interface_opts.extcap);
+#endif
 
             g_array_append_val(global_capture_opts.all_ifaces, device);
             global_capture_opts.num_selected++;
diff --git a/ui/qt/QtShark.pro b/ui/qt/QtShark.pro
index f50f94e0ae..291ee8512f 100644
--- a/ui/qt/QtShark.pro
+++ b/ui/qt/QtShark.pro
@@ -192,6 +192,8 @@ SOURCES_WS_C = \
     ../../capture_opts.c \
     ../../cfile.c \
     ../../color_filters.c \
+    ../../extcap.c \
+    ../../extcap_parser.c \
     ../../file.c  \
     ../../fileset.c \
     ../../frame_tvbuff.c \
diff --git a/ui/qt/about_dialog.cpp b/ui/qt/about_dialog.cpp
index 231645ee4f..1d54f6690b 100644
--- a/ui/qt/about_dialog.cpp
+++ b/ui/qt/about_dialog.cpp
@@ -239,6 +239,19 @@ AboutDialog::AboutDialog(QWidget *parent) :
     g_free(path);
 #endif
 
+#ifdef HAVE_EXTCAP
+    /* Extcap */
+    constpath = get_extcap_dir();
+
+    resultArray = g_strsplit(constpath, G_SEARCHPATH_SEPARATOR_S, 10);
+
+    for(i = 0; resultArray[i]; i++) {
+        message += about_folders_row("Extcap path", g_strstrip(resultArray[i]),
+                                     "Extcap Plugins search path");
+    }
+    g_strfreev(resultArray);
+#endif
+
     message += "</table>";
     ui->label_folders->setText(message);