Merge lp:~kvalo/indicator-network/bug-686356 into lp:~indicator-applet-developers/indicator-network/indicator-network

[Kalle Valo]

[Mikkel Kamstrup Erlandsen (kamstrup)]

Really really tight work Kalle.

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2011-03-09 13:29:43 +0000
+++ .bzrignore	2011-03-18 12:46:25 +0000
@@ -121,3 +121,4 @@
 src/indicator/toggleswitch.c
 src/indicator/toggleswitch.h
 src/indicator/toggleswitch.stamp
+src/libconnman/libconnman_la-connman-ipv6.lo
 
=== modified file 'src/libconnman/Connman-1.0.vapi'
--- src/libconnman/Connman-1.0.vapi	2011-02-22 13:57:51 +0000
+++ src/libconnman/Connman-1.0.vapi	2011-03-18 12:46:25 +0000
@@ -20,6 +20,22 @@
 		public uint method { get; construct; }
 		public string netmask { get; construct; }
 	}
+       [CCode (cheader_filename = "connman-ipv6.h")]
+       public class IPv6 : GLib.Object {
+               [CCode (has_construct_function = false)]
+               public IPv6 (Connman.IPv6Method method, string address, uint8 prefix_length, string gateway) throws GLib.Error;
+               public unowned string get_address ();
+               public unowned string get_gateway ();
+               public Connman.IPv6Method get_method ();
+               public unowned string get_method_as_string ();
+               public uint8 get_prefix_length ();
+               [CCode (has_construct_function = false)]
+               public IPv6.with_strings (string method, string address, uint8 prefix_length, string gateway) throws GLib.Error;
+               public string address { get; construct; }
+               public string gateway { get; construct; }
+               public uint method { get; construct; }
+               public uint8 prefix_length { get; construct; }
+       }
 	[CCode (cheader_filename = "connman-manager.h")]
 	public class Manager : GLib.Object {
 		public weak GLib.Object parent;
@@ -63,6 +79,8 @@
 		public bool get_immutable ();
 		public unowned Connman.IPv4 get_ipv4 ();
 		public unowned Connman.IPv4 get_ipv4_configuration ();
+        public unowned Connman.IPv6 get_ipv6 ();
+        public unowned Connman.IPv6 get_ipv6_configuration ();
 		public bool get_login_required ();
 		public unowned string get_mcc ();
 		public unowned string get_mnc ();
@@ -87,6 +105,7 @@
 		public void set_autoconnect (bool autoconnect);
 		public void set_domains_configuration ([CCode (array_length = false, array_null_terminated = true)] string[] domains);
 		public void set_ipv4_configuration (Connman.IPv4 ipv4);
+        public void set_ipv6_configuration (Connman.IPv6 ipv6);
 		public void set_nameservers_configuration ([CCode (array_length = false, array_null_terminated = true)] string[] nameservers);
 		public void set_passphrase (string passphrase);
 		public static unowned string state2str (Connman.ServiceState state);
@@ -104,6 +123,8 @@
 		public bool immutable { get; }
 		public Connman.IPv4 ipv4 { get; }
 		public Connman.IPv4 ipv4_configuration { get; set; }
+        public Connman.IPv6 ipv6 { get; }
+        public Connman.IPv6 ipv6_configuration { get; set; }
 		public bool login_required { get; }
 		public string mcc { get; }
 		public string mnc { get; }
@@ -132,6 +153,18 @@
 		FIXED,
 		DHCP
 	}
