2007-03-16 Tambet Ingo <tambet@ximian.com>

	* libnm-glib/nm-device.c (nm_device_get_description): Implement.

	* libnm-glib/nm-client.c (nm_client_manager_is_running): Implement. Also add a
	"manager-running" signal that notifies the appearance/disappearance of NM.
	(nm_client_sleep): Implement.

	* libnm-glib/nm-device.c:
	* libnm-glib/nm-device-802-11-wireless.c: 
	* libnm-glib/nm-device-802-3-ethernet.c: 

	Don't inherit from DBusGProxy, add a proxy to private
	data. The reason is, classes inherited from NMDevice wouldn't get any dbus signals
	for anything but their own dbus interface. DBusGProxy objects support only one
	interfaces and to work around this, NMDevice has spearate proxy for each dbus
	interface. The nice side effect of this change is that we do not create a new
	DBusGProxy object for each property access.



git-svn-id: http://svn-archive.gnome.org/svn/NetworkManager/trunk@2479 4912f4e0-d625-0410-9fb7-b9a5a253dbdc

12 files changed, 684 insertions, 207 deletions

diff --git a/ChangeLog b/ChangeLog
index 38bad3542f..a53b38dddb 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,22 @@
+2007-03-16  Tambet Ingo  <tambet@ximian.com>
+
+	* libnm-glib/nm-device.c (nm_device_get_description): Implement.
+
+	* libnm-glib/nm-client.c (nm_client_manager_is_running): Implement. Also add a
+	"manager-running" signal that notifies the appearance/disappearance of NM.
+	(nm_client_sleep): Implement.
+
+	* libnm-glib/nm-device.c:
+	* libnm-glib/nm-device-802-11-wireless.c: 
+	* libnm-glib/nm-device-802-3-ethernet.c: 
+
+	Don't inherit from DBusGProxy, add a proxy to private
+	data. The reason is, classes inherited from NMDevice wouldn't get any dbus signals
+	for anything but their own dbus interface. DBusGProxy objects support only one
+	interfaces and to work around this, NMDevice has spearate proxy for each dbus
+	interface. The nice side effect of this change is that we do not create a new
+	DBusGProxy object for each property access.
+
 2007-03-15  Tambet Ingo  <tambet@ximian.com>
 
 	* src/nm-device-802-11-wireless.c (constructor): Initialize the iw_ext structures
diff --git a/libnm-glib/libnm-glib-test.c b/libnm-glib/libnm-glib-test.c
index 4bd657016d..633b8a16b9 100644
--- a/libnm-glib/libnm-glib-test.c
+++ b/libnm-glib/libnm-glib-test.c
@@ -298,6 +298,20 @@ do_stuff (gpointer user_data)
 	return FALSE;
 }
 
+static void
+manager_running (NMClient *client, gboolean running, gpointer user_data)
+{
+	if (running) {
+		g_print ("NM appeared\n");
+		/* 	test_wireless_enabled (client); */
+		test_get_state (client);
+		test_devices (client);
+
+		/* 	g_idle_add (do_stuff, client); */
+	} else
+		g_print ("NM disappeared\n");
+}
+
 int
 main (int argc, char *argv[])
 {
@@ -310,17 +324,14 @@ main (int argc, char *argv[])
 		exit (1);
 	}
 
-/* 	test_wireless_enabled (client); */
-	test_get_state (client);
-	test_devices (client);
+	g_signal_connect (client, "manager-running", G_CALLBACK (manager_running), NULL);
+	manager_running (client, nm_client_manager_is_running (client), NULL);
 
 	g_signal_connect (client, "device-added",
 					  G_CALLBACK (device_added_cb), NULL);
 	g_signal_connect (client, "device-removed",
 					  G_CALLBACK (device_removed_cb), NULL);
 
-/* 	g_idle_add (do_stuff, client); */
-
 	g_main_loop_run (g_main_loop_new (NULL, FALSE));
 
 	g_object_unref (client);
diff --git a/libnm-glib/nm-client.c b/libnm-glib/nm-client.c
index c214cf4966..c08cae8cb8 100644
--- a/libnm-glib/nm-client.c
+++ b/libnm-glib/nm-client.c
@@ -1,4 +1,5 @@
 #include <dbus/dbus-glib.h>
+#include <string.h>
 #include "nm-client.h"
 #include "nm-device-802-3-ethernet.h"
 #include "nm-device-802-11-wireless.h"
