Update common D-Bus tracking and example code

15 files changed, 1589 insertions, 1571 deletions

diff --git a/.gitignore b/.gitignore
index 5aabe29..ca71aed 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,8 +27,11 @@ po/POTFILES
 po/stamp-it
 po/.intltool-merge-cache
 
-common/instance-glue.h
 common/test-client
+common/connman-demo
 applet/connman-applet
 properties/connman-properties
+marshal.h
+marshal.c
+*-glue.h
 *.desktop
diff --git a/common/Makefile.am b/common/Makefile.am
index 015ca0c..7c8aa4f 100644
--- a/common/Makefile.am
+++ b/common/Makefile.am
@@ -1,14 +1,20 @@
 
 noinst_LIBRARIES = libcommon.a
 
-libcommon_a_SOURCES = common.h client.h client.c \
-				instance.h instance.c
+libcommon_a_SOURCES = connman-dbus.c connman-dbus.h \
+				connman-client.h connman-client.c \
+							instance.h instance.c
 
-noinst_PROGRAMS = test-client
+noinst_PROGRAMS = connman-demo test-client
+
+connman_demo_SOURCES = demo.c
+connman_demo_LDADD = libcommon.a @GTK_LIBS@ @DBUS_LIBS@
 
 test_client_LDADD = libcommon.a @GTK_LIBS@ @DBUS_LIBS@
 
-BUILT_SOURCES = marshal.h marshal.c instance-glue.h client-glue.h
+BUILT_SOURCES = marshal.h marshal.c \
+			connman-dbus-glue.h \
+				instance-glue.h
 
 nodist_libcommon_a_SOURCES = $(BUILT_SOURCES)
 
@@ -16,7 +22,7 @@ CLEANFILES = $(BUILT_SOURCES)
 
 AM_CFLAGS = @DBUS_CFLAGS@ @GTK_CFLAGS@
 
-EXTRA_DIST = marshal.list instance.xml client.xml
+EXTRA_DIST = marshal.list instance.xml connman-client.xml
 
 MAINTAINERCLEANFILES = Makefile.in
 
@@ -29,5 +35,5 @@ marshal.c: marshal.list
 instance-glue.h: instance.xml
 	$(DBUS_BINDING_TOOL) --prefix=instance --mode=glib-server --output=$@ $<
 