+       [CCode (cprefix = "CONNMAN_IPV6_ERROR_INVALID_", cheader_filename = "connman-ipv6.h")]
+       public enum IPv6Error {
+               METHOD,
+               SETTINGS
+       }
+       [CCode (cprefix = "CONNMAN_IPV6_METHOD_", cheader_filename = "connman-ipv6.h")]
+       public enum IPv6Method {
+               OFF,
+               MANUAL,
+               FIXED,
+               AUTO
+       }
 	[CCode (cprefix = "CONNMAN_SERVICE_MODE_", cheader_filename = "connman-service.h")]
 	public enum ServiceMode {
 		MANAGED,
 
=== modified file 'src/libconnman/Makefile.am'
--- src/libconnman/Makefile.am	2011-02-02 13:50:19 +0000
+++ src/libconnman/Makefile.am	2011-03-18 12:46:25 +0000
@@ -7,7 +7,9 @@
 	connman-service.c \
 	connman-service.h \
 	connman-ipv4.c \
-	connman-ipv4.h
+	connman-ipv4.h \
+	connman-ipv6.c \
+	connman-ipv6.h
 
 libconnman_la_LIBADD = \
 	$(GLIB_LIBS) \
 
=== added file 'src/libconnman/connman-ipv6.c'
--- src/libconnman/connman-ipv6.c	1970-01-01 00:00:00 +0000
+++ src/libconnman/connman-ipv6.c	2011-03-18 12:46:25 +0000
@@ -0,0 +1,315 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2011 Canonical Ltd.
+ *
+ * Authors:
+ * Kalle Valo <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#include "connman-ipv6.h"
+
+#include <string.h>
+
+G_DEFINE_TYPE(ConnmanIPv6, connman_ipv6, G_TYPE_OBJECT)
+
+#define GET_PRIVATE(o) \
+  (G_TYPE_INSTANCE_GET_PRIVATE((o), CONNMAN_TYPE_IPV6, \
+			       ConnmanIPv6Private))
+
+typedef struct _ConnmanIPv6Private ConnmanIPv6Private;
+
+struct _ConnmanIPv6Private {
+  ConnmanIPv6Method method;
+  gchar *address;
+  guchar prefix_length;
+  gchar *gateway;
+};
+
+enum
+{
+  /* reserved */
+  PROP_0,
+
+  PROP_METHOD,
+  PROP_ADDRESS,
+  PROP_PREFIX_LENGTH,
+  PROP_GATEWAY,
+};
+
+struct ipv6_method_entry
+{
+  const gchar *str;
+  ConnmanIPv6Method method;
+};
+
+static const struct ipv6_method_entry method_map[] = {
+  { "off",		CONNMAN_IPV6_METHOD_OFF },
+  { "manual",		CONNMAN_IPV6_METHOD_MANUAL },
+  { "fixed",		CONNMAN_IPV6_METHOD_FIXED },
+  { "auto",		CONNMAN_IPV6_METHOD_AUTO },
+};
+
+static ConnmanIPv6Method str2method(const gchar *state)
+{
+  const struct ipv6_method_entry *s;
+  guint i;
+
+  for (i = 0; i < G_N_ELEMENTS(method_map); i++) {
+    s = &method_map[i];
+    if (g_strcmp0(s->str, state) == 0)
+      return s->method;
+  }
+
+  g_warning("unknown ipv6 method: %s", state);
+
+  return CONNMAN_IPV6_METHOD_AUTO;
+}
+
+static const gchar *method2str(ConnmanIPv6Method method)
+{
+  const struct ipv6_method_entry *s;
+  guint i;
+
+  for (i = 0; i < G_N_ELEMENTS(method_map); i++) {
+    s = &method_map[i];
+    if (s->method == method)
+      return s->str;
+  }
+
+  g_warning("%s(): unknown ipv6 method %d", __func__, method);
+
+  return "auto";
+}
+
+ConnmanIPv6Method connman_ipv6_get_method(ConnmanIPv6 *self)
+{
+  ConnmanIPv6Private *priv = GET_PRIVATE(self);
+
+  g_return_val_if_fail(CONNMAN_IS_IPV6(self), CONNMAN_IPV6_METHOD_OFF);
+  g_return_val_if_fail(priv != NULL, CONNMAN_IPV6_METHOD_OFF);
+
+  return priv->method;
+}
+
+const gchar *connman_ipv6_get_method_as_string(ConnmanIPv6 *self)
+{
+  ConnmanIPv6Private *priv = GET_PRIVATE(self);
+
+  g_return_val_if_fail(CONNMAN_IS_IPV6(self), CONNMAN_IPV6_METHOD_OFF);
+  g_return_val_if_fail(priv != NULL, CONNMAN_IPV6_METHOD_OFF);
+
+  return method2str(priv->method);
+}
+
+
+const gchar *connman_ipv6_get_address(ConnmanIPv6 *self)
+{
+  ConnmanIPv6Private *priv = GET_PRIVATE(self);
+
+  g_return_val_if_fail(CONNMAN_IS_IPV6(self), NULL);
+  g_return_val_if_fail(priv != NULL, NULL);
+
+  return priv->address;
+}
+
+guchar connman_ipv6_get_prefix_length(ConnmanIPv6 *self)
+{
+  ConnmanIPv6Private *priv = GET_PRIVATE(self);
+
+  g_return_val_if_fail(CONNMAN_IS_IPV6(self), 0);
+  g_return_val_if_fail(priv != NULL, 0);
+
+  return priv->prefix_length;
+}
+
+const gchar *connman_ipv6_get_gateway(ConnmanIPv6 *self)
+{
+  ConnmanIPv6Private *priv = GET_PRIVATE(self);
+
+  g_return_val_if_fail(CONNMAN_IS_IPV6(self), NULL);
+  g_return_val_if_fail(priv != NULL, NULL);
+
+  return priv->gateway;
+}
+
+static void connman_ipv6_set_property(GObject *object, guint property_id,
+				      const GValue *value, GParamSpec *pspec)
+{
+  ConnmanIPv6 *self = CONNMAN_IPV6(object);
+  ConnmanIPv6Private *priv = GET_PRIVATE(self);
+
+  g_return_if_fail(priv != NULL);
+
+  switch(property_id) {
+  case PROP_METHOD:
+    priv->method = g_value_get_uint(value);
+    break;
+  case PROP_ADDRESS:
+    g_free(priv->address);
+    priv->address = g_value_dup_string(value);
+    break;
+  case PROP_PREFIX_LENGTH:
+    priv->prefix_length = g_value_get_uchar(value);
+    break;
+  case PROP_GATEWAY:
+    g_free(priv->gateway);
+    priv->gateway = g_value_dup_string(value);
+    break;
+  default:
+    /* We don't have any other property... */
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+    break;
+  }
+}
+
+static void connman_ipv6_get_property(GObject *object, guint property_id,
+				       GValue *value, GParamSpec *pspec)
+{
+  ConnmanIPv6 *self = CONNMAN_IPV6(object);
+  ConnmanIPv6Private *priv = GET_PRIVATE(self);
+
+  g_return_if_fail(priv != NULL);
+
+  switch(property_id) {
+  case PROP_METHOD:
+    g_value_set_uint(value, priv->method);
+    break;
+  case PROP_ADDRESS:
+    g_value_set_string(value, priv->address);
+    break;
+  case PROP_PREFIX_LENGTH:
+    g_value_set_uchar(value, priv->prefix_length);
+    break;
+  case PROP_GATEWAY:
+    g_value_set_string(value, priv->gateway);
+    break;
+  default:
+    /* We don't have any other property... */
+    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+    break;
+  }
+}
+
+static void connman_ipv6_dispose(GObject *object)
+{
+  G_OBJECT_CLASS(connman_ipv6_parent_class)->dispose(object);
+}
+
+static void connman_ipv6_finalize(GObject *object)
+{
+  ConnmanIPv6 *self = CONNMAN_IPV6(object);
+  ConnmanIPv6Private *priv = GET_PRIVATE(self);
+
+  g_free(priv->address);
+  g_free(priv->gateway);
+
+  G_OBJECT_CLASS(connman_ipv6_parent_class)->finalize(object);
+}
+
+static void connman_ipv6_class_init(ConnmanIPv6Class *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
+  GParamSpec *pspec;
+
+  g_type_class_add_private(klass, sizeof(ConnmanIPv6Private));
+
+  gobject_class->dispose = connman_ipv6_dispose;
+  gobject_class->finalize = connman_ipv6_finalize;
+  gobject_class->set_property = connman_ipv6_set_property;
+  gobject_class->get_property = connman_ipv6_get_property;
+
+  pspec = g_param_spec_uint("method",
+			    "ConnmanIPv6's method property",
+			    "The ipv6 method",
+			    0, G_MAXUINT,
+			    CONNMAN_IPV6_METHOD_OFF,
+			    G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+  g_object_class_install_property(gobject_class, PROP_METHOD, pspec);
+
+  pspec = g_param_spec_string("address",
+			      "ConnmanIPv6's address",
+			      "IPv6 address",
+			      NULL,
+			      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+  g_object_class_install_property(gobject_class, PROP_ADDRESS, pspec);
+
+  pspec = g_param_spec_uchar("prefix-length",
+			     "ConnmanIPv6's prefix length",
+			     "IPv6 prefix length",
+			     0,
+			     128,
+			     0,
+			     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+  g_object_class_install_property(gobject_class, PROP_PREFIX_LENGTH, pspec);
+
+  pspec = g_param_spec_string("gateway",
+			      "ConnmanIPv6's gateway",
+			      "IPv6 gateway",
+			      NULL,
+			      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
+  g_object_class_install_property(gobject_class, PROP_GATEWAY, pspec);
+}
+
+static void connman_ipv6_init(ConnmanIPv6 *self)
+{
+}
+
+ConnmanIPv6 *connman_ipv6_new(ConnmanIPv6Method method,
+			      const gchar *address,
+			      guchar prefix_length,
+			      const gchar *gateway,
+			      GError **error)
+{
+  g_return_val_if_fail(error == NULL || *error == NULL, NULL);
+
+  return g_object_new(CONNMAN_TYPE_IPV6,
+		      "method", method,
+		      "address", address,
+		      "prefix-length", prefix_length,
+		      "gateway", gateway,
+		      NULL);
+}
+
+ConnmanIPv6 *connman_ipv6_new_with_strings(const gchar *method,
+					   const gchar *address,
+					   guchar prefix_length,
+					   const gchar *gateway,
+					   GError **error)
+{
+  const struct ipv6_method_entry *s;
+  gboolean valid = FALSE;
+  guint i;
+
+  g_return_val_if_fail(error == NULL || *error == NULL, NULL);
+
+  /* check that method is valid and if not, throw an error */
+  for (i = 0; i < G_N_ELEMENTS(method_map); i++) {
+    s = &method_map[i];
+    if (g_strcmp0(s->str, method) == 0) {
+      valid = TRUE;
+      break;
+    }
+  }
+
+  if (valid == FALSE) {
+      g_set_error(error, CONNMAN_IPV6_ERROR,
+		  CONNMAN_IPV6_ERROR_INVALID_METHOD,
+		  "Invalid ipv6 method: %s", method);
+      return NULL;
+  }
+
+  return connman_ipv6_new(str2method(method), address, prefix_length, gateway,
+			  error);
+}
 
=== added file 'src/libconnman/connman-ipv6.h'
--- src/libconnman/connman-ipv6.h	1970-01-01 00:00:00 +0000
+++ src/libconnman/connman-ipv6.h	2011-03-18 12:46:25 +0000
@@ -0,0 +1,93 @@
+/*
+ * indicator-network - user interface for connman
+ * Copyright 2011 Canonical Ltd.
+ *
+ * Authors:
+ * Kalle Valo <[e-mail]>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3, as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranties of
+ * MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+ */
+
+#ifndef _CONNMAN_IPV6_H_
+#define _CONNMAN_IPV6_H_
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define CONNMAN_TYPE_IPV6 connman_ipv6_get_type()
+
+#define CONNMAN_IPV6(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj), CONNMAN_TYPE_IPV6, \
+			      ConnmanIPv6))
+
+#define CONNMAN_IPV6_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass), CONNMAN_TYPE_IPV6, \
+			   ConnmanIPv6Class))
+
+#define CONNMAN_IS_IPV6(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj), CONNMAN_TYPE_IPV6))
+
+#define CONNMAN_IS_IPV6_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass), CONNMAN_TYPE_IPV6))
+
+#define CONNMAN_IPV6_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS((obj), CONNMAN_TYPE_IPV6, \
+			     ConnmanIPv6Class))
+
+typedef struct {
+  GObject parent;
+} ConnmanIPv6;
+
+typedef struct {
+  GObjectClass parent_class;
+} ConnmanIPv6Class;
+
+#define CONNMAN_IPV6_ERROR connman_ipv6_error_quark()
+
+static inline GQuark connman_ipv6_error_quark(void)
+{
+  return g_quark_from_static_string ("connman-ipv6-error-quark");
+}
+
+typedef enum {
+  CONNMAN_IPV6_ERROR_INVALID_METHOD,
+  CONNMAN_IPV6_ERROR_INVALID_SETTINGS,
+} ConnmanIPv6Error;
+
+typedef enum {
+  CONNMAN_IPV6_METHOD_OFF,
+  CONNMAN_IPV6_METHOD_MANUAL,
+  CONNMAN_IPV6_METHOD_FIXED,
+  CONNMAN_IPV6_METHOD_AUTO,
+} ConnmanIPv6Method;
+
+GType connman_ipv6_get_type(void);
+
+ConnmanIPv6Method connman_ipv6_get_method(ConnmanIPv6 *self);
+const gchar *connman_ipv6_get_method_as_string(ConnmanIPv6 *self);
+const gchar *connman_ipv6_get_address(ConnmanIPv6 *self);
+guchar connman_ipv6_get_prefix_length(ConnmanIPv6 *self);
+const gchar *connman_ipv6_get_gateway(ConnmanIPv6 *self);
+ConnmanIPv6 *connman_ipv6_new(ConnmanIPv6Method method,
+			      const gchar *address,
+			      guchar prefix_length,
+			      const gchar *gateway,
+			      GError **error);
+ConnmanIPv6 *connman_ipv6_new_with_strings(const gchar *method,
+					   const gchar *address,
+					   guchar prefix_length,
+					   const gchar *gateway,
+					   GError **error);
+
+#endif
 
