Imported Upstream version 0.9.10.0 upstream/0.9.10.0

1 files changed, 1676 insertions, 0 deletions

diff --git a/tui/nm-editor-bindings.c b/tui/nm-editor-bindings.c
new file mode 100644
index 00000000..5be13588
--- /dev/null
+++ b/tui/nm-editor-bindings.c
@@ -0,0 +1,1676 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
+/*
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * Copyright 2013 Red Hat, Inc.
+ */
+
+/**
+ * SECTION:nm-editor-bindings
+ * @short_description: #GBinding-based NM connection editor helpers
+ *
+ * nm-editor-bindings contains helper functions to bind NMSettings objects
+ * to connection editing widgets. The goal is that this should eventually be
+ * shared between nmtui, nm-connection-editor, and gnome-control-center.
+ */
+
+#include "config.h"
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <dbus/dbus-glib.h>
+
+#include "nm-editor-bindings.h"
+#include "nm-gvaluearray-compat.h"
+
+static void
+value_transform_string_int (const GValue *src_value,
+                            GValue       *dest_value)
+{
+	long val;
+	char *end;
+
+	val = strtol (g_value_get_string (src_value), &end, 10);
+	if (val < G_MININT || val > G_MAXINT || *end)
+		return;
+
+	g_value_set_int (dest_value, (int) val);
+}
+
+static void
+value_transform_string_uint (const GValue *src_value,
+                             GValue       *dest_value)
+{
+	long val;
+	char *end;
+
+	val = strtol (g_value_get_string (src_value), &end, 10);
+	if (val < 0 || val > G_MAXUINT || *end)
+		return;
+
+	g_value_set_uint (dest_value, (gint) val);
+}
+
+void
+nm_editor_bindings_init (void)
+{
+	/* glib registers number -> string, but not string -> number */
+	g_value_register_transform_func (G_TYPE_STRING, G_TYPE_INT, value_transform_string_int);
+	g_value_register_transform_func (G_TYPE_STRING, G_TYPE_UINT, value_transform_string_uint);
+}
+
+static gboolean
+ip_string_parse (const char *text,
+                 int         family,
+                 gpointer    addr,
+                 guint32    *prefix)
+{
+	const char *slash;
+	char *addrstr, *end;
+	gboolean valid;
+
+	slash = strchr (text, '/');
+
+	if (slash) {
+		if (!prefix)
+			return FALSE;
+		addrstr = g_strndup (text, slash - text);
+	} else
+		addrstr = g_strdup (text);
+	valid = (inet_pton (family, addrstr, addr) == 1);
+	g_free (addrstr);
+
+	if (!valid)
+		return FALSE;
+
+	if (slash) {
+		*prefix = strtoul (slash + 1, &end, 10);
+		if (   *end
+		    || *prefix == 0
+		    || (family == AF_INET && *prefix > 32)
+		    || (family == AF_INET6 && *prefix > 128))
+			valid = FALSE;
+	} else if (prefix) {
+		if (family == AF_INET)
+			*prefix = 32;
+		else
+			*prefix = 128;
+	}
+
+	return valid;
+}
+
+static gboolean
+ip4_addresses_with_prefix_to_strv (GBinding     *binding,
+                                   const GValue *source_value,
+                                   GValue       *target_value,
+                                   gpointer      user_data)
+{
+	GPtrArray *addrs;
+	GArray *addr;
+	guint32 addrbytes, prefix;
+	char buf[INET_ADDRSTRLEN], **strings;
+	int i;
+
+	addrs = g_value_get_boxed (source_value);
+	strings = g_new0 (char *, addrs->len + 1);
+
+	for (i = 0; i < addrs->len; i++) {
+		addr = addrs->pdata[i];
+		addrbytes = g_array_index (addr, guint32, 0);
+		prefix = g_array_index (addr, guint32, 1);
+
+		if (addrbytes) {
+			strings[i] = g_strdup_printf ("%s/%d",
+			                              inet_ntop (AF_INET, &addrbytes, buf, sizeof (buf)),
+			                              (int) prefix);
+		} else
+			strings[i] = g_strdup ("");
+	}
+
+	g_value_take_boxed (target_value, strings);
+	return TRUE;
+}
+
+static gboolean
+ip4_addresses_with_prefix_from_strv (GBinding     *binding,
+                                     const GValue *source_value,
+                                     GValue       *target_value,
+                                     gpointer      user_data)
+{
+	char **strings;
+	GPtrArray *addrs;
+	GArray *addr;
+	guint32 *addrvals;
+	int i;
+
+	strings = g_value_get_boxed (source_value);
+	/* Fetch the original property value, so as to preserve the gateway elements */
+	g_object_get (g_binding_get_source (binding),
+	              g_binding_get_source_property (binding), &addrs,
+	              NULL);
+
+	for (i = 0; strings[i]; i++) {
+		if (i >= addrs->len) {
+			guint32 val;
+
+			addr = g_array_sized_new (FALSE, FALSE, sizeof (guint32), 3);
+			val = 0;
+			g_array_append_val (addr, val);
+			val = 32;
+			g_array_append_val (addr, val);
+			val = 0;
+			g_array_append_val (addr, val);
+			g_ptr_array_add (addrs, addr);
+		} else
+			addr = addrs->pdata[i];
+		addrvals = (guint32 *)addr->data;
+
+		if (!ip_string_parse (strings[i], AF_INET, &addrvals[0], &addrvals[1])) {
+			g_ptr_array_unref (addrs);
+			return FALSE;
+		}
+	}
+
+	g_ptr_array_set_size (addrs, i);
+	g_value_take_boxed (target_value, addrs);
+	return TRUE;
+}
+
+/**
+ * nm_editor_bind_ip4_addresses_with_prefix_to_strv:
+ * @source: the source object (eg, an #NMSettingIP4Config)
+ * @source_property: the property on @source to bind (eg,
+ *   %NM_SETTING_IP4_CONFIG_ADDRESSES)
+ * @target: the target object (eg, an #NmtAddressList)
+ * @target_property: the property on @target to bind
+ *   (eg, "strings")
+ * @flags: %GBindingFlags
+ *
+ * Binds the %DBUS_TYPE_G_ARRAY_OF_ARRAY_OF_UINT property
+ * @source_property on @source to the %G_TYPE_STRV property
+ * @target_property on @target.
+ *
+ * Each address/prefix/gateway triplet in @source_property will be
+ * converted to a string of the form "ip.ad.dr.ess/prefix" in
+ * @target_property (and vice versa if %G_BINDING_BIDIRECTIONAL) is
+ * specified. The "gateway" fields in @source_property are ignored
+ * when converting to strings, and unmodified when converting from
+ * strings.
+ */
+void
+nm_editor_bind_ip4_addresses_with_prefix_to_strv (gpointer       source,
+                                                  const gchar   *source_property,
+                                                  gpointer       target,
+                                                  const gchar   *target_property,
+                                                  GBindingFlags  flags)
+{
+	g_object_bind_property_full (source, source_property,
+	                             target, target_property,
+	                             flags,
+	                             ip4_addresses_with_prefix_to_strv,
+	                             ip4_addresses_with_prefix_from_strv,
+	                             NULL, NULL);
+}
+
+static gboolean
+ip4_addresses_to_strv (GBinding     *binding,
+                       const GValue *source_value,
+                       GValue       *target_value,
+                       gpointer      user_data)
+{
+	GArray *addrs;
+	guint32 addrbytes;
+	char buf[INET_ADDRSTRLEN], **strings;
+	int i;
+
+	addrs = g_value_get_boxed (source_value);
+	strings = g_new0 (char *, addrs->len + 1);
+
+	for (i = 0; i < addrs->len; i++) {
+		addrbytes = g_array_index (addrs, guint32, i);
+		if (addrbytes)
+			inet_ntop (AF_INET, &addrbytes, buf, sizeof (buf));
+		else
+			buf[0] = '\0';
+		strings[i] = g_strdup (buf);
+	}
+
+	g_value_take_boxed (target_value, strings);
+	return TRUE;
+}
+
+static gboolean
+ip4_addresses_from_strv (GBinding     *binding,
+                         const GValue *source_value,
+                         GValue       *target_value,
+                         gpointer      user_data)
+{
+	char **strings;
+	GArray *addrs;
+	guint32 addr;
+	int i;
+
+	strings = g_value_get_boxed (source_value);
+	addrs = g_array_new (FALSE, FALSE, sizeof (guint32));
+
+	for (i = 0; strings[i]; i++) {
+		if (!ip_string_parse (strings[i], AF_INET, &addr, NULL)) {
+			g_array_unref (addrs);
+			return FALSE;
+		}
+		g_array_append_val (addrs, addr);
+	}
+
+	g_value_take_boxed (target_value, addrs);
+	return TRUE;
+}
+
+/**
+ * nm_editor_bind_ip4_addresses_to_strv:
+ * @source: the source object (eg, an #NMSettingIP4Config)
+ * @source_property: the property on @source to bind (eg,
+ *   %NM_SETTING_IP4_CONFIG_DNS)
+ * @target: the target object (eg, an #NmtAddressList)
+ * @target_property: the property on @target to bind
+ *   (eg, "strings")
+ * @flags: %GBindingFlags
+ *
+ * Binds the %DBUS_TYPE_G_UINT_ARRAY property @source_property on
+ * @source to the %G_TYPE_STRV property @target_property on @target.
+ *
+ * Each address in @source_property will be converted to a string of
+ * the form "ip.ad.dr.ess" in @target_property (and vice versa if
+ * %G_BINDING_BIDIRECTIONAL) is specified.
+ */
+void
+nm_editor_bind_ip4_addresses_to_strv (gpointer       source,
+                                      const gchar   *source_property,
+                                      gpointer       target,
+                                      const gchar   *target_property,
+                                      GBindingFlags  flags)
+{
+	g_object_bind_property_full (source, source_property,
+	                             target, target_property,
+	                             flags,
+	                             ip4_addresses_to_strv,
+	                             ip4_addresses_from_strv,
+	                             NULL, NULL);
+}
+
+static gboolean
+ip4_gateway_to_string (GBinding     *binding,
+                       const GValue *source_value,
+                       GValue       *target_value,
+                       gpointer      user_data)
+{
+	GPtrArray *addrs;
+	GArray *addr;
+	guint32 gateway = 0;
+	const char *str;
+	char buf[INET_ADDRSTRLEN];
+	int i;
+
+	addrs = g_value_get_boxed (source_value);
+	for (i = 0; i < addrs->len; i++) {
+		addr = addrs->pdata[i];
+		gateway = g_array_index (addr, guint32, 2);
+		if (gateway)
+			break;
+	}
+
+	if (gateway)
+		str = inet_ntop (AF_INET, &gateway, buf, sizeof (buf));
+	else
+		str = "";
+	g_value_set_string (target_value, str);
+	return TRUE;
+}
+
+static gboolean
+ip4_gateway_from_string (GBinding     *binding,
+                         const GValue *source_value,
+                         GValue       *target_value,
+                         gpointer      user_data)
+{
+	const char *text;
+	GPtrArray *addrs;
+	GArray *addr;
+	guint32 addrbytes, *addrvals;
+	int i;
+
+	text = g_value_get_string (source_value);
+	if (!ip_string_parse (text, AF_INET, &addrbytes, NULL))
+		return FALSE;
+
+	/* Fetch the original property value, so as to preserve the IP address elements */
+	g_object_get (g_binding_get_source (binding),
+	              g_binding_get_source_property (binding), &addrs,
+	              NULL);
+	if (!addrs->len) {
+		g_ptr_array_unref (addrs);
+		return FALSE;
+	}
+	addr = addrs->pdata[0];
+	addrvals = (guint32 *)addr->data;
+	if (addrbytes == addrvals[2]) {
+		g_ptr_array_unref (addrs);
+		return FALSE;
+	}
+	addrvals[2] = addrbytes;
+
+	for (i = 1; i < addrs->len; i++) {
+	     addr = addrs->pdata[i];
+	     addrvals = (guint32 *)addr->data;
+	     addrvals[2] = 0;
+	}
+
+	g_value_take_boxed (target_value, addrs);
+	return TRUE;
+}
+
+/**
+ * nm_editor_bind_ip4_gateway_to_string:
+ * @source: the source object (eg, an #NMSettingIP4Config)
+ * @source_property: the property on @source to bind (eg,
+ *   %NM_SETTING_IP4_CONFIG_ADDRESSES)
+ * @target: the target object (eg, an #NmtNewtEntry)
+ * @target_property: the property on @target to bind
+ *   (eg, "text")
+ * @flags: %GBindingFlags
+ *
+ * Binds the %DBUS_TYPE_G_ARRAY_OF_ARRAY_OF_UINT property
+ * @source_property on @source to the %G_TYPE_STRING property
+ * @target_property on @target.
+ *
+ * Specifically, this binds the "gateway" field of the first address
+ * in @source_property; all other addresses in @source_property are
+ * ignored, and its "address" and "prefix" fields are unmodified.
+ */
+void
+nm_editor_bind_ip4_gateway_to_string (gpointer       source,
+                                      const gchar   *source_property,
+                                      gpointer       target,
+                                      const gchar   *target_property,
+                                      GBindingFlags  flags)
+{
+	g_object_bind_property_full (source, source_property,
+	                             target, target_property,
+	                             flags,
+	                             ip4_gateway_to_string,
+	                             ip4_gateway_from_string,
+	                             NULL, NULL);
+}
+
+static gboolean
+ip4_route_transform_to_dest_string (GBinding     *binding,
+                                    const GValue *source_value,
+                                    GValue       *target_value,
+                                    gpointer      user_data)
+{
+	NMIP4Route *route;
+	char buf[INET_ADDRSTRLEN], *string;
+	guint32 addrbytes;
+
+	route = g_value_get_boxed (source_value);
+	if (route)
+		addrbytes = nm_ip4_route_get_dest (route);
+	else
+		addrbytes = 0;
+
+	if (addrbytes) {
+		string = g_strdup_printf ("%s/%d",
+		                          inet_ntop (AF_INET, &addrbytes, buf, sizeof (buf)),
+		                          (int) nm_ip4_route_get_prefix (route));
+		g_value_take_string (target_value, string);
+	} else
+		g_value_set_string (target_value, "");
+	return TRUE;
+}
+
+static gboolean
+ip4_route_transform_to_next_hop_string (GBinding     *binding,
+                                        const GValue *source_value,
+                                        GValue       *target_value,
+                                        gpointer      user_data)
+{
+	NMIP4Route *route;
+	char buf[INET_ADDRSTRLEN];
+	guint32 addrbytes;
+
+	route = g_value_get_boxed (source_value);
+	if (route)
+		addrbytes = nm_ip4_route_get_next_hop (route);
+	else
+		addrbytes = 0;
+
+	if (addrbytes)
+		inet_ntop (AF_INET, &addrbytes, buf, sizeof (buf));
+	else
+		buf[0] = '\0';
+	g_value_set_string (target_value, buf);
+	return TRUE;
+}
+
+static gboolean
+ip4_route_transform_to_metric_string (GBinding     *binding,
+                                      const GValue *source_value,
+                                      GValue       *target_value,
+                                      gpointer      user_data)
+{
+	NMIP4Route *route;
+	char *string;
+
+	route = g_value_get_boxed (source_value);
+	if (route && nm_ip4_route_get_dest (route)) {
+		string = g_strdup_printf ("%lu", (gulong) nm_ip4_route_get_metric (route));
+		g_value_take_string (target_value, string);
+	} else
+		g_value_set_string (target_value, "");
+	return TRUE;
+}
+
+static gboolean
+ip4_route_transform_from_dest_string (GBinding     *binding,
+                                      const GValue *source_value,
+                                      GValue       *target_value,
+                                      gpointer      user_data)
+{
+	NMIP4Route *route;
+	const char *text;
+	guint32 addrbytes, prefix;
+
+	text = g_value_get_string (source_value);
+	if (!ip_string_parse (text, AF_INET, &addrbytes, &prefix))
+		return FALSE;
+
+	/* Fetch the original property value */
+	g_object_get (g_binding_get_source (binding),
+	              g_binding_get_source_property (binding), &route,
+	              NULL);
+
+	nm_ip4_route_set_dest (route, addrbytes);
+	nm_ip4_route_set_prefix (route, prefix);
+
+	g_value_take_boxed (target_value, route);
+	return TRUE;
+}
+
+static gboolean
+ip4_route_transform_from_next_hop_string (GBinding     *binding,
+                                          const GValue *source_value,
+                                          GValue       *target_value,
+                                          gpointer      user_data)
+{
+	NMIP4Route *route;
+	const char *text;
+	guint32 addrbytes;
+
+	text = g_value_get_string (source_value);
+	if (*text) {
+		if (!ip_string_parse (text, AF_INET, &addrbytes, NULL))
+			return FALSE;
+	} else
+		addrbytes = 0;
+
+	/* Fetch the original property value */
+	g_object_get (g_binding_get_source (binding),
+	              g_binding_get_source_property (binding), &route,
+	              NULL);
+
+	nm_ip4_route_set_next_hop (route, addrbytes);
+
+	g_value_take_boxed (target_value, route);
+	return TRUE;
+}
+
+static gboolean
+ip4_route_transform_from_metric_string (GBinding     *binding,
+                                        const GValue *source_value,
+                                        GValue       *target_value,
+                                        gpointer      user_data)
+{
+	NMIP4Route *route;
+	const char *text;
+	guint32 metric;
+
+	text = g_value_get_string (source_value);
+	metric = strtoul (text, NULL, 10);
+
+	/* Fetch the original property value */
+	g_object_get (g_binding_get_source (binding),
+	              g_binding_get_source_property (binding), &route,
+	              NULL);
+
+	nm_ip4_route_set_metric (route, metric);
+
+	g_value_take_boxed (target_value, route);
+	return TRUE;
+}
+
+/**
+ * nm_editor_bind_ip4_route_to_strings:
+ * @source: the source object
+ * @source_property: the source property
+ * @dest_target: the target object for the route's destionation
+ * @dest_target_property: the property on @dest_target
+ * @next_hop_target: the target object for the route's next hop
+ * @next_hop_target_property: the property on @next_hop_target
+ * @metric_target: the target object for the route's metric
+ * @metric_target_property: the property on @metric_target
+ * @flags: %GBindingFlags
+ *
+ * Binds the #NMIP4Route-valued property @source_property on @source
+ * to the three indicated string-valued target properties (and vice
+ * versa if %G_BINDING_BIDIRECTIONAL is specified).
+ *
+ * @dest_target_property should be an "address/prefix" string, as with
+ * nm_editor_bind_ip4_addresses_with_prefix_to_strv(). @next_hop_target
+ * is a plain IP address, and @metric_target is a number.
+ */
+void
+nm_editor_bind_ip4_route_to_strings (gpointer       source,
+                                     const gchar   *source_property,
+                                     gpointer       dest_target,
+                                     const gchar   *dest_target_property,
+                                     gpointer       next_hop_target,
+                                     const gchar   *next_hop_target_property,
+                                     gpointer       metric_target,
+                                     const gchar   *metric_target_property,
+                                     GBindingFlags  flags)
+{
+	g_object_bind_property_full (source, source_property,
+	                             dest_target, dest_target_property,
+	                             flags,
+	                             ip4_route_transform_to_dest_string,
+	                             ip4_route_transform_from_dest_string,
+	                             NULL, NULL);
+	g_object_bind_property_full (source, source_property,
+	                             next_hop_target, next_hop_target_property,
+	                             flags,
+	                             ip4_route_transform_to_next_hop_string,
+	                             ip4_route_transform_from_next_hop_string,
+	                             NULL, NULL);
+	g_object_bind_property_full (source, source_property,
+	                             metric_target, metric_target_property,
+	                             flags,
+	                             ip4_route_transform_to_metric_string,
+	                             ip4_route_transform_from_metric_string,
+	                             NULL, NULL);
+}
+
+#define IP6_ADDRESS_SET(addr) (   addr	  \
+                               && addr->len == sizeof (struct in6_addr) \
+                               && memcmp (addr->data, &in6addr_any, addr->len) != 0)
+
+static gboolean
+ip6_addresses_with_prefix_to_strv (GBinding     *binding,
+                                   const GValue *source_value,
+                                   GValue       *target_value,
+                                   gpointer      user_data)
+{
+	GPtrArray *addrs;
+	GValueArray *addr;
+	GValue *val;
+	GByteArray *addrbytes;
+	guint prefix;
+	char **strings, buf[INET6_ADDRSTRLEN];
+	int i;
+
+	addrs = g_value_get_boxed (source_value);
+	strings = g_new0 (char *, addrs->len + 1);
+
+	for (i = 0; i < addrs->len; i++) {
+		addr = addrs->pdata[i];
+		val = g_value_array_get_nth (addr, 0);
+		addrbytes = g_value_get_boxed (val);
+		val = g_value_array_get_nth (addr, 1);
+		prefix = g_value_get_uint (val);
+
+		if (IP6_ADDRESS_SET (addrbytes)) {
+			strings[i] = g_strdup_printf ("%s/%d",
+			                              inet_ntop (AF_INET6, addrbytes->data, buf, sizeof (buf)),
+			                              prefix);
+		} else
+			strings[i] = g_strdup ("");
+	}
+
+	g_value_take_boxed (target_value, strings);
+	return TRUE;
+}
+
+static gboolean
+ip6_addresses_with_prefix_from_strv (GBinding     *binding,
+                                     const GValue *source_value,
+                                     GValue       *target_value,
+                                     gpointer      user_data)
+{
+	char **strings;
+	GPtrArray *addrs;
+	GValueArray *addr;
+	guint32 prefix;
+	GValue val = G_VALUE_INIT, *valp;
+	GByteArray *ba;
+	int i;
+
+	strings = g_value_get_boxed (source_value);
+
+	/* Fetch the original property value, so as to preserve the gateway elements */
+	g_object_get (g_binding_get_source (binding),
+	              g_binding_get_source_property (binding), &addrs,
+	              NULL);
+
+	for (i = 0; strings[i]; i++) {
+		if (i >= addrs->len) {
+			addr = g_value_array_new (3);
+
+			g_value_init (&val, DBUS_TYPE_G_UCHAR_ARRAY);
+			ba = g_byte_array_sized_new (sizeof (struct in6_addr));
+			g_byte_array_append (ba, (guint8 *) &in6addr_any, sizeof (struct in6_addr));
+			g_value_take_boxed (&val, ba);
+			g_value_array_append (addr, &val);
+			g_value_unset (&val);
+
+			g_value_init (&val, G_TYPE_UINT);
+			g_value_set_uint (&val, 128);
+			g_value_array_append (addr, &val);
+			g_value_unset (&val);
+
+			g_value_init (&val, DBUS_TYPE_G_UCHAR_ARRAY);
+			ba = g_byte_array_sized_new (sizeof (struct in6_addr));
+			g_byte_array_append (ba, (guint8 *) &in6addr_any, sizeof (struct in6_addr));
+			g_value_take_boxed (&val, ba);
+			g_value_array_append (addr, &val);
+			g_value_unset (&val);
+
+			g_ptr_array_add (addrs, addr);
+		} else
+			addr = addrs->pdata[i];
+
+		valp = g_value_array_get_nth (addr, 0);
+		ba = g_value_get_boxed (valp);
+		g_assert (ba->len == sizeof (struct in6_addr));
+
+		if (!ip_string_parse (strings[i], AF_INET6, ba->data, &prefix)) {
+			g_ptr_array_unref (addrs);
+			return FALSE;
+		}
+
+		valp = g_value_array_get_nth (addr, 1);
+		g_value_set_uint (valp, prefix);
+	}
+
+	g_ptr_array_set_size (addrs, i);
+	g_value_set_boxed (target_value, addrs);
+	return TRUE;
+}
+
+/**
+ * nm_editor_bind_ip6_addresses_with_prefix_to_strv:
+ * @source: the source object (eg, an #NMSettingIP6Config)
+ * @source_property: the property on @source to bind (eg,
+ *   %NM_SETTING_IP6_CONFIG_ADDRESSES)
+ * @target: the target object (eg, an #NmtAddressList)
+ * @target_property: the property on @target to bind
+ *   (eg, "strings")
+ * @flags: %GBindingFlags
+ *
+ * Binds the %DBUS_TYPE_G_ARRAY_OF_IP6_ADDRESS property
+ * @source_property on @source to the %G_TYPE_STRV property
+ * @target_property on @target.
+ *
+ * Each address/prefix/gateway triplet in @source_property will be
+ * converted to a string of the form "ip::ad:dr:ess/prefix" in
+ * @target_property (and vice versa if %G_BINDING_BIDIRECTIONAL) is
+ * specified. The "gateway" fields in @source_property are ignored
+ * when converting to strings, and unmodified when converting from
+ * strings.
+ */
+void
+nm_editor_bind_ip6_addresses_with_prefix_to_strv (gpointer       source,
+                                                  const gchar   *source_property,
+                                                  gpointer       target,
+                                                  const gchar   *target_property,
+                                                  GBindingFlags  flags)
+{
+	g_object_bind_property_full (source, source_property,
+	                             target, target_property,
+	                             flags,
+	                             ip6_addresses_with_prefix_to_strv,
+	                             ip6_addresses_with_prefix_from_strv,
+	                             NULL, NULL);
+}
+
+static gboolean
+ip6_addresses_to_strv (GBinding     *binding,
+                       const GValue *source_value,
+                       GValue       *target_value,
+                       gpointer      user_data)
+{
+	GPtrArray *addrs;
+	GByteArray *addrbytes;
+	char buf[INET6_ADDRSTRLEN], **strings;
+	int i;
+
+	addrs = g_value_get_boxed (source_value);
+	strings = g_new0 (char *, addrs->len + 1);
+
+	for (i = 0; i < addrs->len; i++) {
+		addrbytes = addrs->pdata[i];
+		if (IP6_ADDRESS_SET (addrbytes))
+			inet_ntop (AF_INET6, addrbytes->data, buf, sizeof (buf));
+		else
+			buf[0] = '\0';
+		strings[i] = g_strdup (buf);
+	}
+
+	g_value_take_boxed (target_value, strings);
+	return TRUE;
+}
+
+static gboolean
+ip6_addresses_from_strv (GBinding     *binding,
+                         const GValue *source_value,
+                         GValue       *target_value,
+                         gpointer      user_data)
+{
+	char **strings;
+	GPtrArray *addrs;
+	GByteArray *addr;
+	struct in6_addr addrbytes;
+	int i;
+
+	strings = g_value_get_boxed (source_value);
+	addrs = g_ptr_array_new ();
+
+	for (i = 0; strings[i]; i++) {
+		if (!ip_string_parse (strings[i], AF_INET6, &addrbytes, NULL)) {
+			while (i--)
+				g_byte_array_unref (addrs->pdata[i]);
+			g_ptr_array_unref (addrs);
+			return FALSE;
+		}
+
+		addr = g_byte_array_sized_new (sizeof (addrbytes));
+		g_byte_array_append (addr, (guint8 *)&addrbytes, sizeof (addrbytes));
+		g_ptr_array_add (addrs, addr);
+	}
+
+	g_value_take_boxed (target_value, addrs);
+	return TRUE;
+}
+
+/**
+ * nm_editor_bind_ip6_addresses_to_strv:
+ * @source: the source object (eg, an #NMSettingIP6Config)
+ * @source_property: the property on @source to bind (eg,
+ *   %NM_SETTING_IP6_CONFIG_DNS)
+ * @target: the target object (eg, an #NmtAddressList)
+ * @target_property: the property on @target to bind
+ *   (eg, "strings")
+ * @flags: %GBindingFlags
+ *
+ * Binds the %DBUS_TYPE_G_ARRAY_OF_ARRAY_OF_UCHAR property
+ * @source_property on @source to the %G_TYPE_STRV property
+ * @target_property on @target.
+ *
+ * Each address in @source_property will be converted to a string of
+ * the form "ip::ad:dr:ess" in @target_property (and vice versa if
+ * %G_BINDING_BIDIRECTIONAL) is specified.
+ */
+void
+nm_editor_bind_ip6_addresses_to_strv (gpointer       source,
+                                      const gchar   *source_property,
+                                      gpointer       target,
+                                      const gchar   *target_property,
+                                      GBindingFlags  flags)
+{
+	g_object_bind_property_full (source, source_property,
+	                             target, target_property,
+	                             flags,
+	                             ip6_addresses_to_strv,
+	                             ip6_addresses_from_strv,
+	                             NULL, NULL);
+}
+
+static gboolean
+ip6_gateway_to_string (GBinding     *binding,
+                       const GValue *source_value,
+                       GValue       *target_value,
+                       gpointer      user_data)
+{
+	GPtrArray *addrs;
+	GValueArray *addr;
+	GValue *val;
+	GByteArray *gateway;
+	char buf[INET6_ADDRSTRLEN];
+	const char *str;
+
+	addrs = g_value_get_boxed (source_value);
+	if (addrs->len == 0)
+		return FALSE;
+
+	addr = addrs->pdata[0];
+	val = g_value_array_get_nth (addr, 2);
+	gateway = g_value_get_boxed (val);
+
+	if (IP6_ADDRESS_SET (gateway))
+		str = inet_ntop (AF_INET6, gateway->data, buf, sizeof (buf));
+	else
+		str = "";
+	g_value_set_string (target_value, str);
+	return TRUE;
+}
+
+static gboolean
+ip6_gateway_from_string (GBinding     *binding,
+                         const GValue *source_value,
+                         GValue       *target_value,
+                         gpointer      user_data)
+{
+	GPtrArray *addrs;
+	const char *text;
+	GValueArray *addr;
+	struct in6_addr gateway;
+	GValue *val;
+	GByteArray *ba;
+	int i;
+
+	text = g_value_get_string (source_value);
+	if (!ip_string_parse (text, AF_INET6, &gateway, NULL))
+		return FALSE;
+
+	/* Fetch the original property value, so as to preserve the IP address elements */
+	g_object_get (g_binding_get_source (binding),
+	              g_binding_get_source_property (binding), &addrs,
+	              NULL);
+	if (!addrs->len) {
+		g_ptr_array_unref (addrs);
+		return FALSE;
+	}
+
+	addr = addrs->pdata[0];
+
+	ba = g_byte_array_sized_new (sizeof (gateway));
+	g_byte_array_append (ba, (guint8 *) &gateway, sizeof (gateway));
+
+	val = g_value_array_get_nth (addr, 2);
+	g_value_take_boxed (val, ba);
+
+	for (i = 1; i < addrs->len; i++) {
+		addr = addrs->pdata[i];
+		val = g_value_array_get_nth (addr, 2);
+		ba = g_value_get_boxed (val);
+
+		if (ba)
+			memset (ba->data, 0, ba->len);
+	}
+
+	g_value_take_boxed (target_value, addrs);
+	return TRUE;
+}
+
+/**
+ * nm_editor_bind_ip6_gateway_to_string:
+ * @source: the source object (eg, an #NMSettingIP6Config)
+ * @source_property: the property on @source to bind (eg,
+ *   %NM_SETTING_IP6_CONFIG_ADDRESSES)
+ * @target: the target object (eg, an #NmtNewtEntry)
+ * @target_property: the property on @target to bind
+ *   (eg, "text")
+ * @flags: %GBindingFlags
+ *
+ * Binds the %DBUS_TYPE_G_ARRAY_OF_IP6_ADDRESS property
+ * @source_property on @source to the %G_TYPE_STRING property
+ * @target_property on @target.
+ *
+ * Specifically, this binds the "gateway" field of the first address
+ * in @source_property; all other addresses in @source_property are
+ * ignored, and its "address" and "prefix" fields are unmodified.
+ */
+void
+nm_editor_bind_ip6_gateway_to_string (gpointer       source,
+                                      const gchar   *source_property,
+                                      gpointer       target,
+                                      const gchar   *target_property,
+                                      GBindingFlags  flags)
+{
+	g_object_bind_property_full (source, source_property,
+	                             target, target_property,
+	                             flags,
+	                             ip6_gateway_to_string,
+	                             ip6_gateway_from_string,
+	                             NULL, NULL);
+}
+
+#define IN6_ADDR_SET(bytes) (memcmp (bytes, &in6addr_any, sizeof (struct in6_addr)) != 0)
+
+static gboolean
+ip6_route_transform_to_dest_string (GBinding     *binding,
+                                    const GValue *source_value,
+                                    GValue       *target_value,
+                                    gpointer      user_data)
+{
+	NMIP6Route *route;
+	char buf[INET6_ADDRSTRLEN], *string;
+	const struct in6_addr *addrbytes;
+
+	route = g_value_get_boxed (source_value);
+	if (route)
+		addrbytes = nm_ip6_route_get_dest (route);
+	else
+		addrbytes = &in6addr_any;
+
+	if (IN6_ADDR_SET (addrbytes)) {
+		string = g_strdup_printf ("%s/%d",
+		                          inet_ntop (AF_INET6, addrbytes, buf, sizeof (buf)),
+		                          (int) nm_ip6_route_get_prefix (route));
+		g_value_take_string (target_value, string);
+	} else
+		g_value_set_string (target_value, "");
+	return TRUE;
+}
+
+static gboolean
+ip6_route_transform_to_next_hop_string (GBinding     *binding,
+                                        const GValue *source_value,
+                                        GValue       *target_value,
+                                        gpointer      user_data)
+{
+	NMIP6Route *route;
+	char buf[INET6_ADDRSTRLEN];
+	const struct in6_addr *addrbytes;
+
+	route = g_value_get_boxed (source_value);
+	if (route)
+		addrbytes = nm_ip6_route_get_next_hop (route);
+	else
+		addrbytes = &in6addr_any;
+
+	if (IN6_ADDR_SET (addrbytes))
+		inet_ntop (AF_INET6, addrbytes, buf, sizeof (buf));
+	else
+		buf[0] = '\0';
+	g_value_set_string (target_value, buf);
+	return TRUE;
+}
+
+static gboolean
+ip6_route_transform_to_metric_string (GBinding     *binding,
+                                      const GValue *source_value,
+                                      GValue       *target_value,
+                                      gpointer      user_data)
+{
+	NMIP6Route *route;
+	char *string;
+
+	route = g_value_get_boxed (source_value);
+	if (route && IN6_ADDR_SET (nm_ip6_route_get_dest (route))) {
+		string = g_strdup_printf ("%lu", (gulong) nm_ip6_route_get_metric (route));
+		g_value_take_string (target_value, string);
+	} else
+		g_value_set_string (target_value, "");
+	return TRUE;
+}
+
+static gboolean
+ip6_route_transform_from_dest_string (GBinding     *binding,
+                                      const GValue *source_value,
+                                      GValue       *target_value,
+                                      gpointer      user_data)
+{
+	NMIP6Route *route;
+	const char *text;
+	struct in6_addr addrbytes;
+	guint32 prefix;
+
+	text = g_value_get_string (source_value);
+	if (!ip_string_parse (text, AF_INET6, &addrbytes, &prefix))
+		return FALSE;
+
+	/* Fetch the original property value */
+	g_object_get (g_binding_get_source (binding),
+	              g_binding_get_source_property (binding), &route,
+	              NULL);
+
+	nm_ip6_route_set_dest (route, &addrbytes);
+	nm_ip6_route_set_prefix (route, prefix);
+
+	g_value_take_boxed (target_value, route);
+	return TRUE;
+}
+
+static gboolean
+ip6_route_transform_from_next_hop_string (GBinding     *binding,
+                                          const GValue *source_value,
+                                          GValue       *target_value,
+                                          gpointer      user_data)
+{
+	NMIP6Route *route;
+	const char *text;
+	struct in6_addr addrbytes;
+
+	text = g_value_get_string (source_value);
+	if (*text) {
+		if (!ip_string_parse (text, AF_INET6, &addrbytes, NULL))
+			return FALSE;
+	} else
+		addrbytes = in6addr_any;
+
+	/* Fetch the original property value */
+	g_object_get (g_binding_get_source (binding),
+	              g_binding_get_source_property (binding), &route,
+	              NULL);
+
+	nm_ip6_route_set_next_hop (route, &addrbytes);
+
+	g_value_take_boxed (target_value, route);
+	return TRUE;
+}
+
+static gboolean
+ip6_route_transform_from_metric_string (GBinding     *binding,
+                                        const GValue *source_value,
+                                        GValue       *target_value,
+                                        gpointer      user_data)
+{
+	NMIP6Route *route;
+	const char *text;
+	guint32 metric;
+
+	text = g_value_get_string (source_value);
+	metric = strtoul (text, NULL, 10);
+
+	/* Fetch the original property value */
+	g_object_get (g_binding_get_source (binding),
+	              g_binding_get_source_property (binding), &route,
+	              NULL);
+
+	nm_ip6_route_set_metric (route, metric);
+
+	g_value_take_boxed (target_value, route);
+	return TRUE;
+}
+
+/**
+ * nm_editor_bind_ip6_route_to_strings:
+ * @source: the source object
+ * @source_property: the source property
+ * @dest_target: the target object for the route's destionation
+ * @dest_target_property: the property on @dest_target
+ * @next_hop_target: the target object for the route's next hop
+ * @next_hop_target_property: the property on @next_hop_target
+ * @metric_target: the target object for the route's metric
+ * @metric_target_property: the property on @metric_target
+ * @flags: %GBindingFlags
+ *
+ * Binds the #NMIP6Route-valued property @source_property on @source
+ * to the three indicated string-valued target properties (and vice
+ * versa if %G_BINDING_BIDIRECTIONAL is specified).
+ *
+ * @dest_target_property should be an "address/prefix" string, as with
+ * nm_editor_bind_ip6_addresses_with_prefix_to_strv(). @next_hop_target
+ * is a plain IP address, and @metric_target is a number.
+ */
+void
+nm_editor_bind_ip6_route_to_strings (gpointer       source,
+                                     const gchar   *source_property,
+                                     gpointer       dest_target,
+                                     const gchar   *dest_target_property,
+                                     gpointer       next_hop_target,
+                                     const gchar   *next_hop_target_property,
+                                     gpointer       metric_target,
+                                     const gchar   *metric_target_property,
+                                     GBindingFlags  flags)
+{
+	g_object_bind_property_full (source, source_property,
+	                             dest_target, dest_target_property,
+	                             flags,
+	                             ip6_route_transform_to_dest_string,
+	                             ip6_route_transform_from_dest_string,
+	                             NULL, NULL);
+	g_object_bind_property_full (source, source_property,
+	                             next_hop_target, next_hop_target_property,
+	                             flags,
+	                             ip6_route_transform_to_next_hop_string,
+	                             ip6_route_transform_from_next_hop_string,
+	                             NULL, NULL);
+	g_object_bind_property_full (source, source_property,
+	                             metric_target, metric_target_property,
+	                             flags,
+	                             ip6_route_transform_to_metric_string,
+	                             ip6_route_transform_from_metric_string,
+	                             NULL, NULL);
+}
+
+/* Wireless security method binding */
+typedef struct {
+	NMConnection *connection;
+	NMSettingWirelessSecurity *s_wsec;
+	gboolean s_wsec_in_use;
+
+	GObject *target;
+	char *target_property;
+
+	gboolean updating;
+} NMEditorWirelessSecurityMethodBinding;
+
+static const char *
+get_security_type (NMEditorWirelessSecurityMethodBinding *binding)
+{
+	const char *key_mgmt, *auth_alg;
+
+	if (!binding->s_wsec_in_use)
+		return "none";
+
+	key_mgmt = nm_setting_wireless_security_get_key_mgmt (binding->s_wsec);
+	auth_alg = nm_setting_wireless_security_get_auth_alg (binding->s_wsec);
+
+	/* No IEEE 802.1x */
+	if (!strcmp (key_mgmt, "none")) {
+		NMWepKeyType wep_type = nm_setting_wireless_security_get_wep_key_type (binding->s_wsec);
+
+		if (wep_type == NM_WEP_KEY_TYPE_KEY)
+			return "wep-key";
+		else
+			return "wep-passphrase";
+	}
+
+	if (!strcmp (key_mgmt, "ieee8021x")) {
+		if (auth_alg && !strcmp (auth_alg, "leap"))
+			return "leap";
+		return "dynamic-wep";
+	}
+
+	if (   !strcmp (key_mgmt, "wpa-none")
+	    || !strcmp (key_mgmt, "wpa-psk"))
+		return "wpa-personal";
+
+	if (!strcmp (key_mgmt, "wpa-eap"))
+		return "wpa-enterprise";
+
+	return NULL;
+}
+
+static void
+wireless_security_changed (GObject    *object,
+                           GParamSpec *pspec,
+                           gpointer    user_data)
+{
+	NMEditorWirelessSecurityMethodBinding *binding = user_data;
+
+	if (binding->updating)
+		return;
+
+	binding->updating = TRUE;
+	g_object_set (binding->target,
+	              binding->target_property, get_security_type (binding),
+	              NULL);
+	binding->updating = FALSE;
+}
+
+static void
+wireless_connection_changed (NMConnection *connection,
+                             gpointer      user_data)
+{
+	NMEditorWirelessSecurityMethodBinding *binding = user_data;
+	NMSettingWirelessSecurity *s_wsec;
+
+	if (binding->updating)
+		return;
+
+	s_wsec = nm_connection_get_setting_wireless_security (connection);
+	if (   (s_wsec && binding->s_wsec_in_use)
+	    || (!s_wsec && !binding->s_wsec_in_use))
+		return;
+
+	binding->s_wsec_in_use = !binding->s_wsec_in_use;
+	wireless_security_changed (NULL, NULL, binding);
+}
+
+static void
+wireless_security_target_changed (GObject    *object,
+                                  GParamSpec *pspec,
+                                  gpointer    user_data)
+{
+	NMEditorWirelessSecurityMethodBinding *binding = user_data;
+	char *method;
+
+	if (binding->updating)
+		return;
+
+	g_object_get (binding->target,
+	              binding->target_property, &method,
+	              NULL);
+
+	binding->updating = TRUE;
+
+	if (!strcmp (method, "none")) {
+		if (!binding->s_wsec_in_use)
+			return;
+		binding->s_wsec_in_use = FALSE;
+		nm_connection_remove_setting (binding->connection, NM_TYPE_SETTING_WIRELESS_SECURITY);
+
+		binding->updating = FALSE;
+		return;
+	}
+
+	if (!binding->s_wsec_in_use) {
+		binding->s_wsec_in_use = TRUE;
+		nm_connection_add_setting (binding->connection, NM_SETTING (binding->s_wsec));
+	}
+
+	if (!strcmp (method, "wep-key")) {
+		g_object_set (binding->s_wsec,
+		              NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "none",
+		              NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, "open",
+		              NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE, NM_WEP_KEY_TYPE_KEY,
+		              NULL);
+	} else if (!strcmp (method, "wep-passphrase")) {
+		g_object_set (binding->s_wsec,
+		              NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "none",
+		              NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, "open",
+		              NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE, NM_WEP_KEY_TYPE_PASSPHRASE,
+		              NULL);
+	} else if (!strcmp (method, "leap")) {
+		g_object_set (binding->s_wsec,
+		              NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "ieee8021x",
+		              NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, "leap",
+		              NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE, NM_WEP_KEY_TYPE_UNKNOWN,
+		              NULL);
+	} else if (!strcmp (method, "dynamic-wep")) {
+		g_object_set (binding->s_wsec,
+		              NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "ieee8021x",
+		              NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, "open",
+		              NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE, NM_WEP_KEY_TYPE_UNKNOWN,
+		              NULL);
+	} else if (!strcmp (method, "wpa-personal")) {
+		g_object_set (binding->s_wsec,
+		              NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "wpa-psk",
+		              NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, NULL,
+		              NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE, NM_WEP_KEY_TYPE_UNKNOWN,
+		              NULL);
+	} else if (!strcmp (method, "wpa-enterprise")) {
+		g_object_set (binding->s_wsec,
+		              NM_SETTING_WIRELESS_SECURITY_KEY_MGMT, "wpa-eap",
+		              NM_SETTING_WIRELESS_SECURITY_AUTH_ALG, NULL,
+		              NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE, NM_WEP_KEY_TYPE_UNKNOWN,
+		              NULL);
+	} else
+		g_warn_if_reached ();
+
+	binding->updating = FALSE;
+}
+
+static void
+wireless_security_target_destroyed (gpointer  user_data,
+                                    GObject  *ex_target)
+{
+	NMEditorWirelessSecurityMethodBinding *binding = user_data;
+
+	g_signal_handlers_disconnect_by_func (binding->s_wsec, G_CALLBACK (wireless_security_changed), binding);
+	g_object_unref (binding->s_wsec);
+	g_object_unref (binding->connection);
+
+	g_free (binding->target_property);
+
+	g_slice_free (NMEditorWirelessSecurityMethodBinding, binding);
+}
+
+/**
+ * nm_editor_bind_wireless_security_method:
+ * @connection: an #NMConnection
+ * @s_wsec: an #NMSettingWirelessSecurity
+ * @target: the target widget
+ * @target_property: the string-valued property on @target to bind
+ * @flags: %GBindingFlags
+ *
+ * Binds the wireless security method on @connection to
+ * @target_property on @target (and vice versa if
+ * %G_BINDING_BIDIRECTIONAL).
+ *
+ * @target_property will be of the values "none", "wpa-personal",
+ * "wpa-enterprise", "wep-key", "wep-passphrase", "dynamic-wep", or
+ * "leap".
+ *
+ * If binding bidirectionally, @s_wsec will be automatically added to
+ * or removed from @connection as needed when @target_property
+ * changes.
+ */
+void
+nm_editor_bind_wireless_security_method (NMConnection              *connection,
+                                         NMSettingWirelessSecurity *s_wsec,
+                                         gpointer                   target,
+                                         const char                *target_property,
+                                         GBindingFlags              flags)
+{
+	NMEditorWirelessSecurityMethodBinding *binding;
+	char *notify;
+
+	binding = g_slice_new0 (NMEditorWirelessSecurityMethodBinding);
+
+	binding->target = target;
+	binding->target_property = g_strdup (target_property);
+	if (flags & G_BINDING_BIDIRECTIONAL) {
+		notify = g_strdup_printf ("notify::%s", target_property);
+		g_signal_connect (target, notify, G_CALLBACK (wireless_security_target_changed), binding);
+		g_free (notify);
+	}
+	g_object_weak_ref (target, wireless_security_target_destroyed, binding);
+
+	binding->connection = g_object_ref (connection);
+	g_signal_connect (connection, NM_CONNECTION_CHANGED,
+	                  G_CALLBACK (wireless_connection_changed), binding);
+	binding->s_wsec_in_use = (nm_connection_get_setting_wireless_security (connection) != NULL);
+
+	binding->s_wsec = g_object_ref (s_wsec);
+	g_signal_connect (s_wsec, "notify::" NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,
+	                  G_CALLBACK (wireless_security_changed), binding);
+	g_signal_connect (s_wsec, "notify::" NM_SETTING_WIRELESS_SECURITY_AUTH_ALG,
+	                  G_CALLBACK (wireless_security_changed), binding);
+	g_signal_connect (s_wsec, "notify::" NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,
+	                  G_CALLBACK (wireless_security_changed), binding);
+
+	if (flags & G_BINDING_SYNC_CREATE)
+		wireless_security_changed (NULL, NULL, binding);
+}
+
+/* WEP key binding */
+
+typedef struct {
+	NMSettingWirelessSecurity *s_wsec;
+	GObject *entry, *key_selector;
+	char *entry_property, *key_selector_property;
+
+	gboolean updating;
+} NMEditorWepKeyBinding;
+
+static void
+wep_key_setting_changed (GObject    *object,
+                         GParamSpec *pspec,
+                         gpointer    user_data)
+{
+	NMEditorWepKeyBinding *binding = user_data;
+	const char *key;
+	int index;
+
+	if (binding->updating)
+		return;
+
+	index = nm_setting_wireless_security_get_wep_tx_keyidx (binding->s_wsec);
+	key = nm_setting_wireless_security_get_wep_key (binding->s_wsec, index);
+
+	binding->updating = TRUE;
+	g_object_set (binding->key_selector,
+	              binding->key_selector_property, index,
+	              NULL);
+	g_object_set (binding->entry,
+	              binding->entry_property, key,
+	              NULL);
+	binding->updating = FALSE;
+}
+
+static void
+wep_key_ui_changed (GObject    *object,
+                    GParamSpec *pspec,
+                    gpointer    user_data)
+{
+	NMEditorWepKeyBinding *binding = user_data;
+	char *key;
+	int index;
+
+	if (binding->updating)
+		return;
+
+	g_object_get (binding->key_selector,
+	              binding->key_selector_property, &index,
+	              NULL);
+	g_object_get (binding->entry,
+	              binding->entry_property, &key,
+	              NULL);
+
+	binding->updating = TRUE;
+	g_object_set (binding->s_wsec,
+	              NM_SETTING_WIRELESS_SECURITY_WEP_TX_KEYIDX, index,
+	              NM_SETTING_WIRELESS_SECURITY_WEP_KEY0, index == 0 ? key : NULL,
+	              NM_SETTING_WIRELESS_SECURITY_WEP_KEY1, index == 1 ? key : NULL,
+	              NM_SETTING_WIRELESS_SECURITY_WEP_KEY2, index == 2 ? key : NULL,
+	              NM_SETTING_WIRELESS_SECURITY_WEP_KEY3, index == 3 ? key : NULL,
+	              NULL);
+	binding->updating = FALSE;
+
+	g_free (key);
+}
+
+static void
+wep_key_target_destroyed (gpointer  user_data,
+                          GObject  *ex_target)
+{
+	NMEditorWepKeyBinding *binding = user_data;
+
+	g_signal_handlers_disconnect_by_func (binding->s_wsec, G_CALLBACK (wep_key_setting_changed), binding);
+
+	if (ex_target != binding->entry) {
+		g_signal_handlers_disconnect_by_func (binding->entry, G_CALLBACK (wep_key_ui_changed), binding);
+		g_object_weak_unref (binding->entry, wep_key_target_destroyed, binding);
+	} else {
+		g_signal_handlers_disconnect_by_func (binding->key_selector, G_CALLBACK (wep_key_ui_changed), binding);
+		g_object_weak_unref (binding->key_selector, wep_key_target_destroyed, binding);
+	}
+
+	g_object_unref (binding->s_wsec);
+	g_free (binding->entry_property);
+	g_free (binding->key_selector_property);
+
+	g_slice_free (NMEditorWepKeyBinding, binding);
+}
+
+/**
+ * nm_editor_bind_wireless_security_wep_key:
+ * @s_wsec: an #NMSettingWirelessSecurity
+ * @entry: an entry widget
+ * @entry_property: the string-valued property on @entry to bind
+ * @key_selector: a pop-up widget of some sort
+ * @key_selector_property: the integer-valued property on
+ *   @key_selector to bind
+ * @flags: %GBindingFlags
+ *
+ * Binds the "wep-tx-keyidx" property on @s_wsec to
+ * @key_selector_property on @key_selector, and the corresponding
+ * "wep-keyN" property to @entry_property on @entry (and vice versa if
+ * %G_BINDING_BIDIRECTIONAL).
+ */
+void
+nm_editor_bind_wireless_security_wep_key (NMSettingWirelessSecurity *s_wsec,
+                                          gpointer       entry,
+                                          const char    *entry_property,
+                                          gpointer       key_selector,
+                                          const char    *key_selector_property,
+                                          GBindingFlags  flags)
+{
+	NMEditorWepKeyBinding *binding;
+	char *notify;
+
+	binding = g_slice_new0 (NMEditorWepKeyBinding);
+	binding->s_wsec = g_object_ref (s_wsec);
+	binding->entry = entry;
+	binding->entry_property = g_strdup (entry_property);
+	binding->key_selector = key_selector;
+	binding->key_selector_property = g_strdup (key_selector_property);
+
+	g_signal_connect (s_wsec, "notify::" NM_SETTING_WIRELESS_SECURITY_WEP_KEY0,
+	                  G_CALLBACK (wep_key_setting_changed), binding);
+	g_signal_connect (s_wsec, "notify::" NM_SETTING_WIRELESS_SECURITY_WEP_KEY1,
+	                  G_CALLBACK (wep_key_setting_changed), binding);
+	g_signal_connect (s_wsec, "notify::" NM_SETTING_WIRELESS_SECURITY_WEP_KEY2,
+	                  G_CALLBACK (wep_key_setting_changed), binding);
+	g_signal_connect (s_wsec, "notify::" NM_SETTING_WIRELESS_SECURITY_WEP_KEY3,
+	                  G_CALLBACK (wep_key_setting_changed), binding);
+
+	g_signal_connect (s_wsec, "notify::" NM_SETTING_WIRELESS_SECURITY_WEP_TX_KEYIDX,
+	                  G_CALLBACK (wep_key_setting_changed), binding);
+
+	if (flags & G_BINDING_BIDIRECTIONAL) {
+		notify = g_strdup_printf ("notify::%s", entry_property);
+		g_signal_connect (entry, notify, G_CALLBACK (wep_key_ui_changed), binding);
+		g_free (notify);
+
+		notify = g_strdup_printf ("notify::%s", key_selector_property);
+		g_signal_connect (key_selector, notify, G_CALLBACK (wep_key_ui_changed), binding);
+		g_free (notify);
+	}
+
+	g_object_weak_ref (entry, wep_key_target_destroyed, binding);
+	g_object_weak_ref (key_selector, wep_key_target_destroyed, binding);
+
+	if (flags & G_BINDING_SYNC_CREATE)
+		wep_key_setting_changed (NULL, NULL, binding);
+}
+
+/* VLAN binding */
+
+typedef struct {
+	NMSettingVlan *s_vlan;
+
+	char *last_ifname_parent;
+	int last_ifname_id;
+
+	gboolean updating;
+} NMEditorVlanWidgetBinding;
+
+static gboolean
+parse_interface_name (const char  *ifname,
+                      char       **parent_ifname,
+                      int         *id)
+{
+	const char *ifname_end;
+	char *end;
+
+	if (!ifname || !*ifname)
+		return FALSE;
+
+	if (g_str_has_prefix (ifname, "vlan")) {
+		ifname_end = ifname + 4;
+		*id = strtoul (ifname_end, &end, 10);
+		if (*end || end == (char *)ifname_end || *id < 0)
+			return FALSE;
+		*parent_ifname = NULL;
+		return TRUE;
+	}
+
+	ifname_end = strchr (ifname, '.');
+	if (ifname_end) {
+		*id = strtoul (ifname_end + 1, &end, 10);
+		if (*end || end == (char *)ifname_end + 1 || *id < 0)
+			return FALSE;
+		*parent_ifname = g_strndup (ifname, ifname_end - ifname);
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+static void
+vlan_settings_changed (GObject    *object,
+                       GParamSpec *pspec,
+                       gpointer    user_data)
+{
+	NMEditorVlanWidgetBinding *binding = user_data;
+	const char *ifname, *parent;
+	char *ifname_parent;
+	int ifname_id, id;
+
+	if (binding->updating)
+		return;
+
+	ifname = nm_setting_vlan_get_interface_name (binding->s_vlan);
+	parent = nm_setting_vlan_get_parent (binding->s_vlan);
+	id = nm_setting_vlan_get_id (binding->s_vlan);
+
+	if (!parse_interface_name (ifname, &ifname_parent, &ifname_id))
+		return;
+
+	/* If the id in INTERFACE_NAME changed, and ID is either unset, or was previously
+	 * in sync with INTERFACE_NAME, then update ID.
+	 */
+	if (   id != ifname_id
+	    && (id == binding->last_ifname_id || id == 0)) {
+		binding->updating = TRUE;
+		g_object_set (G_OBJECT (binding->s_vlan),
+		              NM_SETTING_VLAN_ID, ifname_id,
+		              NULL);
+		binding->updating = FALSE;
+	}
+
+	/* If the PARENT in INTERFACE_NAME changed, and PARENT is either unset, or was
+	 * previously in sync with INTERFACE_NAME, then update PARENT.
+	 */
+	if (   g_strcmp0 (parent, ifname_parent) != 0
+	    && (   g_strcmp0 (parent, binding->last_ifname_parent) == 0
+	        || !parent || !*parent)) {
+		binding->updating = TRUE;
+		g_object_set (G_OBJECT (binding->s_vlan),
+		              NM_SETTING_VLAN_PARENT, ifname_parent,
+		              NULL);
+		binding->updating = FALSE;
+	}
+
+	g_free (binding->last_ifname_parent);
+	binding->last_ifname_parent = ifname_parent;
+	binding->last_ifname_id = ifname_id;
+}
+
+static void
+vlan_target_destroyed (gpointer  user_data,
+                       GObject  *ex_target)
+{
+	NMEditorVlanWidgetBinding *binding = user_data;
+
+	g_free (binding->last_ifname_parent);
+	g_slice_free (NMEditorVlanWidgetBinding, binding);
+}
+
+/**
+ * nm_editor_bind_vlan_name:
+ * @s_vlan: an #NMSettingVlan
+ *
+ * Binds together several properties on @s_vlan, so that if the
+ * %NM_SETTING_VLAN_INTERFACE_NAME matches %NM_SETTING_VLAN_PARENT
+ * and %NM_SETTING_VLAN_ID in the obvious way, then changes to
+ * %NM_SETTING_VLAN_INTERFACE_NAME will propagate to the other
+ * two properties automatically.
+ */
+void
+nm_editor_bind_vlan_name (NMSettingVlan *s_vlan)
+{
+	NMEditorVlanWidgetBinding *binding;
+	const char *ifname;
+
+	binding = g_slice_new0 (NMEditorVlanWidgetBinding);
+	binding->s_vlan = s_vlan;
+
+	g_signal_connect (s_vlan, "notify::" NM_SETTING_VLAN_INTERFACE_NAME,
+	                  G_CALLBACK (vlan_settings_changed), binding);
+
+	g_object_weak_ref (G_OBJECT (s_vlan), vlan_target_destroyed, binding);
+
+	ifname = nm_setting_vlan_get_interface_name (s_vlan);
+	if (!parse_interface_name (ifname, &binding->last_ifname_parent, &binding->last_ifname_id)) {
+		binding->last_ifname_parent = NULL;
+		binding->last_ifname_id = 0;
+	}
+}