@@ -11,12 +12,15 @@ G_DEFINE_TYPE (NMClient, nm_client, DBUS_TYPE_G_PROXY)
 #define NM_CLIENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_CLIENT, NMClientPrivate))
 
 typedef struct {
+	DBusGProxy *bus_proxy;
+	gboolean manager_running;
 	NMState state;
 	gboolean have_device_list;
 	GHashTable *devices;
 } NMClientPrivate;
 
 enum {
+	MANAGER_RUNNING,
 	DEVICE_ADDED,
 	DEVICE_REMOVED,
 	STATE_CHANGE,
@@ -26,6 +30,12 @@ enum {
 
 static guint signals[LAST_SIGNAL] = { 0 };
 
+static void proxy_name_owner_changed (DBusGProxy *proxy,
+									  const char *name,
+									  const char *old_owner,
+									  const char *new_owner,
+									  gpointer user_data);
+
 static void client_state_change_proxy (DBusGProxy *proxy, guint state, gpointer user_data);
 static void client_device_added_proxy (DBusGProxy *proxy, char *path, gpointer user_data);
 static void client_device_removed_proxy (DBusGProxy *proxy, char *path, gpointer user_data);
@@ -46,10 +56,23 @@ finalize (GObject *object)
 {
 	NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (object);
 
+	g_object_unref (priv->bus_proxy);
 	g_hash_table_destroy (priv->devices);
 }
 
 static void
+manager_running (NMClient *client, gboolean running)
+{
+	if (!running) {
+		NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (client);
+
+		priv->state = NM_STATE_UNKNOWN;
+		g_hash_table_remove_all (priv->devices);
+		priv->have_device_list = FALSE;
+	}
+}
+
+static void
 nm_client_class_init (NMClientClass *client_class)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (client_class);
@@ -59,7 +82,18 @@ nm_client_class_init (NMClientClass *client_class)
 	/* virtual methods */
 	object_class->finalize = finalize;
 
+	client_class->manager_running = manager_running;
+
 	/* signals */
+	signals[MANAGER_RUNNING] =
+		g_signal_new ("manager-running",
+					  G_OBJECT_CLASS_TYPE (object_class),
+					  G_SIGNAL_RUN_FIRST,
+					  G_STRUCT_OFFSET (NMClientClass, manager_running),
+					  NULL, NULL,
+					  g_cclosure_marshal_VOID__BOOLEAN,
+					  G_TYPE_NONE, 1,
+					  G_TYPE_BOOLEAN);
 	signals[DEVICE_ADDED] =
 		g_signal_new ("device-added",
 					  G_OBJECT_CLASS_TYPE (object_class),
@@ -92,6 +126,36 @@ nm_client_class_init (NMClientClass *client_class)
 
 }
 
+static void
+setup_bus_listener (NMClient *client, DBusGConnection *connection)
+{
+	NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (client);
+	GError *err = NULL;
+
+	priv->bus_proxy = dbus_g_proxy_new_for_name (connection,
+												 "org.freedesktop.DBus",
+												 "/org/freedesktop/DBus",
+												 "org.freedesktop.DBus");
+
+	dbus_g_proxy_add_signal (priv->bus_proxy, "NameOwnerChanged",
+							 G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
+							 G_TYPE_INVALID);
+	dbus_g_proxy_connect_signal (priv->bus_proxy,
+								 "NameOwnerChanged",
+								 G_CALLBACK (proxy_name_owner_changed),
+								 client, NULL);
+
+	if (!dbus_g_proxy_call (priv->bus_proxy,
+							"NameHasOwner", &err,
+							G_TYPE_STRING, NM_DBUS_SERVICE,
+							G_TYPE_INVALID,
+							G_TYPE_BOOLEAN, &priv->manager_running,
+							G_TYPE_INVALID)) {
+		g_warning ("Error on NameHasOwner DBUS call: %s", err->message);
+		g_error_free (err);
+	}
+}
+
 NMClient *
 nm_client_new (void)
 {
@@ -137,10 +201,31 @@ nm_client_new (void)
 								 NULL,
 								 NULL);
 
+	setup_bus_listener (client, connection);
+
 	return client;
 }
 
 static void
+proxy_name_owner_changed (DBusGProxy *proxy,
+						  const char *name,
+						  const char *old_owner,
+						  const char *new_owner,
+						  gpointer user_data)
+{
+	if (name && !strcmp (name, NM_DBUS_SERVICE)) {
+		NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (user_data);
+
+		if (new_owner && strlen (new_owner) > 0)
+			priv->manager_running = TRUE;
+		else
+			priv->manager_running = FALSE;
+
+		g_signal_emit (NM_CLIENT (user_data), signals[MANAGER_RUNNING], 0, priv->manager_running);
+	}
+}
+
+static void
 client_state_change_proxy (DBusGProxy *proxy, guint state, gpointer user_data)
 {
 	NMClient *client = NM_CLIENT (proxy);
@@ -208,6 +293,14 @@ client_device_removed_proxy (DBusGProxy *proxy, char *path, gpointer user_data)
 	}
 }
 
+gboolean
+nm_client_manager_is_running (NMClient *client)
+{
+	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
+
+	return NM_CLIENT_GET_PRIVATE (client)->manager_running;
+}
+
 static void
 devices_to_slist (gpointer key, gpointer value, gpointer user_data)
 {
@@ -308,3 +401,17 @@ nm_client_get_state (NMClient *client)
 
 	return priv->state;
 }