=== modified file 'src/libconnman/connman-service.c'
--- src/libconnman/connman-service.c	2011-02-21 16:24:29 +0000
+++ src/libconnman/connman-service.c	2011-03-18 12:46:25 +0000
@@ -65,6 +65,8 @@
   gchar **domains_configuration;
   ConnmanIPv4 *ipv4;
   ConnmanIPv4 *ipv4_configuration;
+  ConnmanIPv6 *ipv6;
+  ConnmanIPv6 *ipv6_configuration;
 };
 
 enum
@@ -99,8 +101,8 @@
   PROP_DOMAINS_CONFIGURATION, /* rw */
   PROP_IPV4,
   PROP_IPV4_CONFIGURATION, /* rw */
-  /* PROP_IPV6, */
-  /* PROP_IPV6_CONFIGURATION, /\* rw *\/ */
+  PROP_IPV6,
+  PROP_IPV6_CONFIGURATION, /* rw */
   /* PROP_PROXY, */
   /* PROP_PROXY_CONFIGURATION, /\* rw *\/ */
   /* PROP_PROVIDER, */
@@ -647,6 +649,53 @@
   g_object_set(self, "ipv4-configuration", ipv4, NULL);
 }
 
+/**
+ * connman_service_get_ipv6:
+ *
+ * @self: self
+ *
+ * Returns: (transfer none): Current ipv6 settings. The caller must
+ * take a reference.
+ */
+ConnmanIPv6 *connman_service_get_ipv6(ConnmanService *self)
+{
+  ConnmanServicePrivate *priv = GET_PRIVATE(self);
+
+  g_return_val_if_fail(CONNMAN_IS_SERVICE(self), NULL);
+  g_return_val_if_fail(priv != NULL, NULL);
+
+  return priv->ipv6;
+}
+
+/**
+ * connman_service_get_ipv6_configuration:
+ *
+ * @self: self
+ *
+ * Returns: (transfer none): Current configured ipv6 settings. The caller must
+ * take a reference.
+ */
+ConnmanIPv6 *connman_service_get_ipv6_configuration(ConnmanService *self)
+{
+  ConnmanServicePrivate *priv = GET_PRIVATE(self);
+
+  g_return_val_if_fail(CONNMAN_IS_SERVICE(self), NULL);
+  g_return_val_if_fail(priv != NULL, NULL);
+
+  return priv->ipv6_configuration;
+}
+
+void connman_service_set_ipv6_configuration(ConnmanService *self,
+					    ConnmanIPv6 *ipv6)
+{
+  ConnmanServicePrivate *priv = GET_PRIVATE(self);
+
+  g_return_if_fail(CONNMAN_IS_SERVICE(self));
+  g_return_if_fail(priv != NULL);
+
+  g_object_set(self, "ipv6-configuration", ipv6, NULL);
+}
+
 const gchar *connman_service_get_path(ConnmanService *self)
 {
   ConnmanServicePrivate *priv = GET_PRIVATE(self);
@@ -1109,6 +1158,11 @@
 
  out:
   g_object_notify(G_OBJECT(self), "ipv4");
+
+  g_free(method);
+  g_free(address);
+  g_free(netmask);
+  g_free(gateway);
 }
 
 static void ipv4_configuration_updated(ConnmanService *self, GVariant *variant)