-client-glue.h: client.xml
-	$(DBUS_BINDING_TOOL) --prefix=client --mode=glib-client --output=$@ $<
+connman-dbus-glue.h: connman-dbus.xml
+	$(DBUS_BINDING_TOOL) --prefix=connman --mode=glib-client --output=$@ $<
diff --git a/common/client.c b/common/client.c
deleted file mode 100644
index 3ca03e4..0000000
--- a/common/client.c
+++ /dev/null
@@ -1,971 +0,0 @@
-/*
- *
- *  Connection Manager
- *
- *  Copyright (C) 2008  Intel Corporation. All rights reserved.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 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 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 St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include <string.h>
-
-#include <dbus/dbus-glib.h>
-
-#include <gtk/gtk.h>
-
-#include "common.h"
-#include "client.h"
-
-#ifndef DBYS_TYPE_G_OBJECT_PATH_ARRAY
-#define DBUS_TYPE_G_OBJECT_PATH_ARRAY \
-	(dbus_g_type_get_collection("GPtrArray", DBUS_TYPE_G_OBJECT_PATH))
-#endif
-
-static GtkTreeStore *store = NULL;
-
-static client_state_callback state_callback = NULL;
-static guint current_state = CLIENT_STATE_UNKNOWN;
-static gint current_signal = -1;
-
-static void execute_state_callback(void)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-	gboolean cont;
-	guint new_state = CLIENT_STATE_UNKNOWN;
-	gint new_signal = -1;
-
-	if (state_callback == NULL)
-		return;
-
-	cont = gtk_tree_model_get_iter_first(model, &iter);
-
-	while (cont == TRUE) {
-		gboolean active;
-		guint type, state, signal;
-
-		gtk_tree_model_get(model, &iter,
-					CLIENT_COLUMN_ACTIVE, &active,
-					CLIENT_COLUMN_TYPE, &type,
-					CLIENT_COLUMN_STATE, &state,
-					CLIENT_COLUMN_SIGNAL, &signal, -1);
-
-		if (active == TRUE) {
-			switch (new_state) {
-			case CLIENT_STATE_CARRIER:
-			case CLIENT_STATE_CONNECT:
-			case CLIENT_STATE_CONNECTED:
-			case CLIENT_STATE_CONFIGURE:
-			case CLIENT_STATE_READY:
-				break;
-			default:
-				new_state = state;
-				break;
-			}
-
-			if (state == CLIENT_STATE_READY) {
-				switch (type) {
-				case CLIENT_TYPE_80211:
-					if ((gint) signal > new_signal)
-						new_signal = signal;
-					break;
-				}
-			}
-		}
-
-		cont = gtk_tree_model_iter_next(model, &iter);
-	}
-
-	if (current_state != new_state || current_signal != new_signal) {
-		current_state = new_state;
-		current_signal = new_signal;
-		state_callback(new_state, new_signal);
-	}
-}
-
-static guint string_to_type(const char *type)
-{
-	if (g_ascii_strcasecmp(type, "ethernet") == 0)
-		return CLIENT_TYPE_80203;
-	else if (g_ascii_strcasecmp(type, "wifi") == 0)
-		return CLIENT_TYPE_80211;
-	else
-		return CLIENT_TYPE_UNKNOWN;
-}
-
-static guint string_to_state(const char *state)
-{
-	if (g_ascii_strcasecmp(state, "off") == 0)
-		return CLIENT_STATE_OFF;
-	else if (g_ascii_strcasecmp(state, "enabled") == 0)
-		return CLIENT_STATE_ENABLED;
-	else if (g_ascii_strcasecmp(state, "scanning") == 0)
-		return CLIENT_STATE_SCANNING;
-	else if (g_ascii_strcasecmp(state, "connect") == 0)
-		return CLIENT_STATE_CONNECT;
-	else if (g_ascii_strcasecmp(state, "connected") == 0)
-		return CLIENT_STATE_CONNECTED;
-	else if (g_ascii_strcasecmp(state, "carrier") == 0)
-		return CLIENT_STATE_CARRIER;
-	else if (g_ascii_strcasecmp(state, "configure") == 0)
-		return CLIENT_STATE_CONFIGURE;
-	else if (g_ascii_strcasecmp(state, "ready") == 0)
-		return CLIENT_STATE_READY;
-	else if (g_ascii_strcasecmp(state, "shutdown") == 0)
-		return CLIENT_STATE_SHUTDOWN;
-	else
-		return CLIENT_STATE_UNKNOWN;
-}
-
-static guint string_to_policy(const char *policy)
-{
-	if (g_ascii_strcasecmp(policy, "off") == 0)
-		return CLIENT_POLICY_OFF;
-	else if (g_ascii_strcasecmp(policy, "ignore") == 0)
-		return CLIENT_POLICY_IGNORE;
-	else if (g_ascii_strcasecmp(policy, "auto") == 0)
-		return CLIENT_POLICY_AUTO;
-	else if (g_ascii_strcasecmp(policy, "ask") == 0)
-		return CLIENT_POLICY_ASK;
-	else
-		return CLIENT_POLICY_UNKNOWN;
-}
-
-static const char *policy_to_string(guint policy)
-{
-	switch (policy) {
-	case CLIENT_POLICY_OFF:
-		return "off";
-	case CLIENT_POLICY_IGNORE:
-		return "ignore";
-	case CLIENT_POLICY_AUTO:
-		return "auto";
-	case CLIENT_POLICY_ASK:
-		return "ask";
-	default:
-		return "unknown";
-	}
-}
-
-static guint string_to_ipv4_method(const char *method)
-{
-	if (g_ascii_strcasecmp(method, "off") == 0)
-		return CLIENT_IPV4_METHOD_OFF;
-	else if (g_ascii_strcasecmp(method, "static") == 0)
-		return CLIENT_IPV4_METHOD_STATIC;
-	else if (g_ascii_strcasecmp(method, "dhcp") == 0)
-		return CLIENT_IPV4_METHOD_DHCP;
-	else
-		return CLIENT_IPV4_METHOD_UNKNOWN;
-}
-
-static const char *ipv4_method_to_string(guint method)
-{
-	switch (method) {
-	case CLIENT_IPV4_METHOD_OFF:
-		return "off";
-	case CLIENT_IPV4_METHOD_STATIC:
-		return "static";
-	case CLIENT_IPV4_METHOD_DHCP:
-		return "dhcp";
-	default:
-		return "unknown";
-	}
-}
-
-static void handle_ipv4(GHashTable *hash, GtkTreeIter *iter)
-{
-	GValue *value;
-	const char *str;
-
-	value = g_hash_table_lookup(hash, "Method");
-	if (value != NULL) {
-		str = g_value_get_string(value);
-		gtk_tree_store_set(store, iter, CLIENT_COLUMN_IPV4_METHOD,
-					string_to_ipv4_method(str), -1);
-	}
-
-	value = g_hash_table_lookup(hash, "Address");
-	if (value != NULL) {
-		str = g_value_get_string(value);
-		gtk_tree_store_set(store, iter,
-				CLIENT_COLUMN_IPV4_ADDRESS, str, -1);
-	}
-
-	value = g_hash_table_lookup(hash, "Netmask");
-	if (value != NULL) {
-		str = g_value_get_string(value);
-		gtk_tree_store_set(store, iter,
-				CLIENT_COLUMN_IPV4_NETMASK, str, -1);
-	}
-
-	value = g_hash_table_lookup(hash, "Gateway");
-	if (value != NULL) {
-		str = g_value_get_string(value);
-		gtk_tree_store_set(store, iter,
-				CLIENT_COLUMN_IPV4_GATEWAY, str, -1);
-	}
-}
-
-#if 0
-static void ipv4_notify(DBusGProxy *object,
-				DBusGProxyCall *call, void *user_data)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-	GError *error = NULL;
-	GHashTable *hash = NULL;
-
-	dbus_g_proxy_end_call(object, call, &error,
-				dbus_g_type_get_map("GHashTable",
-						G_TYPE_STRING, G_TYPE_VALUE),
-				&hash, G_TYPE_INVALID);
-
-	if (error != NULL) {
-		g_printerr("Getting interface address failed: %s\n",
-							error->message);
-		g_error_free(error);
-		return;
-	}
-
-	if (hash == NULL)
-		return;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter,
-							user_data) == FALSE)
-		return;
-
-	handle_ipv4(hash, &iter);
-}
-#endif
-
-static void append_network(GHashTable *hash, GtkTreeIter *parent)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-	GValue *value;
-	const char *str;
-	gchar *essid;
-	guint signal;
-	gboolean security, cont;
-
-	value = g_hash_table_lookup(hash, "ESSID");
-	if (value == NULL)
-		return;
-
-	str = g_value_get_string(value);
-	if (str == NULL)
-		return;
-
-	value = g_hash_table_lookup(hash, "Signal");
-	signal = (value == NULL) ? 0 : g_value_get_uint(value);
-
-	value = g_hash_table_lookup(hash, "Security");
-	security = (value == NULL) ? FALSE : TRUE;
-
-	cont = gtk_tree_model_iter_children(model, &iter, parent);
-
-	while (cont == TRUE) {
-		gtk_tree_model_get(model, &iter,
-				CLIENT_COLUMN_NETWORK_ESSID, &essid, -1);
-
-		if (strcmp(str, essid) == 0) {
-			gtk_tree_store_set(store, &iter,
-					CLIENT_COLUMN_SIGNAL, signal, -1);
-			g_free(essid);
-			return;
-		}
-
-		g_free(essid);
-
-		cont = gtk_tree_model_iter_next(model, &iter);
-	}
-
-	gtk_tree_store_insert_with_values(store, &iter, parent, -1,
-				CLIENT_COLUMN_ACTIVE, TRUE,
-				CLIENT_COLUMN_SIGNAL, signal,
-				CLIENT_COLUMN_NETWORK_ESSID, str,
-				CLIENT_COLUMN_NETWORK_SECURITY, security, -1);
-}
-
-static void handle_network(GHashTable *hash,
-				GtkTreeIter *iter, gboolean secrets)
-{
-	GValue *value;
-	const char *str;
-
-	value = g_hash_table_lookup(hash, "ESSID");
-	if (value != NULL) {
-		str = g_value_get_string(value);
-		gtk_tree_store_set(store, iter,
-					CLIENT_COLUMN_NETWORK_ESSID, str, -1);
-	}
-
-	value = g_hash_table_lookup(hash, "PSK");
-	if (value != NULL) {
-		str = g_value_get_string(value);
-		gtk_tree_store_set(store, iter,
-					CLIENT_COLUMN_NETWORK_PSK, str, -1);
-	} else if (secrets == TRUE)
-		gtk_tree_store_set(store, iter,
-					CLIENT_COLUMN_NETWORK_PSK, NULL, -1);
-		
-}
-
-static void network_notify(DBusGProxy *object,
-				DBusGProxyCall *call, void *user_data)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-	GError *error = NULL;
-	GHashTable *hash = NULL;
-
-	dbus_g_proxy_end_call(object, call, &error,
-				dbus_g_type_get_map("GHashTable",
-						G_TYPE_STRING, G_TYPE_VALUE),
-				&hash, G_TYPE_INVALID);
-
-	if (error != NULL) {
-		g_printerr("Getting interface network failed: %s\n",
-							error->message);
-		g_error_free(error);
-		return;
-	}
-
-	if (hash == NULL)
-		return;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter,
-							user_data) == FALSE)
-		return;
-
-	handle_network(hash, &iter, TRUE);
-}
-
-static void properties_notify(DBusGProxy *object,
-				DBusGProxyCall *call, void *user_data)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-	GError *error = NULL;
-	GHashTable *hash = NULL;
-	GValue *value;
-	const char *str;
-	guint type = CLIENT_TYPE_UNKNOWN;
-	guint state = CLIENT_STATE_UNKNOWN;
-	guint signal = 0;
-	guint policy = CLIENT_POLICY_UNKNOWN;
-	const gchar *driver, *vendor, *product;
-
-	dbus_g_proxy_end_call(object, call, &error,
-				dbus_g_type_get_map("GHashTable",
-						G_TYPE_STRING, G_TYPE_VALUE),
-				&hash, G_TYPE_INVALID);
-
-	if (error != NULL) {
-		g_printerr("Getting interface properties failed: %s\n",
-							error->message);
-		g_error_free(error);
-		return;
-	}
-
-	if (hash == NULL)
-		return;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter,
-							user_data) == FALSE)
-		return;
-
-	value = g_hash_table_lookup(hash, "Type");
-	if (value == NULL)
-		return;
-
-	str = g_value_get_string(value);
-	if (str == NULL || g_str_equal(str, "device") == FALSE)
-		return;
-
-	value = g_hash_table_lookup(hash, "Subtype");
-	if (value != NULL) {
-		str = g_value_get_string(value);
-		type = string_to_type(str);
-	}
-
-	value = g_hash_table_lookup(hash, "Driver");
-	driver = value ? g_value_get_string(value) : NULL;
-
-	value = g_hash_table_lookup(hash, "Vendor");
-	vendor = value ? g_value_get_string(value) : NULL;
-
-	value = g_hash_table_lookup(hash, "Product");
-	product = value ? g_value_get_string(value) : NULL;
-
-	value = g_hash_table_lookup(hash, "State");
-	if (value != NULL) {
-		str = g_value_get_string(value);
-		state = string_to_state(str);
-	}
-
-	value = g_hash_table_lookup(hash, "Signal");
-	if (value != NULL)
-		signal = g_value_get_uint(value);
-
-	value = g_hash_table_lookup(hash, "Policy");
-	if (value != NULL) {
-		str = g_value_get_string(value);
-		policy = string_to_policy(str);
-	}
-
-	gtk_tree_store_set(store, &iter, CLIENT_COLUMN_TYPE, type,
-					CLIENT_COLUMN_DRIVER, driver,
-					CLIENT_COLUMN_VENDOR, vendor,
-					CLIENT_COLUMN_PRODUCT, product,
-					CLIENT_COLUMN_STATE, state,
-					CLIENT_COLUMN_SIGNAL, signal,
-					CLIENT_COLUMN_POLICY, policy, -1);
-
-	execute_state_callback();
-}
-
-static void update_element(DBusGProxy *proxy,
-				GtkTreeModel *model, GtkTreeIter *iter)
-{
-	DBusGProxyCall *call;
-	gchar *index;
-
-	index = gtk_tree_model_get_string_from_iter(model, iter);
-
-	call = dbus_g_proxy_begin_call_with_timeout(proxy,
-					"GetProperties", properties_notify,
-					index, g_free, 2000, G_TYPE_INVALID);
-
-	index = gtk_tree_model_get_string_from_iter(model, iter);
-
-#if 0
-	call = dbus_g_proxy_begin_call_with_timeout(proxy,
-					"GetNetwork", network_notify,
-					index, g_free, 2000, G_TYPE_INVALID);
-
-	index = gtk_tree_model_get_string_from_iter(model, iter);
-
-	call = dbus_g_proxy_begin_call_with_timeout(proxy,
-					"GetIPv4", ipv4_notify,
-					index, g_free, 2000, G_TYPE_INVALID);
-#endif
-}
-
-static void state_changed(DBusGProxy *proxy, const char *state,
-							gpointer user_data)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter,
-							user_data) == FALSE)
-		return;
-
-	gtk_tree_store_set(store, &iter, CLIENT_COLUMN_STATE,
-						string_to_state(state), -1);
-
-	execute_state_callback();
-}
-
-static void signal_changed(DBusGProxy *proxy, unsigned int signal,
-							gpointer user_data)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter,
-							user_data) == FALSE)
-		return;
-
-	gtk_tree_store_set(store, &iter, CLIENT_COLUMN_SIGNAL, signal, -1);
-
-	execute_state_callback();
-}
-
-static void policy_changed(DBusGProxy *proxy, const char *policy,
-							gpointer user_data)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter,
-							user_data) == FALSE)
-		return;
-
-	gtk_tree_store_set(store, &iter, CLIENT_COLUMN_POLICY,
-						string_to_policy(policy), -1);
-}
-
-static void network_found(DBusGProxy *proxy, GHashTable *hash,
-							gpointer user_data)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter,
-							user_data) == FALSE)
-		return;
-
-	append_network(hash, &iter);
-}
-
-static void network_changed(DBusGProxy *proxy, GHashTable *hash,
-							gpointer user_data)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-	DBusGProxyCall *call;
-	gchar *index;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter,
-							user_data) == FALSE)
-		return;
-
-	handle_network(hash, &iter, FALSE);
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	call = dbus_g_proxy_begin_call_with_timeout(proxy,
-					"GetNetwork", network_notify,
-					index, g_free, 2000, G_TYPE_INVALID);
-}
-
-static void ipv4_changed(DBusGProxy *system, GHashTable *hash,
-							gpointer user_data)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter,
-							user_data) == FALSE)
-		return;
-
-	handle_ipv4(hash, &iter);
-}
-
-static void signal_closure(gpointer user_data, GClosure *closure)
-{
-	g_free(user_data);
-}
-
-static void add_element(DBusGProxy *manager, const char *path)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-	DBusGProxy *proxy;
-	gchar *index;
-	gboolean cont;
-
-	cont = gtk_tree_model_get_iter_first(model, &iter);
-
-	while (cont == TRUE) {
-		const char *object_path;
-
-		gtk_tree_model_get(model, &iter,
-					CLIENT_COLUMN_PROXY, &proxy, -1);
-		if (proxy == NULL)
-			continue;
-
-		object_path = dbus_g_proxy_get_path(proxy);
-
-		g_object_unref(proxy);
-
-		if (strcmp(object_path, path) == 0) {
-			gtk_tree_store_set(store, &iter,
-					CLIENT_COLUMN_ACTIVE, TRUE,
-					CLIENT_COLUMN_STATE,
-						CLIENT_STATE_UNKNOWN, -1);
-			update_element(proxy, model, &iter);
-			return;
-		}
-
-		cont = gtk_tree_model_iter_next(model, &iter);
-	}
-
-	proxy = dbus_g_proxy_new_from_proxy(manager, CONNMAN_ELEMENT, path);
-
-	gtk_tree_store_insert_with_values(store, &iter, NULL, -1,
-					CLIENT_COLUMN_ACTIVE, TRUE,
-					CLIENT_COLUMN_PROXY, proxy,
-					CLIENT_COLUMN_STATE,
-						CLIENT_STATE_UNKNOWN, -1);
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	dbus_g_proxy_add_signal(proxy, "StateChanged",
-					G_TYPE_STRING, G_TYPE_INVALID);
-
-	dbus_g_proxy_connect_signal(proxy, "StateChanged",
-			G_CALLBACK(state_changed), index, signal_closure);
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	dbus_g_proxy_add_signal(proxy, "SignalChanged",
-					G_TYPE_UINT, G_TYPE_INVALID);
-
-	dbus_g_proxy_connect_signal(proxy, "SignalChanged",
-			G_CALLBACK(signal_changed), index, signal_closure);
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	dbus_g_proxy_add_signal(proxy, "PolicyChanged",
-					G_TYPE_STRING, G_TYPE_INVALID);
-
-	dbus_g_proxy_connect_signal(proxy, "PolicyChanged",
-			G_CALLBACK(policy_changed), index, signal_closure);
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	dbus_g_proxy_add_signal(proxy, "NetworkFound",
-				dbus_g_type_get_map("GHashTable",
-					G_TYPE_STRING, G_TYPE_VALUE),
-							G_TYPE_INVALID);
-
-	dbus_g_proxy_connect_signal(proxy, "NetworkFound",
-			G_CALLBACK(network_found), index, signal_closure);
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	dbus_g_proxy_add_signal(proxy, "NetworkChanged",
-				dbus_g_type_get_map("GHashTable",
-					G_TYPE_STRING, G_TYPE_VALUE),
-							G_TYPE_INVALID);
-
-	dbus_g_proxy_connect_signal(proxy, "NetworkChanged",
-			G_CALLBACK(network_changed), index, signal_closure);
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	dbus_g_proxy_add_signal(proxy, "IPv4Changed",
-				dbus_g_type_get_map("GHashTable",
-					G_TYPE_STRING, G_TYPE_VALUE),
-							G_TYPE_INVALID);
-
-	dbus_g_proxy_connect_signal(proxy, "IPv4Changed",
-			G_CALLBACK(ipv4_changed), index, signal_closure);
-
-	update_element(proxy, model, &iter);
-}
-
-static void element_added(DBusGProxy *manager, const char *path,
-							gpointer user_data)
-{
-	add_element(manager, path);
-
-	execute_state_callback();
-}
-
-static gboolean disable_element(GtkTreeModel *model, GtkTreePath *path,
-					GtkTreeIter *iter, gpointer user_data)
-{
-	DBusGProxy *proxy;
-	const char *object_path;
-
-	if (user_data == NULL) {
-		gtk_tree_store_set(GTK_TREE_STORE(model), iter,
-					CLIENT_COLUMN_ACTIVE, FALSE, -1);
-		return FALSE;
-	}
-
-	gtk_tree_model_get(model, iter, CLIENT_COLUMN_PROXY, &proxy, -1);
-	if (proxy == NULL)
-		return FALSE;
-
-	object_path = dbus_g_proxy_get_path(proxy);
-
-	g_object_unref(proxy);
-
-	if (strcmp(object_path, user_data) == 0) {
-		gtk_tree_store_set(GTK_TREE_STORE(model), iter,
-					CLIENT_COLUMN_ACTIVE, FALSE, -1);
-		return TRUE;
-	}
-
-	return FALSE;
-}
-
-static void element_removed(DBusGProxy *manager, const char *path,
-							gpointer user_data)
-{
-	gtk_tree_model_foreach(GTK_TREE_MODEL(store),
-					disable_element, (gpointer) path);
-
-	execute_state_callback();
-}
-
-static DBusGProxy *create_manager(DBusGConnection *conn)
-{
-	DBusGProxy *manager;
-	GError *error = NULL;
-	GPtrArray *array = NULL;
-
-	manager = dbus_g_proxy_new_for_name(conn, CONNMAN_SERVICE,
-							"/", CONNMAN_MANAGER);
-
-	dbus_g_proxy_call(manager, "ListElements", &error, G_TYPE_INVALID,
-			DBUS_TYPE_G_OBJECT_PATH_ARRAY, &array, G_TYPE_INVALID);
-
-	if (error == NULL) {
-		int i;
-
-		for (i = 0; i < array->len; i++) {
-			gchar *path = g_ptr_array_index(array, i);
-			add_element(manager, path);
-			g_free(path);
-		}
-	} else
-		g_error_free(error);
-
-	dbus_g_proxy_add_signal(manager, "ElementAdded",
-				DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
-
-	dbus_g_proxy_connect_signal(manager, "ElementAdded",
-				G_CALLBACK(element_added), NULL, NULL);
-
-	dbus_g_proxy_add_signal(manager, "ElementRemoved",
-				DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
-
-	dbus_g_proxy_connect_signal(manager, "ElementRemoved",
-				G_CALLBACK(element_removed), NULL, NULL);
-
-	return manager;
-}
-
-static void name_owner_changed(DBusGProxy *system, const char *name,
-			const char *prev, const char *new, gpointer user_data)
-{
-	if (strcmp(name, CONNMAN_SERVICE) == 0 && *new == '\0')
-		gtk_tree_model_foreach(GTK_TREE_MODEL(store),
-						disable_element, NULL);
-
-	execute_state_callback();
-}
-
-static DBusGProxy *create_system(DBusGConnection *conn)
-{
-	DBusGProxy *system;
-
-	system = dbus_g_proxy_new_for_name(conn, DBUS_SERVICE_DBUS,
-					DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS);
-
-	dbus_g_proxy_add_signal(system, "NameOwnerChanged",
-		G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
-
-	dbus_g_proxy_connect_signal(system, "NameOwnerChanged",
-				G_CALLBACK(name_owner_changed), NULL, NULL);
-
-	return system;
-}
-
-static DBusGConnection *connection;
-static DBusGProxy *system, *manager;
-
-gboolean client_init(GError **error)
-{
-	GError *dbus_error = NULL;
-
-	connection = dbus_g_bus_get(DBUS_BUS_SYSTEM, &dbus_error);
-	if (dbus_error != NULL) {
-		g_error_free(dbus_error);
-		return FALSE;
-	}
-
-	store = gtk_tree_store_new(17, G_TYPE_BOOLEAN, DBUS_TYPE_G_PROXY,
-				G_TYPE_POINTER, G_TYPE_UINT, G_TYPE_STRING,
-				G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT,
-				G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING,
-				G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_UINT,
-				G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
-
-	system = create_system(connection);
-
-	manager = create_manager(connection);
-
-	return TRUE;
-}
-
-void client_cleanup(void)
-{
-	g_object_unref(manager);
-
-	g_object_unref(system);
-
-	g_object_unref(store);
-
-	dbus_g_connection_unref(connection);
-}
-
-void client_set_userdata(const gchar *index, gpointer user_data)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter, index) == FALSE)
-		return;
-
-	gtk_tree_store_set(store, &iter, CLIENT_COLUMN_USERDATA,
-							user_data, -1);
-}
-
-void client_set_state_callback(client_state_callback callback)
-{
-	state_callback = callback;
-
-	execute_state_callback();
-}
-
-void client_propose_scanning(void)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-	gboolean cont;
-
-	cont = gtk_tree_model_get_iter_first(model, &iter);
-
-	while (cont == TRUE) {
-		DBusGProxy *proxy;
-		gboolean active;
-
-		gtk_tree_model_get(model, &iter,
-					CLIENT_COLUMN_ACTIVE, &active,
-					CLIENT_COLUMN_PROXY, &proxy, -1);
-		if (proxy == NULL || active == FALSE)
-			continue;
-
-		dbus_g_proxy_call(proxy, "Scan", NULL,
-					G_TYPE_INVALID, G_TYPE_INVALID);
-
-		g_object_unref(proxy);
-
-		cont = gtk_tree_model_iter_next(model, &iter);
-	}
-}
-
-GtkTreeModel *client_get_model(void)
-{
-	return gtk_tree_model_filter_new(GTK_TREE_MODEL(store), NULL);
-}
-
-GtkTreeModel *client_get_active_model(void)
-{
-	GtkTreeModel *model;
-
-	model = gtk_tree_model_filter_new(GTK_TREE_MODEL(store), NULL);
-	gtk_tree_model_filter_set_visible_column(GTK_TREE_MODEL_FILTER(model),
-							CLIENT_COLUMN_ACTIVE);
-
-	return model;
-}
-
-void client_set_policy(const gchar *index, guint policy)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-	DBusGProxy *proxy;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter, index) == FALSE)
-		return;
-
-	gtk_tree_model_get(model, &iter, CLIENT_COLUMN_PROXY, &proxy, -1);
-	if (proxy == NULL)
-		return;
-
-	dbus_g_proxy_call_no_reply(proxy, "SetPolicy", G_TYPE_STRING,
-				policy_to_string(policy), G_TYPE_INVALID);
-
-	g_object_unref(proxy);
-}
-
-static void value_free(GValue *value)
-{
-	g_value_unset(value);
-	g_free(value);
-}
-
-void client_set_ipv4(const gchar *index, guint method)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-	DBusGProxy *proxy;
-	GHashTable *hash = NULL;
-	GValue *value;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter, index) == FALSE)
-		return;
-
-	gtk_tree_model_get(model, &iter, CLIENT_COLUMN_PROXY, &proxy, -1);
-	if (proxy == NULL)
-		return;
-
-	hash = g_hash_table_new_full(g_str_hash, g_str_equal,
-					g_free, (GDestroyNotify) value_free);
-
-	value = g_new0(GValue, 1);
-	g_value_init(value, G_TYPE_STRING);
-	g_value_set_string(value, ipv4_method_to_string(method));
-	g_hash_table_insert(hash, g_strdup("Method"), value);
-
-	dbus_g_proxy_call_no_reply(proxy, "SetIPv4",
-					dbus_g_type_get_map("GHashTable",
-						G_TYPE_STRING, G_TYPE_VALUE),
-					hash, G_TYPE_INVALID);
-
-	g_object_unref(proxy);
-}
-
-void client_set_network(const gchar *index, const gchar *network,
-						const gchar *passphrase)
-{
-	GtkTreeModel *model = GTK_TREE_MODEL(store);
-	GtkTreeIter iter;
-	DBusGProxy *proxy;
-	GHashTable *hash = NULL;
-	GValue *value;
-
-	if (gtk_tree_model_get_iter_from_string(model, &iter, index) == FALSE)
-		return;
-
-	gtk_tree_model_get(model, &iter, CLIENT_COLUMN_PROXY, &proxy, -1);
-	if (proxy == NULL)
-		return;
-
-	hash = g_hash_table_new_full(g_str_hash, g_str_equal,
-					g_free, (GDestroyNotify) value_free);
-
-	value = g_new0(GValue, 1);
-	g_value_init(value, G_TYPE_STRING);
-	g_value_set_string(value, network);
-	g_hash_table_insert(hash, g_strdup("ESSID"), value);
-
-	if (passphrase != NULL) {
-		value = g_new0(GValue, 1);
-		g_value_init(value, G_TYPE_STRING);
-		g_value_set_string(value, passphrase);
-		g_hash_table_insert(hash, g_strdup("PSK"), value);
-	}
-
-	dbus_g_proxy_call_no_reply(proxy, "SetNetwork",
-					dbus_g_type_get_map("GHashTable",
-						G_TYPE_STRING, G_TYPE_VALUE),
-					hash, G_TYPE_INVALID);
-
-	g_object_unref(proxy);
-}
diff --git a/common/client.h b/common/client.h
deleted file mode 100644
index 10ab599..0000000
--- a/common/client.h
+++ /dev/null
@@ -1,92 +0,0 @@
-/*
- *
- *  Connection Manager
- *
- *  Copyright (C) 2008  Intel Corporation. All rights reserved.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 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 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 St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-enum {
-	CLIENT_COLUMN_ACTIVE,
-	CLIENT_COLUMN_PROXY,
-	CLIENT_COLUMN_USERDATA,
-	CLIENT_COLUMN_TYPE,
-	CLIENT_COLUMN_DRIVER,
-	CLIENT_COLUMN_VENDOR,
-	CLIENT_COLUMN_PRODUCT,
-	CLIENT_COLUMN_STATE,
-	CLIENT_COLUMN_SIGNAL,
-	CLIENT_COLUMN_POLICY,
-	CLIENT_COLUMN_NETWORK_ESSID,
-	CLIENT_COLUMN_NETWORK_PSK,
-	CLIENT_COLUMN_NETWORK_SECURITY,
-	CLIENT_COLUMN_IPV4_METHOD,
-	CLIENT_COLUMN_IPV4_ADDRESS,
-	CLIENT_COLUMN_IPV4_NETMASK,
-	CLIENT_COLUMN_IPV4_GATEWAY,
-};
-
-enum {
-	CLIENT_TYPE_UNKNOWN,
-	CLIENT_TYPE_80203,
-	CLIENT_TYPE_80211,
-};
-
-enum {
-	CLIENT_STATE_UNKNOWN,
-	CLIENT_STATE_OFF,
-	CLIENT_STATE_ENABLED,
-	CLIENT_STATE_SCANNING,
-	CLIENT_STATE_CONNECT,
-	CLIENT_STATE_CONNECTED,
-	CLIENT_STATE_CARRIER,
-	CLIENT_STATE_CONFIGURE,
-	CLIENT_STATE_READY,
-	CLIENT_STATE_SHUTDOWN,
-};
-
-enum {
-	CLIENT_POLICY_UNKNOWN,
-	CLIENT_POLICY_OFF,
-	CLIENT_POLICY_IGNORE,
-	CLIENT_POLICY_AUTO,
-	CLIENT_POLICY_ASK,
-};
-
-enum {
-	CLIENT_IPV4_METHOD_UNKNOWN,
-	CLIENT_IPV4_METHOD_OFF,
-	CLIENT_IPV4_METHOD_STATIC,
-	CLIENT_IPV4_METHOD_DHCP,
-};
-
-gboolean client_init(GError **error);
-void client_cleanup(void);
-
-void client_set_userdata(const gchar *index, gpointer user_data);
-
-typedef void (* client_state_callback) (guint state, gint signal);
-void client_set_state_callback(client_state_callback callback);
-
-void client_propose_scanning(void);
-
-GtkTreeModel *client_get_model(void);
-GtkTreeModel *client_get_active_model(void);
-
-void client_set_policy(const gchar *index, guint policy);
-void client_set_ipv4(const gchar *index, guint method);
-void client_set_network(const gchar *index, const gchar *network,
-						const gchar *passphrase);
diff --git a/common/client.xml b/common/client.xml
deleted file mode 100644
index 7b4070d..0000000
--- a/common/client.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-
-<node name="/">
-  <interface name="manager">
-    <method name="GetProperties">
-      <arg type="a{sv}" direction="out"/>
-    </method>
-  </interface>
-
-  <interface name="device">
-    <method name="GetProperties">
-      <arg type="a{sv}" direction="out"/>
-    </method>
-  </interface>
-
-  <interface name="network">
-    <method name="GetProperties">
-      <arg type="a{sv}" direction="out"/>
-    </method>
-  </interface>
-</node>
diff --git a/common/common.h b/common/common.h
deleted file mode 100644
index f7f0a1e..0000000
--- a/common/common.h
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- *
- *  Connection Manager
- *
- *  Copyright (C) 2008  Intel Corporation. All rights reserved.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2 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 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 St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#define CONNMAN_SERVICE    "org.moblin.connman"
-#define CONNMAN_INSTANCE   CONNMAN_SERVICE ".Instance"
-#define CONNMAN_MANAGER    CONNMAN_SERVICE ".Manager"
-#define CONNMAN_ELEMENT    CONNMAN_SERVICE ".Element"
diff --git a/common/connman-client.c b/common/connman-client.c
new file mode 100644
index 0000000..f7c3b36
--- /dev/null
+++ b/common/connman-client.c
@@ -0,0 +1,325 @@
+/*
+ *
+ *  Connection Manager
+ *
+ *  Copyright (C) 2008  Intel Corporation. All rights reserved.
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1 as published by the Free Software Foundation.
+ *
+ *  This library 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "connman-dbus.h"
+#include "connman-dbus-glue.h"
+#include "connman-client.h"
+
+#include "marshal.h"
+
+#ifdef DEBUG
+#define DBG(fmt, arg...) printf("%s:%s() " fmt "\n", __FILE__, __FUNCTION__ , ## arg)
+#else
+#define DBG(fmt...)
+#endif
+
+#define CONNMAN_CLIENT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE((obj), \
+				CONNMAN_TYPE_CLIENT, ConnmanClientPrivate))
+
+typedef struct _ConnmanClientPrivate ConnmanClientPrivate;
+
+struct _ConnmanClientPrivate {
+	GtkTreeStore *store;
+	DBusGProxy *dbus;
+	DBusGProxy *manager;
+	ConnmanClientCallback callback;
+};
+
+G_DEFINE_TYPE(ConnmanClient, connman_client, G_TYPE_OBJECT)
+
+static void name_owner_changed(DBusGProxy *dbus, const char *name,
+			const char *prev, const char *new, gpointer user_data)
+{
+	ConnmanClient *client = user_data;
+	ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client);
+	GtkTreeIter iter;
+	gboolean cont;
+
+	if (g_str_equal(name, CONNMAN_SERVICE) == FALSE || *new != '\0')
+		return;
+
+	DBG("client %p name %s", client, name);
+
+	cont = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(priv->store),
+									&iter);
+
+	while (cont == TRUE)
+		cont = gtk_tree_store_remove(priv->store, &iter);
+}
+
+static DBusGConnection *connection = NULL;
+
+static void connman_client_init(ConnmanClient *client)
+{
+	ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client);
+
+	DBG("client %p", client);
+
+	priv->store = gtk_tree_store_new(_CONNMAN_NUM_COLUMNS, G_TYPE_OBJECT,
+			G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT,
+			G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
+			G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING);
+
+	g_object_set_data(G_OBJECT(priv->store), "State", g_strdup("offline"));
+
+	priv->dbus = dbus_g_proxy_new_for_name(connection, DBUS_SERVICE_DBUS,
+				DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS);
+
+	dbus_g_proxy_add_signal(priv->dbus, "NameOwnerChanged",
+					G_TYPE_STRING, G_TYPE_STRING,
+					G_TYPE_STRING, G_TYPE_INVALID);
+	dbus_g_proxy_connect_signal(priv->dbus, "NameOwnerChanged",
+				G_CALLBACK(name_owner_changed), client, NULL);
+
+	priv->manager = connman_dbus_create_manager(connection, priv->store);
+}
+
+static void connman_client_finalize(GObject *client)
+{
+	ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client);
+
+	DBG("client %p", client);
+
+	g_signal_handlers_disconnect_by_func(priv->dbus,
+					name_owner_changed, client);
+	g_object_unref(priv->dbus);
+
+	connman_dbus_destroy_manager(priv->manager, priv->store);
+
+	g_object_unref(priv->store);
+
+	G_OBJECT_CLASS(connman_client_parent_class)->finalize(client);
+}
+
+static void connman_client_class_init(ConnmanClientClass *klass)
+{
+	GObjectClass *object_class = (GObjectClass *) klass;
+	GError *error = NULL;
+
+	DBG("class %p", klass);
+
+	g_type_class_add_private(klass, sizeof(ConnmanClientPrivate));
+
+	object_class->finalize = connman_client_finalize;
+
+	dbus_g_object_register_marshaller(marshal_VOID__STRING_BOXED,
+						G_TYPE_NONE, G_TYPE_STRING,
+						G_TYPE_VALUE, G_TYPE_INVALID);
+
+	connection = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
+
+	if (error != NULL) {
+		g_printerr("Connecting to system bus failed: %s\n",
+							error->message);
+		g_error_free(error);
+	}
+}
+
+static ConnmanClient *connman_client = NULL;
+
+ConnmanClient *connman_client_new(void)
+{
+	if (connman_client != NULL)
+		return g_object_ref(connman_client);
+
+	connman_client = CONNMAN_CLIENT(g_object_new(CONNMAN_TYPE_CLIENT,
+									NULL));
+
+	DBG("client %p", connman_client);
+
+	return connman_client;
+}
+
+GtkTreeModel *connman_client_get_model(ConnmanClient *client)
+{
+	ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client);
+	GtkTreeModel *model;
+
+	DBG("client %p", client);
+
+	model = g_object_ref(priv->store);
+
+	return model;
+}
+
+static gboolean device_filter(GtkTreeModel *model,
+					GtkTreeIter *iter, gpointer user_data)
+{
+	DBusGProxy *proxy;
+	gboolean active;
+
+	gtk_tree_model_get(model, iter, CONNMAN_COLUMN_PROXY, &proxy, -1);
+
+	if (proxy == NULL)
+		return FALSE;
+
+	active = g_str_equal(CONNMAN_DEVICE_INTERFACE,
+					dbus_g_proxy_get_interface(proxy));
+
+	g_object_unref(proxy);
+
+	return active;
+}
+
+GtkTreeModel *connman_client_get_device_model(ConnmanClient *client)
+{
+	ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client);
+	GtkTreeModel *model;
+
+	DBG("client %p", client);
+
+	model = gtk_tree_model_filter_new(GTK_TREE_MODEL(priv->store), NULL);
+
+	gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model),
+						device_filter, NULL, NULL);
+
+	return model;
+}
+
+static gboolean network_filter(GtkTreeModel *model,
+					GtkTreeIter *iter, gpointer user_data)
+{
+	gchar *device = user_data;
+	DBusGProxy *proxy;
+	gboolean active;
+
+	gtk_tree_model_get(model, iter, CONNMAN_COLUMN_PROXY, &proxy, -1);
+
+	if (proxy == NULL)
+		return FALSE;
+
+	if (g_str_equal(CONNMAN_NETWORK_INTERFACE,
+				dbus_g_proxy_get_interface(proxy)) == TRUE)
+		active = g_str_has_prefix(dbus_g_proxy_get_interface(proxy),
+								device);
+	else
+		active = FALSE;
+
+	g_object_unref(proxy);
+
+	return active;
+}
+
+GtkTreeModel *connman_client_get_network_model(ConnmanClient *client,
+							const gchar *device)
+{
+	ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client);
+	GtkTreeModel *model;
+
+	DBG("client %p", client);
+
+	model = gtk_tree_model_filter_new(GTK_TREE_MODEL(priv->store), NULL);
+
+	gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model),
+				network_filter, g_strdup(device), g_free);
+
+	return model;
+}
+
+void connman_client_set_powered(ConnmanClient *client, const gchar *device,
+							gboolean powered)
+{
+	ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client);
+	DBusGProxy *proxy;
+	GValue value = { 0 };
+
+	DBG("client %p", client);
+
+	proxy = connman_dbus_get_proxy(priv->store, device);
+	if (proxy == NULL)
+		return;
+
+	g_value_init(&value, G_TYPE_BOOLEAN);
+	g_value_set_boolean(&value, powered);
+
+	connman_set_property(proxy, "Powered", &value, NULL);
+
+	g_object_unref(proxy);
+}
+
+void connman_client_propose_scan(ConnmanClient *client, const gchar *device)
+{
+	ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client);
+	DBusGProxy *proxy;
+
+	DBG("client %p", client);
+
+	proxy = connman_dbus_get_proxy(priv->store, device);
+	if (proxy == NULL)
+		return;
+
+	connman_propose_scan(proxy, NULL);
+
+	g_object_unref(proxy);
+}
+
+void connman_client_connect(ConnmanClient *client, const gchar *network)
+{
+	ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client);
+	DBusGProxy *proxy;
+
+	DBG("client %p", client);
+
+	proxy = connman_dbus_get_proxy(priv->store, network);
+	if (proxy == NULL)
+		return;
+
+	connman_connect(proxy, NULL);
+
+	g_object_unref(proxy);
+}
+
+void connman_client_disconnect(ConnmanClient *client, const gchar *network)
+{
+	ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client);
+	DBusGProxy *proxy;
+
+	DBG("client %p", client);
+
+	proxy = connman_dbus_get_proxy(priv->store, network);
+	if (proxy == NULL)
+		return;
+
+	connman_disconnect(proxy, NULL);
+
+	g_object_unref(proxy);
+}
+
+void connman_client_set_callback(ConnmanClient *client,
+					ConnmanClientCallback callback)
+{
+	ConnmanClientPrivate *priv = CONNMAN_CLIENT_GET_PRIVATE(client);
+	gchar *state;
+
+	DBG("client %p", client);
+
+	priv->callback = callback;
+
+	g_object_set_data(G_OBJECT(priv->store), "callback", callback);
+
+	state = g_object_get_data(G_OBJECT(priv->store), "State");
+	if (state != NULL && priv->callback != NULL)
+		priv->callback(state, NULL);
+}
diff --git a/common/connman-client.h b/common/connman-client.h
new file mode 100644
index 0000000..52b0dfd
--- /dev/null
+++ b/common/connman-client.h
@@ -0,0 +1,105 @@
+/*
+ *
+ *  Connection Manager
+ *
+ *  Copyright (C) 2008  Intel Corporation. All rights reserved.
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1 as published by the Free Software Foundation.
+ *
+ *  This library 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef __CONNMAN_CLIENT_H
+#define __CONNMAN_CLIENT_H
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define CONNMAN_TYPE_CLIENT (connman_client_get_type())
+#define CONNMAN_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), \
+					CONNMAN_TYPE_CLIENT, ConnmanClient))
+#define CONNMAN_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), \
+					CONNMAN_TYPE_CLIENT, ConnmanClientClass))
+#define CONNMAN_IS_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), \
+							CONNMAN_TYPE_CLIENT))
+#define CONNMAN_IS_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), \
+							CONNMAN_TYPE_CLIENT))
+#define CONNMAN_GET_CLIENT_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), \
+					CONNMAN_TYPE_CLIENT, ConnmanClientClass))
+
+typedef struct _ConnmanClient ConnmanClient;
+typedef struct _ConnmanClientClass ConnmanClientClass;
+
+struct _ConnmanClient {
+	GObject parent;
+};
+
+struct _ConnmanClientClass {
+	GObjectClass parent_class;
+};
+
+GType connman_client_get_type(void);
+
+ConnmanClient *connman_client_new(void);
+
+GtkTreeModel *connman_client_get_model(ConnmanClient *client);
+GtkTreeModel *connman_client_get_device_model(ConnmanClient *client);
+GtkTreeModel *connman_client_get_network_model(ConnmanClient *client,
+							const gchar *device);
+
+void connman_client_set_powered(ConnmanClient *client, const gchar *device,
+							gboolean powered);
+void connman_client_propose_scan(ConnmanClient *client, const gchar *device);
+
+void connman_client_connect(ConnmanClient *client, const gchar *network);
+void connman_client_disconnect(ConnmanClient *client, const gchar *network);
+
+typedef void (* ConnmanClientCallback) (const char *status, void *user_data);
+
+void connman_client_set_callback(ConnmanClient *client,
+					ConnmanClientCallback callback);
+
+enum {
+	CONNMAN_COLUMN_PROXY,		/* G_TYPE_OBJECT  */
+	CONNMAN_COLUMN_NAME,		/* G_TYPE_STRING  */
+	CONNMAN_COLUMN_ICON,		/* G_TYPE_STRING  */
+	CONNMAN_COLUMN_TYPE,		/* G_TYPE_UINT    */
+	CONNMAN_COLUMN_ENABLED,		/* G_TYPE_BOOLEAN */
+	CONNMAN_COLUMN_INRANGE,		/* G_TYPE_BOOLEAN */
+	CONNMAN_COLUMN_REMEMBER,	/* G_TYPE_BOOLEAN */
+	CONNMAN_COLUMN_STRENGTH,	/* G_TYPE_UINT    */
+	CONNMAN_COLUMN_SECURITY,	/* G_TYPE_UINT    */
+	CONNMAN_COLUMN_PASSPHRASE,	/* G_TYPE_STRING  */
+	_CONNMAN_NUM_COLUMNS
+};
+
+enum {
+	CONNMAN_TYPE_UNKNOWN,
+	CONNMAN_TYPE_ETHERNET,
+	CONNMAN_TYPE_WIFI,
+	CONNMAN_TYPE_WIMAX,
+	CONNMAN_TYPE_BLUETOOTH,
+};
+
+enum {
+	CONNMAN_SECURITY_UNKNOWN,
+	CONNMAN_SECURITY_NONE,
+	CONNMAN_SECURITY_WEP,
+	CONNMAN_SECURITY_WPA,
+	CONNMAN_SECURITY_WPA2,
+};
+
+G_END_DECLS
+
+#endif /* __CONNMAN_CLIENT_H */
diff --git a/common/connman-dbus.c b/common/connman-dbus.c
new file mode 100644
index 0000000..d977c1b
--- /dev/null
+++ b/common/connman-dbus.c
@@ -0,0 +1,570 @@
+/*
+ *
+ *  Connection Manager
+ *
+ *  Copyright (C) 2008  Intel Corporation. All rights reserved.
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1 as published by the Free Software Foundation.
+ *
+ *  This library 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "connman-client.h"
+
+#include "connman-dbus.h"
+#include "connman-dbus-glue.h"
+
+#ifdef DEBUG
+#define DBG(fmt, arg...) printf("%s:%s() " fmt "\n", __FILE__, __FUNCTION__ , ## arg)
+#else
+#define DBG(fmt...)
+#endif
+
+#ifndef DBUS_TYPE_G_OBJECT_PATH_ARRAY
+#define DBUS_TYPE_G_OBJECT_PATH_ARRAY \
+	(dbus_g_type_get_collection("GPtrArray", DBUS_TYPE_G_OBJECT_PATH))
+#endif
+
+#ifndef DBUS_TYPE_G_DICTIONARY
+#define DBUS_TYPE_G_DICTIONARY \
+	(dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE))
+#endif
+
+static DBusGConnection *connection = NULL;
+
+typedef gboolean (*IterSearchFunc) (GtkTreeStore *store,
+				GtkTreeIter *iter, gconstpointer user_data);
+
+static gboolean iter_search(GtkTreeStore *store,
+				GtkTreeIter *iter, GtkTreeIter *parent,
+				IterSearchFunc func, gconstpointer user_data)
+{
+	gboolean cont, found = FALSE;
+
+	if (parent == NULL)
+		cont = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store),
+									iter);
+	else
+		cont = gtk_tree_model_iter_children(GTK_TREE_MODEL(store),
+								iter, parent);
+
+	while (cont == TRUE) {
+		GtkTreeIter child;
+
+		found = func(store, iter, user_data);
+		if (found == TRUE)
+			break;
+
+		found = iter_search(store, &child, iter, func, user_data);
+		if (found == TRUE) {
+			*iter = child;
+			break;
+		}
+
+		cont = gtk_tree_model_iter_next(GTK_TREE_MODEL(store), iter);
+	}
+
+	return found;
+}
+
+static gboolean compare_proxy(GtkTreeStore *store, GtkTreeIter *iter,
+						gconstpointer user_data)
+{
+	const char *path = user_data;
+	DBusGProxy *proxy;
+	gboolean found = FALSE;
+
+	gtk_tree_model_get(GTK_TREE_MODEL(store), iter,
+					CONNMAN_COLUMN_PROXY, &proxy, -1);
+
+	if (proxy != NULL) {
+		found = g_str_equal(path, dbus_g_proxy_get_path(proxy));
+		g_object_unref(proxy);
+	}
+
+	return found;
+}
+
+static gboolean get_iter_from_proxy(GtkTreeStore *store,
+					GtkTreeIter *iter, DBusGProxy *proxy)
+{
+	const char *path = dbus_g_proxy_get_path(proxy);
+
+	return iter_search(store, iter, NULL, compare_proxy, path);
+}
+
+static gboolean get_iter_from_path(GtkTreeStore *store,
+					GtkTreeIter *iter, const char *path)
+{
+	return iter_search(store, iter, NULL, compare_proxy, path);
+}
+
+DBusGProxy *connman_dbus_get_proxy(GtkTreeStore *store, const gchar *path)
+{
+	DBusGProxy *proxy;
+	GtkTreeIter iter;
+
+	if (iter_search(store, &iter, NULL, compare_proxy, path) == FALSE)
+		return NULL;
+
+	gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
+					CONNMAN_COLUMN_PROXY, &proxy, -1);
+
+	return proxy;
+}
+
+static void iterate_list(const GValue *value, gpointer user_data)
+{
+	GSList **list = user_data;
+	gchar *path = g_value_dup_boxed(value);
+
+	if (path == NULL)
+		return;
+
+	*list = g_slist_prepend(*list, path);
+}
+
+static gint compare_path(gconstpointer a, gconstpointer b)
+{
+	return g_strcmp0(a, b);
+}
+
+static void property_update(GtkTreeStore *store, const GValue *value,
+			const char *key, connman_get_properties_reply callback)
+{
+	GSList *list, *link, *old_list, *new_list = NULL;
+	const char *iface;
+
+	DBG("store %p", store);
+
+	if (g_str_equal(key, "Connections") == TRUE)
+		iface = CONNMAN_CONNECTION_INTERFACE;
+	else if (g_str_equal(key, "Devices") == TRUE)
+		iface = CONNMAN_DEVICE_INTERFACE;
+	else
+		iface = CONNMAN_NETWORK_INTERFACE;
+
+	old_list = g_object_get_data(G_OBJECT(store), key);
+
+	dbus_g_type_collection_value_iterate(value, iterate_list, &new_list);
+
+	g_object_set_data(G_OBJECT(store), key, new_list);
+
+	for (list = new_list; list; list = list->next) {
+		gchar *path = list->data;
+		DBusGProxy *proxy;
+
+		link = g_slist_find_custom(old_list, path, compare_path);
+		if (link != NULL) {
+			g_free(link->data);
+			old_list = g_slist_delete_link(old_list, link);
+			continue;
+		}
+
+		proxy = dbus_g_proxy_new_for_name(connection,
+						CONNMAN_SERVICE, path, iface);
+		if (proxy == NULL)
+			continue;
+
+		connman_get_properties_async(proxy, callback, store);
+	}
+
+	for (list = old_list; list; list = list->next) {
+		gchar *path = list->data;
+		GtkTreeIter iter;
+
+		if (get_iter_from_path(store, &iter, path) == TRUE)
+			gtk_tree_store_remove(store, &iter);
+
+		g_free(path);
+	}
+
+	g_slist_free(old_list);
+}
+
+static guint get_type(const GValue *value)
+{
+	const char *type = value ? g_value_get_string(value) : NULL;
+
+	if (type == NULL)
+		return CONNMAN_TYPE_UNKNOWN;
+	else if (g_str_equal(type, "ethernet") == TRUE)
+		return CONNMAN_TYPE_ETHERNET;
+	else if (g_str_equal(type, "wifi") == TRUE)
+		return CONNMAN_TYPE_WIFI;
+	else if (g_str_equal(type, "wimax") == TRUE)
+		return CONNMAN_TYPE_WIMAX;
+	else if (g_str_equal(type, "bluetooth") == TRUE)
+		return CONNMAN_TYPE_BLUETOOTH;
+
+	return CONNMAN_TYPE_UNKNOWN;
+}
+
+static const gchar *type2icon(guint type)
+{
+	switch (type) {
+	case CONNMAN_TYPE_ETHERNET:
+		return "network-wired";
+	case CONNMAN_TYPE_WIFI:
+	case CONNMAN_TYPE_WIMAX:
+		return "network-wireless";
+	case CONNMAN_TYPE_BLUETOOTH:
+		return "bluetooth";
+	default:
+		return NULL;
+	}
+}
+
+static guint get_security(const GValue *value)
+{
+	const char *security = value ? g_value_get_string(value) : NULL;
+
+	if (security == NULL)
+		return CONNMAN_SECURITY_UNKNOWN;
+	else if (g_str_equal(security, "none") == TRUE)
+		return CONNMAN_SECURITY_NONE;
+	else if (g_str_equal(security, "wep") == TRUE)
+		return CONNMAN_SECURITY_WEP;
+	else if (g_str_equal(security, "wpa") == TRUE)
+		return CONNMAN_SECURITY_WPA;
+	else if (g_str_equal(security, "wpa2") == TRUE)
+		return CONNMAN_SECURITY_WPA2;
+
+	return CONNMAN_SECURITY_UNKNOWN;
+}
+
+static void network_changed(DBusGProxy *proxy, const char *property,
+					GValue *value, gpointer user_data)
+{
+	GtkTreeStore *store = user_data;
+	const char *path = dbus_g_proxy_get_path(proxy);
+	GtkTreeIter iter;
+
+	DBG("store %p proxy %p property %s", store, proxy, property);
+
+	if (get_iter_from_path(store, &iter, path) == FALSE)
+		return;
+
+	if (g_str_equal(property, "Connected") == TRUE) {
+		gboolean connected = g_value_get_boolean(value);
+		gtk_tree_store_set(store, &iter,
+					CONNMAN_COLUMN_ENABLED, connected, -1);
+	} else if (g_str_equal(property, "Available") == TRUE) {
+		gboolean inrange = g_value_get_boolean(value);
+		gtk_tree_store_set(store, &iter,
+					CONNMAN_COLUMN_INRANGE, inrange, -1);
+	} else if (g_str_equal(property, "Remember") == TRUE) {
+		gboolean remember = g_value_get_boolean(value);
+		gtk_tree_store_set(store, &iter,
+					CONNMAN_COLUMN_REMEMBER, remember, -1);
+	} else if (g_str_equal(property, "Strength") == TRUE) {
+		guint strength = g_value_get_uchar(value);
+		gtk_tree_store_set(store, &iter,
+					CONNMAN_COLUMN_STRENGTH, strength, -1);
+	}
+}
+
+static void network_properties(DBusGProxy *proxy, GHashTable *hash,
+					GError *error, gpointer user_data)
+{
+	GtkTreeStore *store = user_data;
+	GValue *value;
+	const gchar *device, *name, *secret;
+	gboolean connected, inrange, remember;
+	guint strength, security;
+	GtkTreeIter iter, parent;
+
+	if (hash == NULL)
+		goto done;
+
+	value = g_hash_table_lookup(hash, "Device");
+	device = value ? g_value_get_boxed(value) : NULL;
+
+	value = g_hash_table_lookup(hash, "Name");
+	name = value ? g_value_get_string(value) : NULL;
+
+	value = g_hash_table_lookup(hash, "Connected");
+	connected = value ? g_value_get_boolean(value) : FALSE;
+
+	value = g_hash_table_lookup(hash, "Available");
+	inrange = value ? g_value_get_boolean(value) : FALSE;
+
+	value = g_hash_table_lookup(hash, "Remember");
+	remember = value ? g_value_get_boolean(value) : FALSE;
+
+	value = g_hash_table_lookup(hash, "Strength");
+	strength = value ? g_value_get_uchar(value) : 0;
+
+	value = g_hash_table_lookup(hash, "WiFi.Security");
+	security = get_security(value);
+
+	value = g_hash_table_lookup(hash, "WiFi.Passphrase");
+	secret = value ? g_value_get_string(value) : NULL;
+
+	DBG("name %s strength %d", name, strength);
+
+	if (get_iter_from_path(store, &parent, device) == FALSE)
+		return;
+
+	if (get_iter_from_proxy(store, &iter, proxy) == FALSE) {
+		gtk_tree_store_insert_with_values(store, &iter, &parent, -1,
+					CONNMAN_COLUMN_PROXY, proxy,
+					CONNMAN_COLUMN_NAME, name,
+					CONNMAN_COLUMN_ENABLED, connected,
+					CONNMAN_COLUMN_INRANGE, inrange,
+					CONNMAN_COLUMN_REMEMBER, remember,
+					CONNMAN_COLUMN_STRENGTH, strength,
+					CONNMAN_COLUMN_SECURITY, security,
+					CONNMAN_COLUMN_PASSPHRASE, secret, -1);
+
+		dbus_g_proxy_add_signal(proxy, "PropertyChanged",
+				G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID);
+		dbus_g_proxy_connect_signal(proxy, "PropertyChanged",
+				G_CALLBACK(network_changed), store, NULL);
+	} else
+		gtk_tree_store_set(store, &iter,
+					CONNMAN_COLUMN_NAME, name,
+					CONNMAN_COLUMN_ENABLED, connected,
+					CONNMAN_COLUMN_INRANGE, inrange,
+					CONNMAN_COLUMN_REMEMBER, remember,
+					CONNMAN_COLUMN_STRENGTH, strength,
+					CONNMAN_COLUMN_SECURITY, security,
+					CONNMAN_COLUMN_PASSPHRASE, secret, -1);
+
+done:
+	g_object_unref(proxy);
+}
+
+static void device_changed(DBusGProxy *proxy, const char *property,
+					GValue *value, gpointer user_data)
+{
+	GtkTreeStore *store = user_data;
+	const char *path = dbus_g_proxy_get_path(proxy);
+	GtkTreeIter iter;
+
+	DBG("store %p proxy %p property %s", store, proxy, property);
+
+	if (get_iter_from_path(store, &iter, path) == FALSE)
+		return;
+
+	if (g_str_equal(property, "Powered") == TRUE) {
+		gboolean powered = g_value_get_boolean(value);
+		gtk_tree_store_set(store, &iter,
+					CONNMAN_COLUMN_ENABLED, powered, -1);
+	} else if (g_str_equal(property, "Networks") == TRUE)
+		property_update(store, value, path, network_properties);
+}
+
+static void device_properties(DBusGProxy *proxy, GHashTable *hash,
+					GError *error, gpointer user_data)
+{
+	GtkTreeStore *store = user_data;
+	const char *path = dbus_g_proxy_get_path(proxy);
+	GValue *value;
+	const gchar *name, *icon;
+	guint type;
+	gboolean powered;
+	GtkTreeIter iter;
+
+	if (hash == NULL)
+		goto done;
+
+	value = g_hash_table_lookup(hash, "Name");
+	name = value ? g_value_get_string(value) : NULL;
+
+	value = g_hash_table_lookup(hash, "Type");
+	type = get_type(value);
+	icon = type2icon(type);
+
+	value = g_hash_table_lookup(hash, "Powered");
+	powered = value ? g_value_get_boolean(value) : FALSE;
+
+	DBG("name %s type %d", name, type);
+
+	if (get_iter_from_proxy(store, &iter, proxy) == FALSE) {
+		gtk_tree_store_insert_with_values(store, &iter, NULL, -1,
+					CONNMAN_COLUMN_PROXY, proxy,
+					CONNMAN_COLUMN_NAME, name,
+					CONNMAN_COLUMN_ICON, icon,
+					CONNMAN_COLUMN_TYPE, type,
+					CONNMAN_COLUMN_ENABLED, powered, -1);
+
+		dbus_g_proxy_add_signal(proxy, "PropertyChanged",
+				G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID);
+		dbus_g_proxy_connect_signal(proxy, "PropertyChanged",
+				G_CALLBACK(device_changed), store, NULL);
+	} else
+		gtk_tree_store_set(store, &iter,
+					CONNMAN_COLUMN_NAME, name,
+					CONNMAN_COLUMN_ICON, icon,
+					CONNMAN_COLUMN_TYPE, type,
+					CONNMAN_COLUMN_ENABLED, powered, -1);
+
+	value = g_hash_table_lookup(hash, "Networks");
+	if (value != NULL)
+		property_update(store, value, path, network_properties);
+
+done:
+	g_object_unref(proxy);
+}
+
+static void connection_changed(DBusGProxy *proxy, const char *property,
+					GValue *value, gpointer user_data)
+{
+	GtkTreeStore *store = user_data;
+	const char *path = dbus_g_proxy_get_path(proxy);
+	GtkTreeIter iter;
+
+	DBG("store %p proxy %p property %s", store, proxy, property);
+
+	if (get_iter_from_path(store, &iter, path) == FALSE)
+		return;
+
+	if (g_str_equal(property, "Default") == TRUE) {
+		gboolean enabled = g_value_get_boolean(value);
+		gtk_tree_store_set(store, &iter,
+					CONNMAN_COLUMN_ENABLED, enabled, -1);
+	}
+}
+
+static void connection_properties(DBusGProxy *proxy, GHashTable *hash,
+					GError *error, gpointer user_data)
+{
+	GtkTreeStore *store = user_data;
+	GValue *value;
+	const gchar *name;
+	guint type;
+	gboolean enabled;
+	GtkTreeIter iter;
+
+	if (hash == NULL)
+		goto done;
+
+	value = g_hash_table_lookup(hash, "Type");
+	type = get_type(value);
+
+	value = g_hash_table_lookup(hash, "Default");
+	enabled = value ? g_value_get_boolean(value) : FALSE;
+
+	DBG("type %d", type);
+
+	if (get_iter_from_proxy(store, &iter, proxy) == FALSE) {
+		gtk_tree_store_insert_with_values(store, &iter, NULL, -1,
+					CONNMAN_COLUMN_PROXY, proxy,
+					CONNMAN_COLUMN_TYPE, type,
+					CONNMAN_COLUMN_ENABLED, enabled, -1);
+
+		dbus_g_proxy_add_signal(proxy, "PropertyChanged",
+				G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID);
+		dbus_g_proxy_connect_signal(proxy, "PropertyChanged",
+				G_CALLBACK(connection_changed), store, NULL);
+	} else
+		gtk_tree_store_set(store, &iter,
+					CONNMAN_COLUMN_NAME, name,
+					CONNMAN_COLUMN_TYPE, type,
+					CONNMAN_COLUMN_ENABLED, enabled, -1);
+
+done:
+	g_object_unref(proxy);
+}
+
+static void manager_changed(DBusGProxy *proxy, const char *property,
+					GValue *value, gpointer user_data)
+{
+	GtkTreeStore *store = user_data;
+
+	DBG("store %p proxy %p property %s", store, proxy, property);
+
+	if (g_str_equal(property, "State") == TRUE) {
+		ConnmanClientCallback callback;
+		gchar *state;
+
+		state = g_object_get_data(G_OBJECT(store), "State");
+		g_free(state);
+
+		state = g_value_dup_string(value);
+		g_object_set_data(G_OBJECT(store), "State", state);
+
+		callback = g_object_get_data(G_OBJECT(store), "callback");
+		if (callback)
+			callback(state, NULL);
+	} else if (g_str_equal(property, "Connections") == TRUE) {
+		property_update(store, value, property, connection_properties);
+	} else if (g_str_equal(property, "Devices") == TRUE) {
+		property_update(store, value, property, device_properties);
+	}
+}
+
+static void manager_properties(DBusGProxy *proxy, GHashTable *hash,
+					GError *error, gpointer user_data)
+{
+	GtkTreeStore *store = user_data;
+	ConnmanClientCallback callback;
+	GValue *value;
+	gchar *state;
+
+	DBG("store %p proxy %p hash %p", store, proxy, hash);
+
+	value = g_hash_table_lookup(hash, "State");
+	state = value ? g_value_dup_string(value) : NULL;
+	g_object_set_data(G_OBJECT(store), "State", state);
+
+	callback = g_object_get_data(G_OBJECT(store), "callback");
+	if (callback)
+		callback(state, NULL);
+
+	value = g_hash_table_lookup(hash, "Connections");
+	if (value != NULL)
+		property_update(store, value,
+					"Connections", connection_properties);
+
+	value = g_hash_table_lookup(hash, "Devices");
+	if (value != NULL)
+		property_update(store, value, "Devices", device_properties);
+}
+
+DBusGProxy *connman_dbus_create_manager(DBusGConnection *conn,
+						GtkTreeStore *store)
+{
+	DBusGProxy *proxy;
+
+	connection = dbus_g_connection_ref(conn);
+
+	proxy = dbus_g_proxy_new_for_name(connection, CONNMAN_SERVICE,
+			CONNMAN_MANAGER_PATH, CONNMAN_MANAGER_INTERFACE);
+
+	DBG("store %p proxy %p", store, proxy);
+
+	dbus_g_proxy_add_signal(proxy, "PropertyChanged",
+				G_TYPE_STRING, G_TYPE_VALUE, G_TYPE_INVALID);
+	dbus_g_proxy_connect_signal(proxy, "PropertyChanged",
+				G_CALLBACK(manager_changed), store, NULL);
+
+	connman_get_properties_async(proxy, manager_properties, store);
+
+	return proxy;
+}
+
+void connman_dbus_destroy_manager(DBusGProxy *proxy, GtkTreeStore *store)
+{
+	DBG("store %p proxy %p", store, proxy);
+
+	g_signal_handlers_disconnect_by_func(proxy, manager_changed, store);
+	g_object_unref(proxy);
+
+	dbus_g_connection_unref(connection);
+}
diff --git a/common/connman-dbus.h b/common/connman-dbus.h
new file mode 100644
index 0000000..dfb1b66
--- /dev/null
+++ b/common/connman-dbus.h
@@ -0,0 +1,42 @@
+/*
+ *
+ *  Connection Manager
+ *
+ *  Copyright (C) 2008  Intel Corporation. All rights reserved.
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser General Public
+ *  License version 2.1 as published by the Free Software Foundation.
+ *
+ *  This library 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#include <dbus/dbus-glib.h>
+#include <gtk/gtk.h>
+
+#define CONNMAN_SERVICE			"org.moblin.connman"
+
+#define CONNMAN_ERROR_INTERFACE		CONNMAN_SERVICE ".Error"
+#define CONNMAN_AGENT_INTERFACE		CONNMAN_SERVICE ".Agent"
+
+#define CONNMAN_MANAGER_INTERFACE	CONNMAN_SERVICE ".Manager"
+#define CONNMAN_MANAGER_PATH		"/"
+
+#define CONNMAN_PROFILE_INTERFACE	CONNMAN_SERVICE ".Profile"
+#define CONNMAN_DEVICE_INTERFACE	CONNMAN_SERVICE ".Device"
+#define CONNMAN_NETWORK_INTERFACE	CONNMAN_SERVICE ".Network"
+#define CONNMAN_CONNECTION_INTERFACE	CONNMAN_SERVICE ".Connection"
+
+DBusGProxy *connman_dbus_create_manager(DBusGConnection *connection,
+							GtkTreeStore *store);
+void connman_dbus_destroy_manager(DBusGProxy *proxy, GtkTreeStore *store);
+
+DBusGProxy *connman_dbus_get_proxy(GtkTreeStore *store, const gchar *path);
diff --git a/common/connman-dbus.xml b/common/connman-dbus.xml
new file mode 100644
index 0000000..9fefd55
--- /dev/null
+++ b/common/connman-dbus.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+
+<node name="/">
+  <interface name="connman">
+    <method name="GetProperties">
+      <arg type="a{sv}" direction="out"/>
+    </method>
+    <method name="SetProperty">
+      <arg type="s"/>
+      <arg type="v"/>
+    </method>
+    <method name="ProposeScan">
+    </method>
+    <method name="Connect">
+    </method>
+    <method name="Disconnect">
+    </method>
+  </interface>
+</node>
diff --git a/common/demo.c b/common/demo.c
new file mode 100644
index 0000000..2338220
--- /dev/null
+++ b/common/demo.c
@@ -0,0 +1,446 @@
+/*
+ *
+ *  Connection Manager
+ *
+ *  Copyright (C) 2008  Intel Corporation. All rights reserved.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 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 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 St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <dbus/dbus-glib.h>
+#include <gtk/gtk.h>
+
+#include "connman-client.h"
+
+static gboolean option_fullscreen = FALSE;
+static ConnmanClient *client;
+
+static GtkWidget *tree_networks = NULL;
+static GtkWidget *button_enabled = NULL;
+static GtkWidget *button_refresh = NULL;
+static GtkWidget *button_connect = NULL;
+static GtkWidget *label_status = NULL;
+static GtkTreeSelection *selection = NULL;
+
+static void status_callback(const char *status, void *user_data)
+{
+	gchar *markup;
+
+	if (label_status == NULL)
+		return;
+
+	markup = g_strdup_printf("System is %s", status);
+	gtk_label_set_markup(GTK_LABEL(label_status), markup);
+	g_free(markup);
+}
+
+static GtkWidget *create_label(const gchar *str)
+{
+	GtkWidget *label;
+	gchar *tmp;
+
+	label = gtk_label_new(NULL);
+	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
+	gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
+
+	tmp = g_strdup_printf("<b>%s</b>", str);
+	gtk_label_set_markup(GTK_LABEL(label), tmp);
+	g_free(tmp);
+
+	return label;
+}
+
+static void changed_callback(GtkComboBox *combo, gpointer user_data)
+{
+	GtkTreeModel *model = gtk_combo_box_get_model(combo);
+	GtkTreeIter iter;
+	DBusGProxy *proxy;
+	gchar *path;
+	gboolean enabled;
+
+	if (gtk_combo_box_get_active_iter(combo, &iter) == FALSE)
+		return;
+
+	path = g_object_get_data(G_OBJECT(button_enabled), "device");
+	g_free(path);
+
+	gtk_tree_model_get(model, &iter, CONNMAN_COLUMN_PROXY, &proxy,
+					CONNMAN_COLUMN_ENABLED, &enabled, -1);
+
+	path = g_strdup(dbus_g_proxy_get_path(proxy));
+	g_object_set_data(G_OBJECT(button_enabled), "device", path);
+
+	g_object_unref(proxy);
+
+	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button_enabled),
+								enabled);
+
+	gtk_widget_set_sensitive(button_refresh, enabled);
+
+	model = connman_client_get_network_model(client, path);
+	gtk_tree_view_set_model(GTK_TREE_VIEW(tree_networks), model);
+	g_object_unref(model);
+}
+
+static void toggled_callback(GtkToggleButton *button, gpointer user_data)
+{
+	gchar *path;
+	gboolean active;
+
+	path = g_object_get_data(G_OBJECT(button), "device");
+	if (path == NULL)
+		return;
+
+	active = gtk_toggle_button_get_active(button);
+
+	connman_client_set_powered(client, path, active);
+
+	gtk_widget_set_sensitive(button_refresh, active);
+}
+
+static void refresh_callback(GtkButton *button, gpointer user_data)
+{
+	gchar *path;
+
+	path = g_object_get_data(G_OBJECT(button_enabled), "device");
+	if (path == NULL)
+		return;
+
+	connman_client_propose_scan(client, path);
+}
+
+static void connect_callback(GtkButton *button, gpointer user_data)
+{
+	GtkTreeModel *model;
+	GtkTreeIter iter;
+	DBusGProxy *proxy;
+	const gchar *path;
+	gboolean enabled;
+
+	if (gtk_tree_selection_get_selected(selection, &model, &iter) == FALSE)
+		return;
+
+	gtk_tree_model_get(model, &iter, CONNMAN_COLUMN_PROXY, &proxy,
+					CONNMAN_COLUMN_ENABLED, &enabled, -1);
+
+	path = dbus_g_proxy_get_path(proxy);
+
+	if (enabled == FALSE)
+		connman_client_connect(client, path);
+	else
+		connman_client_disconnect(client, path);
+
+	g_object_unref(proxy);
+
+	if (enabled == FALSE)
+		g_object_set(button_connect,
+				"label", GTK_STOCK_DISCONNECT, NULL);
+	else
+		g_object_set(button_connect,
+				"label", GTK_STOCK_CONNECT, NULL);
+}
+
+static GtkWidget *create_left(void)
+{
+	GtkWidget *mainbox;
+	GtkWidget *vbox;
+	GtkWidget *hbox;
+	GtkWidget *label;
+	GtkWidget *combo;
+	GtkWidget *button;
+	GtkTreeModel *model;
+	GtkCellRenderer *renderer;
+
+	mainbox = gtk_vbox_new(FALSE, 24);
+	gtk_container_set_border_width(GTK_CONTAINER(mainbox), 8);
+
+	vbox = gtk_vbox_new(FALSE, 6);
+	gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0);
+
+	label = create_label("Device");
+	gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
+
+	combo = gtk_combo_box_new();
+	gtk_box_pack_start(GTK_BOX(vbox), combo, FALSE, FALSE, 0);
+	g_signal_connect(G_OBJECT(combo), "changed",
+					G_CALLBACK(changed_callback), NULL);
+
+	gtk_cell_layout_clear(GTK_CELL_LAYOUT(combo));
+
+	renderer = gtk_cell_renderer_text_new();
+	gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), renderer, TRUE);
+	gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), renderer,
+					"text", CONNMAN_COLUMN_NAME, NULL);
+
+	button = gtk_check_button_new_with_label("Enabled");
+	gtk_box_pack_end(GTK_BOX(vbox), button, FALSE, FALSE, 0);
+	g_signal_connect(G_OBJECT(button), "toggled",
+					G_CALLBACK(toggled_callback), NULL);
+
+	button_enabled = button;
+
+	vbox = gtk_vbox_new(FALSE, 6);
+	gtk_box_pack_start(GTK_BOX(mainbox), vbox, TRUE, TRUE, 0);
+
+	label = create_label("Status");
+	gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
+
+	label = gtk_label_new(NULL);
+	gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
+	gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
+	gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
+
+	label_status = label;
+
+	vbox = gtk_vbox_new(FALSE, 6);
+	gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0);
+
+	hbox = gtk_hbox_new(FALSE, 12);
+	gtk_box_set_homogeneous(GTK_BOX(hbox), TRUE);
+	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
+
+	button = gtk_button_new_from_stock(GTK_STOCK_REFRESH);
+	gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
+	gtk_widget_set_sensitive(button, FALSE);
+	g_signal_connect(G_OBJECT(button), "clicked",
+					G_CALLBACK(refresh_callback), NULL);
+
+	button_refresh = button;
+
+	button = gtk_button_new_from_stock(GTK_STOCK_DISCONNECT);
+	gtk_box_pack_end(GTK_BOX(hbox), button, TRUE, TRUE, 0);
+	gtk_widget_set_sensitive(button, FALSE);
+	g_signal_connect(G_OBJECT(button), "clicked",
+					G_CALLBACK(connect_callback), NULL);
+
+	button_connect = button;
+
+	model = connman_client_get_device_model(client);
+	gtk_combo_box_set_model(GTK_COMBO_BOX(combo), model);
+	g_object_unref(model);
+
+	gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
+
+	return mainbox;
+}
+
+static void select_callback(GtkTreeSelection *selection, gpointer user_data)
+{
+	GtkTreeModel *model;
+	GtkTreeIter iter;
+	gboolean selected, enabled;
+
+	selected = gtk_tree_selection_get_selected(selection, &model, &iter);
+
+	if (selected == TRUE) {
+		gtk_tree_model_get(model, &iter,
+					CONNMAN_COLUMN_ENABLED, &enabled, -1);
+
+		if (enabled == TRUE)
+			g_object_set(button_connect,
+					"label", GTK_STOCK_DISCONNECT, NULL);
+		else
+			g_object_set(button_connect,
+					"label", GTK_STOCK_CONNECT, NULL);
+	}
+
+	gtk_widget_set_sensitive(button_connect, selected);
+}
+
+static void status_to_icon(GtkTreeViewColumn *column, GtkCellRenderer *cell,
+			GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
+{
+	gboolean enabled;
+
+	gtk_tree_model_get(model, iter, CONNMAN_COLUMN_ENABLED, &enabled, -1);
+
+	if (enabled == TRUE)
+		g_object_set(cell, "icon-name", GTK_STOCK_ABOUT, NULL);
+
+	g_object_set(cell, "visible", enabled, NULL);
+}
+
+static GtkWidget *create_right(void)
+{
+	GtkWidget *mainbox;
+	GtkWidget *vbox;
+	GtkWidget *label;
+	GtkWidget *scrolled;
+	GtkWidget *tree;
+	GtkTreeViewColumn *column;
+	GtkCellRenderer *renderer;
+
+	mainbox = gtk_vbox_new(FALSE, 24);
+	gtk_container_set_border_width(GTK_CONTAINER(mainbox), 8);
+
+	vbox = gtk_vbox_new(FALSE, 6);
+	gtk_box_pack_start(GTK_BOX(mainbox), vbox, TRUE, TRUE, 0);
+
+	label = create_label("Networks");
+	gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
+
+	scrolled = gtk_scrolled_window_new(NULL, NULL);
+	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
+				GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
+							GTK_SHADOW_OUT);
+	gtk_container_add(GTK_CONTAINER(vbox), scrolled);
+
+	tree = gtk_tree_view_new();
+	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
+	gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE);
+	gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
+	gtk_container_add(GTK_CONTAINER(scrolled), tree);
+
+	gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), 0,
+				NULL, gtk_cell_renderer_pixbuf_new(),
+					status_to_icon, NULL, NULL);
+	column = gtk_tree_view_get_column(GTK_TREE_VIEW(tree), 0);
+	gtk_tree_view_column_set_min_width(column, 24);
+
+	column = gtk_tree_view_column_new();
+	gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(column), TRUE);
+	gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
+
+	renderer = gtk_cell_renderer_text_new();
+	gtk_tree_view_column_pack_start(column, renderer, TRUE);
+	gtk_tree_view_column_add_attribute(column, renderer,
+					"text", CONNMAN_COLUMN_NAME);
+
+	tree_networks = tree;
+
+	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
+	gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
+	g_signal_connect(G_OBJECT(selection), "changed",
+				G_CALLBACK(select_callback), NULL);
+
+	return mainbox;
+}
+
+static gboolean delete_callback(GtkWidget *window, GdkEvent *event,
+							gpointer user_data)
+{
+	gtk_widget_destroy(GTK_WIDGET(window));
+
+	gtk_main_quit();
+
+	return FALSE;
+}
+
+static void close_callback(GtkWidget *button, gpointer user_data)
+{
+	GtkWidget *window = user_data;
+
+	gtk_widget_destroy(window);
+
+	gtk_main_quit();
+}
+
+static GtkWidget *create_window(void)
+{
+	GtkWidget *window;
+	GtkWidget *vbox;
+	GtkWidget *hbox;
+	GtkWidget *notebook;
+	GtkWidget *buttonbox;
+	GtkWidget *button;
+	GtkWidget *widget;
+
+	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
+	gtk_window_set_default_size(GTK_WINDOW(window), 580, 360);
+	g_signal_connect(G_OBJECT(window), "delete-event",
+					G_CALLBACK(delete_callback), NULL);
+
+	vbox = gtk_vbox_new(FALSE, 12);
+	gtk_container_set_border_width(GTK_CONTAINER(vbox), 12);
+	gtk_container_add(GTK_CONTAINER(window), vbox);
+
+	notebook = gtk_notebook_new();
+	gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook), FALSE);
+	gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
+
+	buttonbox = gtk_hbutton_box_new();
+	gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_END);
+	gtk_box_pack_start(GTK_BOX(vbox), buttonbox, FALSE, FALSE, 0);
+
+	button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
+	gtk_container_add(GTK_CONTAINER(buttonbox), button);
+	g_signal_connect(G_OBJECT(button), "clicked",
+					G_CALLBACK(close_callback), window);
+
+	hbox = gtk_hbox_new(FALSE, 0);
+	gtk_container_set_border_width(GTK_CONTAINER(hbox), 8);
+
+	widget = create_right();
+	gtk_widget_set_size_request(widget, 280, -1);
+	gtk_box_pack_end(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
+
+	widget = create_left();
+	gtk_widget_set_size_request(widget, 260, -1);
+	gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
+
+	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), hbox, NULL);
+
+	return window;
+}
+
+static GOptionEntry options[] = {
+	{ "fullscreen", 'f', 0, G_OPTION_ARG_NONE, &option_fullscreen,
+					"Start up in fullscreen mode" },
+	{ NULL },
+};
+
+int main(int argc, char *argv[])
+{
+	GError *error = NULL;
+	GtkWidget *window;
+
+	if (gtk_init_with_args(&argc, &argv, NULL,
+				options, NULL, &error) == FALSE) {
+		if (error != NULL) {
+			g_printerr("%s\n", error->message);
+			g_error_free(error);
+		} else
+			g_printerr("An unknown error occurred\n");
+
+		gtk_exit(1);
+	}
+
+	g_set_application_name("Connection Manager Demo");
+
+	gtk_window_set_default_icon_name("network-wireless");
+
+	client = connman_client_new();
+
+	window = create_window();
+
+	connman_client_set_callback(client, status_callback);
+
+	if (option_fullscreen == TRUE)
+		gtk_window_fullscreen(GTK_WINDOW(window));
+
+	gtk_widget_show_all(window);
+
+	gtk_main();
+
+	g_object_unref(client);
+
+	return 0;
+}
diff --git a/common/instance.c b/common/instance.c
index b82af94..8934cd5 100644
--- a/common/instance.c
+++ b/common/instance.c
@@ -27,9 +27,11 @@
 
 #include <gtk/gtk.h>
 
-#include "common.h"
 #include "instance.h"
 
+#define CONNMAN_SERVICE    "org.moblin.connman"
+#define CONNMAN_INSTANCE   CONNMAN_SERVICE ".Instance"
+
 static DBusGConnection *connection;
 
 static GtkWindow *instance_window;
diff --git a/common/test-client.c b/common/test-client.c
index 8942600..4b741aa 100644
--- a/common/test-client.c
+++ b/common/test-client.c
@@ -23,142 +23,64 @@
 #include <config.h>
 #endif
 
-#include <string.h>
-#include <signal.h>
-
+#include <dbus/dbus-glib.h>
 #include <gtk/gtk.h>
 
-#include "client.h"
+#include "connman-client.h"
+
+static ConnmanClient *client;
 
-static void state_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell,
+static void proxy_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell,
 			GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 {
-	GtkTreeIter parent;
-	gboolean active;
-	guint state, signal;
+	DBusGProxy *proxy;
 	gchar *markup;
-	const char *str;
-
-	gtk_tree_model_get(model, iter, CLIENT_COLUMN_ACTIVE, &active,
-					CLIENT_COLUMN_STATE, &state,
-					CLIENT_COLUMN_SIGNAL, &signal, -1);
-
-	if (gtk_tree_model_iter_parent(model, &parent, iter) == TRUE) {
-		markup = g_strdup_printf("%s [%d]",
-				active == TRUE ? "Valid" : "Invalid", signal);
-		g_object_set(cell, "markup", markup, NULL);
-		g_free(markup);
-		return;
-	}
-
-	switch (state) {
-	case CLIENT_STATE_OFF:
-		str = "Off";
-		break;
-	case CLIENT_STATE_ENABLED:
-		str = "Enabled";
-		break;
-	case CLIENT_STATE_SCANNING:
-		str = "Scanning";
-		break;
-	case CLIENT_STATE_CONNECT:
-		str = "Connect";
-		break;
-	case CLIENT_STATE_CONNECTED:
-		str = "Connected";
-		break;
-	case CLIENT_STATE_CARRIER:
-		str = "Carrier";
-		break;
-	case CLIENT_STATE_CONFIGURE:
-		str = "Configure";
-		break;
-	case CLIENT_STATE_READY:
-		str = "Ready";
-		break;
-	case CLIENT_STATE_SHUTDOWN:
-		str = "Shutdown";
-		break;
-	default:
-		str = "Unknown";
-		break;
-	}
-
-	markup = g_strdup_printf("%s\n<small>%d %%\n%s</small>", str,
-				signal, active == TRUE ? "ON" : "OFF");
+
+	gtk_tree_model_get(model, iter, CONNMAN_COLUMN_PROXY, &proxy, -1);
+
+	markup = g_strdup_printf("<b>%s</b>\n"
+					"<span size=\"xx-small\">%s\n\n</span>",
+					dbus_g_proxy_get_interface(proxy),
+						dbus_g_proxy_get_path(proxy));
 	g_object_set(cell, "markup", markup, NULL);
 	g_free(markup);
+
+	g_object_unref(proxy);
 }
 
-static void type_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell,
+static void name_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell,
 			GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 {
-	GtkTreeIter parent;
+	gchar *name, *icon;
 	guint type;
-	gchar *driver, *markup;
-	const char *str;
-
-	if (gtk_tree_model_iter_parent(model, &parent, iter) == TRUE) {
-		g_object_set(cell, "text", NULL, NULL);
-		return;
-	}
-
-	gtk_tree_model_get(model, iter, CLIENT_COLUMN_TYPE, &type,
-					CLIENT_COLUMN_DRIVER, &driver, -1);
-
-	switch (type) {
-	case CLIENT_TYPE_80203:
-		str = "IEEE 802.03";
-		break;
-	case CLIENT_TYPE_80211:
-		str = "IEEE 802.11";
-		break;
-	default:
-		str = "Unknown";
-		break;
-	}
-
-	markup = g_strdup_printf("%s\n<small>%s\n</small>", str, driver);
+	gchar *markup;
+
+	gtk_tree_model_get(model, iter, CONNMAN_COLUMN_NAME, &name,
+					CONNMAN_COLUMN_ICON, &icon,
+					CONNMAN_COLUMN_TYPE, &type, -1);
+
+	markup = g_strdup_printf("Name: %s\nIcon: %s\nType: %d",
+							name, icon, type);
 	g_object_set(cell, "markup", markup, NULL);
 	g_free(markup);
 
-	g_free(driver);
+	g_free(icon);
+	g_free(name);
 }
 
-static void policy_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell,
+static void status_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell,
 			GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 {
-	GtkTreeIter parent;
-	guint policy;
+	gboolean enabled, inrange, remember;
 	gchar *markup;
-	const char *str;
-
-	if (gtk_tree_model_iter_parent(model, &parent, iter) == TRUE) {
-		g_object_set(cell, "text", NULL, NULL);
-		return;
-	}
-
-	gtk_tree_model_get(model, iter, CLIENT_COLUMN_POLICY, &policy, -1);
-
-	switch (policy) {
-	case CLIENT_POLICY_OFF:
-		str = "Off";
-		break;
-	case CLIENT_POLICY_IGNORE:
-		str = "Ignore";
-		break;
-	case CLIENT_POLICY_AUTO:
-		str = "Automatic";
-		break;
-	case CLIENT_POLICY_ASK:
-		str = "Ask User";
-		break;
-	default:
-		str = "Unknown";
-		break;
-	}
-
-	markup = g_strdup_printf("%s\n<small>\n</small>", str);
+
+	gtk_tree_model_get(model, iter, CONNMAN_COLUMN_ENABLED, &enabled,
+					CONNMAN_COLUMN_INRANGE, &inrange,
+					CONNMAN_COLUMN_REMEMBER, &remember, -1);
+
+	markup = g_strdup_printf("Enabled: %d\n"
+					"InRange: %d\nRemember: %d",
+						enabled, inrange, remember);
 	g_object_set(cell, "markup", markup, NULL);
 	g_free(markup);
 }
@@ -166,108 +88,20 @@ static void policy_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell,
 static void network_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell,
 			GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
 {
-	GtkTreeIter parent;
-	gchar *essid, *psk, *markup;
-
-	if (gtk_tree_model_iter_parent(model, &parent, iter) == TRUE) {
-		gtk_tree_model_get(model, iter,
-				CLIENT_COLUMN_NETWORK_ESSID, &essid, -1);
-		g_object_set(cell, "text", essid, NULL);
-		g_free(essid);
-		return;
-	}
-
-	gtk_tree_model_get(model, iter, CLIENT_COLUMN_NETWORK_ESSID, &essid,
-					CLIENT_COLUMN_NETWORK_PSK, &psk, -1);
-
-	if (essid != NULL)
-		markup = g_strdup_printf("%s\n<small>PSK: %s\n</small>",
-				essid, psk && *psk != '\0' ? "Yes" : "No");
-	else
-		markup = g_strdup_printf("\n<small>\n</small>");
-	g_object_set(cell, "markup", markup, NULL);
-	g_free(markup);
+	guint strength, security;
+	gchar *secret;
+	gchar *markup;
 
-	g_free(essid);
-	g_free(psk);
-}
+	gtk_tree_model_get(model, iter, CONNMAN_COLUMN_STRENGTH, &strength,
+					CONNMAN_COLUMN_SECURITY, &security,
+					CONNMAN_COLUMN_PASSPHRASE, &secret, -1);
 
-static void ipv4_to_text(GtkTreeViewColumn *column, GtkCellRenderer *cell,
-			GtkTreeModel *model, GtkTreeIter *iter, gpointer data)
-{
-	GtkTreeIter parent;
-	guint state, method;
-	gchar *address, *netmask, *gateway, *markup;
-	const char *str;
-
-	if (gtk_tree_model_iter_parent(model, &parent, iter) == TRUE) {
-		g_object_set(cell, "text", NULL, NULL);
-		return;
-	}
-
-	gtk_tree_model_get(model, iter, CLIENT_COLUMN_STATE, &state,
-				CLIENT_COLUMN_IPV4_METHOD, &method,
-				CLIENT_COLUMN_IPV4_ADDRESS, &address,
-				CLIENT_COLUMN_IPV4_NETMASK, &netmask,
-				CLIENT_COLUMN_IPV4_GATEWAY, &gateway, -1);
-
-	switch (method) {
-	case CLIENT_IPV4_METHOD_OFF:
-		str = "Off";
-		break;
-	case CLIENT_IPV4_METHOD_STATIC:
-		str = "Manually";
-		break;
-	case CLIENT_IPV4_METHOD_DHCP:
-		str = "DHCP";
-		break;
-	default:
-		str = "Unknown";
-		break;
-	}
-
-	if (address != NULL && state == CLIENT_STATE_READY)
-		markup = g_strdup_printf("%s\n<small>%s/%s\ngw %s</small>",
-					str, address, netmask, gateway);
-	else
-		markup = g_strdup_printf("%s\n<small>\n</small>", str);
+	markup = g_strdup_printf("Strength: %d\nSecurity: %d\nSecret: %s",
+						strength, security, secret);
 	g_object_set(cell, "markup", markup, NULL);
 	g_free(markup);
 
-	g_free(address);
-	g_free(netmask);
-	g_free(gateway);
-}
-
-static void select_callback(GtkTreeSelection *selection, gpointer user_data)
-{
-	GtkTreeModel *model;
-	GtkTreeIter iter;
-	GtkWidget *widget;
-	gboolean selected;
-	gchar *network = NULL, *passphrase = NULL;
-
-	selected = gtk_tree_selection_get_selected(selection, &model, &iter);
-	if (selected == TRUE)
-		gtk_tree_model_get(model, &iter,
-				CLIENT_COLUMN_NETWORK_ESSID, &network,
-				CLIENT_COLUMN_NETWORK_PSK, &passphrase, -1);
-
-	widget = g_object_get_data(G_OBJECT(selection), "network");
-	if (widget != NULL) {
-		gtk_combo_box_remove_text(GTK_COMBO_BOX(widget), 0);
-		gtk_combo_box_insert_text(GTK_COMBO_BOX(widget), 0,
-						network ? network : "");
-		gtk_combo_box_set_active(GTK_COMBO_BOX(widget), 0);
-	}
-
-	widget = g_object_get_data(G_OBJECT(selection), "passphrase");
-	if (widget != NULL)
-		gtk_entry_set_text(GTK_ENTRY(widget),
-						passphrase ? passphrase : "");
-
-	g_free(network);
-	g_free(passphrase);
+	g_free(secret);
 }
 
 static GtkWidget *create_tree(void)
@@ -281,188 +115,41 @@ static GtkWidget *create_tree(void)
 	gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
 
 	gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), -1,
-				"State", gtk_cell_renderer_text_new(),
-					state_to_text, NULL, NULL);
+				"Proxy", gtk_cell_renderer_text_new(),
+					proxy_to_text, NULL, NULL);
 
 	gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), -1,
-				"Type", gtk_cell_renderer_text_new(),
-					type_to_text, NULL, NULL);
-
-#if 0
-	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(tree), -1,
-				"Driver", gtk_cell_renderer_text_new(),
-					"text", CLIENT_COLUMN_DRIVER, NULL);
-
-	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(tree), -1,
-				"Vendor", gtk_cell_renderer_text_new(),
-					"text", CLIENT_COLUMN_VENDOR, NULL);
-
-	gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(tree), -1,
-				"Product", gtk_cell_renderer_text_new(),
-					"text", CLIENT_COLUMN_PRODUCT, NULL);
-#endif
+				"Name", gtk_cell_renderer_text_new(),
+					name_to_text, NULL, NULL);
 
 	gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), -1,
-				"Policy", gtk_cell_renderer_text_new(),
-					policy_to_text, NULL, NULL);
+				"Status", gtk_cell_renderer_text_new(),
+					status_to_text, NULL, NULL);
 
 	gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), -1,
 				"Network", gtk_cell_renderer_text_new(),
-					network_to_text, NULL, NULL);\
-
-	gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), -1,
-				"IPv4", gtk_cell_renderer_text_new(),
-					ipv4_to_text, NULL, NULL);
+					network_to_text, NULL, NULL);
 
-	model = client_get_model();
+	model = connman_client_get_model(client);
 	gtk_tree_view_set_model(GTK_TREE_VIEW(tree), model);
 	g_object_unref(model);
 
 	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
 	gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
 
-	g_signal_connect(G_OBJECT(selection), "changed",
-					G_CALLBACK(select_callback), NULL);
-
 	gtk_tree_view_expand_all(GTK_TREE_VIEW(tree));
 
 	return tree;
 }
 
-static void policy_off(GtkWidget *button, gpointer user_data)
-{
-	GtkTreeSelection *selection = user_data;
-	GtkTreeModel *model;
-	GtkTreeIter iter;
-	gchar *index;
-
-	if (gtk_tree_selection_get_selected(selection,
-						&model, &iter) == FALSE)
-		return;
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	client_set_policy(index, CLIENT_POLICY_OFF);
-}
-
-static void policy_ignore(GtkWidget *button, gpointer user_data)
-{
-	GtkTreeSelection *selection = user_data;
-	GtkTreeModel *model;
-	GtkTreeIter iter;
-	gchar *index;
-
-	if (gtk_tree_selection_get_selected(selection,
-						&model, &iter) == FALSE)
-		return;
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	client_set_policy(index, CLIENT_POLICY_IGNORE);
-}
-
-static void policy_auto(GtkWidget *button, gpointer user_data)
-{
-	GtkTreeSelection *selection = user_data;
-	GtkTreeModel *model;
-	GtkTreeIter iter;
-	gchar *index;
-
-	if (gtk_tree_selection_get_selected(selection,
-						&model, &iter) == FALSE)
-		return;
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	client_set_policy(index, CLIENT_POLICY_AUTO);
-}
-
-static void policy_ask(GtkWidget *button, gpointer user_data)
-{
-	GtkTreeSelection *selection = user_data;
-	GtkTreeModel *model;
-	GtkTreeIter iter;
-	gchar *index;
-
-	if (gtk_tree_selection_get_selected(selection,
-						&model, &iter) == FALSE)
-		return;
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	client_set_policy(index, CLIENT_POLICY_ASK);
-}
-
-static void dhcp_callback(GtkWidget *button, gpointer user_data)
-{
-	GtkTreeSelection *selection = user_data;
-	GtkTreeModel *model;
-	GtkTreeIter iter;
-	gchar *index;
-
-	if (gtk_tree_selection_get_selected(selection,
-						&model, &iter) == FALSE)
-		return;
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	client_set_ipv4(index, CLIENT_IPV4_METHOD_DHCP);
-}
-
-static void static_callback(GtkWidget *button, gpointer user_data)
-{
-	GtkTreeSelection *selection = user_data;
-	GtkTreeModel *model;
-	GtkTreeIter iter;
-	gchar *index;
-
-	if (gtk_tree_selection_get_selected(selection,
-						&model, &iter) == FALSE)
-		return;
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	client_set_ipv4(index, CLIENT_IPV4_METHOD_STATIC);
-}
-
-static void network_callback(GtkWidget *button, gpointer user_data)
-{
-	GtkTreeSelection *selection = user_data;
-	GtkTreeModel *model;
-	GtkTreeIter iter;
-	GtkWidget *widget;
-	gchar *index, *network;
-	const gchar *passphrase;
-
-	if (gtk_tree_selection_get_selected(selection,
-						&model, &iter) == FALSE)
-		return;
-
-	index = gtk_tree_model_get_string_from_iter(model, &iter);
-
-	widget = g_object_get_data(G_OBJECT(selection), "network");
-	if (widget == NULL)
-		return;
-
-	network = gtk_combo_box_get_active_text(GTK_COMBO_BOX(widget));
-
-	widget = g_object_get_data(G_OBJECT(selection), "passphrase");
-	if (widget == NULL)
-		return;
-
-	passphrase = gtk_entry_get_text(GTK_ENTRY(widget));
-
-	client_set_network(index, network, passphrase);
-
-	g_free(network);
-}
-
-static void delete_callback(GtkWidget *window, GdkEvent *event,
+static gboolean delete_callback(GtkWidget *window, GdkEvent *event,
 							gpointer user_data)
 {
 	gtk_widget_destroy(GTK_WIDGET(window));
 
 	gtk_main_quit();
+
+	return FALSE;
 }
 
 static void close_callback(GtkWidget *button, gpointer user_data)
@@ -478,14 +165,10 @@ static GtkWidget *create_window(void)
 {
 	GtkWidget *window;
 	GtkWidget *mainbox;
-	GtkWidget *hbox;
-	GtkWidget *vbox;
 	GtkWidget *tree;
 	GtkWidget *scrolled;
 	GtkWidget *buttonbox;
 	GtkWidget *button;
-	GtkWidget *combo;
-	GtkWidget *entry;
 	GtkTreeSelection *selection;
 
 	tree = create_tree();
@@ -494,7 +177,7 @@ static GtkWidget *create_window(void)
 	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 	gtk_window_set_title(GTK_WINDOW(window), "Client Test");
 	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
-	gtk_window_set_default_size(GTK_WINDOW(window), 600, 400);
+	gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
 	g_signal_connect(G_OBJECT(window), "delete-event",
 					G_CALLBACK(delete_callback), NULL);
 
@@ -509,68 +192,6 @@ static GtkWidget *create_window(void)
 							GTK_SHADOW_OUT);
 	gtk_box_pack_start(GTK_BOX(mainbox), scrolled, TRUE, TRUE, 0);
 
-	hbox = gtk_hbox_new(FALSE, 8);
-	gtk_box_pack_start(GTK_BOX(mainbox), hbox, FALSE, FALSE, 0);
-
-	buttonbox = gtk_vbutton_box_new();
-	gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox),
-						GTK_BUTTONBOX_START);
-	gtk_box_pack_start(GTK_BOX(hbox), buttonbox, FALSE, FALSE, 0);
-
-	button = gtk_button_new_with_label("Policy Off");
-	gtk_container_add(GTK_CONTAINER(buttonbox), button);
-	g_signal_connect(G_OBJECT(button), "clicked",
-				G_CALLBACK(policy_off), selection);
-
-	button = gtk_button_new_with_label("Policy Ignore");
-	gtk_container_add(GTK_CONTAINER(buttonbox), button);
-	g_signal_connect(G_OBJECT(button), "clicked",
-				G_CALLBACK(policy_ignore), selection);
-
-	button = gtk_button_new_with_label("Policy Auto");
-	gtk_container_add(GTK_CONTAINER(buttonbox), button);
-	g_signal_connect(G_OBJECT(button), "clicked",
-				G_CALLBACK(policy_auto), selection);
-
-	button = gtk_button_new_with_label("Policy Ask");
-	gtk_container_add(GTK_CONTAINER(buttonbox), button);
-	g_signal_connect(G_OBJECT(button), "clicked",
-				G_CALLBACK(policy_ask), selection);
-
-	buttonbox = gtk_vbutton_box_new();
-	gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox),
-						GTK_BUTTONBOX_START);
-	gtk_box_pack_start(GTK_BOX(hbox), buttonbox, FALSE, FALSE, 0);
-
-	button = gtk_button_new_with_label("DHCP");
-	gtk_container_add(GTK_CONTAINER(buttonbox), button);
-	g_signal_connect(G_OBJECT(button), "clicked",
-				G_CALLBACK(dhcp_callback), selection);
-
-	button = gtk_button_new_with_label("Static IP");
-	gtk_container_add(GTK_CONTAINER(buttonbox), button);
-	g_signal_connect(G_OBJECT(button), "clicked",
-				G_CALLBACK(static_callback), selection);
-
-	vbox = gtk_vbox_new(FALSE, 0);
-	gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
-
-	combo = gtk_combo_box_entry_new_text();
-	gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "");
-	gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "Guest");
-	gtk_box_pack_start(GTK_BOX(vbox), combo, FALSE, FALSE, 0);
-	g_object_set_data(G_OBJECT(selection), "network", combo);
-
-	entry = gtk_entry_new();
-	gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
-	gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
-	g_object_set_data(G_OBJECT(selection), "passphrase", entry);
-
-	button = gtk_button_new_with_label("Set Network");
-	gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0);
-	g_signal_connect(G_OBJECT(button), "clicked",
-				G_CALLBACK(network_callback), selection);
-
 	buttonbox = gtk_hbutton_box_new();
 	gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox),
 						GTK_BUTTONBOX_END);
@@ -588,31 +209,19 @@ static GtkWidget *create_window(void)
 	return window;
 }
 
-static void sig_term(int sig)
-{
-	gtk_main_quit();
-}
-
 int main(int argc, char *argv[])
 {
-	struct sigaction sa;
-
 	gtk_init(&argc, &argv);
 
-	gtk_window_set_default_icon_name("stock_internet");
+	client = connman_client_new();
 
-	client_init(NULL);
+	gtk_window_set_default_icon_name("network-wireless");
 
 	create_window();
 
-	memset(&sa, 0, sizeof(sa));
-	sa.sa_handler = sig_term;
-	sigaction(SIGINT, &sa, NULL);
-	sigaction(SIGTERM, &sa, NULL);
-
 	gtk_main();
 
-	client_cleanup();
+	g_object_unref(client);
 
 	return 0;
 }
diff --git a/configure.ac b/configure.ac
index 141a4ca..122cde5 100644
--- a/configure.ac
+++ b/configure.ac
@@ -34,7 +34,7 @@ AC_ARG_ENABLE(debug, AC_HELP_STRING([--enable-debug],
 			[enable compiling with debugging information]), [
 	if (test "${enableval}" = "yes" &&
 				test "${ac_cv_prog_cc_g}" = "yes"); then
-		CFLAGS="$CFLAGS -g -O0"
+		CFLAGS="$CFLAGS -g -O0 -DDEBUG"
 	fi
 ])