+
+void
+nm_client_sleep (NMClient *client, gboolean sleep)
+{
+	GError *err = NULL;
+
+	g_return_if_fail (NM_IS_CLIENT (client));
+
+	if (!org_freedesktop_NetworkManager_sleep (DBUS_G_PROXY (client), sleep, &err)) {
+		g_warning ("Error in sleep: %s", err->message);
+		g_error_free (err);
+	}
+}
+
diff --git a/libnm-glib/nm-client.h b/libnm-glib/nm-client.h
index c2247775c1..24d63d16d0 100644
--- a/libnm-glib/nm-client.h
+++ b/libnm-glib/nm-client.h
@@ -23,6 +23,7 @@ typedef struct {
 	DBusGProxyClass parent;
 
 	/* Signals */
+	void (*manager_running) (NMClient *client, gboolean running);
 	void (*device_added) (NMClient *client, NMDevice *device);
 	void (*device_removed) (NMClient *client, NMDevice *device);
 	void (*state_change) (NMClient *client, NMState state);
@@ -33,10 +34,11 @@ GType nm_client_get_type (void);
 
 NMClient *nm_client_new                  (void);
 
+gboolean  nm_client_manager_is_running   (NMClient *client);
 GSList   *nm_client_get_devices          (NMClient *client);
-
 gboolean  nm_client_wireless_get_enabled (NMClient *client);
 void      nm_client_wireless_set_enabled (NMClient *client, gboolean enabled);
 NMState   nm_client_get_state            (NMClient *client);
+void      nm_client_sleep                (NMClient *client, gboolean sleep);
 
 #endif /* NM_CLIENT_H */
diff --git a/libnm-glib/nm-device-802-11-wireless.c b/libnm-glib/nm-device-802-11-wireless.c
index d511ab340e..f004acf091 100644
--- a/libnm-glib/nm-device-802-11-wireless.c
+++ b/libnm-glib/nm-device-802-11-wireless.c
@@ -9,8 +9,11 @@ G_DEFINE_TYPE (NMDevice80211Wireless, nm_device_802_11_wireless, NM_TYPE_DEVICE)
 #define NM_DEVICE_802_11_WIRELESS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_DEVICE_802_11_WIRELESS, NMDevice80211WirelessPrivate))
 
 typedef struct {
+	DBusGProxy *wireless_proxy;
 	gboolean have_network_list;
 	GHashTable *networks;
+
+	gboolean disposed;
 } NMDevice80211WirelessPrivate;
 
 enum {
@@ -30,17 +33,69 @@ nm_device_802_11_wireless_init (NMDevice80211Wireless *device)
 {
 	NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
 
+	priv->disposed = FALSE;
 	priv->networks = g_hash_table_new_full (g_str_hash, g_str_equal,
 											(GDestroyNotify) g_free,
 											(GDestroyNotify) g_object_unref);
 }
 
+static GObject*
+constructor (GType type,
+			 guint n_construct_params,
+			 GObjectConstructParam *construct_params)
+{
+	GObject *object;
+	NMDevice80211WirelessPrivate *priv;
+
+	object = G_OBJECT_CLASS (nm_device_802_11_wireless_parent_class)->constructor (type,
+																				   n_construct_params,
+																				   construct_params);
+	if (!object)
+		return NULL;
+
+	priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
+
+	priv->wireless_proxy = dbus_g_proxy_new_for_name (nm_device_get_connection (NM_DEVICE (object)),
+													  NM_DBUS_SERVICE,
+													  nm_device_get_path (NM_DEVICE (object)),
+													  NM_DBUS_INTERFACE_DEVICE_WIRELESS);
+
+	dbus_g_proxy_add_signal (priv->wireless_proxy, "NetworkAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
+	dbus_g_proxy_connect_signal (priv->wireless_proxy, "NetworkAdded",
+								 G_CALLBACK (network_added_proxy),
+								 object, NULL);
+
+	dbus_g_proxy_add_signal (priv->wireless_proxy, "NetworkRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
+	dbus_g_proxy_connect_signal (priv->wireless_proxy, "NetworkRemoved",
+								 G_CALLBACK (network_removed_proxy),
+								 object, NULL);
+	
+	return object;
+}
+
+static void
+dispose (GObject *object)
+{
+	NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
+
+	if (priv->disposed)
+		return;
+
+	priv->disposed = TRUE;
+
+	g_object_unref (priv->wireless_proxy);
+
+	G_OBJECT_CLASS (nm_device_802_11_wireless_parent_class)->dispose (object);
+}
+
 static void
 finalize (GObject *object)
 {
 	NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
 
 	g_hash_table_destroy (priv->networks);
+
+	G_OBJECT_CLASS (nm_device_802_11_wireless_parent_class)->finalize (object);
 }
 
 static void
@@ -51,6 +106,8 @@ nm_device_802_11_wireless_class_init (NMDevice80211WirelessClass *device_class)
 	g_type_class_add_private (device_class, sizeof (NMDevice80211WirelessPrivate));
 
 	/* virtual methods */
+	object_class->constructor = constructor;
+	object_class->dispose = dispose;
 	object_class->finalize = finalize;
 
 	/* signals */
@@ -78,104 +135,49 @@ nm_device_802_11_wireless_class_init (NMDevice80211WirelessClass *device_class)
 NMDevice80211Wireless *
 nm_device_802_11_wireless_new (DBusGConnection *connection, const char *path)
 {
-	NMDevice80211Wireless *device;
-	DBusGProxy *proxy;
-
 	g_return_val_if_fail (connection != NULL, NULL);
 	g_return_val_if_fail (path != NULL, NULL);
 
-	device = (NMDevice80211Wireless *) g_object_new (NM_TYPE_DEVICE_802_11_WIRELESS,
-													 "name", NM_DBUS_SERVICE,
-													 "path", path, 
-													 "interface", NM_DBUS_INTERFACE_DEVICE_WIRELESS,
-													 "connection", connection,
-													 NULL);
-
-	proxy = DBUS_G_PROXY (device);
-
-	dbus_g_proxy_add_signal (proxy, "NetworkAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
-	dbus_g_proxy_connect_signal (proxy,
-								 "NetworkAdded",
-								 G_CALLBACK (network_added_proxy),
-								 NULL,
-								 NULL);
-
-	dbus_g_proxy_add_signal (proxy, "NetworkRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
-	dbus_g_proxy_connect_signal (proxy,
-								 "NetworkRemoved",
-								 G_CALLBACK (network_removed_proxy),
-								 NULL,
-								 NULL);
-
-	return device;
+	return (NMDevice80211Wireless *) g_object_new (NM_TYPE_DEVICE_802_11_WIRELESS,
+												   NM_DEVICE_CONNECTION, connection,
+												   NM_DEVICE_PATH, path,
+												   NULL);
 }
 
 char *
 nm_device_802_11_wireless_get_hw_address (NMDevice80211Wireless *device)
 {
-	GValue value = {0,};
-	char *address = NULL;
-
 	g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), NULL);
 
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE_WIRELESS,
-							  "HwAddress",
-							  &value))
-		address = g_strdup (g_value_get_string (&value));
-
-	return address;
+	return nm_dbus_get_string_property (nm_device_get_properties_proxy (NM_DEVICE (device)),
+										NM_DBUS_INTERFACE_DEVICE_WIRELESS, "HwAddress");
 }
 
 int
 nm_device_802_11_wireless_get_mode (NMDevice80211Wireless *device)
 {
-	GValue value = {0,};
-	int mode = 0;
-
 	g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), 0);
 
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE_WIRELESS,
-							  "Mode",
-							  &value))
-		mode = g_value_get_int (&value);
-
-	return mode;
+	return nm_dbus_get_int_property (nm_device_get_properties_proxy (NM_DEVICE (device)),
+									 NM_DBUS_INTERFACE_DEVICE_WIRELESS, "Mode");
 }
 
 int
 nm_device_802_11_wireless_get_bitrate (NMDevice80211Wireless *device)
 {
-	GValue value = {0,};
-	int bitrate = 0;
-
 	g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), 0);
 
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE_WIRELESS,
-							  "Bitrate",
-							  &value))
-		bitrate = g_value_get_int (&value);
-
-	return bitrate;
+	return nm_dbus_get_int_property (nm_device_get_properties_proxy (NM_DEVICE (device)),
+									 NM_DBUS_INTERFACE_DEVICE_WIRELESS, "Bitrate");
 }
 
 guint32
 nm_device_802_11_wireless_get_capabilities (NMDevice80211Wireless *device)
 {
-	guint32 caps = 0;
-	GValue value = {0,};
-
-	g_return_val_if_fail (NM_IS_DEVICE (device), 0);
-
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE_WIRELESS,
-							  "WirelessCapabilities",
-							  &value))
-		caps = g_value_get_uint (&value);
+	g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), 0);
 
-	return caps;
+	return nm_dbus_get_uint_property (nm_device_get_properties_proxy (NM_DEVICE (device)),
+									  NM_DBUS_INTERFACE_DEVICE_WIRELESS, "WirelessCapabilities");
 }
 
 static NMAccessPoint *