@@ -1120,9 +1174,9 @@
   GVariantIter iter;
   GVariant *value;
 
-  if (priv->ipv4 != NULL) {
-    g_object_unref(priv->ipv4);
-    priv->ipv4 = NULL;
+  if (priv->ipv4_configuration != NULL) {
+    g_object_unref(priv->ipv4_configuration);
+    priv->ipv4_configuration = NULL;
   }
 
   g_variant_iter_init(&iter, variant);
@@ -1162,6 +1216,121 @@
 
  out:
   g_object_notify(G_OBJECT(self), "ipv4-configuration");
+
+  g_free(method);
+  g_free(address);
+  g_free(netmask);
+  g_free(gateway);
+}
+
+static void ipv6_updated(ConnmanService *self, GVariant *variant)
+{
+  ConnmanServicePrivate *priv = GET_PRIVATE(self);
+  gchar *method = NULL, *address = NULL, *gateway = NULL, *key;
+  guchar prefix_len = 0;
+  GError *error = NULL;
+  GVariantIter iter;
+  GVariant *value;
+
+  if (priv->ipv6 != NULL) {
+    g_object_unref(priv->ipv6);
+    priv->ipv6 = NULL;
+  }
+
+  g_variant_iter_init(&iter, variant);
+
+  while (g_variant_iter_next(&iter, "{sv}", &key, &value)) {
+    if (g_strcmp0(key, "Method") == 0)
+      method = g_variant_dup_string(value, NULL);
+    else if (g_strcmp0(key, "Address") == 0)
+      address = g_variant_dup_string(value, NULL);
+    else if (g_strcmp0(key, "PrefixLength") == 0)
+      prefix_len = g_variant_get_byte(value);
+    else if (g_strcmp0(key, "Gateway") == 0)
+      gateway = g_variant_dup_string(value, NULL);
+    else
+      g_warning("Unknown ipv6 property: %s", key);
+
+    g_free(key);
+    g_variant_unref(value);
+  }
+
+  if (method == NULL && address == NULL &&
+      prefix_len == 0 && gateway == NULL)
+    /* some cases, like with bluetooth, ipv6 dict is just empty */
+    goto out;
+
+  priv->ipv6 = connman_ipv6_new_with_strings(method, address, prefix_len,
+					     gateway, &error);
+  if (error != NULL) {
+    g_warning("Received invalid ipv6 settings: %s", error->message);
+    g_error_free(error);
+    return;
+  }
+
+ out:
+  g_object_notify(G_OBJECT(self), "ipv6");
+
+  g_free(method);
+  g_free(address);
+  g_free(gateway);
+}
+
+static void ipv6_configuration_updated(ConnmanService *self, GVariant *variant)
+{
+  ConnmanServicePrivate *priv = GET_PRIVATE(self);
+  gchar *method = NULL, *address = NULL, *gateway = NULL, *key;
+  guchar prefix_len = 0;
+  GError *error = NULL;
+  GVariantIter iter;
+  GVariant *value;
+
+  if (priv->ipv6_configuration != NULL) {
+    g_object_unref(priv->ipv6_configuration);
+    priv->ipv6_configuration = NULL;
+  }
+
+  g_variant_iter_init(&iter, variant);
+
+  while (g_variant_iter_next(&iter, "{sv}", &key, &value)) {
+    if (g_strcmp0(key, "Method") == 0)
+      method = g_variant_dup_string(value, NULL);
+    else if (g_strcmp0(key, "Address") == 0)
+      address = g_variant_dup_string(value, NULL);
+    else if (g_strcmp0(key, "PrefixLength") == 0)
+      prefix_len = g_variant_get_byte(value);
+    else if (g_strcmp0(key, "Gateway") ==  0)
+      gateway = g_variant_dup_string(value, NULL);
+    else
+      g_warning("Unknown ipv6 property: %s", key);
+
+    g_free(key);
+    g_variant_unref(value);
+  }
+
+  if (method == NULL && address == NULL &&
+      prefix_len == 0 && gateway == NULL)
+    /* some cases, like with bluetooth, ipv6 dict is just empty */
+    goto out;
+
+  priv->ipv6_configuration = connman_ipv6_new_with_strings(method,
+							   address,
+							   prefix_len,
+							   gateway,
+							   &error);
+  if (error != NULL) {
+    g_warning("Received invalid ipv6 configuration settings: %s",
+	      error->message);
+    g_error_free(error);
+    return;
+  }
+
+ out:
+  g_object_notify(G_OBJECT(self), "ipv6-configuration");
+
+  g_free(method);
+  g_free(address);
+  g_free(gateway);
 }
 
 struct property_map
@@ -1195,6 +1364,8 @@
   { CONNMAN_PROPERTY_DOMAINS_CONFIGURATION, domains_configuration_updated },
   { CONNMAN_PROPERTY_IPV4,		ipv4_updated },
   { CONNMAN_PROPERTY_IPV4_CONFIGURATION, ipv4_configuration_updated },
+  { CONNMAN_PROPERTY_IPV6,		ipv6_updated },
+  { CONNMAN_PROPERTY_IPV6_CONFIGURATION, ipv6_configuration_updated },
 };
 
 static void property_updated(ConnmanService *self, const gchar *property,
@@ -1505,6 +1676,37 @@
   set_service_property(self, "IPv4.Configuration", value);
 }
 
+static void update_ipv6_configuration(ConnmanService *self)
+{
+  ConnmanServicePrivate *priv = GET_PRIVATE(self);
+  GVariantBuilder builder;
+  gchar prefix_length[10];
+  ConnmanIPv6 *ipv6;
+  GVariant *value;
+
+  if (priv->ipv6_configuration == NULL)
+    return;
+
+  ipv6 = priv->ipv6_configuration;
+
+  g_variant_builder_init(&builder, G_VARIANT_TYPE("a{ss}"));
+
+  g_variant_builder_add(&builder, "{ss}", "Method",
+			connman_ipv6_get_method_as_string(ipv6));
+  g_variant_builder_add(&builder, "{ss}", "Address",
+  			connman_ipv6_get_address(ipv6));
+
+  g_snprintf(prefix_length, sizeof(prefix_length), "%d",
+	     connman_ipv6_get_prefix_length(ipv6));
+  g_variant_builder_add(&builder, "{ss}", "PrefixLength", prefix_length);
+  g_variant_builder_add(&builder, "{ss}", "Gateway",
+  			connman_ipv6_get_gateway(ipv6));
+
+  value = g_variant_new("a{ss}", &builder);
+
+  set_service_property(self, "IPv6.Configuration", value);
+}
+
 static void connman_service_set_property(GObject *object,
 					       guint property_id,
 					       const GValue *value,
@@ -1611,6 +1813,17 @@
     priv->ipv4_configuration = g_value_dup_object(value);
     update_ipv4_configuration(self);
     break;
+  case PROP_IPV6:
+    if (priv->ipv6 != NULL)
+      g_object_unref(priv->ipv6);
+    priv->ipv6 = g_value_dup_object(value);
+    break;
+  case PROP_IPV6_CONFIGURATION:
+    if (priv->ipv6_configuration != NULL)
+      g_object_unref(priv->ipv6_configuration);
+    priv->ipv6_configuration = g_value_dup_object(value);
+    update_ipv6_configuration(self);
+    break;
   default:
     /* We don't have any other property... */
     G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
@@ -1727,6 +1940,16 @@
     g_object_unref(priv->ipv4_configuration);
     priv->ipv4_configuration = NULL;
   }