@@ -186,11 +188,7 @@ get_network (NMDevice80211Wireless *device, const char *path, gboolean create_if
 
 	ap = g_hash_table_lookup (priv->networks, path);
 	if (!ap && create_if_not_found) {
-		DBusGConnection *connection = NULL;
-
-		g_object_get (device, "connection", &connection, NULL);
-		ap = nm_access_point_new (connection, path);
-
+		ap = nm_access_point_new (nm_device_get_connection (NM_DEVICE (device)), path);
 		if (ap)
 			g_hash_table_insert (priv->networks, g_strdup (path), ap);
 	}
@@ -201,17 +199,18 @@ get_network (NMDevice80211Wireless *device, const char *path, gboolean create_if
 NMAccessPoint *
 nm_device_802_11_wireless_get_active_network (NMDevice80211Wireless *device)
 {
-	GValue value = {0,};
+	GError *err = NULL;
+	char *path;
 	NMAccessPoint *ap = NULL;
 
 	g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), NULL);
 
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE_WIRELESS,
-							  "ActiveNetwork",
-							  &value)) {
-		g_assert (G_VALUE_TYPE (&value) == DBUS_TYPE_G_OBJECT_PATH);
-		ap = get_network (device, (const char *) g_value_get_boxed (&value), TRUE);
+	path = nm_dbus_get_object_path_property (nm_device_get_properties_proxy (NM_DEVICE (device)),
+											 NM_DBUS_INTERFACE_DEVICE_WIRELESS,
+											 "ActiveNetwork");
+	if (path) {
+		ap = get_network (device, path, TRUE);
+		g_free (path);
 	}
 
 	return ap;
@@ -242,7 +241,9 @@ nm_device_802_11_wireless_get_networks (NMDevice80211Wireless *device)
 		return list;
 	}
 
-	if (!org_freedesktop_NetworkManager_Device_Wireless_get_active_networks (DBUS_G_PROXY (device), &array, &err)) {
+	if (!org_freedesktop_NetworkManager_Device_Wireless_get_active_networks
+		(NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device)->wireless_proxy, &array, &err)) {
+
 		g_warning ("Error in get_networks: %s", err->message);
 		g_error_free (err);
 	} else {
@@ -273,10 +274,10 @@ nm_device_802_11_wireless_activate (NMDevice80211Wireless *device,
 	g_return_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device));
 	g_return_if_fail (NM_IS_ACCESS_POINT (ap));
 
-	if (!org_freedesktop_NetworkManager_Device_Wireless_activate (DBUS_G_PROXY (device),
-																  dbus_g_proxy_get_path (DBUS_G_PROXY (ap)),
-																  user_requested,
-																  &err)) {
+	if (!org_freedesktop_NetworkManager_Device_Wireless_activate
+		(NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device)->wireless_proxy,
+		 dbus_g_proxy_get_path (DBUS_G_PROXY (ap)), user_requested, &err)) {
+
 		g_warning ("Error in wireless_activate: %s", err->message);
 		g_error_free (err);
 	}
@@ -285,7 +286,7 @@ nm_device_802_11_wireless_activate (NMDevice80211Wireless *device,
 static void
 network_added_proxy (DBusGProxy *proxy, char *path, gpointer user_data)
 {
-	NMDevice80211Wireless *device = NM_DEVICE_802_11_WIRELESS (proxy);
+	NMDevice80211Wireless *device = NM_DEVICE_802_11_WIRELESS (user_data);
 	NMAccessPoint *ap;
 
 	ap = get_network (device, path, TRUE);
@@ -296,7 +297,7 @@ network_added_proxy (DBusGProxy *proxy, char *path, gpointer user_data)
 static void
 network_removed_proxy (DBusGProxy *proxy, char *path, gpointer user_data)
 {
-	NMDevice80211Wireless *device = NM_DEVICE_802_11_WIRELESS (proxy);
+	NMDevice80211Wireless *device = NM_DEVICE_802_11_WIRELESS (user_data);
 	NMAccessPoint *ap;
 
 	ap = get_network (device, path, FALSE);
diff --git a/libnm-glib/nm-device-802-3-ethernet.c b/libnm-glib/nm-device-802-3-ethernet.c
index a51402865f..1c0188833d 100644
--- a/libnm-glib/nm-device-802-3-ethernet.c
+++ b/libnm-glib/nm-device-802-3-ethernet.c
@@ -6,14 +6,71 @@
 
 G_DEFINE_TYPE (NMDevice8023Ethernet, nm_device_802_3_ethernet, NM_TYPE_DEVICE)
 
+#define NM_DEVICE_802_3_ETHERNET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_DEVICE_802_3_ETHERNET, NMDevice8023EthernetPrivate))
+
+typedef struct {
+	DBusGProxy *ethernet_proxy;
+
+	gboolean disposed;
+} NMDevice8023EthernetPrivate;
+
+
 static void
 nm_device_802_3_ethernet_init (NMDevice8023Ethernet *device)
 {
+	NMDevice8023EthernetPrivate *priv = NM_DEVICE_802_3_ETHERNET_GET_PRIVATE (device);
+
+	priv->disposed = FALSE;
+}
+
+static GObject*
+constructor (GType type,
+			 guint n_construct_params,
+			 GObjectConstructParam *construct_params)
+{
+	GObject *object;
+	NMDevice8023EthernetPrivate *priv;
+
+	object = G_OBJECT_CLASS (nm_device_802_3_ethernet_parent_class)->constructor (type,
+																				  n_construct_params,
+																				  construct_params);
+	if (!object)
+		return NULL;
+
+	priv = NM_DEVICE_802_3_ETHERNET_GET_PRIVATE (object);
+
+	priv->ethernet_proxy = dbus_g_proxy_new_for_name (nm_device_get_connection (NM_DEVICE (object)),
+													  NM_DBUS_SERVICE,
+													  nm_device_get_path (NM_DEVICE (object)),
+													  NM_DBUS_INTERFACE_DEVICE_WIRED);
+	return object;
+}
+
+static void
+dispose (GObject *object)
+{
+	NMDevice8023EthernetPrivate *priv = NM_DEVICE_802_3_ETHERNET_GET_PRIVATE (object);
+
+	if (priv->disposed)
+		return;
+
+	priv->disposed = TRUE;
+
+	g_object_unref (priv->ethernet_proxy);
+
+	G_OBJECT_CLASS (nm_device_802_3_ethernet_parent_class)->dispose (object);
 }
 
 static void
 nm_device_802_3_ethernet_class_init (NMDevice8023EthernetClass *device_class)
 {
+	GObjectClass *object_class = G_OBJECT_CLASS (device_class);
+
+	g_type_class_add_private (device_class, sizeof (NMDevice8023EthernetPrivate));
+
+	/* virtual methods */
+	object_class->constructor = constructor;
+	object_class->dispose = dispose;
 }
 
 NMDevice8023Ethernet *
@@ -23,45 +80,27 @@ nm_device_802_3_ethernet_new (DBusGConnection *connection, const char *path)
 	g_return_val_if_fail (path != NULL, NULL);
 
 	return (NMDevice8023Ethernet *) g_object_new (NM_TYPE_DEVICE_802_3_ETHERNET,
-												  "name", NM_DBUS_SERVICE,
-												  "path", path, 
-												  "interface",  NM_DBUS_INTERFACE_DEVICE_WIRED,
-												  "connection", connection,
+												  NM_DEVICE_CONNECTION, connection,
+												  NM_DEVICE_PATH, path,
 												  NULL);
 }
 
 int
 nm_device_802_3_ethernet_get_speed (NMDevice8023Ethernet *device)
 {
-	int speed = 0;
-	GValue value = {0,};
-
 	g_return_val_if_fail (NM_IS_DEVICE_802_3_ETHERNET (device), 0);
 
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE_WIRED,
-							  "Speed",
-							  &value))
-		speed = g_value_get_int (&value);
-
-	return speed;
+	return nm_dbus_get_int_property (nm_device_get_properties_proxy (NM_DEVICE (device)),
+									 NM_DBUS_INTERFACE_DEVICE_WIRED, "Speed");
 }
 
 char *
 nm_device_802_3_ethernet_get_hw_address (NMDevice8023Ethernet *device)
 {
-	char *address = NULL;
-	GValue value = {0,};
-
 	g_return_val_if_fail (NM_IS_DEVICE_802_3_ETHERNET (device), NULL);
 
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE_WIRED,
-							  "HwAddress",
-							  &value))
-		address = g_strdup (g_value_get_string (&value));
-
-	return address;
+	return nm_dbus_get_string_property (nm_device_get_properties_proxy (NM_DEVICE (device)),
+										NM_DBUS_INTERFACE_DEVICE_WIRED, "HwAddress");
 }
 
 void