+
+  if (priv->ipv6 != NULL) {
+    g_object_unref(priv->ipv6);
+    priv->ipv6 = NULL;
+  }
+
+  if (priv->ipv6_configuration != NULL) {
+    g_object_unref(priv->ipv6_configuration);
+    priv->ipv6_configuration = NULL;
+  }
 }
 
 static void connman_service_finalize(GObject *object)
@@ -1956,6 +2179,21 @@
 			     G_PARAM_READWRITE);
   g_object_class_install_property(gobject_class, PROP_IPV4_CONFIGURATION,
 				  pspec);
+
+  pspec = g_param_spec_object("ipv6",
+			     "ConnmanService's ipv6 property",
+			     "ConnmanIPv6 object",
+			     CONNMAN_TYPE_IPV6,
+			     G_PARAM_READABLE);
+  g_object_class_install_property(gobject_class, PROP_IPV6, pspec);
+
+  pspec = g_param_spec_object("ipv6-configuration",
+			     "ConnmanService's ipv6-configuration property",
+			     "ConnmanIPv6 object",
+			     CONNMAN_TYPE_IPV6,
+			     G_PARAM_READWRITE);
+  g_object_class_install_property(gobject_class, PROP_IPV6_CONFIGURATION,
+				  pspec);
 }
 
 static void connman_service_init(ConnmanService *self)
 
=== modified file 'src/libconnman/connman-service.h'
--- src/libconnman/connman-service.h	2011-02-21 16:24:29 +0000
+++ src/libconnman/connman-service.h	2011-03-18 12:46:25 +0000
@@ -22,6 +22,7 @@
 #define _CONNMAN_SERVICE_H_
 
 #include "connman-ipv4.h"
+#include "connman-ipv6.h"
 
 #include <glib-object.h>
 #include <gio/gio.h>
@@ -129,6 +130,10 @@
 ConnmanIPv4 *connman_service_get_ipv4_configuration(ConnmanService *self);
 void connman_service_set_ipv4_configuration(ConnmanService *self,
 					    ConnmanIPv4 *ipv4);
+ConnmanIPv6 *connman_service_get_ipv6(ConnmanService *self);
+ConnmanIPv6 *connman_service_get_ipv6_configuration(ConnmanService *self);
+void connman_service_set_ipv6_configuration(ConnmanService *self,
+					    ConnmanIPv6 *ipv6);
 
 /* methods */
 void connman_service_connect(ConnmanService *self,
 
=== modified file 'src/libconnman/connman.h'
--- src/libconnman/connman.h	2011-02-22 13:57:51 +0000
+++ src/libconnman/connman.h	2011-03-18 12:46:25 +0000
@@ -74,6 +74,8 @@
 #define CONNMAN_PROPERTY_DOMAINS_CONFIGURATION	"Domains.Configuration"
 #define CONNMAN_PROPERTY_IPV4			"IPv4"
 #define CONNMAN_PROPERTY_IPV4_CONFIGURATION	"IPv4.Configuration"
+#define CONNMAN_PROPERTY_IPV6			"IPv6"
+#define CONNMAN_PROPERTY_IPV6_CONFIGURATION	"IPv6.Configuration"
 #define CONNMAN_PROPERTY_TECHNOLOGIES		"Technologies"
 #define CONNMAN_PROPERTY_OFFLINE_MODE		"OfflineMode"
 
 
=== modified file 'src/libconnman/generate_vapi'
--- src/libconnman/generate_vapi	2011-02-02 13:50:19 +0000
+++ src/libconnman/generate_vapi	2011-03-18 12:46:25 +0000
@@ -18,6 +18,7 @@
     connman.h connman-manager.c connman-manager.h \
     connman-service.c connman-service.h \
     connman-ipv4.c connman-ipv4.h \
+    connman-ipv6.c connman-ipv6.h \
     libconnman.la
 
 vapigen \
 
=== modified file 'src/settings/frontend/widgets/dialogs/edit-connection.vala'
--- src/settings/frontend/widgets/dialogs/edit-connection.vala	2011-03-17 13:28:03 +0000
+++ src/settings/frontend/widgets/dialogs/edit-connection.vala	2011-03-18 12:46:25 +0000
@@ -55,6 +55,15 @@
     private Gtk.TreeIter ipv4_manual_iter;
     private Gtk.TreeIter ipv4_dhcp_iter;
 
+    /* ipv6 */
+    private Gtk.ComboBox combobox_ipv6_method;
+    private Gtk.Entry entry_ipv6_address;
+    private Gtk.Entry entry_ipv6_prefix_length;
+    private Gtk.Entry entry_ipv6_gateway;
+    private Gtk.TreeIter ipv6_off_iter;
+    private Gtk.TreeIter ipv6_manual_iter;
+    private Gtk.TreeIter ipv6_auto_iter;
+
     private Gtk.Entry entry_nameservers;
     private Gtk.Entry entry_domains;
 
@@ -153,6 +162,7 @@
                                                     });
         }
 
+        /* ipv4 combobox */
         var store = new Gtk.ListStore(2, typeof(int), typeof(string));
         Gtk.TreeIter iter;
 
@@ -173,6 +183,27 @@
         store.append(out iter);
         store.set(iter, 0, Connman.IPv4Method.DHCP, 1, "DHCP");
         this.ipv4_dhcp_iter = iter;
+
+        /* ipv6 combobox */
+        store = new Gtk.ListStore(2, typeof(int), typeof(string));
+
+        this.combobox_ipv6_method.model = store;
+
+        cell = new Gtk.CellRendererText();
+        this.combobox_ipv6_method.pack_start(cell, false);
+        this.combobox_ipv6_method.set_attributes(cell, "text", 1);
+
+        store.append(out iter);
+        store.set(iter, 0, Connman.IPv6Method.OFF, 1, "Off");
+        this.ipv6_off_iter = iter;
+
+        store.append(out iter);
+        store.set(iter, 0, Connman.IPv6Method.MANUAL, 1, "Manual");
+        this.ipv6_manual_iter = iter;
+
+        store.append(out iter);
+        store.set(iter, 0, Connman.IPv6Method.AUTO, 1, "Auto");
+        this.ipv6_auto_iter = iter;
     }
 
     private void get_widgets() {
@@ -203,6 +234,16 @@
         this.entry_ipv4_gateway = b.get_object("entry_ipv4_gateway")
                         as Gtk.Entry;
 
+        /* ipv6 */
+        this.combobox_ipv6_method = b.get_object("combobox_ipv6_method")
+                        as Gtk.ComboBox;
+        this.entry_ipv6_address = b.get_object("entry_ipv6_address")
+                        as Gtk.Entry;
+        this.entry_ipv6_prefix_length = b.get_object("entry_ipv6_prefix_length")
+                        as Gtk.Entry;
+        this.entry_ipv6_gateway = b.get_object("entry_ipv6_gateway")
+                        as Gtk.Entry;
+
         /* dns */
         this.entry_nameservers = b.get_object("entry_nameservers") as Gtk.Entry;
         this.entry_domains = b.get_object("entry_domains") as Gtk.Entry;
@@ -214,6 +255,7 @@
         this.button_save.clicked.connect(this.on_button_save_clicked);
         this.button_cancel.clicked.connect(this.on_button_cancel_clicked);
         this.combobox_ipv4_method.changed.connect(ipv4_method_changed);
+        this.combobox_ipv6_method.changed.connect(ipv6_method_changed);
     }
 
     private void ipv4_method_changed(Gtk.ComboBox box) {
@@ -243,6 +285,33 @@
         }
     }
 