@@ -71,8 +110,9 @@ nm_device_802_3_ethernet_activate (NMDevice8023Ethernet *device, gboolean user_r
 
 	g_return_if_fail (NM_IS_DEVICE_802_3_ETHERNET (device));
 
-	if (!org_freedesktop_NetworkManager_Device_Wired_activate (DBUS_G_PROXY (device),
-															   user_requested, &err)) {
+	if (!org_freedesktop_NetworkManager_Device_Wired_activate
+		(NM_DEVICE_802_3_ETHERNET_GET_PRIVATE (device)->ethernet_proxy, user_requested, &err)) {
+
 		g_warning ("Activation failed: %s", err->message);
 		g_error_free (err);
 	}
diff --git a/libnm-glib/nm-device-private.h b/libnm-glib/nm-device-private.h
index 973077b4c5..f9f2e79007 100644
--- a/libnm-glib/nm-device-private.h
+++ b/libnm-glib/nm-device-private.h
@@ -1,6 +1,12 @@
 #ifndef NM_DEVICE_PRIVATE_H
 #define NM_DEVICE_PRIVATE_H
 
+#include <dbus/dbus-glib.h>
+
+DBusGConnection *nm_device_get_connection       (NMDevice *device);
+const char      *nm_device_get_path             (NMDevice *device);
+DBusGProxy      *nm_device_get_properties_proxy (NMDevice *device);
+
 /* static methods */
 NMDeviceType     nm_device_type_for_path (DBusGConnection *connection,
 										  const char *path);
diff --git a/libnm-glib/nm-device.c b/libnm-glib/nm-device.c
index 40b577408a..879e0fb6ac 100644
--- a/libnm-glib/nm-device.c
+++ b/libnm-glib/nm-device.c
@@ -4,12 +4,18 @@
 
 #include "nm-device-bindings.h"
 
-G_DEFINE_TYPE (NMDevice, nm_device, DBUS_TYPE_G_PROXY)
+G_DEFINE_TYPE (NMDevice, nm_device, G_TYPE_OBJECT)
 
 #define NM_DEVICE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_DEVICE, NMDevicePrivate))
 
 typedef struct {
+	DBusGConnection *connection;
+	char *path;
+	DBusGProxy *device_proxy;
+	DBusGProxy *properties_proxy;
 	NMDeviceState state;
+
+	gboolean disposed;
 } NMDevicePrivate;
 
 enum {
@@ -20,11 +26,25 @@ enum {
 
 static guint signals[LAST_SIGNAL] = { 0 };
 
+
+enum {
+	PROP_0,
+	PROP_CONNECTION,
+	PROP_PATH,
+
+	LAST_PROP
+};
+
+
 static void device_state_change_proxy (DBusGProxy *proxy, guint state, gpointer user_data);
 
 static void
 nm_device_init (NMDevice *device)
 {
+	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (device);
+
+	priv->state = NM_DEVICE_STATE_UNKNOWN;
+	priv->disposed = FALSE;
 }
 
 static GObject*
@@ -33,24 +53,108 @@ constructor (GType type,
 			 GObjectConstructParam *construct_params)
 {
 	GObject *object;
+	NMDevicePrivate *priv;
 
 	object = G_OBJECT_CLASS (nm_device_parent_class)->constructor (type,
 																   n_construct_params,
 																   construct_params);
-
 	if (!object)
 		return NULL;
 
-	dbus_g_proxy_add_signal (DBUS_G_PROXY (object), "StateChanged", G_TYPE_UINT, G_TYPE_INVALID);
-	dbus_g_proxy_connect_signal (DBUS_G_PROXY (object),
-								 "StateChanged",
+	priv = NM_DEVICE_GET_PRIVATE (object);
+
+	if (priv->connection == NULL || priv->path == NULL) {
+		g_warning ("Connection or path not received.");
+		g_object_unref (object);
+		return NULL;
+	}
+
+	priv->device_proxy = dbus_g_proxy_new_for_name (priv->connection,
+													NM_DBUS_SERVICE,
+													priv->path,
+													NM_DBUS_INTERFACE_DEVICE);
+
+	dbus_g_proxy_add_signal (priv->device_proxy, "StateChanged", G_TYPE_UINT, G_TYPE_INVALID);
+	dbus_g_proxy_connect_signal (priv->device_proxy, "StateChanged",
 								 G_CALLBACK (device_state_change_proxy),
-								 object,
-								 NULL);
+								 object, NULL);
+	
+	priv->properties_proxy = dbus_g_proxy_new_for_name (priv->connection,
+														NM_DBUS_SERVICE,
+														priv->path,
+														"org.freedesktop.DBus.Properties");
+
 	return object;
 }
 
 static void
+dispose (GObject *object)
+{
+	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (object);
+
+	if (priv->disposed)
+		return;
+
+	priv->disposed = TRUE;
+
+	g_object_unref (priv->device_proxy);
+	g_object_unref (priv->properties_proxy);
+	dbus_g_connection_unref (priv->connection);
+
+	G_OBJECT_CLASS (nm_device_parent_class)->dispose (object);
+}
+
+static void
+finalize (GObject *object)
+{
+	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (object);
+
+	g_free (priv->path);
+
+	G_OBJECT_CLASS (nm_device_parent_class)->finalize (object);
+}
+
+static void
+set_property (GObject *object, guint prop_id,
+			  const GValue *value, GParamSpec *pspec)
+{
+	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (object);
+
+	switch (prop_id) {
+	case PROP_CONNECTION:
+		/* Construct only */
+		priv->connection = dbus_g_connection_ref ((DBusGConnection *) g_value_get_boxed (value));
+		break;
+	case PROP_PATH:
+		/* Construct only */
+		priv->path = g_strdup (g_value_get_string (value));
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		break;
+	}
+}
+
+static void
+get_property (GObject *object, guint prop_id,
+			  GValue *value, GParamSpec *pspec)
+{
+	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (object);
+
+	switch (prop_id) {
+	case PROP_CONNECTION:
+		g_value_set_boxed (value, priv->connection);
+		break;
+	case PROP_PATH:
+		g_value_set_string (value, priv->path);
+		break;
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		break;
+	}
+}
+
+static void
 nm_device_class_init (NMDeviceClass *device_class)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (device_class);
@@ -59,6 +163,27 @@ nm_device_class_init (NMDeviceClass *device_class)
 
 	/* virtual methods */
 	object_class->constructor = constructor;
+	object_class->set_property = set_property;
+	object_class->get_property = get_property;
+	object_class->dispose = dispose;
+	object_class->finalize = finalize;
+
+	/* porperties */
+	g_object_class_install_property
+		(object_class, PROP_CONNECTION,
+		 g_param_spec_boxed (NM_DEVICE_CONNECTION,
+							 "Connection",
+							 "Connection",
+							 DBUS_TYPE_G_CONNECTION,
+							 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
+
+	g_object_class_install_property
+		(object_class, PROP_PATH,
+		 g_param_spec_string (NM_DEVICE_PATH,
+							  "Object Path",
+							  "DBus Object Path",
+							  NULL,
+							  G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 
 	/* signals */
 	signals[STATE_CHANGED] =
@@ -70,7 +195,6 @@ nm_device_class_init (NMDeviceClass *device_class)
 					  g_cclosure_marshal_VOID__UINT,
 					  G_TYPE_NONE, 1,
 					  G_TYPE_UINT);
-
 }
 
 static void
@@ -89,10 +213,8 @@ NMDevice *
 nm_device_new (DBusGConnection *connection, const char *path)
 {
 	return (NMDevice *) g_object_new (NM_TYPE_DEVICE,
-									  "name", NM_DBUS_SERVICE,
-									  "path", path, 
-									  "interface", NM_DBUS_INTERFACE_DEVICE,
-									  "connection", connection,
+									  NM_DEVICE_CONNECTION, connection,
+									  NM_DEVICE_PATH, path,
 									  NULL);
 }
 
@@ -103,7 +225,7 @@ nm_device_deactivate (NMDevice *device)
 
 	g_return_if_fail (NM_IS_DEVICE (device));
 
-	if (!org_freedesktop_NetworkManager_Device_deactivate (DBUS_G_PROXY (device), &err)) {
+	if (!org_freedesktop_NetworkManager_Device_deactivate (NM_DEVICE_GET_PRIVATE (device)->device_proxy, &err)) {
 		g_warning ("Cannot deactivate device: %s", err->message);
 		g_error_free (err);
 	}
@@ -112,107 +234,64 @@ nm_device_deactivate (NMDevice *device)
 char *
 nm_device_get_iface (NMDevice *device)
 {
-	char *iface = NULL;
-	GValue value = {0,};
-
 	g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
 
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE,
-							  "Interface",
-							  &value))
-		iface = g_strdup (g_value_get_string (&value));
-
-	return iface;
+	return nm_dbus_get_string_property (NM_DEVICE_GET_PRIVATE (device)->properties_proxy,
+										NM_DBUS_INTERFACE_DEVICE, "Interface");
 }
 
 char *
 nm_device_get_udi (NMDevice *device)
 {
-	char *udi = NULL;
-	GValue value = {0,};
-
 	g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
 
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE,
-							  "Udi",
-							  &value))
-		udi = g_strdup (g_value_get_string (&value));
-
-	return udi;
+	return nm_dbus_get_string_property (NM_DEVICE_GET_PRIVATE (device)->properties_proxy,
+										NM_DBUS_INTERFACE_DEVICE, "Udi");
 }
 
 char *
 nm_device_get_driver (NMDevice *device)
 {
-	char *driver = NULL;
-	GValue value = {0,};
-
 	g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
 
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE,
-							  "Driver",
-							  &value))
-		driver = g_strdup (g_value_get_string (&value));
-
-	return driver;
+	return nm_dbus_get_string_property (NM_DEVICE_GET_PRIVATE (device)->properties_proxy,
+										NM_DBUS_INTERFACE_DEVICE, "Driver");
 }
 
 guint32
 nm_device_get_capabilities (NMDevice *device)
 {
-	guint32 caps = 0;
-	GValue value = {0,};
-
 	g_return_val_if_fail (NM_IS_DEVICE (device), 0);
 
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE,
-							  "Capabilities",
-							  &value))
-		caps = g_value_get_uint (&value);
-
-	return caps;
+	return nm_dbus_get_uint_property (NM_DEVICE_GET_PRIVATE (device)->properties_proxy,
+									  NM_DBUS_INTERFACE_DEVICE, "Capabilities");
 }
 
 guint32
 nm_device_get_ip4_address (NMDevice *device)
 {
-	guint32 address = 0;
-	GValue value = {0,};
-
 	g_return_val_if_fail (NM_IS_DEVICE (device), 0);
 
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE,
-							  "Ip4Address",
-							  &value))
-		address = g_value_get_uint (&value);
-
-	return address;
+	return nm_dbus_get_uint_property (NM_DEVICE_GET_PRIVATE (device)->properties_proxy,
+									  NM_DBUS_INTERFACE_DEVICE, "Ip4Address");
 }
 
 NMIP4Config *
 nm_device_get_ip4_config (NMDevice *device)
 {
+	NMDevicePrivate *priv;
+	char *path;
 	NMIP4Config *config = NULL;
-	GValue value = {0,};
 
-	g_return_val_if_fail (NM_IS_DEVICE (device), 0);
-
-	if (nm_dbus_get_property (DBUS_G_PROXY (device),
-							  NM_DBUS_INTERFACE_DEVICE,
-							  "Ip4Config",
-							  &value)) {
-		DBusGConnection *connection = NULL;
-
-		g_assert (G_VALUE_TYPE (&value) == DBUS_TYPE_G_OBJECT_PATH);
-
-		g_object_get (device, "connection", &connection, NULL);
+	g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
 
-		config = nm_ip4_config_new (connection, (const char *) g_value_get_boxed (&value));
+	priv = NM_DEVICE_GET_PRIVATE (device);
+	path = nm_dbus_get_object_path_property (priv->properties_proxy,
+											 NM_DBUS_INTERFACE_DEVICE,
+											 "Ip4Config");
+	if (path) {
+		config = nm_ip4_config_new (priv->connection, path);
+		g_free (path);
 	}
 
 	return config;
@@ -227,19 +306,108 @@ nm_device_get_state (NMDevice *device)
 
 	priv = NM_DEVICE_GET_PRIVATE (device);
 
-	if (priv->state == NM_DEVICE_STATE_UNKNOWN) {
-		GValue value = {0,};
-
-		if (nm_dbus_get_property (DBUS_G_PROXY (device),
-								  NM_DBUS_INTERFACE_DEVICE,
-								  "State",
-								  &value))
-			priv->state = g_value_get_uint (&value);
-	}
+	if (priv->state == NM_DEVICE_STATE_UNKNOWN)
+		priv->state = nm_dbus_get_uint_property (priv->properties_proxy, NM_DBUS_INTERFACE_DEVICE, "State");
 
 	return priv->state;
 }
 
+char *
+nm_device_get_description (NMDevice *device)
+{
+	DBusGProxy *proxy;
+	GError *err = NULL;
+	char *udi;
+	char *physical_device_udi = NULL;
+	char *vendor = NULL;
+	char *product = NULL;
+	char *description = NULL;
+
+	g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
+
+	/* First, get the physical device info */
+
+	udi = nm_device_get_udi (device);
+	proxy = dbus_g_proxy_new_for_name (nm_device_get_connection (device),
+									   "org.freedesktop.Hal",
+									   udi,
+									   "org.freedesktop.Hal.Device");
+	g_free (udi);
+
+	if (!dbus_g_proxy_call (proxy, "GetPropertyString", &err,
+							G_TYPE_STRING, "net.physical_device",
+							G_TYPE_INVALID,
+							G_TYPE_STRING, &physical_device_udi,
+							G_TYPE_INVALID)) {
+		g_warning ("Error getting physical device info from HAL: %s", err->message);
+		g_error_free (err);
+		goto out;
+    }
+	g_object_unref (proxy);
+
+	/* Now get the vendor and product info from the physical device */
+
+	proxy = dbus_g_proxy_new_for_name (nm_device_get_connection (device),
+									   "org.freedesktop.Hal",
+									   physical_device_udi,
+									   "org.freedesktop.Hal.Device");
+
+	if (!dbus_g_proxy_call (proxy, "GetPropertyString", &err,
+							G_TYPE_STRING, "info.vendor",
+							G_TYPE_INVALID,
+							G_TYPE_STRING, &vendor,
+							G_TYPE_INVALID)) {
+		g_warning ("Error getting vendor info from HAL: %s", err->message);
+		g_error_free (err);
+		goto out;
+    }
+
+	if (!dbus_g_proxy_call (proxy, "GetPropertyString", &err,
+							G_TYPE_STRING, "info.product",
+							G_TYPE_INVALID,
+							G_TYPE_STRING, &product,
+							G_TYPE_INVALID)) {
+		g_warning ("Error getting product info from HAL: %s", err->message);
+		g_error_free (err);
+		goto out;
+    }
+
+	description = g_strdup_printf ("%s %s", vendor, product);
+
+ out:
+	g_object_unref (proxy);
+	g_free (physical_device_udi);
+	g_free (vendor);
+	g_free (product);
+
+	return description;
+}
+
+DBusGConnection *
+nm_device_get_connection (NMDevice *device)
+{
+	g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
+
+	return NM_DEVICE_GET_PRIVATE (device)->connection;
+}
+
+const char *
+nm_device_get_path (NMDevice *device)
+{
+	g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
+
+	return NM_DEVICE_GET_PRIVATE (device)->path;
+}
+
+DBusGProxy *
+nm_device_get_properties_proxy (NMDevice *device)
+{
+	g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
+
+	return NM_DEVICE_GET_PRIVATE (device)->properties_proxy;
+}
+
+
 NMDeviceType
 nm_device_type_for_path (DBusGConnection *connection,
 						 const char *path)
diff --git a/libnm-glib/nm-device.h b/libnm-glib/nm-device.h
index d948640ef9..2f731fca33 100644
--- a/libnm-glib/nm-device.h
+++ b/libnm-glib/nm-device.h
@@ -14,12 +14,15 @@
 #define NM_IS_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), NM_TYPE_DEVICE))
 #define NM_DEVICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_DEVICE, NMDeviceClass))
 
+#define NM_DEVICE_CONNECTION "connection"
+#define NM_DEVICE_PATH "path"
+
 typedef struct {
-	DBusGProxy parent;
+	GObject parent;
 } NMDevice;
 
 typedef struct {
-	DBusGProxyClass parent;
+	GObjectClass parent;
 
 	/* Signals */
 	void (*state_changed) (NMDevice *device, NMDeviceState state);
@@ -38,6 +41,7 @@ guint32   nm_device_get_capabilities (NMDevice *device);
 guint32   nm_device_get_ip4_address (NMDevice *device);
 NMIP4Config *nm_device_get_ip4_config (NMDevice *device);
 NMDeviceState nm_device_get_state (NMDevice *device);
+char     *nm_device_get_description (NMDevice *device);
 
 NMDeviceType  nm_device_type_for_path (DBusGConnection *connection,
 									   const char *path);
diff --git a/libnm-glib/nm-ip4-config.c b/libnm-glib/nm-ip4-config.c
index 68f99f6915..95ca59d387 100644
--- a/libnm-glib/nm-ip4-config.c
+++ b/libnm-glib/nm-ip4-config.c
@@ -1,5 +1,4 @@
 #include "nm-ip4-config.h"
-#include "nm-device-private.h"
 #include "nm-utils.h"
 
 
diff --git a/libnm-glib/nm-utils.c b/libnm-glib/nm-utils.c
index 01edf9d475..0802820c27 100644
--- a/libnm-glib/nm-utils.c
+++ b/libnm-glib/nm-utils.c
@@ -1,5 +1,109 @@
 #include "nm-utils.h"
 
+char *
+nm_dbus_get_string_property (DBusGProxy *proxy,
+							 const char *interface,
+							 const char *prop_name)
+{
+	GError *err = NULL;
+	char *str = NULL;
+	GValue value = {0,};
+
+	g_return_val_if_fail (DBUS_IS_G_PROXY (proxy), NULL);
+
+	if (dbus_g_proxy_call (proxy, "Get", &err,
+						   G_TYPE_STRING, interface,
+						   G_TYPE_STRING, prop_name,
+						   G_TYPE_INVALID,
+						   G_TYPE_VALUE, &value,
+						   G_TYPE_INVALID)) {
+		str = g_strdup (g_value_get_string (&value));
+	} else {
+		g_warning ("Error in device_get_property: %s\n", err->message);
+		g_error_free (err);
+	}
+
+	return str;
+}
+
+char *
+nm_dbus_get_object_path_property (DBusGProxy *proxy,
+								  const char *interface,
+								  const char *prop_name)
+{
+	GError *err = NULL;
+	char *path = NULL;
+	GValue value = {0,};
+
+	g_return_val_if_fail (DBUS_IS_G_PROXY (proxy), NULL);
+
+	if (dbus_g_proxy_call (proxy, "Get", &err,
+						   G_TYPE_STRING, interface,
+						   G_TYPE_STRING, prop_name,
+						   G_TYPE_INVALID,
+						   G_TYPE_VALUE, &value,
+						   G_TYPE_INVALID)) {
+		path = g_strdup (g_value_get_boxed (&value));
+	} else {
+		g_warning ("Error in device_get_property: %s\n", err->message);
+		g_error_free (err);
+	}
+
+	return path;
+}
+
+gint32
+nm_dbus_get_int_property (DBusGProxy *proxy,
+						  const char *interface,
+						  const char *prop_name)
+{
+	GError *err = NULL;
+	gint32 i = 0;
+	GValue value = {0,};
+
+	g_return_val_if_fail (DBUS_IS_G_PROXY (proxy), 0);
+
+	if (dbus_g_proxy_call (proxy, "Get", &err,
+						   G_TYPE_STRING, interface,
+						   G_TYPE_STRING, prop_name,
+						   G_TYPE_INVALID,
+						   G_TYPE_VALUE, &value,
+						   G_TYPE_INVALID)) {
+		i = g_value_get_int (&value);
+	} else {
+		g_warning ("Error in device_get_property: %s\n", err->message);
+		g_error_free (err);
+	}
+
+	return i;
+}
+
+guint32
+nm_dbus_get_uint_property (DBusGProxy *proxy,
+						   const char *interface,
+						   const char *prop_name)
+{
+	GError *err = NULL;
+	guint32 i = 0;
+	GValue value = {0,};
+
+	g_return_val_if_fail (DBUS_IS_G_PROXY (proxy), 0);
+
+	if (dbus_g_proxy_call (proxy, "Get", &err,
+						   G_TYPE_STRING, interface,
+						   G_TYPE_STRING, prop_name,
+						   G_TYPE_INVALID,
+						   G_TYPE_VALUE, &value,
+						   G_TYPE_INVALID)) {
+		i = g_value_get_uint (&value);
+	} else {
+		g_warning ("Error in device_get_property: %s\n", err->message);
+		g_error_free (err);
+	}
+
+	return i;
+}
+
 gboolean
 nm_dbus_get_property (DBusGProxy *proxy,
 					  const char *interface,
diff --git a/libnm-glib/nm-utils.h b/libnm-glib/nm-utils.h
index 42ce35a29c..723c23e9a3 100644
--- a/libnm-glib/nm-utils.h
+++ b/libnm-glib/nm-utils.h
@@ -3,6 +3,22 @@
 
 #include <dbus/dbus-glib.h>
 
+char *nm_dbus_get_string_property (DBusGProxy *proxy,
+								   const char *interface,
+								   const char *prop_name);
+
+char *nm_dbus_get_object_path_property (DBusGProxy *proxy,
+										const char *interface,
+										const char *prop_name);
+
+gint32 nm_dbus_get_int_property (DBusGProxy *proxy,
+								 const char *interface,
+								 const char *prop_name);
+
+guint32 nm_dbus_get_uint_property (DBusGProxy *proxy,
+								   const char *interface,
+								   const char *prop_name);
+
 gboolean  nm_dbus_get_property (DBusGProxy *proxy,
 								const char *interface,
 								const char *prop_name,