+    private void ipv6_method_changed(Gtk.ComboBox box) {
+        Gtk.TreeIter iter;
+        Gtk.ListStore store;
+        Connman.IPv6Method method;
+
+        if (this.combobox_ipv6_method.get_active_iter(out iter) == false)
+            return;
+
+        store = this.combobox_ipv6_method.model as Gtk.ListStore;
+        store.get(iter, 0, out method);
+
+        switch (method) {
+        case Connman.IPv6Method.MANUAL:
+            this.entry_ipv6_address.sensitive = true;
+            this.entry_ipv6_prefix_length.sensitive = true;
+            this.entry_ipv6_gateway.sensitive = true;
+            break;
+        case Connman.IPv6Method.OFF:
+        case Connman.IPv6Method.AUTO:
+        default:
+            this.entry_ipv6_address.sensitive = false;
+            this.entry_ipv6_prefix_length.sensitive = false;
+            this.entry_ipv6_gateway.sensitive = false;
+            break;
+        }
+    }
+
     private void update_mode() {
         string mode = "";
 
@@ -345,6 +414,51 @@
         }
     }
 
+    private void update_ipv6() {
+        var ipv6 = this.connection.get_ipv6_configuration();
+        Gtk.TreeIter iter;
+
+        switch (ipv6.method) {
+        case Connman.IPv6Method.OFF:
+            iter = this.ipv6_off_iter;
+            break;
+        case Connman.IPv6Method.MANUAL:
+            iter = this.ipv6_manual_iter;
+            this.entry_ipv6_address.text = ipv6.address;
+            this.entry_ipv6_prefix_length.text = ipv6.prefix_length.to_string();
+            this.entry_ipv6_gateway.text = ipv6.gateway;
+            break;
+        case Connman.IPv6Method.AUTO:
+        default:
+            iter = this.ipv6_auto_iter;
+            break;
+        }
+
+        this.combobox_ipv6_method.set_active_iter(iter);
+    }
+
+    private void save_ipv6() {
+        Gtk.TreeIter iter;
+        Connman.IPv6Method method;
+        Connman.IPv6 ipv6;
+
+        var store = this.combobox_ipv6_method.model as Gtk.ListStore;
+
+        this.combobox_ipv6_method.get_active_iter(out iter);
+        store.get(iter, 0, out method);
+
+        var address = this.entry_ipv6_address.text;
+        uint8 prefix_length = (uint8) uint64.parse(this.entry_ipv6_prefix_length.text);
+        var gateway = this.entry_ipv6_gateway.text;
+
+        try {
+            ipv6 = new Connman.IPv6(method, address, prefix_length, gateway);
+            this.connection.set_ipv6_configuration(ipv6);
+        } catch (GLib.Error e) {
+            stderr.printf("Failed to create ipv6 object: %s", e.message);
+        }
+    }
+
     private void update_nameservers() {
         string s = string.joinv(" ", this.connection.get_nameservers_configuration());
         this.entry_nameservers.set_text(s);
@@ -386,6 +500,7 @@
             update_security();
             update_passphrase();
             update_ipv4();
+            update_ipv6();
             update_nameservers();
             update_domains();
             break;
@@ -393,6 +508,7 @@
             update_name();
             update_autoconnect();
             update_ipv4();
+            update_ipv6();
             update_nameservers();
             update_domains();
             break;
@@ -400,6 +516,7 @@
             update_name();
             update_autoconnect();
             update_ipv4();
+            update_ipv6();
             update_nameservers();
             update_domains();
             break;
@@ -412,18 +529,21 @@
             save_autoconnect();
             save_passphrase();
             save_ipv4();
+            save_ipv6();
             save_nameservers();
             save_domains();
             break;
         case Connman.ServiceType.ETHERNET:
             save_autoconnect();
             save_ipv4();
+            save_ipv6();
             save_nameservers();
             save_domains();
             break;
         case Connman.ServiceType.BLUETOOTH:
             save_autoconnect();
             save_ipv4();
+            save_ipv6();
             save_nameservers();
             save_domains();
             break;